Improved shaders_postprocessing example

1 files changed, 530 insertions, 0 deletions

diff --git a/docs/examples/web/shaders/shaders_postprocessing.data b/docs/examples/web/shaders/shaders_postprocessing.data
index f6f6502d..a0ed4476 100644
--- a/docs/examples/web/shaders/shaders_postprocessing.data
+++ b/docs/examples/web/shaders/shaders_postprocessing.data
@@ -60389,6 +60389,29 @@ _úƒÀi
 €Å®ü3€ÓV
 "þÿG
|:ƒÀé+€ÕÁ ½ôí%Ïàóñº
 

+precision mediump float;

+

+// Input vertex attributes (from vertex shader)

+varying vec2 fragTexCoord;

+varying vec4 fragColor;

+

+// Input uniform values

+uniform sampler2D texture0;

+uniform vec4 colDiffuse;

+

+// NOTE: Add here your custom variables

+uniform vec2 resolution = vec2(800, 450);

+

+void main()

+{

+    // Texel color fetching from texture sampler

+    vec4 texelColor = texture2D(texture0, fragTexCoord);

+    

+    // NOTE: Implement here your fragment shader code

+    

+    gl_FragColor = texelColor*colDiffuse;

+}#version 100

+

 // Input vertex attributes

 attribute vec3 vertexPosition;

 attribute vec2 vertexTexCoord;

@@ -60450,4 +60473,511 @@ void main()
 

     // Calculate final fragment color

     gl_FragColor = ((sum/(samples*samples)) + source)*colDiffuse;

+}#version 100

+

+precision mediump float;

+

+// Input vertex attributes (from vertex shader)

+varying vec2 fragTexCoord;

+varying vec4 fragColor;

+

+// Input uniform values

+uniform sampler2D texture0;

+uniform vec4 colDiffuse;

+

+// NOTE: Add here your custom variables

+

+// NOTE: Render size values must be passed from code

+const float renderWidth = 800.0;

+const float renderHeight = 450.0;

+

+vec3 offset = vec3(0.0, 1.3846153846, 3.2307692308);

+vec3 weight = vec3(0.2270270270, 0.3162162162, 0.0702702703);

+

+void main() 

+{ 

+    // Texel color fetching from texture sampler

+    vec3 tc = texture2D(texture0, fragTexCoord).rgb*weight.x;

+    

+    tc += texture2D(texture0, fragTexCoord + vec2(offset.y)/renderWidth, 0.0).rgb*weight.y;

+    tc += texture2D(texture0, fragTexCoord - vec2(offset.y)/renderWidth, 0.0).rgb*weight.y;

+    

+    tc += texture2D(texture0, fragTexCoord + vec2(offset.z)/renderWidth, 0.0).rgb*weight.z;

+    tc += texture2D(texture0, fragTexCoord - vec2(offset.z)/renderWidth, 0.0).rgb*weight.z;

+

+    gl_FragColor = vec4(tc, 1.0);

+}# version 100

+

+precision mediump float;

+

+// Input vertex attributes (from vertex shader)

+varying vec2 fragTexCoord;

+varying vec4 fragColor;

+

+// Input uniform values

+uniform sampler2D texture0;

+uniform vec4 colDiffuse;

+

+// NOTE: Add here your custom variables

+

+float hatchOffsetY = 5.0;

+float lumThreshold01 = 0.9;

+float lumThreshold02 = 0.7;

+float lumThreshold03 = 0.5;

+float lumThreshold04 = 0.3;

+

+void main() 

