shaderflow 0.4.0.dev1__py2.py3-none-any.whl

ShaderFlow/Resources/Scenes/Examples/GLSL/Bouncing.frag

@@ -0,0 +1,50 @@
+/*
+// (c) MIT, Tremeschin
+// Hours wasted: 6
+*/
+
+#define ADVANCED_CORRECTION true
+
+void main() {
+    float angle;
+    float aspect;
+
+    // Take into account rotation and image contents
+    // Fixme: Vertical stretching is slightly wrong
+    if (ADVANCED_CORRECTION) {
+        aspect = texture(iBounceAspectRatio, vec2(angle/TAU, 0.5)).r;
+        angle = iTime/2;
+    } else {
+        aspect = logoAspectRatio;
+        angle = 0;
+    }
+
+    // Calculate the coordinate, a lot going on I wished to explain
+    vec2 correction = (1 - iLogoSize*vec2(aspect/iAspectRatio, 1));
+    vec2 uv = (gluv - iBouncePosition*correction) / iLogoSize;
+    uv *= rotate2d(angle);
+
+    // // Grid - Not part of the tech demo
+
+    // Background
+    int grid_spacing = 100;
+    int grid_thick = 2;
+    float size1 = 180.0;
+
+    // Background color
+    fragColor = vec4(vec3(0.3), 1);
+
+    // Grid marks when spacing fract (mod) pixel distance is less than value
+    bool _x = mod(glxy.x, grid_spacing) > (grid_spacing - grid_thick);
+    bool _y = mod(glxy.y, grid_spacing) > (grid_spacing - grid_thick);
+    if (_x || _y) {
+    	fragColor = vec4(vec3(0.2), 1);
+    }
+
+    // // Draw the bouncing logo
+
+    if (!agluv_oob(uv)) {
+        fragColor = alpha_composite(fragColor, gtexture(logo, uv));
+    }
+}
+

ShaderFlow/Resources/Scenes/Examples/GLSL/Life/Simulation.glsl

@@ -0,0 +1,49 @@
+/*
+// (c) MIT, Tremeschin
+Conway's Game of Life Simulation
+*/
+
+// Live cells with two or three neighbours survive
+const int alive[9] = int[9](
+    0, 0, 1,
+    1, 0, 0,
+    0, 0, 0
+);
+
+// Dead cell swith three neighbours becomes alive
+const int dead[9] = int[9](
+    0, 0, 0,
+    1, 0, 0,
+    0, 0, 0
+);
+
+void main() {
+    int near = 0;
+    int current;
+
+    // Make the animation slower
+    if ((iFrame % iLifePeriod) != 0) {
+        fragColor.r = texture(iLife1x0, astuv).r;
+        fragColor.a = 1;
+        return;
+    }
+
+    ivec2 pixel = ivec2(astuv*iLifeSize);
+
+    // Integrate the rules kernel
+    for (int x=-1; x<=1; x++) {
+        for (int y=-1; y<=1; y++) {
+            ivec2 point = pixel + ivec2(x, y);
+            int cell = texelFetch(iLife1x0, point, 0).r > 0.5 ? 1:0;
+            if (x==0 && y==0) {
+                current = cell;
+            } else {
+                near += cell;
+            }
+        }
+    }
+
+    // Apply the rules
+    fragColor.r = (current==1)?alive[near]:dead[near];
+    fragColor.a = 1;
+}

ShaderFlow/Resources/Scenes/Examples/GLSL/Life/Visuals.glsl

@@ -0,0 +1,31 @@
+/*
+// (c) MIT, Tremeschin
+Conway's Game of Life Visuals
+*/
+
+#define COLOR1 vec3(0.01060815, 0.01808215, 0.10018654)
+#define COLOR2 vec3(0.38092887, 0.12061482, 0.32506528)
+#define COLOR3 vec3(0.79650140, 0.10506637, 0.31063031)
+#define COLOR4 vec3(0.95922872, 0.53307513, 0.37488950)
+
+void main() {
+    vec2 uv = iCamera.stuv;
+
+    // Rratio of the life temporal integration of f(t) = (1 - t)^k
+    // Higher values prefer latest states, lower values smooths all
+    float exponent = 1.3;
+    float area = 1/(exponent + 1);
+
+    // Integrate life
+    float life = 0;
+    life += stexture(iLife0x0, uv).r;
+    life += stexture(iLife1x0, uv).r * pow(0.8, exponent);
+    life += stexture(iLife2x0, uv).r * pow(0.6, exponent);
+    life += stexture(iLife3x0, uv).r * pow(0.4, exponent);
+    life += stexture(iLife4x0, uv).r * pow(0.2, exponent);
+    life /= (5*area);
+
+    // Colorize life
+    fragColor.rgb = palette(life, COLOR1, COLOR2, COLOR3, COLOR4);
+    fragColor.a = 1;
+}

