Help

#################################################################
INITIALIZATION
#################################################################

//note that some values have already been initialized, things that do not require
//opengl context or call opengl functions were initialized in the constructor, such as glm matrices
//and vectors
void GLWidget::initializeGL()
{
        if(glewInit() != GLEW_OK)
        cout << "Failure Initializing GLEW\n";

    //4.0.0 Build 10.18.10.3308
    cout << "openGL Version: " << glGetString(GL_VERSION) << endl;
    cout << "GLSL Version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << endl;
    program = makeProgram("shaders\\vert.glsl", "shaders\\frag.glsl", NULL);

    glUseProgram(program);
        checkError("glUseProgram");
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);

    glEnable(GL_CULL_FACE);
    glCullFace(GL_BACK);
    glFrontFace(GL_CCW);
    glClearColor(0, 0.05, 0.2, 1);

    pLoc = glGetUniformLocation(program, "P");
    mvLoc = glGetUniformLocation(program, "MV");
    nmlLoc = glGetUniformLocation(program, "NML");
    eyeLoc = glGetUniformLocation(program, "eye");
    lightLoc = glGetUniformLocation(program, "lPos");

    glUniformMatrix4fv(mvLoc, 1, false, value_ptr(view));
    glUniformMatrix4fv(pLoc, 1, false, value_ptr(projection));
    glUniformMatrix3fv(nmlLoc, 1, false, value_ptr(normal));
    checkError();
    glUniform3fv(eyeLoc, 1, value_ptr(eye));
    glUniform3fv(lightLoc, 1, value_ptr(lPos));

    //model.loadObj("data\\beethovan_bust.obj");
    model.loadObj("data\\box.obj");
    model.loadBuffers(program);
    model.loadTextures(program);

}

#################################################################
DRAWING
#################################################################

void GLWidget::paintGL()
{
    glUseProgram(program);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
    model.render();
    checkError();
}

void Model::render()
{
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, albedo);

        glActiveTexture(GL_TEXTURE1);
        glBindTexture(GL_TEXTURE_2D, normal);

        glActiveTexture(GL_TEXTURE2);
        glBindTexture(GL_TEXTURE_2D, height);

        glBindVertexArray(vao);
        glDrawElements(GL_TRIANGLES, 3 * numTris, GL_UNSIGNED_INT, 0);
        glBindVertexArray(0);
}

#################################################################
LOADING TEXTURES
#################################################################

void Model::loadTextures(GLint program)
{
    albedo = SOIL_load_OGL_texture("map\\color_map.jpg",
                                        SOIL_LOAD_RGB, SOIL_CREATE_NEW_ID,
                                        SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_MIPMAPS);

    normal = SOIL_load_OGL_texture("map\\normal_map.jpg",
                                        SOIL_LOAD_RGB, SOIL_CREATE_NEW_ID,
                                        SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_MIPMAPS);

    height = SOIL_load_OGL_texture("map\\height_map.jpg",
                                        SOIL_LOAD_RGB, SOIL_CREATE_NEW_ID,
                                        SOIL_FLAG_POWER_OF_TWO | SOIL_FLAG_MIPMAPS);

        GLint aLoc = glGetUniformLocation(program, "albedo_map");
        GLint nLoc = glGetUniformLocation(program, "normal_map");
        GLint hLoc = glGetUniformLocation(program, "height_map");

        glUseProgram(program);
        glUniform1i(aLoc, 0);
        glUniform1i(nLoc, 1);
        glUniform1i(hLoc, 2);
}

#################################################################
GENERATING AND BINDING BUFFERS, AND ATTRIBUTES
#################################################################

