├── LICENSE ├── README.md ├── misc └── pull-and-crop-screenshot.sh ├── screenshots ├── blue-ink-bricks.png ├── boxes-iterative.png ├── boxes-recursive.png ├── cave.png ├── color-bricks.png ├── color-fire.png ├── color-flow.png ├── color-grid.png ├── colored-plasma-noise-bricks.png ├── drag-color.png ├── fading-color.png ├── fading-landscape.png ├── fire-flow.png ├── fire-path.png ├── fire.png ├── fog.png ├── large-slow-swoosh.png ├── paint.png ├── plasma-bricks.png ├── plasma.png ├── sand.png ├── smoke.png ├── spiral.png ├── star-swoosh.png ├── swoosh.png ├── triangles.png ├── very-smooth.png └── waves.png └── shaders ├── blue-ink-bricks.glsl ├── boxes-iterative.glsl ├── boxes-recursive.glsl ├── cave.glsl ├── color-bricks.glsl ├── color-fire.glsl ├── color-flow.glsl ├── color-grid.glsl ├── colored-plasma-noise-bricks.glsl ├── drag-color.glsl ├── fading-color.glsl ├── fading-landscape.glsl ├── fire-flow.glsl ├── fire-path.glsl ├── fire.glsl ├── fog.glsl ├── large-slow-swoosh.glsl ├── paint.glsl ├── plasma-bricks.glsl ├── plasma.glsl ├── sand.glsl ├── smoke.glsl ├── spiral.glsl ├── star-swoosh.glsl ├── swoosh.glsl ├── triangles.glsl ├── very-smooth.glsl └── waves.glsl /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2018 Michael Cipold 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # GLSL Live Wallpaper Shaders 2 | A selection of live wallpaper shaders for [Shader Editor](https://github.com/markusfisch/ShaderEditor) (Android). 3 | 4 | I created these shaders for fun in my spare time on my phone - please excuse formatting and short variable names. 5 | Using Shader Editor these shaders can be used as live wallpapers. Most of them feature touch interactivity. 6 | 7 | ## How to use a shader as live wallpaper 8 | * Download a shader (GLSL-File) from the repository. 9 | * Copy the shader to your phone into a folder called "ShaderEditor" in the "Download"-Directory. 10 | * Install Shader Editor ([Play Store](https://play.google.com/store/apps/details?id=de.markusfisch.android.shadereditor), [F-Droid](https://f-droid.org/en/packages/de.markusfisch.android.shadereditor/)) 11 | * Open the settings, scroll to the bottom and choose "Import shaders" (currently in beta) 12 | * Exit the settings and verify the shader is loaded and working 13 | * Choose the shader for live wallpaper in the settings 14 | 15 | ## Screenshots 16 |

17 | blue-ink-bricks 18 | boxes-iterative 19 | boxes-recursive 20 |

21 |

22 | cave 23 | color-bricks 24 | colored-plasma-noise-bricks 25 |

26 |

27 | color-fire 28 | color-flow 29 | color-grid 30 |

31 |

32 | drag-color 33 | fading-color 34 | fading-landscape 35 |

36 |

37 | fire-flow 38 | fire-path 39 | fire 40 |

41 |

42 | fog 43 | large-slow-swoosh 44 | paint 45 |

46 |

47 | plasma-bricks 48 | plasma 49 | sand 50 |

51 |

52 | smoke 53 | spiral 54 | star-swoosh 55 |

56 |

57 | swoosh 58 | triangles 59 | very-smooth 60 |

61 |

62 | waves 63 |