ShaderFlow/Resources/Scenes/Examples/GLSL/MotionBlur.frag

@@ -0,0 +1,20 @@
+/*
+// (c) MIT, Tremeschin
+*/
+
+void main() {
+    vec2 uv = iCamera.stuv;
+
+    if (iLayer == 0) {
+        fragColor = stexture(background, uv);
+    } else if (iLayer == 1) {
+        // Average of the last iTemporal layers
+        vec4 color = vec4(0);
+        for (int i=0; i<iScreenTemporal; i++) {
+            float factor = smoothstep(1.0, 0.0, float(i)/iScreenTemporal);
+            color += iScreenTexture(i, 0, astuv) * factor;
+        }
+        fragColor = 2 * color/iScreenTemporal;
+    }
+    fragColor.a = 1;
+}

ShaderFlow/Resources/Scenes/Examples/GLSL/Multipass.frag

@@ -0,0 +1,43 @@
+/*
+// (c) MIT, Tremeschin
+*/
+
+/** Walk in circles around the pixel and integrate samples, divide by area
+ * • Radius: How far to walk to sample the blur
+ * • Directions: Number of "rays" to cast
+ * • Steps: Number of samples per ray until the radius is reached
+ */
+vec4 blur(sampler2D image, vec2 stuv, float radius, int directions, int steps) {
+    vec4 color = vec4(0);
+    float weights = 0.0;
+
+    for (float direction=0; direction<TAU; direction+=TAU/directions) {
+        for (float walk=1.0/steps; walk<1.0; walk+=1.0/steps) {
+            vec2 offset = vec2(cos(direction), sin(direction)) * radius * walk / 2000;
+            vec4 sample = texture(image, stuv + offset);
+            float weight = 1.0 - distance(offset, vec2(0)) / float(radius);
+            color += sample * weight;
+            weights += weight;
+        }
+    }
+
+    return color / weights;
+}
+
+void main() {
+    if (iLayer == 0) {
+        fragColor = stexture(background, stuv);
+
+    } else if (iLayer == 1) {
+        fragColor = texture(iScreen0x0, astuv);
+
+        // Invert red on the left, blur the right
+        if (gluv.x < 0) {
+            fragColor.r = 1 - fragColor.r;
+        } else {
+            fragColor = blur(iScreen0x0, astuv, 5, 8, 8);
+        }
+    }
+
+    fragColor.a = 1;
+}

ShaderFlow/Resources/Scenes/Examples/GLSL/RayMarch.frag

@@ -0,0 +1,59 @@
+/*
+// (c) MIT, Tremeschin
+*/
+
+#define MAX_STEPS 100
+#define MAX_DIST 100.0
+#define MIN_DIST 0.001
+
+float sdScene(vec3 origin) {
+    // origin = fract(origin) - 0.5;
+
+    // float sphere = sdSphere(origin, vec3(sin(iTime)*3, 0, 3), 1);
+    // float box    = sdBox(origin, vec3(0, 0, 10), vec3(8));
+    // float ground = sdPlane(origin, vec3(0, -1, 0), vec3(0, 1, 0));
+
+    // float sdf = 1e10;
+    // sdf = sdSmoothUnion(sdf, sphere, 1);
+    // sdf = sdSmoothUnion(sdf, box, 1);
+    // sdf = sdSmoothUnion(sdf, ground, 1);
+    // return box;
+
+
+    float sdf = 2*MAX_DIST;
+
+    for (int i=2; i<8; i++) {
+        sdf = sdUnion(sdf, sdBox(origin, vec3(0, 0, i), vec3(i-1)));
+    }
+
+    return sdf;
+
+}
+
+void main() {
+    vec3 col = vec3(0);
+
+    // Camera setup
+    vec3 origin = iCamera.origin;
+    vec3 target = iCamera.target;
+    vec3 forward = normalize(target - origin);
+
+    // Raymarching
+    float traveled = 0;
+    float walk = 0;
+    int steps;
+
+    for (steps=0; steps<MAX_STEPS; steps++) {
+        vec3 point = origin + (forward*traveled);
+        walk       = sdScene(point);
+        traveled  += walk;
+        if (walk<MIN_DIST || walk>MAX_DIST) break;
+    }
+
+    // Color based on the distance
+    // col = palette_magma(1 - (sqrt(traveled)*0.1 + steps*0.01));
+    // col = vec3(sqrt(traveled)*0.1);
+    col = vec3(1 - sqrt(steps)*0.1);
+
+    fragColor = vec4(col, 1);
+}

