├── .gitattributes ├── AA ├── .vscode │ └── settings.json └── AA.glsl ├── Fragment ├── Boxes.glsl ├── Cherry.glsl ├── Circles.glsl ├── Circles2.glsl ├── Circles3.glsl ├── Circles4.glsl ├── Circles5.glsl ├── Coaxial.glsl ├── Discs.glsl ├── Discs2.glsl ├── Discs3.glsl ├── Discs4.glsl ├── Dots1.glsl ├── Dots2.glsl ├── Dots3.glsl ├── Eyes.glsl ├── Eyes2.glsl ├── GradNoise1.glsl ├── GradNoise2.glsl ├── GradNoise3.glsl ├── Grid.glsl ├── Hex.glsl ├── Hex2.glsl ├── Hex3.glsl ├── Hex4.glsl ├── Hex5.glsl ├── Lattice.glsl ├── Lattice2.glsl ├── Lattice3.glsl ├── Lines.glsl ├── Noise.glsl ├── ReactDiffuse.glsl ├── Rows.glsl ├── Sliders.glsl ├── Spectrum.glsl ├── Spectrum2.glsl ├── Template.glsl ├── TestCard.glsl ├── Text.glsl ├── Text2.glsl ├── Text3.glsl ├── Tri.glsl ├── TriLattice.glsl ├── TriLattice2.glsl ├── TriLattice3.glsl ├── TriLattice4.glsl ├── TriLattice5.glsl ├── TriLattice6.glsl ├── TriLattice7.glsl ├── TriLattice8.glsl ├── ValueNoise.glsl ├── Waves.glsl └── Zebra.glsl ├── Images ├── Adventure.png ├── MonaLisa.jpg └── Primitive.png ├── Lines ├── .vscode │ └── settings.json └── Lines.glsl └── README.md /.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto 3 | 4 | # Custom for Visual Studio 5 | *.cs diff=csharp 6 | 7 | # Standard to msysgit 8 | *.doc diff=astextplain 9 | *.DOC diff=astextplain 10 | *.docx diff=astextplain 11 | *.DOCX diff=astextplain 12 | *.dot diff=astextplain 13 | *.DOT diff=astextplain 14 | *.pdf diff=astextplain 15 | *.PDF diff=astextplain 16 | *.rtf diff=astextplain 17 | *.RTF diff=astextplain 18 | -------------------------------------------------------------------------------- /AA/.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "shader-toy.textures": { 3 | "0": "file://C:/Users/keijiro/Documents/ShaderSketches/Images/Adventure.png" 4 | } 5 | } -------------------------------------------------------------------------------- /AA/AA.glsl: -------------------------------------------------------------------------------- 1 | const vec2 textureSize = vec2(128.0); 2 | 3 | vec2 QuantizeUV(vec2 uv) 4 | { 5 | return (floor(uv * textureSize) + 0.5) / textureSize; 6 | } 7 | 8 | float Luma(vec3 rgb) 9 | { 10 | return dot(rgb, vec3(0.2126, 0.7152, 0.0722)); 11 | } 12 | 13 | vec3 SampleTexture(vec2 uv) 14 | { 15 | return texture2D(iChannel0, uv, -1000.0).rgb; 16 | } 17 | 18 | vec3 AASample(vec2 uv, bool force2tap, bool mask) 19 | { 20 | vec2 duv = 1.0 / textureSize.xy; 21 | 22 | vec3 c0 = SampleTexture(uv); 23 | 24 | float l0 = Luma(c0); 25 | float l1 = Luma(SampleTexture(uv + duv * vec2(-0.5, -0.5))) + 1.0 / 384.0; 26 | float l2 = Luma(SampleTexture(uv + duv * vec2(+0.5, -0.5))); 27 | float l3 = Luma(SampleTexture(uv + duv * vec2(-0.5, +0.5))); 28 | float l4 = Luma(SampleTexture(uv + duv * vec2(+0.5, +0.5))); 29 | 30 | float l_max = max(max(max(l1, l2), l3), l4); 31 | float l_min = min(min(min(l1, l2), l3), l4); 32 | float contrast = max(l0, l_max) - min(l0, l_min); 33 | if (contrast < max(0.05, 0.125 * l_max)) return c0; 34 | 35 | if (mask) return vec3(1.0, 0.0, 0.0); 36 | 37 | vec2 dir1 = normalize(vec2((l3 + l4) - (l1 + l2), (l2 + l4) - (l1 + l3))); 38 | vec2 dir2 = clamp(dir1 / (min(abs(dir1.x), abs(dir1.y)) * 8.0), -2.0, 2.0); 39 | 40 | vec3 c1a = SampleTexture(uv - duv * dir1 * 0.5); 41 | vec3 c1b = SampleTexture(uv + duv * dir1 * 0.5); 42 | vec3 c2a = SampleTexture(uv - duv * dir2 * 2.0); 43 | vec3 c2b = SampleTexture(uv + duv * dir2 * 2.0); 44 | 45 | vec3 c_2tap = (c1a + c1b) * 0.5; 46 | vec3 c_4tap = (c1a + c1b + c2a + c2b) * 0.25; 47 | float l_4tap = Luma(c_4tap); 48 | return (l_4tap < l_min || l_max < l_4tap || force2tap) ? c_2tap : c_4tap; 49 | } 50 | 51 | void main() 52 | { 53 | vec2 uv = QuantizeUV(gl_FragCoord.xy / iResolution.xy * 2.0); 54 | 55 | if (uv.y < 1.0) 56 | if (uv.x < 1.0) 57 | gl_FragColor.rgb = AASample(fract(uv), true, false); 58 | else 59 | gl_FragColor.rgb = AASample(fract(uv), false, false); 60 | else 61 | if (uv.x < 1.0) 62 | gl_FragColor.rgb = SampleTexture(fract(uv)); 63 | else 64 | gl_FragColor.rgb = AASample(fract(uv), false, true); 65 | } -------------------------------------------------------------------------------- /Fragment/Boxes.glsl: -------------------------------------------------------------------------------- 1 | float circle(vec2 coord, vec2 offs) 2 | { 3 | float reso = 16.0; 4 | float cw = iResolution.x / reso; 5 | 6 | vec2 p = mod(coord, cw) - cw * 0.5 + offs * cw; 7 | 8 | vec2 p2 = floor(coord / cw) - offs; 9 | vec2 gr = vec2(0.193, 0.272); 10 | float tr = iGlobalTime * 2.0; 11 | float ts = tr + dot(p2, gr); 12 | 13 | float sn = sin(tr), cs = cos(tr); 14 | p = mat2(cs, -sn, sn, cs) * p; 15 | 16 | float s = cw * (0.3 + 0.3 * sin(ts)); 17 | float d = max(abs(p.x), abs(p.y)); 18 | 19 | return max(0.0, 1.0 - abs(s - d)); 20 | } 21 | 22 | void main() 23 | { 24 | float c = 0.0; 25 | 26 | for (int i = 0; i < 9; i++) 27 | { 28 | float dx = mod(float(i), 3.0) - 1.0; 29 | float dy = float(i / 3) - 1.0; 30 | c += circle(gl_FragCoord.xy, vec2(dx, dy)); 31 | } 32 | 33 | gl_FragColor = vec4(vec3(min(1.0, c)), 1); 34 | } -------------------------------------------------------------------------------- /Fragment/Cherry.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | out vec4 fragColor; 6 | 7 | float rand(vec2 uv) 8 | { 9 | return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453); 10 | } 11 | 12 | void main(void) 13 | { 14 | const float pi = 3.1415926; 15 | float scale = resolution.y / 5; 16 | 17 | vec2 p = gl_FragCoord.xy / scale; 18 | float t = time * 0.6 + rand(floor(p)) * 200; 19 | 20 | float s2 = 1.6 + 0.6 * sin(t); 21 | p = (fract(p) - 0.5) * s2; // repeat and scale 22 | scale /= s2; 23 | 24 | float d1 = 1e6; // distance field (petal) 25 | float d2 = 0; // distance field (cut) 26 | 27 | for (int i = 0; i < 5; i++) 28 | { 29 | float phi = pi * (2.0 * i / 5 + 0.1) + t; 30 | 31 | vec2 v1 = vec2(cos(phi), sin(phi)); // outward vector 32 | vec2 v2 = vec2(-v1.y, v1.x); // vertical vector 33 | vec2 v3 = vec2(cos(phi - 1), sin(phi - 1)); // cut line 1 34 | vec2 v4 = vec2(cos(phi + 1), sin(phi + 1)); // cut line 2 35 | 36 | d1 = min(d1, max(distance(p, v1 * 0.27 - v2 * 0.15), 37 | distance(p, v1 * 0.27 + v2 * 0.15))); 38 | 39 | d2 = max(d2, min(dot(v3, p) - dot(v3, v1 * 0.4), 40 | dot(v4, p) - dot(v4, v1 * 0.4))); 41 | } 42 | 43 | vec2 c12 = vec2(1) - vec2(d1 - 0.29, d2) * scale; 44 | vec3 c = max(vec3(1, 0.7, 0.7) + p.y, 0) * min(c12.x, c12.y); 45 | 46 | fragColor = vec4(c, 1); 47 | } 48 | -------------------------------------------------------------------------------- /Fragment/Circles.glsl: -------------------------------------------------------------------------------- 1 | float circle(vec2 coord, vec2 offs) 2 | { 3 | float reso = 16.0; 4 | float cw = iResolution.x / reso; 5 | 6 | vec2 p = mod(coord, cw) + offs * cw; 7 | float d = distance(p, vec2(cw / 2.0)); 8 | 9 | vec2 p2 = floor(coord / cw) - offs; 10 | vec2 gr = vec2(0.443, 0.312); 11 | float t = iGlobalTime * 2.0 + dot(p2, gr); 12 | 13 | float l = cw * (sin(t) + 1.2) * 0.4; 14 | float lw = 1.5; 15 | return max(0.0, 1.0 - abs(l - d) / lw); 16 | } 17 | 18 | void main() 19 | { 20 | float c = 0.0; 21 | for (int i = 0; i < 9; i++) 22 | { 23 | float dx = mod(float(i), 3.0) - 1.0; 24 | float dy = float(i / 3) - 1.0; 25 | c += circle(gl_FragCoord.xy, vec2(dx, dy)); 26 | } 27 | gl_FragColor = vec4(vec3(min(1.0, c)), 1); 28 | } -------------------------------------------------------------------------------- /Fragment/Circles2.glsl: -------------------------------------------------------------------------------- 1 | float circle(vec2 coord, vec2 seed) 2 | { 3 | float reso = 16.0; 4 | float cw = iResolution.x / reso; 5 | 6 | vec2 p = mod(coord, cw); 7 | float d = distance(p, vec2(cw / 2.0)); 8 | 9 | float rnd = dot(floor(coord / cw), seed); 10 | float t = iGlobalTime * 2.0 + fract(sin(rnd)) * 6.2; 11 | 12 | float l = cw * (sin(t) * 0.25 + 0.25); 13 | return clamp(l - d, 0.0, 1.0); 14 | } 15 | 16 | void main() 17 | { 18 | vec2 p = gl_FragCoord.xy; 19 | vec2 dp = vec2(7.9438, 0.3335) * iGlobalTime; 20 | float c1 = circle(p - dp, vec2(323.443, 412.312)); 21 | float c2 = circle(p + dp, vec2(878.465, 499.173)); 22 | float c = max(0.0, c1 - c2); 23 | gl_FragColor = vec4(c, c, c, 1); 24 | } -------------------------------------------------------------------------------- /Fragment/Circles3.glsl: -------------------------------------------------------------------------------- 1 | float circle(vec2 coord, float spd) 2 | { 3 | float reso = 12.0; 4 | float cw = iResolution.x / reso; 5 | 6 | vec2 p = mod(coord, cw); 7 | float d = distance(p, vec2(cw / 2.0)); 8 | 9 | float rnd = dot(floor(coord / cw), vec2(1323.443, 1412.312)); 10 | float t = iGlobalTime * 2.0 + fract(sin(rnd)) * 6.2; 11 | 12 | float l = cw * (sin(t * spd) * 0.25 + 0.25); 13 | return clamp(l - d, 0.0, 1.0); 14 | } 15 | 16 | void main() 17 | { 18 | vec2 p = gl_FragCoord.xy; 19 | vec2 dp = vec2(7.9438, 1.3335) * iGlobalTime; 20 | float c1 = circle(p - dp, 1.0); 21 | float c2 = circle(p + dp, 1.4); 22 | float c = max(0.0, abs(c1 - c2)); 23 | gl_FragColor = vec4(c, c, c, 1); 24 | } -------------------------------------------------------------------------------- /Fragment/Circles4.glsl: -------------------------------------------------------------------------------- 1 | #define MONOCHROME 1 2 | 3 | vec3 circle(vec2 coord, float bias) 4 | { 5 | float repeat = sin(iGlobalTime * 0.4) * 10.0 + 30.0; 6 | 7 | float interval = iResolution.x / repeat; 8 | vec2 center = iResolution.xy * 0.5; 9 | 10 | float dist1 = distance(coord, center); 11 | float num = max(floor(dist1 / interval + 0.5) + bias, 1.0); 12 | float radius = num * interval; 13 | 14 | float phase1 = iGlobalTime * 3.0 + radius * 0.04; 15 | float phase2 = phase1 * 1.3426; 16 | vec2 offs = vec2(sin(phase1), cos(phase2)) * interval * 0.5; 17 | float dist2 = distance(coord, center + offs); 18 | 19 | float width = interval * 0.33; 20 | float c = clamp(width * 0.5 - abs(radius - dist2), 0.0, 1.0); 21 | 22 | #if MONOCHROME 23 | return vec3(1, 1, 1) * c; 24 | #else 25 | float c_r = 0.7 + 0.2 * sin(phase1 * 0.12); 26 | float c_g = 0.5 + 0.2 * sin(phase1 * 0.34); 27 | float c_b = 0.3 + 0.2 * sin(phase1 * 0.176); 28 | return vec3(c_r, c_g, c_b) * c; 29 | #endif 30 | } 31 | 32 | void main() 33 | { 34 | vec2 p = gl_FragCoord.xy; 35 | vec3 c1 = circle(p, -1.0); 36 | vec3 c2 = circle(p, 0.0); 37 | vec3 c3 = circle(p, 1.0); 38 | gl_FragColor = vec4(max(max(c1, c2), c3), 1); 39 | } -------------------------------------------------------------------------------- /Fragment/Circles5.glsl: -------------------------------------------------------------------------------- 1 | float circles(vec2 coord) 2 | { 3 | float reso = 5.0; 4 | float width = iResolution.x / reso; 5 | 6 | vec2 center = floor(coord / width + 0.5) * width; 7 | float dist = distance(coord, center); 8 | 9 | float time = iGlobalTime * 0.9; 10 | float phase = dot(center, vec2(1.647346, 7.323874)); 11 | float radius = width * (0.3 + sin(time + phase) * 0.16); 12 | 13 | return dist - radius; 14 | } 15 | 16 | float line(vec2 coord, float seed) 17 | { 18 | vec2 dir = vec2(-1.0, 1.0); 19 | float bound = dot(iResolution.xy, abs(dir)); 20 | 21 | float speed = fract(seed * 4785.9433) * 0.3 + 0.3; 22 | float time = fract(iGlobalTime * speed); 23 | 24 | float phase = iGlobalTime * (fract(seed * 438.454) * 3.3 + 3.3); 25 | float width = bound * 0.02 * (sin(phase) + 1.0); 26 | 27 | float dist = dot(coord, dir) + (time - 0.5) * bound; 28 | return abs(dist) - width; 29 | } 30 | 31 | void main() 32 | { 33 | vec2 p = gl_FragCoord.xy; 34 | 35 | float c = 1e+6; 36 | for (int i = 0; i < 4; i++) 37 | c = min(c, line(p, 94.3 * float(i))); 38 | 39 | c = max(c, circles(p)); 40 | c = clamp(1.0 - abs(1.0 - c), 0.0, 1.0); 41 | 42 | gl_FragColor = vec4(vec3(c, c, c), 1); 43 | } -------------------------------------------------------------------------------- /Fragment/Coaxial.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | out vec4 fragColor; 6 | 7 | float uvrand(vec2 uv) 8 | { 9 | return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453); 10 | } 11 | 12 | float arc(vec2 coord) 13 | { 14 | const float pi = 3.1415926; 15 | float t = floor(time * 1.1) * 7.3962; 16 | 17 | vec2 sc = (coord.xy - resolution / 2) / resolution.y; 18 | float phi = atan(sc.y, sc.x + 1e-6); 19 | vec2 pc = vec2(fract(phi / (pi * 2) + time * 0.07), length(sc)); 20 | 21 | vec2 org = vec2(0.5, 0.5); 22 | vec2 wid = vec2(0.5, 0.5); 23 | 24 | for (int i = 0; i < 7; i++) 25 | { 26 | if (uvrand(org + t) < 0.04 * i) break; 27 | wid *= 0.5; 28 | org += wid * (step(org, pc) * 2 - 1); 29 | } 30 | 31 | return uvrand(org); 32 | } 33 | 34 | void main(void) 35 | { 36 | vec4 delta = vec4(-1, -1, 1, 1) * 0.5; 37 | 38 | // neightbor four samples 39 | float c1 = arc(gl_FragCoord.xy + delta.xy); 40 | float c2 = arc(gl_FragCoord.xy + delta.zy); 41 | float c3 = arc(gl_FragCoord.xy + delta.xw); 42 | float c4 = arc(gl_FragCoord.xy + delta.zw); 43 | 44 | // roberts cross operator 45 | float gx = c1 - c4; 46 | float gy = c2 - c3; 47 | float g = sqrt(gx * gx + gy * gy); 48 | 49 | fragColor = vec4(g * 4); 50 | } 51 | -------------------------------------------------------------------------------- /Fragment/Discs.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | out vec4 fragColor; 6 | 7 | void main(void) 8 | { 9 | const float rep = 10; 10 | 11 | float scale = 8 / resolution.y; 12 | vec2 p0 = gl_FragCoord.xy * scale; 13 | 14 | vec2 p1 = floor(p0); 15 | vec2 p2 = (fract(p0 * vec2(2, 1.2)) - vec2(0, 0.5)) / vec2(2, 1.2); 16 | 17 | float c1 = length(p2); 18 | float c2 = length(vec2(0.5, 0) - p2); 19 | 20 | float c3 = abs(0.5 - fract(c1 * rep + 0.25)); 21 | float c4 = abs(0.5 - fract(c2 * rep + 0.25)); 22 | 23 | c4 *= 1 - clamp((c2 - 0.4) * 10, 0, 1); 24 | float c = mix(c3, c4, clamp((c1 - 0.4) * 10, 0, 1)); 25 | 26 | c = (0.35 - c) / (scale * rep); 27 | 28 | fragColor = vec4(c); 29 | } 30 | -------------------------------------------------------------------------------- /Fragment/Discs2.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | out vec4 fragColor; 6 | 7 | float saturate(float x) { return clamp(x, 0, 1); } 8 | 9 | float rand(vec2 uv) 10 | { 11 | return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453); 12 | } 13 | 14 | void main(void) 15 | { 16 | float scale = resolution.y / 10; 17 | vec2 p = gl_FragCoord.xy / scale; 18 | vec2 p1 = fract(p) - 0.5; 19 | vec2 p2 = fract(p - 0.5) - 0.5; 20 | 21 | float z1 = rand(0.12 * floor(p)); 22 | float z2 = rand(0.23 * floor(p - 0.5)); 23 | 24 | float r1 = 0.2 + 0.2 * sin(time * 1.9 + z1 * 30); 25 | float r2 = 0.2 + 0.2 * sin(time * 1.9 + z2 * 30); 26 | 27 | float c1 = saturate((r1 - length(p1)) * scale); 28 | float c2 = saturate((r2 - length(p2)) * scale); 29 | 30 | float a1 = saturate((r1 + 0.08 - length(p1)) * scale); 31 | float a2 = saturate((r2 + 0.08 - length(p2)) * scale); 32 | 33 | float c = mix( 34 | mix(mix(0, c1, a1), c2, a2), 35 | mix(mix(0, c2, a2), c1, a1), 36 | step(z1, z2) 37 | ); 38 | 39 | fragColor = vec4(c, c, c, 1); 40 | } 41 | -------------------------------------------------------------------------------- /Fragment/Discs3.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | out vec4 fragColor; 6 | 7 | float saturate(float x) { return clamp(x, 0, 1); } 8 | vec3 saturate(vec3 x) { return clamp(x, 0, 1); } 9 | 10 | float rand(vec2 uv) 11 | { 12 | return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453); 13 | } 14 | 15 | vec3 palette(float z) 16 | { 17 | vec3 a = vec3(0.90, 0.60, 0.69); 18 | vec3 b = vec3(0.17, 0.41, 0.41); 19 | return saturate(a + b * sin(z * 9 + time * 2)); 20 | } 21 | 22 | void main(void) 23 | { 24 | float scale = resolution.y / (6 + sin(time * 0.4) * 3); 25 | vec2 p = (gl_FragCoord.xy - resolution / 2) / scale; 26 | vec2 p1 = fract(p) - 0.5; 27 | vec2 p2 = fract(p - 0.5) - 0.5; 28 | 29 | float z1 = rand(0.19 * floor(p)); 30 | float z2 = rand(0.31 * floor(p - 0.5)); 31 | 32 | vec3 c1 = palette(z1); 33 | vec3 c2 = palette(z2); 34 | 35 | c1 *= saturate((0.25 - abs(0.5 - fract(length(p1) * 10 + 0.26))) * scale / 10); 36 | c2 *= saturate((0.25 - abs(0.5 - fract(length(p2) * 10 + 0.26))) * scale / 10); 37 | 38 | float a1 = saturate((0.5 - length(p1)) * scale); 39 | float a2 = saturate((0.5 - length(p2)) * scale); 40 | 41 | vec3 c = mix( 42 | mix(mix(vec3(0), c1, a1), c2, a2), 43 | mix(mix(vec3(0), c2, a2), c1, a1), 44 | step(z1, z2) 45 | ); 46 | 47 | fragColor = vec4(c, 1); 48 | } 49 | -------------------------------------------------------------------------------- /Fragment/Discs4.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | out vec4 fragColor; 6 | 7 | float saturate(float x) { return clamp(x, 0, 1); } 8 | 9 | float rand(vec2 uv) 10 | { 11 | return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453); 12 | } 13 | 14 | vec3 palette(float z) 15 | { 16 | float g = 0.6 + 0.4 * sin(z * 8 + time * 2); 17 | float b = 0.5 + 0.4 * sin(z * 5 + time * 3); 18 | return vec3(1, g, b); 19 | } 20 | 21 | void main(void) 22 | { 23 | float scale = resolution.y / 5; 24 | vec2 p = gl_FragCoord.xy / scale; 25 | 26 | vec2 offs1 = vec2(time * 0.53, sin(time * 1.35) * 0.2); 27 | vec2 offs2 = vec2(time * 0.81, sin(time * 1.19) * 0.2); 28 | 29 | vec2 p1 = p + offs1; 30 | vec2 p2 = p + offs2 - 0.5; 31 | 32 | float z1 = rand(0.19 * floor(p1)); 33 | float z2 = rand(0.31 * floor(p2)); 34 | 35 | p1 = fract(p1) - 0.5; 36 | p2 = fract(p2) - 0.5; 37 | 38 | float s1 = 0.9 + sin(time * (0.6 + z1)) * 0.6; 39 | float s2 = 0.9 + sin(time * (0.6 + z2)) * 0.6; 40 | 41 | float d1 = (0.25 - abs(0.5 - fract(length(p1) * s1 * 10 + 0.26))) / (s1 * 10); 42 | float d2 = (0.25 - abs(0.5 - fract(length(p2) * s2 * 10 + 0.26))) / (s2 * 10); 43 | 44 | vec3 c1 = palette(z1) * saturate(d1 * scale); 45 | vec3 c2 = palette(z2) * saturate(d2 * scale); 46 | 47 | float a1 = saturate((0.5 - length(p1)) * scale); 48 | float a2 = saturate((0.5 - length(p2)) * scale); 49 | 50 | vec3 c1on2 = mix(c2 * a2, c1, a1); 51 | vec3 c2on1 = mix(c1 * a1, c2, a2); 52 | 53 | fragColor = vec4(mix(c2on1, c1on2, step(z1, z2)), 1); 54 | } 55 | -------------------------------------------------------------------------------- /Fragment/Dots1.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | 6 | out vec4 fragColor; 7 | 8 | float swirl(vec2 coord) 9 | { 10 | float l = length(coord) / resolution.x; 11 | float phi = atan(coord.y, coord.x + 1e-6); 12 | return sin(l * 10 + phi - time * 4) * 0.5 + 0.5; 13 | } 14 | 15 | float halftone(vec2 coord) 16 | { 17 | coord -= resolution * 0.5; 18 | float size = resolution.x / (60 + sin(time * 0.5) * 50); 19 | vec2 uv = coord / size; 20 | vec2 ip = floor(uv); // column, row 21 | vec2 odd = vec2(0.5 * mod(ip.y, 2), 0); // odd line offset 22 | vec2 cp = floor(uv - odd) + odd; // dot center 23 | float d = length(uv - cp - 0.5) * size; // distance 24 | float r = swirl(cp * size) * (size - 2) * 0.5; // dot radius 25 | return clamp(d - r, 0, 1); 26 | } 27 | 28 | void main(void) 29 | { 30 | fragColor = vec4(vec3(1, 1, 0) * halftone(gl_FragCoord.xy), 1); 31 | } 32 | -------------------------------------------------------------------------------- /Fragment/Dots2.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | 6 | out vec4 fragColor; 7 | 8 | vec2 rotate(vec2 p, float theta) 9 | { 10 | vec2 sncs = vec2(sin(theta), cos(theta)); 11 | return vec2(p.x * sncs.y - p.y * sncs.x, dot(p, sncs)); 12 | } 13 | 14 | float swirl(vec2 coord, float t) 15 | { 16 | float l = length(coord) / resolution.x; 17 | float phi = atan(coord.y, coord.x + 1e-6); 18 | return sin(l * 10 + phi - t * 4) * 0.5 + 0.5; 19 | } 20 | 21 | float halftone(vec2 coord, float angle, float t, float amp) 22 | { 23 | coord -= resolution * 0.5; 24 | float size = resolution.x / (60 + sin(time * 0.5) * 50); 25 | vec2 uv = rotate(coord / size, angle / 180 * 3.14); 26 | vec2 ip = floor(uv); // column, row 27 | vec2 odd = vec2(0.5 * mod(ip.y, 2), 0); // odd line offset 28 | vec2 cp = floor(uv - odd) + odd; // dot center 29 | float d = length(uv - cp - 0.5) * size; // distance 30 | float r = swirl(cp * size, t) * size * 0.5 * amp; // dot radius 31 | return 1 - clamp(d - r, 0, 1); 32 | } 33 | 34 | void main(void) 35 | { 36 | vec3 c1 = 1 - vec3(1, 0, 0) * halftone(gl_FragCoord.xy, 0, time * 1.00, 0.7); 37 | vec3 c2 = 1 - vec3(0, 1, 0) * halftone(gl_FragCoord.xy, 30, time * 1.33, 0.7); 38 | vec3 c3 = 1 - vec3(0, 0, 1) * halftone(gl_FragCoord.xy, -30, time * 1.66, 0.7); 39 | vec3 c4 = 1 - vec3(1, 1, 1) * halftone(gl_FragCoord.xy, 60, time * 2.13, 0.4); 40 | fragColor = vec4(c1 * c2 * c3 * c4,1); 41 | } 42 | -------------------------------------------------------------------------------- /Fragment/Dots3.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | 6 | out vec4 fragColor; 7 | 8 | float smin(float a, float b, float k) 9 | { 10 | float h = clamp(0.5 + 0.5 * (b - a) / k, 0, 1); 11 | return mix(b, a, h) - k * h * (1 - h); 12 | } 13 | 14 | float swirl(vec2 coord) 15 | { 16 | float l = length(coord) / resolution.x; 17 | float phi = atan(coord.y, coord.x + 1e-6); 18 | return sin(l * 21 + phi * 5 - time * 4) * 0.5 + 0.5; 19 | } 20 | 21 | float halftone(vec2 coord, float size, vec2 offs) 22 | { 23 | vec2 uv = coord / size; 24 | vec2 ip = floor(uv) + offs; // column, row 25 | vec2 odd = vec2(0.5 * mod(ip.y, 2), 0); // odd line offset 26 | vec2 cp = floor(uv - odd + offs) + odd; // dot center 27 | float d = length(uv - cp - 0.5) * size; // distance 28 | float r = swirl(cp * size) * size * 0.6; // dot radius 29 | return max(0, d - r); 30 | } 31 | 32 | void main(void) 33 | { 34 | vec2 coord = gl_FragCoord.xy - resolution * 0.5; 35 | float size = resolution.x / (30 + sin(time * 0.5) * 20); 36 | float k = size / 4; 37 | 38 | float d = halftone(coord, size, vec2(-0.5, -1)); 39 | d = smin(d, halftone(coord, size, vec2( 0.5, -1)), k); 40 | d = smin(d, halftone(coord, size, vec2(-1.0, 0)), k); 41 | d = smin(d, halftone(coord, size, vec2( 0.0, 0)), k); 42 | d = smin(d, halftone(coord, size, vec2( 1.0, 0)), k); 43 | d = smin(d, halftone(coord, size, vec2(-0.5, 1)), k); 44 | d = smin(d, halftone(coord, size, vec2( 0.5, 1)), k); 45 | 46 | fragColor = vec4(d, d, d, 1); 47 | } 48 | -------------------------------------------------------------------------------- /Fragment/Eyes.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | 6 | out vec4 fragColor; 7 | 8 | float eyes(vec2 coord) 9 | { 10 | float div = 8 - cos(time * 0.3) * 7; 11 | float sc = resolution.y / div; 12 | vec2 p = (coord - resolution / 2) / sc; 13 | 14 | // circles 15 | float l = length(fract(p - 0.5) - 0.5); 16 | float rep = sin(dot(floor(p - 0.5), vec2(9.1, 7.9)) + time) * 5 + 8; 17 | float c = (abs(0.5 - fract(l * rep + 0.5)) - 0.25) * sc / rep; 18 | 19 | // grid lines 20 | vec2 gr = (abs(0.5 - fract(p)) - 0.05) * sc; 21 | 22 | return min(min(c, gr.x), gr.y); 23 | } 24 | 25 | void main(void) 26 | { 27 | fragColor = vec4(eyes(gl_FragCoord.xy)); 28 | } 29 | -------------------------------------------------------------------------------- /Fragment/Eyes2.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | 6 | out vec4 fragColor; 7 | 8 | float rand(vec2 uv) 9 | { 10 | return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453); 11 | } 12 | 13 | vec3 hue2rgb(float h) 14 | { 15 | h = fract(h) * 6 - 2; 16 | return clamp(vec3(abs(h - 1) - 1, 2 - abs(h), 2 - abs(h - 2)), 0, 1); 17 | } 18 | 19 | vec3 eyes(vec2 coord) 20 | { 21 | const float pi = 3.141592; 22 | float t = 0.4 * time; 23 | float div = 5 - cos(t * 0.33 * pi) * 4; 24 | float sc = resolution.y / div; 25 | 26 | vec2 p = (coord - resolution / 2) / sc - 0.5; 27 | 28 | // center offset 29 | float dir = floor(rand(floor(p) + floor(t) * 0.11) * 4) * pi / 2; 30 | vec2 offs = vec2(sin(dir), cos(dir)) * 0.6; 31 | offs *= smoothstep(0.0, 0.1, fract(t)); 32 | offs *= smoothstep(0.4, 0.5, 1 - fract(t)); 33 | 34 | // circles 35 | float l = length(fract(p) + offs - 0.5); 36 | float rep = sin((rand(floor(p)) * 2 + 2) * t) * 4 + 5; 37 | float c = (abs(0.5 - fract(l * rep + 0.5)) - 0.25) * sc / rep; 38 | 39 | // grid lines 40 | vec2 gr = (abs(0.5 - fract(p + 0.5)) - 0.05) * sc; 41 | c = clamp(min(min(c, gr.x), gr.y), 0, 1); 42 | 43 | return hue2rgb(rand(floor(p) * 0.3231)) * c; 44 | } 45 | 46 | void main(void) 47 | { 48 | fragColor = vec4(eyes(gl_FragCoord.xy), 1); 49 | } 50 | -------------------------------------------------------------------------------- /Fragment/GradNoise1.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform vec2 resolution; 4 | uniform float time; 5 | out vec4 fragColor; 6 | 7 | float fade(float x) { return x * x * x * (x * (x * 6 - 15) + 10); } 8 | 9 | float phash(float p) 10 | { 11 | p = fract(7.8233139 * p); 12 | p = ((2384.2345 * p - 1324.3438) * p + 3884.2243) * p - 4921.2354; 13 | return fract(p) * 2 - 1; 14 | } 15 | 16 | float noise(float p) 17 | { 18 | float ip = floor(p); 19 | float fp = fract(p); 20 | float d0 = phash(ip ) * fp; 21 | float d1 = phash(ip + 1) * (fp - 1); 22 | return mix(d0, d1, fade(fp)); 23 | } 24 | 25 | void main(void) 26 | { 27 | float p = gl_FragCoord.x * 10 / resolution.x; 28 | p += time * 2 - 10; 29 | fragColor = vec4(noise(p) / 2 + 0.5); 30 | } 31 | -------------------------------------------------------------------------------- /Fragment/GradNoise2.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform vec2 resolution; 4 | uniform float time; 5 | out vec4 fragColor; 6 | 7 | vec2 fade(vec2 x) { return x * x * x * (x * (x * 6 - 15) + 10); } 8 | 9 | vec2 phash(vec2 p) 10 | { 11 | p = fract(mat2(1.2989833, 7.8233198, 6.7598192, 3.4857334) * p); 12 | p = ((2384.2345 * p - 1324.3438) * p + 3884.2243) * p - 4921.2354; 13 | return normalize(fract(p) * 2 - 1); 14 | } 15 | 16 | float noise(vec2 p) 17 | { 18 | vec2 ip = floor(p); 19 | vec2 fp = fract(p); 20 | float d00 = dot(phash(ip), fp); 21 | float d01 = dot(phash(ip + vec2(0, 1)), fp - vec2(0, 1)); 22 | float d10 = dot(phash(ip + vec2(1, 0)), fp - vec2(1, 0)); 23 | float d11 = dot(phash(ip + vec2(1, 1)), fp - vec2(1, 1)); 24 | fp = fade(fp); 25 | return mix(mix(d00, d01, fp.y), mix(d10, d11, fp.y), fp.x); 26 | } 27 | 28 | void main(void) 29 | { 30 | vec2 p = vec2(gl_FragCoord.xy * 10 / resolution.y) + vec2(time * 2 - 10); 31 | fragColor = vec4(noise(p) / 2 + 0.5); 32 | } 33 | -------------------------------------------------------------------------------- /Fragment/GradNoise3.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform vec2 resolution; 4 | uniform float time; 5 | out vec4 fragColor; 6 | 7 | vec3 fade(vec3 x) { return x * x * x * (x * (x * 6 - 15) + 10); } 8 | 9 | vec3 phash(vec3 p) 10 | { 11 | p = fract(mat3(1.2989833, 7.8233198, 2.3562332, 12 | 6.7598192, 3.4857334, 8.2837193, 13 | 2.9175399, 2.9884245, 5.4987265) * p); 14 | p = ((2384.2345 * p - 1324.3438) * p + 3884.2243) * p - 4921.2354; 15 | return normalize(fract(p) * 2 - 1); 16 | } 17 | 18 | float noise(vec3 p) 19 | { 20 | vec3 ip = floor(p); 21 | vec3 fp = fract(p); 22 | float d000 = dot(phash(ip), fp); 23 | float d001 = dot(phash(ip + vec3(0, 0, 1)), fp - vec3(0, 0, 1)); 24 | float d010 = dot(phash(ip + vec3(0, 1, 0)), fp - vec3(0, 1, 0)); 25 | float d011 = dot(phash(ip + vec3(0, 1, 1)), fp - vec3(0, 1, 1)); 26 | float d100 = dot(phash(ip + vec3(1, 0, 0)), fp - vec3(1, 0, 0)); 27 | float d101 = dot(phash(ip + vec3(1, 0, 1)), fp - vec3(1, 0, 1)); 28 | float d110 = dot(phash(ip + vec3(1, 1, 0)), fp - vec3(1, 1, 0)); 29 | float d111 = dot(phash(ip + vec3(1, 1, 1)), fp - vec3(1, 1, 1)); 30 | fp = fade(fp); 31 | return mix(mix(mix(d000, d001, fp.z), mix(d010, d011, fp.z), fp.y), 32 | mix(mix(d100, d101, fp.z), mix(d110, d111, fp.z), fp.y), fp.x); 33 | } 34 | 35 | void main(void) 36 | { 37 | vec3 p = vec3(gl_FragCoord.xy * 10 / resolution.y, time); 38 | fragColor = vec4(noise(p) / 2 + 0.5); 39 | } 40 | -------------------------------------------------------------------------------- /Fragment/Grid.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | out vec4 fragColor; 6 | 7 | float uvrand(vec2 uv) 8 | { 9 | return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453); 10 | } 11 | 12 | void main(void) 13 | { 14 | vec2 offs = vec2(resolution.x - resolution.y, 0) / 2; 15 | vec2 p = (gl_FragCoord.xy - offs) / resolution.y; 16 | 17 | vec2 ro = vec2(0.5, 0.5); // rect origin 18 | vec2 rw = vec2(0.5, 0.5); // rect extent (half width) 19 | float t = floor(time); 20 | 21 | for (int i = 0; i < 6; i++) 22 | { 23 | if (uvrand(ro + t) < 0.05 * i) break; 24 | rw *= 0.5; 25 | ro += rw * (step(ro, p) * 2 - 1); 26 | } 27 | 28 | float rnd = uvrand(ro); 29 | 30 | vec2 sl = rnd < 0.5 ? vec2(1,0) : vec2(0,1); // sliding param 31 | sl *= 2 * rw * (1 - smoothstep(0, 0.5, fract(time))); 32 | 33 | vec2 cp = (abs(rw - p + ro) - sl) * resolution.y - 3; // rect fill 34 | float c = clamp(min(cp.x, cp.y), 0, 1); 35 | 36 | c *= rnd * (1 - abs(floor(p.x))); // outside 37 | 38 | fragColor = vec4(c, 0, 0, 1); 39 | } 40 | -------------------------------------------------------------------------------- /Fragment/Hex.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | const float PI = 3.141592; 4 | uniform float time; 5 | uniform vec2 resolution; 6 | 7 | out vec4 fragColor; 8 | 9 | void main(void) 10 | { 11 | vec2 coord = gl_FragCoord.xy - resolution * 0.5; 12 | 13 | float phi = atan(coord.y, coord.x + 1e-6); 14 | phi = phi / PI * 0.5 + 0.5; 15 | float seg = floor(phi * 6); 16 | 17 | float theta = (seg + 0.5) / 6 * PI * 2; 18 | vec2 dir = vec2(cos(theta), sin(theta)); 19 | float l = dot(dir, coord); 20 | 21 | float phase = time * 0.8; 22 | float w1 = sin(floor(phase ) + seg) * 40 + 60; 23 | float w2 = sin(floor(phase + 1) + seg) * 40 + 60; 24 | float w = mix(w1, w2, smoothstep(0.75, 1, fract(phase))); 25 | 26 | float prog = l / w + time * 2; 27 | float thresh = fract(73.8493748 * abs(sin(floor(prog) * 4.67458347))); 28 | float c = clamp((fract(prog) - thresh) * w * 0.3, 0, 1); 29 | 30 | fragColor = vec4(c, c, c, 1); 31 | } 32 | -------------------------------------------------------------------------------- /Fragment/Hex2.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | const float PI = 3.141592; 4 | uniform float time; 5 | uniform vec2 resolution; 6 | 7 | out vec4 fragColor; 8 | 9 | void main(void) 10 | { 11 | vec2 coord = gl_FragCoord.xy - resolution * 0.5; 12 | 13 | float phi = atan(coord.y, coord.x + 1e-6); 14 | phi = phi / PI * 0.5 + 0.5; 15 | float seg = floor(phi * 6); 16 | 17 | float theta = (seg + 0.5) / 6 * PI * 2; 18 | vec2 dir1 = vec2(cos(theta), sin(theta)); 19 | vec2 dir2 = vec2(-dir1.y, dir1.x); 20 | 21 | float l = dot(dir1, coord); 22 | float w = sin(seg * 31.374) * 18 + 20; 23 | float prog = l / w + time * 2; 24 | float idx = floor(prog); 25 | 26 | float phase = time * 0.8; 27 | float th1 = fract(273.84937 * sin(idx * 54.67458 + floor(phase ))); 28 | float th2 = fract(273.84937 * sin(idx * 54.67458 + floor(phase + 1))); 29 | float thresh = mix(th1, th2, smoothstep(0.75, 1, fract(phase))); 30 | 31 | float l2 = dot(dir2, coord); 32 | float slide = fract(idx * 32.74853) * 200 * time; 33 | float w2 = fract(idx * 39.721784) * 500; 34 | float prog2 = (l2 + slide) / w2; 35 | 36 | float c = clamp((fract(prog) - thresh) * w * 0.3, 0, 1); 37 | c *= clamp((fract(prog2) - 1 + thresh) * w2 * 0.3, 0, 1); 38 | 39 | fragColor = vec4(c, c, c, 1); 40 | } 41 | -------------------------------------------------------------------------------- /Fragment/Hex3.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | out vec4 fragColor; 6 | 7 | void main(void) 8 | { 9 | const float pi = 3.1415926535; 10 | vec2 p = gl_FragCoord.xy - resolution / 2; 11 | float phi = atan(p.y, p.x + 1e-5); 12 | 13 | float fin = mod(floor(phi * 3 / pi + 0.5), 6); 14 | float phi_fin = fin * pi / 3; 15 | 16 | vec2 dir = vec2(cos(phi_fin), sin(phi_fin)); 17 | float l = dot(dir, p) - time * resolution.y / 8; 18 | float seg = floor(l * 70 / resolution.y); 19 | 20 | float th = sin(time) * 0.4 + 0.5; 21 | float t = sin(seg * 92.198763) * time; 22 | fragColor = vec4(step(th, fract(phi / pi / 2 + t))); 23 | } 24 | -------------------------------------------------------------------------------- /Fragment/Hex4.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | out vec4 fragColor; 6 | 7 | vec3 hue2rgb(float h) 8 | { 9 | h = fract(h) * 6 - 2; 10 | return clamp(vec3(abs(h - 1) - 1, 2 - abs(h), 2 - abs(h - 2)), 0, 1); 11 | } 12 | 13 | void main(void) 14 | { 15 | const float pi = 3.1415926535; 16 | vec2 p = gl_FragCoord.xy - resolution / 2; 17 | float phi = atan(p.y, p.x + 1e-5); 18 | 19 | float fin = mod(floor(phi * 3 / pi + 0.5), 6); 20 | float phi_fin = fin * pi / 3; 21 | 22 | vec2 dir = vec2(cos(phi_fin), sin(phi_fin)); 23 | float l = dot(dir, p) - time * resolution.y / 8; 24 | float seg = floor(l * 40 / resolution.y); 25 | 26 | float th = sin(time) * 0.4 + 0.5; 27 | float t = sin(seg * 92.198763) * time; 28 | 29 | vec3 c = hue2rgb(sin(seg * 99.374662) * 237.28364); 30 | c *= step(th, fract(phi / pi / 2 + t)); 31 | 32 | fragColor = vec4(c, 1); 33 | } 34 | -------------------------------------------------------------------------------- /Fragment/Hex5.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | out vec4 fragColor; 6 | 7 | void main(void) 8 | { 9 | const float pi = 3.1415926535; 10 | vec2 p = gl_FragCoord.xy - resolution / 2; 11 | float phi = atan(p.y, p.x + 1e-6); 12 | 13 | float fin = mod(floor(phi * 3 / pi + 0.5), 6); 14 | float phi_fin = fin * pi / 3; 15 | 16 | vec2 dir = vec2(cos(phi_fin), sin(phi_fin)); 17 | float l = dot(dir, p) - time * resolution.y / 5; 18 | 19 | float ivr = 20; 20 | float seg = l / ivr; 21 | 22 | float w = sin(floor(seg) * 0.2 - time) * 0.4 + 0.5; 23 | float c = (w / 2 - abs(fract(seg) - 0.5)) * ivr; 24 | 25 | fragColor = vec4(c, c, c, 1); 26 | } 27 | -------------------------------------------------------------------------------- /Fragment/Lattice.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | out vec4 fragColor; 6 | 7 | void main(void) 8 | { 9 | const float pi = 3.1415926; 10 | float t = time * 0.7; 11 | 12 | float scale = 10 / resolution.y; 13 | vec2 p = gl_FragCoord.xy * scale + 0.5; // pos normalized /w grid 14 | p += vec2(2, 0.5) * time; 15 | 16 | float rnd = fract(sin(dot(floor(p), vec2(21.98, 19.37))) * 4231.73); 17 | rnd = floor(rnd * 2) / 2 + floor(t) / 2; 18 | 19 | float anim = smoothstep(0, 0.7, fract(t)); 20 | float phi = pi * (rnd + 0.5 * anim + 0.25); 21 | vec2 dir = vec2(cos(phi), sin(phi)); 22 | 23 | vec2 pf = fract(p); 24 | float d1 = abs(dot(pf - vec2(0.5, 0), dir)); // line 1 25 | float d2 = abs(dot(pf - vec2(0.5, 1), dir)); // line 2 26 | 27 | fragColor = vec4((0.1 - min(d1, d2)) / scale); 28 | } 29 | -------------------------------------------------------------------------------- /Fragment/Lattice2.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | out vec4 fragColor; 6 | 7 | void main(void) 8 | { 9 | const float pi = 3.1415926; 10 | float t = time * 0.7; 11 | 12 | float scale = 10 / resolution.y; 13 | vec2 p = gl_FragCoord.xy * scale + 0.5; // pos normalized /w grid 14 | p += vec2(2, 0.5) * time; 15 | 16 | float rnd = fract(sin(dot(floor(p), vec2(21.98, 19.37))) * 4231.73); 17 | float flip = fract(rnd * 13.8273) > 0.5 ? 1 : -1; 18 | rnd = floor(rnd * 2) / 2 + floor(t) * flip / 2; 19 | 20 | float anim = smoothstep(0, 0.66, fract(t)); 21 | float phi = pi * (rnd + anim * flip / 2 + 0.25); 22 | vec2 offs = vec2(cos(phi), sin(phi)) * sqrt(2) / 2; 23 | 24 | vec2 pf = fract(p); 25 | float d1 = abs(0.5 - distance(pf, vec2(0.5 - offs))); // arc 1 26 | float d2 = abs(0.5 - distance(pf, vec2(0.5 + offs))); // arc 2 27 | 28 | float w = 0.1 + 0.08 * sin(t); 29 | fragColor = vec4((w - min(d1, d2)) / scale); 30 | } 31 | -------------------------------------------------------------------------------- /Fragment/Lattice3.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | out vec4 fragColor; 6 | 7 | void main(void) 8 | { 9 | const float pi = 3.1415926; 10 | float t = time * 0.7; 11 | 12 | float scale = 10 / resolution.y; 13 | vec2 p = gl_FragCoord.xy * scale + 0.5; // pos normalized /w grid 14 | p += vec2(2, 0.5) * time; 15 | 16 | float rnd = fract(sin(dot(floor(p), vec2(21.98, 19.37))) * 4231.73); 17 | float flip = fract(rnd * 13.8273) > 0.5 ? 1 : -1; 18 | rnd = floor(rnd * 2) / 2 + floor(t) * flip / 2; 19 | 20 | float anim = smoothstep(0, 0.66, fract(t)); 21 | float phi = pi * (rnd + anim * flip / 2); 22 | vec2 a1 = vec2(cos(phi), sin(phi)); 23 | vec2 a2 = vec2(-a1.y, a1.x); 24 | vec2 a3 = vec2(cos(phi + pi / 4), sin(phi + pi / 4)); 25 | 26 | vec2 pf = fract(p) - 0.5; 27 | float d1 = abs(min(min(dot( pf, a1), dot( pf, a2)), dot( pf, a3) - 0.2)); 28 | float d2 = abs(min(min(dot(-pf, a1), dot(-pf, a2)), dot(-pf, a3) - 0.2)); 29 | 30 | float w = 0.1 + sin(t) * 0.08; // line width 31 | float c = 1 - clamp((w - min(d1, d2)) / scale, 0, 1); 32 | fragColor = vec4(c, 0.5 * c, 0, 1); 33 | } 34 | -------------------------------------------------------------------------------- /Fragment/Lines.glsl: -------------------------------------------------------------------------------- 1 | float potential(vec2 coord) 2 | { 3 | float t = iGlobalTime * 2.0; 4 | return saturate(dot(sin(coord * 0.015 + t) + 1.0, vec2(0.4))); 5 | } 6 | 7 | float line(vec2 coord) 8 | { 9 | float reso = 24.0; 10 | float cw = iResolution.x / reso; 11 | 12 | vec2 pc = floor(coord / cw) * cw; 13 | vec2 pd = fract(coord / cw) * cw; 14 | 15 | float pt = potential(pc); 16 | float lw = pt + 0.5; 17 | float grad = 1.0 - pt * 2.0; 18 | 19 | return saturate(lw - abs(grad * pd.y - pd.x + cw * pt)); 20 | } 21 | 22 | void main() 23 | { 24 | float c = line(gl_FragCoord.xy); 25 | gl_FragColor = vec4(vec3(c, c, c), 1); 26 | } -------------------------------------------------------------------------------- /Fragment/Noise.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform vec2 resolution; 4 | uniform vec3 spectrum; 5 | uniform sampler2D prevFrame; 6 | out vec4 fragColor; 7 | 8 | float rand(vec2 uv) 9 | { 10 | return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453); 11 | } 12 | 13 | float noise(vec2 p) 14 | { 15 | vec2 ip = floor(p); 16 | vec2 fp = smoothstep(0, 1, p - ip); 17 | float r00 = rand(ip); 18 | float r01 = rand(ip + vec2(0, 1)); 19 | float r10 = rand(ip + vec2(1, 0)); 20 | float r11 = rand(ip + vec2(1, 1)); 21 | return mix(mix(r00, r01, fp.y), mix(r10, r11, fp.y), fp.x); 22 | } 23 | 24 | void main(void) 25 | { 26 | vec2 p = gl_FragCoord.xy * 20 / resolution.y; 27 | vec3 c = vec3(noise(p));; 28 | 29 | fragColor = vec4(c, 1); 30 | } 31 | -------------------------------------------------------------------------------- /Fragment/ReactDiffuse.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | uniform sampler2D prevFrame; 6 | out vec4 fragColor; 7 | 8 | float rand(vec2 uv) 9 | { 10 | return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453); 11 | } 12 | 13 | vec2 ReactDiffuse(vec2 p) 14 | { 15 | vec4 duv = vec4(1, 1, -1, 0) / resolution.xyxy; 16 | 17 | vec2 s = texture(prevFrame, p).xy; 18 | 19 | vec2 lpc = 20 | texture(prevFrame, p - duv.xy).xy * 0.05 + 21 | texture(prevFrame, p - duv.wy).xy * 0.20 + 22 | texture(prevFrame, p - duv.zy).xy * 0.05 + 23 | 24 | texture(prevFrame, p - duv.xw).xy * 0.20 + 25 | s * -1 + 26 | texture(prevFrame, p + duv.xw).xy * 0.20 + 27 | 28 | texture(prevFrame, p + duv.zy).xy * 0.05 + 29 | texture(prevFrame, p + duv.wy).xy * 0.20 + 30 | texture(prevFrame, p + duv.xy).xy * 0.05; 31 | 32 | const float f = 0.0545; 33 | const float k = 0.0650; 34 | 35 | s += vec2( 36 | lpc.x * 1.00 - s.x * s.y * s.y + f * (1 - s.x), 37 | lpc.y * 0.3 + s.x * s.y * s.y - (k + f) * s.y 38 | ); 39 | 40 | return s; 41 | } 42 | 43 | void main(void) 44 | { 45 | bool initiate = false; 46 | 47 | // *** TO INITIATE THE STATE, ENABLE THE LINE BELOW. *** 48 | //initiate = true; 49 | 50 | vec2 uv = gl_FragCoord.xy / resolution; 51 | 52 | if (initiate) 53 | { 54 | fragColor = vec4(1, step(0.9, rand(uv + time * 0.01)), 0, 0); 55 | } 56 | else if (uv.x < 0.5) 57 | { 58 | fragColor = vec4(ReactDiffuse(uv), 0, 0); 59 | } 60 | else 61 | { 62 | vec2 s = texture(prevFrame, uv - vec2(0.5, 0)).xy; 63 | float c = smoothstep(-0.2, 0.2, s.y - s.x); 64 | fragColor = vec4(c, c, c, 1); 65 | } 66 | } 67 | -------------------------------------------------------------------------------- /Fragment/Rows.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | const float PI = 3.141592; 4 | uniform float time; 5 | uniform vec2 resolution; 6 | 7 | out vec4 fragColor; 8 | 9 | void main(void) 10 | { 11 | vec2 coord = gl_FragCoord.xy; 12 | vec2 size = resolution.xx / vec2(60, 15); 13 | 14 | float y = coord.y / size.y; 15 | float scr = 3 + 3 * fract(floor(y) * 12433.34); 16 | float x = coord.x / size.x + scr * time; 17 | 18 | float t = time * 1.1; 19 | float t01 = fract(t); 20 | float phase = floor(x) * 2353.48272 + floor(y) * 2745.32782 + floor(t); 21 | 22 | float h = mix( 23 | fract(sin(phase ) * 1423.84), 24 | fract(sin(phase + 1) * 1423.84), 25 | smoothstep(0.8, 1, t01) * 1.3 - smoothstep(0.5, 0.8, t01) * 0.3 26 | ); 27 | 28 | float c1 = (0.4 - abs(0.4 - fract(x))) / 0.8 * size.x; 29 | float c2 = (h - fract(y)) * size.y; 30 | float c = clamp(c1, 0, 1) * clamp(c2, 0, 1); 31 | 32 | fragColor = vec4(c, c, c, 1); 33 | } 34 | -------------------------------------------------------------------------------- /Fragment/Sliders.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | uniform vec3 spectrum; 6 | out vec4 fragColor; 7 | 8 | float rand(vec2 uv) 9 | { 10 | return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453); 11 | } 12 | 13 | void main(void) 14 | { 15 | float t = time * 1.2; 16 | 17 | float rep = 2 + pow(rand(vec2(floor(t))), 2) * 100; 18 | vec2 p0 = gl_FragCoord.xy / vec2(20, resolution.y / rep); 19 | vec2 p1 = floor(p0); 20 | vec2 p2 = fract(p0); 21 | 22 | float r = rand(p1 + floor(t) * 0.11356); 23 | float x = 1 - p2.y; 24 | float sp = mix(spectrum.x * 2, spectrum.y * 4, r > 0.5 ? 1 : 0); 25 | float th = fract(t - min(1, sp * (1 + r * 2))); 26 | float c = step(smoothstep(0, 1, th), x); 27 | 28 | fragColor = vec4(c); 29 | } 30 | -------------------------------------------------------------------------------- /Fragment/Spectrum.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform vec2 resolution; 4 | uniform vec3 spectrum; 5 | uniform sampler2D prevFrame; 6 | out vec4 fragColor; 7 | 8 | void main(void) 9 | { 10 | const int rep = 12; 11 | 12 | vec2 p = gl_FragCoord.xy; 13 | vec3 sp = spectrum * vec3(2, 8, 256); 14 | vec3 c; 15 | 16 | if (p.x < 1) 17 | { 18 | // the first column is used for storing history 19 | vec3 prev = texture(prevFrame, vec2(p.x, p.y - 1) / resolution).rgb; 20 | c = mix(sp, prev, min(1, p.y + 0.25)); 21 | } 22 | else 23 | { 24 | p /= resolution; 25 | c = vec3(0); 26 | 27 | for (int i = 0; i < rep; i++) 28 | { 29 | float i01 = i * 1.0 / rep; 30 | 31 | // sample the history column 32 | sp = texture(prevFrame, vec2(0, i * 2.0 / resolution.y)).xyz; 33 | 34 | // three points curve 35 | float px = p.x * 3 - i01 * 0.25; 36 | float lv = mix(sp.x, sp.y, smoothstep(0, 1.5, px)); 37 | lv = mix(lv, sp.z, smoothstep(1.5, 3, px)); 38 | 39 | lv = step(p.y - i01 * 0.25, lv); 40 | c += lv * 1.2 / rep * vec3(1, 1 - i01, i01); 41 | } 42 | } 43 | 44 | fragColor = vec4(c, 1); 45 | } 46 | -------------------------------------------------------------------------------- /Fragment/Spectrum2.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform vec2 resolution; 4 | uniform vec3 spectrum; 5 | uniform sampler2D prevFrame; 6 | out vec4 fragColor; 7 | 8 | void main(void) 9 | { 10 | vec2 p = gl_FragCoord.xy; 11 | vec3 c; 12 | 13 | if (p.x < 1) 14 | { 15 | // spectrum history 16 | c = texture(prevFrame, vec2(p.x, p.y - 1) / resolution).rgb; 17 | c = mix(spectrum * vec3(1, 16, 256) * 2, c, min(1, p.y)); 18 | } 19 | else 20 | { 21 | // color bars 22 | vec2 ref = vec2(0, p.x * 0.1 / resolution.y); 23 | c = texture(prevFrame, ref).rgb; 24 | c = c - abs(p.y / resolution.y - 0.5); 25 | } 26 | 27 | fragColor = vec4(c, 1); 28 | } 29 | -------------------------------------------------------------------------------- /Fragment/Template.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 mouse; 5 | uniform vec2 resolution; 6 | uniform vec3 spectrum; 7 | uniform sampler2D texture0; 8 | uniform sampler2D texture1; 9 | uniform sampler2D texture2; 10 | uniform sampler2D texture3; 11 | uniform sampler2D prevFrame; 12 | 13 | out vec4 fragColor; 14 | 15 | const float PI = 3.14159265359; 16 | const vec4 C1 = vec4(0, 1, 0.5, -1); 17 | 18 | float saturate(float x) { return clamp(x, 0, 1); } 19 | vec2 saturate(vec2 x) { return clamp(x, 0, 1); } 20 | vec3 saturate(vec3 x) { return clamp(x, 0, 1); } 21 | vec4 saturate(vec4 x) { return clamp(x, 0, 1); } 22 | 23 | vec3 max4(vec3 a, vec3 b, vec3 c, vec3 d) 24 | { 25 | return max(max(max(a, b), c), d); 26 | } 27 | 28 | vec3 mix4(vec3 a, vec3 b, vec3 c, vec3 d, float t) 29 | { 30 | t = fract(t / 4) * 4; 31 | vec3 acc = mix(a, b, saturate(t)); 32 | acc = mix(acc, c, saturate(t - 1)); 33 | acc = mix(acc, d, saturate(t - 2)); 34 | acc = mix(acc, a, saturate(t - 3)); 35 | return acc; 36 | } 37 | 38 | vec2 sincos(float x) { return vec2(sin(x), cos(x)); } 39 | 40 | mat2 rotate(float x) 41 | { 42 | vec2 sc = sincos(x); 43 | return mat2(sc.y, sc.x, -sc.x, sc.y); 44 | } 45 | 46 | float rand(vec2 uv) 47 | { 48 | return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453); 49 | } 50 | 51 | float rand(float x, float y = 0) 52 | { 53 | return rand(vec2(x, y)); 54 | } 55 | 56 | vec3 hue2rgb(float h) 57 | { 58 | h = fract(h) * 6 - 2; 59 | return saturate(vec3(abs(h - 1) - 1, 2 - abs(h), 2 - abs(h - 2))); 60 | } 61 | 62 | float fade(float x) { return x * x * x * (x * (x * 6 - 15) + 10); } 63 | vec2 fade(vec2 x) { return x * x * x * (x * (x * 6 - 15) + 10); } 64 | vec3 fade(vec3 x) { return x * x * x * (x * (x * 6 - 15) + 10); } 65 | 66 | float phash(float p) 67 | { 68 | p = fract(7.8233139 * p); 69 | p = ((2384.2345 * p - 1324.3438) * p + 3884.2243) * p - 4921.2354; 70 | return fract(p) * 2 - 1; 71 | } 72 | 73 | vec2 phash(vec2 p) 74 | { 75 | p = fract(mat2(1.2989833, 7.8233198, 6.7598192, 3.4857334) * p); 76 | p = ((2384.2345 * p - 1324.3438) * p + 3884.2243) * p - 4921.2354; 77 | return normalize(fract(p) * 2 - 1); 78 | } 79 | 80 | vec3 phash(vec3 p) 81 | { 82 | p = fract(mat3(1.2989833, 7.8233198, 2.3562332, 83 | 6.7598192, 3.4857334, 8.2837193, 84 | 2.9175399, 2.9884245, 5.4987265) * p); 85 | p = ((2384.2345 * p - 1324.3438) * p + 3884.2243) * p - 4921.2354; 86 | return normalize(fract(p) * 2 - 1); 87 | } 88 | 89 | float cnoise(float p) 90 | { 91 | float ip = floor(p); 92 | float fp = fract(p); 93 | float d0 = phash(ip ) * fp; 94 | float d1 = phash(ip + 1) * (fp - 1); 95 | return mix(d0, d1, fade(fp)); 96 | } 97 | 98 | float cnoise(vec2 p) 99 | { 100 | vec2 ip = floor(p); 101 | vec2 fp = fract(p); 102 | float d00 = dot(phash(ip), fp); 103 | float d01 = dot(phash(ip + vec2(0, 1)), fp - vec2(0, 1)); 104 | float d10 = dot(phash(ip + vec2(1, 0)), fp - vec2(1, 0)); 105 | float d11 = dot(phash(ip + vec2(1, 1)), fp - vec2(1, 1)); 106 | fp = fade(fp); 107 | return mix(mix(d00, d01, fp.y), mix(d10, d11, fp.y), fp.x); 108 | } 109 | 110 | float cnoise(vec3 p) 111 | { 112 | vec3 ip = floor(p); 113 | vec3 fp = fract(p); 114 | float d000 = dot(phash(ip), fp); 115 | float d001 = dot(phash(ip + vec3(0, 0, 1)), fp - vec3(0, 0, 1)); 116 | float d010 = dot(phash(ip + vec3(0, 1, 0)), fp - vec3(0, 1, 0)); 117 | float d011 = dot(phash(ip + vec3(0, 1, 1)), fp - vec3(0, 1, 1)); 118 | float d100 = dot(phash(ip + vec3(1, 0, 0)), fp - vec3(1, 0, 0)); 119 | float d101 = dot(phash(ip + vec3(1, 0, 1)), fp - vec3(1, 0, 1)); 120 | float d110 = dot(phash(ip + vec3(1, 1, 0)), fp - vec3(1, 1, 0)); 121 | float d111 = dot(phash(ip + vec3(1, 1, 1)), fp - vec3(1, 1, 1)); 122 | fp = fade(fp); 123 | return mix(mix(mix(d000, d001, fp.z), mix(d010, d011, fp.z), fp.y), 124 | mix(mix(d100, d101, fp.z), mix(d110, d111, fp.z), fp.y), fp.x); 125 | } 126 | 127 | vec3 sample(sampler2D t, vec2 uv) 128 | { 129 | return texture(t, fract(1 - uv)).rgb; 130 | } 131 | 132 | vec3 feedback(vec2 offs) 133 | { 134 | vec2 uv = gl_FragCoord.xy / resolution; 135 | offs.x *= resolution.x / resolution.y; 136 | return texture(prevFrame, fract(uv + offs)).rgb; 137 | } 138 | 139 | vec2 uv2rect(vec2 uv) 140 | { 141 | vec2 p = uv * 2 - 1; 142 | p.x *= resolution.x / resolution.y; 143 | return p; 144 | } 145 | 146 | vec2 uv2polar(vec2 uv) 147 | { 148 | vec2 p = uv * 2 - 1; 149 | p.x *= resolution.x / resolution.y; 150 | return vec2(atan(p.y, p.x) / PI / 2 + 0.5, length(p)); 151 | } 152 | 153 | vec2 uv2tri(vec2 uv) 154 | { 155 | vec2 p = uv2rect(uv); 156 | float sx = p.x - p.y / 2; // skewed x 157 | float offs = step(fract(1 - p.y), fract(sx)); 158 | // distance from borders 159 | vec3 tp = vec3(dot(p, vec2(1, 0.5)), dot(p, vec2(-1, 0.5)), p.y); 160 | vec3 tp1 = fract(+tp); 161 | vec3 tp2 = fract(-tp); 162 | float d1 = min(min(tp1.x, tp1.y), tp1.z); 163 | float d2 = min(min(tp2.x, tp2.y), tp2.z); 164 | float d = min(d1, d2) * 3; 165 | return vec2(floor(sx) * 2 + offs, floor(p.y)) + d; 166 | } 167 | 168 | vec2 uv2hex(vec2 uv) 169 | { 170 | vec2 p = uv * 2 - 1; 171 | p.x *= resolution.x / resolution.y; 172 | float seg = floor(fract(atan(p.y, p.x) / PI / 2 + 0.5 / 6) * 6); 173 | vec2 v1 = sincos(seg / 6 * PI * 2).yx; 174 | #if 0 175 | vec2 v2 = vec2(-v1.y, v1.x) * 0.86602540378; // sin(60 degs); 176 | return vec2(dot(p, v2) / dot(p, v1) + 0.5 + seg, dot(p, v1)); 177 | #else 178 | vec2 v2 = vec2(-v1.y, v1.x); 179 | return vec2(dot(p, v2) * 0.5 + 0.5 + seg, dot(p, v1)); 180 | #endif 181 | } 182 | 183 | vec3 render(vec2 uv); 184 | 185 | void main(void) 186 | { 187 | fragColor = vec4(render(gl_FragCoord.xy / resolution), 1); 188 | } 189 | 190 | // 191 | // 192 | // 193 | 194 | vec3 render(vec2 uv) 195 | { 196 | return vec3(1) * cnoise(uv.x * 4 + time); 197 | } 198 | 199 | -------------------------------------------------------------------------------- /Fragment/TestCard.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform vec2 resolution; 4 | out vec4 fragColor; 5 | 6 | float saturate(float x) { return clamp(x, 0, 1); } 7 | vec3 saturate(vec3 x) { return clamp(x, 0, 1); } 8 | 9 | vec3 hue2rgb(float h) 10 | { 11 | h = fract(saturate(h)) * 6 - 2; 12 | return saturate(vec3(abs(h - 1) - 1, 2 - abs(h), 2 - abs(h - 2))); 13 | } 14 | 15 | void main(void) 16 | { 17 | float scale = 27.0 / resolution.y; // grid scale 18 | vec2 area = vec2(floor(13 / resolution.y * resolution.x), 13); // size of inner area 19 | 20 | vec2 p0 = gl_FragCoord.xy - resolution / 2; // position (pixel) 21 | vec2 p1 = p0 * scale; // position (grid) 22 | 23 | // gray background with crosshair 24 | float c1 = 1 - step(2, min(abs(p0.x), abs(p0.y))) * 0.5; 25 | 26 | // grid lines 27 | vec2 grid = step(scale, abs(0.5 - fract(p1 * 0.5))); 28 | c1 = saturate(c1 + 2 - grid.x - grid.y); 29 | 30 | // outer area checker 31 | vec2 checker = step(0.49999, fract(floor(p1 * 0.5 + 0.5) * 0.5)); 32 | if (any(greaterThan(abs(p1), area))) c1 = abs(checker.x - checker.y); 33 | 34 | float corner = sqrt(8) - length(abs(p1) - area + 4); // corner circles 35 | float circle = 12 - length(p1); // big center circle 36 | float mask = saturate(circle / scale); // center circls mask 37 | 38 | // grayscale bars 39 | float bar1 = saturate(p1.y < 5 ? floor(p1.x / 4 + 3) / 5 : p1.x / 16 + 0.5); 40 | c1 = mix(c1, bar1, mask * saturate(ceil(4 - abs(5 - p1.y)))); 41 | 42 | // basic color bars 43 | vec3 bar2 = hue2rgb((p1.y > -5 ? floor(p1.x / 4) / 6 : p1.x / 16) + 0.5); 44 | vec3 c2 = mix(vec3(c1), bar2, mask * saturate(ceil(4 - abs(-5 - p1.y)))); 45 | 46 | // big circle line 47 | c2 = mix(c2, vec3(1), saturate(2 - abs(max(circle, corner)) / scale)); 48 | 49 | fragColor = vec4(c2, 1); 50 | } 51 | -------------------------------------------------------------------------------- /Fragment/Text.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | 6 | out vec4 fragColor; 7 | 8 | float letter(vec2 coord) 9 | { 10 | float size = resolution.x / 25; 11 | 12 | vec2 gp = floor(coord / size * 7); // global 13 | vec2 rp = floor(fract(coord / size) * 7); // repeated 14 | 15 | vec2 odd = fract(rp * 0.5) * 2; 16 | float rnd = fract(sin(dot(gp, vec2(12.9898, 78.233))) * 43758.5453); 17 | 18 | float c = max(odd.x, odd.y) * step(0.5, rnd); // random lines 19 | c += min(odd.x, odd.y); // corder and center points 20 | 21 | c *= rp.x * (6 - rp.x); // cropping 22 | c *= rp.y * (6 - rp.y); 23 | 24 | return clamp(c, 0, 1); 25 | } 26 | 27 | void main(void) 28 | { 29 | vec2 coord = gl_FragCoord.xy; 30 | coord.x += resolution.x * 0.1 * time; 31 | 32 | float c; // MSAA with 2x2 RGSS sampling pattern 33 | c = letter(coord + vec2(-3.0 / 8, -1.0 / 8)); 34 | c += letter(coord + vec2( 1.0 / 8, -3.0 / 8)); 35 | c += letter(coord + vec2( 3.0 / 8, 1.0 / 8)); 36 | c += letter(coord + vec2(-1.0 / 8, 3.0 / 8)); 37 | fragColor = vec4(c / 4); 38 | } 39 | -------------------------------------------------------------------------------- /Fragment/Text2.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | 6 | out vec4 fragColor; 7 | 8 | float rand(vec2 uv) 9 | { 10 | return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453); 11 | } 12 | 13 | float letter(vec2 coord) 14 | { 15 | float size = resolution.x / 25; 16 | 17 | float gt = time * 0.3; // global 18 | float ct = floor(gt); // coarse 19 | float rt = fract(gt); // repeated 20 | 21 | vec2 gp = floor(coord / size * 7); // global 22 | vec2 cp = floor(coord / size); // coarse 23 | vec2 rp = floor(fract(coord / size) * 7); // repeated 24 | vec2 odd = fract(rp * 0.5) * 2; 25 | 26 | float th = (1 - pow(rand(cp + ct * 0.82), 3)) * 0.7; 27 | float amp = smoothstep(th, th + 0.03, rt); 28 | amp *= smoothstep(0, 0.05, 1 - rt); 29 | 30 | float c = max(odd.x, odd.y); // 2x2 grid 31 | c *= step(0.5, rand(gp + 0.1 * ct)); // random removal 32 | c += min(odd.x, odd.y); // border and center points 33 | 34 | c *= rp.x * (6 - rp.x); // cropping 35 | c *= rp.y * (6 - rp.y); 36 | 37 | return clamp(c, 0, 1) * amp; 38 | } 39 | 40 | void main(void) 41 | { 42 | vec2 coord = gl_FragCoord.xy; 43 | float c; // MSAA with 2x2 RGSS sampling pattern 44 | c = letter(coord + vec2(-3.0 / 8, -1.0 / 8)); 45 | c += letter(coord + vec2( 1.0 / 8, -3.0 / 8)); 46 | c += letter(coord + vec2( 3.0 / 8, 1.0 / 8)); 47 | c += letter(coord + vec2(-1.0 / 8, 3.0 / 8)); 48 | fragColor = vec4(c / 4); 49 | } 50 | -------------------------------------------------------------------------------- /Fragment/Text3.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | 6 | out vec4 fragColor; 7 | 8 | float rand(vec2 uv) 9 | { 10 | return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453); 11 | } 12 | 13 | float glyph(vec2 coord) 14 | { 15 | float chars = 25; 16 | float size = resolution.x / chars; 17 | 18 | // time 19 | float gt = time * 3.5; // global 20 | float ct = floor(gt); // coarse 21 | float rt = fract(gt); // repeated 22 | 23 | // position 24 | vec2 gp = floor(coord / size * 7); // global 25 | vec2 cp = floor(coord / size); // coarse 26 | vec2 rp = floor(fract(coord / size) * 7); // repeated 27 | vec2 odd = fract(rp * 0.5) * 2; // odd/even 28 | 29 | // scrolling 30 | vec2 gp2 = gp - vec2(0, ct * 7); // global (scrolled) 31 | vec2 cp2 = cp - vec2(0, ct); // coarse (scrolled) 32 | 33 | float c = max(odd.x, odd.y); // 2x2 grid 34 | c *= step(0.5, rand(gp2)); // random removal 35 | c += min(odd.x, odd.y); // border and center points 36 | 37 | c *= rp.x * (6 - rp.x); // cropping 38 | c *= rp.y * (6 - rp.y); 39 | 40 | c *= max(step(1, cp.y), step(cp.x, chars * rt)); // 1st line anim 41 | c *= step(0.15, rand(cp2 * 10)); // space 42 | c *= step(cp.x, rand(cp2.yy * 10) * 10 + 10); // line end 43 | 44 | float flicker = sin(time * 100 + coord.y * 3.1416 * 0.3) * 20 + 0.5; 45 | c = clamp(clamp(c, 0, 1) * flicker, 0, 1); 46 | 47 | return c; 48 | } 49 | 50 | void main(void) 51 | { 52 | fragColor = vec4(0, glyph(gl_FragCoord.xy), 0, 1); 53 | } 54 | -------------------------------------------------------------------------------- /Fragment/Tri.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | const float PI = 3.141592; 4 | uniform float time; 5 | uniform vec2 resolution; 6 | 7 | out vec4 fragColor; 8 | 9 | void main(void) 10 | { 11 | vec2 coord = gl_FragCoord.xy - resolution * 0.5; 12 | 13 | float phi = atan(coord.y, coord.x + 1e-6); 14 | float seg = fract(phi / (2 * PI) + 0.5 - 0.5 / 6) * 3; 15 | 16 | float theta = (floor(seg) * 2 / 3 + 0.5) * PI; 17 | vec2 dir = vec2(-cos(theta), -sin(theta)); 18 | 19 | float y = dot(dir, coord); 20 | float w = resolution.x * 0.08; 21 | 22 | float phase = time * 1.1; 23 | float pr = y / w - time * 1.4; 24 | float id = floor(pr) - floor(phase); 25 | 26 | float th1 = fract( id / 2) * 2; 27 | float th2 = fract((id + 1) / 2) * 2; 28 | float thp = min(1, fract(phase) + fract(seg) * 0.2); 29 | float th = mix(th1, th2, smoothstep(0.8, 1.0, thp)); 30 | 31 | float d = fract(pr); 32 | float c = clamp((abs(0.5 - d) - (1 - th) / 2) * w / 2, 0, 1); 33 | 34 | fragColor = vec4(c, c, c, 1); 35 | } 36 | -------------------------------------------------------------------------------- /Fragment/TriLattice.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | out vec4 fragColor; 6 | 7 | float rand(vec2 uv) 8 | { 9 | return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453); 10 | } 11 | 12 | vec2 uv2tri(vec2 uv) 13 | { 14 | float sx = uv.x - uv.y / 2; // skewed x 15 | float sxf = fract(sx); 16 | float offs = step(fract(1 - uv.y), sxf); 17 | return vec2(floor(sx) * 2 + sxf + offs, uv.y); 18 | } 19 | 20 | float tri(vec2 uv) 21 | { 22 | float sp = 1.2 + 3.3 * rand(floor(uv2tri(uv))); 23 | return max(0, sin(sp * time)); 24 | } 25 | 26 | void main(void) 27 | { 28 | vec2 uv = (gl_FragCoord.xy - resolution.xy / 2) / resolution.y; 29 | 30 | float t1 = time / 2; 31 | float t2 = t1 + 0.5; 32 | 33 | float c1 = tri(uv * (2 + 4 * fract(t1)) + floor(t1)); 34 | float c2 = tri(uv * (2 + 4 * fract(t2)) + floor(t2)); 35 | 36 | fragColor = vec4(mix(c1, c2, abs(1 - 2 * fract(t1)))); 37 | } 38 | -------------------------------------------------------------------------------- /Fragment/TriLattice2.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | out vec4 fragColor; 6 | 7 | float rand(vec2 uv) 8 | { 9 | return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453); 10 | } 11 | 12 | vec3 hue2rgb(float h) 13 | { 14 | h = fract(h) * 6 - 2; 15 | return clamp(vec3(abs(h - 1) - 1, 2 - abs(h), 2 - abs(h - 2)), 0, 1); 16 | } 17 | 18 | vec2 uv2tri(vec2 uv) 19 | { 20 | float sx = uv.x - uv.y / 2; // skewed x 21 | float sxf = fract(sx); 22 | float offs = step(fract(1 - uv.y), sxf); 23 | return vec2(floor(sx) * 2 + sxf + offs, uv.y); 24 | } 25 | 26 | vec3 tri(vec2 uv) 27 | { 28 | vec2 p = floor(uv2tri(uv)); 29 | float h = rand(p + 0.1) * 0.2 + time * 0.2; 30 | float s = sin((rand(p + 0.2) * 3.3 + 1.2) * time) * 0.5 + 0.5; 31 | return hue2rgb(h) * s + 0.5; 32 | } 33 | 34 | void main(void) 35 | { 36 | vec2 uv = (gl_FragCoord.xy - resolution.xy / 2) / resolution.y; 37 | 38 | float t1 = time / 2; 39 | float t2 = t1 + 0.5; 40 | 41 | vec3 c1 = tri(uv * (8 - 4 * fract(t1)) + floor(t1) * 4); 42 | vec3 c2 = tri(uv * (8 - 4 * fract(t2)) + floor(t2) * 4 + 2); 43 | 44 | fragColor = vec4(mix(c1, c2, abs(1 - 2 * fract(t1))), 1); 45 | } 46 | -------------------------------------------------------------------------------- /Fragment/TriLattice3.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | out vec4 fragColor; 6 | 7 | float rand(vec2 uv) 8 | { 9 | return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453); 10 | } 11 | 12 | vec3 hue2rgb(float h) 13 | { 14 | h = fract(h) * 6 - 2; 15 | return clamp(vec3(abs(h - 1) - 1, 2 - abs(h), 2 - abs(h - 2)), 0, 1); 16 | } 17 | 18 | vec2 uv2tri(vec2 uv) 19 | { 20 | float sx = uv.x - uv.y / 2; // skewed x 21 | float sxf = fract(sx); 22 | float offs = step(fract(1 - uv.y), sxf); 23 | return vec2(floor(sx) * 2 + sxf + offs, uv.y); 24 | } 25 | 26 | float tri(vec2 uv) 27 | { 28 | vec2 p = floor(uv2tri(uv)); 29 | p = vec2(p.x + p.y, p.y * 2); 30 | float d = length(p + 1); 31 | float f1 = 1.6 + sin(time * 0.5765) * 0.583; 32 | float f2 = 1.3 + sin(time * 1.7738) * 0.432; 33 | return abs(sin(f1 * d) * sin(f2 * d)); 34 | } 35 | 36 | void main(void) 37 | { 38 | float t = smoothstep(0.2, 0.8, fract(time)); 39 | 40 | vec2 uv = gl_FragCoord.xy - resolution.xy / 2; 41 | uv *= (2 - t) / resolution.y; 42 | 43 | float c = mix(tri(uv * 4), tri(uv * 8), t); 44 | fragColor = vec4(c, c, c, 1); 45 | } 46 | -------------------------------------------------------------------------------- /Fragment/TriLattice4.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | out vec4 fragColor; 6 | 7 | const float PI = 3.14159265359; 8 | 9 | float rand(vec2 uv) 10 | { 11 | return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453); 12 | } 13 | 14 | vec2 uv2tri(vec2 uv) 15 | { 16 | float sx = uv.x - uv.y / 2; // skewed x 17 | float sxf = fract(sx); 18 | float offs = step(fract(1 - uv.y), sxf); 19 | return vec2(floor(sx) * 2 + sxf + offs, uv.y); 20 | } 21 | 22 | void main(void) 23 | { 24 | float s = sin(time * 1.2); 25 | 26 | vec2 uv = (gl_FragCoord.xy - resolution / 2) / resolution.y; 27 | uv.x += uv.y * s * 0.1; 28 | vec2 p = uv2tri(uv * (8 + s)); 29 | 30 | float r1 = rand(floor(p) * 0.011 + 0.345) * PI * 2; 31 | float r2 = rand(floor(p) * 0.007 + 0.789) * PI * 2; 32 | 33 | p.x += p.y / 2; // unskew 34 | 35 | vec2 dir = vec2(cos(r1), sin(r1)); 36 | float t = dot(p, dir) + r2 + time * 2.94; 37 | 38 | float cr = sin(t * 1.000) * 0.4 + 0.61; 39 | float cg = sin(t * 0.782) * 0.2 + 0.22; 40 | float cb = sin(t * 0.751) * 0.3 + 0.32; 41 | 42 | fragColor = vec4(cr, cg, cb, 1); 43 | } 44 | -------------------------------------------------------------------------------- /Fragment/TriLattice5.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | out vec4 fragColor; 6 | 7 | float rand(vec2 uv) 8 | { 9 | return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453); 10 | } 11 | 12 | vec2 uv2tri(vec2 uv) 13 | { 14 | float sx = uv.x - uv.y / 2; // skewed x 15 | float sxf = fract(sx); 16 | float offs = step(fract(1 - uv.y), sxf); 17 | return vec2(floor(sx) * 2 + sxf + offs, uv.y); 18 | } 19 | 20 | void main(void) 21 | { 22 | vec2 uv = (gl_FragCoord.xy - resolution / 2) / resolution.y * 8; 23 | uv.y += time; 24 | 25 | float t = time * 0.8; 26 | float tc = floor(t); 27 | float tp = smoothstep(0, 0.8, fract(t)); 28 | 29 | vec2 r1 = vec2(floor(uv.y), tc); 30 | vec2 r2 = vec2(floor(uv.y), tc + 1); 31 | float offs = mix(rand(r1), rand(r2), tp); 32 | 33 | uv.x += offs * 8; 34 | 35 | vec2 p = uv2tri(uv); 36 | float ph = rand(floor(p)) * 6.3 + p.y * 0.2; 37 | float c = abs(sin(ph + time)); 38 | 39 | fragColor = vec4(c, c, c, 1); 40 | } 41 | -------------------------------------------------------------------------------- /Fragment/TriLattice6.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | out vec4 fragColor; 6 | 7 | float rand(vec2 uv) 8 | { 9 | return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453); 10 | } 11 | 12 | vec2 uv2tri(vec2 uv) 13 | { 14 | float sx = uv.x - uv.y / 2; // skewed x 15 | float offs = step(fract(1 - uv.y), fract(sx)); 16 | return vec2(floor(sx) * 2 + offs, floor(uv.y)); 17 | } 18 | 19 | void main(void) 20 | { 21 | vec2 uv = (gl_FragCoord.xy - resolution / 2) / resolution.y * 8; 22 | 23 | vec3 p = vec3(dot(uv, vec2(1, 0.5)), dot(uv, vec2(-1, 0.5)), uv.y); 24 | vec3 p1 = fract(+p); 25 | vec3 p2 = fract(-p); 26 | 27 | float d1 = min(min(p1.x, p1.y), p1.z); 28 | float d2 = min(min(p2.x, p2.y), p2.z); 29 | float d = min(d1, d2); 30 | 31 | vec2 tri = uv2tri(uv); 32 | float r = rand(tri) * 2 + tri.x / 16 + time * 2; 33 | float c = step(0.2 + sin(r) * 0.2, d); 34 | 35 | fragColor = vec4(c, c, c, 1); 36 | } 37 | -------------------------------------------------------------------------------- /Fragment/TriLattice7.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | out vec4 fragColor; 6 | 7 | float rand(vec2 uv) 8 | { 9 | return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453); 10 | } 11 | 12 | vec2 uv2tri(vec2 uv) 13 | { 14 | float sx = uv.x - uv.y / 2; // skewed x 15 | float offs = step(fract(1 - uv.y), fract(sx)); 16 | return vec2(floor(sx) * 2 + offs, floor(uv.y)); 17 | } 18 | 19 | void main(void) 20 | { 21 | float res = resolution.y / (5 + sin(time * 0.5)); 22 | 23 | vec2 uv = (gl_FragCoord.xy - resolution / 2) / res; 24 | uv += vec2(1, 0.5) * time; 25 | 26 | vec3 p = vec3(dot(uv, vec2(1, 0.5)), dot(uv, vec2(-1, 0.5)), uv.y); 27 | vec3 p1 = fract(+p); 28 | vec3 p2 = fract(-p); 29 | 30 | float d1 = min(min(p1.x, p1.y), p1.z); 31 | float d2 = min(min(p2.x, p2.y), p2.z); 32 | float d = min(d1, d2); 33 | float c1 = (d - 0.04) * res; 34 | 35 | float r = rand(uv2tri(uv)) * 6.3; 36 | d = dot(uv, vec2(cos(r), sin(r))) + time * 0.25; 37 | float c2 = (abs(0.5 - fract(d * 4)) - 0.18) * res / 4; 38 | 39 | float c = min(c1, c2); 40 | fragColor = vec4(c, c, c, 1); 41 | } 42 | -------------------------------------------------------------------------------- /Fragment/TriLattice8.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | out vec4 fragColor; 6 | 7 | float rand(vec2 uv) 8 | { 9 | return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453); 10 | } 11 | 12 | vec2 uv2tri(vec2 uv) 13 | { 14 | float sx = uv.x - uv.y / 2; // skewed x 15 | float offs = step(fract(1 - uv.y), fract(sx)); 16 | return vec2(floor(sx) * 2 + offs, floor(uv.y)); 17 | } 18 | 19 | void main(void) 20 | { 21 | float res = resolution.y / (5 + sin(time * 0.5)); 22 | 23 | vec2 uv = (gl_FragCoord.xy - resolution / 2) / res; 24 | 25 | vec3 p = vec3(dot(uv, vec2(1, 0.5)), dot(uv, vec2(-1, 0.5)), uv.y); 26 | vec3 p1 = fract(+p); 27 | vec3 p2 = fract(-p); 28 | 29 | // distance from borders 30 | float d1 = min(min(p1.x, p1.y), p1.z); 31 | float d2 = min(min(p2.x, p2.y), p2.z); 32 | float d = min(d1, d2); 33 | 34 | // border line 35 | float c = clamp((d - 0.04) * res, 0, 1); 36 | 37 | // gradient inside triangles 38 | float r = rand(uv2tri(uv)); 39 | c *= abs(0.5 - fract(d + r + time * 0.8)) * 2; 40 | 41 | // color variation 42 | float cb = sin(time * 4.8 + r * 32.984) * 0.5 + 0.5; 43 | vec3 rgb = mix(vec3(0.75, 0, 0), vec3(1, 0.5, 0.5), cb); 44 | 45 | fragColor = vec4(rgb * c, 1); 46 | } 47 | -------------------------------------------------------------------------------- /Fragment/ValueNoise.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform vec2 resolution; 4 | out vec4 fragColor; 5 | 6 | float rand(vec2 uv) 7 | { 8 | return fract(sin(dot(uv, vec2(12.9898, 78.233))) * 43758.5453); 9 | } 10 | 11 | float noise(vec2 p) 12 | { 13 | vec2 ip = floor(p); 14 | float r00 = rand(ip); 15 | float r01 = rand(ip + vec2(0, 1)); 16 | float r10 = rand(ip + vec2(1, 0)); 17 | float r11 = rand(ip + vec2(1, 1)); 18 | vec2 fp = smoothstep(0, 1, p - ip); 19 | return mix(mix(r00, r01, fp.y), mix(r10, r11, fp.y), fp.x); 20 | } 21 | 22 | void main(void) 23 | { 24 | vec2 p = gl_FragCoord.xy * 20 / resolution.y; 25 | fragColor = vec4(noise(p)); 26 | } 27 | -------------------------------------------------------------------------------- /Fragment/Waves.glsl: -------------------------------------------------------------------------------- 1 | float wave(vec2 coord) 2 | { 3 | float interval = iResolution.x * 0.04; 4 | vec2 p = coord / interval; 5 | 6 | float py2t = 0.112 * sin(iGlobalTime * 0.378); 7 | float phase1 = dot(p, vec2(0.00, 1.00)) + iGlobalTime * 1.338; 8 | float phase2 = dot(p, vec2(0.09, py2t)) + iGlobalTime * 0.566; 9 | float phase3 = dot(p, vec2(0.08, 0.11)) + iGlobalTime * 0.666; 10 | 11 | float pt = phase1 + sin(phase2) * 3.0; 12 | pt = abs(fract(pt) - 0.5) * interval * 0.5; 13 | 14 | float lw = 2.3 + sin(phase3) * 1.9; 15 | return saturate(lw - pt); 16 | } 17 | 18 | void main() 19 | { 20 | gl_FragColor.rgb = vec3(wave(gl_FragCoord.xy)); 21 | } -------------------------------------------------------------------------------- /Fragment/Zebra.glsl: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform float time; 4 | uniform vec2 resolution; 5 | out vec4 fragColor; 6 | 7 | void main(void) 8 | { 9 | const float pi = 3.14159265359; 10 | float size = resolution.y / 10; // cell size in pixel 11 | 12 | vec2 p1 = gl_FragCoord.xy / size; // normalized pos 13 | vec2 p2 = fract(p1) - 0.5; // relative pos from cell center 14 | 15 | // random number 16 | float rnd = dot(floor(p1), vec2(12.9898, 78.233)); 17 | rnd = fract(sin(rnd) * 43758.5453); 18 | 19 | // rotation matrix 20 | float phi = rnd * pi * 2 + time * 0.4; 21 | mat2x2 rot = mat2x2(cos(phi), -sin(phi), sin(phi), cos(phi)); 22 | 23 | vec2 p3 = rot * p2; // apply rotation 24 | p3.y += sin(p3.x * 5 + time * 2) * 0.12; // wave 25 | 26 | float rep = fract(rnd * 13.285) * 8 + 2; // line repetition 27 | float gr = fract(p3.y * rep + time * 0.8); // repeating gradient 28 | 29 | // make antialiased line by saturating the gradient 30 | float c = clamp((0.25 - abs(0.5 - gr)) * size * 0.75 / rep, 0, 1); 31 | c *= max(0, 1 - length(p2) * 0.6); // darken corners 32 | 33 | vec2 bd = (0.5 - abs(p2)) * size - 2; // border lines 34 | c *= clamp(min(bd.x, bd.y), 0, 1); 35 | 36 | fragColor = vec4(c); 37 | } 38 | -------------------------------------------------------------------------------- /Images/Adventure.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/keijiro/ShaderSketches/fbe4ee6fbaa536b202b0e5c172456ce3227f9603/Images/Adventure.png -------------------------------------------------------------------------------- /Images/MonaLisa.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/keijiro/ShaderSketches/fbe4ee6fbaa536b202b0e5c172456ce3227f9603/Images/MonaLisa.jpg -------------------------------------------------------------------------------- /Images/Primitive.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/keijiro/ShaderSketches/fbe4ee6fbaa536b202b0e5c172456ce3227f9603/Images/Primitive.png -------------------------------------------------------------------------------- /Lines/.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "shader-toy.textures": { 3 | "0": "file://C:/Users/keijiro/Documents/ShaderSketches/Images/MonaLisa.jpg" 4 | } 5 | } -------------------------------------------------------------------------------- /Lines/Lines.glsl: -------------------------------------------------------------------------------- 1 | float texture(vec2 uv, float t) 2 | { 3 | uv *= mix(0.5, 0.35, t); 4 | uv += mix(vec2(0.05, 0.2), vec2(0.4, 0.4), t); 5 | return dot(texture2D(iChannel0, uv).rgb, vec3(0.3333)); 6 | } 7 | 8 | float line(vec2 coord) 9 | { 10 | float interval = iResolution.x * 0.03; 11 | vec2 dir = normalize(vec2(1.0, 3.0)); 12 | 13 | float rel = fract(dot(coord, dir) / interval) - 0.5; 14 | vec2 uv = (coord - dir * rel * interval) / iResolution.xy; 15 | 16 | float phase = fract(iGlobalTime * 0.2); 17 | float c2w = (1.0 - cos(phase * 3.142 * 2.0)) * 3.0; 18 | float width = 0.71 + texture(uv, phase) * c2w; 19 | 20 | return saturate(width - abs(rel * interval)); 21 | } 22 | 23 | void main() 24 | { 25 | gl_FragColor = vec4(line(gl_FragCoord.xy)); 26 | } -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ShaderSketches 2 | -------------- 3 | 4 | This is a repository that stores GLSL shader sketches I created while commuting 5 | every day. You can see GIFs of these sketches from [my Tumblr]. 6 | 7 | ![gif](https://media.giphy.com/media/xUA7aLUXn5W9LgJjEc/giphy.gif) 8 | ![gif](https://media.giphy.com/media/xUA7b8A70ljiLn7P7G/giphy.gif) 9 | ![gif](https://media.giphy.com/media/l1BgRWXnktdmA9xew/giphy.gif) 10 | ![gif](https://media.giphy.com/media/3og0IUsDqjpRQwePTi/giphy.gif) 11 | 12 | I'm using [KodeLife] shader editor and [GPD Win] handheld PC for sketching. In my 13 | opinion, this is the best combination of portable development. I created all 14 | these sketches while standing in a train. 15 | 16 | Note that the coding convention of KodeLife is a bit different from [ShaderToy] 17 | or [GLSL Sandbox]. You have to modify the code to run them on these environments. 18 | 19 | ### License 20 | 21 | - Code: [Unlicense] - You can use it for whatever you want. 22 | - GIF: [CC BY 4.0] 23 | 24 | [my Tumblr]: http://radiumsoftware.tumblr.com/tagged/glsl 25 | [KodeLife]: https://hexler.net/software/kodelife 26 | [GPD Win]: https://www.indiegogo.com/projects/gpd-win-intel-z8700-win-10-os-game-console-laptop/ 27 | [ShaderToy]: https://www.shadertoy.com/ 28 | [GLSL Sandbox]: http://glslsandbox.com/ 29 | [Unlicense]: http://unlicense.org/ 30 | [CC BY 4.0]: https://creativecommons.org/licenses/by/4.0/ 31 | --------------------------------------------------------------------------------