Updated examples to latest raylib 5.0 and shell!

1 files changed, 42 insertions, 25 deletions

diff --git a/examples/shaders/shaders_postprocessing.data b/examples/shaders/shaders_postprocessing.data
index e8b0e7f..13731d5 100644
--- a/examples/shaders/shaders_postprocessing.data
+++ b/examples/shaders/shaders_postprocessing.data
@@ -7781,30 +7781,30 @@ precision mediump float;
 varying vec2 fragTexCoord;

 varying vec4 fragColor;

 

-uniform vec2 screenDims;        // Dimensions of the screen

 uniform vec2 c;                 // c.x = real, c.y = imaginary component. Equation done is z^2 + c

 uniform vec2 offset;            // Offset of the scale.

 uniform float zoom;             // Zoom of the scale.

 

 // NOTE: Maximum number of shader for-loop iterations depend on GPU,

 // for example, on RasperryPi for this examply only supports up to 60

-const int MAX_ITERATIONS = 48;  // Max iterations to do

+const int maxIterations = 48;     // Max iterations to do.

+const float colorCycles = 1.0f;   // Number of times the color palette repeats.

 

 // Square a complex number

 vec2 ComplexSquare(vec2 z)

 {

     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.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);

-    vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);

-    return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);

+    vec4 K = vec4(1.0f, 2.0f/3.0f, 1.0f/3.0f, 3.0f);

+    vec3 p = abs(fract(c.xxx + K.xyz)*6.0f - K.www);

+    return c.z*mix(K.xxx, clamp(p - K.xxx, 0.0f, 1.0f), c.y);

 }

 

 void main()

@@ -7820,8 +7820,8 @@ void main()
 

       If the number is below 2, we keep iterating.

       But when do we stop iterating if the number is always below 2 (it converges)?

-      That is what MAX_ITERATIONS is for.

-      Then we can divide the iterations by the MAX_ITERATIONS value to get a normalized value that we can

+      That is what maxIterations is for.

+      Then we can divide the iterations by the maxIterations value to get a normalized value that we can

       then map to a color.

 

       We use dot product (z.x * z.x + z.y * z.y) to determine the magnitude (length) squared.

@@ -7830,13 +7830,15 @@ 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 + offset.x/screenDims.x)*2.5/zoom, (fragTexCoord.y + offset.y/screenDims.y)*1.5/zoom);

+    vec2 z = vec2((fragTexCoord.x - 0.5f)*2.5f, (fragTexCoord.y - 0.5f)*1.5f)/zoom;

+    z.x += offset.x;

+    z.y += offset.y;

 

     int iter = 0;

     for (int iterations = 0; iterations < 60; iterations++)

     {

         z = ComplexSquare(z) + c;  // Iterate function

-        if (dot(z, z) > 4.0) break;

+        if (dot(z, z) > 4.0f) break;

 

         iter = iterations;

     }

@@ -7847,14 +7849,14 @@ void main()
     z = ComplexSquare(z) + c;

 

     // This last part smooths the color (again see link above).

-    float smoothVal = float(iter) + 1.0 - (log(log(length(z)))/log(2.0));

+    float smoothVal = float(iter) + 1.0f - (log(log(length(z)))/log(2.0f));

 

     // Normalize the value so it is between 0 and 1.

-    float norm = smoothVal/float(MAX_ITERATIONS);

+    float norm = smoothVal/float(maxIterations);

 

     // If in set, color black. 0.999 allows for some float accuracy error.

-    if (norm > 0.999) gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);

-    else gl_FragColor = vec4(Hsv2rgb(vec3(norm, 1.0, 1.0)), 1.0);

+    if (norm > 0.999f) gl_FragColor = vec4(0.0f, 0.0f, 0.0f, 1.0f);

+    else gl_FragColor = vec4(Hsv2rgb(vec3(norm*colorCycles, 1.0f, 1.0f)), 1.0f);

 }

 #version 100

 

@@ -7876,12 +7878,6 @@ uniform vec4 colDiffuse;
 #define     LIGHT_DIRECTIONAL       0

 #define     LIGHT_POINT             1

 

-struct MaterialProperty {

-    vec3 color;

-    int useSampler;

-    sampler2D sampler;

-};

-

 struct Light {

     int enabled;

     int type;

@@ -8892,7 +8888,28 @@ void main()
     tc += center;

     vec4 color = texture2D(texture0, tc/texSize)*colDiffuse*fragColor;;

 

-    gl_FragColor = vec4(color.rgb, 1.0);;

+    gl_FragColor = vec4(color.rgb, 1.0);

+}

+#version 100

+

+precision mediump float;

+

+// Input vertex attributes (from vertex shader)

+varying vec2 fragTexCoord;

+varying vec4 fragColor;

+

+// Input uniform values

+uniform sampler2D diffuseMap;

+uniform vec4 tiling;

+

+// NOTE: Add here your custom variables

+

+void main()

+{

+    vec2 texCoord = fragTexCoord*tiling;

+    fragColor = texture2D(diffuseMap, texCoord);

+    

+    gl_FragColor = fragColor;

 }

 #version 100

 

@@ -8906,7 +8923,7 @@ varying vec4 fragColor;
 uniform sampler2D texture0;

 uniform vec4 colDiffuse;

 

-uniform float secondes;

+uniform float seconds;

 

 uniform vec2 size;

 

@@ -8925,8 +8942,8 @@ void main() {
     float boxTop = 0.0;

 

     vec2 p = fragTexCoord;

-    p.x += cos((fragTexCoord.y - boxTop) * freqX / ( pixelWidth * 750.0) + (secondes * speedX)) * ampX * pixelWidth;

-    p.y += sin((fragTexCoord.x - boxLeft) * freqY * aspect / ( pixelHeight * 750.0) + (secondes * speedY)) * ampY * pixelHeight;

+    p.x += cos((fragTexCoord.y - boxTop) * freqX / ( pixelWidth * 750.0) + (seconds * speedX)) * ampX * pixelWidth;

+    p.y += sin((fragTexCoord.x - boxLeft) * freqY * aspect / ( pixelHeight * 750.0) + (seconds * speedY)) * ampY * pixelHeight;

 

     gl_FragColor = texture2D(texture0, p)*colDiffuse*fragColor;

 }