@3driseai/3drise-viewer 0.1.41 → 0.1.43

package/dist/components/water/core/fountain.js

@@ -0,0 +1,619 @@
+// Emitted from Claude outputs/water-lab/fountain.mjs by gen_family.mjs — edit the lab module and re-emit.
+// water/core/fountain — Fountain (type 'water', config.type 'fountain'). Shared core: ../waterCore. six kinds of fountain, all water only (the basin, bowls and nozzles are the
+// user's meshes):
+//   jets     ballistic jets (single / ring / crown / fan) that break into droplets
+//   laminar  the same arcs as unbroken glass rods (laminar-flow nozzles), landing without splash
+//   dancing  jets whose heights run as a wave / chase / pulse over time (a show fountain)
+//   geyser   one thick aerated column that bursts up, collapses into a plume and pulses
+//   bell     a laminar dome: a thin sheet leaving a nozzle radially and falling as a bell
+//   tiers    stacked bowls: water discs spilling over their rims as curtains onto the next
+//
+// Construction (jets):
+// COLUMN. Near the nozzle a jet is a coherent glassy rod, so it is drawn as geometry: a tube
+// swept along the closed-form parabola (x = v·sinθ·t, y = v·cosθ·t − ½gt²), radius growing
+// slightly with flight, its surface wobbling with advected noise; shaded as water — Fresnel
+// sky reflection, the background tinted through it, a tight sun glint — and fading out where
+// the jet breaks up (`breakup` sets where). BREAK-UP. Past that point the water is drops in
+// CLUMPS (slugs): droplets share a slug phase with jitter, stretched along their velocity,
+// scattering sideways with flight time; near the apex they droop and thin out. Each droplet
+// is a tiny lens — sky through it, a glint. SPLASH. Where a jet lands: a crown of short
+// upward streaks, a CHURN patch (boiling foam on the basin) and expanding RINGS on the jet's
+// cadence. BASIN. Round, tiled floor seen through the water with refraction, caustics and
+// Beer–Lambert absorption. Patterns: single, ring, crown (alternating heights), arc (fan).
+import * as THREE from 'three';
+import { GLSL_COMMON, GLSL_BILLBOARD, createSunUniforms, createBasinUniforms, createBasin, applyBasinWind, instancedQuads, mulberry32, ringSpawner, createMistVolume } from '../waterCore.js';
+export const STRUCTURAL = ['kind', 'pattern', 'jets', 'droplets', 'basinSize', 'tiers', 'topRadius', 'spread', 'tierHeight', 'bellRadius', 'nozzleHeight'];
+const MAX_JETS = 24;
+const G = 9.81;
+export function createUniforms() {
+    return {
+        ...createSunUniforms(),
+        uJets: { value: Array.from({ length: MAX_JETS }, () => new THREE.Vector4()) }, // nozzle x, z, dir angle, speed
+        uJetAux: { value: Array.from({ length: MAX_JETS }, () => new THREE.Vector4()) }, // tilt, flight time, phase, apex
+        uJetCount: { value: 0 },
+        uThickness: { value: 1 }, uBreakup: { value: 0.45 }, uSplash: { value: 1 }, uSpin: { value: 0 }, uFroth: { value: 1 },
+        uWaterColor: { value: new THREE.Color('#cfe9f2') }, uFoamColor: { value: new THREE.Color('#eef6f8') },
+        uCamPos: { value: new THREE.Vector3() },
+    };
+}
+/** Per-jet apex-height factors for the dancing kind. */
+function danceFactors(c, n, now) {
+    const f = new Float32Array(n).fill(1);
+    if (c.kind !== 'dancing')
+        return f;
+    const sp = c.danceSpeed;
+    for (let i = 0; i < n; i++) {
+        const ph = i / n;
+        if (c.dance === 'wave')
+            f[i] = 0.35 + 0.65 * (0.5 + 0.5 * Math.sin((now * sp - ph * 2) * 2.2));
+        else if (c.dance === 'chase') {
+            const d = ((now * sp * 0.6) % 1 + 1 - ph) % 1;
+            f[i] = 0.25 + 0.75 * Math.max(0, 1 - d * 3);
+        }
+        else
+            f[i] = 0.3 + 0.7 * Math.pow(0.5 + 0.5 * Math.sin(now * sp * 2.5 + i * 0.3), 2.0);
+    }
+    return f;
+}
+export function layoutJets(u, c, now = 0) {
+    const n = Math.min(MAX_JETS, Math.max(1, Math.round(c.jets)));
+    const tilt = (c.tilt * Math.PI) / 180;
+    const rng = mulberry32(11);
+    const single = c.pattern === 'single' || c.kind === 'geyser';
+    u.uJetCount.value = single ? 1 : n;
+    const dance = danceFactors(c, u.uJetCount.value, now);
+    for (let i = 0; i < MAX_JETS; i++) {
+        if (i >= u.uJetCount.value) {
+            u.uJets.value[i].set(0, 0, 0, 0);
+            u.uJetAux.value[i].set(0, 1, 0, 0);
+            continue;
+        }
+        let x = 0, z = 0, dir = 0, h = c.height * dance[i], th = tilt;
+        if (c.kind === 'geyser') {
+            // a geyser surges: slow noise over the height, with sharper bursts
+            const n1 = Math.sin(now * 0.9) * 0.5 + Math.sin(now * 2.3 + 1.0) * 0.3 + Math.sin(now * 5.1) * 0.2;
+            h = c.height * (0.6 + 0.4 * (0.5 + 0.5 * n1));
+            th = 0.02;
+        }
+        if (single) {
+            if (c.kind !== 'geyser')
+                th = 0;
+        }
+        else if (c.pattern === 'ring' || c.pattern === 'crown') {
+            const a = (i / n) * Math.PI * 2;
+            x = Math.cos(a) * c.radius;
+            z = Math.sin(a) * c.radius;
+            dir = a;
+            if (c.pattern === 'crown')
+                h = c.height * (i % 2 ? 0.55 : 1);
+        }
+        else if (c.pattern === 'arc') {
+            const t = n === 1 ? 0 : i / (n - 1) - 0.5;
+            x = t * c.radius * 2;
+            dir = Math.PI / 2;
+            th = tilt * 0.6 + Math.abs(t) * 0.3;
+            h = c.height * (1 - 0.5 * Math.abs(t));
+        }
+        const vy = Math.sqrt(2 * G * h), v = vy / Math.max(Math.cos(th), 0.05), T = (2 * vy) / G;
+        u.uJets.value[i].set(x, z, dir, v);
+        u.uJetAux.value[i].set(th, T, rng(), h);
+    }
+}
+export function applyConfig(u, c) {
+    if (c.thickness !== undefined)
+        u.uThickness.value = c.thickness;
+    if (c.breakup !== undefined)
+        u.uBreakup.value = c.breakup;
+    if (c.kind !== undefined) {
+        // kind presets over the shared machinery
+        if (c.kind === 'laminar') {
+            u.uBreakup.value = 1.0;
+            u.uFroth.value = 0;
+        }
+        else if (c.kind === 'geyser') {
+            u.uBreakup.value = Math.min(c.breakup ?? 0.45, 0.4);
+            u.uFroth.value = 2.0;
+            u.uThickness.value = (c.thickness ?? 1) * 6;
+        }
+        else {
+            u.uFroth.value = 1;
+        }
+    }
+    if (c.splash !== undefined)
+        u.uSplash.value = c.splash;
+    if (c.spin !== undefined)
+        u.uSpin.value = c.spin;
+    if (c.waterColor !== undefined)
+        u.uWaterColor.value.set(c.waterColor);
+    if (c.foamColor !== undefined)
+        u.uFoamColor.value.set(c.foamColor);
+}
+// shared: where jet j is at flight fraction f (with spin)
+const GLSL_JET = /* glsl */ `
+uniform vec4 uJets[${MAX_JETS}];
+uniform vec4 uJetAux[${MAX_JETS}];
+uniform int uJetCount;
+uniform float uThickness, uBreakup, uSplash, uSpin, uFroth;
+void jetAt(int j, float t, out vec3 p, out vec3 vel, out vec3 out_, out vec2 nozzle) {
+    vec4 J = uJets[j]; vec4 A = uJetAux[j];
+    float spin = uSpin * uTime * 6.2832 / 60.0;
+    float ang = J.z + spin;
+    nozzle = vec2(cos(spin) * J.x - sin(spin) * J.y, sin(spin) * J.x + cos(spin) * J.y);
+    out_ = vec3(cos(ang), 0.0, sin(ang));
+    float v = J.w, th = A.x;
+    vec3 vel0 = vec3(out_.x * v * sin(th), v * cos(th), out_.z * v * sin(th));
+    p = vec3(nozzle.x, 0.0, nozzle.y) + vel0 * t + vec3(0.0, -0.5 * 9.81 * t * t, 0.0);
+    vel = vel0 + vec3(0.0, -9.81 * t, 0.0);
+}
+`;
+// ---------------------------------------------------------------------------- the column: a tube swept along the arc (vertex stage places a ring at each segment)
+const COLUMN_VERT = /* glsl */ `
+${GLSL_COMMON}
+${GLSL_JET}
+attribute vec2 aRing;     // x: flight fraction along the tube (0..1 of the whole flight), y: angle around (0..1)
+attribute float aJet;
+varying vec3 vP; varying vec3 vN; varying float vF; varying float vAng; varying vec3 vAxis;
+void main() {
+    int j = int(aJet + 0.5);
+    float T = uJetAux[j].y;
+    float f = aRing.x;
+    vec3 p, vel, out_; vec2 nz;
+    jetAt(j, f * T, p, vel, out_, nz);
+    vec3 axis = normalize(vel);
+    vec3 side = normalize(cross(axis, vec3(0.0, 1.0, 0.0) + out_ * 0.01));
+    vec3 upv = normalize(cross(side, axis));
+    float ang = aRing.y * 6.2832;
+    // radius: nozzle diameter, swelling with flight; wobble advected along the jet
+    float wob = (vnoise21(vec2(f * 14.0 - uTime * 6.0, ang * 0.5)) - 0.5) * 0.3 * f;
+    float r = (0.035 + 0.04 * uThickness) * (0.75 + 1.1 * f) * (1.0 + wob);
+    vec3 n = cos(ang) * side + sin(ang) * upv;
+    vec3 lp = p + n * r;
+    vP = (modelMatrix * vec4(lp, 1.0)).xyz;
+    vN = normalize(mat3(modelMatrix) * n);
+    vAxis = normalize(mat3(modelMatrix) * axis);
+    vF = f; vAng = ang;
+    gl_Position = projectionMatrix * viewMatrix * vec4(vP, 1.0);
+}
+`;
+const COLUMN_FRAG = /* glsl */ `
+${GLSL_COMMON}
+${GLSL_JET}
+uniform vec3 uWaterColor, uFoamColor, uCamPos;
+varying vec3 vP; varying vec3 vN; varying float vF; varying float vAng; varying vec3 vAxis;
+void main() {
+    float f = vF;
+    vec3 N = normalize(vN);
+    // surface texture travelling along the jet: it is a rod of water, streaked
+    float st = vnoise21(vec2(vAng * 1.2, f * 30.0 - uTime * 9.0));
+    float st2 = vnoise21(vec2(vAng * 3.0 + 5.0, f * 60.0 - uTime * 14.0));
+    N = normalize(N + vAxis * (st - 0.5) * 0.6 + cross(N, vAxis) * (st2 - 0.5) * 0.4);
+    vec3 V = normalize(uCamPos - vP);
+    vec3 L = normalize(uSunDir);
+    float fres = fresnelWater(N, V);
+    vec3 skyR = skyColor(reflect(-V, N));
+    // through the rod: the sky behind, tinted — a jet is clear glass near the nozzle
+    vec3 through = skyColor(refract(-V, N, 0.75)) * 0.75 * mix(vec3(1.0), uWaterColor, 0.35);
+    // aeration: white froth grows toward the break-up
+    float froth = smoothstep(uBreakup * 0.5, uBreakup, f) * (0.4 + 0.6 * st2) * uFroth;
+    vec3 frothCol = uFoamColor * (uSkyAmbient * 0.55 + uSunColor * (0.2 + 0.3 * max(dot(N, L), 0.0)));
+    vec3 col = mix(through, skyR, fres) + uSunColor * ggx(N, L, V, 0.06) * fres * 2.0;
+    col = mix(col, frothCol, froth * 0.8);
+    // the column fades out across the break-up; the drops take over
+    float a = (1.0 - smoothstep(uBreakup * 0.85, uBreakup * 1.15, f)) * (0.65 + 0.35 * froth);
+    if (a < 0.01) discard;
+    gl_FragColor = vec4(col * a, a);
+    #include <colorspace_fragment>
+}
+`;
+// ---------------------------------------------------------------------------- the drops: clumps past the break-up
+const DROP_VERT = /* glsl */ `
+${GLSL_COMMON}
+${GLSL_BILLBOARD}
+${GLSL_JET}
+attribute vec4 aSeed;
+varying vec2 vUv; varying float vA; varying vec3 vP; varying float vCore;
+void main() {
+    vUv = uv;
+    int j = int(floor(aSeed.x * float(uJetCount)));
+    float T = uJetAux[j].y;
+    // slugs: 8 per flight, drops share a slug phase with jitter, the stream is continuous in time
+    float slug = floor(aSeed.y * 8.0);
+    float phase = (slug + hash11(aSeed.z * 9.0) * mix(0.35, 1.0, clamp(uFroth - 1.0, 0.0, 1.0))) / 8.0;
+    float t = mod(phase * T + uTime, T);
+    float f = t / T;
+    vec3 p, vel, out_; vec2 nz;
+    jetAt(j, t, p, vel, out_, nz);
+    // only past the break-up (the column draws before it); fade in across it
+    float born = smoothstep(uBreakup * 0.85, uBreakup * 1.15, f);
+    vec3 axis = normalize(vel);
+    vec3 side = normalize(cross(axis, vec3(0.0, 1.0, 0.0) + out_ * 0.01));
+    vec3 upv = normalize(cross(side, axis));
+    vec2 sc = (hash22(aSeed.zw * 40.0) - 0.5) * 2.0;
+    float grow = max(f - uBreakup, 0.0);
+    float radial = ((0.03 + 0.04 * uThickness) + grow * grow * 0.6 + grow * 0.12) * (1.0 + 0.8 * clamp(uFroth - 1.0, 0.0, 1.0));
+    p += (side * sc.x + upv * sc.y) * radial * (0.3 + 0.7 * aSeed.w);
+    float core = 1.0 - smoothstep(0.0, 0.35, grow);
+    float size = (0.007 + 0.009 * uThickness) * (0.7 + 0.8 * aSeed.z) * (1.0 + grow * 0.6);
+    if (p.y < 0.0) p.y = 0.0;
+    vec3 wc = (modelMatrix * vec4(p, 1.0)).xyz;
+    vP = wc; vA = born * (0.75 - 0.3 * grow); vCore = core;
+    gl_Position = billboard(wc, position.xy, size, 1.0 + core * 2.5, vel);
+}
+`;
+const DROP_FRAG = /* glsl */ `
+${GLSL_COMMON}
+uniform vec3 uWaterColor, uFoamColor, uCamPos;
+varying vec2 vUv; varying float vA; varying vec3 vP; varying float vCore;
+void main() {
+    vec2 d = vUv - 0.5; float r = length(d) * 2.0;
+    float a = smoothstep(1.0, 0.3, r) * vA;
+    if (a < 0.01) discard;
+    vec3 L = normalize(uSunDir); vec3 V = normalize(uCamPos - vP);
+    vec3 N = normalize(vec3(d * 2.0, sqrt(max(0.0, 1.0 - r * r))));
+    float glint = pow(max(dot(reflect(-L, N), V), 0.0), 30.0);
+    vec3 col = skyColor(reflect(-V, N)) * 0.7 + uFoamColor * (uSkyAmbient * 0.35 + uSunColor * 0.12) * (0.4 + 0.6 * vCore) + uSunColor * glint * 1.3;
+    gl_FragColor = vec4(col * a, a);
+    #include <colorspace_fragment>
+}
+`;
+// splash crowns at the landing points
+const SPLASH_VERT = /* glsl */ `
+${GLSL_COMMON}
+${GLSL_BILLBOARD}
+${GLSL_JET}
+attribute vec4 aSeed;
+varying vec2 vUv; varying float vA; varying vec3 vP; varying float vCore;
+void main() {
+    vUv = uv; vCore = 0.6;
+    int j = int(floor(aSeed.x * float(uJetCount)));
+    float T = uJetAux[j].y;
+    vec3 land, vel0, out_; vec2 nz;
+    jetAt(j, T, land, vel0, out_, nz);
+    land.y = 0.0;
+    float life = 0.3 + aSeed.z * 0.25;
+    float t = mod(aSeed.y * life * 4.0 + uTime, life);
+    float f = t / life;
+    float a0 = aSeed.w * 6.2832;
+    // the crown leans away from the incoming jet
+    vec2 away = normalize(vel0.xz) * 0.8;
+    vec3 vel = vec3(cos(a0) * (0.5 + aSeed.z * 1.4) + away.x, 1.6 + aSeed.z * 2.4, sin(a0) * (0.5 + aSeed.z * 1.4) + away.y);
+    vec3 p = land + vel * t + vec3(0.0, -4.9 * t * t, 0.0);
+    if (p.y < 0.0) p.y = 0.0;
+    vec3 wc = (modelMatrix * vec4(p, 1.0)).xyz;
+    vP = wc; vA = uSplash * (1.0 - f) * 0.8;
+    gl_Position = billboard(wc, position.xy, 0.006 + aSeed.z * 0.01, 1.5, vel + vec3(0.0, -9.81 * t, 0.0));
+}
+`;
+// ---------------------------------------------------------------------------- lathe sheets: the bell and the tier curtains
+/** A surface of revolution: profile(t) -> [r, y] for t in 0..1, uv = (angle, t). */
+function lathe(profile, around = 72, along = 40) {
+    const pos = [], uv = [], idx = [];
+    for (let i = 0; i <= along; i++) {
+        const t = i / along;
+        const [r, y] = profile(t);
+        for (let a = 0; a <= around; a++) {
+            const ang = (a / around) * Math.PI * 2;
+            pos.push(Math.cos(ang) * r, y, Math.sin(ang) * r);
+            uv.push(a / around, t);
+            if (i < along && a < around) {
+                const k = i * (around + 1) + a;
+                idx.push(k, k + around + 1, k + 1, k + 1, k + around + 1, k + around + 2);
+            }
+        }
+    }
+    const geo = new THREE.BufferGeometry();
+    geo.setAttribute('position', new THREE.Float32BufferAttribute(pos, 3));
+    geo.setAttribute('uv', new THREE.Float32BufferAttribute(uv, 2));
+    geo.setIndex(idx);
+    geo.computeVertexNormals();
+    geo.computeBoundingSphere();
+    return geo;
+}
+const SHEET_VERT = /* glsl */ `
+${GLSL_COMMON}
+uniform float uSheetTime;   // flight time of the whole sheet (s)
+varying vec2 vUv; varying vec3 vP; varying vec3 vN;
+void main() {
+    vUv = uv;
+    // a little sway growing with the fall
+    float sw = (vnoise21(vec2(uv.x * 10.0, uv.y * 3.0 - uTime * 1.2)) - 0.5) * 0.06 * uv.y;
+    vec3 p = position + normal * sw;
+    vP = (modelMatrix * vec4(p, 1.0)).xyz;
+    vN = normalize(mat3(modelMatrix) * normal);
+    gl_Position = projectionMatrix * viewMatrix * vec4(vP, 1.0);
+}
+`;
+// the bell: a smooth laminar sheet — glass, not ropes
+const BELL_FRAG = /* glsl */ `
+${GLSL_COMMON}
+uniform float uSheetTime, uSplash;
+uniform vec3 uWaterColor, uFoamColor, uCamPos;
+varying vec2 vUv; varying vec3 vP; varying vec3 vN;
+void main() {
+    float t = vUv.y;                                  // 0 at the nozzle, 1 at the rim
+    vec3 N = normalize(vN);
+    vec3 V = normalize(uCamPos - vP);
+    if (dot(N, V) < 0.0) N = -N;
+    // laminar sheet: faint ribs flowing outward, thinning toward the rim
+    float rib = vnoise21(vec2(vUv.x * 60.0, t * 6.0 - uTime * 2.5));
+    float rib2 = vnoise21(vec2(vUv.x * 140.0 + 3.0, t * 14.0 - uTime * 4.0));
+    N = normalize(N + vec3((rib - 0.5) * 0.12 + (rib2 - 0.5) * 0.08));
+    vec3 L = normalize(uSunDir);
+    float fres = fresnelWater(N, V);
+    vec3 skyR = skyColor(reflect(-V, N));
+    vec3 through = skyColor(refract(-V, N, 0.78)) * 0.8 * mix(vec3(1.0), uWaterColor, 0.25);
+    vec3 col = mix(through, skyR, fres) + uSunColor * ggx(N, L, V, 0.04) * fres * 2.5;
+    // the rim tears into lace as the sheet thins
+    float lace = smoothstep(0.85, 1.0, t) * smoothstep(0.45, 0.75, vnoise21(vec2(vUv.x * 90.0, t * 30.0 - uTime * 5.0)));
+    vec3 foamLit = uFoamColor * (uSkyAmbient * 0.5 + uSunColor * 0.25);
+    col = mix(col, foamLit, lace * 0.5);
+    float thickness = 1.0 - t * 0.55;                 // the sheet thins as it spreads
+    float a = (0.18 + 0.72 * fres) * thickness * (1.0 - smoothstep(0.92, 1.0, t) * (1.0 - lace));
+    gl_FragColor = vec4(col * a, a);
+    #include <colorspace_fragment>
+}
+`;
+// a tier curtain: a thin falling sheet off a rim — ropes by angle, aerating with the fall
+const CURTAIN_FRAG = /* glsl */ `
+${GLSL_COMMON}
+uniform float uSheetTime, uRimRadius, uSplash;
+uniform vec3 uWaterColor, uFoamColor, uCamPos;
+varying vec2 vUv; varying vec3 vP; varying vec3 vN;
+void main() {
+    float fall = vUv.y;
+    float tf = uSheetTime * sqrt(fall);
+    vec2 q = vec2(vUv.x * uRimRadius * 6.2832 / 0.12, (tf + uTime) * 3.0);
+    float ropes = fbm21(vec2(q.x, q.y * 0.12));
+    float ropes2 = vnoise21(vec2(q.x * 0.45 + 3.0, q.y * 0.06));
+    float dens = ropes * 0.7 + ropes2 * 0.35 + 0.1;
+    float cover = smoothstep(0.42, 0.62, dens);
+    if (cover < 0.02) discard;
+    float tau = cover * (0.08 + 0.6 * max(dens - 0.42, 0.0)) * (0.6 + fall * 1.2);
+    vec3 N = normalize(vN);
+    vec3 V = normalize(uCamPos - vP);
+    if (dot(N, V) < 0.0) N = -N;
+    float dsx = (fbm21(vec2(q.x + 0.12, q.y * 0.12)) - ropes) * 6.0;
+    N = normalize(N + cross(N, vec3(0.0, 1.0, 0.0)) * dsx * 0.5);
+    vec3 L = normalize(uSunDir);
+    float T = exp(-tau * 2.0);
+    vec3 skyR = skyColor(reflect(-V, N));
+    vec3 thin = mix(uWaterColor, vec3(0.8), 0.5) * (uSkyAmbient * 0.45 + uSunColor * 0.22) * 0.8 + skyR * 0.28;
+    vec3 thick = uFoamColor * (uSkyAmbient * 0.45 + uSunColor * (0.14 + 0.24 * max(dot(N, L), 0.0)));
+    vec3 col = mix(thick, thin, T);
+    float fres = fresnelWater(N, V);
+    col = mix(col, skyR, fres * 0.5 * T) + uSunColor * ggx(N, L, V, 0.12) * fres * 0.8;
+    float a = (1.0 - T * 0.6) * cover * 0.85;
+    gl_FragColor = vec4(col * a, a);
+    #include <colorspace_fragment>
+}
+`;
+function buildBell(u, c) {
+    const h0 = c.nozzleHeight, R = c.bellRadius, r0 = 0.08 + 0.05 * c.thickness;
+    // apex above the nozzle: a fraction of the radius (a bell is wider than it is tall)
+    const apex = Math.max(0.15, R * 0.35);
+    const vy = Math.sqrt(2 * G * apex);
+    const T = (vy + Math.sqrt(vy * vy + 2 * G * h0)) / G; // time to y = 0
+    const vr = (R - r0) / T;
+    const geo = lathe((t) => { const tt = t * T; return [r0 + vr * tt, h0 + vy * tt - 0.5 * G * tt * tt]; }, 96, 48);
+    const mat = new THREE.ShaderMaterial({ uniforms: { ...u, uSheetTime: { value: T } }, vertexShader: SHEET_VERT, fragmentShader: BELL_FRAG, side: THREE.DoubleSide, transparent: true, depthWrite: false, blending: THREE.CustomBlending, blendSrc: THREE.OneFactor, blendDst: THREE.OneMinusSrcAlphaFactor });
+    const m = new THREE.Mesh(geo, mat);
+    m.frustumCulled = false;
+    m.renderOrder = 4;
+    return m;
+}
+function buildTiers(u, c) {
+    const meshes = [], discs = [];
+    const n = Math.max(1, Math.round(c.tiers));
+    for (let i = 0; i < n; i++) {
+        const R = c.topRadius + i * c.spread, H = (n - i) * c.tierHeight;
+        // the bowl's water disc, with a churn ring where the tier above lands
+        const bu = createBasinUniforms();
+        const disc = createBasin(bu, R * 2, R * 2, 48, true);
+        disc.position.y = H;
+        bu.uDeepColor.value.set(c.basinColor);
+        bu.uFoamColor.value.set(c.foamColor);
+        bu.uRough.value = 0.04;
+        bu.uDetail.value = 0.35;
+        bu.uDetailSize.value = 0.2;
+        bu.uEdgeFade.value = 0.02;
+        applyBasinWind(bu, 0.4, 90, R * 2, 60);
+        if (i > 0) {
+            const Rp = c.topRadius + (i - 1) * c.spread + 0.2;
+            for (let j = 0; j < 20; j++) {
+                const a = (j / 20) * Math.PI * 2;
+                bu.uChurn.value[j].set(Math.cos(a) * Rp, Math.sin(a) * Rp, Rp * 0.14, 0.3 * c.splash);
+            }
+        }
+        meshes.push(disc);
+        discs.push(bu);
+        // the curtain off this rim down to the next disc (or the basin)
+        const drop = i < n - 1 ? c.tierHeight : H;
+        const T = Math.sqrt(2 * drop / G), throwV = 0.35 + 0.1 * c.thickness;
+        const geo = lathe((t) => { const tt = t * T; return [R + throwV * tt, H - 0.5 * G * tt * tt]; }, 96, 24);
+        const mat = new THREE.ShaderMaterial({ uniforms: { ...u, uSheetTime: { value: T }, uRimRadius: { value: R } }, vertexShader: SHEET_VERT, fragmentShader: CURTAIN_FRAG, side: THREE.DoubleSide, transparent: true, depthWrite: false, blending: THREE.CustomBlending, blendSrc: THREE.OneFactor, blendDst: THREE.OneMinusSrcAlphaFactor });
+        const m = new THREE.Mesh(geo, mat);
+        m.frustumCulled = false;
+        m.renderOrder = 4 + i;
+        meshes.push(m);
+    }
+    return { meshes, update: (dt, now) => { for (const bu of discs) {
+            bu.uTime.value = now;
+            bu.uCamPos.value.copy(u.uCamPos.value);
+            for (const k of ['uSunDir', 'uSunColor', 'uSkyAmbient', 'uGroundAmbient', 'uSkyTop', 'uSkyHorizon', 'uNight'])
+                bu[k].value = u[k].value;
+        } } };
+}
+function columnGeometry(nJets, breakup) {
+    // rings along the first (breakup * 1.2) of the flight; 10 around
+    const segs = 36, around = 10;
+    const pos = [], ring = [], jet = [], idx = [];
+    for (let j = 0; j < nJets; j++) {
+        const base = j * (segs + 1) * (around + 1);
+        for (let s = 0; s <= segs; s++) {
+            const f = (s / segs) * Math.min(breakup * 1.25, 1);
+            for (let a = 0; a <= around; a++) {
+                pos.push(0, 0, 0);
+                ring.push(f, a / around);
+                jet.push(j);
+                if (s < segs && a < around) {
+                    const k = base + s * (around + 1) + a;
+                    idx.push(k, k + around + 1, k + 1, k + 1, k + around + 1, k + around + 2);
+                }
+            }
+        }
+    }
+    const geo = new THREE.BufferGeometry();
+    geo.setAttribute('position', new THREE.Float32BufferAttribute(pos, 3));
+    geo.setAttribute('aRing', new THREE.Float32BufferAttribute(ring, 2));
+    geo.setAttribute('aJet', new THREE.Float32BufferAttribute(jet, 1));
+    geo.setIndex(idx);
+    geo.boundingSphere = new THREE.Sphere(new THREE.Vector3(), 1e5);
+    return geo;
+}
+export function build(u, cfg) {
+    const c = { ...cfg };
+    applyConfig(u, c);
+    layoutJets(u, c);
+    const group = new THREE.Group();
+    const parts = [];
+    const premul = { transparent: true, depthWrite: false, blending: THREE.CustomBlending, blendSrc: THREE.OneFactor, blendDst: THREE.OneMinusSrcAlphaFactor };
+    const rng = mulberry32(5);
+    const seed = () => [rng(), rng(), rng(), rng()];
+    const nJets = u.uJetCount.value;
+    const jetKind = ['jets', 'laminar', 'dancing', 'geyser'].includes(c.kind);
+    const extra = []; // kind-specific per-frame work
+    if (jetKind) {
+        const column = new THREE.Mesh(columnGeometry(nJets, 0.95), new THREE.ShaderMaterial({ uniforms: u, vertexShader: COLUMN_VERT, fragmentShader: COLUMN_FRAG, side: THREE.DoubleSide, ...premul }));
+        column.frustumCulled = false;
+        column.renderOrder = 4;
+        group.add(column);
+        parts.push(column);
+        if (c.kind !== 'laminar') {
+            const dropN = Math.round(360 * c.droplets * nJets * (0.5 + c.height / 6) * (c.kind === 'geyser' ? 5 : 1));
+            const drops = new THREE.Mesh(instancedQuads(dropN, seed), new THREE.ShaderMaterial({ uniforms: u, vertexShader: DROP_VERT, fragmentShader: DROP_FRAG, ...premul }));
+            drops.frustumCulled = false;
+            drops.renderOrder = 5;
+            const splash = new THREE.Mesh(instancedQuads(90 * nJets * (c.kind === 'geyser' ? 6 : 1), seed), new THREE.ShaderMaterial({ uniforms: u, vertexShader: SPLASH_VERT, fragmentShader: DROP_FRAG, ...premul }));
+            splash.frustumCulled = false;
+            splash.renderOrder = 5;
+            group.add(drops, splash);
+            parts.push(drops, splash);
+        }
+        if (c.kind === 'geyser') {
+            // the plume: mist around the collapsing top
+            const pw = c.height * 0.22 + 0.6;
+            const plume = createMistVolume(u, new THREE.Vector3(0, c.height * 0.92, 0), new THREE.Vector3(pw, pw * 1.5, pw), 12, 0.3, '#e4ebef');
+            plume.mesh.renderOrder = 6;
+            plume.u.uRise.value = 0.8;
+            group.add(plume.mesh);
+            parts.push(plume.mesh);
+        }
+    }
+    else if (c.kind === 'bell') {
+        const bell = buildBell(u, c);
+        group.add(bell);
+        parts.push(bell);
+    }
+    else if (c.kind === 'tiers') {
+        const t = buildTiers(u, c);
+        for (const m of t.meshes) {
+            group.add(m);
+            parts.push(m);
+        }
+        extra.push(t.update);
+    }
+    // basin: round, tiled floor through the water
+    const bu = createBasinUniforms();
+    const basin = createBasin(bu, c.basinSize, c.basinSize, 110, true);
+    bu.uDeepColor.value.set(c.basinColor);
+    bu.uFoamColor.value.set(c.foamColor);
+    bu.uRough.value = 0.03;
+    bu.uDetail.value = 0.3;
+    bu.uDetailSize.value = 0.3;
+    bu.uEdgeFade.value = 0.04;
+    bu.uFloor.value = c.floor ? 1 : 0;
+    bu.uFloorDepth.value = c.basinDepth;
+    bu.uFloorTile.value = c.tile;
+    bu.uRingSize.value.set(1.0, 1.6, 3.5);
+    applyBasinWind(bu, 0.5, 90, c.basinSize, 60);
+    group.add(basin);
+    parts.push(basin);
+    const spawn = ringSpawner(bu);
+    const nextRing = new Float32Array(MAX_JETS);
+    const landing = (j, now) => {
+        const J = u.uJets.value[j], A = u.uJetAux.value[j];
+        const spin = u.uSpin.value * now * 6.2832 / 60, ang = J.z + spin, range = J.w * Math.sin(A.x) * A.y;
+        const nx = Math.cos(spin) * J.x - Math.sin(spin) * J.y, nz = Math.sin(spin) * J.x + Math.cos(spin) * J.y;
+        return [nx + Math.cos(ang) * range, nz + Math.sin(ang) * range];
+    };
+    const setChurn = (now) => {
+        for (let j = 0; j < 24; j++)
+            bu.uChurn.value[j].set(0, 0, 0, 0);
+        if (jetKind) {
+            const r = (c.kind === 'geyser' ? 1.2 : 0.25) + 0.2 * c.thickness, st = (c.kind === 'laminar' ? 0.25 : 0.9) * c.splash;
+            for (let j = 0; j < nJets; j++) {
+                const [x, z] = landing(j, now);
+                bu.uChurn.value[j].set(x, z, r, st);
+            }
+        }
+        else if (c.kind === 'bell') {
+            for (let j = 0; j < 16; j++) {
+                const a = (j / 16) * Math.PI * 2;
+                bu.uChurn.value[j].set(Math.cos(a) * c.bellRadius, Math.sin(a) * c.bellRadius, c.bellRadius * 0.18, 0.22 * c.splash);
+            }
+        }
+        else if (c.kind === 'tiers') {
+            const R = c.topRadius + (c.tiers - 1) * c.spread + 0.3;
+            for (let j = 0; j < 20; j++) {
+                const a = (j / 20) * Math.PI * 2;
+                bu.uChurn.value[j].set(Math.cos(a) * R, Math.sin(a) * R, R * 0.16, 0.35 * c.splash);
+            }
+        }
+    };
+    setChurn(0);
+    return {
+        object: group,
+        apply(patch) {
+            Object.assign(c, patch);
+            applyConfig(u, patch);
+            if (patch.radius !== undefined || patch.height !== undefined || patch.tilt !== undefined)
+                layoutJets(u, c, u.uTime.value);
+            if (patch.basinColor)
+                bu.uDeepColor.value.set(patch.basinColor);
+            if (patch.foamColor)
+                bu.uFoamColor.value.set(patch.foamColor);
+            if (patch.basinDepth !== undefined)
+                bu.uFloorDepth.value = c.basinDepth;
+            if (patch.tile !== undefined)
+                bu.uFloorTile.value = c.tile;
+            if (patch.floor !== undefined)
+                bu.uFloor.value = c.floor ? 1 : 0;
+        },
+        update(dt, camera) {
+            u.uTime.value += dt;
+            bu.uTime.value = u.uTime.value;
+            u.uCamPos.value.copy(camera.position);
+            bu.uCamPos.value.copy(camera.position);
+            for (const k of ['uSunDir', 'uSunColor', 'uSkyAmbient', 'uGroundAmbient', 'uSkyTop', 'uSkyHorizon', 'uNight'])
+                bu[k].value = u[k].value;
+            const now = u.uTime.value;
+            if (c.kind === 'dancing' || c.kind === 'geyser')
+                layoutJets(u, c, now);
+            setChurn(now);
+            for (const f of extra)
+                f(dt, now);
+            if (jetKind)
+                for (let j = 0; j < nJets; j++) {
+                    if (now < nextRing[j])
+                        continue;
+                    nextRing[j] = now + 0.22 + 0.12 * Math.random();
+                    const [x, z] = landing(j, now);
+                    spawn(x, z, (c.kind === 'laminar' ? 0.004 : 0.01) * c.splash * (0.5 + c.thickness * 0.5), now);
+                }
+        },
+        dispose() { for (const p of parts) {
+            p.geometry.dispose();
+            p.material.dispose();
+        } },
+    };
+}

