REVIEWED: Potential shader issues

examples/shaders/resources/shaders/glsl100/depth.fs

@@ -22,5 +22,5 @@ void main()
     float depth = (2.0*zNear)/(zFar + zNear - z*(zFar - zNear));
 
     // Calculate final fragment color
-    gl_FragColor = vec4(depth, depth, depth, 1.0f);
+    gl_FragColor = vec4(depth, depth, depth, 1.0);
 }

examples/shaders/resources/shaders/glsl120/shadowmap.fs

@@ -48,31 +48,31 @@ void main()
     // Shadow calculations
     vec4 fragPosLightSpace = lightVP*vec4(fragPosition, 1);
     fragPosLightSpace.xyz /= fragPosLightSpace.w; // Perform the perspective division
-    fragPosLightSpace.xyz = (fragPosLightSpace.xyz + 1.0f) / 2.0f; // Transform from [-1, 1] range to [0, 1] range
+    fragPosLightSpace.xyz = (fragPosLightSpace.xyz + 1.0)/2.0; // Transform from [-1, 1] range to [0, 1] range
     vec2 sampleCoords = fragPosLightSpace.xy;
     float curDepth = fragPosLightSpace.z;
+
     // Slope-scale depth bias: depth biasing reduces "shadow acne" artifacts, where dark stripes appear all over the scene.
     // The solution is adding a small bias to the depth
     // In this case, the bias is proportional to the slope of the surface, relative to the light
     float bias = max(0.0008*(1.0 - dot(normal, l)), 0.00008);
     int shadowCounter = 0;
     const int numSamples = 9;
+    
     // PCF (percentage-closer filtering) algorithm:
     // Instead of testing if just one point is closer to the current point,
     // we test the surrounding points as well.
     // This blurs shadow edges, hiding aliasing artifacts.
-    vec2 texelSize = vec2(1.0f / float(shadowMapResolution));
+    vec2 texelSize = vec2(1.0/float(shadowMapResolution));
     for (int x = -1; x <= 1; x++)
     {
         for (int y = -1; y <= 1; y++)
         {
             float sampleDepth = texture2D(shadowMap, sampleCoords + texelSize*vec2(x, y)).r;
-            if (curDepth - bias > sampleDepth)
+            if (curDepth - bias > sampleDepth) shadowCounter++;
-            {
-                shadowCounter++;
-            }
         }
     }
+    
     finalColor = mix(finalColor, vec4(0, 0, 0, 1), float(shadowCounter)/float(numSamples));
 
     // Add ambient lighting whether in shadow or not

examples/shaders/resources/shaders/glsl330/depth.fs

@@ -23,5 +23,5 @@ void main()
     float depth = (2.0*zNear)/(zFar + zNear - z*(zFar - zNear));
 
     // Calculate final fragment color
-    finalColor = vec4(depth, depth, depth, 1.0f);
+    finalColor = vec4(depth, depth, depth, 1.0);
 }

examples/shaders/resources/shaders/glsl330/julia_set.fs

@@ -12,23 +12,20 @@ uniform vec2 offset;            // Offset of the scale.
 uniform float zoom;             // Zoom of the scale.
 
 const int maxIterations = 255;     // Max iterations to do.
-const float colorCycles = 2.0f;    // Number of times the color palette repeats. Can show higher detail for higher iteration numbers.
+const float colorCycles = 2.0;    // Number of times the color palette repeats. Can show higher detail for higher iteration numbers.
 
 // Square a complex number
 vec2 ComplexSquare(vec2 z)
 {
-    return vec2(
+    return vec2(z.x*z.x - z.y*z.y, z.x*z.y*2.0);
-        z.x*z.x - z.y*z.y,
-        z.x*z.y*2.0f
-    );
 }
 
 // Convert Hue Saturation Value (HSV) color into RGB
 vec3 Hsv2rgb(vec3 c)
 {
-    vec4 K = vec4(1.0f, 2.0f/3.0f, 1.0f/3.0f, 3.0f);
+    vec4 K = vec4(1.0, 2.0/3.0, 1.0/3.0, 3.0);
-    vec3 p = abs(fract(c.xxx + K.xyz)*6.0f - K.www);
+    vec3 p = abs(fract(c.xxx + K.xyz)*6.0 - K.www);
-    return c.z*mix(K.xxx, clamp(p - K.xxx, 0.0f, 1.0f), c.y);
+    return c.z*mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
 }
 
 void main()
