How is the w component of the geometric coordinates computed in the example of perspective correction?

How is the w component of the geometric coordinates computed in the example of perspective correction?

Perspective-correction-interpolation demo
static float vertexClipCoords1[] =
{
25.0, 25.0, 150.0, 150.0,
-25.0, 25.0, 150.0, 150.0,
25.0, 25.0, -50.0, 50.0
};

GitHub - kingchenbin/Perspective-correction-interpolation: Demo using OpenGL4.2 which shows perspective correction intepolation with a typical texture mapping

#version 420

//vertex attribs
in vec4 model_postion;
in vec2 tex_coord_in;

//uniform variables
uniform mat4 modelViewMatrix;
uniform mat4 projectionMatrix;

//vs output
out vec4 eye_coord;
out vec4 clip_coord;
out vec2 tex_coord;
noperspective out vec2 tex_coord_NoCorrection;
flat out vec2 tex_coord_Flat;

void main(void) 
{
    tex_coord = tex_coord_in;
    tex_coord_NoCorrection = tex_coord_in;
    tex_coord_Flat = tex_coord_in;
    eye_coord = modelViewMatrix * model_postion;
    clip_coord = projectionMatrix * eye_coord;
    gl_Position = clip_coord;
}
#version 420

//ps input
in vec4 eye_coord;
in vec4 clip_coord;
in vec2 tex_coord;
noperspective in vec2 tex_coord_NoCorrection;
flat in vec2 tex_coord_Flat;

//uniform variables
uniform sampler2D tex;
uniform vec2 vertexWindowCoords[3];
uniform vec4 vertexClipCoords[3];
uniform vec2 vertexTexCoords[3];
uniform int interpolateMode;

//ps output
out vec4 color;

float calcLength(vec2 start, vec2 end)
{
    return sqrt(pow(start.x-end.x, 2) + pow(start.y-end.y,2));
}

float calcSquare(vec2 A, vec2 B, vec2 C)
{
    float lenA, lenB, lenC, p;
    lenA = calcLength(B, C);
    lenB = calcLength(A, C);
    lenC = calcLength(A, B);
    p = (lenA+lenB+lenC)/2.0;
    return sqrt(p*(p-lenA)*(p-lenB)*(p-lenC));
}

void main(void) 
{
    if (interpolateMode == 2)
    {
        color = texture(tex, tex_coord_NoCorrection);
    }
    else if (interpolateMode == 3 || interpolateMode == 4)
    {
        float a,b,c;
        float squareA,squareB,squareC,square;

        square = calcSquare(vertexWindowCoords[0], vertexWindowCoords[1], vertexWindowCoords[2]);
        squareA = calcSquare(gl_FragCoord.xy, vertexWindowCoords[1], vertexWindowCoords[2]);
        squareB = calcSquare(gl_FragCoord.xy, vertexWindowCoords[0], vertexWindowCoords[2]);
        squareC = calcSquare(gl_FragCoord.xy, vertexWindowCoords[0], vertexWindowCoords[1]);

        a = squareA/square;
        b = squareB/square;
        c = squareC/square;
        
        if (interpolateMode == 3)
        {
            vec2 texCoordCorrection;
            texCoordCorrection = a * vertexTexCoords[0] / vertexClipCoords[0].w + b * vertexTexCoords[1] / vertexClipCoords[1].w + c * vertexTexCoords[2] / vertexClipCoords[2].w;
            texCoordCorrection = texCoordCorrection / (a / vertexClipCoords[0].w + b / vertexClipCoords[1].w + c / vertexClipCoords[2].w);
            color = texture(tex, texCoordCorrection);
        }
        else
        {
            vec2 texCoordNoCorrection;
            texCoordNoCorrection = a * vertexTexCoords[0] + b * vertexTexCoords[1] + c * vertexTexCoords[2];
            color = texture(tex, tex_coord_NoCorrection);
        }
    }
    else
    {
        color = texture(tex, tex_coord);
    }
}
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <io.h>
#define GLEW_STATIC 1
#include <GL/glew.h>
#include <GL/glu.h>
#include <GL/glut.h>

