clean up fragment shader

src/main.cpp

@@ -297,12 +297,12 @@ class SDLGLGLWindow {
         int width, height, nrChannels;
         stbi_set_flip_vertically_on_load(true);
         glGenTextures(2, texture);
-        unsigned char *data = stbi_load("src/assets/blending_transparent_window.png", &width, &height, &nrChannels, 0);
+        unsigned char *data = stbi_load("src/assets/container.jpg", &width, &height, &nrChannels, 0);
 
         if (data) { 
             glBindTexture(GL_TEXTURE_2D, texture[0]);
             glCheckError();
-            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
 
             glGenerateMipmap(GL_TEXTURE_2D);
             glCheckError();
@@ -422,22 +422,23 @@ class SDLGLGLWindow {
         glGenBuffers( 1, &gVBO );
 
         glBindVertexArray(gVAO);
+
         glBindBuffer(GL_ARRAY_BUFFER,  gVBO);
         glBufferData( GL_ARRAY_BUFFER, sizeof cubeVertices, cubeVertices, GL_STATIC_DRAW );
         glCheckError();
 
-        unsigned int gVertexPos2DLocation = shader->get_attrib("LVertexPos2D");
-        unsigned int gtexlocation = shader->get_attrib("aTexCoords");
-        unsigned int normloc = shader->get_attrib( "aNormal" );
+        glCheckError();
 
-        glVertexAttribPointer( gVertexPos2DLocation, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), NULL);
-        glVertexAttribPointer( normloc, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void *)(3 * sizeof (float)));
-        glVertexAttribPointer(gtexlocation, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void *)(6 * sizeof(float)));
+        glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), NULL);
+        glVertexAttribPointer( 1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void *)(3 * sizeof (float)));
+        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void *)(6 * sizeof(float)));
 
         glCheckError();
-        glEnableVertexAttribArray(gtexlocation);
-        glEnableVertexAttribArray(gVertexPos2DLocation);
-        glEnableVertexAttribArray(normloc);
+        glEnableVertexAttribArray(0);
+        glCheckError();
+        glEnableVertexAttribArray(1);
+        glCheckError();
+        glEnableVertexAttribArray(2);
         glCheckError();
 
         /*********** ENDCUBES **************/
