1866 lines
71 KiB
Markdown
1866 lines
71 KiB
Markdown
|
# Effect Catalog
|
|||
|
|
|
|||
|
|
Effect building blocks that produce visual patterns. In v2, these are used **inside scene functions** that return a pixel canvas directly. The building blocks below operate on grid coordinate arrays and produce `(chars, colors)` or value/hue fields that the scene function renders to canvas via `_render_vf()`.
|
|||
|
|
|
|||
|
|
> **See also:** architecture.md · composition.md · scenes.md · shaders.md · troubleshooting.md
|
|||
|
|
|
|||
|
|
## Design Philosophy
|
|||
|
|
|
|||
|
|
Effects are the creative core. Don't copy these verbatim for every project -- use them as **building blocks** and **combine, modify, and invent** new ones. Every project should feel distinct.
|
|||
|
|
|
|||
|
|
Key principles:
|
|||
|
|
- **Layer multiple effects** rather than using a single monolithic function
|
|||
|
|
- **Parameterize everything** -- hue, speed, density, amplitude should all be arguments
|
|||
|
|
- **React to features** -- audio/video features should modulate at least 2-3 parameters per effect
|
|||
|
|
- **Vary per section** -- never use the same effect config for the entire video
|
|||
|
|
- **Invent project-specific effects** -- the catalog below is a starting vocabulary, not a fixed set
|
|||
|
|
|
|||
|
|
---
|
|||
|
|
|
|||
|
|
## Background Fills
|
|||
|
|
|
|||
|
|
Every effect should start with a background. Never leave flat black.
|
|||
|
|
|
|||
|
|
### Animated Sine Field (General Purpose)
|
|||
|
|
```python
|
|||
|
|
def bg_sinefield(g, f, t, hue=0.6, bri=0.5, pal=PAL_DEFAULT,
|
|||
|
|
freq=(0.13, 0.17, 0.07, 0.09), speed=(0.5, -0.4, -0.3, 0.2)):
|
|||
|
|
"""Layered sine field. Adjust freq/speed tuples for different textures."""
|
|||
|
|
v1 = np.sin(g.cc*freq[0] + t*speed[0]) * np.sin(g.rr*freq[1] - t*speed[1]) * 0.5 + 0.5
|
|||
|
|
v2 = np.sin(g.cc*freq[2] - t*speed[2] + g.rr*freq[3]) * 0.4 + 0.5
|
|||
|
|
v3 = np.sin(g.dist_n*5 + t*0.2) * 0.3 + 0.4
|
|||
|
|
v4 = np.cos(g.angle*3 - t*0.6) * 0.15 + 0.5
|
|||
|
|
val = np.clip((v1*0.3 + v2*0.25 + v3*0.25 + v4*0.2) * bri * (0.6 + f["rms"]*0.6), 0.06, 1)
|
|||
|
|
mask = val > 0.03
|
|||
|
|
ch = val2char(val, mask, pal)
|
|||
|
|
h = np.full_like(val, hue) + f.get("cent", 0.5)*0.1 + val*0.08
|
|||
|
|
R, G, B = hsv2rgb(h, np.clip(0.35+f.get("flat",0.4)*0.4, 0, 1) * np.ones_like(val), val)
|
|||
|
|
return ch, mkc(R, G, B, g.rows, g.cols)
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Video-Source Background
|
|||
|
|
```python
|
|||
|
|
def bg_video(g, frame_rgb, pal=PAL_DEFAULT, brightness=0.5):
|
|||
|
|
small = np.array(Image.fromarray(frame_rgb).resize((g.cols, g.rows)))
|
|||
|
|
lum = np.mean(small, axis=2) / 255.0 * brightness
|
|||
|
|
mask = lum > 0.02
|
|||
|
|
ch = val2char(lum, mask, pal)
|
|||
|
|
co = np.clip(small * np.clip(lum[:,:,None]*1.5+0.3, 0.3, 1), 0, 255).astype(np.uint8)
|
|||
|
|
return ch, co
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Noise / Static Field
|
|||
|
|
```python
|
|||
|
|
def bg_noise(g, f, t, pal=PAL_BLOCKS, density=0.3, hue_drift=0.02):
|
|||
|
|
val = np.random.random((g.rows, g.cols)).astype(np.float32) * density * (0.5 + f["rms"]*0.5)
|
|||
|
|
val = np.clip(val, 0, 1); mask = val > 0.02
|
|||
|
|
ch = val2char(val, mask, pal)
|
|||
|
|
R, G, B = hsv2rgb(np.full_like(val, t*hue_drift % 1), np.full_like(val, 0.3), val)
|
|||
|
|
return ch, mkc(R, G, B, g.rows, g.cols)
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Perlin-Like Smooth Noise
|
|||
|
|
```python
|
|||
|
|
def bg_smooth_noise(g, f, t, hue=0.5, bri=0.5, pal=PAL_DOTS, octaves=3):
|
|||
|
|
"""Layered sine approximation of Perlin noise. Cheap, smooth, organic."""
|
|||
|
|
val = np.zeros((g.rows, g.cols), dtype=np.float32)
|
|||
|
|
for i in range(octaves):
|
|||
|
|
freq = 0.05 * (2 ** i)
|
|||
|
|
amp = 0.5 / (i + 1)
|
|||
|
|
phase = t * (0.3 + i * 0.2)
|
|||
|
|
val += np.sin(g.cc * freq + phase) * np.cos(g.rr * freq * 0.7 - phase * 0.5) * amp
|
|||
|
|
val = np.clip(val * 0.5 + 0.5, 0, 1) * bri
|
|||
|
|
mask = val > 0.03
|
|||
|
|
ch = val2char(val, mask, pal)
|
|||
|
|
h = np.full_like(val, hue) + val * 0.1
|
|||
|
|
R, G, B = hsv2rgb(h, np.full_like(val, 0.5), val)
|
|||
|
|
return ch, mkc(R, G, B, g.rows, g.cols)
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Cellular / Voronoi Approximation
|
|||
|
|
```python
|
|||
|
|
def bg_cellular(g, f, t, n_centers=12, hue=0.5, bri=0.6, pal=PAL_BLOCKS):
|
|||
|
|
"""Voronoi-like cells using distance to nearest of N moving centers."""
|
|||
|
|
rng = np.random.RandomState(42) # deterministic centers
|
|||
|
|
cx = (rng.rand(n_centers) * g.cols).astype(np.float32)
|
|||
|
|
cy = (rng.rand(n_centers) * g.rows).astype(np.float32)
|
|||
|
|
# Animate centers
|
|||
|
|
cx_t = cx + np.sin(t * 0.5 + np.arange(n_centers) * 0.7) * 5
|
|||
|
|
cy_t = cy + np.cos(t * 0.4 + np.arange(n_centers) * 0.9) * 3
|
|||
|
|
# Min distance to any center
|
|||
|
|
min_d = np.full((g.rows, g.cols), 999.0, dtype=np.float32)
|
|||
|
|
for i in range(n_centers):
|
|||
|
|
d = np.sqrt((g.cc - cx_t[i])**2 + (g.rr - cy_t[i])**2)
|
|||
|
|
min_d = np.minimum(min_d, d)
|
|||
|
|
val = np.clip(1.0 - min_d / (g.cols * 0.3), 0, 1) * bri
|
|||
|
|
# Cell edges (where distance is near-equal between two centers)
|
|||
|
|
# ... second-nearest trick for edge highlighting
|
|||
|
|
mask = val > 0.03
|
|||
|
|
ch = val2char(val, mask, pal)
|
|||
|
|
R, G, B = hsv2rgb(np.full_like(val, hue) + min_d * 0.005, np.full_like(val, 0.5), val)
|
|||
|
|
return ch, mkc(R, G, B, g.rows, g.cols)
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
---
|
|||
|
|
|
|||
|
|
> **Note:** The v1 `eff_rings`, `eff_rays`, `eff_spiral`, `eff_glow`, `eff_tunnel`, `eff_vortex`, `eff_freq_waves`, `eff_interference`, `eff_aurora`, and `eff_ripple` functions are superseded by the `vf_*` value field generators below (used via `_render_vf()`). The `vf_*` versions integrate with the multi-grid composition pipeline and are preferred for all new scenes.
|
|||
|
|
|
|||
|
|
---
|
|||
|
|
|
|||
|
|
## Particle Systems
|
|||
|
|
|
|||
|
|
### General Pattern
|
|||
|
|
All particle systems use persistent state via the `S` dict parameter:
|
|||
|
|
```python
|
|||
|
|
# S is the persistent state dict (same as r.S, passed explicitly)
|
|||
|
|
if "px" not in S:
|
|||
|
|
S["px"]=[]; S["py"]=[]; S["vx"]=[]; S["vy"]=[]; S["life"]=[]; S["char"]=[]
|
|||
|
|
|
|||
|
|
# Emit new particles (on beat, continuously, or on trigger)
|
|||
|
|
# Update: position += velocity, apply forces, decay life
|
|||
|
|
# Draw: map to grid, set char/color based on life
|
|||
|
|
# Cull: remove dead, cap total count
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Particle Character Sets
|
|||
|
|
|
|||
|
|
Don't hardcode particle chars. Choose per project/mood:
|
|||
|
|
|
|||
|
|
```python
|
|||
|
|
# Energy / explosive
|
|||
|
|
PART_ENERGY = list("*+#@\u26a1\u2726\u2605\u2588\u2593")
|
|||
|
|
PART_SPARK = list("\u00b7\u2022\u25cf\u2605\u2736*+")
|
|||
|
|
# Organic / natural
|
|||
|
|
PART_LEAF = list("\u2740\u2741\u2742\u2743\u273f\u2618\u2022")
|
|||
|
|
PART_SNOW = list("\u2744\u2745\u2746\u00b7\u2022*\u25cb")
|
|||
|
|
PART_RAIN = list("|\u2502\u2503\u2551/\\")
|
|||
|
|
PART_BUBBLE = list("\u25cb\u25ce\u25c9\u25cf\u2218\u2219\u00b0")
|
|||
|
|
# Data / tech
|
|||
|
|
PART_DATA = list("01{}[]<>|/\\")
|
|||
|
|
PART_HEX = list("0123456789ABCDEF")
|
|||
|
|
PART_BINARY = list("01")
|
|||
|
|
# Mystical
|
|||
|
|
PART_RUNE = list("\u16a0\u16a2\u16a6\u16b1\u16b7\u16c1\u16c7\u16d2\u16d6\u16da\u16de\u16df\u2726\u2605")
|
|||
|
|
PART_ZODIAC = list("\u2648\u2649\u264a\u264b\u264c\u264d\u264e\u264f\u2650\u2651\u2652\u2653")
|
|||
|
|
# Minimal
|
|||
|
|
PART_DOT = list("\u00b7\u2022\u25cf")
|
|||
|
|
PART_DASH = list("-=~\u2500\u2550")
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Explosion (Beat-Triggered)
|
|||
|
|
```python
|
|||
|
|
def emit_explosion(S, f, center_r, center_c, char_set=PART_ENERGY, count_base=80):
|
|||
|
|
if f.get("beat", 0) > 0:
|
|||
|
|
for _ in range(int(count_base + f["rms"]*150)):
|
|||
|
|
ang = random.uniform(0, 2*math.pi)
|
|||
|
|
sp = random.uniform(1, 9) * (0.5 + f.get("sub_r", 0.3)*2)
|
|||
|
|
S["px"].append(float(center_c))
|
|||
|
|
S["py"].append(float(center_r))
|
|||
|
|
S["vx"].append(math.cos(ang)*sp*2.5)
|
|||
|
|
S["vy"].append(math.sin(ang)*sp)
|
|||
|
|
S["life"].append(1.0)
|
|||
|
|
S["char"].append(random.choice(char_set))
|
|||
|
|
# Update: gravity on vy += 0.03, life -= 0.015
|
|||
|
|
# Color: life * 255 for brightness, hue fade controlled by caller
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Rising Embers
|
|||
|
|
```python
|
|||
|
|
# Emit: sy = rows-1, vy = -random.uniform(1,5), vx = random.uniform(-1.5,1.5)
|
|||
|
|
# Update: vx += random jitter * 0.3, life -= 0.01
|
|||
|
|
# Cap at ~1500 particles
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Dissolving Cloud
|
|||
|
|
```python
|
|||
|
|
# Init: N=600 particles spread across screen
|
|||
|
|
# Update: slow upward drift, fade life progressively
|
|||
|
|
# life -= 0.002 * (1 + elapsed * 0.05) # accelerating fade
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Starfield (3D Projection)
|
|||
|
|
```python
|
|||
|
|
# N stars with (sx, sy, sz) in normalized coords
|
|||
|
|
# Move: sz -= speed (stars approach camera)
|
|||
|
|
# Project: px = cx + sx/sz * cx, py = cy + sy/sz * cy
|
|||
|
|
# Reset stars that pass camera (sz <= 0.01)
|
|||
|
|
# Brightness = (1 - sz), draw streaks behind bright stars
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Orbit (Circular/Elliptical Motion)
|
|||
|
|
```python
|
|||
|
|
def emit_orbit(S, n=20, radius=15, speed=1.0, char_set=PART_DOT):
|
|||
|
|
"""Particles orbiting a center point."""
|
|||
|
|
for i in range(n):
|
|||
|
|
angle = i * 2 * math.pi / n
|
|||
|
|
S["px"].append(0.0); S["py"].append(0.0) # will be computed from angle
|
|||
|
|
S["vx"].append(angle) # store angle as "vx" for orbit
|
|||
|
|
S["vy"].append(radius + random.uniform(-2, 2)) # store radius
|
|||
|
|
S["life"].append(1.0)
|
|||
|
|
S["char"].append(random.choice(char_set))
|
|||
|
|
# Update: angle += speed * dt, px = cx + radius * cos(angle), py = cy + radius * sin(angle)
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Gravity Well
|
|||
|
|
```python
|
|||
|
|
# Particles attracted toward one or more gravity points
|
|||
|
|
# Update: compute force vector toward each well, apply as acceleration
|
|||
|
|
# Particles that reach well center respawn at edges
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Flocking / Boids
|
|||
|
|
|
|||
|
|
Emergent swarm behavior from three simple rules: separation, alignment, cohesion.
|
|||
|
|
|
|||
|
|
```python
|
|||
|
|
def update_boids(S, g, f, n_boids=200, perception=8.0, max_speed=2.0,
|
|||
|
|
sep_weight=1.5, ali_weight=1.0, coh_weight=1.0,
|
|||
|
|
char_set=None):
|
|||
|
|
"""Boids flocking simulation. Particles self-organize into organic groups.
|
|||
|
|
|
|||
|
|
perception: how far each boid can see (grid cells)
|
|||
|
|
sep_weight: separation (avoid crowding) strength
|
|||
|
|
ali_weight: alignment (match neighbor velocity) strength
|
|||
|
|
coh_weight: cohesion (steer toward group center) strength
|
|||
|
|
"""
|
|||
|
|
if char_set is None:
|
|||
|
|
char_set = list("·•●◦∘⬤")
|
|||
|
|
if "boid_x" not in S:
|
|||
|
|
rng = np.random.RandomState(42)
|
|||
|
|
S["boid_x"] = rng.uniform(0, g.cols, n_boids).astype(np.float32)
|
|||
|
|
S["boid_y"] = rng.uniform(0, g.rows, n_boids).astype(np.float32)
|
|||
|
|
S["boid_vx"] = (rng.random(n_boids).astype(np.float32) - 0.5) * max_speed
|
|||
|
|
S["boid_vy"] = (rng.random(n_boids).astype(np.float32) - 0.5) * max_speed
|
|||
|
|
S["boid_ch"] = [random.choice(char_set) for _ in range(n_boids)]
|
|||
|
|
|
|||
|
|
bx = S["boid_x"]; by = S["boid_y"]
|
|||
|
|
bvx = S["boid_vx"]; bvy = S["boid_vy"]
|
|||
|
|
n = len(bx)
|
|||
|
|
|
|||
|
|
# For each boid, compute steering forces
|
|||
|
|
ax = np.zeros(n, dtype=np.float32)
|
|||
|
|
ay = np.zeros(n, dtype=np.float32)
|
|||
|
|
|
|||
|
|
# Spatial hash for efficient neighbor lookup
|
|||
|
|
cell_size = perception
|
|||
|
|
cells = {}
|
|||
|
|
for i in range(n):
|
|||
|
|
cx_i = int(bx[i] / cell_size)
|
|||
|
|
cy_i = int(by[i] / cell_size)
|
|||
|
|
key = (cx_i, cy_i)
|
|||
|
|
if key not in cells:
|
|||
|
|
cells[key] = []
|
|||
|
|
cells[key].append(i)
|
|||
|
|
|
|||
|
|
for i in range(n):
|
|||
|
|
cx_i = int(bx[i] / cell_size)
|
|||
|
|
cy_i = int(by[i] / cell_size)
|
|||
|
|
sep_x, sep_y = 0.0, 0.0
|
|||
|
|
ali_x, ali_y = 0.0, 0.0
|
|||
|
|
coh_x, coh_y = 0.0, 0.0
|
|||
|
|
count = 0
|
|||
|
|
|
|||
|
|
# Check neighboring cells
|
|||
|
|
for dcx in range(-1, 2):
|
|||
|
|
for dcy in range(-1, 2):
|
|||
|
|
for j in cells.get((cx_i + dcx, cy_i + dcy), []):
|
|||
|
|
if j == i:
|
|||
|
|
continue
|
|||
|
|
dx = bx[j] - bx[i]
|
|||
|
|
dy = by[j] - by[i]
|
|||
|
|
dist = np.sqrt(dx * dx + dy * dy)
|
|||
|
|
if dist < perception and dist > 0.01:
|
|||
|
|
count += 1
|
|||
|
|
# Separation: steer away from close neighbors
|
|||
|
|
if dist < perception * 0.4:
|
|||
|
|
sep_x -= dx / (dist * dist)
|
|||
|
|
sep_y -= dy / (dist * dist)
|
|||
|
|
# Alignment: match velocity
|
|||
|
|
ali_x += bvx[j]
|
|||
|
|
ali_y += bvy[j]
|
|||
|
|
# Cohesion: steer toward center of group
|
|||
|
|
coh_x += bx[j]
|
|||
|
|
coh_y += by[j]
|
|||
|
|
|
|||
|
|
if count > 0:
|
|||
|
|
# Normalize and weight
|
|||
|
|
ax[i] += sep_x * sep_weight
|
|||
|
|
ay[i] += sep_y * sep_weight
|
|||
|
|
ax[i] += (ali_x / count - bvx[i]) * ali_weight * 0.1
|
|||
|
|
ay[i] += (ali_y / count - bvy[i]) * ali_weight * 0.1
|
|||
|
|
ax[i] += (coh_x / count - bx[i]) * coh_weight * 0.01
|
|||
|
|
ay[i] += (coh_y / count - by[i]) * coh_weight * 0.01
|
|||
|
|
|
|||
|
|
# Audio reactivity: bass pushes boids outward from center
|
|||
|
|
if f.get("bass", 0) > 0.5:
|
|||
|
|
cx_g, cy_g = g.cols / 2, g.rows / 2
|
|||
|
|
dx = bx - cx_g; dy = by - cy_g
|
|||
|
|
dist = np.sqrt(dx**2 + dy**2) + 1
|
|||
|
|
ax += (dx / dist) * f["bass"] * 2
|
|||
|
|
ay += (dy / dist) * f["bass"] * 2
|
|||
|
|
|
|||
|
|
# Update velocity and position
|
|||
|
|
bvx += ax; bvy += ay
|
|||
|
|
# Clamp speed
|
|||
|
|
speed = np.sqrt(bvx**2 + bvy**2) + 1e-10
|
|||
|
|
over = speed > max_speed
|
|||
|
|
bvx[over] *= max_speed / speed[over]
|
|||
|
|
bvy[over] *= max_speed / speed[over]
|
|||
|
|
bx += bvx; by += bvy
|
|||
|
|
|
|||
|
|
# Wrap at edges
|
|||
|
|
bx %= g.cols; by %= g.rows
|
|||
|
|
|
|||
|
|
S["boid_x"] = bx; S["boid_y"] = by
|
|||
|
|
S["boid_vx"] = bvx; S["boid_vy"] = bvy
|
|||
|
|
|
|||
|
|
# Draw
|
|||
|
|
ch = np.full((g.rows, g.cols), " ", dtype="U1")
|
|||
|
|
co = np.zeros((g.rows, g.cols, 3), dtype=np.uint8)
|
|||
|
|
for i in range(n):
|
|||
|
|
r, c = int(by[i]) % g.rows, int(bx[i]) % g.cols
|
|||
|
|
ch[r, c] = S["boid_ch"][i]
|
|||
|
|
spd = min(1.0, speed[i] / max_speed)
|
|||
|
|
R, G, B = hsv2rgb_scalar(spd * 0.3, 0.8, 0.5 + spd * 0.5)
|
|||
|
|
co[r, c] = (R, G, B)
|
|||
|
|
return ch, co
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Flow Field Particles
|
|||
|
|
|
|||
|
|
Particles that follow the gradient of a value field. Any `vf_*` function becomes a "river" that carries particles:
|
|||
|
|
|
|||
|
|
```python
|
|||
|
|
def update_flow_particles(S, g, f, flow_field, n=500, speed=1.0,
|
|||
|
|
life_drain=0.005, emit_rate=10,
|
|||
|
|
char_set=None):
|
|||
|
|
"""Particles steered by a value field gradient.
|
|||
|
|
|
|||
|
|
flow_field: float32 (rows, cols) — the field particles follow.
|
|||
|
|
Particles flow from low to high values (uphill) or along
|
|||
|
|
the gradient direction.
|
|||
|
|
"""
|
|||
|
|
if char_set is None:
|
|||
|
|
char_set = list("·•∘◦°⋅")
|
|||
|
|
if "fp_x" not in S:
|
|||
|
|
S["fp_x"] = []; S["fp_y"] = []; S["fp_vx"] = []; S["fp_vy"] = []
|
|||
|
|
S["fp_life"] = []; S["fp_ch"] = []
|
|||
|
|
|
|||
|
|
# Emit new particles at random positions
|
|||
|
|
for _ in range(emit_rate):
|
|||
|
|
if len(S["fp_x"]) < n:
|
|||
|
|
S["fp_x"].append(random.uniform(0, g.cols - 1))
|
|||
|
|
S["fp_y"].append(random.uniform(0, g.rows - 1))
|
|||
|
|
S["fp_vx"].append(0.0); S["fp_vy"].append(0.0)
|
|||
|
|
S["fp_life"].append(1.0)
|
|||
|
|
S["fp_ch"].append(random.choice(char_set))
|
|||
|
|
|
|||
|
|
# Compute gradient of flow field (central differences)
|
|||
|
|
pad = np.pad(flow_field, 1, mode="wrap")
|
|||
|
|
grad_x = (pad[1:-1, 2:] - pad[1:-1, :-2]) * 0.5
|
|||
|
|
grad_y = (pad[2:, 1:-1] - pad[:-2, 1:-1]) * 0.5
|
|||
|
|
|
|||
|
|
# Update particles
|
|||
|
|
i = 0
|
|||
|
|
while i < len(S["fp_x"]):
|
|||
|
|
px, py = S["fp_x"][i], S["fp_y"][i]
|
|||
|
|
# Sample gradient at particle position
|
|||
|
|
gc = int(px) % g.cols; gr = int(py) % g.rows
|
|||
|
|
gx = grad_x[gr, gc]; gy = grad_y[gr, gc]
|
|||
|
|
# Steer velocity toward gradient direction
|
|||
|
|
S["fp_vx"][i] = S["fp_vx"][i] * 0.9 + gx * speed * 10
|
|||
|
|
S["fp_vy"][i] = S["fp_vy"][i] * 0.9 + gy * speed * 10
|
|||
|
|
S["fp_x"][i] += S["fp_vx"][i]
|
|||
|
|
S["fp_y"][i] += S["fp_vy"][i]
|
|||
|
|
S["fp_life"][i] -= life_drain
|
|||
|
|
|
|||
|
|
if S["fp_life"][i] <= 0:
|
|||
|
|
for k in ("fp_x", "fp_y", "fp_vx", "fp_vy", "fp_life", "fp_ch"):
|
|||
|
|
S[k].pop(i)
|
|||
|
|
else:
|
|||
|
|
i += 1
|
|||
|
|
|
|||
|
|
# Draw
|
|||
|
|
ch = np.full((g.rows, g.cols), " ", dtype="U1")
|
|||
|
|
co = np.zeros((g.rows, g.cols, 3), dtype=np.uint8)
|
|||
|
|
for i in range(len(S["fp_x"])):
|
|||
|
|
r = int(S["fp_y"][i]) % g.rows
|
|||
|
|
c = int(S["fp_x"][i]) % g.cols
|
|||
|
|
ch[r, c] = S["fp_ch"][i]
|
|||
|
|
v = S["fp_life"][i]
|
|||
|
|
co[r, c] = (int(v * 200), int(v * 180), int(v * 255))
|
|||
|
|
return ch, co
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Particle Trails
|
|||
|
|
|
|||
|
|
Draw fading lines between current and previous positions:
|
|||
|
|
|
|||
|
|
```python
|
|||
|
|
def draw_particle_trails(S, g, trail_key="trails", max_trail=8, fade=0.7):
|
|||
|
|
"""Add trails to any particle system. Call after updating positions.
|
|||
|
|
Stores previous positions in S[trail_key] and draws fading lines.
|
|||
|
|
|
|||
|
|
Expects S to have 'px', 'py' lists (standard particle keys).
|
|||
|
|
max_trail: number of previous positions to remember
|
|||
|
|
fade: brightness multiplier per trail step (0.7 = 70% each step back)
|
|||
|
|
"""
|
|||
|
|
if trail_key not in S:
|
|||
|
|
S[trail_key] = []
|
|||
|
|
|
|||
|
|
# Store current positions
|
|||
|
|
current = list(zip(
|
|||
|
|
[int(y) for y in S.get("py", [])],
|
|||
|
|
[int(x) for x in S.get("px", [])]
|
|||
|
|
))
|
|||
|
|
S[trail_key].append(current)
|
|||
|
|
if len(S[trail_key]) > max_trail:
|
|||
|
|
S[trail_key] = S[trail_key][-max_trail:]
|
|||
|
|
|
|||
|
|
# Draw trails onto char/color arrays
|
|||
|
|
ch = np.full((g.rows, g.cols), " ", dtype="U1")
|
|||
|
|
co = np.zeros((g.rows, g.cols, 3), dtype=np.uint8)
|
|||
|
|
trail_chars = list("·∘◦°⋅.,'`")
|
|||
|
|
|
|||
|
|
for age, positions in enumerate(reversed(S[trail_key])):
|
|||
|
|
bri = fade ** age
|
|||
|
|
if bri < 0.05:
|
|||
|
|
break
|
|||
|
|
ci = min(age, len(trail_chars) - 1)
|
|||
|
|
for r, c in positions:
|
|||
|
|
if 0 <= r < g.rows and 0 <= c < g.cols and ch[r, c] == " ":
|
|||
|
|
ch[r, c] = trail_chars[ci]
|
|||
|
|
v = int(bri * 180)
|
|||
|
|
co[r, c] = (v, v, int(v * 0.8))
|
|||
|
|
return ch, co
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
---
|
|||
|
|
|
|||
|
|
## Rain / Matrix Effects
|
|||
|
|
|
|||
|
|
### Column Rain (Vectorized)
|
|||
|
|
```python
|
|||
|
|
def eff_matrix_rain(g, f, t, S, hue=0.33, bri=0.6, pal=PAL_KATA,
|
|||
|
|
speed_base=0.5, speed_beat=3.0):
|
|||
|
|
"""Vectorized matrix rain. S dict persists column positions."""
|
|||
|
|
if "ry" not in S or len(S["ry"]) != g.cols:
|
|||
|
|
S["ry"] = np.random.uniform(-g.rows, g.rows, g.cols).astype(np.float32)
|
|||
|
|
S["rsp"] = np.random.uniform(0.3, 2.0, g.cols).astype(np.float32)
|
|||
|
|
S["rln"] = np.random.randint(8, 40, g.cols)
|
|||
|
|
S["rch"] = np.random.randint(0, len(pal), (g.rows, g.cols)) # pre-assign chars
|
|||
|
|
|
|||
|
|
speed_mult = speed_base + f.get("bass", 0.3)*speed_beat + f.get("sub_r", 0.3)*3
|
|||
|
|
if f.get("beat", 0) > 0: speed_mult *= 2.5
|
|||
|
|
S["ry"] += S["rsp"] * speed_mult
|
|||
|
|
|
|||
|
|
# Reset columns that fall past bottom
|
|||
|
|
rst = (S["ry"] - S["rln"]) > g.rows
|
|||
|
|
S["ry"][rst] = np.random.uniform(-25, -2, rst.sum())
|
|||
|
|
|
|||
|
|
# Vectorized draw using fancy indexing
|
|||
|
|
ch = np.full((g.rows, g.cols), " ", dtype="U1")
|
|||
|
|
co = np.zeros((g.rows, g.cols, 3), dtype=np.uint8)
|
|||
|
|
heads = S["ry"].astype(int)
|
|||
|
|
for c in range(g.cols):
|
|||
|
|
head = heads[c]
|
|||
|
|
trail_len = S["rln"][c]
|
|||
|
|
for i in range(trail_len):
|
|||
|
|
row = head - i
|
|||
|
|
if 0 <= row < g.rows:
|
|||
|
|
fade = 1.0 - i / trail_len
|
|||
|
|
ci = S["rch"][row, c] % len(pal)
|
|||
|
|
ch[row, c] = pal[ci]
|
|||
|
|
v = fade * bri * 255
|
|||
|
|
if i == 0: # head is bright white-ish
|
|||
|
|
co[row, c] = (int(v*0.9), int(min(255, v*1.1)), int(v*0.9))
|
|||
|
|
else:
|
|||
|
|
R, G, B = hsv2rgb_single(hue, 0.7, fade * bri)
|
|||
|
|
co[row, c] = (R, G, B)
|
|||
|
|
return ch, co, S
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
---
|
|||
|
|
|
|||
|
|
## Glitch / Data Effects
|
|||
|
|
|
|||
|
|
### Horizontal Band Displacement
|
|||
|
|
```python
|
|||
|
|
def eff_glitch_displace(ch, co, f, intensity=1.0):
|
|||
|
|
n_bands = int(8 + f.get("flux", 0.3)*25 + f.get("bdecay", 0)*15) * intensity
|
|||
|
|
for _ in range(int(n_bands)):
|
|||
|
|
y = random.randint(0, ch.shape[0]-1)
|
|||
|
|
h = random.randint(1, int(3 + f.get("sub", 0.3)*8))
|
|||
|
|
shift = int((random.random()-0.5) * f.get("rms", 0.3)*40 + f.get("bdecay", 0)*20*(random.random()-0.5))
|
|||
|
|
if shift != 0:
|
|||
|
|
for row in range(h):
|
|||
|
|
rr = y + row
|
|||
|
|
if 0 <= rr < ch.shape[0]:
|
|||
|
|
ch[rr] = np.roll(ch[rr], shift)
|
|||
|
|
co[rr] = np.roll(co[rr], shift, axis=0)
|
|||
|
|
return ch, co
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Block Corruption
|
|||
|
|
```python
|
|||
|
|
def eff_block_corrupt(ch, co, f, char_pool=None, count_base=20):
|
|||
|
|
if char_pool is None:
|
|||
|
|
char_pool = list(PAL_BLOCKS[4:] + PAL_KATA[2:8])
|
|||
|
|
for _ in range(int(count_base + f.get("flux", 0.3)*60 + f.get("bdecay", 0)*40)):
|
|||
|
|
bx = random.randint(0, max(1, ch.shape[1]-6))
|
|||
|
|
by = random.randint(0, max(1, ch.shape[0]-4))
|
|||
|
|
bw, bh = random.randint(2,6), random.randint(1,4)
|
|||
|
|
block_char = random.choice(char_pool)
|
|||
|
|
# Fill rectangle with single char and random color
|
|||
|
|
for r in range(bh):
|
|||
|
|
for c in range(bw):
|
|||
|
|
rr, cc = by+r, bx+c
|
|||
|
|
if 0 <= rr < ch.shape[0] and 0 <= cc < ch.shape[1]:
|
|||
|
|
ch[rr, cc] = block_char
|
|||
|
|
co[rr, cc] = (random.randint(100,255), random.randint(0,100), random.randint(0,80))
|
|||
|
|
return ch, co
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Scan Bars (Vertical)
|
|||
|
|
```python
|
|||
|
|
def eff_scanbars(ch, co, f, t, n_base=4, chars="|\u2551|!1l"):
|
|||
|
|
for bi in range(int(n_base + f.get("himid_r", 0.3)*12)):
|
|||
|
|
sx = int((t*50*(1+bi*0.3) + bi*37) % ch.shape[1])
|
|||
|
|
for rr in range(ch.shape[0]):
|
|||
|
|
if random.random() < 0.7:
|
|||
|
|
ch[rr, sx] = random.choice(chars)
|
|||
|
|
return ch, co
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Error Messages
|
|||
|
|
```python
|
|||
|
|
# Parameterize the error vocabulary per project:
|
|||
|
|
ERRORS_TECH = ["SEGFAULT","0xDEADBEEF","BUFFER_OVERRUN","PANIC!","NULL_PTR",
|
|||
|
|
"CORRUPT","SIGSEGV","ERR_OVERFLOW","STACK_SMASH","BAD_ALLOC"]
|
|||
|
|
ERRORS_COSMIC = ["VOID_BREACH","ENTROPY_MAX","SINGULARITY","DIMENSION_FAULT",
|
|||
|
|
"REALITY_ERR","TIME_PARADOX","DARK_MATTER_LEAK","QUANTUM_DECOHERE"]
|
|||
|
|
ERRORS_ORGANIC = ["CELL_DIVISION_ERR","DNA_MISMATCH","MUTATION_OVERFLOW",
|
|||
|
|
"NEURAL_DEADLOCK","SYNAPSE_TIMEOUT","MEMBRANE_BREACH"]
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Hex Data Stream
|
|||
|
|
```python
|
|||
|
|
hex_str = "".join(random.choice("0123456789ABCDEF") for _ in range(random.randint(8,20)))
|
|||
|
|
stamp(ch, co, hex_str, rand_row, rand_col, (0, 160, 80))
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
---
|
|||
|
|
|
|||
|
|
## Spectrum / Visualization
|
|||
|
|
|
|||
|
|
### Mirrored Spectrum Bars
|
|||
|
|
```python
|
|||
|
|
def eff_spectrum(g, f, t, n_bars=64, pal=PAL_BLOCKS, mirror=True):
|
|||
|
|
bar_w = max(1, g.cols // n_bars); mid = g.rows // 2
|
|||
|
|
band_vals = np.array([f.get("sub",0.3), f.get("bass",0.3), f.get("lomid",0.3),
|
|||
|
|
f.get("mid",0.3), f.get("himid",0.3), f.get("hi",0.3)])
|
|||
|
|
ch = np.full((g.rows, g.cols), " ", dtype="U1")
|
|||
|
|
co = np.zeros((g.rows, g.cols, 3), dtype=np.uint8)
|
|||
|
|
for b in range(n_bars):
|
|||
|
|
frac = b / n_bars
|
|||
|
|
fi = frac * 5; lo_i = int(fi); hi_i = min(lo_i+1, 5)
|
|||
|
|
bval = min(1, (band_vals[lo_i]*(1-fi%1) + band_vals[hi_i]*(fi%1)) * 1.8)
|
|||
|
|
height = int(bval * (g.rows//2 - 2))
|
|||
|
|
for dy in range(height):
|
|||
|
|
hue = (f.get("cent",0.5)*0.3 + frac*0.3 + dy/max(height,1)*0.15) % 1.0
|
|||
|
|
ci = pal[min(int(dy/max(height,1)*len(pal)*0.7+len(pal)*0.2), len(pal)-1)]
|
|||
|
|
for dc in range(bar_w - (1 if bar_w > 2 else 0)):
|
|||
|
|
cc = b*bar_w + dc
|
|||
|
|
if 0 <= cc < g.cols:
|
|||
|
|
rows_to_draw = [mid - dy, mid + dy] if mirror else [g.rows - 1 - dy]
|
|||
|
|
for row in rows_to_draw:
|
|||
|
|
if 0 <= row < g.rows:
|
|||
|
|
ch[row, cc] = ci
|
|||
|
|
co[row, cc] = hsv_to_rgb_single(hue, 0.85, 0.5+dy/max(height,1)*0.5)
|
|||
|
|
return ch, co
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Waveform
|
|||
|
|
```python
|
|||
|
|
def eff_waveform(g, f, t, row_offset=-5, hue=0.1):
|
|||
|
|
ch = np.full((g.rows, g.cols), " ", dtype="U1")
|
|||
|
|
co = np.zeros((g.rows, g.cols, 3), dtype=np.uint8)
|
|||
|
|
for c in range(g.cols):
|
|||
|
|
wv = (math.sin(c*0.15+t*5)*f.get("bass",0.3)*0.5
|
|||
|
|
+ math.sin(c*0.3+t*8)*f.get("mid",0.3)*0.3
|
|||
|
|
+ math.sin(c*0.6+t*12)*f.get("hi",0.3)*0.15)
|
|||
|
|
wr = g.rows + row_offset + int(wv * 4)
|
|||
|
|
if 0 <= wr < g.rows:
|
|||
|
|
ch[wr, c] = "~"
|
|||
|
|
v = int(120 + f.get("rms",0.3)*135)
|
|||
|
|
co[wr, c] = [v, int(v*0.7), int(v*0.4)]
|
|||
|
|
return ch, co
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
---
|
|||
|
|
|
|||
|
|
## Fire / Lava
|
|||
|
|
|
|||
|
|
### Fire Columns
|
|||
|
|
```python
|
|||
|
|
def eff_fire(g, f, t, n_base=20, hue_base=0.02, hue_range=0.12, pal=PAL_BLOCKS):
|
|||
|
|
n_cols = int(n_base + f.get("bass",0.3)*30 + f.get("sub_r",0.3)*20)
|
|||
|
|
ch = np.full((g.rows, g.cols), " ", dtype="U1")
|
|||
|
|
co = np.zeros((g.rows, g.cols, 3), dtype=np.uint8)
|
|||
|
|
for fi in range(n_cols):
|
|||
|
|
fx_c = int((fi*g.cols/n_cols + np.sin(t*2+fi*0.7)*3) % g.cols)
|
|||
|
|
height = int((f.get("bass",0.3)*0.4 + f.get("sub_r",0.3)*0.3 + f.get("rms",0.3)*0.3) * g.rows * 0.7)
|
|||
|
|
for dy in range(min(height, g.rows)):
|
|||
|
|
fr = g.rows - 1 - dy
|
|||
|
|
frac = dy / max(height, 1)
|
|||
|
|
bri = max(0.1, (1 - frac*0.6) * (0.5 + f.get("rms",0.3)*0.5))
|
|||
|
|
hue = hue_base + frac * hue_range
|
|||
|
|
ci = "\u2588" if frac<0.2 else ("\u2593" if frac<0.4 else ("\u2592" if frac<0.6 else "\u2591"))
|
|||
|
|
ch[fr, fx_c] = ci
|
|||
|
|
R, G, B = hsv2rgb_single(hue, 0.9, bri)
|
|||
|
|
co[fr, fx_c] = (R, G, B)
|
|||
|
|
return ch, co
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Ice / Cold Fire (same structure, different hue range)
|
|||
|
|
```python
|
|||
|
|
# hue_base=0.55, hue_range=0.15 -- blue to cyan
|
|||
|
|
# Lower intensity, slower movement
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
---
|
|||
|
|
|
|||
|
|
## Text Overlays
|
|||
|
|
|
|||
|
|
### Scrolling Ticker
|
|||
|
|
```python
|
|||
|
|
def eff_ticker(ch, co, t, text, row, speed=15, color=(80, 100, 140)):
|
|||
|
|
off = int(t * speed) % max(len(text), 1)
|
|||
|
|
doubled = text + " " + text
|
|||
|
|
stamp(ch, co, doubled[off:off+ch.shape[1]], row, 0, color)
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Beat-Triggered Words
|
|||
|
|
```python
|
|||
|
|
def eff_beat_words(ch, co, f, words, row_center=None, color=(255,240,220)):
|
|||
|
|
if f.get("beat", 0) > 0:
|
|||
|
|
w = random.choice(words)
|
|||
|
|
r = (row_center or ch.shape[0]//2) + random.randint(-5,5)
|
|||
|
|
stamp(ch, co, w, r, (ch.shape[1]-len(w))//2, color)
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Fading Message Sequence
|
|||
|
|
```python
|
|||
|
|
def eff_fading_messages(ch, co, t, elapsed, messages, period=4.0, color_base=(220,220,220)):
|
|||
|
|
msg_idx = int(elapsed / period) % len(messages)
|
|||
|
|
phase = elapsed % period
|
|||
|
|
fade = max(0, min(1.0, phase) * min(1.0, period - phase))
|
|||
|
|
if fade > 0.05:
|
|||
|
|
v = fade
|
|||
|
|
msg = messages[msg_idx]
|
|||
|
|
cr, cg, cb = [int(c * v) for c in color_base]
|
|||
|
|
stamp(ch, co, msg, ch.shape[0]//2, (ch.shape[1]-len(msg))//2, (cr, cg, cb))
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
---
|
|||
|
|
|
|||
|
|
## Screen Shake
|
|||
|
|
Shift entire char/color arrays on beat:
|
|||
|
|
```python
|
|||
|
|
def eff_shake(ch, co, f, x_amp=6, y_amp=3):
|
|||
|
|
shake_x = int(f.get("sub",0.3)*x_amp*(random.random()-0.5)*2 + f.get("bdecay",0)*4*(random.random()-0.5)*2)
|
|||
|
|
shake_y = int(f.get("bass",0.3)*y_amp*(random.random()-0.5)*2)
|
|||
|
|
if abs(shake_x) > 0:
|
|||
|
|
ch = np.roll(ch, shake_x, axis=1)
|
|||
|
|
co = np.roll(co, shake_x, axis=1)
|
|||
|
|
if abs(shake_y) > 0:
|
|||
|
|
ch = np.roll(ch, shake_y, axis=0)
|
|||
|
|
co = np.roll(co, shake_y, axis=0)
|
|||
|
|
return ch, co
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
---
|
|||
|
|
|
|||
|
|
## Composable Effect System
|
|||
|
|
|
|||
|
|
The real creative power comes from **composition**. There are three levels:
|
|||
|
|
|
|||
|
|
### Level 1: Character-Level Layering
|
|||
|
|
|
|||
|
|
Stack multiple effects as `(chars, colors)` layers:
|
|||
|
|
|
|||
|
|
```python
|
|||
|
|
class LayerStack(EffectNode):
|
|||
|
|
"""Render effects bottom-to-top with character-level compositing."""
|
|||
|
|
def add(self, effect, alpha=1.0):
|
|||
|
|
"""alpha < 1.0 = probabilistic override (sparse overlay)."""
|
|||
|
|
self.layers.append((effect, alpha))
|
|||
|
|
|
|||
|
|
# Usage:
|
|||
|
|
stack = LayerStack()
|
|||
|
|
stack.add(bg_effect) # base — fills screen
|
|||
|
|
stack.add(main_effect) # overlay on top (space chars = transparent)
|
|||
|
|
stack.add(particle_effect) # sparse overlay on top of that
|
|||
|
|
ch, co = stack.render(g, f, t, S)
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Level 2: Pixel-Level Blending
|
|||
|
|
|
|||
|
|
After rendering to canvases, blend with Photoshop-style modes:
|
|||
|
|
|
|||
|
|
```python
|
|||
|
|
class PixelBlendStack:
|
|||
|
|
"""Stack canvases with blend modes for complex compositing."""
|
|||
|
|
def add(self, canvas, mode="normal", opacity=1.0)
|
|||
|
|
def composite(self) -> canvas
|
|||
|
|
|
|||
|
|
# Usage:
|
|||
|
|
pbs = PixelBlendStack()
|
|||
|
|
pbs.add(canvas_a) # base
|
|||
|
|
pbs.add(canvas_b, "screen", 0.7) # additive glow
|
|||
|
|
pbs.add(canvas_c, "difference", 0.5) # psychedelic interference
|
|||
|
|
result = pbs.composite()
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Level 3: Temporal Feedback
|
|||
|
|
|
|||
|
|
Feed previous frame back into current frame for recursive effects:
|
|||
|
|
|
|||
|
|
```python
|
|||
|
|
fb = FeedbackBuffer()
|
|||
|
|
for each frame:
|
|||
|
|
canvas = render_current()
|
|||
|
|
canvas = fb.apply(canvas, decay=0.8, blend="screen",
|
|||
|
|
transform="zoom", transform_amt=0.015, hue_shift=0.02)
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Effect Nodes — Uniform Interface
|
|||
|
|
|
|||
|
|
In the v2 protocol, effect nodes are used **inside** scene functions. The scene function itself returns a canvas. Effect nodes produce intermediate `(chars, colors)` that are rendered to canvas via the grid's `.render()` method or `_render_vf()`.
|
|||
|
|
|
|||
|
|
```python
|
|||
|
|
class EffectNode:
|
|||
|
|
def render(self, g, f, t, S) -> (chars, colors)
|
|||
|
|
|
|||
|
|
# Concrete implementations:
|
|||
|
|
class ValueFieldEffect(EffectNode):
|
|||
|
|
"""Wraps a value field function + hue field function + palette."""
|
|||
|
|
def __init__(self, val_fn, hue_fn, pal=PAL_DEFAULT, sat=0.7)
|
|||
|
|
|
|||
|
|
class LambdaEffect(EffectNode):
|
|||
|
|
"""Wrap any (g,f,t,S) -> (ch,co) function."""
|
|||
|
|
def __init__(self, fn)
|
|||
|
|
|
|||
|
|
class ConditionalEffect(EffectNode):
|
|||
|
|
"""Switch effects based on audio features."""
|
|||
|
|
def __init__(self, condition, if_true, if_false=None)
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Value Field Generators (Atomic Building Blocks)
|
|||
|
|
|
|||
|
|
These produce float32 arrays `(rows, cols)` in range [0,1]. They are the raw visual patterns. All have signature `(g, f, t, S, **params) -> float32 array`.
|
|||
|
|
|
|||
|
|
#### Trigonometric Fields (sine/cosine-based)
|
|||
|
|
|
|||
|
|
```python
|
|||
|
|
def vf_sinefield(g, f, t, S, bri=0.5,
|
|||
|
|
freq=(0.13, 0.17, 0.07, 0.09), speed=(0.5, -0.4, -0.3, 0.2)):
|
|||
|
|
"""Layered sine field. General purpose background/texture."""
|
|||
|
|
v1 = np.sin(g.cc*freq[0] + t*speed[0]) * np.sin(g.rr*freq[1] - t*speed[1]) * 0.5 + 0.5
|
|||
|
|
v2 = np.sin(g.cc*freq[2] - t*speed[2] + g.rr*freq[3]) * 0.4 + 0.5
|
|||
|
|
v3 = np.sin(g.dist_n*5 + t*0.2) * 0.3 + 0.4
|
|||
|
|
return np.clip((v1*0.35 + v2*0.35 + v3*0.3) * bri * (0.6 + f.get("rms",0.3)*0.6), 0, 1)
|
|||
|
|
|
|||
|
|
def vf_smooth_noise(g, f, t, S, octaves=3, bri=0.5):
|
|||
|
|
"""Multi-octave sine approximation of Perlin noise."""
|
|||
|
|
val = np.zeros((g.rows, g.cols), dtype=np.float32)
|
|||
|
|
for i in range(octaves):
|
|||
|
|
freq = 0.05 * (2 ** i); amp = 0.5 / (i + 1)
|
|||
|
|
phase = t * (0.3 + i * 0.2)
|
|||
|
|
val = val + np.sin(g.cc*freq + phase) * np.cos(g.rr*freq*0.7 - phase*0.5) * amp
|
|||
|
|
return np.clip(val * 0.5 + 0.5, 0, 1) * bri
|
|||
|
|
|
|||
|
|
def vf_rings(g, f, t, S, n_base=6, spacing_base=4):
|
|||
|
|
"""Concentric rings, bass-driven count and wobble."""
|
|||
|
|
n = int(n_base + f.get("sub_r",0.3)*25 + f.get("bass",0.3)*10)
|
|||
|
|
sp = spacing_base + f.get("bass_r",0.3)*7 + f.get("rms",0.3)*3
|
|||
|
|
val = np.zeros((g.rows, g.cols), dtype=np.float32)
|
|||
|
|
for ri in range(n):
|
|||
|
|
rad = (ri+1)*sp + f.get("bdecay",0)*15
|
|||
|
|
wobble = f.get("mid_r",0.3)*5*np.sin(g.angle*3+t*4)
|
|||
|
|
rd = np.abs(g.dist - rad - wobble)
|
|||
|
|
th = 1 + f.get("sub",0.3)*3
|
|||
|
|
val = np.maximum(val, np.clip((1 - rd/th) * (0.4 + f.get("bass",0.3)*0.8), 0, 1))
|
|||
|
|
return val
|
|||
|
|
|
|||
|
|
def vf_spiral(g, f, t, S, n_arms=3, tightness=2.5):
|
|||
|
|
"""Logarithmic spiral arms."""
|
|||
|
|
val = np.zeros((g.rows, g.cols), dtype=np.float32)
|
|||
|
|
for ai in range(n_arms):
|
|||
|
|
offset = ai * 2*np.pi / n_arms
|
|||
|
|
log_r = np.log(g.dist + 1) * tightness
|
|||
|
|
arm_phase = g.angle + offset - log_r + t * 0.8
|
|||
|
|
arm_val = np.clip(np.cos(arm_phase * n_arms) * 0.6 + 0.2, 0, 1)
|
|||
|
|
arm_val *= (0.4 + f.get("rms",0.3)*0.6) * np.clip(1 - g.dist_n*0.5, 0.2, 1)
|
|||
|
|
val = np.maximum(val, arm_val)
|
|||
|
|
return val
|
|||
|
|
|
|||
|
|
def vf_tunnel(g, f, t, S, speed=3.0, complexity=6):
|
|||
|
|
"""Tunnel depth effect — infinite zoom feeling."""
|
|||
|
|
tunnel_d = 1.0 / (g.dist_n + 0.1)
|
|||
|
|
v1 = np.sin(tunnel_d*2 - t*speed) * 0.45 + 0.55
|
|||
|
|
v2 = np.sin(g.angle*complexity + tunnel_d*1.5 - t*2) * 0.35 + 0.55
|
|||
|
|
return np.clip(v1*0.5 + v2*0.5, 0, 1)
|
|||
|
|
|
|||
|
|
def vf_vortex(g, f, t, S, twist=3.0):
|
|||
|
|
"""Twisting radial pattern — distance modulates angle."""
|
|||
|
|
twisted = g.angle + g.dist_n * twist * np.sin(t * 0.5)
|
|||
|
|
val = np.sin(twisted * 4 - t * 2) * 0.5 + 0.5
|
|||
|
|
return np.clip(val * (0.5 + f.get("bass",0.3)*0.8), 0, 1)
|
|||
|
|
|
|||
|
|
def vf_interference(g, f, t, S, n_waves=6):
|
|||
|
|
"""Overlapping sine waves creating moire patterns."""
|
|||
|
|
drivers = ["mid_r", "himid_r", "bass_r", "lomid_r", "hi_r", "sub_r"]
|
|||
|
|
vals = np.zeros((g.rows, g.cols), dtype=np.float32)
|
|||
|
|
for i in range(min(n_waves, len(drivers))):
|
|||
|
|
angle = i * np.pi / n_waves
|
|||
|
|
freq = 0.06 + i * 0.03; sp = 0.5 + i * 0.3
|
|||
|
|
proj = g.cc * np.cos(angle) + g.rr * np.sin(angle)
|
|||
|
|
vals = vals + np.sin(proj*freq + t*sp) * f.get(drivers[i], 0.3) * 2.5
|
|||
|
|
return np.clip(vals * 0.12 + 0.45, 0.1, 1)
|
|||
|
|
|
|||
|
|
def vf_aurora(g, f, t, S, n_bands=3):
|
|||
|
|
"""Horizontal aurora bands."""
|
|||
|
|
val = np.zeros((g.rows, g.cols), dtype=np.float32)
|
|||
|
|
for i in range(n_bands):
|
|||
|
|
fr = 0.08 + i*0.04; fc = 0.012 + i*0.008
|
|||
|
|
sr = 0.7 + i*0.3; sc = 0.18 + i*0.12
|
|||
|
|
val = val + np.sin(g.rr*fr + t*sr) * np.sin(g.cc*fc + t*sc) * (0.6/n_bands)
|
|||
|
|
return np.clip(val * (f.get("lomid_r",0.3)*3 + 0.2), 0, 0.7)
|
|||
|
|
|
|||
|
|
def vf_ripple(g, f, t, S, sources=None, freq=0.3, damping=0.02):
|
|||
|
|
"""Concentric ripples from point sources."""
|
|||
|
|
if sources is None: sources = [(0.5, 0.5)]
|
|||
|
|
val = np.zeros((g.rows, g.cols), dtype=np.float32)
|
|||
|
|
for ry, rx in sources:
|
|||
|
|
dy = g.rr - g.rows*ry; dx = g.cc - g.cols*rx
|
|||
|
|
d = np.sqrt(dy**2 + dx**2)
|
|||
|
|
val = val + np.sin(d*freq - t*4) * np.exp(-d*damping) * 0.5
|
|||
|
|
return np.clip(val + 0.5, 0, 1)
|
|||
|
|
|
|||
|
|
def vf_plasma(g, f, t, S):
|
|||
|
|
"""Classic plasma: sum of sines at different orientations and speeds."""
|
|||
|
|
v = np.sin(g.cc * 0.03 + t * 0.7) * 0.5
|
|||
|
|
v = v + np.sin(g.rr * 0.04 - t * 0.5) * 0.4
|
|||
|
|
v = v + np.sin((g.cc * 0.02 + g.rr * 0.03) + t * 0.3) * 0.3
|
|||
|
|
v = v + np.sin(g.dist_n * 4 - t * 0.8) * 0.3
|
|||
|
|
return np.clip(v * 0.5 + 0.5, 0, 1)
|
|||
|
|
|
|||
|
|
def vf_diamond(g, f, t, S, freq=0.15):
|
|||
|
|
"""Diamond/checkerboard pattern."""
|
|||
|
|
val = np.abs(np.sin(g.cc * freq + t * 0.5)) * np.abs(np.sin(g.rr * freq * 1.2 - t * 0.3))
|
|||
|
|
return np.clip(val * (0.6 + f.get("rms",0.3)*0.8), 0, 1)
|
|||
|
|
|
|||
|
|
def vf_noise_static(g, f, t, S, density=0.4):
|
|||
|
|
"""Random noise — different each frame. Non-deterministic."""
|
|||
|
|
return np.random.random((g.rows, g.cols)).astype(np.float32) * density * (0.5 + f.get("rms",0.3)*0.5)
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
#### Noise-Based Fields (organic, non-periodic)
|
|||
|
|
|
|||
|
|
These produce qualitatively different textures from sine-based fields — organic, non-repeating, without visible axis alignment. They're the foundation of high-end generative art.
|
|||
|
|
|
|||
|
|
```python
|
|||
|
|
def _hash2d(ix, iy):
|
|||
|
|
"""Integer-coordinate hash for gradient noise. Returns float32 in [0,1]."""
|
|||
|
|
# Good-quality hash via large prime mixing
|
|||
|
|
n = ix * 374761393 + iy * 668265263
|
|||
|
|
n = (n ^ (n >> 13)) * 1274126177
|
|||
|
|
return ((n ^ (n >> 16)) & 0x7fffffff).astype(np.float32) / 0x7fffffff
|
|||
|
|
|
|||
|
|
def _smoothstep(t):
|
|||
|
|
"""Hermite smoothstep: 3t^2 - 2t^3. Smooth interpolation in [0,1]."""
|
|||
|
|
t = np.clip(t, 0, 1)
|
|||
|
|
return t * t * (3 - 2 * t)
|
|||
|
|
|
|||
|
|
def _smootherstep(t):
|
|||
|
|
"""Perlin's improved smoothstep: 6t^5 - 15t^4 + 10t^3. C2-continuous."""
|
|||
|
|
t = np.clip(t, 0, 1)
|
|||
|
|
return t * t * t * (t * (t * 6 - 15) + 10)
|
|||
|
|
|
|||
|
|
def _value_noise_2d(x, y):
|
|||
|
|
"""2D value noise at arbitrary float coordinates. Returns float32 in [0,1].
|
|||
|
|
x, y: float32 arrays of same shape."""
|
|||
|
|
ix = np.floor(x).astype(np.int64)
|
|||
|
|
iy = np.floor(y).astype(np.int64)
|
|||
|
|
fx = _smootherstep(x - ix)
|
|||
|
|
fy = _smootherstep(y - iy)
|
|||
|
|
# 4-corner hashes
|
|||
|
|
n00 = _hash2d(ix, iy)
|
|||
|
|
n10 = _hash2d(ix + 1, iy)
|
|||
|
|
n01 = _hash2d(ix, iy + 1)
|
|||
|
|
n11 = _hash2d(ix + 1, iy + 1)
|
|||
|
|
# Bilinear interpolation
|
|||
|
|
nx0 = n00 * (1 - fx) + n10 * fx
|
|||
|
|
nx1 = n01 * (1 - fx) + n11 * fx
|
|||
|
|
return nx0 * (1 - fy) + nx1 * fy
|
|||
|
|
|
|||
|
|
def vf_noise(g, f, t, S, freq=0.08, speed=0.3, bri=0.7):
|
|||
|
|
"""Value noise. Smooth, organic, no axis alignment artifacts.
|
|||
|
|
freq: spatial frequency (higher = finer detail).
|
|||
|
|
speed: temporal scroll rate."""
|
|||
|
|
x = g.cc * freq + t * speed
|
|||
|
|
y = g.rr * freq * 0.8 - t * speed * 0.4
|
|||
|
|
return np.clip(_value_noise_2d(x, y) * bri, 0, 1)
|
|||
|
|
|
|||
|
|
def vf_fbm(g, f, t, S, octaves=5, freq=0.06, lacunarity=2.0, gain=0.5,
|
|||
|
|
speed=0.2, bri=0.8):
|
|||
|
|
"""Fractal Brownian Motion — octaved noise with lacunarity/gain control.
|
|||
|
|
The standard building block for clouds, terrain, smoke, organic textures.
|
|||
|
|
|
|||
|
|
octaves: number of noise layers (more = finer detail, more cost)
|
|||
|
|
freq: base spatial frequency
|
|||
|
|
lacunarity: frequency multiplier per octave (2.0 = standard)
|
|||
|
|
gain: amplitude multiplier per octave (0.5 = standard, <0.5 = smoother)
|
|||
|
|
speed: temporal evolution rate
|
|||
|
|
"""
|
|||
|
|
val = np.zeros((g.rows, g.cols), dtype=np.float32)
|
|||
|
|
amplitude = 1.0
|
|||
|
|
f_x = freq
|
|||
|
|
f_y = freq * 0.85 # slight anisotropy avoids grid artifacts
|
|||
|
|
for i in range(octaves):
|
|||
|
|
phase = t * speed * (1 + i * 0.3)
|
|||
|
|
x = g.cc * f_x + phase + i * 17.3 # offset per octave
|
|||
|
|
y = g.rr * f_y - phase * 0.6 + i * 31.7
|
|||
|
|
val = val + _value_noise_2d(x, y) * amplitude
|
|||
|
|
amplitude *= gain
|
|||
|
|
f_x *= lacunarity
|
|||
|
|
f_y *= lacunarity
|
|||
|
|
# Normalize to [0,1]
|
|||
|
|
max_amp = (1 - gain ** octaves) / (1 - gain) if gain != 1 else octaves
|
|||
|
|
return np.clip(val / max_amp * bri * (0.6 + f.get("rms", 0.3) * 0.6), 0, 1)
|
|||
|
|
|
|||
|
|
def vf_domain_warp(g, f, t, S, base_fn=None, warp_fn=None,
|
|||
|
|
warp_strength=15.0, freq=0.06, speed=0.2):
|
|||
|
|
"""Domain warping — feed one noise field's output as coordinate offsets
|
|||
|
|
into another noise field. Produces flowing, melting organic distortion.
|
|||
|
|
Signature technique of high-end generative art (Inigo Quilez).
|
|||
|
|
|
|||
|
|
base_fn: value field to distort (default: fbm)
|
|||
|
|
warp_fn: value field for displacement (default: noise at different freq)
|
|||
|
|
warp_strength: how many grid cells to displace (higher = more warped)
|
|||
|
|
"""
|
|||
|
|
# Warp field: displacement in x and y
|
|||
|
|
wx = _value_noise_2d(g.cc * freq * 1.3 + t * speed, g.rr * freq + 7.1)
|
|||
|
|
wy = _value_noise_2d(g.cc * freq + t * speed * 0.7 + 3.2, g.rr * freq * 1.1 - 11.8)
|
|||
|
|
# Center warp around 0 (noise returns [0,1], shift to [-0.5, 0.5])
|
|||
|
|
wx = (wx - 0.5) * warp_strength * (0.5 + f.get("rms", 0.3) * 1.0)
|
|||
|
|
wy = (wy - 0.5) * warp_strength * (0.5 + f.get("bass", 0.3) * 0.8)
|
|||
|
|
# Sample base field at warped coordinates
|
|||
|
|
warped_cc = g.cc + wx
|
|||
|
|
warped_rr = g.rr + wy
|
|||
|
|
if base_fn is not None:
|
|||
|
|
# Create a temporary grid-like object with warped coords
|
|||
|
|
# Simplification: evaluate base_fn with modified coordinates
|
|||
|
|
val = _value_noise_2d(warped_cc * freq * 0.8 + t * speed * 0.5,
|
|||
|
|
warped_rr * freq * 0.7 - t * speed * 0.3)
|
|||
|
|
else:
|
|||
|
|
# Default: fbm at warped coordinates
|
|||
|
|
val = np.zeros((g.rows, g.cols), dtype=np.float32)
|
|||
|
|
amp = 1.0
|
|||
|
|
fx, fy = freq * 0.8, freq * 0.7
|
|||
|
|
for i in range(4):
|
|||
|
|
val = val + _value_noise_2d(warped_cc * fx + t * speed * 0.5 + i * 13.7,
|
|||
|
|
warped_rr * fy - t * speed * 0.3 + i * 27.3) * amp
|
|||
|
|
amp *= 0.5; fx *= 2.0; fy *= 2.0
|
|||
|
|
val = val / 1.875 # normalize 4-octave sum
|
|||
|
|
return np.clip(val * 0.8, 0, 1)
|
|||
|
|
|
|||
|
|
def vf_voronoi(g, f, t, S, n_cells=20, speed=0.3, edge_width=1.5,
|
|||
|
|
mode="distance", seed=42):
|
|||
|
|
"""Voronoi diagram as value field. Proper implementation with
|
|||
|
|
nearest/second-nearest distance for cell interiors and edges.
|
|||
|
|
|
|||
|
|
mode: "distance" (bright at center, dark at edges),
|
|||
|
|
"edge" (bright at cell boundaries),
|
|||
|
|
"cell_id" (flat color per cell — use with discrete palette)
|
|||
|
|
edge_width: thickness of edge highlight (for "edge" mode)
|
|||
|
|
"""
|
|||
|
|
rng = np.random.RandomState(seed)
|
|||
|
|
# Animated cell centers
|
|||
|
|
cx = rng.rand(n_cells).astype(np.float32) * g.cols
|
|||
|
|
cy = rng.rand(n_cells).astype(np.float32) * g.rows
|
|||
|
|
vx = (rng.rand(n_cells).astype(np.float32) - 0.5) * speed * 10
|
|||
|
|
vy = (rng.rand(n_cells).astype(np.float32) - 0.5) * speed * 10
|
|||
|
|
cx_t = (cx + vx * np.sin(t * 0.5 + np.arange(n_cells) * 0.8)) % g.cols
|
|||
|
|
cy_t = (cy + vy * np.cos(t * 0.4 + np.arange(n_cells) * 1.1)) % g.rows
|
|||
|
|
|
|||
|
|
# Compute nearest and second-nearest distance
|
|||
|
|
d1 = np.full((g.rows, g.cols), 1e9, dtype=np.float32)
|
|||
|
|
d2 = np.full((g.rows, g.cols), 1e9, dtype=np.float32)
|
|||
|
|
id1 = np.zeros((g.rows, g.cols), dtype=np.int32)
|
|||
|
|
for i in range(n_cells):
|
|||
|
|
d = np.sqrt((g.cc - cx_t[i]) ** 2 + (g.rr - cy_t[i]) ** 2)
|
|||
|
|
mask = d < d1
|
|||
|
|
d2 = np.where(mask, d1, np.minimum(d2, d))
|
|||
|
|
id1 = np.where(mask, i, id1)
|
|||
|
|
d1 = np.minimum(d1, d)
|
|||
|
|
|
|||
|
|
if mode == "edge":
|
|||
|
|
# Edges: where d2 - d1 is small
|
|||
|
|
edge_val = np.clip(1.0 - (d2 - d1) / edge_width, 0, 1)
|
|||
|
|
return edge_val * (0.5 + f.get("rms", 0.3) * 0.8)
|
|||
|
|
elif mode == "cell_id":
|
|||
|
|
# Flat per-cell value
|
|||
|
|
return (id1.astype(np.float32) / n_cells) % 1.0
|
|||
|
|
else:
|
|||
|
|
# Distance: bright near center, dark at edges
|
|||
|
|
max_d = g.cols * 0.15
|
|||
|
|
return np.clip(1.0 - d1 / max_d, 0, 1) * (0.5 + f.get("rms", 0.3) * 0.7)
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
#### Simulation-Based Fields (emergent, evolving)
|
|||
|
|
|
|||
|
|
These use persistent state `S` to evolve patterns frame-by-frame. They produce complexity that can't be achieved with stateless math.
|
|||
|
|
|
|||
|
|
```python
|
|||
|
|
def vf_reaction_diffusion(g, f, t, S, feed=0.055, kill=0.062,
|
|||
|
|
da=1.0, db=0.5, dt=1.0, steps_per_frame=8,
|
|||
|
|
init_mode="spots"):
|
|||
|
|
"""Gray-Scott reaction-diffusion model. Produces coral, leopard spots,
|
|||
|
|
mitosis, worm-like, and labyrinthine patterns depending on feed/kill.
|
|||
|
|
|
|||
|
|
The two chemicals A and B interact:
|
|||
|
|
A + 2B → 3B (autocatalytic)
|
|||
|
|
B → P (decay)
|
|||
|
|
feed: rate A is replenished, kill: rate B decays
|
|||
|
|
Different feed/kill ratios produce radically different patterns.
|
|||
|
|
|
|||
|
|
Presets (feed, kill):
|
|||
|
|
Spots/dots: (0.055, 0.062)
|
|||
|
|
Worms/stripes: (0.046, 0.063)
|
|||
|
|
Coral/branching: (0.037, 0.060)
|
|||
|
|
Mitosis/splitting: (0.028, 0.062)
|
|||
|
|
Labyrinth/maze: (0.029, 0.057)
|
|||
|
|
Holes/negative: (0.039, 0.058)
|
|||
|
|
Chaos/unstable: (0.026, 0.051)
|
|||
|
|
|
|||
|
|
steps_per_frame: simulation steps per video frame (more = faster evolution)
|
|||
|
|
"""
|
|||
|
|
key = "rd_" + str(id(g)) # unique per grid
|
|||
|
|
if key + "_a" not in S:
|
|||
|
|
# Initialize chemical fields
|
|||
|
|
A = np.ones((g.rows, g.cols), dtype=np.float32)
|
|||
|
|
B = np.zeros((g.rows, g.cols), dtype=np.float32)
|
|||
|
|
if init_mode == "spots":
|
|||
|
|
# Random seed spots
|
|||
|
|
rng = np.random.RandomState(42)
|
|||
|
|
for _ in range(max(3, g.rows * g.cols // 200)):
|
|||
|
|
r, c = rng.randint(2, g.rows - 2), rng.randint(2, g.cols - 2)
|
|||
|
|
B[r - 1:r + 2, c - 1:c + 2] = 1.0
|
|||
|
|
elif init_mode == "center":
|
|||
|
|
cr, cc = g.rows // 2, g.cols // 2
|
|||
|
|
B[cr - 3:cr + 3, cc - 3:cc + 3] = 1.0
|
|||
|
|
elif init_mode == "ring":
|
|||
|
|
mask = (g.dist_n > 0.2) & (g.dist_n < 0.3)
|
|||
|
|
B[mask] = 1.0
|
|||
|
|
S[key + "_a"] = A
|
|||
|
|
S[key + "_b"] = B
|
|||
|
|
|
|||
|
|
A = S[key + "_a"]
|
|||
|
|
B = S[key + "_b"]
|
|||
|
|
|
|||
|
|
# Audio modulation: feed/kill shift subtly with audio
|
|||
|
|
f_mod = feed + f.get("bass", 0.3) * 0.003
|
|||
|
|
k_mod = kill + f.get("hi_r", 0.3) * 0.002
|
|||
|
|
|
|||
|
|
for _ in range(steps_per_frame):
|
|||
|
|
# Laplacian via 3x3 convolution kernel
|
|||
|
|
# [0.05, 0.2, 0.05]
|
|||
|
|
# [0.2, -1.0, 0.2]
|
|||
|
|
# [0.05, 0.2, 0.05]
|
|||
|
|
pA = np.pad(A, 1, mode="wrap")
|
|||
|
|
pB = np.pad(B, 1, mode="wrap")
|
|||
|
|
lapA = (pA[:-2, 1:-1] + pA[2:, 1:-1] + pA[1:-1, :-2] + pA[1:-1, 2:]) * 0.2 \
|
|||
|
|
+ (pA[:-2, :-2] + pA[:-2, 2:] + pA[2:, :-2] + pA[2:, 2:]) * 0.05 \
|
|||
|
|
- A * 1.0
|
|||
|
|
lapB = (pB[:-2, 1:-1] + pB[2:, 1:-1] + pB[1:-1, :-2] + pB[1:-1, 2:]) * 0.2 \
|
|||
|
|
+ (pB[:-2, :-2] + pB[:-2, 2:] + pB[2:, :-2] + pB[2:, 2:]) * 0.05 \
|
|||
|
|
- B * 1.0
|
|||
|
|
ABB = A * B * B
|
|||
|
|
A = A + (da * lapA - ABB + f_mod * (1 - A)) * dt
|
|||
|
|
B = B + (db * lapB + ABB - (f_mod + k_mod) * B) * dt
|
|||
|
|
A = np.clip(A, 0, 1)
|
|||
|
|
B = np.clip(B, 0, 1)
|
|||
|
|
|
|||
|
|
S[key + "_a"] = A
|
|||
|
|
S[key + "_b"] = B
|
|||
|
|
# Output B chemical as value (the visible pattern)
|
|||
|
|
return np.clip(B * 2.0, 0, 1)
|
|||
|
|
|
|||
|
|
def vf_game_of_life(g, f, t, S, rule="life", birth=None, survive=None,
|
|||
|
|
steps_per_frame=1, density=0.3, fade=0.92, seed=42):
|
|||
|
|
"""Cellular automaton as value field with analog fade trails.
|
|||
|
|
Grid cells are born/die by neighbor count rules. Dead cells fade
|
|||
|
|
gradually instead of snapping to black, producing ghost trails.
|
|||
|
|
|
|||
|
|
rule presets:
|
|||
|
|
"life": B3/S23 (Conway's Game of Life)
|
|||
|
|
"coral": B3/S45678 (slow crystalline growth)
|
|||
|
|
"maze": B3/S12345 (fills to labyrinth)
|
|||
|
|
"anneal": B4678/S35678 (smooth blobs)
|
|||
|
|
"day_night": B3678/S34678 (balanced growth/decay)
|
|||
|
|
Or specify birth/survive directly as sets: birth={3}, survive={2,3}
|
|||
|
|
|
|||
|
|
fade: how fast dead cells dim (0.9 = slow trails, 0.5 = fast)
|
|||
|
|
"""
|
|||
|
|
presets = {
|
|||
|
|
"life": ({3}, {2, 3}),
|
|||
|
|
"coral": ({3}, {4, 5, 6, 7, 8}),
|
|||
|
|
"maze": ({3}, {1, 2, 3, 4, 5}),
|
|||
|
|
"anneal": ({4, 6, 7, 8}, {3, 5, 6, 7, 8}),
|
|||
|
|
"day_night": ({3, 6, 7, 8}, {3, 4, 6, 7, 8}),
|
|||
|
|
}
|
|||
|
|
if birth is None or survive is None:
|
|||
|
|
birth, survive = presets.get(rule, presets["life"])
|
|||
|
|
|
|||
|
|
key = "gol_" + str(id(g))
|
|||
|
|
if key + "_grid" not in S:
|
|||
|
|
rng = np.random.RandomState(seed)
|
|||
|
|
S[key + "_grid"] = (rng.random((g.rows, g.cols)) < density).astype(np.float32)
|
|||
|
|
S[key + "_display"] = S[key + "_grid"].copy()
|
|||
|
|
|
|||
|
|
grid = S[key + "_grid"]
|
|||
|
|
display = S[key + "_display"]
|
|||
|
|
|
|||
|
|
# Beat can inject random noise
|
|||
|
|
if f.get("beat", 0) > 0.5:
|
|||
|
|
inject = np.random.random((g.rows, g.cols)) < 0.02
|
|||
|
|
grid = np.clip(grid + inject.astype(np.float32), 0, 1)
|
|||
|
|
|
|||
|
|
for _ in range(steps_per_frame):
|
|||
|
|
# Count neighbors (toroidal wrap)
|
|||
|
|
padded = np.pad(grid > 0.5, 1, mode="wrap").astype(np.int8)
|
|||
|
|
neighbors = (padded[:-2, :-2] + padded[:-2, 1:-1] + padded[:-2, 2:] +
|
|||
|
|
padded[1:-1, :-2] + padded[1:-1, 2:] +
|
|||
|
|
padded[2:, :-2] + padded[2:, 1:-1] + padded[2:, 2:])
|
|||
|
|
alive = grid > 0.5
|
|||
|
|
new_alive = np.zeros_like(grid, dtype=bool)
|
|||
|
|
for b in birth:
|
|||
|
|
new_alive |= (~alive) & (neighbors == b)
|
|||
|
|
for s in survive:
|
|||
|
|
new_alive |= alive & (neighbors == s)
|
|||
|
|
grid = new_alive.astype(np.float32)
|
|||
|
|
|
|||
|
|
# Analog display: alive cells = 1.0, dead cells fade
|
|||
|
|
display = np.where(grid > 0.5, 1.0, display * fade)
|
|||
|
|
S[key + "_grid"] = grid
|
|||
|
|
S[key + "_display"] = display
|
|||
|
|
return np.clip(display, 0, 1)
|
|||
|
|
|
|||
|
|
def vf_strange_attractor(g, f, t, S, attractor="clifford",
|
|||
|
|
n_points=50000, warmup=500, bri=0.8, seed=42,
|
|||
|
|
params=None):
|
|||
|
|
"""Strange attractor projected to 2D density field.
|
|||
|
|
Iterates N points through attractor equations, bins to grid,
|
|||
|
|
produces a density map. Elegant, non-repeating curves.
|
|||
|
|
|
|||
|
|
attractor presets:
|
|||
|
|
"clifford": sin(a*y) + c*cos(a*x), sin(b*x) + d*cos(b*y)
|
|||
|
|
"de_jong": sin(a*y) - cos(b*x), sin(c*x) - cos(d*y)
|
|||
|
|
"bedhead": sin(x*y/b) + cos(a*x - y), x*sin(a*y) + cos(b*x - y)
|
|||
|
|
|
|||
|
|
params: (a, b, c, d) floats — each attractor has different sweet spots.
|
|||
|
|
If None, uses time-varying defaults for animation.
|
|||
|
|
"""
|
|||
|
|
key = "attr_" + attractor
|
|||
|
|
if params is None:
|
|||
|
|
# Time-varying parameters for slow morphing
|
|||
|
|
a = -1.4 + np.sin(t * 0.05) * 0.3
|
|||
|
|
b = 1.6 + np.cos(t * 0.07) * 0.2
|
|||
|
|
c = 1.0 + np.sin(t * 0.03 + 1) * 0.3
|
|||
|
|
d = 0.7 + np.cos(t * 0.04 + 2) * 0.2
|
|||
|
|
else:
|
|||
|
|
a, b, c, d = params
|
|||
|
|
|
|||
|
|
# Iterate attractor
|
|||
|
|
rng = np.random.RandomState(seed)
|
|||
|
|
x = rng.uniform(-0.1, 0.1, n_points).astype(np.float64)
|
|||
|
|
y = rng.uniform(-0.1, 0.1, n_points).astype(np.float64)
|
|||
|
|
|
|||
|
|
# Warmup iterations (reach the attractor)
|
|||
|
|
for _ in range(warmup):
|
|||
|
|
if attractor == "clifford":
|
|||
|
|
xn = np.sin(a * y) + c * np.cos(a * x)
|
|||
|
|
yn = np.sin(b * x) + d * np.cos(b * y)
|
|||
|
|
elif attractor == "de_jong":
|
|||
|
|
xn = np.sin(a * y) - np.cos(b * x)
|
|||
|
|
yn = np.sin(c * x) - np.cos(d * y)
|
|||
|
|
elif attractor == "bedhead":
|
|||
|
|
xn = np.sin(x * y / b) + np.cos(a * x - y)
|
|||
|
|
yn = x * np.sin(a * y) + np.cos(b * x - y)
|
|||
|
|
else:
|
|||
|
|
xn = np.sin(a * y) + c * np.cos(a * x)
|
|||
|
|
yn = np.sin(b * x) + d * np.cos(b * y)
|
|||
|
|
x, y = xn, yn
|
|||
|
|
|
|||
|
|
# Bin to grid
|
|||
|
|
# Find bounds
|
|||
|
|
margin = 0.1
|
|||
|
|
x_min, x_max = x.min() - margin, x.max() + margin
|
|||
|
|
y_min, y_max = y.min() - margin, y.max() + margin
|
|||
|
|
|
|||
|
|
# Map to grid coordinates
|
|||
|
|
gx = ((x - x_min) / (x_max - x_min) * (g.cols - 1)).astype(np.int32)
|
|||
|
|
gy = ((y - y_min) / (y_max - y_min) * (g.rows - 1)).astype(np.int32)
|
|||
|
|
valid = (gx >= 0) & (gx < g.cols) & (gy >= 0) & (gy < g.rows)
|
|||
|
|
gx, gy = gx[valid], gy[valid]
|
|||
|
|
|
|||
|
|
# Accumulate density
|
|||
|
|
density = np.zeros((g.rows, g.cols), dtype=np.float32)
|
|||
|
|
np.add.at(density, (gy, gx), 1.0)
|
|||
|
|
|
|||
|
|
# Log-scale density for visibility (most bins have few hits)
|
|||
|
|
density = np.log1p(density)
|
|||
|
|
mx = density.max()
|
|||
|
|
if mx > 0:
|
|||
|
|
density = density / mx
|
|||
|
|
return np.clip(density * bri * (0.5 + f.get("rms", 0.3) * 0.8), 0, 1)
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
#### SDF-Based Fields (geometric precision)
|
|||
|
|
|
|||
|
|
Signed Distance Fields produce mathematically precise shapes. Unlike sine fields (organic, blurry), SDFs give hard geometric boundaries with controllable edge softness. Combined with domain warping, they create "melting geometry" effects.
|
|||
|
|
|
|||
|
|
All SDF primitives return a **signed distance** (negative inside, positive outside). Convert to a value field with `sdf_render()`.
|
|||
|
|
|
|||
|
|
```python
|
|||
|
|
def sdf_render(dist, edge_width=1.5, invert=False):
|
|||
|
|
"""Convert signed distance to value field [0,1].
|
|||
|
|
edge_width: controls anti-aliasing / softness of the boundary.
|
|||
|
|
invert: True = bright inside shape, False = bright outside."""
|
|||
|
|
val = 1.0 - np.clip(dist / edge_width, 0, 1) if not invert else np.clip(dist / edge_width, 0, 1)
|
|||
|
|
return np.clip(val, 0, 1)
|
|||
|
|
|
|||
|
|
def sdf_glow(dist, falloff=0.05):
|
|||
|
|
"""Render SDF as glowing outline — bright at boundary, fading both directions."""
|
|||
|
|
return np.clip(np.exp(-np.abs(dist) * falloff), 0, 1)
|
|||
|
|
|
|||
|
|
# --- Primitives ---
|
|||
|
|
|
|||
|
|
def sdf_circle(g, cx_frac=0.5, cy_frac=0.5, radius=0.3):
|
|||
|
|
"""Circle SDF. cx/cy/radius in normalized [0,1] coordinates."""
|
|||
|
|
dx = (g.cc / g.cols - cx_frac) * (g.cols / g.rows) # aspect correction
|
|||
|
|
dy = g.rr / g.rows - cy_frac
|
|||
|
|
return np.sqrt(dx**2 + dy**2) - radius
|
|||
|
|
|
|||
|
|
def sdf_box(g, cx_frac=0.5, cy_frac=0.5, w=0.3, h=0.2, round_r=0.0):
|
|||
|
|
"""Rounded rectangle SDF."""
|
|||
|
|
dx = np.abs(g.cc / g.cols - cx_frac) * (g.cols / g.rows) - w + round_r
|
|||
|
|
dy = np.abs(g.rr / g.rows - cy_frac) - h + round_r
|
|||
|
|
outside = np.sqrt(np.maximum(dx, 0)**2 + np.maximum(dy, 0)**2)
|
|||
|
|
inside = np.minimum(np.maximum(dx, dy), 0)
|
|||
|
|
return outside + inside - round_r
|
|||
|
|
|
|||
|
|
def sdf_ring(g, cx_frac=0.5, cy_frac=0.5, radius=0.3, thickness=0.03):
|
|||
|
|
"""Ring (annulus) SDF."""
|
|||
|
|
d = sdf_circle(g, cx_frac, cy_frac, radius)
|
|||
|
|
return np.abs(d) - thickness
|
|||
|
|
|
|||
|
|
def sdf_line(g, x0=0.2, y0=0.5, x1=0.8, y1=0.5, thickness=0.01):
|
|||
|
|
"""Line segment SDF between two points (normalized coords)."""
|
|||
|
|
ax = g.cc / g.cols * (g.cols / g.rows) - x0 * (g.cols / g.rows)
|
|||
|
|
ay = g.rr / g.rows - y0
|
|||
|
|
bx = (x1 - x0) * (g.cols / g.rows)
|
|||
|
|
by = y1 - y0
|
|||
|
|
h = np.clip((ax * bx + ay * by) / (bx * bx + by * by + 1e-10), 0, 1)
|
|||
|
|
dx = ax - bx * h
|
|||
|
|
dy = ay - by * h
|
|||
|
|
return np.sqrt(dx**2 + dy**2) - thickness
|
|||
|
|
|
|||
|
|
def sdf_triangle(g, cx=0.5, cy=0.5, size=0.25):
|
|||
|
|
"""Equilateral triangle SDF centered at (cx, cy)."""
|
|||
|
|
px = (g.cc / g.cols - cx) * (g.cols / g.rows) / size
|
|||
|
|
py = (g.rr / g.rows - cy) / size
|
|||
|
|
# Equilateral triangle math
|
|||
|
|
k = np.sqrt(3.0)
|
|||
|
|
px = np.abs(px) - 1.0
|
|||
|
|
py = py + 1.0 / k
|
|||
|
|
cond = px + k * py > 0
|
|||
|
|
px2 = np.where(cond, (px - k * py) / 2.0, px)
|
|||
|
|
py2 = np.where(cond, (-k * px - py) / 2.0, py)
|
|||
|
|
px2 = np.clip(px2, -2.0, 0.0)
|
|||
|
|
return -np.sqrt(px2**2 + py2**2) * np.sign(py2) * size
|
|||
|
|
|
|||
|
|
def sdf_star(g, cx=0.5, cy=0.5, n_points=5, outer_r=0.25, inner_r=0.12):
|
|||
|
|
"""Star polygon SDF — n-pointed star."""
|
|||
|
|
px = (g.cc / g.cols - cx) * (g.cols / g.rows)
|
|||
|
|
py = g.rr / g.rows - cy
|
|||
|
|
angle = np.arctan2(py, px)
|
|||
|
|
dist = np.sqrt(px**2 + py**2)
|
|||
|
|
# Modular angle for star symmetry
|
|||
|
|
wedge = 2 * np.pi / n_points
|
|||
|
|
a = np.abs((angle % wedge) - wedge / 2)
|
|||
|
|
# Interpolate radius between inner and outer
|
|||
|
|
r_at_angle = inner_r + (outer_r - inner_r) * np.clip(np.cos(a * n_points) * 0.5 + 0.5, 0, 1)
|
|||
|
|
return dist - r_at_angle
|
|||
|
|
|
|||
|
|
def sdf_heart(g, cx=0.5, cy=0.45, size=0.25):
|
|||
|
|
"""Heart shape SDF."""
|
|||
|
|
px = (g.cc / g.cols - cx) * (g.cols / g.rows) / size
|
|||
|
|
py = -(g.rr / g.rows - cy) / size + 0.3 # flip y, offset
|
|||
|
|
px = np.abs(px)
|
|||
|
|
cond = (px + py) > 1.0
|
|||
|
|
d1 = np.sqrt((px - 0.25)**2 + (py - 0.75)**2) - np.sqrt(2.0) / 4.0
|
|||
|
|
d2 = np.sqrt((px + py - 1.0)**2) / np.sqrt(2.0)
|
|||
|
|
return np.where(cond, d1, d2) * size
|
|||
|
|
|
|||
|
|
# --- Combinators ---
|
|||
|
|
|
|||
|
|
def sdf_union(d1, d2):
|
|||
|
|
"""Boolean union — shape is wherever either SDF is inside."""
|
|||
|
|
return np.minimum(d1, d2)
|
|||
|
|
|
|||
|
|
def sdf_intersect(d1, d2):
|
|||
|
|
"""Boolean intersection — shape is where both SDFs overlap."""
|
|||
|
|
return np.maximum(d1, d2)
|
|||
|
|
|
|||
|
|
def sdf_subtract(d1, d2):
|
|||
|
|
"""Boolean subtraction — d1 minus d2."""
|
|||
|
|
return np.maximum(d1, -d2)
|
|||
|
|
|
|||
|
|
def sdf_smooth_union(d1, d2, k=0.1):
|
|||
|
|
"""Smooth minimum (polynomial) — blends shapes with rounded join.
|
|||
|
|
k: smoothing radius. Higher = more rounding."""
|
|||
|
|
h = np.clip(0.5 + 0.5 * (d2 - d1) / k, 0, 1)
|
|||
|
|
return d2 * (1 - h) + d1 * h - k * h * (1 - h)
|
|||
|
|
|
|||
|
|
def sdf_smooth_subtract(d1, d2, k=0.1):
|
|||
|
|
"""Smooth subtraction — d1 minus d2 with rounded edge."""
|
|||
|
|
return sdf_smooth_union(d1, -d2, k)
|
|||
|
|
|
|||
|
|
def sdf_repeat(g, sdf_fn, spacing_x=0.25, spacing_y=0.25, **sdf_kwargs):
|
|||
|
|
"""Tile an SDF primitive infinitely. spacing in normalized coords."""
|
|||
|
|
# Modular coordinates
|
|||
|
|
mod_cc = (g.cc / g.cols) % spacing_x - spacing_x / 2
|
|||
|
|
mod_rr = (g.rr / g.rows) % spacing_y - spacing_y / 2
|
|||
|
|
# Create modified grid-like arrays for the SDF
|
|||
|
|
# This is a simplified approach — build a temporary namespace
|
|||
|
|
class ModGrid:
|
|||
|
|
pass
|
|||
|
|
mg = ModGrid()
|
|||
|
|
mg.cc = mod_cc * g.cols; mg.rr = mod_rr * g.rows
|
|||
|
|
mg.cols = g.cols; mg.rows = g.rows
|
|||
|
|
return sdf_fn(mg, **sdf_kwargs)
|
|||
|
|
|
|||
|
|
# --- SDF as Value Field ---
|
|||
|
|
|
|||
|
|
def vf_sdf(g, f, t, S, sdf_fn=sdf_circle, edge_width=1.5, glow=False,
|
|||
|
|
glow_falloff=0.03, animate=True, **sdf_kwargs):
|
|||
|
|
"""Wrap any SDF primitive as a standard vf_* value field.
|
|||
|
|
If animate=True, applies slow rotation and breathing to the shape."""
|
|||
|
|
if animate:
|
|||
|
|
sdf_kwargs.setdefault("cx_frac", 0.5)
|
|||
|
|
sdf_kwargs.setdefault("cy_frac", 0.5)
|
|||
|
|
d = sdf_fn(g, **sdf_kwargs)
|
|||
|
|
if glow:
|
|||
|
|
return sdf_glow(d, glow_falloff) * (0.5 + f.get("rms", 0.3) * 0.8)
|
|||
|
|
return sdf_render(d, edge_width) * (0.5 + f.get("rms", 0.3) * 0.8)
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Hue Field Generators (Color Mapping)
|
|||
|
|
|
|||
|
|
These produce float32 hue arrays [0,1]. Independently combinable with any value field. Each is a factory returning a closure with signature `(g, f, t, S) -> float32 array`. Can also be a plain float for fixed hue.
|
|||
|
|
|
|||
|
|
```python
|
|||
|
|
def hf_fixed(hue):
|
|||
|
|
"""Single hue everywhere."""
|
|||
|
|
def fn(g, f, t, S):
|
|||
|
|
return np.full((g.rows, g.cols), hue, dtype=np.float32)
|
|||
|
|
return fn
|
|||
|
|
|
|||
|
|
def hf_angle(offset=0.0):
|
|||
|
|
"""Hue mapped to angle from center — rainbow wheel."""
|
|||
|
|
def fn(g, f, t, S):
|
|||
|
|
return (g.angle / (2 * np.pi) + offset + t * 0.05) % 1.0
|
|||
|
|
return fn
|
|||
|
|
|
|||
|
|
def hf_distance(base=0.5, scale=0.02):
|
|||
|
|
"""Hue mapped to distance from center."""
|
|||
|
|
def fn(g, f, t, S):
|
|||
|
|
return (base + g.dist * scale + t * 0.03) % 1.0
|
|||
|
|
return fn
|
|||
|
|
|
|||
|
|
def hf_time_cycle(speed=0.1):
|
|||
|
|
"""Hue cycles uniformly over time."""
|
|||
|
|
def fn(g, f, t, S):
|
|||
|
|
return np.full((g.rows, g.cols), (t * speed) % 1.0, dtype=np.float32)
|
|||
|
|
return fn
|
|||
|
|
|
|||
|
|
def hf_audio_cent():
|
|||
|
|
"""Hue follows spectral centroid — timbral color shifting."""
|
|||
|
|
def fn(g, f, t, S):
|
|||
|
|
return np.full((g.rows, g.cols), f.get("cent", 0.5) * 0.3, dtype=np.float32)
|
|||
|
|
return fn
|
|||
|
|
|
|||
|
|
def hf_gradient_h(start=0.0, end=1.0):
|
|||
|
|
"""Left-to-right hue gradient."""
|
|||
|
|
def fn(g, f, t, S):
|
|||
|
|
h = np.broadcast_to(
|
|||
|
|
start + (g.cc / g.cols) * (end - start),
|
|||
|
|
(g.rows, g.cols)
|
|||
|
|
).copy() # .copy() is CRITICAL — see troubleshooting.md
|
|||
|
|
return h % 1.0
|
|||
|
|
return fn
|
|||
|
|
|
|||
|
|
def hf_gradient_v(start=0.0, end=1.0):
|
|||
|
|
"""Top-to-bottom hue gradient."""
|
|||
|
|
def fn(g, f, t, S):
|
|||
|
|
h = np.broadcast_to(
|
|||
|
|
start + (g.rr / g.rows) * (end - start),
|
|||
|
|
(g.rows, g.cols)
|
|||
|
|
).copy()
|
|||
|
|
return h % 1.0
|
|||
|
|
return fn
|
|||
|
|
|
|||
|
|
def hf_plasma(speed=0.3):
|
|||
|
|
"""Plasma-style hue field — organic color variation."""
|
|||
|
|
def fn(g, f, t, S):
|
|||
|
|
return (np.sin(g.cc*0.02 + t*speed)*0.5 + np.sin(g.rr*0.015 + t*speed*0.7)*0.5) % 1.0
|
|||
|
|
return fn
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
---
|
|||
|
|
|
|||
|
|
## Coordinate Transforms
|
|||
|
|
|
|||
|
|
UV-space transforms applied **before** effect evaluation. Any `vf_*` function can be rotated, zoomed, tiled, or distorted by transforming the grid coordinates it sees.
|
|||
|
|
|
|||
|
|
### Transform Helpers
|
|||
|
|
|
|||
|
|
```python
|
|||
|
|
def uv_rotate(g, angle):
|
|||
|
|
"""Rotate UV coordinates around grid center.
|
|||
|
|
Returns (rotated_cc, rotated_rr) arrays — use in place of g.cc, g.rr."""
|
|||
|
|
cx, cy = g.cols / 2.0, g.rows / 2.0
|
|||
|
|
cos_a, sin_a = np.cos(angle), np.sin(angle)
|
|||
|
|
dx = g.cc - cx
|
|||
|
|
dy = g.rr - cy
|
|||
|
|
return cx + dx * cos_a - dy * sin_a, cy + dx * sin_a + dy * cos_a
|
|||
|
|
|
|||
|
|
def uv_scale(g, sx=1.0, sy=1.0, cx_frac=0.5, cy_frac=0.5):
|
|||
|
|
"""Scale UV coordinates around a center point.
|
|||
|
|
sx, sy > 1 = zoom in (fewer repeats), < 1 = zoom out (more repeats)."""
|
|||
|
|
cx = g.cols * cx_frac; cy = g.rows * cy_frac
|
|||
|
|
return cx + (g.cc - cx) / sx, cy + (g.rr - cy) / sy
|
|||
|
|
|
|||
|
|
def uv_skew(g, kx=0.0, ky=0.0):
|
|||
|
|
"""Skew UV coordinates. kx shears horizontally, ky vertically."""
|
|||
|
|
return g.cc + g.rr * kx, g.rr + g.cc * ky
|
|||
|
|
|
|||
|
|
def uv_tile(g, nx=3.0, ny=3.0, mirror=False):
|
|||
|
|
"""Tile UV coordinates. nx, ny = number of repeats.
|
|||
|
|
mirror=True: alternating tiles are flipped (seamless)."""
|
|||
|
|
u = (g.cc / g.cols * nx) % 1.0
|
|||
|
|
v = (g.rr / g.rows * ny) % 1.0
|
|||
|
|
if mirror:
|
|||
|
|
flip_u = ((g.cc / g.cols * nx).astype(int) % 2) == 1
|
|||
|
|
flip_v = ((g.rr / g.rows * ny).astype(int) % 2) == 1
|
|||
|
|
u = np.where(flip_u, 1.0 - u, u)
|
|||
|
|
v = np.where(flip_v, 1.0 - v, v)
|
|||
|
|
return u * g.cols, v * g.rows
|
|||
|
|
|
|||
|
|
def uv_polar(g):
|
|||
|
|
"""Convert Cartesian to polar UV. Returns (angle_as_cc, dist_as_rr).
|
|||
|
|
Use to make any linear effect radial."""
|
|||
|
|
# Angle wraps [0, cols), distance wraps [0, rows)
|
|||
|
|
return g.angle / (2 * np.pi) * g.cols, g.dist_n * g.rows
|
|||
|
|
|
|||
|
|
def uv_cartesian_from_polar(g):
|
|||
|
|
"""Convert polar-addressed effects back to Cartesian.
|
|||
|
|
Treats g.cc as angle and g.rr as radius."""
|
|||
|
|
angle = g.cc / g.cols * 2 * np.pi
|
|||
|
|
radius = g.rr / g.rows
|
|||
|
|
cx, cy = g.cols / 2.0, g.rows / 2.0
|
|||
|
|
return cx + radius * np.cos(angle) * cx, cy + radius * np.sin(angle) * cy
|
|||
|
|
|
|||
|
|
def uv_twist(g, amount=2.0):
|
|||
|
|
"""Twist: rotation increases with distance from center. Creates spiral distortion."""
|
|||
|
|
twist_angle = g.dist_n * amount
|
|||
|
|
return uv_rotate_raw(g.cc, g.rr, g.cols / 2, g.rows / 2, twist_angle)
|
|||
|
|
|
|||
|
|
def uv_rotate_raw(cc, rr, cx, cy, angle):
|
|||
|
|
"""Raw rotation on arbitrary coordinate arrays."""
|
|||
|
|
cos_a, sin_a = np.cos(angle), np.sin(angle)
|
|||
|
|
dx = cc - cx; dy = rr - cy
|
|||
|
|
return cx + dx * cos_a - dy * sin_a, cy + dx * sin_a + dy * cos_a
|
|||
|
|
|
|||
|
|
def uv_fisheye(g, strength=1.5):
|
|||
|
|
"""Fisheye / barrel distortion on UV coordinates."""
|
|||
|
|
cx, cy = g.cols / 2.0, g.rows / 2.0
|
|||
|
|
dx = (g.cc - cx) / cx
|
|||
|
|
dy = (g.rr - cy) / cy
|
|||
|
|
r = np.sqrt(dx**2 + dy**2)
|
|||
|
|
r_distort = np.power(r, strength)
|
|||
|
|
scale = np.where(r > 0, r_distort / (r + 1e-10), 1.0)
|
|||
|
|
return cx + dx * scale * cx, cy + dy * scale * cy
|
|||
|
|
|
|||
|
|
def uv_wave(g, t, freq=0.1, amp=3.0, axis="x"):
|
|||
|
|
"""Sinusoidal coordinate displacement. Wobbles the UV space."""
|
|||
|
|
if axis == "x":
|
|||
|
|
return g.cc + np.sin(g.rr * freq + t * 3) * amp, g.rr
|
|||
|
|
else:
|
|||
|
|
return g.cc, g.rr + np.sin(g.cc * freq + t * 3) * amp
|
|||
|
|
|
|||
|
|
def uv_mobius(g, a=1.0, b=0.0, c=0.0, d=1.0):
|
|||
|
|
"""Möbius transformation (conformal map): f(z) = (az + b) / (cz + d).
|
|||
|
|
Operates on complex plane. Produces mathematically precise, visually
|
|||
|
|
striking inversions and circular transforms."""
|
|||
|
|
cx, cy = g.cols / 2.0, g.rows / 2.0
|
|||
|
|
# Map grid to complex plane [-1, 1]
|
|||
|
|
zr = (g.cc - cx) / cx
|
|||
|
|
zi = (g.rr - cy) / cy
|
|||
|
|
# Complex division: (a*z + b) / (c*z + d)
|
|||
|
|
num_r = a * zr - 0 * zi + b # imaginary parts of a,b,c,d = 0 for real params
|
|||
|
|
num_i = a * zi + 0 * zr + 0
|
|||
|
|
den_r = c * zr - 0 * zi + d
|
|||
|
|
den_i = c * zi + 0 * zr + 0
|
|||
|
|
denom = den_r**2 + den_i**2 + 1e-10
|
|||
|
|
wr = (num_r * den_r + num_i * den_i) / denom
|
|||
|
|
wi = (num_i * den_r - num_r * den_i) / denom
|
|||
|
|
return cx + wr * cx, cy + wi * cy
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Using Transforms with Value Fields
|
|||
|
|
|
|||
|
|
Transforms modify what coordinates a value field sees. Wrap the transform around the `vf_*` call:
|
|||
|
|
|
|||
|
|
```python
|
|||
|
|
# Rotate a plasma field 45 degrees
|
|||
|
|
def vf_rotated_plasma(g, f, t, S):
|
|||
|
|
rc, rr = uv_rotate(g, np.pi / 4 + t * 0.1)
|
|||
|
|
class TG: # transformed grid
|
|||
|
|
pass
|
|||
|
|
tg = TG(); tg.cc = rc; tg.rr = rr
|
|||
|
|
tg.rows = g.rows; tg.cols = g.cols
|
|||
|
|
tg.dist_n = g.dist_n; tg.angle = g.angle; tg.dist = g.dist
|
|||
|
|
return vf_plasma(tg, f, t, S)
|
|||
|
|
|
|||
|
|
# Tile a vortex 3x3 with mirror
|
|||
|
|
def vf_tiled_vortex(g, f, t, S):
|
|||
|
|
tc, tr = uv_tile(g, 3, 3, mirror=True)
|
|||
|
|
class TG:
|
|||
|
|
pass
|
|||
|
|
tg = TG(); tg.cc = tc; tg.rr = tr
|
|||
|
|
tg.rows = g.rows; tg.cols = g.cols
|
|||
|
|
tg.dist = np.sqrt((tc - g.cols/2)**2 + (tr - g.rows/2)**2)
|
|||
|
|
tg.dist_n = tg.dist / (tg.dist.max() + 1e-10)
|
|||
|
|
tg.angle = np.arctan2(tr - g.rows/2, tc - g.cols/2)
|
|||
|
|
return vf_vortex(tg, f, t, S)
|
|||
|
|
|
|||
|
|
# Helper: create transformed grid from coordinate arrays
|
|||
|
|
def make_tgrid(g, new_cc, new_rr):
|
|||
|
|
"""Build a grid-like object with transformed coordinates.
|
|||
|
|
Preserves rows/cols for sizing, recomputes polar coords."""
|
|||
|
|
class TG:
|
|||
|
|
pass
|
|||
|
|
tg = TG()
|
|||
|
|
tg.cc = new_cc; tg.rr = new_rr
|
|||
|
|
tg.rows = g.rows; tg.cols = g.cols
|
|||
|
|
cx, cy = g.cols / 2.0, g.rows / 2.0
|
|||
|
|
dx = new_cc - cx; dy = new_rr - cy
|
|||
|
|
tg.dist = np.sqrt(dx**2 + dy**2)
|
|||
|
|
tg.dist_n = tg.dist / (max(cx, cy) + 1e-10)
|
|||
|
|
tg.angle = np.arctan2(dy, dx)
|
|||
|
|
tg.dx = dx; tg.dy = dy
|
|||
|
|
tg.dx_n = dx / max(g.cols, 1)
|
|||
|
|
tg.dy_n = dy / max(g.rows, 1)
|
|||
|
|
return tg
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
---
|
|||
|
|
|
|||
|
|
## Temporal Coherence
|
|||
|
|
|
|||
|
|
Tools for smooth, intentional parameter evolution over time. Replaces the default pattern of either static parameters or raw audio reactivity.
|
|||
|
|
|
|||
|
|
### Easing Functions
|
|||
|
|
|
|||
|
|
Standard animation easing curves. All take `t` in [0,1] and return [0,1]:
|
|||
|
|
|
|||
|
|
```python
|
|||
|
|
def ease_linear(t): return t
|
|||
|
|
def ease_in_quad(t): return t * t
|
|||
|
|
def ease_out_quad(t): return t * (2 - t)
|
|||
|
|
def ease_in_out_quad(t): return np.where(t < 0.5, 2*t*t, -1 + (4-2*t)*t)
|
|||
|
|
def ease_in_cubic(t): return t**3
|
|||
|
|
def ease_out_cubic(t): return (t - 1)**3 + 1
|
|||
|
|
def ease_in_out_cubic(t):
|
|||
|
|
return np.where(t < 0.5, 4*t**3, 1 - (-2*t + 2)**3 / 2)
|
|||
|
|
def ease_in_expo(t): return np.where(t == 0, 0, 2**(10*(t-1)))
|
|||
|
|
def ease_out_expo(t): return np.where(t == 1, 1, 1 - 2**(-10*t))
|
|||
|
|
def ease_elastic(t):
|
|||
|
|
"""Elastic ease-out — overshoots then settles."""
|
|||
|
|
return np.where(t == 0, 0, np.where(t == 1, 1,
|
|||
|
|
2**(-10*t) * np.sin((t*10 - 0.75) * (2*np.pi) / 3) + 1))
|
|||
|
|
def ease_bounce(t):
|
|||
|
|
"""Bounce ease-out — bounces at the end."""
|
|||
|
|
t = np.asarray(t, dtype=np.float64)
|
|||
|
|
result = np.empty_like(t)
|
|||
|
|
m1 = t < 1/2.75
|
|||
|
|
m2 = (~m1) & (t < 2/2.75)
|
|||
|
|
m3 = (~m1) & (~m2) & (t < 2.5/2.75)
|
|||
|
|
m4 = ~(m1 | m2 | m3)
|
|||
|
|
result[m1] = 7.5625 * t[m1]**2
|
|||
|
|
t2 = t[m2] - 1.5/2.75; result[m2] = 7.5625 * t2**2 + 0.75
|
|||
|
|
t3 = t[m3] - 2.25/2.75; result[m3] = 7.5625 * t3**2 + 0.9375
|
|||
|
|
t4 = t[m4] - 2.625/2.75; result[m4] = 7.5625 * t4**2 + 0.984375
|
|||
|
|
return result
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Keyframe Interpolation
|
|||
|
|
|
|||
|
|
Define parameter values at specific times. Interpolates between them with easing:
|
|||
|
|
|
|||
|
|
```python
|
|||
|
|
def keyframe(t, points, ease_fn=ease_in_out_cubic, loop=False):
|
|||
|
|
"""Interpolate between keyframed values.
|
|||
|
|
|
|||
|
|
Args:
|
|||
|
|
t: current time (float, seconds)
|
|||
|
|
points: list of (time, value) tuples, sorted by time
|
|||
|
|
ease_fn: easing function for interpolation
|
|||
|
|
loop: if True, wraps around after last keyframe
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
interpolated value at time t
|
|||
|
|
|
|||
|
|
Example:
|
|||
|
|
twist = keyframe(t, [(0, 1.0), (5, 6.0), (10, 2.0)], ease_out_cubic)
|
|||
|
|
"""
|
|||
|
|
if not points:
|
|||
|
|
return 0.0
|
|||
|
|
if loop:
|
|||
|
|
period = points[-1][0] - points[0][0]
|
|||
|
|
if period > 0:
|
|||
|
|
t = points[0][0] + (t - points[0][0]) % period
|
|||
|
|
|
|||
|
|
# Clamp to range
|
|||
|
|
if t <= points[0][0]:
|
|||
|
|
return points[0][1]
|
|||
|
|
if t >= points[-1][0]:
|
|||
|
|
return points[-1][1]
|
|||
|
|
|
|||
|
|
# Find surrounding keyframes
|
|||
|
|
for i in range(len(points) - 1):
|
|||
|
|
t0, v0 = points[i]
|
|||
|
|
t1, v1 = points[i + 1]
|
|||
|
|
if t0 <= t <= t1:
|
|||
|
|
progress = (t - t0) / (t1 - t0)
|
|||
|
|
eased = ease_fn(progress)
|
|||
|
|
return v0 + (v1 - v0) * eased
|
|||
|
|
|
|||
|
|
return points[-1][1]
|
|||
|
|
|
|||
|
|
def keyframe_array(t, points, ease_fn=ease_in_out_cubic):
|
|||
|
|
"""Keyframe interpolation that works with numpy arrays as values.
|
|||
|
|
points: list of (time, np.array) tuples."""
|
|||
|
|
if t <= points[0][0]: return points[0][1].copy()
|
|||
|
|
if t >= points[-1][0]: return points[-1][1].copy()
|
|||
|
|
for i in range(len(points) - 1):
|
|||
|
|
t0, v0 = points[i]
|
|||
|
|
t1, v1 = points[i + 1]
|
|||
|
|
if t0 <= t <= t1:
|
|||
|
|
progress = ease_fn((t - t0) / (t1 - t0))
|
|||
|
|
return v0 * (1 - progress) + v1 * progress
|
|||
|
|
return points[-1][1].copy()
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Value Field Morphing
|
|||
|
|
|
|||
|
|
Smooth transition between two different value fields:
|
|||
|
|
|
|||
|
|
```python
|
|||
|
|
def vf_morph(g, f, t, S, vf_a, vf_b, t_start, t_end,
|
|||
|
|
ease_fn=ease_in_out_cubic):
|
|||
|
|
"""Morph between two value fields over a time range.
|
|||
|
|
|
|||
|
|
Usage:
|
|||
|
|
val = vf_morph(g, f, t, S,
|
|||
|
|
lambda g,f,t,S: vf_plasma(g,f,t,S),
|
|||
|
|
lambda g,f,t,S: vf_vortex(g,f,t,S, twist=5),
|
|||
|
|
t_start=10.0, t_end=15.0)
|
|||
|
|
"""
|
|||
|
|
if t <= t_start:
|
|||
|
|
return vf_a(g, f, t, S)
|
|||
|
|
if t >= t_end:
|
|||
|
|
return vf_b(g, f, t, S)
|
|||
|
|
progress = ease_fn((t - t_start) / (t_end - t_start))
|
|||
|
|
a = vf_a(g, f, t, S)
|
|||
|
|
b = vf_b(g, f, t, S)
|
|||
|
|
return a * (1 - progress) + b * progress
|
|||
|
|
|
|||
|
|
def vf_sequence(g, f, t, S, fields, durations, crossfade=1.0,
|
|||
|
|
ease_fn=ease_in_out_cubic):
|
|||
|
|
"""Cycle through a sequence of value fields with crossfades.
|
|||
|
|
|
|||
|
|
fields: list of vf_* callables
|
|||
|
|
durations: list of float seconds per field
|
|||
|
|
crossfade: seconds of overlap between adjacent fields
|
|||
|
|
"""
|
|||
|
|
total = sum(durations)
|
|||
|
|
t_local = t % total # loop
|
|||
|
|
elapsed = 0
|
|||
|
|
for i, dur in enumerate(durations):
|
|||
|
|
if t_local < elapsed + dur:
|
|||
|
|
# Current field
|
|||
|
|
base = fields[i](g, f, t, S)
|
|||
|
|
# Check if we're in a crossfade zone
|
|||
|
|
time_in = t_local - elapsed
|
|||
|
|
time_left = dur - time_in
|
|||
|
|
if time_in < crossfade and i > 0:
|
|||
|
|
# Fading in from previous
|
|||
|
|
prev = fields[(i - 1) % len(fields)](g, f, t, S)
|
|||
|
|
blend = ease_fn(time_in / crossfade)
|
|||
|
|
return prev * (1 - blend) + base * blend
|
|||
|
|
if time_left < crossfade and i < len(fields) - 1:
|
|||
|
|
# Fading out to next
|
|||
|
|
nxt = fields[(i + 1) % len(fields)](g, f, t, S)
|
|||
|
|
blend = ease_fn(1 - time_left / crossfade)
|
|||
|
|
return base * (1 - blend) + nxt * blend
|
|||
|
|
return base
|
|||
|
|
elapsed += dur
|
|||
|
|
return fields[-1](g, f, t, S)
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Temporal Noise
|
|||
|
|
|
|||
|
|
3D noise sampled at `(x, y, t)` — patterns evolve smoothly in time without per-frame discontinuities:
|
|||
|
|
|
|||
|
|
```python
|
|||
|
|
def vf_temporal_noise(g, f, t, S, freq=0.06, t_freq=0.3, octaves=4,
|
|||
|
|
bri=0.8):
|
|||
|
|
"""Noise field that evolves smoothly in time. Uses 3D noise via
|
|||
|
|
two 2D noise lookups combined with temporal interpolation.
|
|||
|
|
|
|||
|
|
Unlike vf_fbm which scrolls noise (creating directional motion),
|
|||
|
|
this morphs the pattern in-place — cells brighten and dim without
|
|||
|
|
the field moving in any direction."""
|
|||
|
|
# Two noise samples at floor/ceil of temporal coordinate
|
|||
|
|
t_scaled = t * t_freq
|
|||
|
|
t_lo = np.floor(t_scaled)
|
|||
|
|
t_frac = _smootherstep(np.full((g.rows, g.cols), t_scaled - t_lo, dtype=np.float32))
|
|||
|
|
|
|||
|
|
val_lo = np.zeros((g.rows, g.cols), dtype=np.float32)
|
|||
|
|
val_hi = np.zeros((g.rows, g.cols), dtype=np.float32)
|
|||
|
|
amp = 1.0; fx = freq
|
|||
|
|
for i in range(octaves):
|
|||
|
|
val_lo = val_lo + _value_noise_2d(
|
|||
|
|
g.cc * fx + t_lo * 7.3 + i * 13, g.rr * fx + t_lo * 3.1 + i * 29) * amp
|
|||
|
|
val_hi = val_hi + _value_noise_2d(
|
|||
|
|
g.cc * fx + (t_lo + 1) * 7.3 + i * 13, g.rr * fx + (t_lo + 1) * 3.1 + i * 29) * amp
|
|||
|
|
amp *= 0.5; fx *= 2.0
|
|||
|
|
max_amp = (1 - 0.5 ** octaves) / 0.5
|
|||
|
|
val = (val_lo * (1 - t_frac) + val_hi * t_frac) / max_amp
|
|||
|
|
return np.clip(val * bri * (0.6 + f.get("rms", 0.3) * 0.6), 0, 1)
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
---
|
|||
|
|
|
|||
|
|
### Combining Value Fields
|
|||
|
|
|
|||
|
|
The combinatorial explosion comes from mixing value fields with math:
|
|||
|
|
|
|||
|
|
```python
|
|||
|
|
# Multiplication = intersection (only shows where both have brightness)
|
|||
|
|
combined = vf_plasma(g,f,t,S) * vf_vortex(g,f,t,S)
|
|||
|
|
|
|||
|
|
# Addition = union (shows both, clips at 1.0)
|
|||
|
|
combined = np.clip(vf_rings(g,f,t,S) + vf_spiral(g,f,t,S), 0, 1)
|
|||
|
|
|
|||
|
|
# Interference = beat pattern (shows XOR-like patterns)
|
|||
|
|
combined = np.abs(vf_plasma(g,f,t,S) - vf_tunnel(g,f,t,S))
|
|||
|
|
|
|||
|
|
# Modulation = one effect shapes the other
|
|||
|
|
combined = vf_rings(g,f,t,S) * (0.3 + 0.7 * vf_plasma(g,f,t,S))
|
|||
|
|
|
|||
|
|
# Maximum = shows the brightest of two effects
|
|||
|
|
combined = np.maximum(vf_spiral(g,f,t,S), vf_aurora(g,f,t,S))
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
### Full Scene Example (v2 — Canvas Return)
|
|||
|
|
|
|||
|
|
A v2 scene function composes effects internally and returns a pixel canvas:
|
|||
|
|
|
|||
|
|
```python
|
|||
|
|
def scene_complex(r, f, t, S):
|
|||
|
|
"""v2 scene function: returns canvas (uint8 H,W,3).
|
|||
|
|
r = Renderer, f = audio features, t = time, S = persistent state dict."""
|
|||
|
|
g = r.grids["md"]
|
|||
|
|
rows, cols = g.rows, g.cols
|
|||
|
|
|
|||
|
|
# 1. Value field composition
|
|||
|
|
plasma = vf_plasma(g, f, t, S)
|
|||
|
|
vortex = vf_vortex(g, f, t, S, twist=4.0)
|
|||
|
|
combined = np.clip(plasma * 0.6 + vortex * 0.5 + plasma * vortex * 0.4, 0, 1)
|
|||
|
|
|
|||
|
|
# 2. Color from hue field
|
|||
|
|
h = (hf_angle(0.3)(g,f,t,S) * 0.5 + hf_time_cycle(0.08)(g,f,t,S) * 0.5) % 1.0
|
|||
|
|
|
|||
|
|
# 3. Render to canvas via _render_vf helper
|
|||
|
|
canvas = _render_vf(g, combined, h, sat=0.75, pal=PAL_DENSE)
|
|||
|
|
|
|||
|
|
# 4. Optional: blend a second layer
|
|||
|
|
overlay = _render_vf(r.grids["sm"], vf_rings(r.grids["sm"],f,t,S),
|
|||
|
|
hf_fixed(0.6)(r.grids["sm"],f,t,S), pal=PAL_BLOCK)
|
|||
|
|
canvas = blend_canvas(canvas, overlay, "screen", 0.4)
|
|||
|
|
|
|||
|
|
return canvas
|
|||
|
|
|
|||
|
|
# In the render_clip() loop (handled by the framework):
|
|||
|
|
# canvas = scene_fn(r, f, t, S)
|
|||
|
|
# canvas = tonemap(canvas, gamma=scene_gamma)
|
|||
|
|
# canvas = feedback.apply(canvas, ...)
|
|||
|
|
# canvas = shader_chain.apply(canvas, f=f, t=t)
|
|||
|
|
# pipe.stdin.write(canvas.tobytes())
|
|||
|
|
```
|
|||
|
|
|
|||
|
|
Vary the **value field combo**, **hue field**, **palette**, **blend modes**, **feedback config**, and **shader chain** per section for maximum visual variety. With 12 value fields × 8 hue fields × 14 palettes × 20 blend modes × 7 feedback transforms × 38 shaders, the combinations are effectively infinite.
|
|||
|
|
|
|||
|
|
---
|
|||
|
|
|
|||
|
|
## Combining Effects — Creative Guide
|
|||
|
|
|
|||
|
|
The catalog above is vocabulary. Here's how to compose it into something that looks intentional.
|
|||
|
|
|
|||
|
|
### Layering for Depth
|
|||
|
|
Every scene should have at least two layers at different grid densities:
|
|||
|
|
- **Background** (sm or xs): dense, dim texture that prevents flat black. fBM, smooth noise, or domain warp at low brightness (bri=0.15-0.25).
|
|||
|
|
- **Content** (md): the main visual — rings, voronoi, spirals, tunnel. Full brightness.
|
|||
|
|
- **Accent** (lg or xl): sparse highlights — particles, text stencil, glow pulse. Screen-blended on top.
|
|||
|
|
|
|||
|
|
### Interesting Effect Pairs
|
|||
|
|
| Pair | Blend | Why it works |
|
|||
|
|
|------|-------|-------------|
|
|||
|
|
| fBM + voronoi edges | `screen` | Organic fills the cells, edges add structure |
|
|||
|
|
| Domain warp + plasma | `difference` | Psychedelic organic interference |
|
|||
|
|
| Tunnel + vortex | `screen` | Depth perspective + rotational energy |
|
|||
|
|
| Spiral + interference | `exclusion` | Moire patterns from different spatial frequencies |
|
|||
|
|
| Reaction-diffusion + fire | `add` | Living organic base + dynamic foreground |
|
|||
|
|
| SDF geometry + domain warp | `screen` | Clean shapes floating in organic texture |
|
|||
|
|
|
|||
|
|
### Effects as Masks
|
|||
|
|
Any value field can be used as a mask for another effect via `mask_from_vf()`:
|
|||
|
|
- Voronoi cells masking fire (fire visible only inside cells)
|
|||
|
|
- fBM masking a solid color layer (organic color clouds)
|
|||
|
|
- SDF shapes masking a reaction-diffusion field
|
|||
|
|
- Animated iris/wipe revealing one effect over another
|
|||
|
|
|
|||
|
|
### Inventing New Effects
|
|||
|
|
For every project, create at least one effect that isn't in the catalog:
|
|||
|
|
- **Combine two vf_* functions** with math: `np.clip(vf_fbm(...) * vf_rings(...), 0, 1)`
|
|||
|
|
- **Apply coordinate transforms** before evaluation: `vf_plasma(twisted_grid, ...)`
|
|||
|
|
- **Use one field to modulate another's parameters**: `vf_spiral(..., tightness=2 + vf_fbm(...) * 5)`
|
|||
|
|
- **Stack time offsets**: render the same field at `t` and `t - 0.5`, difference-blend for motion trails
|
|||
|
|
- **Mirror a value field** through an SDF boundary for kaleidoscopic geometry
|