64 | -------------------------------------------------------------------------------- /misc/pull-and-crop-screenshot.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | SD_FILE="/sdcard/screenshot.png" 3 | FILE="screenshot-$(date +%s).png" 4 | adb shell screencap -p "$SD_FILE" 5 | adb pull "$SD_FILE" "$FILE" 6 | adb shell rm "$SD_FILE" 7 | convert "$FILE" -crop 1080x1920+0+230 +repage -resize 540x960 "$FILE" 8 | -------------------------------------------------------------------------------- /screenshots/blue-ink-bricks.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/blue-ink-bricks.png -------------------------------------------------------------------------------- /screenshots/boxes-iterative.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/boxes-iterative.png -------------------------------------------------------------------------------- /screenshots/boxes-recursive.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/boxes-recursive.png -------------------------------------------------------------------------------- /screenshots/cave.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/cave.png -------------------------------------------------------------------------------- /screenshots/color-bricks.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/color-bricks.png -------------------------------------------------------------------------------- /screenshots/color-fire.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/color-fire.png -------------------------------------------------------------------------------- /screenshots/color-flow.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/color-flow.png -------------------------------------------------------------------------------- /screenshots/color-grid.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/color-grid.png -------------------------------------------------------------------------------- /screenshots/colored-plasma-noise-bricks.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/colored-plasma-noise-bricks.png -------------------------------------------------------------------------------- /screenshots/drag-color.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/drag-color.png -------------------------------------------------------------------------------- /screenshots/fading-color.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/fading-color.png -------------------------------------------------------------------------------- /screenshots/fading-landscape.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/fading-landscape.png -------------------------------------------------------------------------------- /screenshots/fire-flow.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/fire-flow.png -------------------------------------------------------------------------------- /screenshots/fire-path.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/fire-path.png -------------------------------------------------------------------------------- /screenshots/fire.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/fire.png -------------------------------------------------------------------------------- /screenshots/fog.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/fog.png -------------------------------------------------------------------------------- /screenshots/large-slow-swoosh.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/large-slow-swoosh.png -------------------------------------------------------------------------------- /screenshots/paint.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/paint.png -------------------------------------------------------------------------------- /screenshots/plasma-bricks.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/plasma-bricks.png -------------------------------------------------------------------------------- /screenshots/plasma.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/plasma.png -------------------------------------------------------------------------------- /screenshots/sand.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/sand.png -------------------------------------------------------------------------------- /screenshots/smoke.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/smoke.png -------------------------------------------------------------------------------- /screenshots/spiral.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/spiral.png -------------------------------------------------------------------------------- /screenshots/star-swoosh.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/star-swoosh.png -------------------------------------------------------------------------------- /screenshots/swoosh.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/swoosh.png -------------------------------------------------------------------------------- /screenshots/triangles.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/triangles.png -------------------------------------------------------------------------------- /screenshots/very-smooth.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/very-smooth.png -------------------------------------------------------------------------------- /screenshots/waves.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cipold/lwp-shaders/9dc96594a604fb925284b52bd7c422cccb1dda15/screenshots/waves.png -------------------------------------------------------------------------------- /shaders/blue-ink-bricks.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | uniform vec2 resolution; 8 | uniform sampler2D backbuffer; 9 | uniform sampler2D noise; 10 | uniform int pointerCount; 11 | uniform vec3 pointers[10]; 12 | uniform float time; 13 | uniform float startRandom; 14 | 15 | // constants 16 | const float pi = 3.1415926536; 17 | const float pi2 = 2.0 * pi; 18 | 19 | // helpers 20 | vec3 hsv2rgb(vec3 c) { 21 | vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 22 | vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); 23 | return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); 24 | } 25 | vec2 angleToVec(float rad) { 26 | return vec2(sin(rad), cos(rad)); 27 | } 28 | float noise2(vec2 p) { 29 | p += startRandom; 30 | const int STEPS = 2; 31 | float n = 0.0; 32 | float fTotal = 0.0; 33 | for (int i = 0; i < STEPS; ++i) { 34 | float f = pow(0.5, float(i)); 35 | n += (2.0 * texture2D(noise, 36 | pow(0.33, float(i)) * 5.0 * p + 50.0 * time 37 | + angleToVec(pi2 * float(i + 1) * 50.0 * time) 38 | ).r - 1.0) * f; 39 | fTotal += f; 40 | } 41 | return clamp(1.0 * n / fTotal, -1.0, 1.0); 42 | } 43 | 44 | void main(void) { 45 | // misc 46 | vec2 axy = gl_FragCoord.xy; 47 | vec2 rxy = resolution.xy; 48 | float mxy = max(rxy.x, rxy.y); 49 | vec2 uv = axy / rxy.xy; 50 | vec2 xy = axy / mxy; 51 | 52 | // flow pattern 53 | const float rows = 7.0; 54 | const float cols = 7.0; 55 | const float df = 0.005; 56 | int col = int(uv.x * cols + 0.5); 57 | float px = cols * uv.x; 58 | float py = rows * uv.y; 59 | float pxp = px * 2.0 * pi + pi; 60 | float pyp = py * 2.0 * pi + pi * float(col); 61 | float sctpx = sin(pxp); 62 | float srtpy = sin(pyp); 63 | float cc = min(abs(sin(0.5 * pxp)), abs(sin(0.5 * pyp))); 64 | float ccf = clamp(0.97 + 0.1 * pow(1.0 - cc, 10.0), 0.0, 1.0); 65 | 66 | // smoothing kernel 67 | const int ksize = 3; 68 | const int c = ksize / 2; 69 | float kernel1d[ksize]; 70 | kernel1d[0] = 0.25; 71 | kernel1d[1] = 0.5; 72 | kernel1d[2] = 0.25; 73 | float kernel2d[ksize * ksize]; 74 | for (int i = 0; i < ksize; i++) { 75 | for (int j = 0; j < ksize; j++) { 76 | kernel2d[i * ksize + j] = kernel1d[i] * kernel1d[j]; 77 | } 78 | } 79 | 80 | // color 81 | float alpha = 0.0; 82 | for (int i = 0; i < ksize; i++) { 83 | for (int j = 0; j < ksize; j++) { 84 | alpha += kernel2d[i * ksize + j] * (1.0 - texture2D(backbuffer, 85 | uv + df * vec2(sctpx, srtpy) + vec2(i - c, j - c) / rxy.xy 86 | ).a); 87 | } 88 | } 89 | 90 | // fade to black 91 | alpha -= 0.002; 92 | 93 | // touch 94 | for (int n = 0; n < pointerCount; ++n) { 95 | alpha += pow(1.0 - clamp(abs(10.0 * distance(xy, pointers[n].xy / mxy) - 0.5), 0.0, 1.0), 25.0); 96 | } 97 | 98 | // misc 99 | alpha *= ccf; 100 | float aa = 1.0 - alpha; 101 | vec3 color = hsv2rgb(vec3( 102 | 0.6 - 0.1 * aa, 103 | 1.0 - pow(aa, 3.0), 104 | pow(aa, 0.3) 105 | )); 106 | gl_FragColor = vec4(color, 1.0 - alpha); 107 | } 108 | -------------------------------------------------------------------------------- /shaders/boxes-iterative.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | uniform vec2 resolution; 8 | uniform sampler2D noise; 9 | uniform float time; 10 | uniform sampler2D backbuffer; 11 | uniform int pointerCount; 12 | uniform vec3 pointers[10]; 13 | 14 | vec3 hsv2rgb(vec3 c) { 15 | vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 16 | vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); 17 | return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); 18 | } 19 | 20 | void main(void) { 21 | float mx = max(resolution.x, resolution.y); 22 | vec2 xy = gl_FragCoord.xy / resolution.xy; 23 | vec2 uv = gl_FragCoord.xy / mx; 24 | const int ch = 9; 25 | const int cv = 16; 26 | int r = int(xy.x * float(ch)); 27 | int c = int(xy.y * float(cv)); 28 | int levels = 4; 29 | float rand = 0.0; 30 | for (int l = 0; l < levels; l++) { 31 | int scale = int(pow(3.0, float(l)) + 0.5); 32 | int chl = ch * scale; 33 | int cvl = cv * scale; 34 | float rl = float(int(xy.x * float(chl))) / float(chl) * float(scale); 35 | float cl = float(int(xy.y * float(cvl))) / float(chl) * float(scale); 36 | rand += texture2D(noise, vec2( 37 | 0.25 + 0.5 * rl + 0.1 * sin(0.01 * time), 38 | 0.25 + 0.5 * cl + 0.1 * cos(0.01 * time) 39 | )).r / float(l + 1); 40 | } 41 | vec3 color = hsv2rgb(vec3(0.5 + 0.08 * rand, 0.9, 0.4)); 42 | for (int n = 0; n < pointerCount; ++n) { 43 | vec2 p = pointers[n].xy / resolution.xy; 44 | int pr = int(p.x * float(ch)); 45 | int pc = int(p.y * float(cv)); 46 | if (pr == r && pc == c) { 47 | color += vec3(1.0) * 0.1; 48 | } 49 | } 50 | gl_FragColor = vec4(color, 1.0); 51 | } 52 | -------------------------------------------------------------------------------- /shaders/boxes-recursive.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | uniform vec2 resolution; 8 | uniform sampler2D noise; 9 | uniform float time; 10 | uniform sampler2D backbuffer; 11 | uniform int pointerCount; 12 | uniform vec3 pointers[10]; 13 | 14 | vec3 hsv2rgb(vec3 c) { 15 | vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 16 | vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); 17 | return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); 18 | } 19 | 20 | void main(void) { 21 | float mx = max(resolution.x, resolution.y); 22 | vec2 xy = gl_FragCoord.xy / resolution.xy; 23 | vec2 uv = gl_FragCoord.xy / mx; 24 | const int ch = 9; 25 | const int cv = 16; 26 | int r = int(xy.x * float(ch)); 27 | int c = int(xy.y * float(cv)); 28 | float rand = texture2D(noise, vec2( 29 | 0.25 + 0.5 * float(r) / float(ch) + 0.1 * sin(0.01 * time), 30 | 0.25 + 0.5 * float(c) / float(cv) + 0.1 * cos(0.01 * time) 31 | )).r; 32 | vec3 color = hsv2rgb(vec3(0.5 + 0.15 * rand, 0.9, 0.4)); 33 | color = mix(color, texture2D(backbuffer, mod(xy * 3.0, 1.0)).rgb, 0.6); 34 | for (int n = 0; n < pointerCount; ++n) { 35 | vec2 p = pointers[n].xy / resolution.xy; 36 | int pr = int(p.x * float(ch)); 37 | int pc = int(p.y * float(cv)); 38 | if (pr == r && pc == c) { 39 | color += vec3(1.0) * 0.2; 40 | } 41 | } 42 | gl_FragColor = vec4(color, 1.0); 43 | } 44 | -------------------------------------------------------------------------------- /shaders/cave.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | uniform sampler2D noise; 8 | uniform float time; 9 | uniform vec2 resolution; 10 | uniform sampler2D backbuffer; 11 | uniform int pointerCount; 12 | uniform float startRandom; 13 | 14 | bool ami(float x, float y) { 15 | vec2 xy = gl_FragCoord.xy; 16 | return xy.x >= x - 0.5 && xy.x <= x + 0.5 && xy.y >= y - 0.5 && xy.y <= y + 0.5; 17 | } 18 | 19 | vec3 cave(vec2 ab) { 20 | return vec3(0.2 * texture2D(noise, ab * 1.5 + vec2(0.2 * time, 0.0)).r); 21 | } 22 | 23 | vec3 wall(vec2 ab, float dist) { 24 | return vec3(0.004 / dist, dist, 0.4) * (0.7 + 0.3 * texture2D(noise, ab * 0.5 + vec2(0.14 * time, 0.0)).r); 25 | } 26 | 27 | vec3 player(vec2 ab) { 28 | return vec3(1.0, 1.0, 0.0); 29 | } 30 | 31 | vec2 level(float x) { 32 | float ls = 0.02 * (1.0 + 0.005 * time); 33 | float p = mod(x * 0.025 + time * ls, 3.1415); 34 | float lv = texture2D(noise, vec2(0.5) + 0.5 * vec2(sin(p), cos(p)) + vec2(startRandom)).r * 0.3; 35 | float d = 0.25 - 0.001 * time; 36 | return vec2(0.6 - d / 2. + lv, 0.6 + d / 2. + lv); 37 | } 38 | 39 | void main(void) { 40 | bool touched = pointerCount > 0; 41 | 42 | // pixel 43 | vec2 xy = gl_FragCoord.xy; 44 | vec2 dr = 1. / resolution.xy; 45 | float mxy = max(resolution.x, resolution.y); 46 | float ar = resolution.y / resolution.x; 47 | vec2 uv = xy * dr; 48 | vec2 ab = xy / mxy; 49 | 50 | // color 51 | vec3 color = texture2D(backbuffer, uv).rgb; 52 | float alpha = texture2D(backbuffer, uv).a; 53 | 54 | // player 55 | float hpos = 0.1; 56 | float vpos = texture2D(backbuffer, vec2(0., 0.) * dr).a; 57 | float psize = 0.01; 58 | 59 | // level 60 | vec2 lv = level(uv.x); 61 | vec2 pv = level(hpos * ar); 62 | 63 | if (vpos < pv.x || vpos > pv.y) { 64 | // game over 65 | if (texture2D(backbuffer, vec2(0., 0.) * dr).b > 0.03) { 66 | color = vec3(1., 0., 0.); 67 | alpha = 0.; 68 | } else { 69 | color -= 0.01; 70 | } 71 | 72 | if (color.r < 0.1 && touched) { 73 | // reset 74 | if (ami(0., 0.)) { 75 | alpha = 0.6 + (pv.x + pv.y) * dr.y * 0.5; 76 | } 77 | } 78 | } else { 79 | // draw player and level 80 | if (distance(ab, vec2(hpos, vpos)) < psize) { 81 | color = player(ab); 82 | } else { 83 | color = uv.y < lv.x || uv.y > lv.y ? wall(ab, min(abs(uv.y - lv.x), abs(uv.y - lv.y))) : cave(ab); 84 | } 85 | 86 | // control 87 | float speed = (touched ? 0.003 : - 0.003); 88 | if (ami(0., 0.)) { 89 | alpha += speed; 90 | } 91 | } 92 | 93 | gl_FragColor = vec4(color, alpha); 94 | } 95 | -------------------------------------------------------------------------------- /shaders/color-bricks.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | uniform vec2 resolution; 8 | uniform sampler2D backbuffer; 9 | uniform int pointerCount; 10 | uniform vec3 pointers[10]; 11 | uniform float time; 12 | 13 | const float pi = 3.1415926536; 14 | 15 | vec3 hsv2rgb(vec3 c) { 16 | vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 17 | vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); 18 | return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); 19 | } 20 | 21 | void main(void) { 22 | // misc 23 | vec2 axy = gl_FragCoord.xy; 24 | vec2 rxy = resolution.xy; 25 | float mxy = max(rxy.x, rxy.y); 26 | vec2 uv = axy / rxy.xy; 27 | vec2 xy = axy / mxy; 28 | const float rows = 7.0; 29 | const float cols = 7.0; 30 | int col = int(uv.x * cols + 0.5); 31 | float sctpx = sin(cols * 2.0 * pi * uv.x + pi); 32 | float srtpy = sin(rows * 2.0 * pi * uv.y + pi * float(col)); 33 | 34 | // smoothing kernel 35 | const int ksize = 3; 36 | const int c = ksize / 2; 37 | float kernel1d[ksize]; 38 | kernel1d[0] = 0.25; 39 | kernel1d[1] = 0.5; 40 | kernel1d[2] = 0.25; 41 | float kernel2d[ksize * ksize]; 42 | for (int i = 0; i < ksize; i++) { 43 | for (int j = 0; j < ksize; j++) { 44 | kernel2d[i * ksize + j] = kernel1d[i] * kernel1d[j]; 45 | } 46 | } 47 | 48 | // color 49 | vec3 color = vec3(0.002); 50 | for (int i = 0; i < ksize; i++) { 51 | for (int j = 0; j < ksize; j++) { 52 | color += kernel2d[i * ksize + j] * texture2D(backbuffer, 53 | uv + 54 | 0.005 * vec2(sctpx, srtpy) + 55 | vec2(i - c, j - c) / rxy.xy 56 | ).rgb; 57 | } 58 | } 59 | 60 | // fade to black 61 | color *= 0.97; 62 | color -= vec3(0.01); 63 | 64 | // touch 65 | for (int n = 0; n < pointerCount; ++n) { 66 | float dist = distance(xy, pointers[n].xy / mxy); 67 | float i = pow(1.0 - min(1.0, max(0.0, abs(10.0 * dist - 0.5))), 10.0); 68 | color += vec3(hsv2rgb(vec3(mod(0.2 * time + 0.3 * float(n), 1.0), 1.0, i))) * 1.0; 69 | } 70 | 71 | // misc 72 | gl_FragColor = vec4(color, 1.0); 73 | } 74 | -------------------------------------------------------------------------------- /shaders/color-fire.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | uniform vec2 resolution; 8 | uniform sampler2D backbuffer; 9 | uniform float time; 10 | uniform sampler2D noise; 11 | uniform int pointerCount; 12 | uniform vec3 pointers[10]; 13 | 14 | vec3 hsv2rgb(vec3 c) { 15 | vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 16 | vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); 17 | return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); 18 | } 19 | 20 | void main(void) { 21 | float mx = max(resolution.x, resolution.y); 22 | vec2 uv = gl_FragCoord.xy / resolution.xy; 23 | vec2 xy = gl_FragCoord.xy / mx; 24 | float last = texture2D(backbuffer, uv).r; 25 | float x = 10.0 * (last + 1.0 * (texture2D(noise, uv).r - 0.5)) * 3.1415926536; 26 | vec3 flow = texture2D(backbuffer, uv + 0.001 * vec2(sin(x), cos(x))).rgb; 27 | vec3 color = mix(vec3(0.0), flow, 0.98); 28 | for (int n = 0; n < pointerCount; ++n) { 29 | vec2 p = pointers[n].xy / mx; 30 | float dist = distance(xy, p); 31 | float i = pow(1.0 - min(1.0, max(0.0, 32 | abs(6.0 * dist - 0.5) 33 | )), 3.0); 34 | color += hsv2rgb(vec3(time, 1.0, i)) * 0.2; 35 | } 36 | gl_FragColor = vec4(color, 1.0); 37 | } 38 | -------------------------------------------------------------------------------- /shaders/color-flow.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | uniform vec2 resolution; 8 | uniform sampler2D backbuffer; 9 | uniform float time; 10 | uniform sampler2D noise; 11 | uniform int pointerCount; 12 | uniform vec3 pointers[10]; 13 | 14 | const float pi = 3.1415; 15 | 16 | vec3 hsv2rgb(vec3 c) { 17 | vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 18 | vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); 19 | return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); 20 | } 21 | vec2 angle(float rad) { 22 | return vec2(sin(rad), cos(rad)); 23 | } 24 | 25 | void main(void) { 26 | float mxy = max(resolution.x, resolution.y); 27 | vec2 uv = gl_FragCoord.xy / resolution.xy; 28 | vec2 xy = gl_FragCoord.xy / mxy; 29 | vec2 direction = angle(texture2D(noise, 0.07 * xy + 0.001 * time).r * 8.0 * pi); 30 | vec3 flow = texture2D(backbuffer, uv + 0.005 * direction).rgb; 31 | vec3 color = mix(flow, vec3(0.0), 0.01) - 0.01; 32 | for (int n = 0; n < pointerCount; ++n) { 33 | float dist = distance(xy, pointers[n].xy / mxy); 34 | float i = pow(1.0 - min(1.0, max(0.0, abs(30.0 * dist - 2.0))), 3.0); 35 | color += vec3(hsv2rgb(vec3(mod(0.2 * time + 0.3 * float(n), 1.0), 1.0, i))) * 1.0; 36 | } 37 | gl_FragColor = vec4(color, 1.0); 38 | } 39 | -------------------------------------------------------------------------------- /shaders/color-grid.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | uniform vec2 resolution; 8 | uniform sampler2D backbuffer; 9 | uniform int pointerCount; 10 | uniform vec3 pointers[10]; 11 | uniform float time; 12 | 13 | const float pi = 3.1415926536; 14 | 15 | vec3 hsv2rgb(vec3 c) { 16 | vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 17 | vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); 18 | return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); 19 | } 20 | 21 | void main(void) { 22 | // misc 23 | vec2 axy = gl_FragCoord.xy; 24 | vec2 rxy = resolution.xy; 25 | float mxy = max(rxy.x, rxy.y); 26 | vec2 uv = axy / rxy.xy; 27 | vec2 xy = axy / mxy; 28 | 29 | // kernel 30 | const int ksize = 3; 31 | const int c = ksize / 2; 32 | float kernel1d[ksize]; 33 | kernel1d[0] = 0.25; 34 | kernel1d[1] = 0.5; 35 | kernel1d[2] = 0.25; 36 | float kernel2d[ksize * ksize]; 37 | for (int i = 0; i < ksize; i++) { 38 | for (int j = 0; j < ksize; j++) { 39 | kernel2d[i * ksize + j] = kernel1d[i] * kernel1d[j]; 40 | } 41 | } 42 | 43 | // color * kernel 44 | vec3 color = vec3(0.0); 45 | for (int i = 0; i < ksize; i++) { 46 | for (int j = 0; j < ksize; j++) { 47 | color += kernel2d[i * ksize + j] * texture2D(backbuffer, 48 | uv + 49 | 0.005 * vec2(sin(15.0 * pi * uv.x), cos(15.0 * pi * uv.y)) + 50 | vec2(i - c, j - c) / rxy.xy 51 | ).rgb; 52 | } 53 | } 54 | 55 | // fade 56 | color *= 0.99; 57 | color -= vec3(0.002); 58 | 59 | // touch 60 | for (int n = 0; n < pointerCount; ++n) { 61 | float dist = distance(xy, pointers[n].xy / mxy); 62 | float i = pow(1.0 - min(1.0, max(0.0, abs(10.0 * dist))), 3.0); 63 | color += vec3(hsv2rgb(vec3(mod(0.2 * time + 0.3 * float(n), 1.0), 1.0, i))) * 1.0; 64 | } 65 | 66 | // misc 67 | gl_FragColor = vec4(color, 1.0); 68 | } 69 | -------------------------------------------------------------------------------- /shaders/colored-plasma-noise-bricks.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | uniform vec2 resolution; 8 | uniform sampler2D backbuffer; 9 | uniform sampler2D noise; 10 | uniform int pointerCount; 11 | uniform vec3 pointers[10]; 12 | uniform float time; 13 | uniform float startRandom; 14 | 15 | // comstants 16 | const float pi = 3.1415926536; 17 | const float pi2 = 2.0 * pi; 18 | 19 | // helpers 20 | vec3 hsv2rgb(vec3 c) { 21 | vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 22 | vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); 23 | return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); 24 | } 25 | vec2 angleToVec(float rad) { 26 | return vec2(sin(rad), cos(rad)); 27 | } 28 | float noise2(vec2 p) { 29 | p += startRandom; 30 | const int STEPS = 2; 31 | float n = 0.0; 32 | float fTotal = 0.0; 33 | for (int i = 0; i < STEPS; ++i) { 34 | float f = pow(0.5, float(i)); 35 | n += (2.0 * texture2D(noise, 36 | pow(0.33, float(i)) * 5.0 * p + 50.0 * time 37 | + angleToVec(pi2 * float(i + 1) * 50.0 * time) 38 | ).r - 1.0) * f; 39 | fTotal += f; 40 | } 41 | return clamp(1.0 * n / fTotal, -1.0, 1.0); 42 | } 43 | 44 | void main(void) { 45 | // misc 46 | vec2 axy = gl_FragCoord.xy; 47 | vec2 rxy = resolution.xy; 48 | float mxy = max(rxy.x, rxy.y); 49 | vec2 uv = axy / rxy.xy; 50 | vec2 xy = axy / mxy; 51 | 52 | // flow pattern 53 | const float rows = 7.0; 54 | const float cols = 7.0; 55 | const float df = 0.005; 56 | float col = floor(uv.x * cols + 0.5); 57 | float row = floor(uv.y * rows + 0.5 + 0.5 * mod(col + 1.0, 2.0)); 58 | float px = cols * uv.x; 59 | float py = rows * uv.y; 60 | float pxp = px * 2.0 * pi + pi; 61 | float pyp = py * 2.0 * pi + pi * float(col); 62 | float sctpx = sin(pxp); 63 | float srtpy = sin(pyp); 64 | float cc = min(abs(sin(0.5 * pxp)), abs(sin(0.5 * pyp))); 65 | float ccf = clamp(0.97 + 0.1 * pow(1.0 - cc, 10.0), 0.0, 1.0); 66 | 67 | // smoothing kernel 68 | const int ksize = 3; 69 | const int c = ksize / 2; 70 | float kernel1d[ksize]; 71 | kernel1d[0] = 0.25; 72 | kernel1d[1] = 0.5; 73 | kernel1d[2] = 0.25; 74 | float kernel2d[ksize * ksize]; 75 | for (int i = 0; i < ksize; i++) { 76 | for (int j = 0; j < ksize; j++) { 77 | kernel2d[i * ksize + j] = kernel1d[i] * kernel1d[j]; 78 | } 79 | } 80 | 81 | // color 82 | float alpha = 0.0; 83 | for (int i = 0; i < ksize; i++) { 84 | for (int j = 0; j < ksize; j++) { 85 | alpha += kernel2d[i * ksize + j] * (1.0 - texture2D(backbuffer, 86 | uv + df * vec2(sctpx, srtpy) + vec2(i - c, j - c) / rxy.xy 87 | ).a); 88 | } 89 | } 90 | 91 | // fade to black 92 | alpha -= 0.002; 93 | 94 | // touch 95 | for (int n = 0; n < pointerCount; ++n) { 96 | alpha += pow(1.0 - clamp(abs(10.0 * distance(xy, pointers[n].xy / mxy) - 0.5), 0.0, 1.0), 25.0); 97 | } 98 | 99 | // misc 100 | alpha *= ccf; 101 | float aa = alpha + 0.1 * noise2(xy) * pow(alpha, 0.5); 102 | vec3 color = hsv2rgb(vec3( 103 | 0.6 - 0.1 * aa + 0.065 * (col + row * cols) + 0.01 * time, 104 | 1.0 - pow(aa, 3.0), 105 | pow(aa, 0.3) 106 | )); 107 | gl_FragColor = vec4(color, 1.0 - alpha); 108 | } 109 | -------------------------------------------------------------------------------- /shaders/drag-color.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | uniform sampler2D backbuffer; 8 | uniform int pointerCount; 9 | uniform vec3 pointers[10]; 10 | uniform vec2 resolution; 11 | 12 | void main(void) { 13 | float mxy = max(resolution.x, resolution.y); 14 | vec2 uv = gl_FragCoord.xy / resolution.xy; 15 | vec2 xy = gl_FragCoord.xy / mxy; 16 | vec4 last = texture2D(backbuffer, uv); 17 | vec3 color = vec3(last.a, last.r, last.g); 18 | float alpha = last.b * 0.5; 19 | for (int n = 0; n < pointerCount; ++n) { 20 | float radius = 0.1; 21 | float dist = distance(xy, pointers[n].xy / mxy); 22 | float i = 1.0 - min(1.0, max(0.0, abs(dist / radius))); 23 | alpha += i * 1.0; 24 | } 25 | gl_FragColor = vec4(color, alpha); 26 | } 27 | -------------------------------------------------------------------------------- /shaders/fading-color.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | uniform vec2 resolution; 8 | uniform sampler2D backbuffer; 9 | uniform int pointerCount; 10 | uniform vec3 pointers[10]; 11 | uniform float time; 12 | 13 | vec3 hsv2rgb(vec3 c) { 14 | vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 15 | vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); 16 | return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); 17 | } 18 | 19 | void main(void) { 20 | // misc 21 | vec2 axy = gl_FragCoord.xy; 22 | vec2 rxy = resolution.xy; 23 | float mxy = max(rxy.x, rxy.y); 24 | vec2 uv = axy / rxy.xy; 25 | vec2 xy = axy / mxy; 26 | 27 | // kernel 28 | const int ksize = 3; 29 | const int c = ksize / 2; 30 | float kernel1d[ksize]; 31 | kernel1d[0] = 0.25; 32 | kernel1d[1] = 0.5; 33 | kernel1d[2] = 0.25; 34 | float kernel2d[ksize * ksize]; 35 | for (int i = 0; i < ksize; i++) { 36 | for (int j = 0; j < ksize; j++) { 37 | kernel2d[i * ksize + j] = kernel1d[i] * kernel1d[j]; 38 | } 39 | } 40 | 41 | // color * kernel 42 | vec3 color = vec3(0.0); 43 | for (int i = 0; i < ksize; i++) { 44 | for (int j = 0; j < ksize; j++) { 45 | color += kernel2d[i * ksize + j] * texture2D(backbuffer, uv + vec2(i - c, j - c) / rxy.xy).rgb; 46 | } 47 | } 48 | 49 | // fade 50 | color *= 0.99; 51 | color -= vec3(0.001); 52 | 53 | // touch 54 | for (int n = 0; n < pointerCount; ++n) { 55 | float dist = distance(xy, pointers[n].xy / mxy); 56 | float i = pow(1.0 - min(1.0, max(0.0, abs(10.0 * dist - 0.7))), 30.0); 57 | color += vec3(hsv2rgb(vec3(mod(0.2 * time + 0.3 * float(n), 1.0), 1.0, i))) * 1.0; 58 | } 59 | 60 | // misc 61 | gl_FragColor = vec4(color, 1.0); 62 | } 63 | -------------------------------------------------------------------------------- /shaders/fading-landscape.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | uniform vec2 resolution; 8 | uniform sampler2D backbuffer; 9 | uniform float time; 10 | uniform sampler2D noise; 11 | uniform int pointerCount; 12 | uniform vec3 pointers[10]; 13 | uniform float startRandom; 14 | 15 | const float pi = 3.14159265359; 16 | const int steps = 4; 17 | const float div = 1.0 / float(steps + 1); 18 | 19 | vec3 hsv2rgb(vec3 c) { 20 | vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 21 | vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); 22 | return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); 23 | } 24 | vec2 fromAngle(float rad) { 25 | return vec2(sin(rad), cos(rad)); 26 | } 27 | float toAngle(vec2 v) { 28 | return atan(v.x, v.y); 29 | } 30 | float toAngle(vec2 a, vec2 b) { 31 | return toAngle(a - b); 32 | } 33 | float cos01(float v) { 34 | return 0.5 + 0.5 * cos(v); 35 | } 36 | float noise2(vec2 p) { 37 | float n = texture2D(noise, p).r * div; 38 | for (int i = 0; i < steps; ++i) { 39 | n += texture2D(noise, p + 0.0001 * fromAngle(2.0 * pi * float(i) * div)).r * div; 40 | } 41 | return n; 42 | } 43 | vec2 grad(vec2 p, float dx, float dy) { 44 | return vec2( 45 | noise2(p + vec2(dx, 0)) - noise2(p - vec2(dx, 0)), 46 | noise2(p + vec2(0, dy)) - noise2(p - vec2(0, dy)) 47 | ); 48 | } 49 | 50 | void main(void) { 51 | float mxy = max(resolution.x, resolution.y); 52 | vec2 uv = gl_FragCoord.xy / resolution.xy; 53 | vec2 xy = gl_FragCoord.xy / mxy; 54 | const float scale = 0.05; 55 | const float hSteps = 5.0; 56 | const float hStep = 1.0 / hSteps; 57 | vec2 off = scale * xy + startRandom; 58 | float alpha = texture2D(backbuffer, uv).a; 59 | if (alpha >= 1.0) alpha = noise2(off); 60 | float h = alpha; 61 | h = float(int(h * hSteps + 0.5)) / hSteps; 62 | h += hStep * pow(mod(h, hStep) / hStep, 100.0); 63 | vec3 color = vec3(0.1); 64 | color += 0.05 * (texture2D(noise, 10.0 * uv).rgb - 0.5); 65 | color += hsv2rgb(vec3(0.45 + 0.1 * h, 0.8 + 0.2 * cos01(10.0 * h * pi), h)); 66 | alpha = mix(alpha, 0.0, 0.05 * pow(texture2D(noise, 100.0 * xy + vec2(sin(100.0 * time), cos(111.0 * time))).r, 5.0)); 67 | for (int n = 0; n < pointerCount; ++n) { 68 | float dist = distance(xy, pointers[n].xy / mxy); 69 | alpha += 0.3 * pow(1.0 - min(1.0, max(0.0, 2.0 * dist)), 30.0); 70 | } 71 | alpha = min(alpha, 0.99); 72 | gl_FragColor = vec4(color, alpha); 73 | } 74 | -------------------------------------------------------------------------------- /shaders/fire-flow.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | // inputs 8 | uniform vec2 resolution; 9 | uniform sampler2D backbuffer; 10 | uniform float time; 11 | uniform sampler2D noise; 12 | uniform int pointerCount; 13 | uniform vec3 pointers[10]; 14 | uniform float startRandom; 15 | uniform vec3 gravity; 16 | uniform vec3 linear; 17 | 18 | // comstants 19 | const float PI = 3.1415; 20 | const float PI2 = 2.0 * PI; 21 | 22 | // helper functions 23 | vec3 hsv2rgb(vec3 c) { 24 | vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 25 | vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); 26 | return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); 27 | } 28 | vec2 angleToVec(float rad) { 29 | return vec2(sin(rad), cos(rad)); 30 | } 31 | float vecToAngle(vec2 v) { 32 | return atan(v.x, v.y); 33 | } 34 | float noise2(vec2 p) { 35 | const int STEPS = 3; 36 | const float DIV = 1.0 / float(STEPS + 1); 37 | float n = texture2D(noise, p).r * DIV; 38 | for (int i = 0; i < STEPS; ++i) { 39 | n += texture2D(noise, p + 0.0001 * angleToVec(PI2 * float(i) * DIV)).r * DIV; 40 | } 41 | return n; 42 | } 43 | 44 | void main(void) { 45 | // misc 46 | float mxy = max(resolution.x, resolution.y); 47 | vec2 uv = gl_FragCoord.xy / resolution.xy; 48 | vec2 xy = gl_FragCoord.xy / mxy; 49 | 50 | // landscape 51 | float n = noise2(0.05 * xy + 0.0001 * time + startRandom); 52 | 53 | // flow from last value along landscape 54 | float flow = 1.0 - texture2D(backbuffer, 55 | uv + 0.004 * angleToVec(n * 4.0 * PI2 + vecToAngle(gravity.xy)) 56 | ).a; 57 | 58 | // fade 59 | flow = mix(flow, 0.0, 0.02) - 0.002; 60 | flow = max(flow, 0.0); 61 | 62 | // touch 63 | for (int n = 0; n < pointerCount; ++n) { 64 | float dist = distance(xy, pointers[n].xy / mxy); 65 | flow += pow(1.0 - min(1.0, max(0.0, 2.0 * dist)), 30.0); 66 | } 67 | 68 | // glow 69 | flow = min(flow, 1.0); 70 | 71 | // background 72 | vec3 color = vec3(0.15); 73 | 74 | // visualize flow 75 | color += hsv2rgb(vec3(0.15 * flow, 1.0, pow(flow, 0.35))); 76 | 77 | // height lines 78 | color += n > 0.4 && n < 0.5 ? 0.05 : 0.0; 79 | color += n > 0.1 && n < 0.17 ? 0.05 : 0.0; 80 | 81 | // noise 82 | color += 0.1 * (texture2D(noise, 10.0 * uv).r - 0.5); 83 | 84 | // misc 85 | gl_FragColor = vec4(color, 1.0 - flow); 86 | } 87 | -------------------------------------------------------------------------------- /shaders/fire-path.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | // inputs 8 | uniform vec2 resolution; 9 | uniform sampler2D backbuffer; 10 | uniform float time; 11 | uniform sampler2D noise; 12 | uniform int pointerCount; 13 | uniform vec3 pointers[10]; 14 | uniform float startRandom; 15 | uniform vec3 gravity; 16 | uniform vec3 linear; 17 | 18 | // comstants 19 | const float PI = 3.1415; 20 | const float PI2 = 2.0 * PI; 21 | 22 | // helper functions 23 | vec3 hsv2rgb(vec3 c) { 24 | vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 25 | vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); 26 | return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); 27 | } 28 | vec2 angleToVec(float rad) { 29 | return vec2(sin(rad), cos(rad)); 30 | } 31 | float vecToAngle(vec2 v) { 32 | return atan(v.x, v.y); 33 | } 34 | float noise2(vec2 p) { 35 | return 0.5 + 0.5 * sin(15.0 * p.x) + sin(10.0 * p.y);; 36 | const int STEPS = 3; 37 | const float DIV = 1.0 / float(STEPS + 1); 38 | float n = texture2D(noise, p).r * DIV; 39 | for (int i = 0; i < STEPS; ++i) { 40 | n += texture2D(noise, p + 0.0001 * angleToVec(PI2 * float(i) * DIV)).r * DIV; 41 | } 42 | return n; 43 | } 44 | float step(float v, float s) { 45 | return float(int(v / s)) * s; 46 | } 47 | float sin01(float v) { 48 | return 0.5 + 0.5 * sin(v); 49 | } 50 | 51 | void main(void) { 52 | // misc 53 | float mxy = max(resolution.x, resolution.y); 54 | vec2 uv = gl_FragCoord.xy / resolution.xy; 55 | vec2 xy = gl_FragCoord.xy / mxy; 56 | 57 | // magic 58 | vec2 p = xy + 0.05 * (vec2( 59 | noise2(xy + 0.5 * startRandom + 0.003 * time) + noise2(3.0 * xy + 0.005 * time), 60 | noise2(xy + startRandom + 0.003 * time) + noise2(3.0 * xy) 61 | ) - 0.5); 62 | float a = PI * pow( 63 | sin01(8.0 * PI * p.x) + 64 | sin01(8.0 * PI * p.y), 65 | 2.0); 66 | float flow = 1.0 - texture2D(backbuffer, 67 | uv + 0.003 * angleToVec(a) 68 | ).a; 69 | 70 | // fade 71 | flow = mix(flow, 0.0, 0.00) - 0.003; 72 | flow = max(flow, 0.0); 73 | 74 | // touch 75 | for (int i = 0; i < pointerCount; ++i) { 76 | float dist = distance(xy, pointers[i].xy / mxy); 77 | flow += pow(1.0 - min(1.0, max(0.0, 2.0 * dist)), 30.0); 78 | } 79 | flow = min(flow, 1.0); 80 | 81 | // background 82 | vec3 color = vec3(0.15); 83 | 84 | // visualize flow 85 | color += hsv2rgb(vec3(0.15 * flow, 1.0, pow(flow, 0.35))); 86 | 87 | // height lines 88 | color += 0.1 * (a > 0.1 && a < 0.15 ? 1.0 : 0.0); 89 | color += 0.1 * (a > 8.9 && a < 9.2 ? 1.0 : 0.0); 90 | color += 0.1 * (a > 4.0 && a < 4.3 ? 1.0 : 0.0); 91 | 92 | // noise 93 | color += 0.1 * (texture2D(noise, 10.0 * uv).r - 0.5); 94 | 95 | // misc 96 | gl_FragColor = vec4(color, 1.0 - flow); 97 | } 98 | -------------------------------------------------------------------------------- /shaders/fire.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | uniform vec2 resolution; 8 | uniform sampler2D backbuffer; 9 | uniform float time; 10 | uniform sampler2D noise; 11 | uniform int pointerCount; 12 | uniform vec3 pointers[10]; 13 | 14 | void main(void) { 15 | float mx = max(resolution.x, resolution.y); 16 | vec2 uv = gl_FragCoord.xy / resolution.xy; 17 | vec2 xy = gl_FragCoord.xy / mx; 18 | vec3 color = vec3(0.3, 0.0, 0.0); 19 | float last = texture2D(backbuffer, uv).r; 20 | float x = 10.0 * (last + 1.0 * (texture2D(noise, uv).r - 0.5)) * 3.1415926536; 21 | vec3 flow = texture2D(backbuffer, uv + 0.001 * vec2(sin(x), cos(x))).rgb; 22 | color = mix(color, flow, 0.99); 23 | for (int n = 0; n < pointerCount; ++n) { 24 | vec2 p = pointers[n].xy / mx; 25 | float dist = distance(xy, p); 26 | float i = pow(1.0 - min(1.0, max(0.0, 27 | abs(5.0 * dist) 28 | )), 10.0); 29 | color += vec3(i, i, 0.0) * 0.5; 30 | } 31 | gl_FragColor = vec4(color, 1.0); 32 | } 33 | -------------------------------------------------------------------------------- /shaders/fog.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | uniform vec2 resolution; 8 | uniform sampler2D backbuffer; 9 | uniform float time; 10 | uniform sampler2D noise; 11 | 12 | void main(void) { 13 | vec2 uv = gl_FragCoord.xy / resolution.xy; 14 | vec2 xy = gl_FragCoord.xy / max(resolution.x, resolution.y); 15 | vec3 color = texture2D( 16 | noise, 17 | xy - vec2(sin(time * 0.1), cos(time * 0.1)) 18 | ).rgb; 19 | float last = texture2D(backbuffer, uv).r; 20 | vec3 flow = texture2D(backbuffer, uv + 0.002 * vec2(sin(last * 3.131), cos(last * 3.141))).rgb; 21 | color = mix(color, flow, 0.9); 22 | gl_FragColor = vec4(color, 1.0); 23 | } 24 | -------------------------------------------------------------------------------- /shaders/large-slow-swoosh.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | // input 8 | uniform vec2 resolution; 9 | uniform sampler2D backbuffer; 10 | uniform int pointerCount; 11 | uniform vec3 pointers[10]; 12 | uniform float time; 13 | 14 | // constants 15 | const float pi = 3.1415; 16 | const float pi2 = 2.0 * pi; 17 | 18 | // functions 19 | vec3 hsv2rgb(vec3 c) { 20 | vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 21 | vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); 22 | return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); 23 | } 24 | float angle(vec2 a, vec2 b) { 25 | vec2 d = a - b; 26 | return atan(d.x, d.y); 27 | } 28 | float lim(float mn, float mx, float v) { 29 | return max(mn, min(mx, v)); 30 | } 31 | float sin01(float v) { 32 | return 0.5 + 0.5 * sin(v); 33 | } 34 | 35 | void main(void) { 36 | // misc 37 | vec2 axy = gl_FragCoord.xy; 38 | vec2 rxy = resolution.xy; 39 | float mxy = max(rxy.x, rxy.y); 40 | vec2 uv = axy / rxy.xy; 41 | vec2 xy = axy / mxy; 42 | 43 | // touch 44 | vec3 color = vec3(0.0); 45 | for (int n = 0; n < pointerCount; ++n) { 46 | vec2 pxy = pointers[n].xy / mxy; 47 | const float s = 2.0; 48 | const float e = 6.0; 49 | float d = 1.5 * distance(xy, pxy); 50 | float a = angle(xy, pxy) + 1.7 * float(n); 51 | float a1 = a - 0.5 * time; 52 | float a2 = a + s * time; 53 | color += hsv2rgb(vec3( 54 | a1 / pi2, 1.0, 55 | min(1.0, 20.0 * pow(sin01(e * (a2 - 0.04 / d * sin(30.0 * d))), 50.0 * d) * 56 | pow(sin01(-0.5 * pi + lim(0.0, pi2, 20.0 * d)), 10.0)) 57 | )); 58 | } 59 | 60 | // misc 61 | gl_FragColor = vec4(color, 1.0); 62 | } 63 | -------------------------------------------------------------------------------- /shaders/paint.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | uniform sampler2D backbuffer; 8 | uniform int pointerCount; 9 | uniform vec3 pointers[10]; 10 | uniform vec2 resolution; 11 | 12 | vec3 hsv2rgb(vec3 c) { 13 | vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 14 | vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); 15 | return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); 16 | } 17 | 18 | // paint 19 | void main(void) { 20 | float selTop = 0.15; 21 | float selBot = 0.1; 22 | float mxy = max(resolution.x, resolution.y); 23 | vec2 uv = gl_FragCoord.xy / resolution.xy; 24 | vec2 xy = gl_FragCoord.xy / mxy; 25 | vec3 color = texture2D(backbuffer, uv).rgb; 26 | if (uv.y < selTop) { 27 | // color selector 28 | if (uv.y > selBot) { 29 | color = hsv2rgb(vec3(uv.x, 1.0, 1.0)); 30 | } else { 31 | for (int n = 0; n < pointerCount; ++n) { 32 | vec2 p = pointers[n].xy / resolution.xy; 33 | if (p.y < selTop && p.y > selBot) { 34 | color = hsv2rgb(vec3(p.x, 1.0, 1.0)); 35 | } 36 | } 37 | } 38 | } else { 39 | // paint 40 | for (int n = 0; n < pointerCount; ++n) { 41 | vec2 p = pointers[n].xy / mxy; 42 | float radius = 0.03; 43 | float dist = distance(xy, p); 44 | float i = 1.0 - min(1.0, max(0.0, abs(dist / radius))); 45 | color += i * texture2D(backbuffer, vec2(0)).rgb; 46 | } 47 | } 48 | gl_FragColor = vec4(color, 1.0); 49 | } 50 | -------------------------------------------------------------------------------- /shaders/plasma-bricks.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | uniform vec2 resolution; 8 | uniform sampler2D backbuffer; 9 | uniform sampler2D noise; 10 | uniform int pointerCount; 11 | uniform vec3 pointers[10]; 12 | uniform float time; 13 | uniform float startRandom; 14 | 15 | // comstants 16 | const float pi = 3.1415926536; 17 | const float pi2 = 2.0 * pi; 18 | 19 | // helpers 20 | vec3 hsv2rgb(vec3 c) { 21 | vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 22 | vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); 23 | return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); 24 | } 25 | vec2 angleToVec(float rad) { 26 | return vec2(sin(rad), cos(rad)); 27 | } 28 | float noise2(vec2 p) { 29 | p += startRandom; 30 | const int STEPS = 2; 31 | float n = 0.0; 32 | float fTotal = 0.0; 33 | for (int i = 0; i < STEPS; ++i) { 34 | float f = pow(0.5, float(i)); 35 | n += (2.0 * texture2D(noise, 36 | pow(0.33, float(i)) * 5.0 * p + 50.0 * time 37 | + angleToVec(pi2 * float(i + 1) * 50.0 * time) 38 | ).r - 1.0) * f; 39 | fTotal += f; 40 | } 41 | return clamp(1.0 * n / fTotal, -1.0, 1.0); 42 | } 43 | 44 | void main(void) { 45 | // misc 46 | vec2 axy = gl_FragCoord.xy; 47 | vec2 rxy = resolution.xy; 48 | float mxy = max(rxy.x, rxy.y); 49 | vec2 uv = axy / rxy.xy; 50 | vec2 xy = axy / mxy; 51 | 52 | // flow pattern 53 | const float rows = 7.0; 54 | const float cols = 7.0; 55 | const float df = 0.005; 56 | int col = int(uv.x * cols + 0.5); 57 | float px = cols * uv.x; 58 | float py = rows * uv.y; 59 | float pxp = px * 2.0 * pi + pi; 60 | float pyp = py * 2.0 * pi + pi * float(col); 61 | float sctpx = sin(pxp); 62 | float srtpy = sin(pyp); 63 | float cc = min(abs(sin(0.5 * pxp)), abs(sin(0.5 * pyp))); 64 | float ccf = clamp(0.97 + 0.1 * pow(1.0 - cc, 10.0), 0.0, 1.0); 65 | 66 | // smoothing kernel 67 | const int ksize = 3; 68 | const int c = ksize / 2; 69 | float kernel1d[ksize]; 70 | kernel1d[0] = 0.25; 71 | kernel1d[1] = 0.5; 72 | kernel1d[2] = 0.25; 73 | float kernel2d[ksize * ksize]; 74 | for (int i = 0; i < ksize; i++) { 75 | for (int j = 0; j < ksize; j++) { 76 | kernel2d[i * ksize + j] = kernel1d[i] * kernel1d[j]; 77 | } 78 | } 79 | 80 | // color 81 | float alpha = 0.0; 82 | for (int i = 0; i < ksize; i++) { 83 | for (int j = 0; j < ksize; j++) { 84 | alpha += kernel2d[i * ksize + j] * (1.0 - texture2D(backbuffer, 85 | uv + df * vec2(sctpx, srtpy) + vec2(i - c, j - c) / rxy.xy 86 | ).a); 87 | } 88 | } 89 | 90 | // fade to black 91 | alpha -= 0.002; 92 | 93 | // touch 94 | for (int n = 0; n < pointerCount; ++n) { 95 | alpha += pow(1.0 - clamp(abs(10.0 * distance(xy, pointers[n].xy / mxy) - 0.5), 0.0, 1.0), 25.0); 96 | } 97 | 98 | // misc 99 | alpha *= ccf; 100 | float aa = alpha; 101 | vec3 color = hsv2rgb(vec3( 102 | 0.6 - 0.1 * aa, 103 | 1.0 - pow(aa, 3.0), 104 | pow(aa, 0.3) 105 | )); 106 | gl_FragColor = vec4(color, 1.0 - alpha); 107 | } 108 | -------------------------------------------------------------------------------- /shaders/plasma.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | uniform float time; 8 | uniform int pointerCount; 9 | uniform vec3 pointers[10]; 10 | uniform vec2 resolution; 11 | uniform sampler2D backbuffer; 12 | uniform float startRandom; 13 | 14 | void main(void) { 15 | const float pi = 3.1415926536; 16 | float mx = max(resolution.x, resolution.y); 17 | vec2 uv = gl_FragCoord.xy / mx; 18 | vec2 xy = vec2( 19 | gl_FragCoord.x / resolution.x, 20 | gl_FragCoord.y / resolution.y 21 | ); 22 | vec2 c = vec2(0.5, 0.5); 23 | float s = 0.99; 24 | vec3 lastBg = texture2D( 25 | backbuffer, 26 | (0.5 + 0.4 * vec2(sin(uv.x * 3.0 * pi), cos(uv.y * 3.0 * pi)) - c) * s + c 27 | ).rgb; 28 | float t = (time + startRandom * 100.0) * 0.02; 29 | float tm = mod(t, 1.0); 30 | float p = 1.0 / 4.0; 31 | float up = mod(tm, p) / p; 32 | float down = 1.0 - up; 33 | int i = int(tm / p); 34 | vec3 bgColor = vec3( 35 | i == 0 ? up : (i == 1 ? 1.0 : (i == 2 ? down : 0.0)), 36 | i == 1 ? up : (i == 2 ? 1.0 : (i == 3 ? down : 0.0)), 37 | i == 2 ? up : (i == 3 ? 1.0 : (i == 0 ? down : 0.0)) 38 | ) * 0.4; 39 | vec3 color = mix(lastBg, bgColor, 0.4); 40 | color += 0.1 * pow(0.5 + 0.5 * sin(xy.x * 7.0 + time * 0.2 + xy.y * 8.0), 1000.0); 41 | for (int n = 0; n < pointerCount; ++n) { 42 | vec2 p = pointers[n].xy / mx; 43 | float dist = distance(uv, p); 44 | color += vec3( 45 | pow(1.0 - min(1.0, max(0.0, 46 | abs(10.0 * (dist + 0.01 * sin(atan((p - uv).x, (p - uv).y) * 3.0 + 2.0 * time + float(5 * n) )) - 0.7) 47 | )), 30.0) 48 | ) * 0.1; 49 | } 50 | gl_FragColor = vec4(color, 1.0); 51 | } 52 | -------------------------------------------------------------------------------- /shaders/sand.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | // input 8 | uniform vec2 resolution; 9 | uniform sampler2D backbuffer; 10 | uniform float time; 11 | uniform sampler2D noise; 12 | uniform int pointerCount; 13 | uniform vec3 pointers[10]; 14 | 15 | void main(void) { 16 | // misc 17 | float mx = max(resolution.x, resolution.y); 18 | vec2 uv = gl_FragCoord.xy / resolution.xy; 19 | vec2 xy = gl_FragCoord.xy / mx; 20 | float hStep = 1.0 / float(resolution.x); 21 | float vStep = 1.0 / float(resolution.y); 22 | 23 | // surrounding 24 | vec3 last = texture2D(backbuffer, uv).rgb; 25 | vec3 above = texture2D(backbuffer, uv + vec2(0.0, vStep)).rgb; 26 | vec3 left = texture2D(backbuffer, uv + vec2(-hStep, 0)).rgb; 27 | vec3 right = texture2D(backbuffer, uv + vec2(hStep, 0)).rgb; 28 | vec3 tworight = texture2D(backbuffer, uv + vec2(2.0 * hStep, 0)).rgb; 29 | vec3 twoleft = texture2D(backbuffer, uv + vec2(2.0 * -hStep, 0)).rgb; 30 | vec3 abovel = texture2D(backbuffer, uv + vec2(-hStep, vStep)).rgb; 31 | vec3 abover = texture2D(backbuffer, uv + vec2(hStep, vStep)).rgb; 32 | vec3 below = texture2D(backbuffer, uv + vec2(0.0, -vStep)).rgb; 33 | vec3 belowl = texture2D(backbuffer, uv + vec2(-hStep, -vStep)).rgb; 34 | vec3 belowr = texture2D(backbuffer, uv + vec2(hStep, -vStep)).rgb; 35 | vec3 below2l = texture2D(backbuffer, uv + vec2(2.0 * -hStep, -vStep)).rgb; 36 | 37 | // logic 38 | vec3 color; 39 | if (gl_FragCoord.y <= 0.5) { 40 | color = vec3(1.0); 41 | } else { 42 | color = last; 43 | if (last.r >= 0.5) { 44 | if (below.r <= 0.5 || 45 | belowl.r <= 0.5 && left.r <= 0.5 && (below2l.r <= 0.5 || twoleft.r <= 0.5) || 46 | belowr.r <= 0.5 && right.r <= 0.5 47 | ) color = vec3(0.0); 48 | } else { 49 | if (above.r >= 0.5) color = above; 50 | else if (abovel.r >= 0.5 && left.r >= 0.5) color = abovel; 51 | else if (abover.r >= 0.5 && right.r >= 0.5 && tworight.r >= 0.5) color = abover; 52 | } 53 | } 54 | 55 | // touch 56 | for (int n = 0; n < pointerCount; ++n) { 57 | if (distance(gl_FragCoord.xy, pointers[n].xy) < 10.0) { 58 | color += vec3(1.0); 59 | } 60 | } 61 | 62 | // misc 63 | gl_FragColor = vec4(color, 1.0); 64 | } 65 | -------------------------------------------------------------------------------- /shaders/smoke.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | uniform vec2 resolution; 8 | uniform sampler2D backbuffer; 9 | uniform float time; 10 | uniform sampler2D noise; 11 | uniform int pointerCount; 12 | uniform vec3 pointers[10]; 13 | 14 | void main(void) { 15 | float mx = max(resolution.x, resolution.y); 16 | vec2 uv = gl_FragCoord.xy / resolution.xy; 17 | vec2 xy = gl_FragCoord.xy / mx; 18 | vec3 color = vec3(0.5); 19 | float last = texture2D(backbuffer, uv + 0.01 * (texture2D(noise, uv).rg - 0.5)).r; 20 | float x = last * 2000.0 * 3.1415; 21 | vec3 flow = texture2D(backbuffer, uv + 0.002 * vec2(sin(x), cos(x))).rgb; 22 | color = mix(flow, texture2D(noise, uv).rgb, 0.01); 23 | for (int n = 0; n < pointerCount; ++n) { 24 | float dist = distance(xy, pointers[n].xy / mx); 25 | color += vec3(pow(1.0 - min(1.0, max(0.0, abs(10.0 * dist - 0.7))), 30.0)) * 1.0; 26 | } 27 | gl_FragColor = vec4(color, 1.0); 28 | } 29 | -------------------------------------------------------------------------------- /shaders/spiral.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | uniform vec2 resolution; 8 | uniform sampler2D backbuffer; 9 | uniform int pointerCount; 10 | uniform vec3 pointers[10]; 11 | uniform float time; 12 | const float pi = 3.1415; 13 | 14 | vec3 hsv2rgb(vec3 c) { 15 | vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 16 | vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); 17 | return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); 18 | } 19 | float angle(vec2 a, vec2 b) { 20 | vec2 d = a - b; 21 | return atan(d.x, d.y); 22 | } 23 | 24 | void main(void) { 25 | // misc 26 | vec2 axy = gl_FragCoord.xy; 27 | vec2 rxy = resolution.xy; 28 | float mxy = max(rxy.x, rxy.y); 29 | vec2 uv = axy / rxy.xy; 30 | vec2 xy = axy / mxy; 31 | 32 | // kernel 33 | const int ksize = 5; 34 | const int c = ksize / 2; 35 | float kernel1d[ksize]; 36 | kernel1d[0] = 0.5; 37 | kernel1d[1] = 0.0; 38 | kernel1d[2] = 0.0; 39 | kernel1d[3] = 0.0; 40 | kernel1d[4] = 0.5; 41 | float kernel2d[ksize * ksize]; 42 | for (int i = 0; i < ksize; i++) { 43 | for (int j = 0; j < ksize; j++) { 44 | kernel2d[i * ksize + j] = kernel1d[i] * kernel1d[j]; 45 | } 46 | } 47 | 48 | // color 49 | vec3 color = vec3(0.0); 50 | 51 | // touch 52 | for (int n = 0; n < pointerCount; ++n) { 53 | float dist = distance(xy, pointers[n].xy / mxy); 54 | float i = pow(1.0 - min(1.0, max(0.0, abs(30.0 * dist - 2.0))), 3.0); 55 | float a = angle(xy, pointers[n].xy / mxy); 56 | color += hsv2rgb(vec3(a / (2.0 * pi), 1.0, pow(0.5 + 0.5 * sin(6.0 * (a + pi / 12.0 + time - sin(dist))), 20.0))); 57 | } 58 | 59 | // misc 60 | gl_FragColor = vec4(color, 1.0); 61 | } 62 | -------------------------------------------------------------------------------- /shaders/star-swoosh.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | // input 8 | uniform vec2 resolution; 9 | uniform sampler2D backbuffer; 10 | uniform int pointerCount; 11 | uniform vec3 pointers[10]; 12 | uniform float time; 13 | 14 | // constants 15 | const float pi = 3.1415; 16 | const float pi2 = 2.0 * pi; 17 | 18 | // functions 19 | vec3 hsv2rgb(vec3 c) { 20 | vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 21 | vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); 22 | return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); 23 | } 24 | float angle(vec2 a, vec2 b) { 25 | vec2 d = a - b; 26 | return atan(d.x, d.y); 27 | } 28 | float lim(float mn, float mx, float v) { 29 | return max(mn, min(mx, v)); 30 | } 31 | float sin01(float v) { 32 | return 0.5 + 0.5 * sin(v); 33 | } 34 | 35 | void main(void) { 36 | // misc 37 | vec2 axy = gl_FragCoord.xy; 38 | vec2 rxy = resolution.xy; 39 | float mxy = max(rxy.x, rxy.y); 40 | vec2 uv = axy / rxy.xy; 41 | vec2 xy = axy / mxy; 42 | 43 | // kernel 44 | const int ksize = 3; 45 | const int c = ksize / 2; 46 | float kernel1d[ksize]; 47 | kernel1d[0] = 0.25; 48 | kernel1d[1] = 0.5; 49 | kernel1d[2] = 0.25; 50 | float kernel2d[ksize * ksize]; 51 | for (int i = 0; i < ksize; i++) { 52 | for (int j = 0; j < ksize; j++) { 53 | kernel2d[i * ksize + j] = kernel1d[i] * kernel1d[j]; 54 | } 55 | } 56 | 57 | // color * kernel 58 | vec3 color = vec3(0.0); 59 | for (int i = 0; i < ksize; i++) { 60 | for (int j = 0; j < ksize; j++) { 61 | color += kernel2d[i * ksize + j] * 62 | texture2D(backbuffer, 63 | uv + vec2(i - c, j - c) / rxy.xy 64 | ).rgb; 65 | } 66 | } 67 | 68 | // fade 69 | color *= 0.99; 70 | color -= vec3(0.001); 71 | 72 | // touch 73 | vec3 touch; 74 | for (int n = 0; n < pointerCount; ++n) { 75 | vec2 pxy = pointers[n].xy / mxy; 76 | const float s = 3.0; 77 | const float e = 6.0; 78 | float d = 1.5 * distance(xy, pxy) + 0.05 * sin01(s * e * time - time); 79 | float a = angle(xy, pxy) + 1.7 * float(n); 80 | float a1 = a - 0.5 * time; 81 | float a2 = a + s * time; 82 | touch += hsv2rgb(vec3( 83 | a1 / pi2, 1.0, 84 | pow(sin01(e * (a2 - 0.04 / d * sin(30.0 * d))), 50.0 * d) * 85 | pow(sin01(-0.5 * pi + lim(0.0, pi2, 20.0 * d)), 10.0) 86 | )); 87 | } 88 | 89 | // misc 90 | gl_FragColor = vec4(max(color, touch), 1.0); 91 | } 92 | -------------------------------------------------------------------------------- /shaders/swoosh.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | // input 8 | uniform vec2 resolution; 9 | uniform sampler2D backbuffer; 10 | uniform int pointerCount; 11 | uniform vec3 pointers[10]; 12 | uniform float time; 13 | 14 | // constants 15 | const float pi = 3.1415; 16 | const float pi2 = 2.0 * pi; 17 | 18 | // functions 19 | vec3 hsv2rgb(vec3 c) { 20 | vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 21 | vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); 22 | return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); 23 | } 24 | float angle(vec2 a, vec2 b) { 25 | vec2 d = a - b; 26 | return atan(d.x, d.y); 27 | } 28 | float lim(float mn, float mx, float v) { 29 | return max(mn, min(mx, v)); 30 | } 31 | float sin01(float v) { 32 | return 0.5 + 0.5 * sin(v); 33 | } 34 | 35 | void main(void) { 36 | // misc 37 | vec2 axy = gl_FragCoord.xy; 38 | vec2 rxy = resolution.xy; 39 | float mxy = max(rxy.x, rxy.y); 40 | vec2 uv = axy / rxy.xy; 41 | vec2 xy = axy / mxy; 42 | 43 | // kernel 44 | const int ksize = 3; 45 | const int c = ksize / 2; 46 | float kernel1d[ksize]; 47 | kernel1d[0] = 0.25; 48 | kernel1d[1] = 0.5; 49 | kernel1d[2] = 0.25; 50 | float kernel2d[ksize * ksize]; 51 | for (int i = 0; i < ksize; i++) { 52 | for (int j = 0; j < ksize; j++) { 53 | kernel2d[i * ksize + j] = kernel1d[i] * kernel1d[j]; 54 | } 55 | } 56 | 57 | // color * kernel 58 | vec3 color = vec3(0.0); 59 | for (int i = 0; i < ksize; i++) { 60 | for (int j = 0; j < ksize; j++) { 61 | color += kernel2d[i * ksize + j] * 62 | texture2D(backbuffer, 63 | uv + vec2(i - c, j - c) / rxy.xy 64 | ).rgb; 65 | } 66 | } 67 | 68 | // fade 69 | color *= 0.8; 70 | color -= vec3(0.01); 71 | 72 | // touch 73 | for (int n = 0; n < pointerCount; ++n) { 74 | vec2 pxy = pointers[n].xy / mxy; 75 | float d = 1.5 * distance(xy, pxy); 76 | float a = angle(xy, pxy) + 4.0 * time + 1.7 * float(n); 77 | color += hsv2rgb(vec3( 78 | a / pi2, 1.0, 79 | pow(sin01(6.0 * (a - 0.04 / d * sin(30.0 * d))), 50.0 * d) * 80 | pow(sin01(-0.5 * pi + lim(0.0, pi2, 20.0 * d)), 10.0) 81 | )); 82 | } 83 | 84 | // misc 85 | gl_FragColor = vec4(color, 1.0); 86 | } 87 | -------------------------------------------------------------------------------- /shaders/triangles.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | uniform vec2 resolution; 8 | uniform sampler2D noise; 9 | uniform float time; 10 | uniform sampler2D backbuffer; 11 | 12 | vec3 hsv2rgb(vec3 c) { 13 | vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 14 | vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); 15 | return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); 16 | } 17 | 18 | void main(void) { 19 | vec2 xy = gl_FragCoord.xy / resolution.xy; 20 | vec2 uv = gl_FragCoord.xy / max(resolution.x, resolution.y); 21 | vec2 ab = xy; 22 | const int ch = 10; 23 | const int cv = 10; 24 | int r = int(ab.x * float(ch)); 25 | int c = int(ab.y * float(cv)); 26 | if (mod(ab.y * float(cv), 2.0) < 1.0) { 27 | if (mod(ab.x * float(ch), 2.0) < 1.0) { 28 | r += int(mod(ab.x * float(ch) + ab.y * float(cv), 2.0)); 29 | } else { 30 | r += int(mod(ab.x * float(ch) - ab.y * float(cv), 2.0)); 31 | } 32 | } else { 33 | if (mod(ab.x * float(ch), 2.0) < 1.0) { 34 | r += int(mod(ab.x * float(ch) - ab.y * float(cv), 2.0)); 35 | } else { 36 | r += int(mod(ab.x * float(ch) + ab.y * float(cv), 2.0)); 37 | } 38 | } 39 | float rand = texture2D(noise, vec2( 40 | 0.25 + 0.5 * float(r) / float(ch) + 0.1 * sin(0.01 * time), 41 | 0.25 + 0.5 * float(c) / float(cv) + 0.1 * cos(0.01 * time) 42 | )).r; 43 | vec3 color = hsv2rgb(vec3(mod(0.35 + rand, 1.0), 1.0, 0.5)); 44 | color = mix(color, texture2D(backbuffer, mod(xy * 3.0, 1.0)).rgb, 0.6); 45 | gl_FragColor = vec4(color, 1.0); 46 | } 47 | -------------------------------------------------------------------------------- /shaders/very-smooth.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | uniform vec2 resolution; 8 | uniform sampler2D backbuffer; 9 | uniform int pointerCount; 10 | uniform vec3 pointers[10]; 11 | uniform float time; 12 | 13 | vec3 hsv2rgb(vec3 c) { 14 | vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); 15 | vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www); 16 | return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y); 17 | } 18 | 19 | void main(void) { 20 | // misc 21 | vec2 axy = gl_FragCoord.xy; 22 | vec2 rxy = resolution.xy; 23 | float mxy = max(rxy.x, rxy.y); 24 | vec2 uv = axy / rxy.xy; 25 | vec2 xy = axy / mxy; 26 | 27 | // kernel 28 | const int ksize = 5; 29 | const int c = ksize / 2; 30 | float kernel1d[ksize]; 31 | kernel1d[0] = 0.5; 32 | kernel1d[1] = 0.0; 33 | kernel1d[2] = 0.0; 34 | kernel1d[3] = 0.0; 35 | kernel1d[4] = 0.5; 36 | float kernel2d[ksize * ksize]; 37 | for (int i = 0; i < ksize; i++) { 38 | for (int j = 0; j < ksize; j++) { 39 | kernel2d[i * ksize + j] = kernel1d[i] * kernel1d[j]; 40 | } 41 | } 42 | 43 | // color * kernel 44 | vec3 color = vec3(0.0); 45 | for (int i = 0; i < ksize; i++) { 46 | for (int j = 0; j < ksize; j++) { 47 | color += kernel2d[i * ksize + j] * texture2D(backbuffer, uv + vec2(i - c, j - c) / rxy.xy).rgb; 48 | } 49 | } 50 | 51 | // fade 52 | color *= 0.999; 53 | color -= vec3(0.001); 54 | 55 | // touch 56 | for (int n = 0; n < pointerCount; ++n) { 57 | float dist = distance(xy, pointers[n].xy / mxy); 58 | float i = pow(1.0 - min(1.0, max(0.0, abs(30.0 * dist - 2.0))), 3.0); 59 | color += vec3(hsv2rgb(vec3(mod(0.2 * time + 0.3 * float(n), 1.0), 1.0, i))) * 1.0; 60 | } 61 | 62 | // misc 63 | gl_FragColor = vec4(color, 1.0); 64 | } 65 | -------------------------------------------------------------------------------- /shaders/waves.glsl: -------------------------------------------------------------------------------- 1 | #ifdef GL_FRAGMENT_PRECISION_HIGH 2 | precision highp float; 3 | #else 4 | precision mediump float; 5 | #endif 6 | 7 | uniform vec2 resolution; 8 | uniform sampler2D noise; 9 | uniform float time; 10 | 11 | void main(void) { 12 | vec2 uv = gl_FragCoord.xy / resolution.xy; 13 | int cols = 4; 14 | int rows = 6; 15 | float s = 0.01; 16 | float ts = 0.0002; 17 | float n1 = texture2D(noise, s * uv + ts * time).x 18 | + texture2D(noise, s * uv - ts * time).x; 19 | float n2 = 0.5 * texture2D(noise, s * uv + 0.5 + ts * time).x 20 | + 0.5 * texture2D(noise, s * uv + 0.5 - ts * time).x; 21 | int col = int((uv.x + uv.y + 0.3 * n1) * float(cols)); 22 | float rcol = float(col) / float(cols); 23 | int row = int((uv.y - uv.x + 0.3 * n2) * float(rows)); 24 | float rrow = float(row) / float(rows); 25 | float cs = float(row + col) / float(rows + cols); 26 | vec3 c = vec3(0.2 * cs, 0.7 * cs + 0.2, 0.5 * cs + 0.4); 27 | c += 0.1 * vec3(texture2D(noise, 10.0 * uv)); 28 | gl_FragColor = vec4(c, 1.0); 29 | } 30 | --------------------------------------------------------------------------------