+{

+    vec3 tc = vec3(1.0, 1.0, 1.0);

+    float lum = length(texture2D(texture0, fragTexCoord).rgb);

+

+    if (lum < lumThreshold01) 

+    {

+        if (mod(gl_FragCoord.x + gl_FragCoord.y, 10.0) == 0.0) tc = vec3(0.0, 0.0, 0.0);

+    }  

+

+    if (lum < lumThreshold02) 

+    {

+        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 (lum < lumThreshold04) 

+    {

+        if (mod(gl_FragCoord .x - gl_FragCoord .y - hatchOffsetY, 10.0) == 0.0) tc = vec3(0.0, 0.0, 0.0);

+    }

+

+    gl_FragColor = vec4(tc, 1.0);

+}# version 100

+

+precision mediump float;

+

+// Input vertex attributes (from vertex shader)

+varying vec2 fragTexCoord;

+varying vec4 fragColor;

+

+// Input uniform values

+uniform sampler2D texture0;

+uniform vec4 colDiffuse;

+

+// NOTE: Add here your custom variables

+

+// NOTE: Render size values must be passed from code

+const float renderWidth = 800.0;

+const float renderHeight = 450.0;

+

+float stitchingSize = 6.0;

+int invert = 0;

+

+vec4 PostFX(sampler2D tex, vec2 uv)

+{

+    vec4 c = vec4(0.0);

+    float size = stitchingSize;

+    vec2 cPos = uv * vec2(renderWidth, renderHeight);

+    vec2 tlPos = floor(cPos / vec2(size, size));

+    tlPos *= size;

+

+    int remX = int(mod(cPos.x, size));

+    int remY = int(mod(cPos.y, size));

+    

+    if (remX == 0 && remY == 0) tlPos = cPos;

+    

+    vec2 blPos = tlPos;

+    blPos.y += (size - 1.0);

+    

+    if ((remX == remY) || (((int(cPos.x) - int(blPos.x)) == (int(blPos.y) - int(cPos.y)))))

+    {

+        if (invert == 1) c = vec4(0.2, 0.15, 0.05, 1.0);

+        else c = texture2D(tex, tlPos * vec2(1.0/renderWidth, 1.0/renderHeight)) * 1.4;

+    }

+    else

+    {

+        if (invert == 1) c = texture2D(tex, tlPos * vec2(1.0/renderWidth, 1.0/renderHeight)) * 1.4;

+        else c = vec4(0.0, 0.0, 0.0, 1.0);

+    }

+    

+    return c;

+}

+

+void main()

+{

+    vec3 tc = PostFX(texture0, fragTexCoord).rgb;

+

+    gl_FragColor = vec4(tc, 1.0);

+}#version 100

+

+precision mediump float;

+

+// Input vertex attributes (from vertex shader)

+varying vec2 fragTexCoord;

+

+// Input uniform values

+uniform sampler2D texture0;

+

+// NOTE: Default parameters for Oculus Rift DK2 device

+const vec2 LeftLensCenter = vec2(0.2863248, 0.5);

+const vec2 RightLensCenter = vec2(0.7136753, 0.5);

+const vec2 LeftScreenCenter = vec2(0.25, 0.5);

+const vec2 RightScreenCenter = vec2(0.75, 0.5);

+const vec2 Scale = vec2(0.25, 0.45);

+const vec2 ScaleIn = vec2(4.0, 2.5);

+const vec4 HmdWarpParam = vec4(1.0, 0.22, 0.24, 0.0);

+const vec4 ChromaAbParam = vec4(0.996, -0.004, 1.014, 0.0);

+

+void main()

+{

+    // The following two variables need to be set per eye

+    vec2 LensCenter = fragTexCoord.x < 0.5 ? LeftLensCenter : RightLensCenter;

+    vec2 ScreenCenter = fragTexCoord.x < 0.5 ? LeftScreenCenter : RightScreenCenter;

+    

+    // Scales input texture coordinates for distortion: vec2 HmdWarp(vec2 fragTexCoord, vec2 LensCenter)

+    vec2 theta = (fragTexCoord - LensCenter)*ScaleIn;   // Scales to [-1, 1]

+    float rSq = theta.x*theta.x + theta.y*theta.y;

+    vec2 theta1 = theta*(HmdWarpParam.x + HmdWarpParam.y*rSq + HmdWarpParam.z*rSq*rSq + HmdWarpParam.w*rSq*rSq*rSq);

+    //vec2 tc = LensCenter + Scale*theta1;

+    

+    // Detect whether blue texture coordinates are out of range since these will scaled out the furthest

+    vec2 thetaBlue = theta1*(ChromaAbParam.z + ChromaAbParam.w*rSq);

+    vec2 tcBlue = LensCenter + Scale*thetaBlue;

+

+    if (any(bvec2(clamp(tcBlue, ScreenCenter - vec2(0.25, 0.5), ScreenCenter + vec2(0.25, 0.5)) - tcBlue))) gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);

+    else

+    {

+        // Do blue texture lookup

+        float blue = texture2D(texture0, tcBlue).b;

+

+        // Do green lookup (no scaling)

+        vec2 tcGreen = LensCenter + Scale*theta1;

+        float green = texture2D(texture0, tcGreen).g;

+

+        // Do red scale and lookup

+        vec2 thetaRed = theta1*(ChromaAbParam.x + ChromaAbParam.y*rSq);

+        vec2 tcRed = LensCenter + Scale*thetaRed;

+        float red = texture2D(texture0, tcRed).r;

+

+        gl_FragColor = vec4(red, green, blue, 1.0);

+    }

+}