ShaderFlow/Resources/Scenes/Examples/GLSL/ShaderToy.frag

@@ -0,0 +1,65 @@
+/*
+In ShaderFlow, the main function is as simple as it can get!
+
+void main() {
+    fragColor = vec4(0.2);
+}
+
+// Coordinates
+
+All the coordinates are already converted for you:
+
+- astuv: Absolute 'ShaderToy' uv, from (0, 0) to (1, 1)
+- agluv: Absolute 'OpenGL' uv, from (-1, -1) to (1, 1)
+
+- stuv: Aspect-ratio corrected astuv
+- sgluv: Aspect-ratio corrected agluv
+
+The Top of the screen is always 1, the bottom is 0 or 1 (stuv/gluv)
+
+Or use the iCamera.gluv, iCamera.stuv for a Z=1 plane-projected 2D uv :)
+
+The basis are (Y up), (Z forward), (X right), so (Left-Handed Y up)
+
+- All the Camera Math is already done for 2D, 3D, VR and 360°
+  - Just use iCamera.origin and iCamera.target for Ray Marching
+  - It works on any "UP" vector in Spherical mode. Quaternion math for the win!
+  - Native field of view, dolly zoom parameters
+
+// Quality of Life
+
+With the raw OpenGL bindings provided by ModernGL, the shader compilation
+process is much smarter. It simply fixes a lot of your pain and frustration
+on ShaderToy, and adds a lot of premium features:
+
+- Inter-operability between types like float and int:
+  - No more `cannot convert from 'const int' to 'highp float'` and similar!
+- Smooth animations everywhere with a Dynamics system
+- Native Fractional Super Sampling Anti Aliasing for first class quality
+- Live-reloadable shaders on Path mode, just save the .{frag,glsl,vertex} shader
+- Fastest rendering times you'll ever see. Many years of trickery and optimizations
+
+// Expansible
+
+There's no amount and limit of textures channels you can use, defined
+on the Scene's Python file. For audio reactiveness, the Spectrogram
+math is already there, converting to a log2(y) scale for you.
+
+- Waveforms are already chunked and reduced at your parameters will
+- Video as textures are also available, 4k60 fps fluent playback
+- Low memory usage, progressively reads the Audio File channels or Real Time mode
+- Piano Roll as a texture support. Check out Pianola project for a full example!
+
+// Buffers and Layers
+
+Simply set `texture.layers = L` and `texture.temporal = T` to
+create a matrix of LxT 'rolling' textures
+
+Access them by the name of iNameTxL, iName0x* is the current frame and its layers,
+iName1x2 is the last frame's layer 2, and so on. Layers starts at 0 and ends in T
+*/
+
+void main() {
+    vec3 col = 0.5 + 0.5*cos(iTime + stuv.xyx + vec3(0, 2, 4));
+    fragColor = vec4(col, 1.0);
+}

ShaderFlow/Resources/Scenes/Examples/GLSL/Video.frag

@@ -0,0 +1,5 @@
+void main() {
+    vec2 uv = iCamera.astuv;
+    fragColor = stexture(iVideo, iCamera.stuv);
+    fragColor.a = 1;
+}

ShaderFlow/Resources/Scenes/Examples/GLSL/Visualizer.frag

