{"id":711,"date":"2021-12-08T21:42:55","date_gmt":"2021-12-08T21:42:55","guid":{"rendered":"https:\/\/writingagame.com\/?p=711"},"modified":"2021-12-08T21:58:15","modified_gmt":"2021-12-08T21:58:15","slug":"chapter-23-ifdef-in-shaders","status":"publish","type":"post","link":"https:\/\/writingagame.com\/index.php\/2021\/12\/08\/chapter-23-ifdef-in-shaders\/","title":{"rendered":"Chapter 23. #ifdef in shaders"},"content":{"rendered":"\n

Right now we have 6 shaders (3 vertex+fragment pairs), which generate 3 shader-programs. Now we need to add textured Phong shader, then we’ll need color or texture over transparency mask for both flat <\/em>and phong <\/em>cases, which will double number of shaders, and so on, and soon it will be hard to manage them all. Besides, in most cases it will be just different combinations of the same code fragments.<\/p>\n\n\n\n

However, turned out that GLSL (shaders language) understands #define<\/strong> and #ifdef<\/strong> instructions, which allows to cover ALL mentioned cases by ONE single shaders pair.<\/p>\n\n\n\n

We can generate #define part programmatically, and then concatenate it with shader’s source code, which will let us generate multiple shader programs for different data sources (such as uColor <\/em>or texture <\/em>or else).<\/p>\n\n\n\n

1. In Windows File Explorer<\/strong> open C:\\CPP\\engine\\dt\\shaders<\/em> folder.<\/p>\n\n\n\n

Delete <\/strong>all 6 files from there<\/p>\n\n\n\n

and replace them by:<\/p>\n\n\n\n

\n\n\n\n

2. Vertex shader<\/strong>:<\/p>\n\n\n\n

Copy following code in a Text Editor<\/strong> and save it as a txt file in<\/p>\n\n\n\n

C:\\CPP\\engine\\dt\\shaders\\phong_v<\/strong>.txt<\/em><\/p>\n\n\n

\n\/\/#version 320 es\nprecision lowp float;\nuniform mat4 uMVP; \/\/ transform matrix (Model-View-Projection)\nuniform mat3 uMV3x3; \/\/ Model-View matrix (for calculating normals into eye space)\n\nin vec3 aPos; \/\/ position attribute (x,y,z)\n#if defined(USE_NORMALS)\n\tin vec3 aNormal; \/\/ normal attribute (x,y,z)\n\tout vec3 vNormal; \/\/ varying normal (to pass to fragment shader)\n#endif\n#if defined(USE_TUV0)\n\tin vec2 aTuv; \/\/attribute TUV (texture coordinates)\n#endif\n#if defined(USE_TEX0)\n\tout vec2 vTuv; \/\/varying TUV (pass to fragment shader)\n#endif\n\nvoid main(void) { \n\tgl_Position = uMVP * vec4(aPos, 1.0);\n#if defined(USE_NORMALS)\t\n\t\/\/ Transform the normal's orientation into eye space. \n\tvNormal = uMV3x3 * aNormal;\n#endif\n#if defined(USE_TUV0)\n\tvTuv = aTuv;\n#endif\n}\n\n<\/pre><\/div>\n\n\n
<\/p>\n\n\n\n
\n\n\n\n
3. Fragment shader<\/strong>:<\/p>\n\n\n\n
Copy following code in a Text Editor<\/strong> and save it as a txt file in<\/p>\n\n\n\n
C:\\CPP\\engine\\dt\\shaders\\phong_f<\/strong>.txt<\/em><\/p>\n\n\n
\n\/\/#version 320 es\nprecision lowp float;\nout vec4 FragColor; \/\/output pixel color\nuniform float uAlphaFactor; \/\/for semi-transparency\n\n#if defined(USE_NORMALS)\n\tin vec3 vNormal; \/\/normal passed from rasterizer\n#endif\n#if defined(USE_TEX0)\n\tuniform sampler2D uTex0;  \/\/texture id\n\tin vec2 vTuv; \/\/varying TUV (passed from vertex shader)\n#else\n\tuniform vec4 uColor;\n#endif\n\n#if defined(PHONG)\n\tuniform float uAmbient;\n\tuniform float uSpecularIntencity;\n\tuniform float uSpecularMinDot;\n\tuniform float uSpecularPowerOf;\n\n\tuniform vec3 uVectorToLight;\n\tuniform vec3 uHalfVector;\n#endif\n\nvoid main(void) {\n\n#if defined(USE_TEX0)\n\tFragColor = texture(uTex0, vTuv);\n#else\n\tFragColor = uColor;\n#endif\n\n#if defined(USE_NORMALS)\n\tvec3 vNormalNormal = normalize(vNormal);\n#endif\n\n#if defined(PHONG)\n\tif(uAmbient<1.0){\n\t\t \/\/ Calculate the dot product of the light vector and vertex normal. If the normal and light vector are\n\t\t \/\/ pointing in the same direction then it will get max illumination.\n\t\t float directionalLightIntencity = dot(vNormalNormal, uVectorToLight);\n\t\t\n\t\t \/\/ count ambient component\n\t\t directionalLightIntencity += uAmbient;\n\t\t if(directionalLightIntencity < uAmbient)\n\t\t\tdirectionalLightIntencity = uAmbient;\n\n\t\t \/\/ Multiply the color by the lightIntencity illumination level to get final output color.\n\t\t FragColor *= directionalLightIntencity;\n\t}\n\tif(uSpecularIntencity>0.0){\n\t\t\/\/specular light\n\t\t\/\/ INTENSITY OF THE SPECULAR LIGHT\n\t\t\/\/ DOT PRODUCT OF NORMAL VECTOR AND THE HALF VECTOR TO THE POWER OF THE SPECULAR HARDNESS\n\t\tfloat dotProduct = dot(vNormalNormal, uHalfVector);\n\n\t\tif(dotProduct>uSpecularMinDot){\n\t\t\tfloat specularIntencity = pow(dotProduct, uSpecularPowerOf) * uSpecularIntencity;\t\t\n\t\t\tif(specularIntencity > uSpecularIntencity)\n\t\t\t\tspecularIntencity = uSpecularIntencity;\n\t\t\tFragColor += specularIntencity;\n\t\t}\n\t}\n#endif\n\tif(uAlphaFactor != 1.0)\n\t\tFragColor.a *= uAlphaFactor;\t\t\n}\n\n<\/pre><\/div>\n\n\n
<\/p>\n\n\n\n
Now we need to load them in the memory, concatenate with #deines<\/strong> string, translate and link into executable shader programs.<\/p>\n\n\n\n
\n\n\n\n
File Loader<\/h2>\n\n\n\n
Reading\/loading files into the memory for subsequent manipulations\/processing is a quite common task. We did it before and will a lot in the future. Makes sense to wrap it in a separate class. We’ll call it FileLoader<\/strong>.<\/p>\n\n\n\n
4. Start VS, open C:\\CPP\\a997modeler<\/em>\\p_windows\\p_windows.sln<\/em><\/p>\n\n\n\n
\n\n\n\n
5. Under xEngine <\/em>add new header file FileLoader.h<\/strong><\/p>\n\n\n\n
Location: C:\\CPP\\engine<\/p>\n\n\n\n
Code:<\/p>\n\n\n
\n#pragma once\n#include <string>\n\nclass FileLoader\n{\npublic:\n\tstd::string fullPath;\n\tstd::string inAppFolder;\n\tchar* pData = NULL;\n\tint dataSize = 0;\npublic:\n\tFileLoader(std::string filePath, std::string readMode="rt");\n\tvirtual ~FileLoader();\n\tstatic int translatePath(FileLoader* pFL, std::string filePath);\n\tstatic int loadFile(FileLoader* pFL, std::string filePath, std::string readMode="rb");\n};\n\n<\/pre><\/div>\n\n\n
<\/p>\n\n\n\n
  • translatePath()<\/em> function will check filePath <\/em>parameter and will concatenate it with filesRoot <\/em>when necessary. Also it will extract inAppFolder <\/em>for future use.<\/li>
  • loadFile()<\/em> will retrieve file’s size, allocate memory and load file into the memory.<\/li><\/ul>\n\n\n\n
    \n\n\n\n
    Implementation<\/strong>:<\/p>\n\n\n\n
    6. Under xEngine <\/em>add new C++ file FileLoader.cpp<\/strong><\/p>\n\n\n\n
    Location: C:\\CPP\\engine<\/em><\/p>\n\n\n\n
    Code:<\/p>\n\n\n
    \n#include "FileLoader.h"\n#include "platform.h"\n\nextern std::string filesRoot;\n\nFileLoader::FileLoader(std::string filePath, std::string readMode) {\n    loadFile(this, filePath, readMode);\n}\nFileLoader::~FileLoader() {\n    if (pData != NULL) {\n        delete[] pData;\n        pData = NULL;\n    }\n}\nint FileLoader::translatePath(FileLoader* pFL, std::string filePath) {\n    if (filePath.find(filesRoot) == 0)\n        pFL->fullPath = filePath;\n    else\n        pFL->fullPath = filesRoot + filePath;\n    int startPos = filesRoot.size();\n    int lastSlashPos = pFL->fullPath.find_last_of('\/');\n    pFL->inAppFolder = pFL->fullPath.substr(startPos, lastSlashPos - startPos + 1);\n    return 1;\n}\nint FileLoader::loadFile(FileLoader* pFL, std::string filePath, std::string readMode) {\n    translatePath(pFL, filePath);\n    FILE* pFile;\n    myFopen_s(&pFile, pFL->fullPath.c_str(), readMode.c_str());\n    if (pFile != NULL)\n    {\n        \/\/ obtain file size:\n        fseek(pFile, 0, SEEK_END);\n        pFL->dataSize = ftell(pFile);\n        rewind(pFile);\n        \/\/ size obtained, create buffer\n        pFL->pData = new char[pFL->dataSize + 1];\n        pFL->dataSize = fread(pFL->pData, 1, pFL->dataSize, pFile);\n        pFL->pData[pFL->dataSize] = 0;\n        fclose(pFile);\n    }\n    else {\n        mylog("ERROR loading %s\\n", pFL->fullPath.c_str());\n        return -1;\n    }\n    return 1;\n}\n\n<\/pre><\/div>\n\n\n
    <\/p>\n\n\n\n
    \n\n\n\n
    When shaders are loaded into the memory, we need to set “defines<\/strong>” part. Now, for shaders compilation we will use strings ARRAY, consisting of 2 strings:<\/p>\n\n\n\n
    • “defines” string, which we will set programmatically<\/li>
    • and shader’s source code, which actually is a “string” too.<\/li><\/ul>\n\n\n\n
      We will do it in Shader <\/strong>class.<\/p>\n\n\n\n
      7. Open Shader.h<\/em> and replace code by:<\/p>\n\n\n
      \n#pragma once\n#include "platform.h"\n#include <string>\n#include <vector>\n\nclass Shader\n{\npublic:\n    \/\/Shader program's individual descriptor:\n    unsigned int GLid = -1; \/\/ GL shader id\n    \/\/common variables, "l_" for "location"\n    \/\/attributes\n    int l_aPos; \/\/attribute position (3D coordinates)\n    int l_aTuv; \/\/attribute TUV (texture coordinates)\n    int l_aTuv2; \/\/attribute TUV (texture coordinates for normal map)\n    int l_aNormal; \/\/attribute normal (3D vector)\n    int l_aTangent; \/\/for normal map\n    int l_aBinormal; \/\/for normal map\n    \/\/uniforms\n    int l_uMVP; \/\/ transform matrix (Model-View-Projection)\n    int l_uMV3x3; \/\/ Model-View matrix for normals\n    int l_uVectorToLight; \/\/required for light\n    int l_uHalfVector; \/\/required for specular light\n    \/\/material's properties\n    int l_uColor;\n    int l_uTex0; \/\/texture id\n    int l_uTex1mask; \/\/transparency map\n    int l_uTex2nm; \/\/normal map\n    int l_uTex3; \/\/texture id\n    int l_uTex1alphaChannelN; \/\/alpha channel for mask\n    int l_uTex1alphaNegative; \/\/alpha channel negative\n    int l_uTex0translateChannelN; \/\/translate tex0 to tex3 by channelN.\n    int l_uAlphaFactor; \/\/for semi-transparency\n    int l_uAlphaBlending; \/\/for semi-transparency\n    \/\/light:\n    int l_uAmbient; \/\/ambient light\n    \/\/specular light parameters\n    int l_uSpecularIntencity;\n    int l_uSpecularMinDot;\n    int l_uSpecularPowerOf;\n    \/\/end of descriptor\n\n    \/\/static array (vector) of all loaded shaders\n    static std::vector<Shader*> shaders;\n    \/\/common shader programs ("spN" - shader program number)\n    static int spN_flat_ucolor;\n    static int spN_flat_tex;\n    static int spN_phong_ucolor;\n    static int spN_phong_tex;\n\npublic:\n    static int loadShaders();\n    static int cleanUp();\n    static unsigned int getGLid(int shN) { return shaders.at(shN)->GLid; };\n    static int shaderErrorCheck(int shaderId, std::string ref);\n    static int programErrorCheck(int programId, std::string ref);\n    static int fillLocations(Shader* pSh);\n\n    static int buildShaderObjectFromFiles(std::string filePathVertexS, std::string filePathFragmentS);\n    static int linkShaderProgramFromFiles(const char* filePathVertexS, const char* filePathFragmentS);\n\tstatic int compileShaderFromFile(const char* filePath, GLenum shaderType);\n\n    static int buildShaderObjectWithDefines(std::string definesString, char* sourceVertex, char* sourceFragment);\n    static int linkShaderProgramWithDefines(std::string definesString, char* sourceVertex, char* sourceFragment);\n    static int compileShaderWithDefines(std::string definesString, char* shaderSource, GLenum shaderType);\n\n};\n\n<\/pre><\/div>\n\n\n
      <\/p>\n\n\n\n
      We have 3 new functions here:<\/p>\n\n\n\n
      • compileShaderWithDefines<\/em>, which accepts “def”-string and 1 shader source code as parameters, and then compiles vertex or fragment shader, which will be linked together in<\/li>
      • linkShaderProgramWithDefines<\/em>, which calls 2 compilations and links 2 compiled shaders into a Shader Program, which will be returned to<\/li>
      • buildShaderObjectWithDefines<\/em>, which gets a “def”-string and 2 source codes as parameters, extends defString, calls linkShaderProgramWithDefines<\/em>, analyses linked shader program, fills out variables locations and saves this info, including GL Program’s ID in a new Shader object.<\/li><\/ul>\n\n\n\n
        \n\n\n\n
        8.  Open Shader.cpp<\/em> and replace code by: <\/p>\n\n\n
        \n#include "Shader.h"\n#include "platform.h"\n#include "utils.h"\n#include "FileLoader.h"\n\nextern std::string filesRoot;\n\n\/\/static array (vector) of all loaded shaders\nstd::vector<Shader*> Shader::shaders;\n\/\/common shader programs ("spN" - shader program number)\nint Shader::spN_flat_ucolor = -1;\nint Shader::spN_flat_tex = -1;\nint Shader::spN_phong_ucolor = -1;\nint Shader::spN_phong_tex = -1;\n\nint Shader::loadShaders() {\n    FileLoader* pFLvertex = new FileLoader("\/dt\/shaders\/phong_v.txt");\n    FileLoader* pFLfragment = new FileLoader("\/dt\/shaders\/phong_f.txt");\n    spN_flat_ucolor = buildShaderObjectWithDefines("#define FLAT\\n#define COLOR\\n", pFLvertex->pData, pFLfragment->pData);\n    spN_flat_tex = buildShaderObjectWithDefines("#define FLAT\\n#define TEXTURE\\n", pFLvertex->pData, pFLfragment->pData);\n    spN_phong_ucolor = buildShaderObjectWithDefines("#define PHONG\\n#define COLOR\\n", pFLvertex->pData, pFLfragment->pData);\n    spN_phong_tex = buildShaderObjectWithDefines("#define PHONG\\n#define TEXTURE\\n", pFLvertex->pData, pFLfragment->pData);\n    delete pFLvertex;\n    delete pFLfragment;\n    return 1;\n}\nint Shader::buildShaderObjectFromFiles(std::string filePathVertexS, std::string filePathFragmentS) {\n    \/\/create shader object\n    Shader* pSh = new Shader();\n    shaders.push_back(pSh);\n    pSh->GLid = linkShaderProgramFromFiles((filesRoot + filePathVertexS).c_str(), (filesRoot + filePathFragmentS).c_str());\n    \/\/common variables. If not presented, = -1;\n    fillLocations(pSh);\n\n    return (shaders.size() - 1);\n}\nint Shader::fillLocations(Shader* pSh) {\n    \/\/common variables. If not presented, = -1;\n    \/\/attributes\n    pSh->l_aPos = glGetAttribLocation(pSh->GLid, "aPos"); \/\/attribute position (3D coordinates)\n    pSh->l_aNormal = glGetAttribLocation(pSh->GLid, "aNormal"); \/\/attribute normal (3D vector)\n    pSh->l_aTangent = glGetAttribLocation(pSh->GLid, "aTangent"); \/\/for normal map\n    pSh->l_aBinormal = glGetAttribLocation(pSh->GLid, "aBinormal"); \/\/for normal map\n    pSh->l_aTuv = glGetAttribLocation(pSh->GLid, "aTuv"); \/\/attribute TUV (texture coordinates)\n    pSh->l_aTuv2 = glGetAttribLocation(pSh->GLid, "aTuv2"); \/\/attribute TUV (texture coordinates)\n    \/\/uniforms\n    pSh->l_uMVP = glGetUniformLocation(pSh->GLid, "uMVP"); \/\/ transform matrix (Model-View-Projection)\n    pSh->l_uMV3x3 = glGetUniformLocation(pSh->GLid, "uMV3x3"); \/\/ Model-View matrix for normals\n    pSh->l_uVectorToLight = glGetUniformLocation(pSh->GLid, "uVectorToLight"); \/\/ \n    pSh->l_uHalfVector = glGetUniformLocation(pSh->GLid, "uHalfVector"); \/\/ required for specular light\n    \/\/material's properties\n    pSh->l_uColor = glGetUniformLocation(pSh->GLid, "uColor");\n    pSh->l_uTex0 = glGetUniformLocation(pSh->GLid, "uTex0"); \/\/texture id\n    pSh->l_uTex1mask = glGetUniformLocation(pSh->GLid, "uTex1mask"); \/\/texture id\n    pSh->l_uTex2nm = glGetUniformLocation(pSh->GLid, "uTex2nm"); \/\/texture id\n    pSh->l_uTex3 = glGetUniformLocation(pSh->GLid, "uTex3"); \/\/texture id\n    pSh->l_uTex1alphaChannelN = glGetUniformLocation(pSh->GLid, "uTex1alphaChannelN");\n    pSh->l_uTex1alphaNegative = glGetUniformLocation(pSh->GLid, "uTex1alphaNegative");\n    pSh->l_uTex0translateChannelN = glGetUniformLocation(pSh->GLid, "uTex0translateChannelN");\n    pSh->l_uAlphaFactor = glGetUniformLocation(pSh->GLid, "uAlphaFactor"); \/\/ for semi-transparency\n    pSh->l_uAlphaBlending = glGetUniformLocation(pSh->GLid, "uAlphaBlending"); \/\/ for semi-transparency\n    pSh->l_uAmbient = glGetUniformLocation(pSh->GLid, "uAmbient"); \/\/ ambient light\n    pSh->l_uSpecularIntencity = glGetUniformLocation(pSh->GLid, "uSpecularIntencity"); \/\/ \n    pSh->l_uSpecularMinDot = glGetUniformLocation(pSh->GLid, "uSpecularMinDot"); \/\/ \n    pSh->l_uSpecularPowerOf = glGetUniformLocation(pSh->GLid, "uSpecularPowerOf"); \/\/ \n    return 1;\n}\nint Shader::cleanUp() {\n    int shadersN = shaders.size();\n    if (shadersN < 1)\n        return -1;\n    glUseProgram(0);\n    for (int i = 0; i < shadersN; i++) {\n        Shader* pSh = shaders.at(i);\n        glDeleteProgram(pSh->GLid);\n        delete pSh;\n    }\n    shaders.clear();\n    return 1;\n}\n\nGLchar infoLog[1024];\nint logLength;\nint Shader::shaderErrorCheck(int shaderId, std::string ref) {\n    \/\/use after glCompileShader()\n    if (checkGLerrors(ref) > 0)\n        return -1;\n    glGetShaderInfoLog(shaderId, 1024, &logLength, infoLog);\n    if (logLength == 0)\n        return 0;\n    mylog("%s shader infoLog:\\n%s\\n", ref.c_str(), infoLog);\n    return -1;\n}\nint Shader::programErrorCheck(int programId, std::string ref) {\n    \/\/use after glLinkProgram()\n    if (checkGLerrors(ref) > 0)\n        return -1;\n    glGetProgramInfoLog(programId, 1024, &logLength, infoLog);\n    if (logLength == 0)\n        return 0;\n    mylog("%s program infoLog:\\n%s\\n", ref.c_str(), infoLog);\n    return -1;\n}\n\nint Shader::compileShaderFromFile(const char* filePath, GLenum shaderType) {\n    int shaderId = glCreateShader(shaderType);\n    FILE* pFile;\n    myFopen_s(&pFile, filePath, "rt");\n    if (pFile != NULL)\n    {\n        \/\/ obtain file size:\n        fseek(pFile, 0, SEEK_END);\n        int fSize = ftell(pFile);\n        rewind(pFile);\n        \/\/ size obtained, create buffer\n        char* shaderSource = new char[fSize + 1];\n        fSize = fread(shaderSource, 1, fSize, pFile);\n        shaderSource[fSize] = 0;\n        fclose(pFile);\n        \/\/ source code loaded, compile\n        glShaderSource(shaderId, 1, (const GLchar**)&shaderSource, NULL);\n        \/\/myglErrorCheck("glShaderSource");\n        glCompileShader(shaderId);\n        if (shaderErrorCheck(shaderId, "glCompileShader") < 0)\n            return -1;\n        delete[] shaderSource;\n    }\n    else {\n        mylog("ERROR loading %s\\n", filePath);\n        return -1;\n    }\n    return shaderId;\n}\nint Shader::linkShaderProgramFromFiles(const char* filePathVertexS, const char* filePathFragmentS) {\n    int vertexShaderId = compileShaderFromFile(filePathVertexS, GL_VERTEX_SHADER);\n    int fragmentShaderId = compileShaderFromFile(filePathFragmentS, GL_FRAGMENT_SHADER);\n    int programId = glCreateProgram();\n    glAttachShader(programId, vertexShaderId);\n    glAttachShader(programId, fragmentShaderId);\n    glLinkProgram(programId);\n    if (programErrorCheck(programId, "glLinkProgram") < 0)\n        return -1;\n    \/\/don't need shaders any longer - detach and delete them\n    glDetachShader(programId, vertexShaderId);\n    glDetachShader(programId, fragmentShaderId);\n    glDeleteShader(vertexShaderId);\n    glDeleteShader(fragmentShaderId);\n    return programId;\n}\n\nint Shader::buildShaderObjectWithDefines(std::string definesString, char* sourceVertex, char* sourceFragment) {\n    \/\/create shader object\n    Shader* pSh = new Shader();\n    shaders.push_back(pSh);\n\n    pSh->GLid = linkShaderProgramWithDefines(definesString, sourceVertex, sourceFragment);\n    \/\/common variables. If not presented, = -1;\n    fillLocations(pSh);\n\n    return (shaders.size() - 1);\n}\nint Shader::linkShaderProgramWithDefines(std::string definesString00, char* sourceVertex, char* sourceFragment) {\n    \/\/build extended definesString\n    bool bUSE_NORMALS = false;\n    bool bUSE_TEX0 = false;\n    bool bUSE_TUV0 = false;\n    if (definesString00.find(" PHONG\\n") != std::string::npos)\n        bUSE_NORMALS = true;\n    if (definesString00.find(" TEXTURE\\n") != std::string::npos) {\n        bUSE_TEX0 = true;\n        bUSE_TUV0 = true;\n    }\n    if (definesString00.find(" MIRROR\\n") != std::string::npos) {\n        bUSE_NORMALS = true;\n        bUSE_TEX0 = true;\n    }\n    if (definesString00.find(" OVERMASK\\n") != std::string::npos) {\n        bUSE_TUV0 = true;\n    }\n    std::string definesString;\n    definesString.assign("#version 320 es\\n");\n    definesString.append(definesString00);\n    if (bUSE_NORMALS)\n        definesString.append("#define USE_NORMALS\\n");\n    if (bUSE_TEX0)\n        definesString.append("#define USE_TEX0\\n");\n    if (bUSE_TUV0)\n        definesString.append("#define USE_TUV0\\n");\n\n    int vertexShaderId = compileShaderWithDefines(definesString, sourceVertex, GL_VERTEX_SHADER);\n    int fragmentShaderId = compileShaderWithDefines(definesString, sourceFragment, GL_FRAGMENT_SHADER);\n\n    int programId = glCreateProgram();\n    glAttachShader(programId, vertexShaderId);\n    glAttachShader(programId, fragmentShaderId);\n    glLinkProgram(programId);\n    if (programErrorCheck(programId, "glLinkProgram") < 0)\n        return -1;\n    \/\/don't need shaders any longer - detach and delete them\n    glDetachShader(programId, vertexShaderId);\n    glDetachShader(programId, fragmentShaderId);\n    glDeleteShader(vertexShaderId);\n    glDeleteShader(fragmentShaderId);\n    \/\/mylog("linking program\\n%s\\n", definesString.c_str());\n    return programId;\n}\nint Shader::compileShaderWithDefines(std::string definesString, char* shaderSource, GLenum shaderType) {\n    int shaderId = glCreateShader(shaderType);\n    if (definesString.empty())\n        glShaderSource(shaderId, 1, (const GLchar**)&shaderSource, NULL);\n    else { \/\/2 strings\n        const char* sourceStrings[2];\n        sourceStrings[0] = definesString.c_str();\n        sourceStrings[1] = shaderSource;\n        \/\/ source code loaded, compile\n        glShaderSource(shaderId, 2, (const GLchar**)sourceStrings, NULL);\n    }\n    \/\/myglErrorCheck("glShaderSource");\n    glCompileShader(shaderId);\n    if (shaderErrorCheck(shaderId, "glCompileShader") < 0) {\n        mylog("ERROR in compileShader,\\n%s\\n%s\\n", definesString.c_str(), shaderSource);\n        return -1;\n    }\n    return shaderId;\n}\n\n<\/pre><\/div>\n\n\n
        <\/p>\n\n\n\n
        • Now Shader::loadShaders()<\/em> has a different format. Plus now we are building not 3, but 4 shaders, including new Phong textured shader.<\/li><\/ul>\n\n\n\n
          \n\n\n\n
          Now in  TheGame.cpp<\/em> we can set Phong <\/strong>shader for textured surface. Don’t have to flip it upside down any more.<\/p>\n\n\n\n
          9. Open  TheGame.cpp<\/em> and replace code by:<\/p>\n\n\n
          \n#include "TheGame.h"\n#include "platform.h"\n#include "utils.h"\n#include "linmath.h"\n#include "Texture.h"\n#include "Shader.h"\n#include "DrawJob.h"\n#include "ModelBuilder.h"\n#include "TexCoords.h"\n\nextern std::string filesRoot;\nextern float degrees2radians;\n\nstd::vector<GameSubj*> TheGame::gameSubjs;\n\nint TheGame::getReady() {\n    bExitGame = false;\n    Shader::loadShaders();\n    glEnable(GL_CULL_FACE);\n\n    \/\/=== create box ========================\n    GameSubj* pGS = new GameSubj();\n    gameSubjs.push_back(pGS);\n\n    pGS->name.assign("box1");\n    pGS->ownCoords.setPosition(0, 0, 0);\n    pGS->ownCoords.setDegrees(0, 0, 0);\n    pGS->ownSpeed.setDegrees(0,1,0);\n\n    ModelBuilder* pMB = new ModelBuilder();\n    pMB->useSubjN(gameSubjs.size() - 1);\n\n    \/\/define VirtualShape\n    VirtualShape vs;\n    vs.setShapeType("box-tank");\n    vs.whl[0] = 60;\n    vs.whl[1] = 160;\n    vs.whl[2] = 390;\n    vs.setExt(20);\n    vs.extD = 0;\n    vs.extF = 0; \/\/to make front face "flat"\n    vs.sectionsR = 2;\n\n    Material mt;\n    \/\/define material - flat red\n    mt.shaderN = Shader::spN_phong_ucolor;\n    mt.primitiveType = GL_TRIANGLES;\n    mt.uColor.setRGBA(255, 0, 0,255); \/\/red\n    pMB->useMaterial(&mt);\n\n    pMB->buildBoxFace(pMB,"front v", &vs);\n    pMB->buildBoxFace(pMB, "back v", &vs);\n    pMB->buildBoxFace(pMB, "top", &vs);\n    pMB->buildBoxFace(pMB, "bottom", &vs);\n    pMB->buildBoxFace(pMB, "left all", &vs);\n\n    mt.uColor.clear(); \/\/ set to zero;\n    mt.uTex0 = Texture::loadTexture(filesRoot + "\/dt\/sample_img.png");\n    mt.shaderN = Shader::spN_phong_tex;\n    pMB->useMaterial(&mt);\n    TexCoords tc;\n    tc.set(mt.uTex0, 11, 12, 256, 128, "h"); \/\/flip horizontally\n    pMB->buildBoxFace(pMB, "right all", &vs, &tc);\n\n    pMB->buildDrawJobs(gameSubjs);\n\n    delete pMB;\n\n    \/\/===== set up camera\n    mainCamera.ownCoords.setDegrees(15, 180, 0); \/\/set camera angles\/orientation\n    mainCamera.viewRangeDg = 30;\n    mainCamera.stageSize[0] = 500;\n    mainCamera.stageSize[1] = 375;\n    memcpy(mainCamera.lookAtPoint, pGS->ownCoords.pos, sizeof(float) * 3);\n    mainCamera.onScreenResize();\n\n    \/\/===== set up light\n    v3set(dirToMainLight, -1, 1, 1);\n    vec3_norm(dirToMainLight, dirToMainLight);\n\n    return 1;\n}\nint TheGame::drawFrame() {\n    myPollEvents();\n\n    \/\/glClearColor(0.0, 0.0, 0.5, 1.0);\n    glClear(GL_COLOR_BUFFER_BIT);\n\n    \/\/calculate halfVector\n    float dirToCamera[4] = { 0,0,-1,0 }; \/\/-z\n    mat4x4_mul_vec4plus(dirToCamera, *mainCamera.ownCoords.getRotationMatrix(), dirToCamera, 0);\n\n    float uHalfVector[4] = { 0,0,0,0 };\n    for (int i = 0; i < 3; i++)\n        uHalfVector[i] = (dirToCamera[i] + dirToMainLight[i]) \/ 2;\n    vec3_norm(uHalfVector, uHalfVector);\n\n    mat4x4 mProjection, mViewProjection, mMVP, mMV4x4;\n    \/\/mat4x4_ortho(mProjection, -(float)screenSize[0] \/ 2, (float)screenSize[0] \/ 2, -(float)screenSize[1] \/ 2, (float)screenSize[1] \/ 2, 100.f, 500.f);\n    float nearClip = mainCamera.focusDistance - 250;\n    float farClip = mainCamera.focusDistance + 250;\n    mat4x4_perspective(mProjection, mainCamera.viewRangeDg * degrees2radians, screenAspectRatio, nearClip, farClip);\n    mat4x4_mul(mViewProjection, mProjection, mainCamera.lookAtMatrix);\n    \/\/mViewProjection[1][3] = 0; \/\/keystone effect\n\n    \/\/scan subjects\n    int subjsN = gameSubjs.size();\n    for (int subjN = 0; subjN < subjsN; subjN++) {\n        GameSubj* pGS = gameSubjs.at(subjN);\n        \/\/behavior - apply rotation speed\n        pGS->moveSubj();\n        \/\/prepare subject for rendering\n        pGS->buildModelMatrix(pGS);\n        \/\/build MVP matrix for given subject\n        mat4x4_mul(mMVP, mViewProjection, pGS->ownModelMatrix);\n        \/\/build Model-View (rotation) matrix for normals\n        mat4x4_mul(mMV4x4, mainCamera.lookAtMatrix, (vec4*)pGS->ownCoords.getRotationMatrix());\n        \/\/convert to 3x3 matrix\n        float mMV3x3[3][3];\n        for (int y = 0; y < 3; y++)\n            for (int x = 0; x < 3; x++)\n                mMV3x3[y][x] = mMV4x4[y][x];\n        \/\/render subject\n        for (int i = 0; i < pGS->djTotalN; i++) {\n            DrawJob* pDJ = DrawJob::drawJobs.at(pGS->djStartN + i);\n            pDJ->execute((float*)mMVP, *mMV3x3, dirToMainLight, uHalfVector, NULL);\n        }\n    }\n    mySwapBuffers();\n    return 1;\n}\n\nint TheGame::cleanUp() {\n    int itemsN = gameSubjs.size();\n    \/\/delete all UISubjs\n    for (int i = 0; i < itemsN; i++) {\n        GameSubj* pGS = gameSubjs.at(i);\n        delete pGS;\n    }\n    gameSubjs.clear();\n    \/\/clear all other classes\n    Texture::cleanUp();\n    Shader::cleanUp();\n    DrawJob::cleanUp();\n    return 1;\n}\nint TheGame::onScreenResize(int width, int height) {\n    if (screenSize[0] == width && screenSize[1] == height)\n        return 0;\n    screenSize[0] = width;\n    screenSize[1] = height;\n    screenAspectRatio = (float)width \/ height;\n    glViewport(0, 0, width, height);\n    mainCamera.onScreenResize();\n    mylog(" screen size %d x %d\\n", width, height);\n    return 1;\n}\nint TheGame::run() {\n    getReady();\n    while (!bExitGame) {\n        drawFrame();\n    }\n    cleanUp();\n    return 1;\n}\n\n<\/pre><\/div>\n\n\n
          <\/p>\n\n\n\n
          \n\n\n\n
          10. Build and run.<\/p>\n\n\n\n
          Before<\/strong>:<\/p>\n\n\n\n
          <\/p>\n\n\n\n
          <\/p>\n\n\n\n
          After<\/em>:<\/p>\n\n\n\n
          <\/p>\n\n\n\n
          <\/p>\n\n\n\n