+#version 100

+

+precision mediump float;

+

+// Input vertex attributes (from vertex shader)

+varying vec2 fragTexCoord;

+varying vec4 fragColor;

+

+// Input uniform values

+uniform sampler2D texture0;

+uniform vec4 colDiffuse;

+

+// NOTE: Add here your custom variables

+

+void main()

+{

+    vec4 color = texture2D(texture0, fragTexCoord);

+

+    color += texture2D(texture0, fragTexCoord + 0.001);

+    color += texture2D(texture0, fragTexCoord + 0.003);

+    color += texture2D(texture0, fragTexCoord + 0.005);

+    color += texture2D(texture0, fragTexCoord + 0.007);

+    color += texture2D(texture0, fragTexCoord + 0.009);

+    color += texture2D(texture0, fragTexCoord + 0.011);

+

+    color += texture2D(texture0, fragTexCoord - 0.001);

+    color += texture2D(texture0, fragTexCoord - 0.003);

+    color += texture2D(texture0, fragTexCoord - 0.005);

+    color += texture2D(texture0, fragTexCoord - 0.007);

+    color += texture2D(texture0, fragTexCoord - 0.009);

+    color += texture2D(texture0, fragTexCoord - 0.011);

+

+    color.rgb = vec3((color.r + color.g + color.b)/3.0);

+    color = color/9.5;

+

+    gl_FragColor = color;

+}			#version 100

+

+precision mediump float;

+

+// Input vertex attributes (from vertex shader)

+varying vec2 fragTexCoord;

+varying vec4 fragColor;

+

+// Input uniform values

+uniform sampler2D texture0;

+uniform vec4 colDiffuse;

+

+// NOTE: Add here your custom variables

+

+const float PI = 3.1415926535;

+

+void main()

+{

+    float aperture = 178.0;

+    float apertureHalf = 0.5 * aperture * (PI / 180.0);

+    float maxFactor = sin(apertureHalf);

+

+    vec2 uv = vec2(0.0);

+    vec2 xy = 2.0 * fragTexCoord.xy - 1.0;

+    float d = length(xy);

+    

+    if (d < (2.0 - maxFactor))

+    {

+        d = length(xy * maxFactor);

+        float z = sqrt(1.0 - d * d);

+        float r = atan(d, z) / PI;

+        float phi = atan(xy.y, xy.x);

+

+        uv.x = r * cos(phi) + 0.5;

+        uv.y = r * sin(phi) + 0.5;

+    }

+    else

+    {

+        uv = fragTexCoord.xy;

+    }

+

+    gl_FragColor = texture2D(texture0, uv);

+}#version 100

+

+precision mediump float;

+

+// Input vertex attributes (from vertex shader)

+varying vec2 fragTexCoord;

+varying vec4 fragColor;

+