void Model::loadBuffers(GLint program)
{
    int vertSize = sizeof(Vertex);
    int triSize = sizeof(Triangle);
    int vecSize = sizeof(vec3);

    glGenVertexArrays(1, &vao);
        glBindVertexArray(vao);

    glGenBuffers(1, &vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, vertSize * numVerts, verts, GL_STATIC_DRAW);

    glGenBuffers(1, &ibo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, triSize * numTris, tris, GL_STATIC_DRAW);

    GLint attrib;

    attrib = glGetAttribLocation(program, "position");
    glVertexAttribPointer(attrib, 3, GL_FLOAT, false, vertSize, (GLvoid*)0);
    glEnableVertexAttribArray(attrib);

    attrib = glGetAttribLocation(program, "normal");
    glVertexAttribPointer(attrib, 3, GL_FLOAT, false, vertSize, (GLvoid*)vecSize);
    glEnableVertexAttribArray(attrib);

    attrib = glGetAttribLocation(program, "vTexCoord");
    glVertexAttribPointer(attrib, 3, GL_FLOAT, false, vertSize, (GLvoid*)(4*vecSize));
    glEnableVertexAttribArray(attrib);

    attrib = glGetAttribLocation(program, "tangent");
    glVertexAttribPointer(attrib, 3, GL_FLOAT, false, vertSize, (GLvoid*)(2*vecSize));
    glEnableVertexAttribArray(attrib);

    //clear the bindings to avoid state modification.
    glBindVertexArray(0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
}

#################################################################
COMPILING SHADERS AND LINKING PROGRAM
#################################################################

//g is for geometry shader, and it isn't used
GLuint makeProgram(char *v, char *f, char *g)
{
    int p = glCreateProgram();
    int fs, vs;
    char *v_string = readTextFile(v);
    char *f_string = readTextFile(f);

    vs = glCreateShader(GL_VERTEX_SHADER);
    const GLchar *vc = v_string;
    glShaderSource(vs, 1, &vc, NULL);
    glCompileShader(vs);
    printShaderLog(vs); //"Failed to compile vertex shader.");
    glAttachShader(p, vs);

    fs = glCreateShader(GL_FRAGMENT_SHADER);
    const GLchar *fc = f_string;
    glShaderSource(fs, 1, &fc, NULL);
    glCompileShader(fs); // "Failed to compile fragment shader.");
    printShaderLog(fs);
    glAttachShader(p, fs);

    GLint success = GL_FALSE;
    GLint len, written;
    glLinkProgram(p);
    glGetProgramiv(p, GL_LINK_STATUS, &success);
    if(success == GL_FALSE)
        cout << "Program Failed to Link\n";
    glGetProgramiv(p, GL_INFO_LOG_LENGTH, &len);
    if(len > 0)
    {
        GLchar error[len];
        glGetProgramInfoLog(p, len, &written, error);
        cout << error << endl;
    }
    glUseProgram(p);
    return p;
}
#################################################################
VERTEX SHADER
#################################################################

#version 130
uniform vec3 lPos;
uniform vec3 eye;
uniform mat4 MV;
uniform mat4 P;
uniform mat3 NML;

out vec2 texCoord;
out vec3 vDir;
out vec3 lDir;

in vec3 position;
in vec2 vTexCoord;
in vec3 normal;
in vec3 tangent;

void main()
{
   vec4 pos = MV * vec4(position,1);
   texCoord = vTexCoord;
   gl_Position = P * pos;

   vec3 V  = -pos.xyz;
   vec3 L = lPos - pos.xyz;

   vec3 binormal = cross(normal, tangent);

   vDir.x  = dot(tangent, V);
   vDir.y  = dot(binormal, V);
   vDir.z  = dot(normal, V);

   lDir.x  = dot(tangent, L);
   lDir.y  = dot(binormal, L);
   lDir.z  = dot(normal, L);
}

#################################################################
FRAGMENT SHADER
#################################################################

uniform sampler2D normal_map;
uniform sampler2D albedo_map;
uniform sampler2D height_map;

in vec2 texCoord;
in vec3 vDir;
in vec3 lDir;

float S = 25.0;
vec4 Kd = vec4(1,1,1,1);
vec4 Ks = vec4(1,1,1,1);
vec4 Ka = vec4(1,1,1,1);

void main( void )
{
   float scale = 0.05;
   float bias = -0.03;
   vec3  V = normalize(vDir);
   float height = texture(height_map, texCoord).x;
   height = height * scale + bias;
   vec2 tex2 = texCoord + height * V.xy;
   vec3  L = normalize(lDir);
   vec3  N = normalize((texture(normal_map, tex2).xyz * 2.0) - 1.0);
   float NDotL = dot(N, L);

   vec3  R = normalize(((2.0 * N) * NDotL) - L);
   float RDotV = NDotL * max(0.0, dot(R, V));

   vec4 col = texture( albedo_map, tex2);
   vec4 color = col * NDotL * Kd + col * Ka + Ks * pow(RDotV, S);
   gl_FragColor = (color);
}