@@ -0,0 +1,75 @@
+/*
+// (c) MIT, Tremeschin, I Hate This Code
+*/
+
+// Not proud of this shader :v
+void main() {
+    vec2 uv = iCamera.gluv;
+    vec3 space = vec3(1, 11, 26) / 255;
+
+    if (iCamera.out_of_bounds) {
+        fragColor.rgb = space;
+        return;
+    }
+
+    // Draw background
+    vec2 background_uv = zoom(gluv2stuv(uv), 0.95 + 0.01*sin(iTime) - 0.02*iAudioVolume - 0.03, vec2(0.5));
+    background_uv += 0.005 * vec2(cos(iTime*3.25135), sin(iTime*1.153469));
+    fragColor = stexture(background, background_uv);
+
+    /* Blur background on audio volume */ {
+        float intensity = 0.01*clamp(pow(iAudioVolume, 2.5), 0, 0.3);
+        float quality = 10;
+        float directions = 8;
+        vec4 color = fragColor;
+        for (float angle=0; angle<TAU; angle+=TAU/directions) {
+            for (float walk=1.0/quality; walk<=1.001; walk+=1.0/quality) {
+                vec2 displacement = vec2(cos(angle), sin(angle)) * walk * intensity;
+                color += stexture(background, background_uv + displacement);
+            }
+        }
+        fragColor = color / (quality*directions);
+    }
+
+    // Blink on snare/kick
+    fragColor *= 1 + 5*iAudioSTD*pow(clamp(length(agluv) - 0.3, 0, 1), 6);
+
+    // Music bars coordinates
+    vec2 music_uv = rotate2d(-PI/2) * uv;
+    music_uv *= 1 - 0.4 * pow(abs(iAudioVolume), 0.5);
+    float radius = 0.17;
+
+    // Get spectrogram bar volumes
+    float circle = abs(atan1n(music_uv));
+    vec2 freq = sqrt(texture(iSpectrogram, vec2(0, circle)).xy / 1000);
+    freq *= 0.05 + 3*smoothstep(0, 2, circle);
+
+    // Music bars
+    if (length(music_uv) < radius) {
+        vec2 logo_uv = (rotate2d(0.3*sin(3*iAudioVolumeIntegral + iTime/2)) * music_uv / (1.3*radius));
+        logo_uv *= 1 - 0.02*pow(abs(iAudioVolume), 0.1);
+        fragColor = gtexture(logo, logo_uv * rotate2d(-PI/2));
+    } else {
+        float bar = (music_uv.y < 0) ? freq.x : freq.y;
+        float r = radius + 0.5*bar;
+
+        if (length(music_uv) < r) {
+            fragColor.rgb = mix(fragColor.rgb, vec3(1), smoothstep(0, 1, 0.5 + bar));
+        } else {
+            fragColor.rgb *= pow((length(music_uv) - r) * 0.5, 0.05);
+        }
+    }
+
+    fragColor.rgb = mix(fragColor.rgb, space, smoothstep(0, 1, length(uv)/20));
+
+    // Vignette
+    vec2 vig = astuv * (1 - astuv.yx);
+    fragColor.rgb *= pow(vig.x*vig.y * 20, 0.1 + 0.15*iAudioVolume);
+    fragColor.a = 1;
+
+
+    // Waveform on top and bottom
+    vec2 wave = 0.2*texture(iWaveform, vec2(astuv.x, 0)).rg;
+    if (1 - gluv.y < wave.x) {fragColor *= 0.8;}
+    if (1 + gluv.y < wave.y) {fragColor *= 0.8;}
+}

ShaderFlow/Resources/Scenes/Examples/GLSL/Waveform.frag

@@ -0,0 +1,18 @@
+/*
+// (c) MIT, Tremeschin
+*/
+
+void main() {
+    vec2 wave = texture(iWaveform, vec2(astuv.x, 0)).rg;
+    fragColor = vec4(vec3(0.2), 1);
+
+    if (abs(gluv.y) < wave.x) {
+        fragColor.r = 1;
+    }
+    if (abs(gluv.y) < wave.y) {
+        fragColor.g = 1;
+    }
+    if (abs(gluv.y) < (wave.x + wave.y)/2) {
+        fragColor.b = 1;
+    }
+}

ShaderFlow/Resources/Shaders/Fragment/Default.glsl