+// Input uniform values

+uniform sampler2D texture0;

+uniform vec4 colDiffuse;

+

+// NOTE: Add here your custom variables

+

+void main()

+{

+    // Texel color fetching from texture sampler

+    vec4 texelColor = texture2D(texture0, fragTexCoord)*colDiffuse*fragColor;

+    

+    // Convert texel color to grayscale using NTSC conversion weights

+    float gray = dot(texelColor.rgb, vec3(0.299, 0.587, 0.114));

+    

+    // Calculate final fragment color

+    gl_FragColor = vec4(gray, gray, gray, texelColor.a);

+}#version 100

+

+precision mediump float;

+

+// Input vertex attributes (from vertex shader)

+varying vec2 fragTexCoord;

+varying vec4 fragColor;

+

+// Input uniform values

+uniform sampler2D texture0;

+uniform vec4 colDiffuse;

+

+// NOTE: Add here your custom variables 

+

+// NOTE: Render size values must be passed from code

+const float renderWidth = 800.0;

+const float renderHeight = 450.0;

+

+const float pixelWidth = 5.0;

+const float pixelHeight = 5.0;

+

+void main() 

+{ 

+    float dx = pixelWidth*(1.0/renderWidth);

+    float dy = pixelHeight*(1.0/renderHeight);

+    

+    vec2 coord = vec2(dx*floor(fragTexCoord.x/dx), dy*floor(fragTexCoord.y/dy));

+    

+    vec3 tc = texture2D(texture0, coord).rgb;

+

+    gl_FragColor = vec4(tc, 1.0);

+}#version 100

+

+precision mediump float;

+

+// Input vertex attributes (from vertex shader)

+varying vec2 fragTexCoord;

+varying vec4 fragColor;

+

+// Input uniform values

+uniform sampler2D texture0;

+uniform vec4 colDiffuse;

+

+// NOTE: Add here your custom variables

+

+float gamma = 0.6;

+float numColors = 8.0;

+

+void main() 

+{ 

+    vec3 color = texture2D(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));

+    

+    gl_FragColor = vec4(color, 1.0);

+}#version 100

+

+precision mediump float;

+

+// Input vertex attributes (from vertex shader)

+varying vec2 fragTexCoord;

+varying vec4 fragColor;

+

+// Input uniform values

+uniform sampler2D texture0;

+uniform vec4 colDiffuse;

+

+// NOTE: Add here your custom variables

+

+void main() 