package/dist/components/water/core/stream.d.ts

@@ -0,0 +1,72 @@
+import * as THREE from 'three';
+export declare const STRUCTURAL: string[];
+export declare function createUniforms(): {
+    uWidth: {
+        value: number;
+    };
+    uSpeed: {
+        value: number;
+    };
+    uTurb: {
+        value: number;
+    };
+    uFoam: {
+        value: number;
+    };
+    uRipple: {
+        value: number;
+    };
+    uWaterColor: {
+        value: THREE.Color;
+    };
+    uFoamColor: {
+        value: THREE.Color;
+    };
+    uAbsorb: {
+        value: THREE.Vector3;
+    };
+    uCamPos: {
+        value: THREE.Vector3;
+    };
+    uRings: {
+        value: THREE.Vector4[];
+    };
+    uRingSize: {
+        value: THREE.Vector3;
+    };
+    uChurn: {
+        value: THREE.Vector4[];
+    };
+    uSunDir: {
+        value: THREE.Vector3;
+    };
+    uSunColor: {
+        value: THREE.Color;
+    };
+    uSkyAmbient: {
+        value: THREE.Color;
+    };
+    uGroundAmbient: {
+        value: THREE.Color;
+    };
+    uSkyTop: {
+        value: THREE.Color;
+    };
+    uSkyHorizon: {
+        value: THREE.Color;
+    };
+    uNight: {
+        value: number;
+    };
+    uTime: {
+        value: number;
+    };
+};
+export declare function applyConfig(u: any, c: any): void;
+export declare function build(u: any, cfg: any): {
+    object: THREE.Group<THREE.Object3DEventMap>;
+    apply(patch: any): void;
+    update(dt: any, camera: any): void;
+    dispose(): void;
+};
+//# sourceMappingURL=stream.d.ts.map