#pragma comment(lib,"glew32s.lib")

//Shader类型
typedef enum {
    EVertexShader,
    EFragmentShader,
} EShaderType;

//窗口句柄
static GLint window;

GLuint prog = 0;                        //程序对象
GLuint progNoPersectiveCorrect  = 0;    //程序对象

//InterpolateMode
//1:no qualifier(perspective)
//2:noPerspective
//3:simulate perspective
//4:simulate noPerspective
GLuint InterpolateMode = 1;

static float vertexData[] =
{
    -50.0, -50.0, - 50.0, 1.0, 0.0, 0.0,
     50.0, -50.0, - 50.0, 1.0, 1.0, 0.0,
     50.0,  50.0, -150.0, 1.0, 1.0, 1.0,

     50.0,  50.0, -150.0, 1.0, 1.0, 1.0,
    -50.0,  50.0, -150.0, 1.0, 0.0, 1.0,
    -50.0, -50.0, - 50.0, 1.0, 0.0, 0.0
};

static float modelViewMat[] =
{
    1.0, 0.0, 0.0, 0.0,
    0.0, 1.0, 0.0, 0.0,
    0.0, 0.0, 1.0, 0.0,
    0.0, 0.0, 0.0, 1.0
};

//void Frustum( -100.0, 100.0, -100.0, 100.0, 50.0, 150.0);
static float projectionMat[] =
{
    0.5, 0.0, 0.0, 0.0,
    0.0, 0.5, 0.0, 0.0,
    0.0, 0.0, -2.0, -150.0,
    0.0, 0.0, -1.0, 0.0
};

static float vertexWindowCoords[] =
{
    200.5, 200.5,
    600.5, 200.5,
    466.5, 466.5
};

static float vertexClipCoords[] =
{
    -25.0, -25.0, -50.0,  50.0,
     25.0, -25.0, -50.0,  50.0,
     25.0,  25.0, 150.0, 150.0
};

static float vertexTexCoords[] =
{
    0.0, 0.0,
    1.0, 0.0,
    1.0, 1.0
};

static float vertexWindowCoords1[] =
{
    466.5, 466.5,
    333.5, 466.5,
    200.5, 200.5
};

static float vertexClipCoords1[] =
{
     25.0,  25.0, 150.0, 150.0,
    -25.0,  25.0, 150.0, 150.0,
     25.0,  25.0, -50.0,  50.0
};

static float vertexTexCoords1[] =
{
    1.0, 1.0,
    0.0, 1.0,
    0.0, 0.0
};

//用来检查OpenGL版本,需要GLSL 2.0支持
void getGlVersion( int *major, int *minor )
{
    const char* verstr = (const char*)glGetString( GL_VERSION );
    if( (verstr == NULL) || (sscanf( verstr, "%d.%d", major, minor ) != 2) )
    {
        *major = *minor = 0;
        fprintf( stderr, "Invalid GL_VERSION format!!!\n" );
    }
}

