Updated shaders with comments

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;
 }

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;

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()
 {

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;

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);
 }

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;
 }

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++) 

shaders/glsl100/cross_hatching.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;
 

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;
 

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;
 

shaders/glsl100/fisheye.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;
 

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);
 }

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;
 

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;
 

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;
 

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

shaders/glsl100/swirl.fs

@@ -2,26 +2,30 @@
 
 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);
 
     if (dist < radius) 

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

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);
 }

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;
 }

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);
 }

shaders/glsl330/cross_hatching.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 hatchOffsetY = 5.0;
@@ -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);
 }

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);
 }

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);
+}

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);
 }

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);
+    // Lambertian reflection calculation
+    float diffuse = clamp(dot(N, L), 0, 1);
 
-   return tintColor.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;
+    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 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);
-   }
+        // 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;
+    // Texel color fetching from texture sampler
+    vec4 texelColor = texture(texture0, fragTexCoord);
 
-    fragColor = vec4(finalColor * (ambient + diffuse + specular), textureColor.a);
+    // Calculate final fragment color
+    finalColor = vec4(texelColor.rgb*(ambient + diffuse + specular), texelColor.a);
 }

shaders/glsl330/phong.vs

@@ -1,21 +1,23 @@
 #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

shaders/glsl330/pixel.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;
@@ -24,5 +28,5 @@ void main()
 
     vec3 tc = texture(texture0, coord).rgb;
 
-    fragColor = vec4(tc, 1.0);
+    finalColor = vec4(tc, 1.0);
 }

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);
 }

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);
 }

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);
 }

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);;
 }

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;
 }