@@ -605,35 +606,6 @@ class SDLGLGLWindow {
 
         glCheckError();
 
-        /** draw skybox cubemap  */
-//        glPolygonMode( GL_FRONT_AND_BACK, GL_LINE);
-        glCheckError();
-
-        glDepthMask(GL_FALSE);
-        glCheckError();
-        skyboxShader->use();
-        glCheckError();
-        glCheckError();
-
-        loc = skyboxShader->get_uniform("view");
-        glm::mat4 skybox_view = glm::mat4(glm::mat3(view));
-        glUniformMatrix4fv(loc, 1, GL_FALSE, glm::value_ptr(skybox_view));
-        glCheckError();
-
-        loc = skyboxShader->get_uniform("projection"); 
-        glUniformMatrix4fv(loc, 1, GL_FALSE, glm::value_ptr(projection));
-        glCheckError();
-
-        glBindVertexArray(gVAO);
-        glBindTexture(GL_TEXTURE_CUBE_MAP, cubemap);
-        glCheckError();
-        glDrawArrays(GL_TRIANGLES, 0, 36);
-        glCheckError();
-
-        glDepthMask(GL_TRUE);
-        glCheckError();
-
-        printProgramLog(skyboxShader->program);
         /** Draw guitar backpack **/
         shader->use();
         glCheckError();
@@ -647,13 +619,14 @@ class SDLGLGLWindow {
         glUniformMatrix4fv(loc, 1, GL_FALSE, glm::value_ptr(view));
         glCheckError();
 
+        glBindTexture(GL_TEXTURE_CUBE_MAP, cubemap);
         bp_model->draw(*shader);
         glCheckError();
 
         //*** Draw random cubes ****/
-
-        glBindTexture(GL_TEXTURE_2D, texture[0]);
+        shader->use();
         glBindVertexArray(gVAO);
+        glBindTexture(GL_TEXTURE_2D, texture[0]);
         glCheckError();
 
         std::map<float, glm::vec3> sorted;
@@ -666,6 +639,7 @@ class SDLGLGLWindow {
 
         glCheckError();
         
+        shader->use();
         for(auto it = sorted.rbegin(); it != sorted.rend(); ++it) {
 
             model = glm::mat4(1.0f);
@@ -682,7 +656,10 @@ class SDLGLGLWindow {
             loc = shader->get_uniform("projection"); 
             glUniformMatrix4fv(loc, 1, GL_FALSE, glm::value_ptr(projection));
 
+            glBindTexture(GL_TEXTURE_CUBE_MAP, cubemap);
+        glCheckError();
             glDrawArrays(GL_TRIANGLES, 0, 36);
+        glCheckError();
         }
 
         /*
@@ -706,6 +683,44 @@ class SDLGLGLWindow {
         //
         */
 
+
+
+
+        /** draw skybox cubemap  */
+
+
+        glCheckError();
+        skyboxShader->use();
+        glDepthFunc(GL_LEQUAL);  
+        glCheckError();
+        glCheckError();
+
+        loc = skyboxShader->get_uniform("view");
+        glm::mat4 skybox_view = glm::mat4(glm::mat3(view));
+        glUniformMatrix4fv(loc, 1, GL_FALSE, glm::value_ptr(skybox_view));
+        glCheckError();
+
+        loc = skyboxShader->get_uniform("projection"); 
+        glUniformMatrix4fv(loc, 1, GL_FALSE, glm::value_ptr(projection));
+        glCheckError();
+
+        glBindVertexArray(gVAO);
+        glBindTexture(GL_TEXTURE_CUBE_MAP, cubemap);
+        glCheckError();
+        glDrawArrays(GL_TRIANGLES, 0, 36);
+        glCheckError();
+
+        glCheckError();
+
+        printProgramLog(skyboxShader->program);
+
+
+
+
+
+
+
+
         glCheckError();
 
 

src/mesh.cpp

@@ -58,7 +58,6 @@ void Mesh::draw(Shader &shader) {
         else if(name == "texture_specular")
             number = std::to_string(specularNr++);
 
-        glCheckError();
         glBindTexture(GL_TEXTURE_2D, textures[i].id);
         glCheckError();
     }
@@ -67,7 +66,9 @@ void Mesh::draw(Shader &shader) {
     glCheckError();
     glBindVertexArray(VAO);
     glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
+    glCheckError();
     glBindVertexArray(0);
+    glCheckError();
     glActiveTexture(GL_TEXTURE0);
     glCheckError();
 }

src/shaders/sky.vert

@@ -11,6 +11,7 @@ uniform mat4 projection;
 
 void main()
 {
-    gl_Position = projection * view * vec4( LVertexPos2D, 1.0);
     TexCoords = LVertexPos2D;
+    vec4 pos = projection * view * vec4( LVertexPos2D, 1.0);
+    gl_Position = pos.xyww;
 }

src/shaders/test.frag

@@ -11,7 +11,7 @@ in vec3 FragPos;
 
 //uniform vec3 lightPosition;
 uniform vec3 cameraPosition;
-uniform sampler2D texture_diffuse1;
+uniform samplerCube skybox; 
 
 struct Material {
     sampler2D texture_diffuse1;
@@ -52,7 +52,56 @@ uniform int num_lights;
 uniform Material material;
 
 
-void main() 
+vec4 
+reflection() 
+{
+    vec3 reflectiveness = material.specular * material.shininess / 50;
+    vec3 I = normalize(FragPos - cameraPosition);
+    vec3 R = reflect(I, normalize(Normal));
+    return texture(skybox, R) * (material.shininess / 90);
+}
+
+float
+spotlight(int i, vec3 lightDir) 
+{
+
+    float theta = dot(lightDir, normalize(-lights[i].direction));
+    float epsilon = lights[i].angle_cutoff - lights[i].outer_angle_cutoff;
+    float intensity = clamp((theta - lights[i].outer_angle_cutoff)/epsilon, 0.0, 1.0);
+
+    return intensity;
+}
+
+float 
+attenuation(int i) 
+{
+    float dist = length(lights[i].position - FragPos);
+    float attenuation = 1.0 / (lights[i].attenuation.x + lights[i].attenuation.y *
+    dist + lights[i].attenuation.y * (dist * dist));
+    return attenuation;
+}
+
+vec3
+specular(int i, vec3 lightDir, vec3 norm)
+{
+    float spec = max(dot(normalize(cameraPosition - FragPos), reflect(-lightDir, norm)), 0.0);
+    spec = pow(spec, material.shininess);
+    vec3 specular = lights[i].specular * (spec *
+    vec3(texture(material.texture_specular1, vec2(theTexCoord))));
+    return specular;
+}
+
+vec3
+diffuse(int i, vec3 lightDir, vec3 norm)
+{
+    float diff_val = max(dot(norm, lightDir), 0.0);
+    vec3 diffuse = lights[i].diffuse * (diff_val * material.diffuse);
+    return diffuse;
+}
+
+
+void 
+main() 
 { 
     vec3 endResult = vec3(0);
 
@@ -62,7 +111,6 @@ void main()
 
         // diffuse
         vec3 norm = normalize(Normal);
-
         vec3 lightDir = vec3(0);
         if (lights[i].type == POINT_LIGHT || lights[i].type == SPOT_LIGHT) {
             lightDir = normalize(lights[i].position - FragPos);
@@ -70,43 +118,28 @@ void main()
             lightDir = normalize(-lights[i].direction);
         } 
 
-        float diff_val = max(dot(norm, lightDir), 0.0);
-        vec3 diffuse = lights[i].diffuse * (diff_val * material.diffuse);
+        vec3 diffuse = diffuse(i, lightDir, norm);
 
-        // specular
-        float spec = max(dot(normalize(cameraPosition - FragPos), reflect(-lightDir, norm)), 0.0);
-        spec = pow(spec, material.shininess);
-        vec3 specular = lights[i].specular * (spec *
-        vec3(texture(material.texture_specular1, vec2(theTexCoord))));
+        vec3 specular = specular(i, lightDir, norm);
 
-        vec3 result = vec3(0);
+        vec3 result = ambient;
+        float intensity = 1.0;
 
-        // spotlight
-        if (lights[i].type == POINT_LIGHT || lights[i].type == DIRECTIONAL_LIGHT)
-            result = diffuse + ambient + specular; 
-        else if (lights[i].type == SPOT_LIGHT) {
-            result = ambient;
-
-            float theta = dot(lightDir, normalize(-lights[i].direction));
-            float epsilon = lights[i].angle_cutoff - lights[i].outer_angle_cutoff;
-            float intensity = clamp((theta - lights[i].outer_angle_cutoff)/epsilon, 0.0, 1.0);
-
-            result += (diffuse + specular) * intensity;
+        if (lights[i].type == SPOT_LIGHT) {
+            intensity = spotlight(i, lightDir);
         }
 
-        // attenuation
+        result = ambient + (diffuse + specular) * intensity;
+
         if (lights[i].attenuate) {
-            float dist = length(lights[i].position - FragPos);
-            float attenuation = 1.0 / (lights[i].attenuation.x + lights[i].attenuation.y *
-            dist + lights[i].attenuation.y * (dist * dist));
-            result *= attenuation;
+            result *= attenuation(i);
         }
 
         endResult += result;
-
     }
 
-    LFragment =  (vec4(endResult, 1.0)) * texture(material.texture_diffuse1,
-    vec2(theTexCoord));
+    vec4 parta = (vec4(endResult, 1.0)) * texture(material.texture_diffuse1, vec2(theTexCoord)); 
+    LFragment = parta;
+    
 }