static void display(void)
{
    GLuint loc;

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // Set up attrib values
    loc = glGetAttribLocation(progNoPersectiveCorrect, "model_postion");
    glVertexAttribPointer(loc, 4, GL_FLOAT, GL_FALSE, 24, (GLvoid *)0);
    glEnableVertexAttribArray(loc);
    loc = glGetAttribLocation(progNoPersectiveCorrect, "tex_coord_in");
    glVertexAttribPointer(loc, 2, GL_FLOAT, GL_FALSE, 24, (GLvoid *)16);
    glEnableVertexAttribArray(loc);

    // Set up initial uniform values
    glUniformMatrix4fv(glGetUniformLocation(progNoPersectiveCorrect, "modelViewMatrix"), 1, GL_TRUE, modelViewMat);
    glUniformMatrix4fv(glGetUniformLocation(progNoPersectiveCorrect, "projectionMatrix"), 1, GL_TRUE, projectionMat);
    glUniform1i(glGetUniformLocation(progNoPersectiveCorrect, "tex"), 0);
    glUniform2fv(glGetUniformLocation(progNoPersectiveCorrect, "vertexWindowCoords"), 3, vertexWindowCoords);
    glUniform4fv(glGetUniformLocation(progNoPersectiveCorrect, "vertexClipCoords"), 3, vertexClipCoords);
    glUniform2fv(glGetUniformLocation(progNoPersectiveCorrect, "vertexTexCoords"), 3, vertexTexCoords);
    glUniform1i(glGetUniformLocation(progNoPersectiveCorrect, "interpolateMode"), (int)InterpolateMode);

    glDrawArrays(GL_TRIANGLES, 0, 3);

    // Set up attrib values
    loc = glGetAttribLocation(progNoPersectiveCorrect, "model_postion");
    glVertexAttribPointer(loc, 4, GL_FLOAT, GL_FALSE, 24, (GLvoid *)72);
    glEnableVertexAttribArray(loc);
    loc = glGetAttribLocation(progNoPersectiveCorrect, "tex_coord_in");
    glVertexAttribPointer(loc, 2, GL_FLOAT, GL_FALSE, 24, (GLvoid *)88);
    glEnableVertexAttribArray(loc);

    // Set up initial uniform values
    glUniform2fv(glGetUniformLocation(progNoPersectiveCorrect, "vertexWindowCoords"), 3, vertexWindowCoords1);
    glUniform4fv(glGetUniformLocation(progNoPersectiveCorrect, "vertexClipCoords"), 3, vertexClipCoords1);
    glUniform2fv(glGetUniformLocation(progNoPersectiveCorrect, "vertexTexCoords"), 3, vertexTexCoords1);

    glDrawArrays(GL_TRIANGLES, 0, 3);

    glFlush();
    glutSwapBuffers();
}

static void reshape(int wid, int ht)
{
    return;
}


//Shader related functions
static int shaderSize(char *fileName, EShaderType shaderType)
{
    //返回顶点着色器或者片段着色器的大小
    char name[100];
    strcpy(name, fileName);

    switch (shaderType)
    {
    case EVertexShader:
        strcat(name, ".vert");
        break;
    case EFragmentShader:
        strcat(name, ".frag");
        break;
    default:
        printf("ERROR: unknown shader file type\n");
        exit(1);
        break;
    }

    int count = -1;
    // Open the file, seek to the end to find its length
    int fd = _open(name, _O_RDONLY);
    if (fd != -1)
    {
        count = _lseek(fd, 0, SEEK_END) + 1;
        _close(fd);
    }
    return count;
}


static int readShader(char *fileName, EShaderType shaderType, char *shaderText, int size)
{
    //
    // Reads a shader from the supplied file and returns the shader in the
    // arrays passed in. Returns 1 if successful, 0 if an error occurred.
    // The parameter size is an upper limit of the amount of bytes to read.
    // It is ok for it to be too big.
    //
    FILE *fh;
    char name[100];
    int count;

    strcpy(name, fileName);

    switch (shaderType) 
    {
    case EVertexShader:
        strcat(name, ".vert");
        break;
    case EFragmentShader:
        strcat(name, ".frag");
        break;
    default:
        printf("ERROR: unknown shader file type\n");
        exit(1);
        break;
    }

    // Open the file
    fh = fopen(name, "r");
    if (!fh)
        return -1;

    // Get the shader from a file.
    fseek(fh, 0, SEEK_SET);
    count = (int) fread(shaderText, 1, size, fh);
    shaderText[count] = '\0';

    if (ferror(fh))
        count = 0;

    fclose(fh);
    return count;
}


