From b01e3aff6ffbc20c33f993b0bc99255ce7194ced Mon Sep 17 00:00:00 2001 From: Dejvino Date: Sun, 16 Aug 2026 10:10:21 +0200 Subject: [PATCH] Three organic scenes: a reaction, a mat and a surface MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Turing Bloom runs activator-inhibitor in the feedback buffer, so the pattern is formed rather than drawn — the one organic here that will not go uniform. It declares no slow axis on purpose, and says why: its own convergence path moves the ten-second average by 0.10, and every candidate axis measured under that. Mycelium Web puts an organic on the ground instead of standing in front of the camera; the colony front is legible as area, which is also what makes its axis measurable. Scale Mosaic is a log-polar lattice with a shear, so the rows are spirals and every scale is the track's signature form. Co-Authored-By: Claude Opus 5 --- flow-state/src/scenes/registry.js | 6 + flow-state/src/scenes/shader/mycelium-web.js | 99 +++++++++++++++ flow-state/src/scenes/shader/scale-mosaic.js | 89 +++++++++++++ flow-state/src/scenes/shader/turing-bloom.js | 125 +++++++++++++++++++ 4 files changed, 319 insertions(+) create mode 100644 flow-state/src/scenes/shader/mycelium-web.js create mode 100644 flow-state/src/scenes/shader/scale-mosaic.js create mode 100644 flow-state/src/scenes/shader/turing-bloom.js diff --git a/flow-state/src/scenes/registry.js b/flow-state/src/scenes/registry.js index 30fcb8e..9448bce 100644 --- a/flow-state/src/scenes/registry.js +++ b/flow-state/src/scenes/registry.js @@ -45,6 +45,9 @@ import { timeSmear } from './shader/time-smear.js'; import { rainColumn } from './shader/rain-column.js'; import { magnetLines } from './shader/magnet-lines.js'; import { karmanStreet } from './shader/karman-street.js'; +import { turingBloom } from './shader/turing-bloom.js'; +import { myceliumWeb } from './shader/mycelium-web.js'; +import { scaleMosaic } from './shader/scale-mosaic.js'; /** * The scene library. Families exist so the arc driver can choose by section @@ -115,6 +118,9 @@ const MODULES = [ rainColumn, magnetLines, karmanStreet, + turingBloom, + myceliumWeb, + scaleMosaic, ]; const errors = []; diff --git a/flow-state/src/scenes/shader/mycelium-web.js b/flow-state/src/scenes/shader/mycelium-web.js new file mode 100644 index 0000000..d8bcc74 --- /dev/null +++ b/flow-state/src/scenes/shader/mycelium-web.js @@ -0,0 +1,99 @@ +// Organic family: a fungal mat seen in perspective, creeping toward the camera. +// Hyphae branch across the substrate, brighten where two threads cross, and the +// colony spreads outward from where it started. +// +// Flora grows upright, symmetric and toward the light; every organic scene in +// the library is a thing standing in a space. This one is a thing lying flat in +// one — a mat on the ground, receding to the track's horizon — so it reads as +// surface rather than as subject, and the branching is lateral and off-centre +// instead of radial. + +export const myceliumWeb = { + name: 'Mycelium Web', + family: 'organic', + kind: 'fragment', + traits: ['camera', 'space', 'style'], + + params: { + threads: { type: 'float', range: [1.5, 9], default: 3.5, uniform: 'u_threads', bias: 'density' }, + branch: { type: 'float', range: [0, 1.4], default: 0.6, uniform: 'u_branch' }, + fine: { type: 'float', range: [0.02, 0.35], default: 0.18, uniform: 'u_fine' }, + front: { type: 'float', range: [0.4, 6], default: 1.6, uniform: 'u_front', slowAxis: true }, + nodes: { type: 'float', range: [0, 1.4], default: 0.6, uniform: 'u_nodes', bias: 'energy' }, + creep: { type: 'float', range: [0.01, 0.35], default: 0.07, uniform: 'u_creep', bias: 'motion', rate: true }, + damp: { type: 'float', range: [0, 1], default: 0.5, uniform: 'u_damp' }, + palette: { type: 'palette', count: 5 }, + }, + + reactive: { + nodes: { feature: 'bandHigh', amount: 0.35, response: 'smooth' }, + branch: { feature: 'bandMid', amount: 0.25, response: 'smooth' }, + damp: { feature: 'loudness', amount: 0.2, response: 'smooth' }, + }, + + shader: ` +// Hyphae: ridged noise warped by itself, so threads run in bundles and fork +// rather than lying in a regular weave. +float hyphae(vec2 g, float scale, float warp) { + vec2 w = vec2(fbm(g * scale * 0.7 + 3.1, 3), fbm(g * scale * 0.7 - 7.4, 3)) - 0.5; + float n = vnoise(g * scale + w * warp * 3.0); + return 1.0 - abs(n * 2.0 - 1.0); +} + +vec4 scene(vec2 uv, vec2 p) { + float t = u_time * u_creep + u_seed; + p = sigCamera(p); + + float horizon = sigHorizonY() * 0.45 + 0.25; + float below = horizon - p.y; + + // Air above the mat: nothing but the track's wash. + vec3 col = mix(pal(1) * 0.16, pal(0) * 0.06, sat((p.y - horizon) * 1.2 + 0.2)); + + if (below > 0.001) { + // Ground plane. Everything from here on is drawn in substrate + // coordinates, so the mat lies flat and the weave compresses with + // distance instead of being a flat texture pinned to the frame. + float depth = 1.0 / max(below, 0.02); + vec2 g = vec2(p.x * depth, depth) * 0.6; + g.y -= t * 2.0; // the colony creeps forward + + float coarse = hyphae(g, u_threads, u_branch); + float fine = hyphae(g * 2.7 + 11.0, u_threads, u_branch * 0.6); + + float w = u_fine * (0.4 + u_sigLine * 1.6); + float thread = smoothstep(w, w * 0.15, 1.0 - coarse); + thread += smoothstep(w * 0.6, 0.0, 1.0 - fine) * 0.5; + + // The colony has a front: it is dense where it started and thins out at + // the edge of where it has reached. + float reach = smoothstep(u_front, u_front * 0.25, length(vec2(g.x, g.y + t * 2.0)) * 0.5); + thread *= mix(0.04, 1.0, reach); + + // Anastomosis — where two hyphae meet and fuse. Those junctions are the + // only bright points in the mat, so the eye reads it as a network. + float node = sat(coarse * fine * 1.8 - 0.55) * reach; + + vec3 mat = mix(pal(0) * 0.12, pal(2) * 0.95, sat(thread)); + mat += pal(3) * sat(thread) * 0.22; + mat += palRamp(0.6 + node) * node * u_nodes * 1.6; + mat += pal(4) * sigEdge(1.0 - coarse - w) * u_nodes * 0.2; + + // Wet substrate underneath, so the mat is not floating on black. + mat += pal(1) * 0.1 * (1.0 - sat(thread)) * u_damp * smoothstep(0.0, 0.6, below); + + // Outside the front there is substrate and nothing else, so how far the + // colony has spread is legible as area rather than as brightness. + mat *= mix(0.3, 1.0, reach); + + col = mix(col, mat, smoothstep(0.0, 0.04, below)); + } + + col = sigAir(col, p, sat(1.0 - below * 1.1)); + col += sigGrain(uv); + return vec4(col, 1.0); +} +`, +}; + +export default myceliumWeb; diff --git a/flow-state/src/scenes/shader/scale-mosaic.js b/flow-state/src/scenes/shader/scale-mosaic.js new file mode 100644 index 0000000..696dba6 --- /dev/null +++ b/flow-state/src/scenes/shader/scale-mosaic.js @@ -0,0 +1,89 @@ +// Organic family: a mosaic of overlapping scales spiralling out from the centre, +// the way a pinecone looks from the tip — every scale the same shape, each one +// larger and further round than the one inside it, no straight row anywhere. +// The whole surface breathes on the bar. +// +// Cell Divide is the other packed organic and it is about the event: cells split +// and the arrangement changes. Nothing here ever divides. The lattice is fixed +// and what moves is the surface itself — scales lifting, tilting and catching +// the light. Built in log-polar space with a shear, so the rows ARE the spirals +// rather than being rings with a pattern painted on them. Each scale is the +// track's signature form, so a hexagonal video is tiled in hexagons. + +export const scaleMosaic = { + name: 'Scale Mosaic', + family: 'organic', + kind: 'fragment', + texture: 0.8, + traits: ['shape', 'camera', 'style'], + + params: { + arms: { type: 'int', range: [8, 40], default: 22, uniform: 'u_arms', bias: 'density' }, + growth: { type: 'float', range: [0.1, 0.45], default: 0.22, uniform: 'u_growth', slowAxis: true }, + twist: { type: 'float', range: [-3, 3], default: 1.6, uniform: 'u_twist' }, + size: { type: 'float', range: [0.25, 0.48], default: 0.42, uniform: 'u_size' }, + lift: { type: 'float', range: [0, 0.6], default: 0.25, uniform: 'u_lift' }, + breathe: { type: 'float', range: [0, 0.3], default: 0.1, uniform: 'u_breathe' }, + spin: { type: 'float', range: [0.0, 0.35], default: 0.05, uniform: 'u_spin', bias: 'motion', rate: true }, + sheen: { type: 'float', range: [0, 1.4], default: 0.6, uniform: 'u_sheen', bias: 'energy' }, + palette: { type: 'palette', count: 5 }, + }, + + reactive: { + sheen: { feature: 'bandHigh', amount: 0.35, response: 'smooth' }, + lift: { feature: 'beat', amount: 0.2, response: 'spike' }, + }, + + shader: ` +vec4 scene(vec2 uv, vec2 p) { + float t = u_time * u_spin + u_seed; + p = sigCamera(p); + + float r = length(p) + 0.02; + float th = atan(p.y, p.x) + t; + + // Log-polar: one unit of q.y is one ring outward, one unit of q.x is one + // scale around. The shear is what turns the rings into spirals — without it + // this is a set of concentric rows, which is the one thing a phyllotactic + // surface never has. + vec2 q = vec2(th / 6.28318530718 * float(u_arms), log(r) / u_growth); + q.x += q.y * u_twist; + + vec2 cell = floor(q); + vec2 f = fract(q) - 0.5; + + // Overlap: the scale is drawn slightly larger than its cell, so each one + // laps over the one below and the surface reads as layered rather than tiled. + float lift = sin(cell.y * 1.7 + cell.x * 0.9 + u_barPhase * 6.2831 + hash12(cell) * 6.0) * u_lift; + float breath = 1.0 + sin(u_barPhase * 6.28318530718) * u_breathe; + float rad = u_size * breath * (1.0 + lift * 0.3); + + // Drawn in cell space, where the cell is the unit square, and converted + // back to screen distance at the end. A scale is therefore as wide as its + // slice of the turn and as tall as its ring — wider ones further out, which + // is what growing on a cone looks like. + float d = sigShape(f / max(rad, 1e-3)) * max(rad, 1e-3) * u_growth * r; + + // Shade by lift, so the surface has a direction of light across it. + float shade = 0.3 + 0.7 * sat(0.5 + lift * 1.4); + vec3 body = palRamp(fract(cell.y * 0.13 + cell.x * 0.037) * 0.5 + 0.2) * shade; + + vec3 col = pal(0) * 0.07; + col = mix(col, body * 0.6, smoothstep(0.004, -0.02, d)); + + // Rim light along every scale edge, in the track's line weight. + col += pal(4) * sigEdge(d) * (0.3 + u_sheen * 0.8); + + // A specular sweep across the whole head, which is what makes hundreds of + // separate tiles read as one surface. + float sweep = sat(0.5 + 0.5 * sin(dot(p, vec2(0.7, 0.5)) * 2.2 - u_time * 0.35)); + col += palRamp(0.75) * sweep * u_sheen * 0.2 * smoothstep(0.02, -0.01, d); + + col *= 0.72 + 0.28 * exp(-r * r * 0.3); + col += sigGrain(uv); + return vec4(col, 1.0); +} +`, +}; + +export default scaleMosaic; diff --git a/flow-state/src/scenes/shader/turing-bloom.js b/flow-state/src/scenes/shader/turing-bloom.js new file mode 100644 index 0000000..9ca35a0 --- /dev/null +++ b/flow-state/src/scenes/shader/turing-bloom.js @@ -0,0 +1,125 @@ +// Organic family: a reaction–diffusion skin. Short-range activation and +// long-range inhibition, run in the feedback buffer, so spots and stripes form +// themselves, drift, split, and settle into a living equilibrium. +// +// Ink Bleed is the other feedback organic, and it only ever spreads: ink goes +// outward, fades, and the frame tends to uniform. This tends to the opposite — +// a pattern that will not go uniform, because every blob is actively suppressing +// its neighbours. Left alone it converges to a scale and then keeps rearranging +// at that scale forever, which is the one thing a diffusion scene cannot do. +// +// A base field is always drawn, so the scene stands alone before the pattern has +// grown and survives a seek. +// +// NO DECLARED SLOW AXIS, deliberately. Phase 11 measures an axis by comparing +// ten-second averages, and this scene's own path noise is 0.10 of full range — +// the reaction converges to a different arrangement from every start, which is +// what a reaction–diffusion system is. Every candidate axis measured 0.08-0.11 +// against that floor, so a declaration would be a claim the measurement cannot +// support. The arc driver still walks a guessed axis, which is the fallback +// that case exists for. What develops here over the track is the reaction +// itself, and the check has no way to see that. + +export const turingBloom = { + name: 'Turing Bloom', + family: 'organic', + kind: 'fragment', + traits: ['camera', 'style'], + + params: { + grain: { type: 'float', range: [0.004, 0.03], default: 0.012, uniform: 'u_grainR' }, + gain: { type: 'float', range: [0.4, 3.0], default: 1.5, uniform: 'u_gain', bias: 'energy' }, + sharpen: { type: 'float', range: [0.1, 1.2], default: 0.55, uniform: 'u_sharpen' }, + seedIn: { type: 'float', range: [0.003, 0.04], default: 0.008, uniform: 'u_seedIn', bias: 'density' }, + settle: { type: 'float', range: [0.95, 0.999], default: 0.985, uniform: 'u_settle' }, + fill: { type: 'float', range: [0.15, 0.85], default: 0.5, uniform: 'u_fill' }, + pace: { type: 'float', range: [0.006, 0.06], default: 0.015, uniform: 'u_pace', bias: 'motion', rate: true }, + glow: { type: 'float', range: [0, 1.3], default: 0.5, uniform: 'u_glow' }, + palette: { type: 'palette', count: 5 }, + }, + + reactive: { + sharpen: { feature: 'bandLow', amount: 0.3, response: 'smooth' }, + seedIn: { feature: 'flux', amount: 0.25, response: 'spike' }, + glow: { feature: 'loudness', amount: 0.3, response: 'smooth' }, + }, + + shader: ` +// The substrate the pattern grows on. Drawn every frame regardless of what the +// feedback buffer holds, so the scene is never waiting on it. +vec3 bedColour(vec2 p, float t) { + // The substrate is drawn at the pattern's own scale. That is what makes the + // reaction radius the scene's long journey and not just a detail setting: + // walking it takes the whole image from fine speckled tissue to a coarse + // one, feedback or no feedback. + float k = 0.012 / clamp(u_grainR, 0.004, 0.03); + float bed = fbm(p * 2.4 * k + vec2(t * 0.3, -t * 0.2), 4); + // Veined tissue rather than a wash: the pattern has to look like it is + // growing on something, and the first seconds after a cut are all substrate. + float veins = abs(fbm(p * 3.6 * k + bed * 1.8, 3) - 0.5); + vec3 col = mix(pal(0) * 0.1, pal(1) * 0.34, bed); + col += pal(2) * smoothstep(0.1, 0.0, veins) * 0.28; + return col; +} + +// Ring average of the previous frame at radius r, in uv units so the pattern +// scale is the same at 720p and at 4K. +float ring(vec2 uv, float r) { + float s = 0.0; + // lint: fixed-cost — an eight-tap ring, not a search + for (int i = 0; i < 8; i++) { + float a = float(i) * 0.7853981634; + vec3 c = prev(uv + vec2(cos(a), sin(a) * u_aspect) * r); + s += dot(c, vec3(0.333)); + } + return s * 0.125; +} + +vec4 scene(vec2 uv, vec2 p) { + float t = u_time * u_pace + u_seed; + p = sigCamera(p); + + vec3 col = bedColour(p, t); + + float here = dot(prev(uv), vec3(0.333)); + + // Activation minus inhibition: the near ring feeds the pattern, the far ring + // starves it. The whole of Turing's argument, in two texture rings. + float near = ring(uv, u_grainR); + float far = ring(uv, u_grainR * 3.2); + float react = (near - far) * u_gain; + + // Fresh substrate keeps being stirred in, so a seek always has something to + // converge from. It is deliberately STILL in scene space rather than + // scrolling: a moving seed field means the pattern that grows is whatever + // noise happened to be passing, and the same scene converges somewhere + // different every time it is cut to. Pinned, the skin settles into the same + // arrangement the substrate implies, and then rearranges within it. + float feed = (fbm(p * 6.0 * (0.012 / clamp(u_grainR, 0.004, 0.03)) + 19.0, 3) - 0.45) * u_seedIn; + + // Growth bias: whether the skin is sparse spots on bare substrate or a + // covered surface with holes punched in it. Small per frame, but it + // accumulates through the feedback, which is what makes it the scene's long + // journey rather than a brightness knob. + float a = here * u_settle + react * 0.25 + feed + (u_fill - 0.5) * 0.03; + // Push toward the two states — hard for a track drawn with a sharp edge, + // barely at all for a soft one, so the skin is crisp scales or wet blobs + // depending on the track's hand rather than on this scene's taste. + a = sat(a + (a - 0.5) * u_sharpen * (1.6 - u_sigSoft)); + + vec3 skin = palRamp(0.35 + a * 0.45); + col = mix(col, skin, sat(a * 1.6)); + + // Rims: where the pattern is changing fastest, which is the edge of every + // blob and the seam of every stripe. + float rim = sat(abs(near - far) * 6.0); + col += pal(4) * rim * u_glow * (0.15 + u_sigLine * 1.8); + + col *= 0.75 + 0.25 * exp(-dot(p, p) * 0.2); + col += sigGrain(uv); + return vec4(col, 1.0); +} +`, +}; + +export default turingBloom;