@@ -54,7 +51,7 @@ void main()
 
     // The pixel coordinates are scaled so they are on the mandelbrot scale
     // NOTE: fragTexCoord already comes as normalized screen coordinates but offset must be normalized before scaling and zoom
-    vec2 z = vec2((fragTexCoord.x - 0.5f)*2.5f, (fragTexCoord.y - 0.5f)*1.5f)/zoom;
+    vec2 z = vec2((fragTexCoord.x - 0.5f)*2.5, (fragTexCoord.y - 0.5)*1.5)/zoom;
     z.x += offset.x;
     z.y += offset.y;
 
@@ -63,7 +60,7 @@ void main()
     {
         z = ComplexSquare(z) + c;  // Iterate function
 
-        if (dot(z, z) > 4.0f) break;
+        if (dot(z, z) > 4.0) break;
     }
 
     // Another few iterations decreases errors in the smoothing calculation.
@@ -72,12 +69,12 @@ void main()
     z = ComplexSquare(z) + c;
 
     // This last part smooths the color (again see link above).
-    float smoothVal = float(iterations) + 1.0f - (log(log(length(z)))/log(2.0f));
+    float smoothVal = float(iterations) + 1.0 - (log(log(length(z)))/log(2.0));
 
     // Normalize the value so it is between 0 and 1.
     float norm = smoothVal/float(maxIterations);
 
     // If in set, color black. 0.999 allows for some float accuracy error.
-    if (norm > 0.999f) finalColor = vec4(0.0f, 0.0f, 0.0f, 1.0f);
+    if (norm > 0.999) finalColor = vec4(0.0, 0.0, 0.0, 1.0);
-    else finalColor = vec4(Hsv2rgb(vec3(norm*colorCycles, 1.0f, 1.0f)), 1.0f);
+    else finalColor = vec4(Hsv2rgb(vec3(norm*colorCycles, 1.0, 1.0)), 1.0);
 }

examples/shaders/resources/shaders/glsl330/shadowmap.fs

@@ -51,29 +51,28 @@ void main()
     // Shadow calculations
     vec4 fragPosLightSpace = lightVP * vec4(fragPosition, 1);
     fragPosLightSpace.xyz /= fragPosLightSpace.w; // Perform the perspective division
-    fragPosLightSpace.xyz = (fragPosLightSpace.xyz + 1.0f) / 2.0f; // Transform from [-1, 1] range to [0, 1] range
+    fragPosLightSpace.xyz = (fragPosLightSpace.xyz + 1.0)/2.0; // Transform from [-1, 1] range to [0, 1] range
     vec2 sampleCoords = fragPosLightSpace.xy;
     float curDepth = fragPosLightSpace.z;
+
     // Slope-scale depth bias: depth biasing reduces "shadow acne" artifacts, where dark stripes appear all over the scene.
     // The solution is adding a small bias to the depth
     // In this case, the bias is proportional to the slope of the surface, relative to the light
     float bias = max(0.0002*(1.0 - dot(normal, l)), 0.00002) + 0.00001;
     int shadowCounter = 0;
     const int numSamples = 9;
+
     // PCF (percentage-closer filtering) algorithm:
     // Instead of testing if just one point is closer to the current point,
     // we test the surrounding points as well.
     // This blurs shadow edges, hiding aliasing artifacts.
-    vec2 texelSize = vec2(1.0f / float(shadowMapResolution));
+    vec2 texelSize = vec2(1.0/float(shadowMapResolution));
     for (int x = -1; x <= 1; x++)
     {
         for (int y = -1; y <= 1; y++)
         {
             float sampleDepth = texture(shadowMap, sampleCoords + texelSize*vec2(x, y)).r;
-            if (curDepth - bias > sampleDepth)
+            if (curDepth - bias > sampleDepth) shadowCounter++;
-            {
-                shadowCounter++;
-            }
         }
     }
     finalColor = mix(finalColor, vec4(0, 0, 0, 1), float(shadowCounter)/float(numSamples));