Updated shaders with comments

34 files changed, 295 insertions, 159 deletions

diff --git a/examples/resources/shaders/glsl100/bloom.fs b/examples/resources/shaders/glsl100/bloom.fs
index 5a08843d..280d2fb6 100644
--- a/examples/resources/shaders/glsl100/bloom.fs
+++ b/examples/resources/shaders/glsl100/bloom.fs
@@ -33,5 +33,5 @@ void main()
     else if (texelColor.r < 0.5) tc = sum*sum*0.009 + texelColor;
     else tc = sum*sum*0.0075 + texelColor;
     
-    finalColor = tc;
+    gl_FragColor = tc;
 }
\ No newline at end of file
diff --git a/examples/resources/shaders/glsl100/swirl.fs b/examples/resources/shaders/glsl100/swirl.fs
index e77d4f87..0d6d24f2 100644
--- a/examples/resources/shaders/glsl100/swirl.fs
+++ b/examples/resources/shaders/glsl100/swirl.fs
@@ -20,7 +20,7 @@ float angle = 0.8;
 
 uniform vec2 center = vec2(200.0, 200.0);
 
-void main (void)
+void main()
 {
     vec2 texSize = vec2(renderWidth, renderHeight);
     vec2 tc = fragTexCoord*texSize;
diff --git a/examples/resources/shaders/glsl330/bloom.fs b/examples/resources/shaders/glsl330/bloom.fs
index 47ddee30..0307bc06 100644
--- a/examples/resources/shaders/glsl330/bloom.fs
+++ b/examples/resources/shaders/glsl330/bloom.fs
@@ -17,7 +17,7 @@ void main()
 {
     vec4 sum = vec4(0);
     vec4 tc = vec4(0);
-    
+
     for (int i = -4; i < 4; i++)
     {
         for (int j = -3; j < 3; j++)
diff --git a/examples/resources/shaders/glsl330/phong.fs b/examples/resources/shaders/glsl330/phong.fs
index 80e3d673..c14b346a 100644
--- a/examples/resources/shaders/glsl330/phong.fs
+++ b/examples/resources/shaders/glsl330/phong.fs
@@ -29,6 +29,9 @@ uniform float matGlossiness = 50.0;
 uniform vec3 lightPosition;
 uniform vec3 cameraPosition;
 
+// Fragment shader output data
+out vec4 fragColor;
+
 // Calculate ambient lighting component
 vec3 AmbientLighting()
 {
diff --git a/examples/resources/shaders/glsl330/swirl.fs b/examples/resources/shaders/glsl330/swirl.fs
index da098754..80c16cc9 100644
--- a/examples/resources/shaders/glsl330/swirl.fs
+++ b/examples/resources/shaders/glsl330/swirl.fs
@@ -21,7 +21,7 @@ float angle = 0.8;
 
 uniform vec2 center = vec2(200.0, 200.0);
 
-void main (void)
+void main()
 {
     vec2 texSize = vec2(renderWidth, renderHeight);
     vec2 tc = fragTexCoord*texSize;
diff --git a/shaders/glsl100/base.vs b/shaders/glsl100/base.vs
index 9f339382..e9386939 100644
--- a/shaders/glsl100/base.vs
+++ b/shaders/glsl100/base.vs
@@ -1,20 +1,26 @@
 #version 100
 
+// Input vertex attributes
 attribute vec3 vertexPosition;
 attribute vec2 vertexTexCoord;
 attribute vec3 vertexNormal;
+attribute vec4 vertexColor;
 
-varying vec2 fragTexCoord;
-
+// Input uniform values
 uniform mat4 mvpMatrix;
 
+// Output vertex attributes (to fragment shader)
+varying vec2 fragTexCoord;
+varying vec4 fragColor;
+
 // NOTE: Add here your custom variables 
 
 void main()
 {
-    vec3 normal = vertexNormal;
-    
+    // Send vertex attributes to fragment shader
     fragTexCoord = vertexTexCoord;
+    fragColor = vertexColor;
     
+    // Calculate final vertex position
     gl_Position = mvpMatrix*vec4(vertexPosition, 1.0);
 }
\ No newline at end of file
diff --git a/shaders/glsl100/bloom.fs b/shaders/glsl100/bloom.fs
index 33754c7e..280d2fb6 100644
--- a/shaders/glsl100/bloom.fs
+++ b/shaders/glsl100/bloom.fs
@@ -2,8 +2,11 @@
 
 precision mediump float;
 
+// Input vertex attributes (from vertex shader)
 varying vec2 fragTexCoord;
+varying vec4 fragColor;
 
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
@@ -22,21 +25,13 @@ void main()
         }
     }
     
-    if (texture2D(texture0, fragTexCoord).r < 0.3)
-    {
-        tc = sum*sum*0.012 + texture2D(texture0, fragTexCoord);
-    }
-    else
-    {
-        if (texture2D(texture0, fragTexCoord).r < 0.5)
-        {
-            tc = sum*sum*0.009 + texture2D(texture0, fragTexCoord);
-        }
-        else
-        {
-            tc = sum*sum*0.0075 + texture2D(texture0, fragTexCoord);
-        }
-    }
+    // Texel color fetching from texture sampler
+    vec4 texelColor = texture(texture0, fragTexCoord);
+    
+    // Calculate final fragment color
+    if (texelColor.r < 0.3) tc = sum*sum*0.012 + texelColor;
+    else if (texelColor.r < 0.5) tc = sum*sum*0.009 + texelColor;
+    else tc = sum*sum*0.0075 + texelColor;
     
     gl_FragColor = tc;
 }
\ No newline at end of file
diff --git a/shaders/glsl100/blur.fs b/shaders/glsl100/blur.fs
index a1069c6f..80d40834 100644
--- a/shaders/glsl100/blur.fs
+++ b/shaders/glsl100/blur.fs
@@ -2,7 +2,11 @@
 
 precision mediump float;
 
+// Input vertex attributes (from vertex shader)
 varying vec2 fragTexCoord;
+varying vec4 fragColor;
+
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
@@ -16,6 +20,7 @@ float weight[3] = float[]( 0.2270270270, 0.3162162162, 0.0702702703 );
 
 void main() 
 { 
+    // Texel color fetching from texture sampler
     vec3 tc = texture2D(texture0, fragTexCoord).rgb*weight[0];
 
     for (int i = 1; i < 3; i++) 
diff --git a/shaders/glsl100/cross_hatching.fs b/shaders/glsl100/cross_hatching.fs
index cf01b65e..1f7dab08 100644
--- a/shaders/glsl100/cross_hatching.fs
+++ b/shaders/glsl100/cross_hatching.fs
@@ -2,12 +2,15 @@
 
 precision mediump float;
 
+// Input vertex attributes (from vertex shader)
 varying vec2 fragTexCoord;
+varying vec4 fragColor;
 
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
-// NOTE: Add here your custom variables 
+// NOTE: Add here your custom variables
 
 float hatchOffsetY = 5.0f;
 float lumThreshold01 = 0.9f;
diff --git a/shaders/glsl100/cross_stitching.fs b/shaders/glsl100/cross_stitching.fs
index f1afef04..6fabc027 100644
--- a/shaders/glsl100/cross_stitching.fs
+++ b/shaders/glsl100/cross_stitching.fs
@@ -2,8 +2,11 @@
 
 precision mediump float;
 
+// Input vertex attributes (from vertex shader)
 varying vec2 fragTexCoord;
+varying vec4 fragColor;
 
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
@@ -46,7 +49,7 @@ vec4 PostFX(sampler2D tex, vec2 uv)
     return c;
 }
 
-void main(void)
+void main()
 {
     vec3 tc = PostFX(texture0, fragTexCoord).rgb;
 
diff --git a/shaders/glsl100/dream_vision.fs b/shaders/glsl100/dream_vision.fs
index bb828970..d0cdc687 100644
--- a/shaders/glsl100/dream_vision.fs
+++ b/shaders/glsl100/dream_vision.fs
@@ -2,8 +2,11 @@
 
 precision mediump float;
 
+// Input vertex attributes (from vertex shader)
 varying vec2 fragTexCoord;
+varying vec4 fragColor;
 
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
diff --git a/shaders/glsl100/fisheye.fs b/shaders/glsl100/fisheye.fs
index e7a4485c..9dba297b 100644
--- a/shaders/glsl100/fisheye.fs
+++ b/shaders/glsl100/fisheye.fs
@@ -2,12 +2,15 @@
 
 precision mediump float;
 
+// Input vertex attributes (from vertex shader)
 varying vec2 fragTexCoord;
+varying vec4 fragColor;
 
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
-// NOTE: Add here your custom variables 
+// NOTE: Add here your custom variables
 
 const float PI = 3.1415926535;
 
diff --git a/shaders/glsl100/grayscale.fs b/shaders/glsl100/grayscale.fs
index e55545e2..f92ec335 100644
--- a/shaders/glsl100/grayscale.fs
+++ b/shaders/glsl100/grayscale.fs
@@ -2,8 +2,11 @@
 
 precision mediump float;
 
+// Input vertex attributes (from vertex shader)
 varying vec2 fragTexCoord;
+varying vec4 fragColor;
 
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
@@ -11,10 +14,12 @@ uniform vec4 fragTintColor;
 
 void main()
 {
-    vec4 base = texture2D(texture0, fragTexCoord)*fragTintColor;
+    // Texel color fetching from texture sampler
+    vec4 texelColor = texture(texture0, fragTexCoord)*fragTintColor*fragColor;
     
-    // Convert to grayscale using NTSC conversion weights
-    float gray = dot(base.rgb, vec3(0.299, 0.587, 0.114));
+    // Convert texel color to grayscale using NTSC conversion weights
+    float gray = dot(texelColor.rgb, vec3(0.299, 0.587, 0.114));
     
-    gl_FragColor = vec4(gray, gray, gray, fragTintColor.a);
+    // Calculate final fragment color
+    gl_FragColor = vec4(gray, gray, gray, texelColor.a);
 }
\ No newline at end of file
diff --git a/shaders/glsl100/pixel.fs b/shaders/glsl100/pixel.fs
index 552e8900..c532f219 100644
--- a/shaders/glsl100/pixel.fs
+++ b/shaders/glsl100/pixel.fs
@@ -2,8 +2,11 @@
 
 precision mediump float;
 
+// Input vertex attributes (from vertex shader)
 varying vec2 fragTexCoord;
+varying vec4 fragColor;
 
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
diff --git a/shaders/glsl100/posterization.fs b/shaders/glsl100/posterization.fs
index 4f4c4b93..801ca89c 100644
--- a/shaders/glsl100/posterization.fs
+++ b/shaders/glsl100/posterization.fs
@@ -2,8 +2,11 @@
 
 precision mediump float;
 
+// Input vertex attributes (from vertex shader)
 varying vec2 fragTexCoord;
+varying vec4 fragColor;
 
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
diff --git a/shaders/glsl100/predator.fs b/shaders/glsl100/predator.fs
index 2fbdc7af..1f0e2ce5 100644
--- a/shaders/glsl100/predator.fs
+++ b/shaders/glsl100/predator.fs
@@ -2,8 +2,11 @@
 
 precision mediump float;
 
+// Input vertex attributes (from vertex shader)
 varying vec2 fragTexCoord;
+varying vec4 fragColor;
 
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
diff --git a/shaders/glsl100/scanlines.fs b/shaders/glsl100/scanlines.fs
index 85de158d..d885e10b 100644
--- a/shaders/glsl100/scanlines.fs
+++ b/shaders/glsl100/scanlines.fs
@@ -2,8 +2,11 @@
 
 precision mediump float;
 
+// Input vertex attributes (from vertex shader)
 varying vec2 fragTexCoord;
+varying vec4 fragColor;
 
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
@@ -14,7 +17,7 @@ float frequency = 720/3.0;
 
 uniform float time;
 
-void main (void)
+void main()
 {
 /*
     // Scanlines method 1
diff --git a/shaders/glsl100/swirl.fs b/shaders/glsl100/swirl.fs
index b0d54b23..0d6d24f2 100644
--- a/shaders/glsl100/swirl.fs
+++ b/shaders/glsl100/swirl.fs
@@ -2,28 +2,32 @@
 
 precision mediump float;
 
+// Input vertex attributes (from vertex shader)
 varying vec2 fragTexCoord;
+varying vec4 fragColor;
 
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
 // NOTE: Add here your custom variables
 
-const float renderWidth = 1280; 
-const float renderHeight = 720; 
+const float renderWidth = 800.0;      // HARDCODED for example!
+const float renderHeight = 480.0;     // Use uniforms instead...
 
 float radius = 250.0;
 float angle = 0.8;
 
-uniform vec2 center = vec2(200, 200);
+uniform vec2 center = vec2(200.0, 200.0);
 
-void main (void)
+void main()
 {
     vec2 texSize = vec2(renderWidth, renderHeight);
     vec2 tc = fragTexCoord*texSize;
     tc -= center;
-    float dist = length(tc);
     
+    float dist = length(tc);
+
     if (dist < radius) 
     {
         float percent = (radius - dist)/radius;
@@ -33,7 +37,7 @@ void main (void)
         
         tc = vec2(dot(tc, vec2(c, -s)), dot(tc, vec2(s, c)));
     }
-    
+
     tc += center;
     vec3 color = texture2D(texture0, tc/texSize).rgb;
 
diff --git a/shaders/glsl100/template.fs b/shaders/glsl100/template.fs
index 1f4b8ccf..a3942890 100644
--- a/shaders/glsl100/template.fs
+++ b/shaders/glsl100/template.fs
@@ -2,8 +2,11 @@
 
 precision mediump float;
 
+// Input vertex attributes (from vertex shader)
 varying vec2 fragTexCoord;
+varying vec4 fragColor;
 
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
@@ -11,6 +14,7 @@ uniform vec4 fragTintColor;
 
 void main()
 {
+    // Texel color fetching from texture sampler
     vec4 texelColor = texture2D(texture0, fragTexCoord);
     
     // NOTE: Implement here your fragment shader code
diff --git a/shaders/glsl330/base.vs b/shaders/glsl330/base.vs
index b0f930b7..638cb8ae 100644
--- a/shaders/glsl330/base.vs
+++ b/shaders/glsl330/base.vs
@@ -1,18 +1,26 @@
 #version 330
 
+// Input vertex attributes
 in vec3 vertexPosition;
 in vec2 vertexTexCoord;
 in vec3 vertexNormal;
+in vec4 vertexColor;
 
-out vec2 fragTexCoord;
-
+// Input uniform values
 uniform mat4 mvpMatrix;
 
+// Output vertex attributes (to fragment shader)
+out vec2 fragTexCoord;
+out vec4 fragColor;
+
 // NOTE: Add here your custom variables 
 
 void main()
 {
+    // Send vertex attributes to fragment shader
     fragTexCoord = vertexTexCoord;
+    fragColor = vertexColor;
     
+    // Calculate final vertex position
     gl_Position = mvpMatrix*vec4(vertexPosition, 1.0);
 }
\ No newline at end of file
diff --git a/shaders/glsl330/bloom.fs b/shaders/glsl330/bloom.fs
index 34b6295c..0307bc06 100644
--- a/shaders/glsl330/bloom.fs
+++ b/shaders/glsl330/bloom.fs
@@ -1,12 +1,16 @@
 #version 330
 
+// Input vertex attributes (from vertex shader)
 in vec2 fragTexCoord;
+in vec4 fragColor;
 
-out vec4 fragColor;
-
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
+// Output fragment color
+out vec4 finalColor;
+
 // NOTE: Add here your custom variables
 
 void main()
@@ -18,25 +22,17 @@ void main()
     {
         for (int j = -3; j < 3; j++)
         {
-            sum += texture(texture0, fragTexCoord + vec2(j, i)*0.004) * 0.25;
+            sum += texture(texture0, fragTexCoord + vec2(j, i)*0.004)*0.25;
         }
     }
     
-    if (texture(texture0, fragTexCoord).r < 0.3)
-    {
-        tc = sum*sum*0.012 + texture(texture0, fragTexCoord);
-    }
-    else
-    {
-        if (texture(texture0, fragTexCoord).r < 0.5)
-        {
-            tc = sum*sum*0.009 + texture(texture0, fragTexCoord);
-        }
-        else
-        {
-            tc = sum*sum*0.0075 + texture(texture0, fragTexCoord);
-        }
-    }
+    // Texel color fetching from texture sampler
+    vec4 texelColor = texture(texture0, fragTexCoord);
     
-    fragColor = tc;
+    // Calculate final fragment color
+    if (texelColor.r < 0.3) tc = sum*sum*0.012 + texelColor;
+    else if (texelColor.r < 0.5) tc = sum*sum*0.009 + texelColor;
+    else tc = sum*sum*0.0075 + texelColor;
+
+    finalColor = tc;
 }
\ No newline at end of file
diff --git a/shaders/glsl330/blur.fs b/shaders/glsl330/blur.fs
index 44ea42b1..7c31f727 100644
--- a/shaders/glsl330/blur.fs
+++ b/shaders/glsl330/blur.fs
@@ -1,12 +1,16 @@
 #version 330
 
+// Input vertex attributes (from vertex shader)
 in vec2 fragTexCoord;
+in vec4 fragColor;
 
-out vec4 fragColor;
-
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
+// Output fragment color
+out vec4 finalColor;
+
 // NOTE: Add here your custom variables
 
 const float renderWidth = 1280.0;
@@ -17,13 +21,14 @@ float weight[3] = float[](0.2270270270, 0.3162162162, 0.0702702703);
 
 void main()
 {
-    vec3 tc = texture(texture0, fragTexCoord).rgb*weight[0];
-
+    // Texel color fetching from texture sampler
+    vec3 texelColor = texture(texture0, fragTexCoord).rgb*weight[0];
+    
     for (int i = 1; i < 3; i++) 
     {
-        tc += texture(texture0, fragTexCoord + vec2(offset[i])/renderWidth, 0.0).rgb*weight[i];
-        tc += texture(texture0, fragTexCoord - vec2(offset[i])/renderWidth, 0.0).rgb*weight[i];
+        texelColor += texture(texture0, fragTexCoord + vec2(offset[i])/renderWidth, 0.0).rgb*weight[i];
+        texelColor += texture(texture0, fragTexCoord - vec2(offset[i])/renderWidth, 0.0).rgb*weight[i];
     }
 
-    fragColor = vec4(tc, 1.0);
+    finalColor = vec4(texelColor, 1.0);
 }
\ No newline at end of file
diff --git a/shaders/glsl330/cross_hatching.fs b/shaders/glsl330/cross_hatching.fs
index 6f5df964..c12c48cd 100644
--- a/shaders/glsl330/cross_hatching.fs
+++ b/shaders/glsl330/cross_hatching.fs
@@ -1,13 +1,17 @@
 #version 330
 
+// Input vertex attributes (from vertex shader)
 in vec2 fragTexCoord;
+in vec4 fragColor;
 
-out vec4 fragColor;
-
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
-// NOTE: Add here your custom variables 
+// Output fragment color
+out vec4 finalColor;
+
+// NOTE: Add here your custom variables
 
 float hatchOffsetY = 5.0;
 float lumThreshold01 = 0.9;
@@ -27,18 +31,18 @@ void main()
 
     if (lum < lumThreshold02) 
     {
-        if (mod(gl_FragCoord .x - gl_FragCoord .y, 10.0) == 0.0) tc = vec3(0.0, 0.0, 0.0);
+        if (mod(gl_FragCoord.x - gl_FragCoord.y, 10.0) == 0.0) tc = vec3(0.0, 0.0, 0.0);
     }
 
     if (lum < lumThreshold03) 
     {
-        if (mod(gl_FragCoord .x + gl_FragCoord .y - hatchOffsetY, 10.0) == 0.0) tc = vec3(0.0, 0.0, 0.0);
+        if (mod(gl_FragCoord.x + gl_FragCoord.y - hatchOffsetY, 10.0) == 0.0) tc = vec3(0.0, 0.0, 0.0);
     }
 
     if (lum < lumThreshold04) 
     {
-        if (mod(gl_FragCoord .x - gl_FragCoord .y - hatchOffsetY, 10.0) == 0.0) tc = vec3(0.0, 0.0, 0.0);
+        if (mod(gl_FragCoord.x - gl_FragCoord.y - hatchOffsetY, 10.0) == 0.0) tc = vec3(0.0, 0.0, 0.0);
     }
 
-    fragColor = vec4(tc, 1.0);
+    finalColor = vec4(tc, 1.0);
 }
\ No newline at end of file
diff --git a/shaders/glsl330/cross_stitching.fs b/shaders/glsl330/cross_stitching.fs
index dcb26e79..7c87c6cd 100644
--- a/shaders/glsl330/cross_stitching.fs
+++ b/shaders/glsl330/cross_stitching.fs
@@ -1,12 +1,16 @@
 #version 330
 
+// Input vertex attributes (from vertex shader)
 in vec2 fragTexCoord;
+in vec4 fragColor;
 
-out vec4 fragColor;
-
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
+// Output fragment color
+out vec4 finalColor;
+
 // NOTE: Add here your custom variables
 
 const float renderWidth = 1280.0;
@@ -46,9 +50,9 @@ vec4 PostFX(sampler2D tex, vec2 uv)
     return c;
 }
 
-void main(void)
+void main()
 {
     vec3 tc = PostFX(texture0, fragTexCoord).rgb;
 
-    fragColor = vec4(tc, 1.0);
+    finalColor = vec4(tc, 1.0);
 }
\ No newline at end of file
diff --git a/shaders/glsl330/depth.fs b/shaders/glsl330/depth.fs
new file mode 100644
index 00000000..06d399f9
--- /dev/null
+++ b/shaders/glsl330/depth.fs
@@ -0,0 +1,27 @@
+#version 330
+
+// Input vertex attributes (from vertex shader)
+in vec2 fragTexCoord;
+in vec4 fragColor;
+
+// Input uniform values
+uniform sampler2D texture0;     // Depth texture
+uniform vec4 fragTintColor;
+
+// Output fragment color
+out vec4 finalColor;
+
+// NOTE: Add here your custom variables
+
+void main()
+{
+    float zNear = 0.01; // camera z near
+    float zFar = 10.0;  // camera z far
+    float z = texture(texture0, fragTexCoord).x;
+
+    // Linearize depth value
+    float depth = (2.0*zNear)/(zFar + zNear - z*(zFar - zNear));
+    
+    // Calculate final fragment color
+    finalColor = vec4(depth, depth, depth, 1.0f);
+}
\ No newline at end of file
diff --git a/shaders/glsl330/grayscale.fs b/shaders/glsl330/grayscale.fs
index b3a695bf..d4a8824f 100644
--- a/shaders/glsl330/grayscale.fs
+++ b/shaders/glsl330/grayscale.fs
@@ -1,20 +1,26 @@
 #version 330
 
+// Input vertex attributes (from vertex shader)
 in vec2 fragTexCoord;
+in vec4 fragColor;
 
-out vec4 fragColor;
-
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
+// Output fragment color
+out vec4 finalColor;
+
 // NOTE: Add here your custom variables
 
 void main()
 {
-    vec4 base = texture(texture0, fragTexCoord)*fragTintColor;
+    // Texel color fetching from texture sampler
+    vec4 texelColor = texture(texture0, fragTexCoord)*fragTintColor*fragColor;
     
-    // Convert to grayscale using NTSC conversion weights
-    float gray = dot(base.rgb, vec3(0.299, 0.587, 0.114));
+    // Convert texel color to grayscale using NTSC conversion weights
+    float gray = dot(texelColor.rgb, vec3(0.299, 0.587, 0.114));
     
-    fragColor = vec4(gray, gray, gray, fragTintColor.a);
+    // Calculate final fragment color
+    finalColor = vec4(gray, gray, gray, texelColor.a);
 }
\ No newline at end of file
diff --git a/shaders/glsl330/phong.fs b/shaders/glsl330/phong.fs
index 75b7e6d7..c14b346a 100644
--- a/shaders/glsl330/phong.fs
+++ b/shaders/glsl330/phong.fs
@@ -1,76 +1,85 @@
 #version 330
 
-// Vertex shader input data
+// Input vertex attributes (from vertex shader)
 in vec2 fragTexCoord;
 in vec3 fragNormal;
 
-// Diffuse data
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
-// Light attributes
-uniform vec3 light_ambientColor = vec3(0.6, 0.3, 0);
-uniform vec3 light_diffuseColor = vec3(1, 0.5, 0);
-uniform vec3 light_specularColor = vec3(0, 1, 0);
-uniform float light_intensity = 1;
-uniform float light_specIntensity = 1;
+// Output fragment color
+out vec4 finalColor;
 
-// Material attributes
-uniform vec3 mat_ambientColor = vec3(1, 1, 1);
-uniform vec3 mat_specularColor = vec3(1, 1, 1);
-uniform float mat_glossiness = 50;
+// NOTE: Add here your custom variables
 
-// World attributes
-uniform vec3 lightPos;
-uniform vec3 cameraPos;
+// Light uniform values
+uniform vec3 lightAmbientColor = vec3(0.6, 0.3, 0.0);
+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;
+
+// Material uniform values
+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;
 
 // Fragment shader output data
 out vec4 fragColor;
 
+// 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
-   float diffuse = clamp(dot(N, L), 0, 1);
-   
-   return tintColor.xyz * light_diffuseColor * light_intensity * diffuse;
+    // Lambertian reflection calculation
+    float diffuse = clamp(dot(N, L), 0, 1);
+
+    return (fragTintColor.xyz*lightDiffuseColor*lightIntensity*diffuse);
 }
 
+// Calculate specular lighting component
 vec3 SpecularLighting(in vec3 N, in vec3 L, in vec3 V)
 {
-   float specular = 0;
-
-   // Calculate specular reflection only if the surface is oriented to the light source
-   if(dot(N, L) > 0)
-   {
-      // Calculate half vector
-      vec3 H = normalize(L + V);
-      
-      // Calculate specular intensity
-      specular = pow(dot(N, H), 3 + mat_glossiness);
-   }
+    float specular = 0.0;
+
+    // Calculate specular reflection only if the surface is oriented to the light source
+    if (dot(N, L) > 0)
+    {
+        // Calculate half vector
+        vec3 H = normalize(L + V);
+
+        // Calculate specular intensity
+        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 V = normalize(cameraPos);
+    vec3 L = normalize(lightPosition);
+    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
-    vec4 textureColor = texture(texture0, fragTexCoord);
-    vec3 finalColor = textureColor.rgb;
-    
-    fragColor = vec4(finalColor * (ambient + diffuse + specular), textureColor.a);
+    // Texel color fetching from texture sampler
+    vec4 texelColor = texture(texture0, fragTexCoord);
+
+    // Calculate final fragment color
+    finalColor = vec4(texelColor.rgb*(ambient + diffuse + specular), texelColor.a);
 }
\ No newline at end of file
diff --git a/shaders/glsl330/phong.vs b/shaders/glsl330/phong.vs
index ee6d34bf..d68d9b3f 100644
--- a/shaders/glsl330/phong.vs
+++ b/shaders/glsl330/phong.vs
@@ -1,23 +1,25 @@
 #version 330
 
-// Vertex input data
+// Input vertex attributes
 in vec3 vertexPosition;
 in vec2 vertexTexCoord;
 in vec3 vertexNormal;
 
-// Projection and model data
+// Input uniform values
 uniform mat4 mvpMatrix;
-uniform mat4 modelMatrix;
 
-// Attributes to fragment shader
+// Output vertex attributes (to fragment shader)
 out vec2 fragTexCoord;
 out vec3 fragNormal;
 
+// NOTE: Add here your custom variables
+uniform mat4 modelMatrix;
+
 void main()
 {
-    // Send texture coord to fragment shader
+    // Send vertex attributes to fragment shader
     fragTexCoord = vertexTexCoord;
-    
+
     // Calculate view vector normal from model
     mat3 normalMatrix = transpose(inverse(mat3(modelMatrix)));
     fragNormal = normalize(normalMatrix*vertexNormal);
diff --git a/shaders/glsl330/pixel.fs b/shaders/glsl330/pixel.fs
index aa5a22fe..9ed3ea7d 100644
--- a/shaders/glsl330/pixel.fs
+++ b/shaders/glsl330/pixel.fs
@@ -1,13 +1,17 @@
 #version 330
 
+// Input vertex attributes (from vertex shader)
 in vec2 fragTexCoord;
+in vec4 fragColor;
 
-out vec4 fragColor;
-
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
-// NOTE: Add here your custom variables 
+// Output fragment color
+out vec4 finalColor;
+
+// NOTE: Add here your custom variables
 
 const float renderWidth = 1280.0;
 const float renderHeight = 720.0;
@@ -24,5 +28,5 @@ void main()
 
     vec3 tc = texture(texture0, coord).rgb;
 
-    fragColor = vec4(tc, 1.0);
+    finalColor = vec4(tc, 1.0);
 }
\ No newline at end of file
diff --git a/shaders/glsl330/posterization.fs b/shaders/glsl330/posterization.fs
index 5215bd8b..f1d72a19 100644
--- a/shaders/glsl330/posterization.fs
+++ b/shaders/glsl330/posterization.fs
@@ -1,12 +1,16 @@
 #version 330
 
+// Input vertex attributes (from vertex shader)
 in vec2 fragTexCoord;
+in vec4 fragColor;
 
-out vec4 fragColor;
-
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
+// Output fragment color
+out vec4 finalColor;
+
 // NOTE: Add here your custom variables
 
 float gamma = 0.6;
@@ -14,13 +18,14 @@ float numColors = 8.0;
 
 void main()
 {
-    vec3 color = texture(texture0, fragTexCoord.xy).rgb;
+    // Texel color fetching from texture sampler
+    vec3 texelColor = texture(texture0, fragTexCoord.xy).rgb;
     
-    color = pow(color, vec3(gamma, gamma, gamma));
-    color = color*numColors;
-    color = floor(color);
-    color = color/numColors;
-    color = pow(color, vec3(1.0/gamma));
+    texelColor = pow(texelColor, vec3(gamma, gamma, gamma));
+    texelColor = texelColor*numColors;
+    texelColor = floor(texelColor);
+    texelColor = texelColor/numColors;
+    texelColor = pow(texelColor, vec3(1.0/gamma));
     
-    fragColor = vec4(color, 1.0);
+    finalColor = vec4(texelColor, 1.0);
 }
\ No newline at end of file
diff --git a/shaders/glsl330/predator.fs b/shaders/glsl330/predator.fs
index 85c93d0c..9269dfd4 100644
--- a/shaders/glsl330/predator.fs
+++ b/shaders/glsl330/predator.fs
@@ -1,27 +1,32 @@
 #version 330
 
+// Input vertex attributes (from vertex shader)
 in vec2 fragTexCoord;
+in vec4 fragColor;
 
-out vec4 fragColor;
-
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
+// Output fragment color
+out vec4 finalColor;
+
 // NOTE: Add here your custom variables
 
 void main()
 {
-    vec3 color = texture(texture0, fragTexCoord).rgb;
+    // Texel color fetching from texture sampler
+    vec3 texelColor = texture(texture0, fragTexCoord).rgb;
     vec3 colors[3];
     colors[0] = vec3(0.0, 0.0, 1.0);
     colors[1] = vec3(1.0, 1.0, 0.0);
     colors[2] = vec3(1.0, 0.0, 0.0);
     
-    float lum = (color.r + color.g + color.b)/3.0;
+    float lum = (texelColor.r + texelColor.g + texelColor.b)/3.0;
     
     int ix = (lum < 0.5)? 0:1;
     
     vec3 tc = mix(colors[ix], colors[ix + 1], (lum - float(ix)*0.5)/0.5);
     
-    fragColor = vec4(tc, 1.0);
+    finalColor = vec4(tc, 1.0);
 }
\ No newline at end of file
diff --git a/shaders/glsl330/scanlines.fs b/shaders/glsl330/scanlines.fs
index 0c89e610..177f000d 100644
--- a/shaders/glsl330/scanlines.fs
+++ b/shaders/glsl330/scanlines.fs
@@ -1,12 +1,16 @@
 #version 330
 
+// Input vertex attributes (from vertex shader)
 in vec2 fragTexCoord;
+in vec4 fragColor;
 
-out vec4 fragColor;
-
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
+// Output fragment color
+out vec4 finalColor;
+
 // NOTE: Add here your custom variables
 
 float offset = 0.0;
@@ -14,7 +18,7 @@ float frequency = 720.0/3.0;
 
 uniform float time;
 
-void main (void)
+void main()
 {
 /*
     // Scanlines method 1
@@ -35,7 +39,8 @@ void main (void)
     float globalPos = (fragTexCoord.y + offset) * frequency;
     float wavePos = cos((fract(globalPos) - 0.5)*3.14);
     
-    vec4 color = texture(texture0, fragTexCoord);
+    // Texel color fetching from texture sampler
+    vec4 texelColor = texture(texture0, fragTexCoord);
 
-    fragColor = mix(vec4(0.0, 0.3, 0.0, 0.0), color, wavePos);
+    finalColor = mix(vec4(0.0, 0.3, 0.0, 0.0), texelColor, wavePos);
 }
\ No newline at end of file
diff --git a/shaders/glsl330/swirl.fs b/shaders/glsl330/swirl.fs
index 19d7468b..80c16cc9 100644
--- a/shaders/glsl330/swirl.fs
+++ b/shaders/glsl330/swirl.fs
@@ -1,27 +1,32 @@
 #version 330
 
+// Input vertex attributes (from vertex shader)
 in vec2 fragTexCoord;
+in vec4 fragColor;
 
-out vec4 fragColor;
-
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
+// Output fragment color
+out vec4 finalColor;
+
 // NOTE: Add here your custom variables
 
-const float renderWidth = 1280.0; 
-const float renderHeight = 720.0; 
+const float renderWidth = 800.0;      // HARDCODED for example!
+const float renderHeight = 480.0;     // Use uniforms instead...
 
 float radius = 250.0;
 float angle = 0.8;
 
 uniform vec2 center = vec2(200.0, 200.0);
 
-void main (void)
+void main()
 {
     vec2 texSize = vec2(renderWidth, renderHeight);
     vec2 tc = fragTexCoord*texSize;
     tc -= center;
+    
     float dist = length(tc);
 
     if (dist < radius) 
@@ -37,5 +42,5 @@ void main (void)
     tc += center;
     vec3 color = texture(texture0, tc/texSize).rgb;
 
-    fragColor = vec4(color, 1.0);;
+    finalColor = vec4(color, 1.0);;
 }
\ No newline at end of file
diff --git a/shaders/glsl330/template.fs b/shaders/glsl330/template.fs
index ad7210a4..55b8d4a4 100644
--- a/shaders/glsl330/template.fs
+++ b/shaders/glsl330/template.fs
@@ -1,19 +1,24 @@
 #version 330
 
+// Input vertex attributes (from vertex shader)
 in vec2 fragTexCoord;
+in vec4 fragColor;
 
-out vec4 fragColor;
-
+// Input uniform values
 uniform sampler2D texture0;
 uniform vec4 fragTintColor;
 
+// Output fragment color
+out vec4 finalColor;
+
 // NOTE: Add here your custom variables
 
 void main()
 {
+    // Texel color fetching from texture sampler
     vec4 texelColor = texture(texture0, fragTexCoord);
     
     // NOTE: Implement here your fragment shader code
     
-    fragColor = texelColor*fragTintColor;
+    finalColor = texelColor*fragTintColor;
 }