Review shader and add comments

examples/resources/shaders/glsl330/phong.fs

@@ -4,73 +4,79 @@
 in vec2 fragTexCoord;
 in vec3 fragNormal;
 
-// Diffuse data
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
-// Light attributes
+// Output fragment color
-uniform vec3 light_ambientColor = vec3(0.6, 0.3, 0.0);
+out vec4 finalColor;
-uniform vec3 light_diffuseColor = vec3(1.0, 0.5, 0.0);
-uniform vec3 light_specularColor = vec3(0.0, 1.0, 0.0);
-uniform float light_intensity = 1.0;
-uniform float light_specIntensity = 1.0;
 
-// Material attributes
+// NOTE: Add here your custom variables
-uniform vec3 mat_ambientColor = vec3(1.0, 1.0, 1.0);
-uniform vec3 mat_specularColor = vec3(1.0, 1.0, 1.0);
-uniform float mat_glossiness = 50.0;
 
-// World attributes
+// Light uniform values
-uniform vec3 lightPos;
+uniform vec3 lightAmbientColor = vec3(0.6, 0.3, 0.0);
-uniform vec3 cameraPos;
+uniform vec3 lightDiffuseColor = vec3(1.0, 0.5, 0.0);
+uniform vec3 lightSpecularColor = vec3(0.0, 1.0, 0.0);
+uniform float lightIntensity = 1.0;
+uniform float lightSpecIntensity = 1.0;
 
-// Fragment shader output data
+// Material uniform values
-out vec4 fragColor;
+uniform vec3 matAmbientColor = vec3(1.0, 1.0, 1.0);
+uniform vec3 matSpecularColor = vec3(1.0, 1.0, 1.0);
+uniform float matGlossiness = 50.0;
 
+// World uniform values
+uniform vec3 lightPosition;
+uniform vec3 cameraPosition;
+
+// Calculate ambient lighting component
 vec3 AmbientLighting()
 {
-   return (mat_ambientColor*light_ambientColor);
+    return (matAmbientColor*lightAmbientColor);
 }
 
+// Calculate diffuse lighting component
 vec3 DiffuseLighting(in vec3 N, in vec3 L)
 {
-   // Lambertian reflection calculation
+    // Lambertian reflection calculation
-   float diffuse = clamp(dot(N, L), 0, 1);
+    float diffuse = clamp(dot(N, L), 0, 1);
-   
+
-   return (fragTintColor.xyz*light_diffuseColor*light_intensity*diffuse);
+    return (fragTintColor.xyz*lightDiffuseColor*lightIntensity*diffuse);
 }
 
+// Calculate specular lighting component
 vec3 SpecularLighting(in vec3 N, in vec3 L, in vec3 V)
 {
-   float specular = 0.0;
+    float specular = 0.0;
 
-   // Calculate specular reflection only if the surface is oriented to the light source
+    // Calculate specular reflection only if the surface is oriented to the light source
-   if (dot(N, L) > 0)
+    if (dot(N, L) > 0)
-   {
+    {
-      // Calculate half vector
+        // Calculate half vector
-      vec3 H = normalize(L + V);
+        vec3 H = normalize(L + V);
-      
+
-      // Calculate specular intensity
+        // Calculate specular intensity
-      specular = pow(dot(N, H), 3 + mat_glossiness);
+        specular = pow(dot(N, H), 3 + matGlossiness);
-   }
+    }
    
-   return (mat_specularColor*light_specularColor*light_specIntensity*specular);
+    return (matSpecularColor*lightSpecularColor*lightSpecIntensity*specular);
 }
 
 void main()
 {
     // Normalize input vectors
-    vec3 L = normalize(lightPos);
+    vec3 L = normalize(lightPosition);
-    vec3 V = normalize(cameraPos);
+    vec3 V = normalize(cameraPosition);
     vec3 N = normalize(fragNormal);
     
+    // Calculate lighting components 
     vec3 ambient = AmbientLighting();
     vec3 diffuse = DiffuseLighting(N, L);
     vec3 specular = SpecularLighting(N, L, V);
     
-    // Get base color from texture
+    // Texel color fetching from texture sampler
-    vec4 textureColor = texture(texture0, fragTexCoord);
+    vec4 texelColor = texture(texture0, fragTexCoord);
-    vec3 finalColor = textureColor.rgb;
+
-    
+    // Calculate final fragment color
-    fragColor = vec4(finalColor * (ambient + diffuse + specular), textureColor.a);
+    finalColor = vec4(texelColor.rgb*(ambient + diffuse + specular), texelColor.a);
 }

examples/shaders_basic_lighting.c

@@ -41,23 +41,23 @@ int main()
     // Model initialization
     Vector3 position = { 0.0f, 0.0f, 0.0f };
     Model model = LoadModel("resources/model/dwarf.obj");
-    Shader shader = LoadShader("resources/shaders/phong.vs", "resources/shaders/phong.fs");
+    Shader shader = LoadShader("resources/shaders/glsl330/phong.vs", "resources/shaders/glsl330/phong.fs");
     SetModelShader(&model, shader);
     
     // Shader locations initialization
-    int lIntensityLoc = GetShaderLocation(shader, "light_intensity");
+    int lIntensityLoc = GetShaderLocation(shader, "lightIntensity");
-    int lAmbientLoc = GetShaderLocation(shader, "light_ambientColor");
+    int lAmbientLoc = GetShaderLocation(shader, "lightAmbientColor");
-    int lDiffuseLoc = GetShaderLocation(shader, "light_diffuseColor");
+    int lDiffuseLoc = GetShaderLocation(shader, "lightDiffuseColor");
-    int lSpecularLoc = GetShaderLocation(shader, "light_specularColor");
+    int lSpecularLoc = GetShaderLocation(shader, "lightSpecularColor");
-    int lSpecIntensityLoc = GetShaderLocation(shader, "light_specIntensity");
+    int lSpecIntensityLoc = GetShaderLocation(shader, "lightSpecIntensity");
     
-    int mAmbientLoc = GetShaderLocation(shader, "mat_ambientColor");
+    int mAmbientLoc = GetShaderLocation(shader, "matAmbientColor");
-    int mSpecularLoc = GetShaderLocation(shader, "mat_specularColor");
+    int mSpecularLoc = GetShaderLocation(shader, "matSpecularColor");
-    int mGlossLoc = GetShaderLocation(shader, "mat_glossiness");
+    int mGlossLoc = GetShaderLocation(shader, "matGlossiness");
     
     // Camera and light vectors shader locations
-    int cameraLoc = GetShaderLocation(shader, "cameraPos");
+    int cameraLoc = GetShaderLocation(shader, "cameraPosition");
-    int lightLoc = GetShaderLocation(shader, "lightPos");
+    int lightLoc = GetShaderLocation(shader, "lightPosition");
     
     // Model and View matrix locations (required for lighting)
     int modelLoc = GetShaderLocation(shader, "modelMatrix");