@@ -0,0 +1,65 @@
+// A basic cool shader that draws a grid and a ring
+// Help: I can't code cool shaders :(
+
+// A Checkerboard grid with `grid` blocks vertically
+vec3 grid_layer(vec2 uv, float grid) {
+
+    // Get the grid block color
+    if (mod(floor(uv.x * grid/2) + floor(uv.y * grid/2), 2.0) > 0.5) {
+        return vec3(0.22);
+    } else {
+        return vec3(0.2);
+    }
+}
+
+// A Varying-hue ring that spins
+vec4 ring_layer(vec2 uv) {
+
+    // Angle varying in time
+    float angle = atan2(uv.y, uv.x) + iTime;
+
+    // Fill the whole Hue range
+    vec4 color = hsv2rgb(vec4(angle, 1.0, 1, 1));
+
+    // Ring parameters
+    float d = length(uv);
+    float r = 0.5;
+
+    // Outside the ring
+    if (d > r) {
+        color = color * pow(r/d, 15.0);
+    } else {
+        color = color * pow(d/r, 15.0);
+        color.rgb += vec3(0.3);
+        color.a = 0.2;
+
+        // Draw a "Simon Says" axis
+        if (uv.x < 0) {color.r += 0.3;}
+        if (uv.y < 0) {color.g += 0.3;}
+        if (uv.x > 0 && uv.y > 0) {
+            color.b += 0.3;
+        }
+
+        // Cool transparency
+        color.a = pow(length(uv/r), 2);
+    }
+
+    return color;
+}
+
+// ------------------------------------------------------------------------------------------------|
+
+void main() {
+    vec2 uv = iCamera.gluv;
+
+    if (iCamera.out_of_bounds) {
+        float theta = angle(iCamera.UP, iCamera.ray);
+        fragColor.rgb = mix(vec3(0, 0, 0.129), vec3(0.1), pow(abs(theta)/PI, 2.0));
+        fragColor.a = 1.0;
+        return;
+    }
+
+    fragColor.rgb = grid_layer(uv, 8);
+    fragColor = alpha_composite(fragColor, ring_layer(uv));
+    fragColor.a = 1.0;
+}

ShaderFlow/Resources/Shaders/Fragment/Final.glsl

@@ -0,0 +1,7 @@
+uniform bool iFlip;
+
+void main() {
+    vec2 uv = iFlip ? vec2(astuv.x, 1-astuv.y) : (astuv);
+    fragColor = texture(iScreen, uv);
+    fragColor.a = 1.0;
+}

ShaderFlow/Resources/Shaders/Fragment/Loading.frag

@@ -0,0 +1,40 @@
+/*
+// (c) MIT, Tremeschin
+*/
+
+void main() {
+    fragColor.rgb = vec3(0);
+
+	// Loading icon options
+    float radius = 0.5;
+	float width  = 15.0;
+	float glow   = 2.0;
+
+    // Fixme: Should this be a uniform
+    float pixel = 1.0/min(iResolution.x, iResolution.y);
+
+	// Convert to pixel-space
+	width *= pixel;
+	glow  *= pixel*2;
+
+	// Calculate Tail Size based on Angle
+	float angle = atan(gluv.y, gluv.x);
+	float tail  = smoothstep(0.3, 1, fract((1.5*angle/PI) - iTime));
+
+	// Calculate
+    width = (width - pixel)*0.5*tail;
+
+    float ring  = abs(length(gluv) - radius) - width;
+
+	// Get the final height of the effect
+	float height;
+	height += smoothstep(pixel,     0.0, ring) * tail;
+	height += smoothstep(glow*tail, 0.0, ring) * tail*0.5;
+
+	// Add loading ring
+	fragColor = hsv2rgb(vec4(angle-iTime, height, 1, 1)) * height;
+
+	// Dark theme
+	fragColor.rgb += vec3(0.15);
+	fragColor.a = 1.0;
+}

ShaderFlow/Resources/Shaders/Fragment/Missing.glsl

@@ -0,0 +1,23 @@
+// Missing texture shader. Definitely not inspired in Source Shader
+
+void main() {
+
+    // Walk through the texture
+    vec2 uv = stuv + vec2(iTime) / 64.0;
+
+    // Vertical grid size
+    float size = 8.0;
+
+    // Create missing texture
+    for (int x = -5; x < 5; x++) {
+        for (int y = -5; y < 5; y++) {
+            vec2 block = floor(size * uv);
+            if (mod(block.x + block.y, 2.0) == 0.0) {
+                fragColor.rgb += vec3(1.0, 0.0, 1.0) / 25.0;
+            }
+        }
+    }
+
+    // Lots of transparency to see other elements
+    fragColor.a = 0.2;
+}