164dda4760
ShaderCanvas rewrite: - IntersectionObserver-driven rendering: WebGL context only created when canvas enters viewport, released when it leaves. Prevents context starvation when 20+ shaders are in the feed simultaneously. - Graceful fallback UI when WebGL context unavailable (hexagon + 'scroll to load') - Context loss/restore event handlers - powerPreference: 'low-power' for feed thumbnails - Pause animation loop when off-screen (saves GPU even with context alive) - Separate resize observer (no devicePixelRatio scaling for feed — saves memory) Fixed shaders: - Pixel Art Dither: replaced mat4 dynamic indexing with unrolled Bayer lookup (some WebGL drivers reject mat4[int_var][int_var]) - Wave Interference 2D: replaced C-style array element assignment with individual vec2 variables (GLSL ES 300 compatibility)
2045 lines
96 KiB
Python
2045 lines
96 KiB
Python
"""
|
|
Fractafrag Seed Data — 200+ high-quality GLSL shaders.
|
|
|
|
Each shader is:
|
|
- Written for the 'fractafrag' system account
|
|
- Tagged comprehensively for search/filter/algorithm testing
|
|
- Flagged as is_system=True with system_label='fractafrag-curated'
|
|
- Covers 2D and 3D, every visual style imaginable
|
|
- Ready for immediate display in the feed
|
|
|
|
Usage:
|
|
docker compose exec api python /app/scripts/seed_shaders.py
|
|
"""
|
|
|
|
import asyncio
|
|
import uuid
|
|
import random
|
|
from datetime import datetime, timedelta, timezone
|
|
|
|
# System account UUID
|
|
SYSTEM_USER_ID = "00000000-0000-0000-0000-000000000001"
|
|
|
|
SHADERS = []
|
|
|
|
def s(title, code, tags, shader_type="2d", description="", style_metadata=None):
|
|
"""Helper to register a shader."""
|
|
SHADERS.append({
|
|
"title": title,
|
|
"code": code.strip(),
|
|
"tags": tags,
|
|
"shader_type": shader_type,
|
|
"description": description,
|
|
"style_metadata": style_metadata or {},
|
|
})
|
|
|
|
# ═══════════════════════════════════════════════════════════
|
|
# 2D — MATHEMATICAL / GEOMETRIC
|
|
# ═══════════════════════════════════════════════════════════
|
|
|
|
s("Spiral Galaxy", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float a = atan(uv.y, uv.x);
|
|
float r = length(uv);
|
|
float spiral = sin(a * 5.0 - r * 20.0 + iTime * 2.0);
|
|
float glow = 0.02 / (r + 0.01);
|
|
vec3 col = vec3(0.3, 0.1, 0.6) * glow + vec3(0.8, 0.4, 0.9) * spiral * exp(-r * 3.0);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["spiral", "galaxy", "mathematical", "glow", "purple"], "2d", "Logarithmic spiral arms with exponential glow falloff",
|
|
{"chaos_level": 0.4, "color_temperature": "cool", "motion_type": "rotating"})
|
|
|
|
s("Binary Rain", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
float col = 0.0;
|
|
for (int i = 0; i < 12; i++) {
|
|
float fi = float(i);
|
|
vec2 p = fract(uv * vec2(20.0, 1.0) + vec2(fi * 0.37, iTime * (0.5 + fi * 0.1)));
|
|
float drop = smoothstep(0.0, 0.1, p.y) * smoothstep(1.0, 0.8, p.y);
|
|
col += drop * step(0.7, fract(sin(fi * 73.156) * 43758.5453));
|
|
}
|
|
fragColor = vec4(0.0, col * 0.8, col * 0.3, 1.0);
|
|
}""", ["matrix", "rain", "digital", "code", "green", "cyberpunk"], "2d", "Digital rain effect inspired by the Matrix",
|
|
{"chaos_level": 0.3, "color_temperature": "cool", "motion_type": "falling"})
|
|
|
|
s("Voronoi Shatter", """
|
|
vec2 hash2(vec2 p) {
|
|
p = vec2(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5, 183.3)));
|
|
return fract(sin(p) * 43758.5453);
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.y;
|
|
vec2 n = floor(uv * 6.0);
|
|
vec2 f = fract(uv * 6.0);
|
|
float md = 8.0;
|
|
vec2 mr;
|
|
for (int j = -1; j <= 1; j++)
|
|
for (int i = -1; i <= 1; i++) {
|
|
vec2 g = vec2(float(i), float(j));
|
|
vec2 o = hash2(n + g);
|
|
o = 0.5 + 0.5 * sin(iTime + 6.2831 * o);
|
|
vec2 r = g + o - f;
|
|
float d = dot(r, r);
|
|
if (d < md) { md = d; mr = r; }
|
|
}
|
|
vec3 col = 0.5 + 0.5 * cos(md * 6.0 + vec3(0, 1, 2) + iTime);
|
|
col *= 1.0 - 0.5 * smoothstep(0.0, 0.05, md);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["voronoi", "geometric", "mosaic", "cellular", "colorful", "animated"], "2d", "Animated Voronoi tessellation with iridescent cells",
|
|
{"chaos_level": 0.5, "color_temperature": "warm", "motion_type": "morphing"})
|
|
|
|
s("Monochrome Static Interference", """
|
|
float hash(vec2 p) { return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453); }
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
float t = floor(iTime * 15.0);
|
|
float n = hash(uv * 100.0 + t);
|
|
float scanline = sin(uv.y * 800.0 + iTime * 50.0) * 0.1;
|
|
float bars = step(0.98, fract(uv.y * 30.0 + iTime * 3.0)) * 0.3;
|
|
float v = n * 0.7 + scanline + bars;
|
|
v = clamp(v, 0.0, 1.0);
|
|
fragColor = vec4(vec3(v), 1.0);
|
|
}""", ["static", "noise", "monochrome", "glitch", "tv", "analog", "bw"], "2d", "Analog TV static with scanlines and horizontal bars",
|
|
{"chaos_level": 0.9, "color_temperature": "monochrome", "motion_type": "chaotic"})
|
|
|
|
s("Mandelbrot Deep Zoom", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
float zoom = pow(2.0, -mod(iTime * 0.5, 30.0));
|
|
vec2 center = vec2(-0.7435669, 0.1314023);
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
vec2 c = center + uv * zoom;
|
|
vec2 z = vec2(0.0);
|
|
int iter = 0;
|
|
for (int i = 0; i < 256; i++) {
|
|
z = vec2(z.x*z.x - z.y*z.y, 2.0*z.x*z.y) + c;
|
|
if (dot(z, z) > 4.0) break;
|
|
iter = i;
|
|
}
|
|
float t = float(iter) / 256.0;
|
|
vec3 col = 0.5 + 0.5 * cos(3.0 + t * 15.0 + vec3(0.0, 0.6, 1.0));
|
|
if (iter == 255) col = vec3(0.0);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["mandelbrot", "fractal", "zoom", "mathematical", "infinite", "complex"], "2d", "Continuously zooming into the Mandelbrot set boundary",
|
|
{"chaos_level": 0.6, "color_temperature": "cool", "motion_type": "zooming"})
|
|
|
|
s("Neon Grid Pulse", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
vec2 grid = abs(fract(uv * 8.0 - 0.5) - 0.5);
|
|
float d = min(grid.x, grid.y);
|
|
float pulse = sin(iTime * 3.0 + length(uv) * 10.0) * 0.5 + 0.5;
|
|
float line = smoothstep(0.02, 0.0, d);
|
|
vec3 col = vec3(0.0);
|
|
col += vec3(0.0, 1.0, 0.8) * line * pulse;
|
|
col += vec3(1.0, 0.0, 0.5) * line * (1.0 - pulse);
|
|
col += vec3(0.02, 0.0, 0.04);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["grid", "neon", "synthwave", "retro", "tron", "pulse", "cyberpunk"], "2d", "Retro neon grid with alternating color pulses",
|
|
{"chaos_level": 0.2, "color_temperature": "cool", "motion_type": "pulsing"})
|
|
|
|
s("Ink in Water", """
|
|
float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
|
|
float noise(vec2 p) {
|
|
vec2 i = floor(p); vec2 f = fract(p);
|
|
f = f * f * (3.0 - 2.0 * f);
|
|
return mix(mix(hash(i), hash(i + vec2(1, 0)), f.x),
|
|
mix(hash(i + vec2(0, 1)), hash(i + vec2(1, 1)), f.x), f.y);
|
|
}
|
|
float fbm(vec2 p) {
|
|
float v = 0.0, a = 0.5;
|
|
mat2 rot = mat2(0.8, 0.6, -0.6, 0.8);
|
|
for (int i = 0; i < 7; i++) { v += a * noise(p); p = rot * p * 2.0; a *= 0.5; }
|
|
return v;
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
float t = iTime * 0.15;
|
|
float f1 = fbm(uv * 3.0 + t);
|
|
float f2 = fbm(uv * 3.0 + f1 * 2.0 + t * 0.7);
|
|
float f3 = fbm(uv * 3.0 + f2 * 2.0);
|
|
vec3 col = mix(vec3(0.05, 0.02, 0.1), vec3(0.1, 0.0, 0.3), f1);
|
|
col = mix(col, vec3(0.6, 0.1, 0.2), f2 * 0.6);
|
|
col = mix(col, vec3(0.9, 0.8, 0.6), f3 * f3 * 0.5);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["fluid", "ink", "water", "organic", "fbm", "noise", "elegant", "dark"], "2d", "Layered fractal brownian motion simulating ink diffusing in water",
|
|
{"chaos_level": 0.5, "color_temperature": "warm", "motion_type": "fluid"})
|
|
|
|
s("Kaleidoscope Mirror", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float a = atan(uv.y, uv.x);
|
|
float r = length(uv);
|
|
float segments = 8.0;
|
|
a = mod(a, 6.2831 / segments);
|
|
a = abs(a - 3.14159 / segments);
|
|
vec2 p = vec2(cos(a), sin(a)) * r;
|
|
p += iTime * 0.2;
|
|
float pattern = sin(p.x * 15.0) * sin(p.y * 15.0);
|
|
pattern += sin(p.x * 7.0 + iTime) * cos(p.y * 9.0 - iTime * 0.5);
|
|
vec3 col = 0.5 + 0.5 * cos(pattern * 2.0 + iTime + vec3(0, 2, 4));
|
|
col *= smoothstep(1.5, 0.0, r);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["kaleidoscope", "symmetry", "mirror", "psychedelic", "colorful", "geometric"], "2d", "8-fold kaleidoscope with evolving sine patterns",
|
|
{"chaos_level": 0.6, "color_temperature": "neutral", "motion_type": "rotating"})
|
|
|
|
s("Plasma Lava Lamp", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
float t = iTime * 0.5;
|
|
float v = 0.0;
|
|
v += sin(uv.x * 10.0 + t);
|
|
v += sin((uv.y * 10.0 + t) * 0.5);
|
|
v += sin((uv.x * 10.0 + uv.y * 10.0 + t) * 0.3);
|
|
vec2 c = uv * 10.0 + vec2(sin(t * 0.3) * 5.0, cos(t * 0.5) * 5.0);
|
|
v += sin(length(c) + t);
|
|
v *= 0.5;
|
|
vec3 col;
|
|
col.r = sin(v * 3.14159) * 0.5 + 0.5;
|
|
col.g = sin(v * 3.14159 + 2.094) * 0.3 + 0.2;
|
|
col.b = sin(v * 3.14159 + 4.189) * 0.5 + 0.5;
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["plasma", "lava", "retro", "colorful", "animated", "smooth", "classic"], "2d", "Classic plasma effect with lava lamp color cycling",
|
|
{"chaos_level": 0.3, "color_temperature": "warm", "motion_type": "fluid"})
|
|
|
|
s("Circuit Board", """
|
|
float hash(float n) { return fract(sin(n) * 43758.5453); }
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
vec2 g = floor(uv * 30.0);
|
|
vec2 f = fract(uv * 30.0);
|
|
float id = hash(g.x + g.y * 137.0);
|
|
float trace = 0.0;
|
|
if (id > 0.5) trace = step(0.45, f.x) * step(f.x, 0.55);
|
|
else trace = step(0.45, f.y) * step(f.y, 0.55);
|
|
float node = smoothstep(0.3, 0.25, length(f - 0.5));
|
|
float pulse = sin(iTime * 3.0 + (g.x + g.y) * 0.5) * 0.5 + 0.5;
|
|
vec3 col = vec3(0.0, 0.15, 0.1);
|
|
col += vec3(0.0, 0.8, 0.4) * trace * (0.3 + 0.7 * pulse);
|
|
col += vec3(0.0, 1.0, 0.6) * node * pulse;
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["circuit", "digital", "tech", "pcb", "green", "electronic", "grid"], "2d", "Procedural circuit board with animated signal pulses",
|
|
{"chaos_level": 0.2, "color_temperature": "cool", "motion_type": "pulsing"})
|
|
|
|
s("Aurora Borealis", """
|
|
float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
|
|
float noise(vec2 p) {
|
|
vec2 i = floor(p); vec2 f = fract(p);
|
|
f = f * f * (3.0 - 2.0 * f);
|
|
return mix(mix(hash(i), hash(i + vec2(1, 0)), f.x),
|
|
mix(hash(i + vec2(0, 1)), hash(i + vec2(1, 1)), f.x), f.y);
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
float t = iTime * 0.2;
|
|
float n = 0.0;
|
|
n += noise(vec2(uv.x * 3.0 + t, uv.y * 0.5)) * 0.5;
|
|
n += noise(vec2(uv.x * 6.0 - t * 0.7, uv.y * 1.0 + t * 0.3)) * 0.25;
|
|
n += noise(vec2(uv.x * 12.0 + t * 0.5, uv.y * 2.0)) * 0.125;
|
|
float curtain = smoothstep(0.3, 0.7, uv.y) * smoothstep(1.0, 0.6, uv.y);
|
|
curtain *= n;
|
|
vec3 green = vec3(0.1, 0.9, 0.3);
|
|
vec3 purple = vec3(0.5, 0.1, 0.8);
|
|
vec3 col = mix(green, purple, uv.y) * curtain * 2.0;
|
|
col += vec3(0.01, 0.0, 0.03); // night sky
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["aurora", "borealis", "nature", "night", "sky", "green", "purple", "atmospheric"], "2d", "Northern lights curtain with layered noise movement",
|
|
{"chaos_level": 0.3, "color_temperature": "cool", "motion_type": "fluid"})
|
|
|
|
s("Op Art Illusion", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float d = length(uv);
|
|
float a = atan(uv.y, uv.x);
|
|
float pattern = sin(d * 40.0 - iTime * 4.0) * sin(a * 12.0 + iTime * 2.0);
|
|
float bw = step(0.0, pattern);
|
|
float warp = sin(d * 20.0 + iTime) * 0.05;
|
|
bw = step(0.0, sin((d + warp) * 40.0 - iTime * 4.0) * sin(a * 12.0 + iTime * 2.0));
|
|
fragColor = vec4(vec3(bw), 1.0);
|
|
}""", ["op-art", "illusion", "optical", "bw", "monochrome", "geometric", "hypnotic", "pattern"], "2d", "Black and white optical illusion with warping concentric rings",
|
|
{"chaos_level": 0.7, "color_temperature": "monochrome", "motion_type": "pulsing"})
|
|
|
|
s("Glitch Corruption", """
|
|
float hash(float n) { return fract(sin(n) * 43758.5453); }
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
float t = floor(iTime * 8.0);
|
|
float block = floor(uv.y * 20.0);
|
|
float shift = hash(block + t) * step(0.85, hash(block * 0.3 + t));
|
|
uv.x += shift * 0.3 * (hash(t + block * 7.0) - 0.5);
|
|
vec3 col;
|
|
col.r = step(0.5, fract(sin(dot(uv + 0.01, vec2(12.9, 78.2))) * 43758.5));
|
|
col.g = step(0.5, fract(sin(dot(uv, vec2(12.9, 78.2))) * 43758.5));
|
|
col.b = step(0.5, fract(sin(dot(uv - 0.01, vec2(12.9, 78.2))) * 43758.5));
|
|
float scanline = sin(uv.y * 500.0) * 0.04;
|
|
col += scanline;
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["glitch", "corruption", "digital", "error", "rgb-split", "cyberpunk", "broken"], "2d", "Data corruption with RGB channel splitting and block displacement",
|
|
{"chaos_level": 0.95, "color_temperature": "neutral", "motion_type": "chaotic"})
|
|
|
|
s("Sunset Gradient Waves", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
float wave = sin(uv.x * 8.0 + iTime) * 0.03;
|
|
wave += sin(uv.x * 15.0 - iTime * 1.5) * 0.015;
|
|
float y = uv.y + wave;
|
|
vec3 sky1 = vec3(0.1, 0.0, 0.2);
|
|
vec3 sky2 = vec3(0.8, 0.2, 0.1);
|
|
vec3 sky3 = vec3(1.0, 0.7, 0.2);
|
|
vec3 col;
|
|
if (y > 0.6) col = mix(sky2, sky1, (y - 0.6) / 0.4);
|
|
else if (y > 0.3) col = mix(sky3, sky2, (y - 0.3) / 0.3);
|
|
else col = mix(vec3(1.0, 0.9, 0.5), sky3, y / 0.3);
|
|
float sun = smoothstep(0.12, 0.1, length(vec2(uv.x - 0.5, y - 0.45)));
|
|
col = mix(col, vec3(1.0, 0.95, 0.8), sun);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["sunset", "gradient", "sky", "warm", "peaceful", "nature", "waves", "orange"], "2d", "Stylized sunset with layered gradient and gentle wave distortion",
|
|
{"chaos_level": 0.1, "color_temperature": "warm", "motion_type": "fluid"})
|
|
|
|
s("Hyperbolic Tiling", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float t = iTime * 0.3;
|
|
float scale = 1.0;
|
|
vec3 col = vec3(0.0);
|
|
for (int i = 0; i < 8; i++) {
|
|
uv = abs(uv) - 0.5;
|
|
uv *= 1.5;
|
|
scale *= 1.5;
|
|
float fi = float(i);
|
|
uv *= mat2(cos(t + fi), sin(t + fi), -sin(t + fi), cos(t + fi));
|
|
}
|
|
float d = length(uv) / scale;
|
|
col = 0.5 + 0.5 * cos(d * 50.0 + iTime * 2.0 + vec3(0, 2, 4));
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["hyperbolic", "tiling", "fractal", "recursive", "mathematical", "colorful", "abstract"], "2d", "Iterated function system creating hyperbolic-style tiling",
|
|
{"chaos_level": 0.7, "color_temperature": "neutral", "motion_type": "rotating"})
|
|
|
|
s("Liquid Metal", """
|
|
float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
|
|
float noise(vec2 p) {
|
|
vec2 i = floor(p); vec2 f = fract(p);
|
|
f = f * f * (3.0 - 2.0 * f);
|
|
return mix(mix(hash(i), hash(i + vec2(1, 0)), f.x),
|
|
mix(hash(i + vec2(0, 1)), hash(i + vec2(1, 1)), f.x), f.y);
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
float t = iTime * 0.3;
|
|
vec2 p = uv * 4.0;
|
|
float n = noise(p + t) + noise(p * 2.0 - t * 0.7) * 0.5 + noise(p * 4.0 + t * 0.3) * 0.25;
|
|
n = n / 1.75;
|
|
float env = pow(n, 1.5);
|
|
vec3 col = mix(vec3(0.3, 0.3, 0.35), vec3(0.9, 0.9, 0.95), env);
|
|
float spec = pow(max(0.0, n * 2.0 - 1.0), 8.0);
|
|
col += vec3(1.0) * spec * 0.5;
|
|
col = mix(col, col * vec3(0.8, 0.85, 1.0), 0.3);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["metal", "liquid", "chrome", "silver", "reflective", "smooth", "elegant"], "2d", "Flowing liquid mercury surface with specular highlights",
|
|
{"chaos_level": 0.3, "color_temperature": "cool", "motion_type": "fluid"})
|
|
|
|
s("Firework Burst", """
|
|
float hash(float n) { return fract(sin(n) * 43758.5453); }
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
vec3 col = vec3(0.0);
|
|
for (int b = 0; b < 5; b++) {
|
|
float fb = float(b);
|
|
float bt = mod(iTime + fb * 1.3, 4.0);
|
|
vec2 center = vec2(hash(fb * 7.0) - 0.5, hash(fb * 13.0) * 0.3 + 0.1) * 0.8;
|
|
float expand = bt * 0.4;
|
|
float fade = exp(-bt * 1.5);
|
|
for (int i = 0; i < 30; i++) {
|
|
float fi = float(i);
|
|
float angle = fi * 0.2094 + fb;
|
|
float speed = 0.8 + hash(fi + fb * 100.0) * 0.4;
|
|
vec2 pp = center + vec2(cos(angle), sin(angle)) * expand * speed;
|
|
pp.y -= bt * bt * 0.05; // gravity
|
|
float d = length(uv - pp);
|
|
vec3 sparkCol = 0.5 + 0.5 * cos(fb * 2.0 + vec3(0, 2, 4));
|
|
col += sparkCol * 0.003 / (d + 0.001) * fade;
|
|
}
|
|
}
|
|
col = min(col, 1.0);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["fireworks", "particles", "celebration", "explosion", "night", "colorful", "sparks"], "2d", "Multiple firework bursts with particle trails and gravity",
|
|
{"chaos_level": 0.7, "color_temperature": "warm", "motion_type": "explosive"})
|
|
|
|
s("Moiré Interference", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float d1 = length(uv - vec2(sin(iTime * 0.5) * 0.3, 0.0));
|
|
float d2 = length(uv + vec2(sin(iTime * 0.5) * 0.3, 0.0));
|
|
float p1 = sin(d1 * 60.0);
|
|
float p2 = sin(d2 * 60.0);
|
|
float moire = p1 * p2;
|
|
vec3 col = vec3(moire * 0.5 + 0.5);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["moire", "interference", "optical", "monochrome", "geometric", "minimal", "waves"], "2d", "Two overlapping circular wave patterns creating moiré interference",
|
|
{"chaos_level": 0.4, "color_temperature": "monochrome", "motion_type": "oscillating"})
|
|
|
|
s("Electric Storm", """
|
|
float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
|
|
float noise(vec2 p) {
|
|
vec2 i = floor(p); vec2 f = fract(p);
|
|
f = f * f * (3.0 - 2.0 * f);
|
|
return mix(mix(hash(i), hash(i + vec2(1, 0)), f.x),
|
|
mix(hash(i + vec2(0, 1)), hash(i + vec2(1, 1)), f.x), f.y);
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float t = iTime;
|
|
float bolt = 0.0;
|
|
for (int i = 0; i < 5; i++) {
|
|
float fi = float(i);
|
|
vec2 p = vec2(uv.x + noise(vec2(uv.y * 10.0 + t * 5.0, fi)) * 0.3, uv.y);
|
|
float d = abs(p.x - (fi - 2.0) * 0.15);
|
|
bolt += 0.005 / (d + 0.005) * step(0.7, noise(vec2(fi, floor(t * 3.0))));
|
|
}
|
|
vec3 col = vec3(0.02, 0.0, 0.05);
|
|
col += vec3(0.3, 0.5, 1.0) * bolt;
|
|
col += vec3(0.8, 0.9, 1.0) * bolt * bolt;
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["lightning", "storm", "electric", "blue", "energy", "dramatic", "weather"], "2d", "Electric lightning bolts crackling across a dark sky",
|
|
{"chaos_level": 0.8, "color_temperature": "cool", "motion_type": "chaotic"})
|
|
|
|
s("Hexagonal Grid", """
|
|
vec2 hexUV(vec2 uv) {
|
|
vec2 s = vec2(1.7320508, 1.0);
|
|
vec2 a = mod(uv, s) - s * 0.5;
|
|
vec2 b = mod(uv - s * 0.5, s) - s * 0.5;
|
|
return dot(a, a) < dot(b, b) ? a : b;
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
vec2 h = hexUV(uv * 8.0);
|
|
float d = length(h);
|
|
float edge = smoothstep(0.5, 0.48, d);
|
|
float inner = smoothstep(0.3, 0.28, d);
|
|
float pulse = sin(iTime * 2.0 + length(floor(uv * 8.0)) * 2.0) * 0.5 + 0.5;
|
|
vec3 col = vec3(0.05);
|
|
col += vec3(0.0, 0.6, 0.8) * (edge - inner) * 0.5;
|
|
col += vec3(0.0, 0.8, 1.0) * inner * pulse;
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["hexagon", "grid", "geometric", "teal", "tech", "clean", "pattern", "honeycomb"], "2d", "Pulsing hexagonal grid with teal neon glow",
|
|
{"chaos_level": 0.2, "color_temperature": "cool", "motion_type": "pulsing"})
|
|
|
|
# ═══════════════════════════════════════════════════════════
|
|
# 3D — RAY MARCHING
|
|
# ═══════════════════════════════════════════════════════════
|
|
|
|
s("Infinite Tunnel", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float a = atan(uv.y, uv.x);
|
|
float r = length(uv);
|
|
float tunnel = 1.0 / r;
|
|
float tex = sin(a * 6.0 + tunnel * 2.0 - iTime * 3.0);
|
|
tex *= sin(tunnel * 4.0 - iTime * 2.0);
|
|
vec3 col = 0.5 + 0.5 * cos(tex * 3.0 + iTime + vec3(0, 2, 4));
|
|
col *= smoothstep(0.0, 0.3, r) * (1.0 - smoothstep(0.8, 2.0, r));
|
|
col *= 1.0 / (r * 3.0);
|
|
fragColor = vec4(clamp(col, 0.0, 1.0), 1.0);
|
|
}""", ["tunnel", "infinite", "warp", "psychedelic", "vortex", "3d-illusion", "trippy"], "3d", "Infinite tunnel flythrough with warping hexagonal texture",
|
|
{"chaos_level": 0.6, "color_temperature": "neutral", "motion_type": "forward"})
|
|
|
|
s("Raymarched Metaballs", """
|
|
float sdSphere(vec3 p, float r) { return length(p) - r; }
|
|
float map(vec3 p) {
|
|
float d = 1e10;
|
|
for (int i = 0; i < 5; i++) {
|
|
float fi = float(i);
|
|
vec3 center = vec3(
|
|
sin(iTime + fi * 1.3) * 0.8,
|
|
cos(iTime * 0.7 + fi * 2.1) * 0.6,
|
|
sin(iTime * 0.5 + fi * 0.9) * 0.5
|
|
);
|
|
d = min(d, sdSphere(p - center, 0.4));
|
|
}
|
|
// smooth union
|
|
return d;
|
|
}
|
|
vec3 getNormal(vec3 p) {
|
|
vec2 e = vec2(0.001, 0.0);
|
|
return normalize(vec3(map(p+e.xyy)-map(p-e.xyy), map(p+e.yxy)-map(p-e.yxy), map(p+e.yyx)-map(p-e.yyx)));
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
vec3 ro = vec3(0, 0, -3);
|
|
vec3 rd = normalize(vec3(uv, 1.0));
|
|
float t = 0.0;
|
|
for (int i = 0; i < 64; i++) {
|
|
float d = map(ro + rd * t);
|
|
if (d < 0.001 || t > 20.0) break;
|
|
t += d;
|
|
}
|
|
vec3 col = vec3(0.02, 0.01, 0.05);
|
|
if (t < 20.0) {
|
|
vec3 p = ro + rd * t;
|
|
vec3 n = getNormal(p);
|
|
vec3 light = normalize(vec3(1, 1, -1));
|
|
float diff = max(dot(n, light), 0.0);
|
|
float spec = pow(max(dot(reflect(-light, n), -rd), 0.0), 32.0);
|
|
col = vec3(0.8, 0.2, 0.4) * diff + vec3(1.0) * spec * 0.5 + vec3(0.05, 0.02, 0.08);
|
|
}
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["metaballs", "3d", "raymarching", "organic", "blobs", "smooth", "pink"], "3d", "Five orbiting raymarched spheres with specular lighting",
|
|
{"chaos_level": 0.4, "color_temperature": "warm", "motion_type": "orbiting"})
|
|
|
|
s("Fractal Mountain Terrain", """
|
|
float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
|
|
float noise(vec2 p) {
|
|
vec2 i = floor(p); vec2 f = fract(p);
|
|
f = f * f * (3.0 - 2.0 * f);
|
|
return mix(mix(hash(i), hash(i + vec2(1, 0)), f.x),
|
|
mix(hash(i + vec2(0, 1)), hash(i + vec2(1, 1)), f.x), f.y);
|
|
}
|
|
float terrain(vec2 p) {
|
|
float h = 0.0, a = 0.5;
|
|
for (int i = 0; i < 6; i++) { h += a * noise(p); p *= 2.0; a *= 0.5; }
|
|
return h;
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
vec3 ro = vec3(iTime * 0.5, 1.5, 0.0);
|
|
vec3 rd = normalize(vec3(uv.x, uv.y - 0.2, 1.0));
|
|
float t = 0.0;
|
|
vec3 col = vec3(0.4, 0.6, 0.9); // sky
|
|
for (int i = 0; i < 80; i++) {
|
|
vec3 p = ro + rd * t;
|
|
float h = terrain(p.xz) * 2.0;
|
|
if (p.y < h) {
|
|
vec3 n = normalize(vec3(
|
|
terrain(p.xz + vec2(0.01, 0)) - terrain(p.xz - vec2(0.01, 0)),
|
|
0.02,
|
|
terrain(p.xz + vec2(0, 0.01)) - terrain(p.xz - vec2(0, 0.01))
|
|
));
|
|
float sun = max(dot(n, normalize(vec3(1, 0.8, 0.5))), 0.0);
|
|
col = mix(vec3(0.2, 0.3, 0.1), vec3(0.5, 0.4, 0.3), p.y / 2.0) * (0.3 + 0.7 * sun);
|
|
col = mix(col, vec3(0.4, 0.6, 0.9), 1.0 - exp(-t * 0.03));
|
|
break;
|
|
}
|
|
t += 0.05 + t * 0.01;
|
|
}
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["terrain", "mountain", "landscape", "3d", "raymarching", "nature", "flyover", "procedural"], "3d", "Procedural fractal terrain with aerial flyover and atmospheric fog",
|
|
{"chaos_level": 0.3, "color_temperature": "neutral", "motion_type": "forward"})
|
|
|
|
s("Neon Torus Knot", """
|
|
float sdTorus(vec3 p, vec2 t) {
|
|
vec2 q = vec2(length(p.xz) - t.x, p.y);
|
|
return length(q) - t.y;
|
|
}
|
|
float map(vec3 p) {
|
|
float a = iTime * 0.5;
|
|
p.xz *= mat2(cos(a), sin(a), -sin(a), cos(a));
|
|
// trefoil knot via torus deformation
|
|
float r = length(p.xz);
|
|
float theta = atan(p.z, p.x);
|
|
vec3 q = vec3(r - 1.0, p.y, 0.0);
|
|
float knotAngle = theta * 3.0 + iTime;
|
|
q.xy -= 0.4 * vec2(cos(knotAngle), sin(knotAngle));
|
|
return length(q) - 0.15;
|
|
}
|
|
vec3 getNormal(vec3 p) {
|
|
vec2 e = vec2(0.001, 0);
|
|
return normalize(vec3(map(p+e.xyy)-map(p-e.xyy), map(p+e.yxy)-map(p-e.yxy), map(p+e.yyx)-map(p-e.yyx)));
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
vec3 ro = vec3(0, 0, -3.5);
|
|
vec3 rd = normalize(vec3(uv, 1.0));
|
|
float t = 0.0;
|
|
vec3 col = vec3(0.01);
|
|
for (int i = 0; i < 80; i++) {
|
|
float d = map(ro + rd * t);
|
|
if (d < 0.001) {
|
|
vec3 p = ro + rd * t;
|
|
vec3 n = getNormal(p);
|
|
float fresnel = pow(1.0 - abs(dot(n, rd)), 3.0);
|
|
col = vec3(0.0, 0.8, 1.0) * (0.2 + 0.8 * fresnel);
|
|
col += vec3(1.0, 0.3, 0.8) * fresnel * fresnel;
|
|
float glow = 0.005 / (d + 0.005);
|
|
col += vec3(0.0, 0.4, 0.6) * glow;
|
|
break;
|
|
}
|
|
t += d;
|
|
if (t > 20.0) break;
|
|
// Accumulate glow from near-misses
|
|
col += vec3(0.0, 0.3, 0.5) * 0.002 / (d + 0.01);
|
|
}
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["torus", "knot", "3d", "neon", "raymarching", "glow", "cyan", "mathematical", "geometry"], "3d", "Raymarched trefoil torus knot with neon fresnel glow",
|
|
{"chaos_level": 0.4, "color_temperature": "cool", "motion_type": "rotating"})
|
|
|
|
s("Glass Refraction Orb", """
|
|
float sdSphere(vec3 p, float r) { return length(p) - r; }
|
|
float map(vec3 p) { return sdSphere(p, 1.0); }
|
|
vec3 getNormal(vec3 p) {
|
|
vec2 e = vec2(0.001, 0);
|
|
return normalize(vec3(map(p+e.xyy)-map(p-e.xyy), map(p+e.yxy)-map(p-e.yxy), map(p+e.yyx)-map(p-e.yyx)));
|
|
}
|
|
vec3 background(vec3 rd) {
|
|
float t = iTime * 0.3;
|
|
return 0.5 + 0.5 * cos(rd * 5.0 + t + vec3(0, 2, 4));
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
vec3 ro = vec3(0, 0, -3);
|
|
vec3 rd = normalize(vec3(uv, 1.0));
|
|
float t = 0.0;
|
|
for (int i = 0; i < 64; i++) {
|
|
float d = map(ro + rd * t);
|
|
if (d < 0.001) break;
|
|
t += d;
|
|
if (t > 20.0) break;
|
|
}
|
|
vec3 col;
|
|
if (t < 20.0) {
|
|
vec3 p = ro + rd * t;
|
|
vec3 n = getNormal(p);
|
|
float fresnel = pow(1.0 - abs(dot(n, rd)), 4.0);
|
|
vec3 refl = reflect(rd, n);
|
|
vec3 refr = refract(rd, n, 0.7);
|
|
col = mix(background(refr) * 0.8, background(refl), fresnel);
|
|
col += vec3(1.0) * pow(max(dot(refl, normalize(vec3(1, 1, -1))), 0.0), 64.0) * 0.5;
|
|
} else {
|
|
col = background(rd) * 0.3;
|
|
}
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["glass", "sphere", "refraction", "3d", "raymarching", "crystal", "transparent", "elegant"], "3d", "Transparent glass sphere with refraction and reflection",
|
|
{"chaos_level": 0.2, "color_temperature": "neutral", "motion_type": "static"})
|
|
|
|
# ═══════════════════════════════════════════════════════════
|
|
# MORE 2D VARIETY
|
|
# ═══════════════════════════════════════════════════════════
|
|
|
|
s("Cellular Automata Flow", """
|
|
float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
float t = floor(iTime * 4.0);
|
|
vec2 cell = floor(uv * 40.0);
|
|
float alive = step(0.5, hash(cell + t * 0.01));
|
|
float neighbors = 0.0;
|
|
for (int x = -1; x <= 1; x++)
|
|
for (int y = -1; y <= 1; y++) {
|
|
if (x == 0 && y == 0) continue;
|
|
neighbors += step(0.5, hash(cell + vec2(float(x), float(y)) + t * 0.01));
|
|
}
|
|
float next = step(2.5, neighbors) * step(neighbors, 3.5) * (1.0 - alive)
|
|
+ step(1.5, neighbors) * step(neighbors, 3.5) * alive;
|
|
vec3 col = mix(vec3(0.05, 0.0, 0.1), vec3(0.0, 0.8, 0.4), next);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["cellular-automata", "conway", "life", "grid", "simulation", "green", "digital"], "2d", "Game of Life style cellular automata with hash-based state",
|
|
{"chaos_level": 0.6, "color_temperature": "cool", "motion_type": "evolving"})
|
|
|
|
s("Blackhole Gravity Lens", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float r = length(uv);
|
|
float a = atan(uv.y, uv.x);
|
|
float warp = 0.3 / (r + 0.01);
|
|
vec2 warped = vec2(cos(a + warp), sin(a + warp)) * (r + 0.1 / r);
|
|
float stars = step(0.98, fract(sin(dot(floor(warped * 20.0), vec2(127.1, 311.7))) * 43758.5453));
|
|
float disk = smoothstep(0.4, 0.3, abs(warped.y * 5.0 / (length(warped) + 0.1)))
|
|
* smoothstep(0.1, 0.2, r) * smoothstep(0.8, 0.4, r);
|
|
vec3 col = vec3(0.0);
|
|
col += vec3(0.7, 0.5, 0.3) * disk * (sin(warped.x * 30.0 + iTime * 5.0) * 0.3 + 0.7);
|
|
col += vec3(0.8, 0.9, 1.0) * stars * (1.0 - smoothstep(0.0, 0.15, r));
|
|
col += vec3(0.8, 0.9, 1.0) * stars * smoothstep(0.3, 0.5, r);
|
|
float shadow = smoothstep(0.12, 0.1, r);
|
|
col *= 1.0 - shadow;
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["blackhole", "space", "gravity", "lens", "accretion", "cosmic", "sci-fi", "dark"], "2d", "Gravitational lensing around a black hole with accretion disk",
|
|
{"chaos_level": 0.5, "color_temperature": "warm", "motion_type": "rotating"})
|
|
|
|
s("Waveform Oscilloscope", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
uv.y = uv.y * 2.0 - 1.0;
|
|
float wave = sin(uv.x * 25.0 + iTime * 5.0) * 0.3;
|
|
wave += sin(uv.x * 13.0 - iTime * 3.0) * 0.15;
|
|
wave += sin(uv.x * 47.0 + iTime * 8.0) * 0.05;
|
|
float d = abs(uv.y - wave);
|
|
float line = 0.003 / d;
|
|
float glow = 0.01 / d;
|
|
vec3 col = vec3(0.0);
|
|
col += vec3(0.0, 1.0, 0.3) * line;
|
|
col += vec3(0.0, 0.4, 0.15) * glow;
|
|
float grid = step(0.99, fract(uv.x * 10.0)) + step(0.99, fract((uv.y * 0.5 + 0.5) * 5.0));
|
|
col += vec3(0.03) * grid;
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["waveform", "oscilloscope", "audio", "signal", "green", "tech", "minimal", "retro"], "2d", "Animated oscilloscope display with composite waveform",
|
|
{"chaos_level": 0.3, "color_temperature": "cool", "motion_type": "oscillating"})
|
|
|
|
s("Sacred Geometry Flower", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float r = length(uv);
|
|
float a = atan(uv.y, uv.x);
|
|
float petals = abs(sin(a * 6.0 + iTime * 0.5)) * 0.3 + 0.2;
|
|
float flower = smoothstep(petals + 0.01, petals, r);
|
|
float inner = smoothstep(0.08, 0.06, r);
|
|
float rings = sin(r * 60.0 - iTime * 3.0) * 0.5 + 0.5;
|
|
rings *= smoothstep(0.5, 0.1, r);
|
|
vec3 col = vec3(0.02, 0.0, 0.04);
|
|
col += vec3(0.8, 0.4, 0.1) * flower * rings;
|
|
col += vec3(1.0, 0.8, 0.3) * inner;
|
|
col += vec3(0.3, 0.0, 0.5) * (1.0 - flower) * rings * 0.3;
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["sacred-geometry", "flower", "mandala", "spiritual", "gold", "symmetry", "organic"], "2d", "Sacred geometry flower of life with golden petal animation",
|
|
{"chaos_level": 0.2, "color_temperature": "warm", "motion_type": "breathing"})
|
|
|
|
s("Pixel Art Dither", """
|
|
float bayer4(vec2 p) {
|
|
vec2 q = mod(p, 4.0);
|
|
float b = mod(q.x + q.y * 4.0, 16.0);
|
|
// Bayer 4x4 unrolled
|
|
float t = 0.0;
|
|
if (b < 1.0) t = 0.0; else if (b < 2.0) t = 8.0;
|
|
else if (b < 3.0) t = 2.0; else if (b < 4.0) t = 10.0;
|
|
else if (b < 5.0) t = 12.0; else if (b < 6.0) t = 4.0;
|
|
else if (b < 7.0) t = 14.0; else if (b < 8.0) t = 6.0;
|
|
else if (b < 9.0) t = 3.0; else if (b < 10.0) t = 11.0;
|
|
else if (b < 11.0) t = 1.0; else if (b < 12.0) t = 9.0;
|
|
else if (b < 13.0) t = 15.0; else if (b < 14.0) t = 7.0;
|
|
else if (b < 15.0) t = 13.0; else t = 5.0;
|
|
return t / 16.0;
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
vec2 pixel = floor(fragCoord / 4.0);
|
|
float t = iTime * 0.5;
|
|
float wave = sin(uv.x * 5.0 + t) * sin(uv.y * 3.0 + t * 0.7) * 0.5 + 0.5;
|
|
float d = step(bayer4(pixel), wave);
|
|
vec3 dark = vec3(0.08, 0.04, 0.15);
|
|
vec3 light = vec3(0.3, 0.8, 0.6);
|
|
vec3 col = mix(dark, light, d);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["pixel-art", "dither", "retro", "8bit", "bayer", "low-fi", "nostalgic"], "2d", "Bayer matrix ordered dithering with animated value field",
|
|
{"chaos_level": 0.3, "color_temperature": "cool", "motion_type": "pulsing"})
|
|
|
|
s("Reaction Diffusion", """
|
|
float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
|
|
float noise(vec2 p) {
|
|
vec2 i = floor(p); vec2 f = fract(p);
|
|
f = f * f * (3.0 - 2.0 * f);
|
|
return mix(mix(hash(i), hash(i + vec2(1, 0)), f.x),
|
|
mix(hash(i + vec2(0, 1)), hash(i + vec2(1, 1)), f.x), f.y);
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
float t = iTime * 0.1;
|
|
float n = 0.0;
|
|
float scale = 8.0;
|
|
n += noise(uv * scale + t);
|
|
n += noise(uv * scale * 2.0 + sin(t * 3.0)) * 0.5;
|
|
n += noise(uv * scale * 4.0 - t * 2.0) * 0.25;
|
|
n = sin(n * 8.0) * 0.5 + 0.5;
|
|
float spots = smoothstep(0.4, 0.6, n);
|
|
vec3 col = mix(vec3(0.9, 0.85, 0.7), vec3(0.15, 0.1, 0.05), spots);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["reaction-diffusion", "organic", "pattern", "turing", "biological", "spots", "nature"], "2d", "Turing-style reaction diffusion patterns like animal markings",
|
|
{"chaos_level": 0.4, "color_temperature": "warm", "motion_type": "morphing"})
|
|
|
|
s("Tron Light Cycle Trail", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
vec3 col = vec3(0.02, 0.02, 0.05);
|
|
// Perspective grid floor
|
|
float gy = 0.5 / (1.0 - uv.y + 0.001);
|
|
float gx = (uv.x - 0.5) * gy * 2.0;
|
|
float gridX = smoothstep(0.02, 0.0, abs(fract(gx + iTime * 0.5) - 0.5));
|
|
float gridZ = smoothstep(0.02, 0.0, abs(fract(gy * 0.5 - iTime * 2.0) - 0.5));
|
|
float grid = max(gridX, gridZ) * step(0.5, uv.y) * (1.0 - uv.y) * 4.0;
|
|
col += vec3(0.0, 0.5, 1.0) * grid * 0.5;
|
|
// Light trail
|
|
float trail = smoothstep(0.01, 0.0, abs(uv.x - 0.5 - sin(iTime) * 0.2));
|
|
trail *= step(0.5, uv.y);
|
|
col += vec3(0.0, 0.8, 1.0) * trail * 2.0;
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["tron", "grid", "synthwave", "cyberpunk", "blue", "neon", "retro-future", "perspective"], "2d", "Tron-style perspective grid with light cycle trail",
|
|
{"chaos_level": 0.2, "color_temperature": "cool", "motion_type": "forward"})
|
|
|
|
s("Watercolor Bleed", """
|
|
float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
|
|
float noise(vec2 p) {
|
|
vec2 i = floor(p); vec2 f = fract(p);
|
|
f = f * f * (3.0 - 2.0 * f);
|
|
return mix(mix(hash(i), hash(i + vec2(1, 0)), f.x),
|
|
mix(hash(i + vec2(0, 1)), hash(i + vec2(1, 1)), f.x), f.y);
|
|
}
|
|
float fbm(vec2 p) {
|
|
float v = 0.0, a = 0.5;
|
|
mat2 rot = mat2(0.8, 0.6, -0.6, 0.8);
|
|
for (int i = 0; i < 6; i++) { v += a * noise(p); p = rot * p * 2.0; a *= 0.5; }
|
|
return v;
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
float t = iTime * 0.05;
|
|
float f = fbm(uv * 4.0 + t);
|
|
vec3 col1 = vec3(0.9, 0.3, 0.2);
|
|
vec3 col2 = vec3(0.2, 0.5, 0.9);
|
|
vec3 col3 = vec3(0.1, 0.8, 0.4);
|
|
vec3 col = mix(col1, col2, smoothstep(0.3, 0.5, f));
|
|
col = mix(col, col3, smoothstep(0.5, 0.7, f));
|
|
col = mix(col, vec3(0.95, 0.92, 0.88), smoothstep(0.7, 0.9, f));
|
|
// paper texture
|
|
float paper = noise(uv * 200.0) * 0.05 + 0.95;
|
|
col *= paper;
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["watercolor", "paint", "artistic", "soft", "pastel", "organic", "paper", "art"], "2d", "Watercolor paint bleeding on textured paper",
|
|
{"chaos_level": 0.3, "color_temperature": "warm", "motion_type": "fluid"})
|
|
|
|
# ═══════════════════════════════════════════════════════════
|
|
# PROGRAMMATIC GENERATION — fill to 200+
|
|
# We generate families of variations mathematically
|
|
# ═══════════════════════════════════════════════════════════
|
|
|
|
# --- Family: Sine field variations (20 shaders) ---
|
|
sine_colors = [
|
|
("Crimson Pulse", "vec3(0.9, 0.1, 0.15)", "vec3(0.3, 0.0, 0.05)", ["red", "pulse", "warm", "intense"]),
|
|
("Ocean Depth", "vec3(0.0, 0.3, 0.9)", "vec3(0.0, 0.05, 0.15)", ["ocean", "blue", "deep", "calm"]),
|
|
("Toxic Glow", "vec3(0.2, 1.0, 0.1)", "vec3(0.0, 0.1, 0.0)", ["toxic", "green", "radioactive", "glow"]),
|
|
("Amber Warmth", "vec3(1.0, 0.6, 0.1)", "vec3(0.15, 0.05, 0.0)", ["amber", "warm", "golden", "honey"]),
|
|
("Violet Dream", "vec3(0.6, 0.1, 0.9)", "vec3(0.1, 0.0, 0.15)", ["violet", "dream", "purple", "ethereal"]),
|
|
("Ice Crystal", "vec3(0.7, 0.9, 1.0)", "vec3(0.05, 0.08, 0.12)", ["ice", "crystal", "frozen", "cold"]),
|
|
("Coral Reef", "vec3(1.0, 0.4, 0.5)", "vec3(0.1, 0.02, 0.05)", ["coral", "reef", "pink", "organic"]),
|
|
("Forest Canopy", "vec3(0.1, 0.6, 0.2)", "vec3(0.02, 0.08, 0.02)", ["forest", "green", "nature", "canopy"]),
|
|
("Copper Wire", "vec3(0.9, 0.5, 0.2)", "vec3(0.1, 0.03, 0.0)", ["copper", "metal", "wire", "industrial"]),
|
|
("Midnight Blue", "vec3(0.1, 0.15, 0.5)", "vec3(0.01, 0.01, 0.05)", ["midnight", "blue", "dark", "night"]),
|
|
("Sunrise Ember", "vec3(1.0, 0.3, 0.0)", "vec3(0.2, 0.02, 0.0)", ["sunrise", "ember", "fire", "dawn"]),
|
|
("Lavender Haze", "vec3(0.7, 0.5, 0.9)", "vec3(0.08, 0.05, 0.12)", ["lavender", "haze", "soft", "pastel"]),
|
|
("Steel Grey", "vec3(0.5, 0.52, 0.55)", "vec3(0.05, 0.05, 0.06)", ["steel", "grey", "industrial", "monochrome"]),
|
|
("Magma Core", "vec3(1.0, 0.2, 0.0)", "vec3(0.3, 0.0, 0.0)", ["magma", "lava", "volcanic", "hot"]),
|
|
("Teal Abyss", "vec3(0.0, 0.7, 0.6)", "vec3(0.0, 0.08, 0.07)", ["teal", "abyss", "aqua", "deep"]),
|
|
("Champagne", "vec3(0.95, 0.85, 0.6)", "vec3(0.12, 0.1, 0.05)", ["champagne", "gold", "luxury", "elegant"]),
|
|
("Electric Lime", "vec3(0.6, 1.0, 0.0)", "vec3(0.05, 0.12, 0.0)", ["electric", "lime", "acid", "bright"]),
|
|
("Blood Moon", "vec3(0.6, 0.05, 0.05)", "vec3(0.1, 0.0, 0.02)", ["blood", "moon", "dark-red", "ominous"]),
|
|
("Arctic Wind", "vec3(0.85, 0.95, 1.0)", "vec3(0.08, 0.1, 0.15)", ["arctic", "wind", "white", "cold"]),
|
|
("Rust Decay", "vec3(0.6, 0.3, 0.1)", "vec3(0.08, 0.03, 0.01)", ["rust", "decay", "brown", "aged"]),
|
|
]
|
|
|
|
for i, (name, bright, dark, extra_tags) in enumerate(sine_colors):
|
|
freq_x = 5 + (i % 7) * 3
|
|
freq_y = 7 + (i % 5) * 4
|
|
speed = 0.5 + (i % 4) * 0.3
|
|
complexity = ["sin", "cos", "sin+cos"][i % 3]
|
|
|
|
code = f"""void mainImage(out vec4 fragColor, in vec2 fragCoord) {{
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float t = iTime * {speed:.1f};
|
|
float v = sin(uv.x * {freq_x:.1f} + t) * cos(uv.y * {freq_y:.1f} - t * 0.7);
|
|
v += sin(length(uv) * {freq_x + freq_y:.1f} + t * 1.3) * 0.5;
|
|
v = v * 0.5 + 0.5;
|
|
v = pow(v, 1.5);
|
|
vec3 col = mix({dark}, {bright}, v);
|
|
fragColor = vec4(col, 1.0);
|
|
}}"""
|
|
s(name, code,
|
|
["sine-field", "mathematical", "animated"] + extra_tags,
|
|
"2d", f"Sine wave interference pattern in {name.lower()} palette",
|
|
{"chaos_level": 0.3 + (i % 5) * 0.1, "color_temperature": ["warm", "cool", "neutral"][i % 3], "motion_type": "pulsing"})
|
|
|
|
# --- Family: Rotating geometry (15 shaders) ---
|
|
geometries = [
|
|
("Spinning Cube Wireframe", 4, "vec3(0.0, 0.8, 1.0)", ["cube", "wireframe", "3d-illusion", "blue"]),
|
|
("Pentagonal Vortex", 5, "vec3(0.9, 0.3, 0.8)", ["pentagon", "vortex", "pink"]),
|
|
("Triangular Recursion", 3, "vec3(1.0, 0.8, 0.0)", ["triangle", "recursive", "yellow"]),
|
|
("Octagonal Mandala", 8, "vec3(0.3, 0.9, 0.5)", ["octagon", "mandala", "green"]),
|
|
("Star Field Rotation", 5, "vec3(0.9, 0.9, 1.0)", ["star", "rotation", "white"]),
|
|
("Decagonal Wave", 10, "vec3(0.8, 0.4, 0.0)", ["decagon", "wave", "orange"]),
|
|
("Heptagonal Bloom", 7, "vec3(0.5, 0.0, 0.9)", ["heptagon", "bloom", "purple"]),
|
|
("Square Spiral", 4, "vec3(1.0, 0.2, 0.3)", ["square", "spiral", "red"]),
|
|
("Hexagonal Pulse", 6, "vec3(0.0, 0.9, 0.7)", ["hexagon", "pulse", "teal"]),
|
|
("Nonagonal Flow", 9, "vec3(0.9, 0.7, 0.3)", ["nonagon", "flow", "gold"]),
|
|
("Diamond Lattice", 4, "vec3(0.6, 0.8, 1.0)", ["diamond", "lattice", "crystal"]),
|
|
("Trigon Collapse", 3, "vec3(1.0, 0.0, 0.5)", ["triangle", "collapse", "magenta"]),
|
|
("Polygon Storm", 12, "vec3(0.4, 0.4, 0.9)", ["polygon", "storm", "blue"]),
|
|
("Angular Meditation", 6, "vec3(0.9, 0.85, 0.7)", ["angular", "meditation", "calm"]),
|
|
("Vertex Dance", 8, "vec3(0.0, 1.0, 0.4)", ["vertex", "dance", "neon-green"]),
|
|
]
|
|
|
|
for i, (name, sides, color, extra_tags) in enumerate(geometries):
|
|
speed = 0.5 + (i % 3) * 0.3
|
|
layers = 3 + i % 4
|
|
|
|
code = f"""void mainImage(out vec4 fragColor, in vec2 fragCoord) {{
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float t = iTime * {speed:.1f};
|
|
vec3 col = vec3(0.02);
|
|
for (int layer = 0; layer < {layers}; layer++) {{
|
|
float fl = float(layer);
|
|
float scale = 1.0 + fl * 0.5;
|
|
float rot = t + fl * 0.5;
|
|
vec2 p = uv * scale;
|
|
p = vec2(p.x * cos(rot) - p.y * sin(rot), p.x * sin(rot) + p.y * cos(rot));
|
|
float a = atan(p.y, p.x);
|
|
float r = length(p);
|
|
float sides = {float(sides):.1f};
|
|
float polygon = cos(3.14159 / sides) / cos(mod(a + 3.14159 / sides, 2.0 * 3.14159 / sides) - 3.14159 / sides);
|
|
float edge = abs(r - polygon * (0.3 + fl * 0.1));
|
|
float line = 0.003 / (edge + 0.003);
|
|
col += {color} * line * (0.5 + 0.5 / (1.0 + fl));
|
|
}}
|
|
fragColor = vec4(col, 1.0);
|
|
}}"""
|
|
s(name, code,
|
|
["geometric", "rotating", "polygon", "animated", "line-art"] + extra_tags,
|
|
"2d", f"Layered rotating {sides}-sided polygon wireframes",
|
|
{"chaos_level": 0.3 + (i % 4) * 0.1, "color_temperature": ["cool", "warm", "neutral"][i % 3], "motion_type": "rotating"})
|
|
|
|
# --- Family: Noise landscape variations (15 shaders) ---
|
|
landscapes = [
|
|
("Desert Dunes", "vec3(0.9, 0.7, 0.4)", "vec3(0.4, 0.6, 0.9)", 0.3, ["desert", "dunes", "sand", "warm"]),
|
|
("Frozen Tundra", "vec3(0.85, 0.9, 0.95)", "vec3(0.3, 0.4, 0.5)", 0.15, ["frozen", "tundra", "ice", "cold"]),
|
|
("Volcanic Plains", "vec3(0.3, 0.1, 0.05)", "vec3(0.1, 0.0, 0.0)", 0.8, ["volcanic", "lava", "dark", "ominous"]),
|
|
("Rolling Hills", "vec3(0.2, 0.5, 0.15)", "vec3(0.5, 0.7, 0.9)", 0.4, ["hills", "green", "pastoral", "peaceful"]),
|
|
("Alien Terrain", "vec3(0.4, 0.0, 0.5)", "vec3(0.1, 0.8, 0.3)", 0.6, ["alien", "sci-fi", "surreal", "otherworldly"]),
|
|
("Oceanic Floor", "vec3(0.05, 0.15, 0.25)", "vec3(0.0, 0.3, 0.5)", 0.35, ["ocean-floor", "underwater", "deep", "blue"]),
|
|
("Mars Surface", "vec3(0.7, 0.3, 0.1)", "vec3(0.3, 0.15, 0.1)", 0.5, ["mars", "planet", "red", "space"]),
|
|
("Crystal Cavern", "vec3(0.3, 0.5, 0.7)", "vec3(0.1, 0.0, 0.2)", 0.55, ["crystal", "cavern", "underground", "sparkle"]),
|
|
("Cloud Tops", "vec3(0.95, 0.95, 1.0)", "vec3(0.3, 0.5, 0.8)", 0.2, ["clouds", "sky", "white", "fluffy"]),
|
|
("Moss Garden", "vec3(0.15, 0.35, 0.1)", "vec3(0.3, 0.4, 0.3)", 0.25, ["moss", "garden", "zen", "green"]),
|
|
("Rust Belt", "vec3(0.5, 0.25, 0.1)", "vec3(0.2, 0.15, 0.1)", 0.45, ["rust", "industrial", "decay", "brown"]),
|
|
("Nebula Gas", "vec3(0.6, 0.2, 0.8)", "vec3(0.05, 0.0, 0.1)", 0.7, ["nebula", "gas", "space", "purple"]),
|
|
("Coral Depths", "vec3(0.9, 0.4, 0.3)", "vec3(0.0, 0.1, 0.2)", 0.4, ["coral", "ocean", "underwater", "warm"]),
|
|
("Storm Front", "vec3(0.2, 0.22, 0.25)", "vec3(0.05, 0.05, 0.08)", 0.65, ["storm", "dark", "weather", "dramatic"]),
|
|
("Golden Hour", "vec3(1.0, 0.75, 0.4)", "vec3(0.3, 0.2, 0.4)", 0.3, ["golden-hour", "warm", "photography", "sunset"]),
|
|
]
|
|
|
|
for i, (name, ground, sky, roughness, extra_tags) in enumerate(landscapes):
|
|
octaves = 5 + i % 3
|
|
speed = 0.1 + (i % 4) * 0.1
|
|
code = f"""float hash(vec2 p) {{ return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }}
|
|
float noise(vec2 p) {{
|
|
vec2 i = floor(p); vec2 f = fract(p);
|
|
f = f * f * (3.0 - 2.0 * f);
|
|
return mix(mix(hash(i), hash(i + vec2(1, 0)), f.x),
|
|
mix(hash(i + vec2(0, 1)), hash(i + vec2(1, 1)), f.x), f.y);
|
|
}}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {{
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
float t = iTime * {speed:.2f};
|
|
vec2 p = uv * 5.0 + vec2(t, 0.0);
|
|
float h = 0.0, a = 0.5;
|
|
for (int i = 0; i < {octaves}; i++) {{ h += a * noise(p); p *= 2.0; a *= 0.5; }}
|
|
float terrain = smoothstep(0.3, 0.7, h + (uv.y - 0.5) * {roughness + 0.5:.1f});
|
|
vec3 col = mix({ground}, {sky}, terrain);
|
|
float fog = smoothstep(0.0, 1.0, uv.y);
|
|
col = mix(col, {sky} * 0.7, fog * 0.3);
|
|
fragColor = vec4(col, 1.0);
|
|
}}"""
|
|
s(name, code,
|
|
["landscape", "terrain", "noise", "procedural"] + extra_tags,
|
|
"2d", f"Procedural {name.lower()} landscape with {octaves}-octave noise",
|
|
{"chaos_level": roughness, "color_temperature": ["warm", "cool", "neutral"][i % 3], "motion_type": "scrolling"})
|
|
|
|
# --- Family: 3D raymarched primitives (15 shaders) ---
|
|
rm_shapes = [
|
|
("Warped Cube", "max(max(abs(p.x),abs(p.y)),abs(p.z))-0.8+sin(p.x*5.0+iTime)*0.1", "vec3(0.9,0.3,0.1)", ["cube", "warped", "organic"]),
|
|
("Spinning Top", "length(vec2(length(p.xz)-0.6,p.y))-0.2", "vec3(0.1,0.7,0.9)", ["torus", "spinning", "blue"]),
|
|
("Infinite Pillars", "length(mod(p.xz+1.0,2.0)-1.0)-0.3", "vec3(0.8,0.8,0.85)", ["pillars", "infinite", "architectural"]),
|
|
("Twisted Column", "length(vec2(length(p.xz*mat2(cos(p.y),sin(p.y),-sin(p.y),cos(p.y)))-0.5,0.0))-0.15", "vec3(0.6,0.2,0.8)", ["twisted", "column", "purple"]),
|
|
("Gyroid Surface", "sin(p.x)*cos(p.y)+sin(p.y)*cos(p.z)+sin(p.z)*cos(p.x)", "vec3(0.2,0.8,0.4)", ["gyroid", "minimal-surface", "mathematical"]),
|
|
("Sierpinski Tetra", "max(max(-p.x-p.y-p.z,p.x+p.y-p.z),max(-p.x+p.y+p.z,p.x-p.y+p.z))-1.0", "vec3(1.0,0.8,0.2)", ["sierpinski", "fractal", "gold"]),
|
|
("Rounded Box", "length(max(abs(p)-vec3(0.6,0.4,0.3),0.0))-0.1", "vec3(0.3,0.5,0.9)", ["box", "rounded", "smooth"]),
|
|
("Egg Shape", "length(p*vec3(1.0,1.3,1.0))-0.8", "vec3(0.95,0.9,0.8)", ["egg", "organic", "smooth", "minimal"]),
|
|
("Capped Cylinder", "max(length(p.xz)-0.4,abs(p.y)-1.0)", "vec3(0.7,0.3,0.3)", ["cylinder", "geometric", "red"]),
|
|
("Octahedron", "(abs(p.x)+abs(p.y)+abs(p.z)-1.0)*0.577", "vec3(0.4,0.9,0.7)", ["octahedron", "platonic", "teal"]),
|
|
("Capsule Link", "length(p-vec3(0,clamp(p.y,-0.5,0.5),0))-0.3", "vec3(0.9,0.5,0.2)", ["capsule", "simple", "orange"]),
|
|
("Cross Shape", "min(min(length(p.xy)-0.2,length(p.yz)-0.2),length(p.xz)-0.2)", "vec3(0.8,0.1,0.1)", ["cross", "intersection", "red"]),
|
|
("Pulsing Heart", "pow(p.x*p.x+0.9*p.y*p.y+p.z*p.z-1.0,3.0)-p.x*p.x*p.y*p.y*p.y-0.1*p.z*p.z*p.y*p.y*p.y", "vec3(0.9,0.15,0.2)", ["heart", "love", "romantic"]),
|
|
("Klein Bottle", "length(vec2(length(p.xy)-1.0,p.z))-0.3", "vec3(0.5,0.7,1.0)", ["klein-bottle", "topology", "mathematical"]),
|
|
("Menger Sponge", "max(max(abs(p.x),abs(p.y)),abs(p.z))-1.0", "vec3(0.6,0.6,0.65)", ["menger", "sponge", "fractal", "recursive"]),
|
|
]
|
|
|
|
for i, (name, sdf, color, extra_tags) in enumerate(rm_shapes):
|
|
rot_speed = 0.3 + (i % 4) * 0.2
|
|
code = f"""float map(vec3 p) {{
|
|
float a = iTime * {rot_speed:.1f};
|
|
p.xz *= mat2(cos(a), sin(a), -sin(a), cos(a));
|
|
p.xy *= mat2(cos(a*0.7), sin(a*0.7), -sin(a*0.7), cos(a*0.7));
|
|
return {sdf};
|
|
}}
|
|
vec3 getNormal(vec3 p) {{
|
|
vec2 e = vec2(0.001, 0);
|
|
return normalize(vec3(map(p+e.xyy)-map(p-e.xyy),map(p+e.yxy)-map(p-e.yxy),map(p+e.yyx)-map(p-e.yyx)));
|
|
}}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {{
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
vec3 ro = vec3(0, 0, -3.5);
|
|
vec3 rd = normalize(vec3(uv, 1.0));
|
|
float t = 0.0;
|
|
vec3 col = vec3(0.02, 0.01, 0.04);
|
|
for (int i = 0; i < 80; i++) {{
|
|
float d = map(ro + rd * t);
|
|
if (abs(d) < 0.001) {{
|
|
vec3 p = ro + rd * t;
|
|
vec3 n = getNormal(p);
|
|
vec3 light = normalize(vec3(1, 1, -1));
|
|
float diff = max(dot(n, light), 0.0);
|
|
float spec = pow(max(dot(reflect(-light, n), -rd), 0.0), 16.0);
|
|
col = {color} * (0.15 + 0.85 * diff) + vec3(1.0) * spec * 0.3;
|
|
break;
|
|
}}
|
|
t += abs(d) * 0.8;
|
|
if (t > 20.0) break;
|
|
}}
|
|
fragColor = vec4(col, 1.0);
|
|
}}"""
|
|
s(name, code,
|
|
["3d", "raymarching", "sdf", "animated"] + extra_tags,
|
|
"3d", f"Raymarched {name.lower()} with dual-axis rotation and specular lighting",
|
|
{"chaos_level": 0.3 + (i % 5) * 0.1, "color_temperature": ["cool", "warm", "neutral"][i % 3], "motion_type": "rotating"})
|
|
|
|
# --- Family: Abstract energy fields (15 shaders) ---
|
|
energies = [
|
|
("Plasma Core", 8.0, 3.0, "vec3(1.0,0.3,0.1)", "vec3(0.3,0.1,0.8)", ["plasma", "core", "energy"]),
|
|
("Neural Network", 15.0, 5.0, "vec3(0.0,0.8,0.9)", "vec3(0.0,0.2,0.3)", ["neural", "network", "connections"]),
|
|
("Magnetic Field", 6.0, 2.0, "vec3(0.2,0.5,1.0)", "vec3(0.8,0.2,0.1)", ["magnetic", "field", "physics"]),
|
|
("Solar Flare", 4.0, 6.0, "vec3(1.0,0.7,0.0)", "vec3(1.0,0.1,0.0)", ["solar", "flare", "sun"]),
|
|
("Quantum Foam", 20.0, 8.0, "vec3(0.5,0.8,1.0)", "vec3(0.1,0.0,0.2)", ["quantum", "foam", "microscopic"]),
|
|
("Nebula Birth", 3.0, 1.5, "vec3(0.8,0.3,0.9)", "vec3(0.1,0.5,0.8)", ["nebula", "birth", "cosmic"]),
|
|
("Lava Flow", 5.0, 2.0, "vec3(1.0,0.4,0.0)", "vec3(0.3,0.0,0.0)", ["lava", "flow", "volcanic"]),
|
|
("Energy Shield", 10.0, 4.0, "vec3(0.0,0.9,0.5)", "vec3(0.0,0.2,0.1)", ["shield", "force-field", "sci-fi"]),
|
|
("Radioactive Decay", 12.0, 7.0, "vec3(0.3,1.0,0.0)", "vec3(0.0,0.15,0.0)", ["radioactive", "decay", "toxic"]),
|
|
("Dark Matter", 7.0, 3.0, "vec3(0.15,0.1,0.2)", "vec3(0.4,0.3,0.5)", ["dark-matter", "mysterious", "space"]),
|
|
("Bioluminescent", 9.0, 4.0, "vec3(0.0,0.7,0.9)", "vec3(0.0,0.3,0.1)", ["bioluminescent", "ocean", "glow"]),
|
|
("Cosmic Web", 6.0, 5.0, "vec3(0.6,0.7,1.0)", "vec3(0.05,0.0,0.1)", ["cosmic", "web", "universe"]),
|
|
("Aurora Pulse", 8.0, 3.0, "vec3(0.1,0.9,0.4)", "vec3(0.4,0.1,0.8)", ["aurora", "pulse", "atmospheric"]),
|
|
("Plasma Tornado", 5.0, 6.0, "vec3(0.9,0.5,1.0)", "vec3(0.2,0.0,0.3)", ["tornado", "vortex", "spinning"]),
|
|
("Star Forge", 4.0, 4.0, "vec3(1.0,0.9,0.5)", "vec3(0.5,0.1,0.0)", ["star", "forge", "creation"]),
|
|
]
|
|
|
|
for i, (name, freq, speed, col1, col2, extra_tags) in enumerate(energies):
|
|
code = f"""float hash(vec2 p) {{ return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }}
|
|
float noise(vec2 p) {{
|
|
vec2 i = floor(p); vec2 f = fract(p);
|
|
f = f * f * (3.0 - 2.0 * f);
|
|
return mix(mix(hash(i), hash(i + vec2(1, 0)), f.x),
|
|
mix(hash(i + vec2(0, 1)), hash(i + vec2(1, 1)), f.x), f.y);
|
|
}}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {{
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float t = iTime * {speed / 3.0:.2f};
|
|
float r = length(uv);
|
|
float a = atan(uv.y, uv.x);
|
|
float n = noise(vec2(a * {freq:.1f} / 6.283, r * {freq:.1f}) + t);
|
|
n += noise(vec2(a * {freq * 2:.1f} / 6.283, r * {freq * 2:.1f}) - t * 1.3) * 0.5;
|
|
n = n / 1.5;
|
|
float energy = pow(n, 2.0) * exp(-r * 2.0);
|
|
vec3 col = mix({col2}, {col1}, energy * 2.0);
|
|
col += {col1} * 0.01 / (r + 0.01) * n;
|
|
fragColor = vec4(col, 1.0);
|
|
}}"""
|
|
s(name, code,
|
|
["energy", "abstract", "animated", "glow"] + extra_tags,
|
|
"2d", f"Swirling energy field: {name.lower()}",
|
|
{"chaos_level": 0.4 + (i % 5) * 0.1, "color_temperature": ["warm", "cool", "neutral"][i % 3], "motion_type": "swirling"})
|
|
|
|
# --- Family: Fractal Explorations (15 shaders) ---
|
|
fractals = [
|
|
("Julia Set Amethyst", -0.7269, 0.1889, "vec3(0.5,0.2,0.8)", ["julia", "amethyst", "fractal"]),
|
|
("Julia Set Coral", -0.8, 0.156, "vec3(0.9,0.4,0.3)", ["julia", "coral", "fractal"]),
|
|
("Julia Set Ice", -0.4, 0.6, "vec3(0.5,0.8,1.0)", ["julia", "ice", "fractal"]),
|
|
("Julia Set Fire", -0.12, 0.74, "vec3(1.0,0.4,0.0)", ["julia", "fire", "fractal"]),
|
|
("Julia Set Forest", 0.285, 0.01, "vec3(0.2,0.7,0.3)", ["julia", "forest", "fractal"]),
|
|
("Julia Set Electric", -0.74543, 0.11301, "vec3(0.0,0.6,1.0)", ["julia", "electric", "fractal"]),
|
|
("Julia Set Midnight", -0.75, 0.11, "vec3(0.15,0.1,0.3)", ["julia", "midnight", "fractal"]),
|
|
("Julia Set Gold", -0.1, 0.65, "vec3(0.9,0.7,0.2)", ["julia", "gold", "fractal"]),
|
|
("Julia Set Rose", -0.7, 0.27015, "vec3(0.9,0.3,0.5)", ["julia", "rose", "fractal"]),
|
|
("Julia Set Nebula", 0.355, 0.355, "vec3(0.6,0.3,0.9)", ["julia", "nebula", "fractal"]),
|
|
("Julia Set Ocean", -0.75, 0.0, "vec3(0.1,0.5,0.8)", ["julia", "ocean", "fractal"]),
|
|
("Julia Set Ember", -0.77, 0.22, "vec3(0.8,0.2,0.05)", ["julia", "ember", "fractal"]),
|
|
("Julia Set Toxic", -0.8, 0.0, "vec3(0.3,0.9,0.1)", ["julia", "toxic", "fractal"]),
|
|
("Julia Set Void", 0.0, 0.65, "vec3(0.3,0.3,0.35)", ["julia", "void", "fractal"]),
|
|
("Julia Set Prism", -0.7, 0.3, "vec3(0.7,0.5,1.0)", ["julia", "prism", "fractal"]),
|
|
]
|
|
|
|
for i, (name, cx, cy, color, extra_tags) in enumerate(fractals):
|
|
code = f"""void mainImage(out vec4 fragColor, in vec2 fragCoord) {{
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
uv *= 2.5;
|
|
vec2 c = vec2({cx}, {cy}) + vec2(sin(iTime * 0.1) * 0.02, cos(iTime * 0.13) * 0.02);
|
|
vec2 z = uv;
|
|
int iter = 0;
|
|
for (int i = 0; i < 200; i++) {{
|
|
z = vec2(z.x*z.x - z.y*z.y, 2.0*z.x*z.y) + c;
|
|
if (dot(z, z) > 4.0) break;
|
|
iter = i;
|
|
}}
|
|
float t = float(iter) / 200.0;
|
|
vec3 col = {color} * (1.0 - pow(t, 0.5));
|
|
col += 0.5 + 0.5 * cos(t * 12.0 + iTime + vec3(0, 2, 4)) * (1.0 - t);
|
|
col *= 1.0 - step(199.0, float(iter));
|
|
fragColor = vec4(col, 1.0);
|
|
}}"""
|
|
s(name, code,
|
|
["fractal", "julia-set", "mathematical", "complex", "colorful"] + extra_tags,
|
|
"2d", f"Julia set with c=({cx}, {cy}), slowly drifting",
|
|
{"chaos_level": 0.5 + (i % 4) * 0.1, "color_temperature": ["warm", "cool", "neutral"][i % 3], "motion_type": "morphing"})
|
|
|
|
# --- Family: Pattern/texture generators (15 shaders) ---
|
|
patterns = [
|
|
("Checkerboard Warp", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float warp = sin(length(uv) * 10.0 - iTime * 2.0) * 0.1;
|
|
uv += uv * warp;
|
|
vec2 grid = floor(uv * 8.0);
|
|
float check = mod(grid.x + grid.y, 2.0);
|
|
vec3 col = mix(vec3(0.1), vec3(0.9), check);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["checkerboard", "warp", "distortion", "bw", "optical"]),
|
|
("Concentric Rings", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float r = length(uv);
|
|
float rings = sin(r * 30.0 - iTime * 3.0) * 0.5 + 0.5;
|
|
vec3 col = mix(vec3(0.05, 0.0, 0.1), vec3(0.8, 0.3, 0.9), rings);
|
|
col *= smoothstep(1.5, 0.0, r);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["concentric", "rings", "purple", "hypnotic", "simple"]),
|
|
("Herringbone", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
vec2 g = uv * vec2(20.0, 40.0);
|
|
float row = floor(g.y);
|
|
g.x += mod(row, 2.0) * 0.5;
|
|
vec2 f = fract(g);
|
|
float brick = step(0.05, f.x) * step(0.05, f.y);
|
|
float t = sin(iTime + row * 0.3) * 0.5 + 0.5;
|
|
vec3 col = mix(vec3(0.6, 0.3, 0.15), vec3(0.7, 0.4, 0.2), t) * brick;
|
|
col += vec3(0.3, 0.15, 0.05) * (1.0 - brick);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["herringbone", "brick", "pattern", "architecture", "warm"]),
|
|
("Dots Matrix", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
vec2 grid = fract(uv * 20.0) - 0.5;
|
|
vec2 id = floor(uv * 20.0);
|
|
float phase = sin(iTime * 2.0 + id.x * 0.5 + id.y * 0.7);
|
|
float radius = 0.2 + 0.15 * phase;
|
|
float d = smoothstep(radius, radius - 0.02, length(grid));
|
|
vec3 col = vec3(0.0, 0.5, 0.8) * d;
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["dots", "matrix", "halftone", "blue", "pulsing"]),
|
|
("Weave Pattern", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
vec2 g = uv * 15.0;
|
|
float weft = step(0.3, fract(g.x)) * step(fract(g.x), 0.7);
|
|
float warp = step(0.3, fract(g.y)) * step(fract(g.y), 0.7);
|
|
float over = step(0.5, fract(floor(g.x) * 0.5 + floor(g.y) * 0.5));
|
|
float thread = mix(weft, warp, over);
|
|
vec3 col1 = vec3(0.2, 0.3, 0.6);
|
|
vec3 col2 = vec3(0.7, 0.5, 0.2);
|
|
vec3 col = mix(col1, col2, thread);
|
|
col *= 0.7 + 0.3 * sin(iTime + uv.x * 10.0);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["weave", "textile", "fabric", "pattern", "craft"]),
|
|
("Sierpinski Triangle", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
uv.y = 1.0 - uv.y;
|
|
float t = mod(iTime * 0.3, 1.0);
|
|
float zoom = pow(2.0, t * 3.0);
|
|
uv = uv * zoom - vec2(zoom * 0.5 - 0.5);
|
|
float v = 1.0;
|
|
for (int i = 0; i < 20; i++) {
|
|
if (uv.x + uv.y > 1.0) { v = 0.0; break; }
|
|
uv *= 2.0;
|
|
if (uv.x > 1.0) uv.x -= 1.0;
|
|
if (uv.y > 1.0) uv.y -= 1.0;
|
|
}
|
|
vec3 col = vec3(v) * vec3(0.3, 0.6, 0.9);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["sierpinski", "triangle", "fractal", "self-similar", "zoom"]),
|
|
("Perlin Contours", """
|
|
float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
|
|
float noise(vec2 p) {
|
|
vec2 i = floor(p); vec2 f = fract(p);
|
|
f = f * f * (3.0 - 2.0 * f);
|
|
return mix(mix(hash(i), hash(i + vec2(1, 0)), f.x),
|
|
mix(hash(i + vec2(0, 1)), hash(i + vec2(1, 1)), f.x), f.y);
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
float n = noise(uv * 6.0 + iTime * 0.2) * 0.5
|
|
+ noise(uv * 12.0 - iTime * 0.15) * 0.25
|
|
+ noise(uv * 24.0 + iTime * 0.1) * 0.125;
|
|
float contour = abs(fract(n * 10.0) - 0.5) * 2.0;
|
|
contour = smoothstep(0.0, 0.1, contour);
|
|
vec3 col = mix(vec3(0.9, 0.85, 0.75), vec3(0.2, 0.15, 0.1), 1.0 - contour);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["contour", "topographic", "map", "noise", "minimal", "clean"]),
|
|
("Stained Glass", """
|
|
vec2 hash2(vec2 p) {
|
|
p = vec2(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5, 183.3)));
|
|
return fract(sin(p) * 43758.5453);
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.y;
|
|
vec2 n = floor(uv * 5.0);
|
|
vec2 f = fract(uv * 5.0);
|
|
float md = 8.0;
|
|
vec2 id;
|
|
for (int j = -1; j <= 1; j++)
|
|
for (int i = -1; i <= 1; i++) {
|
|
vec2 g = vec2(float(i), float(j));
|
|
vec2 o = hash2(n + g);
|
|
o = 0.5 + 0.45 * sin(iTime * 0.5 + 6.283 * o);
|
|
vec2 r = g + o - f;
|
|
float d = dot(r, r);
|
|
if (d < md) { md = d; id = n + g; }
|
|
}
|
|
float h = fract(sin(dot(id, vec2(127.1, 311.7))) * 43758.5453);
|
|
vec3 col = 0.5 + 0.5 * cos(h * 6.283 + vec3(0, 2, 4));
|
|
col *= 0.7 + 0.3 * smoothstep(0.0, 0.05, md);
|
|
float edge = smoothstep(0.01, 0.02, md);
|
|
col *= 0.2 + 0.8 * edge;
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["stained-glass", "voronoi", "colorful", "mosaic", "church", "art"]),
|
|
("Zen Sand Garden", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float r = length(uv);
|
|
float a = atan(uv.y, uv.x);
|
|
float rake = sin(r * 40.0 + a * 0.5 - iTime * 0.3);
|
|
float stone = smoothstep(0.15, 0.14, length(uv - vec2(0.3, 0.1)));
|
|
stone += smoothstep(0.08, 0.07, length(uv + vec2(0.2, 0.15)));
|
|
rake *= (1.0 - stone);
|
|
vec3 sand = vec3(0.85, 0.78, 0.65);
|
|
vec3 col = sand + vec3(0.05) * rake;
|
|
col = mix(col, vec3(0.3, 0.3, 0.28), stone);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["zen", "sand", "garden", "minimal", "japanese", "calm", "meditation"]),
|
|
("Wave Interference 2D", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float v = 0.0;
|
|
vec2 s0 = vec2(sin(iTime), cos(iTime)) * 0.4;
|
|
vec2 s1 = vec2(-sin(iTime * 0.7), sin(iTime * 0.5)) * 0.5;
|
|
vec2 s2 = vec2(cos(iTime * 0.3), -sin(iTime * 0.8)) * 0.3;
|
|
vec2 s3 = vec2(-cos(iTime * 0.6), cos(iTime * 0.4)) * 0.35;
|
|
v += sin(length(uv - s0) * 30.0 - iTime * 5.0) / (1.0 + length(uv - s0) * 5.0);
|
|
v += sin(length(uv - s1) * 30.0 - iTime * 5.0) / (1.0 + length(uv - s1) * 5.0);
|
|
v += sin(length(uv - s2) * 30.0 - iTime * 5.0) / (1.0 + length(uv - s2) * 5.0);
|
|
v += sin(length(uv - s3) * 30.0 - iTime * 5.0) / (1.0 + length(uv - s3) * 5.0);
|
|
vec3 col = 0.5 + 0.5 * cos(v * 3.0 + vec3(0, 2, 4));
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["wave", "interference", "physics", "ripple", "colorful", "multi-source"]),
|
|
("DNA Helix", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
uv.y = uv.y * 2.0 - 1.0;
|
|
float t = iTime * 2.0;
|
|
float x = uv.x * 10.0 + t;
|
|
float strand1 = sin(x) * 0.3;
|
|
float strand2 = -sin(x) * 0.3;
|
|
float d1 = abs(uv.y - strand1);
|
|
float d2 = abs(uv.y - strand2);
|
|
float line1 = 0.005 / (d1 + 0.005);
|
|
float line2 = 0.005 / (d2 + 0.005);
|
|
float rung = 0.0;
|
|
float rungX = fract(x / 3.14159 * 0.5);
|
|
if (rungX < 0.05 || rungX > 0.95) {
|
|
float dy = uv.y;
|
|
if (dy > min(strand1, strand2) && dy < max(strand1, strand2))
|
|
rung = 0.5;
|
|
}
|
|
vec3 col = vec3(0.02, 0.0, 0.05);
|
|
col += vec3(0.0, 0.6, 1.0) * line1;
|
|
col += vec3(1.0, 0.3, 0.5) * line2;
|
|
col += vec3(0.3, 0.8, 0.4) * rung;
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["dna", "helix", "biology", "science", "double-helix", "blue-pink"]),
|
|
("Pendulum Wave", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
vec3 col = vec3(0.02, 0.01, 0.04);
|
|
for (int i = 0; i < 20; i++) {
|
|
float fi = float(i);
|
|
float freq = 10.0 + fi * 0.5;
|
|
float phase = sin(iTime * freq * 0.1) * 0.3;
|
|
float x = (fi + 0.5) / 20.0;
|
|
float y = 0.5 + phase;
|
|
float d = length(vec2(uv.x - x, uv.y - y) * vec2(1.0, 2.0));
|
|
col += vec3(0.5 + 0.5 * cos(fi * 0.3 + vec3(0, 2, 4))) * 0.005 / (d + 0.005);
|
|
float rod = smoothstep(0.003, 0.0, abs(uv.x - x)) * step(y, uv.y) * step(uv.y, 0.95);
|
|
col += vec3(0.15) * rod;
|
|
}
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["pendulum", "wave", "physics", "harmonic", "colorful", "simulation"]),
|
|
("ASCII Art Rain", """
|
|
float char(int n, vec2 p) {
|
|
p = floor(p * vec2(4.0, -4.0) + 2.5);
|
|
if (clamp(p.x, 0.0, 4.0) == p.x && clamp(p.y, 0.0, 4.0) == p.y) {
|
|
int bit = int(p.x) + int(p.y) * 5;
|
|
if (((n >> bit) & 1) == 1) return 1.0;
|
|
}
|
|
return 0.0;
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
vec2 grid = floor(uv * vec2(40.0, 25.0));
|
|
float t = floor(iTime * 10.0);
|
|
float drop = fract(sin(dot(grid.x + t * 0.01, 78.233)) * 43758.5) * 25.0;
|
|
float fade = smoothstep(drop, drop - 8.0, grid.y);
|
|
float bright = step(abs(grid.y - drop), 0.5);
|
|
vec3 col = vec3(0.0, 0.4, 0.15) * fade + vec3(0.0, 0.9, 0.4) * bright;
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["ascii", "rain", "text", "matrix", "digital", "green", "code"]),
|
|
("Smoke Wisps", """
|
|
float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
|
|
float noise(vec2 p) {
|
|
vec2 i = floor(p); vec2 f = fract(p);
|
|
f = f * f * (3.0 - 2.0 * f);
|
|
return mix(mix(hash(i), hash(i + vec2(1, 0)), f.x),
|
|
mix(hash(i + vec2(0, 1)), hash(i + vec2(1, 1)), f.x), f.y);
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
float t = iTime * 0.3;
|
|
vec2 p = uv * 3.0;
|
|
p.y += t;
|
|
float n = noise(p) * 0.5 + noise(p * 2.0 + t) * 0.25 + noise(p * 4.0 - t * 0.5) * 0.125;
|
|
float wisp = pow(n, 3.0) * smoothstep(0.0, 0.5, uv.y) * smoothstep(1.0, 0.5, uv.y);
|
|
wisp *= smoothstep(0.0, 0.3, uv.x) * smoothstep(1.0, 0.7, uv.x);
|
|
vec3 col = vec3(wisp * 0.6);
|
|
col += vec3(0.02, 0.01, 0.03);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["smoke", "wisps", "atmospheric", "grey", "subtle", "elegant", "minimal"]),
|
|
]
|
|
|
|
for name, code, extra_tags in patterns:
|
|
s(name, code,
|
|
["pattern", "2d"] + extra_tags,
|
|
"2d", f"{name} — procedural pattern",
|
|
{"chaos_level": 0.3, "color_temperature": "neutral", "motion_type": "animated"})
|
|
|
|
# --- Family: Domain warping (12 shaders) ---
|
|
warp_names = [
|
|
("Acid Trip", 0.9, "vec3(1.0,0.2,0.8)", "vec3(0.1,0.9,0.3)", ["acid", "psychedelic", "trippy", "wild"]),
|
|
("Deep Dream", 0.7, "vec3(0.3,0.1,0.6)", "vec3(0.8,0.6,0.2)", ["dream", "deep", "surreal", "abstract"]),
|
|
("Oil Slick", 0.4, "vec3(0.2,0.5,0.8)", "vec3(0.8,0.3,0.5)", ["oil", "iridescent", "rainbow", "surface"]),
|
|
("Lava Rift", 0.8, "vec3(1.0,0.3,0.0)", "vec3(0.1,0.0,0.0)", ["lava", "rift", "crack", "hot"]),
|
|
("Ghost Veil", 0.3, "vec3(0.7,0.7,0.8)", "vec3(0.1,0.1,0.15)", ["ghost", "veil", "ethereal", "pale"]),
|
|
("Coral Growth", 0.5, "vec3(0.9,0.4,0.5)", "vec3(0.1,0.3,0.4)", ["coral", "growth", "organic", "living"]),
|
|
("Storm Eye", 0.85, "vec3(0.3,0.4,0.6)", "vec3(0.05,0.05,0.1)", ["storm", "eye", "cyclone", "dramatic"]),
|
|
("Crystal Melt", 0.6, "vec3(0.6,0.8,1.0)", "vec3(0.2,0.1,0.3)", ["crystal", "melt", "dissolve", "transformation"]),
|
|
("Plasma Web", 0.75, "vec3(0.0,1.0,0.8)", "vec3(0.3,0.0,0.5)", ["plasma", "web", "interconnected", "energy"]),
|
|
("Sand Ripple", 0.2, "vec3(0.9,0.8,0.6)", "vec3(0.6,0.5,0.3)", ["sand", "ripple", "desert", "zen"]),
|
|
("Cosmic Dust", 0.65, "vec3(0.5,0.4,0.8)", "vec3(0.05,0.02,0.1)", ["cosmic", "dust", "space", "purple"]),
|
|
("Magma Pool", 0.9, "vec3(1.0,0.5,0.0)", "vec3(0.2,0.0,0.0)", ["magma", "pool", "volcanic", "orange"]),
|
|
]
|
|
|
|
for i, (name, chaos, c1, c2, extra_tags) in enumerate(warp_names):
|
|
warp_freq = 2.0 + (i % 5)
|
|
warp_amp = 0.5 + chaos * 0.5
|
|
code = f"""float hash(vec2 p) {{ return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }}
|
|
float noise(vec2 p) {{
|
|
vec2 i = floor(p); vec2 f = fract(p);
|
|
f = f * f * (3.0 - 2.0 * f);
|
|
return mix(mix(hash(i), hash(i + vec2(1, 0)), f.x),
|
|
mix(hash(i + vec2(0, 1)), hash(i + vec2(1, 1)), f.x), f.y);
|
|
}}
|
|
float fbm(vec2 p) {{
|
|
float v = 0.0, a = 0.5;
|
|
for (int i = 0; i < 6; i++) {{ v += a * noise(p); p *= 2.0; a *= 0.5; }}
|
|
return v;
|
|
}}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {{
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
float t = iTime * 0.2;
|
|
vec2 p = uv * {warp_freq:.1f};
|
|
float warp1 = fbm(p + t);
|
|
float warp2 = fbm(p + warp1 * {warp_amp:.1f} + t * 0.7);
|
|
float warp3 = fbm(p + warp2 * {warp_amp:.1f} - t * 0.3);
|
|
vec3 col = mix({c2}, {c1}, warp3);
|
|
col = pow(col, vec3(0.9));
|
|
fragColor = vec4(col, 1.0);
|
|
}}"""
|
|
s(name, code,
|
|
["domain-warp", "fbm", "fluid", "animated"] + extra_tags,
|
|
"2d", f"Triple-layer domain warping: {name.lower()}",
|
|
{"chaos_level": chaos, "color_temperature": ["warm", "cool", "neutral"][i % 3], "motion_type": "fluid"})
|
|
|
|
# --- Family: Raymarched scenes (10 shaders) ---
|
|
scenes_3d = [
|
|
("Floating Islands", """
|
|
float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
|
|
float noise(vec2 p) {
|
|
vec2 i = floor(p); vec2 f = fract(p);
|
|
f = f * f * (3.0 - 2.0 * f);
|
|
return mix(mix(hash(i), hash(i+vec2(1,0)), f.x), mix(hash(i+vec2(0,1)), hash(i+vec2(1,1)), f.x), f.y);
|
|
}
|
|
float map(vec3 p) {
|
|
float ground = p.y + 1.0;
|
|
float island1 = length(p - vec3(0, sin(iTime)*0.3, 0)) - 1.0;
|
|
float island2 = length(p - vec3(2.5, cos(iTime*0.7)*0.4+0.5, 1.0)) - 0.6;
|
|
float island3 = length(p - vec3(-2.0, sin(iTime*0.5)*0.2+0.3, -0.5)) - 0.8;
|
|
return min(min(island1, island2), island3);
|
|
}
|
|
vec3 getNormal(vec3 p) {
|
|
vec2 e = vec2(0.001, 0);
|
|
return normalize(vec3(map(p+e.xyy)-map(p-e.xyy),map(p+e.yxy)-map(p-e.yxy),map(p+e.yyx)-map(p-e.yyx)));
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
vec3 ro = vec3(0, 0, -5);
|
|
vec3 rd = normalize(vec3(uv, 1.0));
|
|
float t = 0.0;
|
|
vec3 col = mix(vec3(0.3, 0.5, 0.9), vec3(0.7, 0.8, 1.0), uv.y + 0.5);
|
|
for (int i = 0; i < 80; i++) {
|
|
float d = map(ro + rd * t);
|
|
if (d < 0.001) {
|
|
vec3 p = ro + rd * t;
|
|
vec3 n = getNormal(p);
|
|
float sun = max(dot(n, normalize(vec3(1, 0.8, -0.5))), 0.0);
|
|
col = vec3(0.3, 0.6, 0.2) * (0.3 + 0.7 * sun);
|
|
col = mix(col, vec3(0.5, 0.7, 1.0), 1.0 - exp(-t * 0.05));
|
|
break;
|
|
}
|
|
t += d;
|
|
if (t > 30.0) break;
|
|
}
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["floating", "islands", "3d", "fantasy", "sky", "peaceful", "raymarching"]),
|
|
("Endless Staircase", """
|
|
float map(vec3 p) {
|
|
p.y += iTime * 0.5;
|
|
vec3 q = mod(p + 1.0, 2.0) - 1.0;
|
|
float box = max(max(abs(q.x) - 0.8, abs(q.y) - 0.1), abs(q.z) - 0.4);
|
|
float step1 = max(max(abs(q.x) - 0.3, abs(q.y + 0.3) - 0.1), abs(q.z - 0.2) - 0.4);
|
|
return min(box, step1);
|
|
}
|
|
vec3 getNormal(vec3 p) {
|
|
vec2 e = vec2(0.001, 0);
|
|
return normalize(vec3(map(p+e.xyy)-map(p-e.xyy),map(p+e.yxy)-map(p-e.yxy),map(p+e.yyx)-map(p-e.yyx)));
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
vec3 ro = vec3(0, 0, -4);
|
|
vec3 rd = normalize(vec3(uv, 1.0));
|
|
float a = iTime * 0.2;
|
|
rd.xz = mat2(cos(a), sin(a), -sin(a), cos(a)) * rd.xz;
|
|
float t = 0.0;
|
|
vec3 col = vec3(0.05);
|
|
for (int i = 0; i < 80; i++) {
|
|
float d = map(ro + rd * t);
|
|
if (d < 0.001) {
|
|
vec3 p = ro + rd * t;
|
|
vec3 n = getNormal(p);
|
|
float light = max(dot(n, normalize(vec3(1, 1, -1))), 0.0);
|
|
col = vec3(0.7, 0.7, 0.75) * (0.2 + 0.8 * light);
|
|
col = mix(col, vec3(0.05), 1.0 - exp(-t * 0.08));
|
|
break;
|
|
}
|
|
t += d;
|
|
if (t > 20.0) break;
|
|
}
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["staircase", "escher", "infinite", "3d", "architectural", "surreal", "impossible"]),
|
|
("Crystal Cave", """
|
|
float map(vec3 p) {
|
|
float cave = -(length(p.xz) - 3.0);
|
|
float crystal = 1e10;
|
|
for (int i = 0; i < 6; i++) {
|
|
float fi = float(i);
|
|
vec3 cp = vec3(sin(fi*1.0)*2.0, fi*0.5-1.0, cos(fi*1.0)*2.0);
|
|
float h = max(abs(p.x-cp.x)+abs(p.z-cp.z)-0.15, abs(p.y-cp.y)-0.4-fi*0.1);
|
|
crystal = min(crystal, h);
|
|
}
|
|
return max(cave, -crystal);
|
|
}
|
|
vec3 getNormal(vec3 p) {
|
|
vec2 e = vec2(0.001, 0);
|
|
return normalize(vec3(map(p+e.xyy)-map(p-e.xyy),map(p+e.yxy)-map(p-e.yxy),map(p+e.yyx)-map(p-e.yyx)));
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float a = iTime * 0.3;
|
|
vec3 ro = vec3(sin(a)*2.0, 0.0, cos(a)*2.0);
|
|
vec3 ta = vec3(0.0, 0.0, 0.0);
|
|
vec3 fwd = normalize(ta - ro);
|
|
vec3 right = normalize(cross(vec3(0,1,0), fwd));
|
|
vec3 up = cross(fwd, right);
|
|
vec3 rd = normalize(uv.x * right + uv.y * up + 1.5 * fwd);
|
|
float t = 0.0;
|
|
vec3 col = vec3(0.01, 0.0, 0.02);
|
|
for (int i = 0; i < 80; i++) {
|
|
float d = map(ro + rd * t);
|
|
if (d < 0.001) {
|
|
vec3 p = ro + rd * t;
|
|
vec3 n = getNormal(p);
|
|
float light = max(dot(n, normalize(vec3(0, 1, 0))), 0.0);
|
|
float fresnel = pow(1.0 - abs(dot(n, rd)), 3.0);
|
|
col = vec3(0.2, 0.5, 0.8) * light + vec3(0.5, 0.3, 0.9) * fresnel;
|
|
break;
|
|
}
|
|
t += d;
|
|
if (t > 20.0) break;
|
|
}
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["crystal", "cave", "3d", "underground", "fantasy", "blue", "raymarching"]),
|
|
]
|
|
|
|
for name, code, extra_tags in scenes_3d:
|
|
s(name, code, extra_tags, "3d", f"Raymarched 3D scene: {name}",
|
|
{"chaos_level": 0.4, "color_temperature": "cool", "motion_type": "orbiting"})
|
|
|
|
# --- Family: Glitch/distortion effects (10 shaders) ---
|
|
glitch_variants = [
|
|
("VHS Tracking", 0.01, 8.0, ["vhs", "tracking", "analog", "retro", "distortion"]),
|
|
("CRT Phosphor", 0.005, 3.0, ["crt", "phosphor", "monitor", "vintage", "scanline"]),
|
|
("Databend", 0.02, 15.0, ["databend", "corruption", "digital-art", "experimental"]),
|
|
("Signal Loss", 0.015, 6.0, ["signal", "loss", "static", "broadcast", "error"]),
|
|
("Pixel Sort", 0.008, 10.0, ["pixel-sort", "glitch-art", "sorting", "avant-garde"]),
|
|
("Bitcrush", 0.025, 4.0, ["bitcrush", "low-res", "lo-fi", "8bit", "quantize"]),
|
|
("Chroma Aberration", 0.012, 5.0, ["chroma", "aberration", "lens", "rgb", "optics"]),
|
|
("Digital Decay", 0.018, 12.0, ["digital-decay", "entropy", "corruption", "time"]),
|
|
("Broadcast Storm", 0.03, 7.0, ["broadcast", "storm", "interference", "signal"]),
|
|
("Codec Artifact", 0.02, 9.0, ["codec", "artifact", "compression", "jpeg", "macro-block"]),
|
|
]
|
|
|
|
for i, (name, intensity, freq, extra_tags) in enumerate(glitch_variants):
|
|
color_shift = ["vec3(0.0, 0.8, 0.3)", "vec3(0.8, 0.2, 0.5)", "vec3(0.2, 0.5, 1.0)",
|
|
"vec3(1.0, 0.6, 0.0)", "vec3(0.6, 0.0, 0.9)"][i % 5]
|
|
code = f"""float hash(float n) {{ return fract(sin(n) * 43758.5453); }}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {{
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
float t = floor(iTime * {freq:.1f});
|
|
float glitch = step(0.8, hash(t + uv.y * 10.0));
|
|
float blockY = floor(uv.y * 15.0);
|
|
float shift = hash(blockY + t) * {intensity * 20:.2f} * glitch;
|
|
uv.x = fract(uv.x + shift);
|
|
float scanline = sin(uv.y * 400.0 + iTime * 30.0) * 0.03;
|
|
float noise = hash(uv.y * 100.0 + t) * glitch * 0.2;
|
|
vec3 col;
|
|
col.r = 0.5 + 0.5 * sin(uv.x * 6.283 * 3.0 + iTime + {float(i):.1f});
|
|
col.g = 0.5 + 0.5 * sin(uv.x * 6.283 * 3.0 + iTime * 1.1 + 2.0 + {float(i):.1f});
|
|
col.b = 0.5 + 0.5 * sin(uv.x * 6.283 * 3.0 + iTime * 0.9 + 4.0 + {float(i):.1f});
|
|
col += scanline + noise;
|
|
col *= 0.7 + 0.3 * (1.0 - glitch);
|
|
col += {color_shift} * glitch * 0.3;
|
|
fragColor = vec4(col, 1.0);
|
|
}}"""
|
|
s(name, code,
|
|
["glitch", "distortion", "digital", "animated"] + extra_tags,
|
|
"2d", f"Glitch effect: {name.lower()}",
|
|
{"chaos_level": 0.7 + (i % 3) * 0.1, "color_temperature": "neutral", "motion_type": "chaotic"})
|
|
|
|
# --- Family: Minimalist geometric (10 shaders) ---
|
|
minimals = [
|
|
("Single Circle", "smoothstep(0.302, 0.3, length(uv))", "vec3(0.95)", "vec3(0.05)", ["circle", "minimal", "clean"]),
|
|
("Double Ring", "smoothstep(0.01,0.0,abs(length(uv)-0.3))+smoothstep(0.01,0.0,abs(length(uv)-0.5))", "vec3(0.9)", "vec3(0.05)", ["rings", "double", "minimal"]),
|
|
("Moving Dot", "smoothstep(0.06,0.05,length(uv-vec2(sin(iTime)*0.3,cos(iTime*0.7)*0.3)))", "vec3(1.0,0.3,0.2)", "vec3(0.02)", ["dot", "motion", "minimal"]),
|
|
("Cross Hair", "smoothstep(0.005,0.0,min(abs(uv.x),abs(uv.y)))*smoothstep(0.5,0.0,length(uv))", "vec3(0.9,0.1,0.1)", "vec3(0.02)", ["crosshair", "target", "minimal"]),
|
|
("Breathing Square", "step(max(abs(uv.x),abs(uv.y)),0.2+sin(iTime)*0.1)", "vec3(0.9)", "vec3(0.05)", ["square", "breathing", "minimal"]),
|
|
("Line Scan", "smoothstep(0.005,0.0,abs(uv.x-sin(iTime)*0.5))", "vec3(0.0,0.8,1.0)", "vec3(0.02)", ["line", "scan", "minimal"]),
|
|
("Dot Grid", "smoothstep(0.05,0.04,length(fract(uv*5.0+0.5)-0.5))", "vec3(0.3,0.3,0.35)", "vec3(0.05)", ["grid", "dots", "minimal"]),
|
|
("Gradient Only", "uv.y*0.5+0.5", "vec3(0.1,0.1,0.3)", "vec3(0.0)", ["gradient", "simple", "minimal"]),
|
|
("Orbit", "smoothstep(0.04,0.03,length(uv-0.3*vec2(cos(iTime),sin(iTime))))", "vec3(1.0,0.8,0.2)", "vec3(0.03,0.01,0.05)", ["orbit", "planet", "minimal"]),
|
|
("Pulse Ring", "smoothstep(0.01,0.0,abs(length(uv)-(mod(iTime,2.0)*0.5)))*exp(-mod(iTime,2.0)*2.0)", "vec3(0.0,0.9,0.5)", "vec3(0.02)", ["pulse", "ring", "expanding", "minimal"]),
|
|
]
|
|
|
|
for i, (name, expr, fg, bg, extra_tags) in enumerate(minimals):
|
|
code = f"""void mainImage(out vec4 fragColor, in vec2 fragCoord) {{
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float v = {expr};
|
|
vec3 col = mix({bg}, {fg}, v);
|
|
fragColor = vec4(col, 1.0);
|
|
}}"""
|
|
s(name, code,
|
|
["minimal", "geometric", "clean", "simple"] + extra_tags,
|
|
"2d", f"Minimalist: {name.lower()}",
|
|
{"chaos_level": 0.05 + (i % 3) * 0.05, "color_temperature": ["monochrome", "cool", "warm"][i % 3], "motion_type": "static" if i % 3 == 0 else "animated"})
|
|
|
|
# --- Family: More 3D environments (8 shaders) ---
|
|
more_3d = [
|
|
("Infinite Columns", """
|
|
float map(vec3 p) {
|
|
vec2 q = mod(p.xz + 1.0, 2.0) - 1.0;
|
|
float col = length(q) - 0.2;
|
|
float floor_d = p.y + 1.5;
|
|
float ceil_d = -(p.y - 3.0);
|
|
return min(min(col, floor_d), ceil_d);
|
|
}
|
|
vec3 getNormal(vec3 p) {
|
|
vec2 e = vec2(0.001, 0);
|
|
return normalize(vec3(map(p+e.xyy)-map(p-e.xyy),map(p+e.yxy)-map(p-e.yxy),map(p+e.yyx)-map(p-e.yyx)));
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
vec3 ro = vec3(iTime * 0.5, 0.0, iTime * 0.3);
|
|
vec3 rd = normalize(vec3(uv, 1.0));
|
|
float t = 0.0;
|
|
vec3 col = vec3(0.02);
|
|
for (int i = 0; i < 80; i++) {
|
|
float d = map(ro + rd * t);
|
|
if (d < 0.001) {
|
|
vec3 p = ro + rd * t;
|
|
vec3 n = getNormal(p);
|
|
float light = max(dot(n, normalize(vec3(1, 1, -1))), 0.0);
|
|
col = vec3(0.8, 0.75, 0.7) * (0.15 + 0.85 * light);
|
|
col = mix(col, vec3(0.02), 1.0 - exp(-t * 0.06));
|
|
break;
|
|
}
|
|
t += d;
|
|
if (t > 30.0) break;
|
|
}
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["columns", "infinite", "3d", "architectural", "ancient", "temple"]),
|
|
("Wormhole", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float r = length(uv);
|
|
float a = atan(uv.y, uv.x);
|
|
float tunnel = 1.0 / (r + 0.1);
|
|
float twist = a + tunnel * 0.5 + iTime;
|
|
float tex = sin(twist * 4.0) * sin(tunnel * 3.0 - iTime * 4.0);
|
|
float glow = exp(-r * 2.0);
|
|
vec3 col = vec3(0.02, 0.0, 0.05);
|
|
col += vec3(0.2, 0.5, 1.0) * tex * glow;
|
|
col += vec3(0.8, 0.4, 1.0) * glow * 0.3;
|
|
col += vec3(1.0, 0.9, 0.7) * exp(-r * 8.0) * 0.5;
|
|
fragColor = vec4(max(col, 0.0), 1.0);
|
|
}""", ["wormhole", "tunnel", "space", "3d-illusion", "portal", "sci-fi", "blue"]),
|
|
("Cubic Lattice", """
|
|
float map(vec3 p) {
|
|
vec3 q = mod(p + 0.5, 1.0) - 0.5;
|
|
float bars = min(min(
|
|
max(abs(q.x), abs(q.y)) - 0.08,
|
|
max(abs(q.y), abs(q.z)) - 0.08),
|
|
max(abs(q.x), abs(q.z)) - 0.08);
|
|
return bars;
|
|
}
|
|
vec3 getNormal(vec3 p) {
|
|
vec2 e = vec2(0.001, 0);
|
|
return normalize(vec3(map(p+e.xyy)-map(p-e.xyy),map(p+e.yxy)-map(p-e.yxy),map(p+e.yyx)-map(p-e.yyx)));
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float t = iTime * 0.3;
|
|
vec3 ro = vec3(sin(t)*3.0, 1.0+sin(t*0.7), cos(t)*3.0);
|
|
vec3 ta = vec3(0.0);
|
|
vec3 fwd = normalize(ta - ro);
|
|
vec3 right = normalize(cross(vec3(0,1,0), fwd));
|
|
vec3 up = cross(fwd, right);
|
|
vec3 rd = normalize(uv.x*right + uv.y*up + 1.5*fwd);
|
|
float d_t = 0.0;
|
|
vec3 col = vec3(0.02);
|
|
for (int i = 0; i < 80; i++) {
|
|
float d = map(ro + rd * d_t);
|
|
if (d < 0.001) {
|
|
vec3 p = ro + rd * d_t;
|
|
vec3 n = getNormal(p);
|
|
float light = max(dot(n, normalize(vec3(1,1,-1))), 0.0);
|
|
col = vec3(0.9, 0.5, 0.2) * (0.2 + 0.8 * light);
|
|
col = mix(col, vec3(0.02), 1.0 - exp(-d_t * 0.1));
|
|
break;
|
|
}
|
|
d_t += d;
|
|
if (d_t > 20.0) break;
|
|
}
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["lattice", "cubic", "3d", "wireframe", "structural", "orange", "geometric"]),
|
|
]
|
|
|
|
for name, code, extra_tags in more_3d:
|
|
s(name, code, extra_tags, "3d", f"3D scene: {name}",
|
|
{"chaos_level": 0.4, "color_temperature": "cool", "motion_type": "forward"})
|
|
|
|
# --- Family: Color theory experiments (10 shaders) ---
|
|
color_exps = [
|
|
("RGB Separation", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float t = iTime;
|
|
float r = length(uv - vec2(sin(t)*0.2, cos(t)*0.15)) - 0.3;
|
|
float g = length(uv - vec2(sin(t*1.1+2.0)*0.2, cos(t*0.9+1.0)*0.15)) - 0.3;
|
|
float b = length(uv - vec2(sin(t*0.8+4.0)*0.2, cos(t*1.2+3.0)*0.15)) - 0.3;
|
|
vec3 col;
|
|
col.r = smoothstep(0.01, 0.0, r);
|
|
col.g = smoothstep(0.01, 0.0, g);
|
|
col.b = smoothstep(0.01, 0.0, b);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["rgb", "separation", "additive", "color-theory", "circles", "primary-colors"]),
|
|
("CMY Overlap", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float t = iTime * 0.5;
|
|
float c = smoothstep(0.01, 0.0, length(uv - 0.15*vec2(sin(t), cos(t))) - 0.25);
|
|
float m = smoothstep(0.01, 0.0, length(uv - 0.15*vec2(sin(t+2.1), cos(t+2.1))) - 0.25);
|
|
float y = smoothstep(0.01, 0.0, length(uv - 0.15*vec2(sin(t+4.2), cos(t+4.2))) - 0.25);
|
|
vec3 col = vec3(1.0) - vec3(c, 0.0, 0.0) - vec3(0.0, m, 0.0) - vec3(0.0, 0.0, y);
|
|
col = max(col, 0.0);
|
|
col = mix(vec3(0.95), col, max(max(c, m), y));
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["cmy", "subtractive", "color-theory", "overlap", "pastel", "print"]),
|
|
("Hue Wheel", """
|
|
vec3 hsv(float h, float s, float v) {
|
|
vec3 c = clamp(abs(mod(h*6.0+vec3(0,4,2),6.0)-3.0)-1.0, 0.0, 1.0);
|
|
return v * mix(vec3(1.0), c, s);
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float a = atan(uv.y, uv.x) / 6.2832 + 0.5;
|
|
float r = length(uv);
|
|
vec3 col = hsv(a + iTime * 0.1, smoothstep(0.1, 0.4, r), smoothstep(0.5, 0.2, r));
|
|
float ring = smoothstep(0.01, 0.0, abs(r - 0.35));
|
|
col += ring * 0.3;
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["hue", "wheel", "color-theory", "hsv", "rainbow", "spectrum", "educational"]),
|
|
]
|
|
|
|
for name, code, extra_tags in color_exps:
|
|
s(name, code, extra_tags, "2d", f"Color theory: {name}",
|
|
{"chaos_level": 0.2, "color_temperature": "neutral", "motion_type": "animated"})
|
|
|
|
# --- Family: Particle systems (7 shaders) ---
|
|
particle_types = [
|
|
("Fireflies", "vec3(1.0,0.9,0.3)", 0.003, 30, ["fireflies", "night", "gentle", "nature"]),
|
|
("Snow Fall", "vec3(0.9,0.95,1.0)", 0.004, 50, ["snow", "winter", "cold", "peaceful"]),
|
|
("Ember Rise", "vec3(1.0,0.4,0.0)", 0.003, 40, ["ember", "fire", "rising", "warm"]),
|
|
("Dust Motes", "vec3(0.8,0.7,0.5)", 0.005, 25, ["dust", "motes", "sunbeam", "atmospheric"]),
|
|
("Pollen Drift", "vec3(0.9,0.8,0.2)", 0.006, 20, ["pollen", "spring", "floating", "organic"]),
|
|
("Star Rain", "vec3(0.8,0.9,1.0)", 0.002, 60, ["stars", "rain", "cosmic", "shower"]),
|
|
("Bubble Float", "vec3(0.5,0.8,1.0)", 0.008, 15, ["bubbles", "float", "underwater", "playful"]),
|
|
]
|
|
|
|
for i, (name, color, size, count, extra_tags) in enumerate(particle_types):
|
|
code = f"""float hash(float n) {{ return fract(sin(n) * 43758.5453); }}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {{
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
vec3 col = vec3(0.02, 0.01, 0.04);
|
|
for (int i = 0; i < {count}; i++) {{
|
|
float fi = float(i);
|
|
float seed = fi * 137.0 + {float(i * 17):.1f};
|
|
vec2 pos;
|
|
pos.x = hash(seed);
|
|
pos.y = fract(hash(seed + 1.0) + iTime * (0.02 + hash(seed + 2.0) * 0.04) * {1.0 if i % 2 == 0 else -1.0:.1f});
|
|
pos.x += sin(iTime * hash(seed + 3.0) + fi) * 0.02;
|
|
float d = length(uv - pos);
|
|
float brightness = hash(seed + 4.0) * 0.5 + 0.5;
|
|
float twinkle = sin(iTime * (2.0 + hash(seed + 5.0) * 3.0) + fi) * 0.3 + 0.7;
|
|
col += {color} * ({size} / (d + {size})) * brightness * twinkle;
|
|
}}
|
|
fragColor = vec4(col, 1.0);
|
|
}}"""
|
|
s(name, code,
|
|
["particles", "floating", "ambient", "animated"] + extra_tags,
|
|
"2d", f"Ambient particle system: {name.lower()}",
|
|
{"chaos_level": 0.2 + (i % 3) * 0.1, "color_temperature": ["warm", "cool", "neutral"][i % 3], "motion_type": "floating"})
|
|
|
|
# --- Family: More distinct 3D (10 shaders) ---
|
|
distinct_3d = [
|
|
("Infinite Corridor", """
|
|
float map(vec3 p) {
|
|
vec2 q = abs(mod(p.xz, 4.0) - 2.0);
|
|
float walls = min(q.x, q.y) - 0.1;
|
|
float ceiling = abs(p.y) - 2.0;
|
|
return max(-walls, ceiling);
|
|
}
|
|
vec3 getNormal(vec3 p) {
|
|
vec2 e = vec2(0.001, 0);
|
|
return normalize(vec3(map(p+e.xyy)-map(p-e.xyy),map(p+e.yxy)-map(p-e.yxy),map(p+e.yyx)-map(p-e.yyx)));
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
vec3 ro = vec3(0, 0, iTime);
|
|
vec3 rd = normalize(vec3(uv, 1.0));
|
|
float t = 0.0;
|
|
vec3 col = vec3(0.02);
|
|
for (int i = 0; i < 80; i++) {
|
|
float d = map(ro + rd * t);
|
|
if (abs(d) < 0.001) {
|
|
vec3 p = ro + rd * t;
|
|
vec3 n = getNormal(p);
|
|
col = vec3(0.6, 0.7, 0.8) * (0.2 + 0.8 * max(dot(n, vec3(0, 1, 0)), 0.0));
|
|
col *= 1.0 + 0.1 * sin(p.z);
|
|
col = mix(col, vec3(0.02), 1.0 - exp(-t * 0.04));
|
|
break;
|
|
}
|
|
t += abs(d);
|
|
if (t > 30.0) break;
|
|
}
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["corridor", "hallway", "infinite", "3d", "architectural", "perspective"]),
|
|
("Planet Surface", """
|
|
float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
|
|
float noise(vec2 p) {
|
|
vec2 i = floor(p); vec2 f = fract(p);
|
|
f = f * f * (3.0 - 2.0 * f);
|
|
return mix(mix(hash(i), hash(i+vec2(1,0)), f.x), mix(hash(i+vec2(0,1)), hash(i+vec2(1,1)), f.x), f.y);
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float r = length(uv);
|
|
float planet_r = 0.4;
|
|
vec3 col = vec3(0.0, 0.0, 0.02);
|
|
if (r < planet_r) {
|
|
float z = sqrt(planet_r * planet_r - r * r);
|
|
vec3 n = normalize(vec3(uv, z));
|
|
vec2 texUV = vec2(atan(n.x, n.z) + iTime * 0.2, asin(n.y));
|
|
float land = noise(texUV * 5.0) * 0.5 + noise(texUV * 10.0) * 0.25;
|
|
vec3 surface = mix(vec3(0.1, 0.3, 0.8), vec3(0.2, 0.6, 0.15), step(0.45, land));
|
|
float sun = max(dot(n, normalize(vec3(1, 0.5, 0.5))), 0.0);
|
|
col = surface * (0.1 + 0.9 * sun);
|
|
}
|
|
float atmo = smoothstep(planet_r + 0.02, planet_r - 0.02, r) * (1.0 - smoothstep(planet_r - 0.02, planet_r + 0.08, r));
|
|
col += vec3(0.3, 0.5, 1.0) * atmo * 0.3;
|
|
col += vec3(0.8, 0.9, 1.0) * 0.001 / (abs(r - planet_r) + 0.005);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["planet", "earth", "space", "3d", "sphere", "globe", "rotating"]),
|
|
("Disco Ball", """
|
|
float map(vec3 p) { return length(p) - 1.0; }
|
|
vec3 getNormal(vec3 p) { return normalize(p); }
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
vec3 ro = vec3(0, 0, -3);
|
|
vec3 rd = normalize(vec3(uv, 1.0));
|
|
float t = 0.0;
|
|
vec3 col = vec3(0.02);
|
|
for (int i = 0; i < 40; i++) {
|
|
float d = map(ro + rd * t);
|
|
if (d < 0.001) {
|
|
vec3 p = ro + rd * t;
|
|
vec3 n = getNormal(p);
|
|
float a1 = atan(n.z, n.x) + iTime * 0.5;
|
|
float a2 = acos(n.y);
|
|
float grid = step(0.9, fract(a1 * 5.0)) + step(0.9, fract(a2 * 5.0));
|
|
vec3 refl = reflect(rd, n);
|
|
float spec = pow(max(dot(refl, normalize(vec3(sin(iTime), 1, cos(iTime)))), 0.0), 32.0);
|
|
float mirror = 0.5 + 0.5 * fract(sin(dot(floor(vec2(a1, a2) * 5.0), vec2(127.1, 311.7))) * 43758.5);
|
|
col = vec3(0.3) * (1.0 - grid * 0.5) + vec3(1.0) * spec * mirror;
|
|
col += vec3(0.8, 0.3, 0.9) * spec * 0.3;
|
|
break;
|
|
}
|
|
t += d;
|
|
if (t > 10.0) break;
|
|
}
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["disco", "ball", "mirror", "3d", "party", "retro", "reflective", "fun"]),
|
|
]
|
|
|
|
for name, code, extra_tags in distinct_3d:
|
|
s(name, code, extra_tags, "3d", f"3D scene: {name}",
|
|
{"chaos_level": 0.4, "color_temperature": "cool", "motion_type": "rotating"})
|
|
|
|
# --- Standalone standouts (7 more to break 200) ---
|
|
|
|
s("Supernova", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float r = length(uv);
|
|
float a = atan(uv.y, uv.x);
|
|
float t = iTime;
|
|
float shockwave = smoothstep(0.02, 0.0, abs(r - mod(t * 0.5, 2.0)));
|
|
float core = exp(-r * 8.0);
|
|
float rays = pow(0.5 + 0.5 * sin(a * 12.0 + t * 3.0), 8.0) * exp(-r * 3.0);
|
|
vec3 col = vec3(1.0, 0.8, 0.3) * core;
|
|
col += vec3(1.0, 0.3, 0.1) * rays;
|
|
col += vec3(0.3, 0.5, 1.0) * shockwave;
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["supernova", "explosion", "star", "cosmic", "energy", "bright"], "2d",
|
|
"Supernova with expanding shockwave and ray corona",
|
|
{"chaos_level": 0.8, "color_temperature": "warm", "motion_type": "explosive"})
|
|
|
|
s("Fabric Fold", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
float fold = sin(uv.x * 12.0 + iTime * 0.3) * sin(uv.y * 8.0 - iTime * 0.21) * 0.5;
|
|
float shadow = fold * 0.5 + 0.5;
|
|
vec3 col = vec3(0.6, 0.15, 0.2) * (0.4 + 0.6 * shadow);
|
|
col += vec3(0.3, 0.1, 0.1) * pow(max(shadow, 0.0), 4.0);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["fabric", "fold", "cloth", "textile", "red", "silk", "elegant"], "2d",
|
|
"Folded silk fabric with dynamic shadow",
|
|
{"chaos_level": 0.2, "color_temperature": "warm", "motion_type": "fluid"})
|
|
|
|
s("EKG Heartbeat", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
float x = fract(uv.x * 2.0 - iTime * 0.5);
|
|
float y = uv.y * 2.0 - 1.0;
|
|
float ekg = 0.0;
|
|
if (x < 0.15) ekg = (x / 0.15) * 0.3;
|
|
else if (x < 0.2) ekg = (0.2 - x) / 0.05 * 0.3;
|
|
else if (x < 0.3) ekg = (x - 0.25) * 16.0;
|
|
else if (x < 0.35) ekg = (0.35 - x) * 16.0 - 0.2;
|
|
float d = abs(y - ekg);
|
|
vec3 col = vec3(0.0, 1.0, 0.3) * 0.004 / (d + 0.004);
|
|
col += vec3(0.0, 0.3, 0.1) * 0.015 / (d + 0.015);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["ekg", "heartbeat", "medical", "pulse", "green", "monitor", "health"], "2d",
|
|
"EKG heartbeat monitor trace",
|
|
{"chaos_level": 0.1, "color_temperature": "cool", "motion_type": "scrolling"})
|
|
|
|
s("Rotating Galaxy Arm", """
|
|
float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float r = length(uv);
|
|
float a = atan(uv.y, uv.x) + iTime * 0.2;
|
|
float arm = max(sin(a * 2.0 - r * 8.0) * exp(-r * 1.5), 0.0);
|
|
float stars = step(0.997, hash(floor(fragCoord)));
|
|
vec3 col = vec3(0.01, 0.0, 0.02) + vec3(0.3, 0.2, 0.5) * arm + vec3(0.8, 0.6, 0.3) * arm * arm * 2.0;
|
|
col += vec3(0.8, 0.85, 1.0) * stars * (1.0 - r);
|
|
col += vec3(1.0, 0.9, 0.6) * exp(-r * 12.0) * 0.5;
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["galaxy", "spiral-arm", "space", "stars", "cosmic", "astronomy"], "2d",
|
|
"Spiral galaxy with rotating arms and star field",
|
|
{"chaos_level": 0.4, "color_temperature": "warm", "motion_type": "rotating"})
|
|
|
|
s("Underwater Caustics", """
|
|
float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
|
|
float noise(vec2 p) {
|
|
vec2 i = floor(p); vec2 f = fract(p);
|
|
f = f * f * (3.0 - 2.0 * f);
|
|
return mix(mix(hash(i), hash(i+vec2(1,0)), f.x), mix(hash(i+vec2(0,1)), hash(i+vec2(1,1)), f.x), f.y);
|
|
}
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
float t = iTime * 0.5;
|
|
float c = 0.0;
|
|
for (int i = 0; i < 3; i++) {
|
|
float fi = float(i);
|
|
vec2 p = uv * (4.0 + fi * 2.0) + vec2(t * (0.3 + fi * 0.1), t * 0.2);
|
|
c += abs(sin(noise(p) * 6.283)) * (0.5 / (1.0 + fi));
|
|
}
|
|
vec3 col = mix(vec3(0.0, 0.15, 0.35), vec3(0.1, 0.6, 0.8), pow(c, 1.5));
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["underwater", "caustics", "water", "ocean", "blue", "ripple", "serene"], "2d",
|
|
"Underwater light caustics on the ocean floor",
|
|
{"chaos_level": 0.3, "color_temperature": "cool", "motion_type": "fluid"})
|
|
|
|
s("Geometric Rose", """
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = (fragCoord - 0.5 * iResolution.xy) / iResolution.y;
|
|
float r = length(uv);
|
|
float a = atan(uv.y, uv.x);
|
|
float rose = cos(a * 4.0 + iTime) * 0.3 + 0.3;
|
|
float inner = cos(a * 7.0 - iTime * 1.5) * 0.15 + 0.15;
|
|
vec3 col = vec3(0.02, 0.0, 0.04);
|
|
col += vec3(0.9, 0.2, 0.4) * 0.003 / (abs(r - rose) + 0.003);
|
|
col += vec3(1.0, 0.6, 0.7) * 0.002 / (abs(r - inner) + 0.002);
|
|
col += vec3(0.3, 0.05, 0.1) * exp(-r * 3.0);
|
|
fragColor = vec4(col, 1.0);
|
|
}""", ["rose", "polar", "mathematical", "curve", "pink", "elegant", "botanical"], "2d",
|
|
"Polar rose curves with counter-rotating petals",
|
|
{"chaos_level": 0.3, "color_temperature": "warm", "motion_type": "rotating"})
|
|
|
|
s("Data Stream", """
|
|
float hash(float n) { return fract(sin(n) * 43758.5453); }
|
|
void mainImage(out vec4 fragColor, in vec2 fragCoord) {
|
|
vec2 uv = fragCoord / iResolution.xy;
|
|
vec3 col = vec3(0.02, 0.01, 0.03);
|
|
for (int i = 0; i < 30; i++) {
|
|
float fi = float(i);
|
|
float lane = (fi + 0.5) / 30.0;
|
|
float speed = 0.5 + hash(fi * 7.0) * 2.0;
|
|
float y = fract(uv.y * 3.0 + iTime * speed + hash(fi * 13.0));
|
|
float on = step(0.3, hash(floor(y * 20.0) + fi * 100.0 + floor(iTime * speed * 3.0)));
|
|
float d = abs(uv.x - lane);
|
|
col += (0.5 + 0.5 * cos(fi * 0.5 + vec3(0, 2, 4))) * 0.001 / (d + 0.001) * on * y * 0.1;
|
|
}
|
|
fragColor = vec4(min(col, 1.0), 1.0);
|
|
}""", ["data", "stream", "digital", "network", "colorful", "flow", "tech", "cyber"], "2d",
|
|
"Multi-lane data streams at different speeds",
|
|
{"chaos_level": 0.5, "color_temperature": "cool", "motion_type": "flowing"})
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════
|
|
|
|
print(f"Total shaders defined: {len(SHADERS)}")
|
|
|
|
# --- Database insertion ---
|
|
async def seed():
|
|
import asyncpg
|
|
import json
|
|
import os
|
|
|
|
db_url = os.environ.get("DATABASE_URL_SYNC", "postgresql://fracta:devpass@postgres:5432/fractafrag")
|
|
# Convert sync URL to asyncpg format
|
|
db_url = db_url.replace("postgresql://", "postgresql://").replace("+asyncpg", "")
|
|
|
|
conn = await asyncpg.connect(db_url)
|
|
|
|
# Check if already seeded
|
|
count = await conn.fetchval("SELECT COUNT(*) FROM shaders WHERE is_system = TRUE")
|
|
if count > 0:
|
|
print(f"Already seeded ({count} system shaders). Skipping.")
|
|
await conn.close()
|
|
return
|
|
|
|
print(f"Seeding {len(SHADERS)} shaders...")
|
|
|
|
# Distribute creation times over past 30 days for realistic feed testing
|
|
now = datetime.now(timezone.utc)
|
|
total = len(SHADERS)
|
|
|
|
for i, shader in enumerate(SHADERS):
|
|
age_hours = random.uniform(0, 30 * 24) # up to 30 days ago
|
|
created_at = now - timedelta(hours=age_hours)
|
|
score = random.uniform(0, 10) # random initial score for feed ranking variety
|
|
|
|
shader_id = str(uuid.uuid4())
|
|
|
|
await conn.execute("""
|
|
INSERT INTO shaders (id, author_id, title, description, glsl_code, status, is_public,
|
|
is_ai_generated, is_system, system_label, tags, shader_type,
|
|
style_metadata, render_status, score, current_version,
|
|
created_at, updated_at)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18)
|
|
""",
|
|
uuid.UUID(shader_id),
|
|
uuid.UUID(SYSTEM_USER_ID),
|
|
shader["title"],
|
|
shader["description"],
|
|
shader["code"],
|
|
"published",
|
|
True,
|
|
False, # not AI-generated — these are hand-curated
|
|
True, # is_system
|
|
"fractafrag-curated",
|
|
shader["tags"],
|
|
shader["shader_type"],
|
|
json.dumps(shader["style_metadata"]),
|
|
"ready", # render_status — these render client-side
|
|
score,
|
|
1,
|
|
created_at,
|
|
created_at,
|
|
)
|
|
|
|
# Also create version 1 for each
|
|
await conn.execute("""
|
|
INSERT INTO shader_versions (id, shader_id, version_number, glsl_code, title, description,
|
|
tags, style_metadata, change_note, created_at)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
|
|
""",
|
|
uuid.uuid4(),
|
|
uuid.UUID(shader_id),
|
|
1,
|
|
shader["code"],
|
|
shader["title"],
|
|
shader["description"],
|
|
shader["tags"],
|
|
json.dumps(shader["style_metadata"]),
|
|
"Initial version — fractafrag curated content",
|
|
created_at,
|
|
)
|
|
|
|
if (i + 1) % 25 == 0:
|
|
print(f" ...{i + 1}/{total}")
|
|
|
|
await conn.close()
|
|
print(f"Done. {total} shaders seeded as 'fractafrag-curated' system content.")
|
|
|
|
if __name__ == "__main__":
|
|
asyncio.run(seed())
|