+{

+    vec3 color = texture2D(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;

+

+    vec3 tc = vec3(0.0, 0.0, 0.0);

+    

+    if (lum < 0.5) tc = mix(colors[0], colors[1], lum/0.5);

+    else tc = mix(colors[1], colors[2], (lum - 0.5)/0.5);

+

+    gl_FragColor = vec4(tc, 1.0);

+}#version 100

+

+precision mediump float;

+

+// Input vertex attributes (from vertex shader)

+varying vec2 fragTexCoord;

+varying vec4 fragColor;

+

+// Input uniform values

+uniform sampler2D texture0;

+uniform vec4 colDiffuse;

+

+// NOTE: Add here your custom variables

+

+float offset = 0.0;

+float frequency = 450.0/3.0;

+

+uniform float time;

+

+void main()

+{

+/*

+    // Scanlines method 1

+    float tval = 0; //time

+    vec2 uv = 0.5 + (fragTexCoord - 0.5)*(0.9 + 0.01*sin(0.5*tval));

+

+    vec4 color = texture2D(texture0, fragTexCoord);

+

+    color = clamp(color*0.5 + 0.5*color*color*1.2, 0.0, 1.0);

+    color *= 0.5 + 0.5*16.0*uv.x*uv.y*(1.0 - uv.x)*(1.0 - uv.y);

+    color *= vec4(0.8, 1.0, 0.7, 1);

+    color *= 0.9 + 0.1*sin(10.0*tval + uv.y*1000.0);

+    color *= 0.97 + 0.03*sin(110.0*tval);

+

+    fragColor = color;

+*/

+    // Scanlines method 2

+    float globalPos = (fragTexCoord.y + offset) * frequency;

+    float wavePos = cos((fract(globalPos) - 0.5)*3.14);

+    

+    vec4 color = texture2D(texture0, fragTexCoord);

+

+    gl_FragColor = mix(vec4(0.0, 0.3, 0.0, 0.0), color, wavePos);

+}#version 100

+

+precision mediump float;

+

+// Input vertex attributes (from vertex shader)

+varying vec2 fragTexCoord;

+varying vec4 fragColor;

+

+// Input uniform values

+uniform sampler2D texture0;

+uniform vec4 colDiffuse;

+

+// NOTE: Add here your custom variables

+vec2 resolution = vec2(800.0, 450.0);

+

+void main() 

+{

+	float x = 1.0/resolution.x;

+	float y = 1.0/resolution.y;

+    

+	vec4 horizEdge = vec4(0.0);

+	horizEdge -= texture2D(texture0, vec2(fragTexCoord.x - x, fragTexCoord.y - y))*1.0;

+	horizEdge -= texture2D(texture0, vec2(fragTexCoord.x - x, fragTexCoord.y    ))*2.0;

+	horizEdge -= texture2D(texture0, vec2(fragTexCoord.x - x, fragTexCoord.y + y))*1.0;

+	horizEdge += texture2D(texture0, vec2(fragTexCoord.x + x, fragTexCoord.y - y))*1.0;

+	horizEdge += texture2D(texture0, vec2(fragTexCoord.x + x, fragTexCoord.y    ))*2.0;

+	horizEdge += texture2D(texture0, vec2(fragTexCoord.x + x, fragTexCoord.y + y))*1.0;

+    

+	vec4 vertEdge = vec4(0.0);

+	vertEdge -= texture2D(texture0, vec2(fragTexCoord.x - x, fragTexCoord.y - y))*1.0;

+	vertEdge -= texture2D(texture0, vec2(fragTexCoord.x    , fragTexCoord.y - y))*2.0;

+	vertEdge -= texture2D(texture0, vec2(fragTexCoord.x + x, fragTexCoord.y - y))*1.0;

+	vertEdge += texture2D(texture0, vec2(fragTexCoord.x - x, fragTexCoord.y + y))*1.0;

+	vertEdge += texture2D(texture0, vec2(fragTexCoord.x    , fragTexCoord.y + y))*2.0;

+	vertEdge += texture2D(texture0, vec2(fragTexCoord.x + x, fragTexCoord.y + y))*1.0;

+    

+	vec3 edge = sqrt((horizEdge.rgb*horizEdge.rgb) + (vertEdge.rgb*vertEdge.rgb));

+	

+	gl_FragColor = vec4(edge, texture2D(texture0, fragTexCoord).a);

+}#version 100

+

+precision mediump float;

+

+// Input vertex attributes (from vertex shader)

+varying vec2 fragTexCoord;

+varying vec4 fragColor;

+

+// Input uniform values

+uniform sampler2D texture0;

+uniform vec4 colDiffuse;

+

+// NOTE: Add here your custom variables

+

+// NOTE: Render size values should be passed from code

+const float renderWidth = 800;

+const float renderHeight = 450;

+

+float radius = 250.0;

+float angle = 0.8;

+

+uniform vec2 center;

+

+void main()

+{

+    vec2 texSize = vec2(renderWidth, renderHeight);

+    vec2 tc = fragTexCoord*texSize;

+    tc -= center;

+    

+    float dist = length(tc);

+

+    if (dist < radius) 

+    {

+        float percent = (radius - dist)/radius;

+        float theta = percent*percent*angle*8.0;

+        float s = sin(theta);

+        float c = cos(theta);

+        

+        tc = vec2(dot(tc, vec2(c, -s)), dot(tc, vec2(s, c)));

+    }

+

+    tc += center;

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

+

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

 }
\ No newline at end of file