/*public*/
int readShaderSource(char *fileName, GLchar **vertexShader, GLchar **fragmentShader)
{
    int vSize, fSize;

    //
    // Allocate memory to hold the source of our shaders.
    //
    vSize = shaderSize(fileName, EVertexShader);
    fSize = shaderSize(fileName, EFragmentShader);

    if ((vSize == -1) || (fSize == -1))
    {
        printf("Cannot determine size of the shader %s\n", fileName);
        return 0;
    }

    *vertexShader = (GLchar *) malloc(vSize);
    *fragmentShader = (GLchar *) malloc(fSize);

    //
    // Read the source code
    //
    if (!readShader(fileName, EVertexShader, *vertexShader, vSize))
    {
        printf("Cannot read the file %s.vert\n", fileName);
        return 0;
    }

    if (!readShader(fileName, EFragmentShader, *fragmentShader, fSize))
    {
        printf("Cannot read the file %s.frag\n", fileName);
        return 0;
    }

    return 1;
}


/*public*/
int installShaders(const GLchar *Vertex,
                   const GLchar *Fragment,
                   GLuint *Program)
{
    GLuint VertexShaderObject   = 0;    //顶点着色器对象
    GLuint FragmentShaderObject = 0;    //片段着色器对象
    GLint vertCompiled, fragCompiled;   //status values
    GLint linked;

    // Create a vertex shader object and a fragment shader object

    VertexShaderObject = glCreateShader(GL_VERTEX_SHADER);
    FragmentShaderObject = glCreateShader(GL_FRAGMENT_SHADER);

    // Load source code strings into shaders

    glShaderSource(VertexShaderObject, 1, &Vertex, NULL);
    glShaderSource(FragmentShaderObject, 1, &Fragment, NULL);

    // Compile the brick vertex shader, and print out
    // the compiler log file.

    glCompileShader(VertexShaderObject);
    glGetShaderiv(VertexShaderObject, GL_COMPILE_STATUS, &vertCompiled);

    // Compile the brick vertex shader, and print out
    // the compiler log file.

    glCompileShader(FragmentShaderObject);
    glGetShaderiv(FragmentShaderObject, GL_COMPILE_STATUS, &fragCompiled);

    char fragLog[1024];
    glGetShaderInfoLog(FragmentShaderObject, 1024, NULL, fragLog);

    if (!vertCompiled || !fragCompiled)
        return 0;

    // Create a program object and attach the two compiled shaders

    *Program = glCreateProgram();
    glAttachShader(*Program, VertexShaderObject);
    glAttachShader(*Program, FragmentShaderObject);

    // Link the program object and print out the info log

    glLinkProgram(*Program);
    glGetProgramiv(*Program, GL_LINK_STATUS, &linked);

    if (!linked)
        return 0;

    return 1;
}

bool init()
{
    GLchar *VertexShaderSource, *FragmentShaderSource;
    bool success = true;
    GLuint vb = 0, tex = 0;
    GLint loc = 0;

    glGenBuffers(1, &vb);
    glBindBuffer(GL_ARRAY_BUFFER, vb);
    glBufferData(GL_ARRAY_BUFFER, 144, vertexData, GL_STATIC_DRAW);

    glGenTextures(1, &tex);
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, tex);

    int texSize = 1024;
    int blockSize = 64;
    int rowPitch = texSize * 4;
    unsigned char* texData = new unsigned char[texSize*texSize*4];
    for (int i = 0; i < texSize/blockSize; ++i)
    {
        for (int j = 0; j < texSize/blockSize; ++j)
        {
            int startX = i*blockSize;
            int startY = j*blockSize;
            bool white = (bool)(i%2 ^ j%2);

            for (int m = startX; m < startX + blockSize; ++m)
            {
                for (int n = startY; n < startY + blockSize; ++n)
                {
                    texData[n * rowPitch + m * 4 + 0] = white ? 255 : 0;
                    texData[n * rowPitch + m * 4 + 1] = white ? 255 : 0;
                    texData[n * rowPitch + m * 4 + 2] = white ? 255 : 0;
                    texData[n * rowPitch + m * 4 + 3] = 255;
                }
            }
        }
    }

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, texSize, texSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, texData);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_R,GL_CLAMP_TO_EDGE);

    /*
    readShaderSource("perspective", &VertexShaderSource, &FragmentShaderSource);
    success = (bool)installShaders(VertexShaderSource, FragmentShaderSource, &prog);
    if (!success) goto Exit;

    // Install program object as part of current state
    glUseProgram(prog);

    // Set up attrib values
    loc = glGetAttribLocation(prog, "model_postion");
    glVertexAttribPointer(loc, 4, GL_FLOAT, GL_FALSE, 24, (GLvoid *)0);
    glEnableVertexAttribArray(loc);
    loc = glGetAttribLocation(prog, "tex_coord_in");
    glVertexAttribPointer(loc, 2, GL_FLOAT, GL_FALSE, 24, (GLvoid *)16);
    glEnableVertexAttribArray(loc);

    // Set up initial uniform values
    glUniformMatrix4fv(glGetUniformLocation(prog, "modelViewMatrix"), 1, GL_TRUE, modelViewMat);
    glUniformMatrix4fv(glGetUniformLocation(prog, "projectionMatrix"), 1, GL_TRUE, projectionMat);
    glUniform1i(glGetUniformLocation(prog, "tex"), 0);
    */

    readShaderSource("noPersectiveCorrect", &VertexShaderSource, &FragmentShaderSource);
    success = (bool)installShaders(VertexShaderSource, FragmentShaderSource, &progNoPersectiveCorrect);
    if (!success) goto Exit;

    // Install program object as part of current state
    glUseProgram(progNoPersectiveCorrect);

    glViewport(0,0,800,800);
    glClearColor(0.2,0.2,0.2,1.0);
    glClearDepth(0.0);
    glDisable(GL_DEPTH_TEST);

Exit:
    return success;
}

void keyboard(unsigned char key, int x, int y)
{
    switch (key) {
      case '1':
          InterpolateMode = 1;
          glUniform1i(glGetUniformLocation(progNoPersectiveCorrect, "interpolateMode"), (int)InterpolateMode);
          glutPostRedisplay();
          break;
      case '2':
          InterpolateMode = 2;
          glUniform1i(glGetUniformLocation(progNoPersectiveCorrect, "interpolateMode"), (int)InterpolateMode);
          glutPostRedisplay();
          break;
      case '3':
          InterpolateMode = 3;
          glUniform1i(glGetUniformLocation(progNoPersectiveCorrect, "interpolateMode"), (int)InterpolateMode);
          glutPostRedisplay();
          break;
      case '4':
          InterpolateMode = 4;
          glUniform1i(glGetUniformLocation(progNoPersectiveCorrect, "interpolateMode"), (int)InterpolateMode);
          glutPostRedisplay();
          break;
      case 'q':
          exit(0);
          break;
      default:
          break;
    }
}

/******************************************************************************/
/*
/* Main
/*
/******************************************************************************/
int main( int argc, char **argv )
{
    int success = 0;
    int gl_major, gl_minor;

    glutInit( &argc, argv );
    glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
    glutInitWindowSize(800, 800);
    window = glutCreateWindow( "Perspective Correction");

    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutKeyboardFunc(keyboard);

    // Initialize the "OpenGL Extension Wrangler" library
    glewInit();

    // Make sure that OpenGL 2.0 is supported by the driver
    getGlVersion(&gl_major, &gl_minor);
    printf("GL_VERSION major=%d minor=%d\n", gl_major, gl_minor);

    if (gl_major < 2)
    {
        printf("GL_VERSION major=%d minor=%d\n", gl_major, gl_minor);
        printf("Support for OpenGL 2.0 is required for this demo...exiting\n");
        exit(1);
    }

    success = init();

    if (success)
        glutMainLoop();

    return 0;
}