@3driseai/3drise-viewer 0.1.41 → 0.1.43

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

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../../src/components/water/core/stream.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,eAAO,MAAM,UAAU,UAAiD,CAAC;AAEzE,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQ7B;AACD,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,QAQ/B;AA4FD,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,GAAG,KAAA;;;;;EA0B3B"}

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

@@ -0,0 +1,167 @@
+// Emitted from Claude outputs/water-lab/stream.mjs by gen_family.mjs — edit the lab module and re-emit.
+// water/core/stream — Stream (type 'water', config.type 'stream'). Shared core: ../waterCore. flowing water along a path, in its own channel.
+//
+// Construction: only the water. A ribbon swept along a Catmull-Rom curve through `points`,
+// drawn transparent over whatever the user put under it (their riverbed mesh, terrain, a
+// channel model): per-vertex channel depth (a parabolic cross-section, deepest mid-stream)
+// gives Beer–Lambert absorption, so the edges are clear and the middle turns green-blue and
+// opaque; Fresnel adds the sky; the flow comes from advecting the ripple normals along the
+// channel with an open-channel velocity profile (fast mid-stream, slow at the banks). Foam:
+// lace along the banks, more on the outer side of bends (faster, deeper). `rocks` marks
+// hashed spots where something breaks the surface: a boiling collar and a wake downstream.
+import * as THREE from 'three';
+import { GLSL_COMMON, GLSL_DISTURB, createSunUniforms, createDisturbanceUniforms, samplePath, mulberry32 } from '../waterCore.js';
+export const STRUCTURAL = ['points', 'width', 'depth', 'curve', 'rocks'];
+export function createUniforms() {
+    return {
+        ...createSunUniforms(), ...createDisturbanceUniforms(),
+        uWidth: { value: 4.5 }, uSpeed: { value: 1.2 }, uTurb: { value: 0.6 }, uFoam: { value: 0.8 }, uRipple: { value: 0.35 },
+        uWaterColor: { value: new THREE.Color('#2a6f6a') }, uFoamColor: { value: new THREE.Color('#eef6f8') },
+        uAbsorb: { value: new THREE.Vector3(0.9, 0.32, 0.22) },
+        uCamPos: { value: new THREE.Vector3() },
+    };
+}
+export function applyConfig(u, c) {
+    if (c.width !== undefined)
+        u.uWidth.value = c.width;
+    if (c.speed !== undefined)
+        u.uSpeed.value = c.speed;
+    if (c.turbulence !== undefined)
+        u.uTurb.value = c.turbulence;
+    if (c.foam !== undefined)
+        u.uFoam.value = c.foam;
+    if (c.rippleSize !== undefined)
+        u.uRipple.value = c.rippleSize;
+    if (c.waterColor !== undefined)
+        u.uWaterColor.value.set(c.waterColor);
+    if (c.foamColor !== undefined)
+        u.uFoamColor.value.set(c.foamColor);
+}
+// ---------------------------------------------------------------------------- water
+const WATER_VERT = /* glsl */ `
+${GLSL_COMMON}
+${GLSL_DISTURB}
+attribute vec3 aFlow;   // u (m along), s (-1..1), curvature
+attribute vec3 aTan;
+attribute float aDepth;
+uniform float uWidth, uSpeed;
+varying vec3 vP; varying vec3 vFlow; varying vec3 vTan; varying float vDepth; varying vec2 vLocal; varying float vChurn;
+void main() {
+    vec3 p = position;
+    vec2 ch = churnField(p.xz, uTime);
+    // standing ripples over the rocks (the churn centres)
+    p.y += ch.y * 0.05;
+    vP = (modelMatrix * vec4(p, 1.0)).xyz;
+    vFlow = aFlow; vTan = normalize(mat3(modelMatrix) * aTan); vDepth = aDepth; vLocal = position.xz; vChurn = ch.x;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(p, 1.0);
+}
+`;
+const WATER_FRAG = /* glsl */ `
+${GLSL_COMMON}
+${GLSL_DISTURB}
+uniform float uWidth, uSpeed, uTurb, uFoam, uRipple;
+uniform vec3 uWaterColor, uFoamColor, uAbsorb, uCamPos;
+varying vec3 vP; varying vec3 vFlow; varying vec3 vTan; varying float vDepth; varying vec2 vLocal; varying float vChurn;
+void main() {
+    float u = vFlow.x, s = vFlow.y, curv = vFlow.z;
+    float prof = 1.0 - 0.75 * s * s;                 // open-channel velocity profile
+    float adv = u - uTime * uSpeed * prof;
+    // ripples stretched downstream, two scales, advected; the churn adds boil
+    vec2 q = vec2(s * uWidth * 0.5, adv) / uRipple;
+    vec3 n1 = noised21(vec2(q.x * 1.5, q.y * 0.4), 0.04);
+    vec3 n2 = noised21(vec2(q.x * 3.2, q.y * 1.0) + 7.0, 0.04);
+    vec3 n3 = noised21(vec2(q.x * 7.0, q.y * 2.5) + 13.0, 0.04);
+    vec2 dn = (n1.yz * 0.9 + n2.yz * 0.6 + n3.yz * 0.3) * (0.3 + uTurb) * 2.0 * (0.5 + 0.5 * prof);
+    vec2 chb = churnField(vLocal, uTime);
+    vec3 up = vec3(0.0, 1.0, 0.0);
+    vec3 bin = normalize(cross(up, vTan));
+    vec3 N = normalize(up - bin * dn.x - vTan * dn.y + (bin * (chb.y - 0.5)) * vChurn * 1.5);
+    vec3 V = normalize(uCamPos - vP);
+    vec3 L = normalize(uSunDir);
+    // what the water adds over the bed: Beer-Lambert over the depth (a view at a slant sees ~2x the depth)
+    float pathLen = vDepth * (1.0 + 1.0 / max(V.y, 0.25) * 0.5);
+    vec3 T = exp(-uAbsorb * pathLen);
+    vec3 body = uWaterColor * (uSkyAmbient * 0.6 + uSunColor * 0.35);
+    float fres = fresnelWater(N, V);
+    vec3 R = reflect(-V, N); R.y = max(R.y, 0.02);
+    vec3 sky = skyColor(R);
+    float spec = ggx(N, L, V, 0.06 + uTurb * 0.06) * 1.2;
+    // foam
+    float bank = smoothstep(0.88, 1.0, abs(s)) * smoothstep(0.45, 0.85, fbm21(vec2(adv * 2.5, s * 6.0))) * 0.6;
+    float bend = clamp(curv * s * uWidth * 1.2, 0.0, 1.0) * smoothstep(0.1, 0.9, abs(s));
+    float lace = smoothstep(0.45, 0.8, fbm21(vec2(adv * 3.0, s * 7.0)) * 0.7 + vnoise21(vec2(adv * 9.0, s * 20.0)) * 0.5);
+    float foam = clamp((bank + bend * 0.6 * lace + vChurn * 1.2) * uFoam, 0.0, 1.0);
+    vec3 foamLit = uFoamColor * (uSkyAmbient * 0.6 + uSunColor * (0.3 + 0.5 * max(dot(N, L), 0.0)));
+    // premultiplied: reflection + scattered body (where the bed is absorbed) + foam, over the bed drawn underneath
+    vec3 col = sky * fres + body * (1.0 - T) * (1.0 - fres) + uSunColor * spec * fres;
+    float alpha = fres + (1.0 - fres) * (1.0 - dot(T, vec3(0.333)));
+    col = mix(col, foamLit, foam); alpha = mix(alpha, 1.0, foam);
+    // the wetted edge: fade the last few cm so the surface meets the bank softly
+    float edge = smoothstep(1.0, 0.96, abs(s));
+    gl_FragColor = vec4(col * alpha * edge, alpha * edge);
+    #include <colorspace_fragment>
+}
+`;
+function channel(c) {
+    const { samples } = samplePath(c.points, c.curve, false, 0.6);
+    const halfW = c.width / 2;
+    const n = samples.length;
+    const depthAt = (s, u) => c.depth * Math.sqrt(Math.max(1 - s * s, 0)) * (0.8 + 0.4 * Math.abs(Math.sin(u * 0.35) * 0.5 + Math.sin(u * 0.11 + 2.0) * 0.5));
+    // water: across the water only, at y = 0, with the depth under each vertex
+    const wa = 10;
+    const wpos = [], wflow = [], wtan = [], wdep = [], widx = [];
+    for (let i = 0; i < n; i++) {
+        const sm = samples[i];
+        const nx = -sm.t.z, nz = sm.t.x;
+        for (let j = 0; j <= wa; j++) {
+            const s = (j / wa) * 2 - 1;
+            wpos.push(sm.p.x + nx * s * halfW, 0, sm.p.z + nz * s * halfW);
+            wflow.push(sm.u, s, sm.curv);
+            wtan.push(sm.t.x, 0, sm.t.z);
+            wdep.push(depthAt(s, sm.u));
+            if (i < n - 1 && j < wa) {
+                const a = i * (wa + 1) + j, b = a + 1, cc = a + wa + 1, d = cc + 1;
+                widx.push(a, cc, b, b, cc, d);
+            }
+        }
+    }
+    const water = new THREE.BufferGeometry();
+    water.setAttribute('position', new THREE.Float32BufferAttribute(wpos, 3));
+    water.setAttribute('aFlow', new THREE.Float32BufferAttribute(wflow, 3));
+    water.setAttribute('aTan', new THREE.Float32BufferAttribute(wtan, 3));
+    water.setAttribute('aDepth', new THREE.Float32BufferAttribute(wdep, 1));
+    water.setIndex(widx);
+    water.computeBoundingSphere();
+    return { water, samples, halfW, depthAt };
+}
+export function build(u, cfg) {
+    const c = { ...cfg };
+    applyConfig(u, c);
+    const group = new THREE.Group();
+    const parts = [];
+    const ch = channel(c);
+    const water = new THREE.Mesh(ch.water, new THREE.ShaderMaterial({ uniforms: u, vertexShader: WATER_VERT, fragmentShader: WATER_FRAG, side: THREE.DoubleSide, transparent: true, depthWrite: false, blending: THREE.CustomBlending, blendSrc: THREE.OneFactor, blendDst: THREE.OneMinusSrcAlphaFactor }));
+    water.renderOrder = 3;
+    water.frustumCulled = false;
+    group.add(water);
+    parts.push(water);
+    // things breaking the surface (the user's rocks): a boiling collar at hashed spots
+    const rng = mulberry32(13);
+    for (let i = 0; i < 24; i++)
+        u.uChurn.value[i].set(0, 0, 0, 0);
+    const nRocks = Math.min(20, Math.round(c.rocks));
+    for (let i = 0; i < nRocks; i++) {
+        const sm = ch.samples[Math.floor((0.1 + 0.8 * rng()) * ch.samples.length)];
+        const s = (rng() - 0.5) * 1.4;
+        const r = 0.3 + rng() * 0.5 * Math.min(1, c.width / 4);
+        const nx = -sm.t.z, nz = sm.t.x;
+        u.uChurn.value[i].set(sm.p.x + nx * s * ch.halfW, sm.p.z + nz * s * ch.halfW, r * 1.6, 0.9 * c.foam);
+    }
+    return {
+        object: group,
+        apply(patch) { Object.assign(c, patch); applyConfig(u, patch); },
+        update(dt, camera) { u.uTime.value += dt; u.uCamPos.value.copy(camera.position); },
+        dispose() { for (const p of parts)
+            p.geometry.dispose(); water.material.dispose(); },
+    };
+}

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

@@ -0,0 +1,78 @@
+import * as THREE from 'three';
+export declare const STRUCTURAL: string[];
+export declare function createUniforms(): {
+    uWidth: {
+        value: number;
+    };
+    uDrop: {
+        value: number;
+    };
+    uThrow: {
+        value: number;
+    };
+    uFlow: {
+        value: number;
+    };
+    uVolume: {
+        value: number;
+    };
+    uAeration: {
+        value: number;
+    };
+    uSurges: {
+        value: number;
+    };
+    uTurb: {
+        value: number;
+    };
+    uMist: {
+        value: number;
+    };
+    uSpray: {
+        value: number;
+    };
+    uOpacity: {
+        value: number;
+    };
+    uWaterColor: {
+        value: THREE.Color;
+    };
+    uFoamColor: {
+        value: THREE.Color;
+    };
+    uCamPos: {
+        value: THREE.Vector3;
+    };
+    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=waterfall.d.ts.map

package/dist/components/water/core/waterfall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"waterfall.d.ts","sourceRoot":"","sources":["../../../../src/components/water/core/waterfall.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,eAAO,MAAM,UAAU,UAAiC,CAAC;AAEzD,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS7B;AACD,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,QAc/B;AA0KD,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,GAAG,KAAA;;;;;EAgE3B"}

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

@@ -0,0 +1,325 @@
+// Emitted from Claude outputs/water-lab/waterfall.mjs by gen_family.mjs — edit the lab module and re-emit.
+// water/core/waterfall — Waterfall (type 'water', config.type 'waterfall'). Shared core: ../waterCore. an aerated sheet of falling water, the plunge pool, the mist.
+//
+// Construction (second pass — the first was a flat curtain with stripes):
+//
+// SHEET. Three grids stacked in depth (back / mid / front, each with its own seed and a
+// slightly different flow phase) so the fall has parallax and body. Each vertex follows free
+// fall from the lip — z = throw·sqrt(fall), horizontal at the lip, vertical at the foot — and
+// sways with slow noise that grows with the fall. The fragment stage treats the water as a
+// THICKNESS field τ: ropes (noise stretched along the fall, advected by FALL TIME so streaks
+// lengthen as the water accelerates), surges (slow pulses travelling down the fall), and
+// fluting (fine horizontal bands). Light is Beer–Lambert through τ: thin water transmits the
+// sky/background tinted by the water colour; thick water scatters white, with forward
+// scattering when the sun is behind the sheet. Aeration (whiteness) grows with the square of
+// the fall; the top 15% is a glassy tongue with real Fresnel sky reflection and a sun glint.
+// The sheet fades into the mist in its last metres.
+//
+// POOL. The basin with CHURN zones along the landing line: boiling foam that radiates away
+// as streaks (polar noise moving outward) and roughens the normal, over the body's ripples.
+//
+// MIST. A real volume: view-aligned slices through drifting, rising 3D noise, dense at the
+// foot and thinning upward and outward, lit by the sky with sun forward-scatter. A thinner
+// haze hugs the whole sheet. SPRAY: instanced droplets flung off the sheet edges and
+// bouncing up out of the churn. Sized by the transform in the app (x = width, y = drop).
+import * as THREE from 'three';
+import { GLSL_COMMON, GLSL_BILLBOARD, createSunUniforms, createBasinUniforms, createBasin, applyBasinWind, instancedQuads, mulberry32, createMistVolume } from '../waterCore.js';
+export const STRUCTURAL = ['width', 'drop', 'poolDepth'];
+export function createUniforms() {
+    return {
+        ...createSunUniforms(),
+        uWidth: { value: 7 }, uDrop: { value: 10 }, uThrow: { value: 1.8 },
+        uFlow: { value: 1 }, uVolume: { value: 0.6 }, uAeration: { value: 1 }, uSurges: { value: 0.6 }, uTurb: { value: 0.6 },
+        uMist: { value: 1 }, uSpray: { value: 0.7 }, uOpacity: { value: 0.85 },
+        uWaterColor: { value: new THREE.Color('#2a8a9c') }, uFoamColor: { value: new THREE.Color('#f1f6f8') },
+        uCamPos: { value: new THREE.Vector3() },
+    };
+}
+export function applyConfig(u, c) {
+    if (c.width !== undefined)
+        u.uWidth.value = c.width;
+    if (c.drop !== undefined)
+        u.uDrop.value = c.drop;
+    if (c.throw !== undefined)
+        u.uThrow.value = c.throw;
+    if (c.flow !== undefined)
+        u.uFlow.value = c.flow;
+    if (c.volume !== undefined)
+        u.uVolume.value = c.volume;
+    if (c.aeration !== undefined)
+        u.uAeration.value = c.aeration;
+    if (c.surges !== undefined)
+        u.uSurges.value = c.surges;
+    if (c.turbulence !== undefined)
+        u.uTurb.value = c.turbulence;
+    if (c.mist !== undefined)
+        u.uMist.value = c.mist;
+    if (c.spray !== undefined)
+        u.uSpray.value = c.spray;
+    if (c.opacity !== undefined)
+        u.uOpacity.value = c.opacity;
+    if (c.waterColor !== undefined)
+        u.uWaterColor.value.set(c.waterColor);
+    if (c.foamColor !== undefined)
+        u.uFoamColor.value.set(c.foamColor);
+}
+// ---------------------------------------------------------------------------- the sheet
+const SHEET_VERT = /* glsl */ `
+${GLSL_COMMON}
+uniform float uWidth, uDrop, uThrow, uTurb, uFlow, uLayer;
+varying vec2 vUv; varying vec3 vP; varying vec3 vN; varying float vFall; varying float vTf;
+void main() {
+    vUv = uv;
+    float fall = 1.0 - uv.y;                                  // 0 at the lip, 1 at the foot
+    float tf = sqrt(2.0 * uDrop * max(fall, 0.0) / 9.81);     // fall time
+    vTf = tf; vFall = fall;
+    // free fall from the lip; each layer a little deeper into the fall
+    float z = uThrow * sqrt(fall) + uLayer * (0.12 + 0.05 * uThrow);
+    // sway: slow noise travelling with the water, growing with the fall
+    float sw = (vnoise21(vec2(uv.x * 2.5 + uLayer * 3.0, tf * 1.1 - uTime * uFlow * 0.7)) - 0.5) * uTurb * (0.1 + 0.9 * fall);
+    vec3 p = vec3(position.x + sw * 0.7, position.y, z + sw * 0.5);
+    vec4 wp = modelMatrix * vec4(p, 1.0);
+    vP = wp.xyz;
+    // parabola normal (dz/dy) — flat at the lip, facing forward lower down
+    float dzdy = uThrow * 0.5 / max(sqrt(fall), 0.08) / uDrop;
+    vN = normalize(mat3(modelMatrix) * normalize(vec3(0.0, dzdy, 1.0)));
+    gl_Position = projectionMatrix * viewMatrix * wp;
+}
+`;
+const SHEET_FRAG = /* glsl */ `
+${GLSL_COMMON}
+uniform float uWidth, uDrop, uFlow, uVolume, uAeration, uSurges, uTurb, uOpacity, uLayer;
+uniform vec3 uWaterColor, uFoamColor, uCamPos;
+varying vec2 vUv; varying vec3 vP; varying vec3 vN; varying float vFall; varying float vTf;
+void main() {
+    float fall = vFall, tf = vTf;
+    float seed = uLayer * 17.3;
+    // --- thickness field ---------------------------------------------------------
+    // ropes: noise narrow across (stream width ~0.3 m) and long along the fall, advected by fall time
+    float rope = 0.3;
+    vec2 q = vec2(vUv.x * uWidth / rope + seed, (tf + uTime * 0.85) * uFlow * 2.4);
+    float ropes = fbm21(vec2(q.x, q.y * 0.08));
+    float ropes2 = vnoise21(vec2(q.x * 0.5 + 3.0, q.y * 0.05) + seed) ;
+    // surges: slow pulses travelling down the whole fall
+    float surge = 0.5 + 0.5 * sin((tf * 1.6 - uTime * uFlow * 1.1) * 2.0 + vnoise21(vec2(vUv.x * 2.0, tf * 0.5) + seed) * 3.0);
+    // fluting: fine horizontal bands moving down fast
+    float flute = vnoise21(vec2(vUv.x * uWidth * 1.5, (tf + uTime * 1.2) * uFlow * 9.0) + seed);
+    // tearing: the ropes break up with turbulence
+    float tear = vnoise21(vec2(q.x * 1.7, q.y * 0.25) + 31.0 + seed) * uTurb;
+    float side = smoothstep(0.0, 0.1, vUv.x) * smoothstep(1.0, 0.9, vUv.x);
+    float dens = ropes * 0.75 + ropes2 * 0.35 + (surge - 0.5) * 0.35 * uSurges + (flute - 0.5) * 0.12 - tear * 0.25
+               + (uVolume - 0.5) * 1.1 - uLayer * 0.18;      // the front layers are sparser
+    dens *= 0.55 + 0.45 * side;
+    float cover = smoothstep(0.30, 0.62, dens);              // water vs air
+    if (cover < 0.01) discard;
+    // thickness in metres-ish: ropes are thick, lace is thin; aeration adds opacity with the fall
+    float tau = cover * (0.08 + 1.2 * max(dens - 0.3, 0.0)) * (1.0 + fall * fall * 2.5 * uAeration);
+    // --- light ----------------------------------------------------------------------
+    vec3 N = normalize(vN);
+    float dsx = (fbm21(vec2(q.x + 0.12, q.y * 0.08)) - ropes) * 8.0;
+    float dsy = (flute - vnoise21(vec2(vUv.x * uWidth * 1.5, (tf + uTime * 1.2) * uFlow * 9.0 + 0.1) + seed)) * 2.0;
+    N = normalize(N + vec3(-dsx, dsy * 0.6, 0.0) * (0.3 + 0.7 * fall));
+    vec3 V = normalize(uCamPos - vP);
+    vec3 L = normalize(uSunDir);
+    float NdotL = max(dot(N, L), 0.0);
+    // transmission (thin water) vs scattering (thick / aerated water)
+    float T = exp(-tau * 2.2);
+    vec3 skyR = skyColor(reflect(-V, N));
+    vec3 thin = mix(uWaterColor, vec3(0.75), 0.55) * (uSkyAmbient * 0.45 + uSunColor * 0.22) * 0.8 + skyR * 0.28;
+    float fwd = pow(max(dot(-V, L), 0.0), 2.0);
+    // thick water: white scattering, kept under 1 at noon (NoToneMapping in the app)
+    vec3 thick = uFoamColor * (uSkyAmbient * 0.45 + uSunColor * (0.13 + 0.22 * NdotL + 0.18 * fwd));
+    vec3 col = mix(thick, thin, T);
+    // glassy tongue at the lip: real reflection + glint
+    float glassy = 1.0 - smoothstep(0.0, 0.18, fall);
+    float fres = fresnelWater(N, V);
+    col = mix(col, mix(col, skyR, fres * 0.8) + uSunColor * ggx(N, L, V, 0.08) * fres * 1.2, glassy);
+    // sun glitter on the whole sheet, broken by the ropes
+    col += uSunColor * ggx(N, L, V, 0.25) * 0.25 * (1.0 - T) * (0.5 + 0.5 * ropes);
+    col = min(col, vec3(0.98));
+    float alpha = (1.0 - T * (1.0 - uOpacity * 0.6)) * cover;
+    alpha *= 1.0 - smoothstep(0.9, 1.0, fall) * 0.8;        // dissolve into the mist at the foot
+    gl_FragColor = vec4(col * alpha, alpha);
+    #include <colorspace_fragment>
+}
+`;
+// the lip: a short glassy run-up over the edge, flowing toward the fall
+const LIP_VERT = /* glsl */ `
+${GLSL_COMMON}
+varying vec2 vUv; varying vec3 vP; varying vec3 vN;
+void main() {
+    vUv = uv;
+    vec3 p = position;
+    // round over the edge: the last 25% dips into the parabola
+    float t = smoothstep(0.75, 1.0, uv.y);
+    p.y -= t * t * 0.35;
+    vec4 wp = modelMatrix * vec4(p, 1.0); vP = wp.xyz;
+    vN = normalize(mat3(modelMatrix) * normalize(vec3(0.0, 1.0, t * 0.9)));
+    gl_Position = projectionMatrix * viewMatrix * wp;
+}
+`;
+const LIP_FRAG = /* glsl */ `
+${GLSL_COMMON}
+uniform float uWidth, uFlow, uVolume;
+uniform vec3 uWaterColor, uFoamColor, uCamPos;
+varying vec2 vUv; varying vec3 vP; varying vec3 vN;
+void main() {
+    vec2 q = vec2(vUv.x * uWidth / 0.3, vUv.y * 6.0 - uTime * uFlow * 4.0);
+    vec3 n1 = noised21(q * vec2(1.0, 0.35), 0.05);
+    vec3 n2 = noised21(q * vec2(2.2, 0.8) + 9.0, 0.05);
+    vec3 N = normalize(normalize(vN) + vec3(-(n1.y + n2.y * 0.6) * 1.5, 0.0, -(n1.z + n2.z * 0.6) * 0.6));
+    float foam = smoothstep(0.6, 0.85, fbm21(q * vec2(1.5, 0.5) + 4.0)) * 0.5 + smoothstep(0.75, 1.0, vUv.y) * 0.5;
+    vec3 body = uWaterColor * 0.6;
+    vec3 col = shadeWater(vP, N, uCamPos, body, uFoamColor, foam * 0.6, 0.05, 1.5);
+    float a = smoothstep(0.0, 0.25, vUv.y) * (0.6 + 0.4 * uVolume);
+    gl_FragColor = vec4(col * a, a);
+    #include <colorspace_fragment>
+}
+`;
+// ---------------------------------------------------------------------------- spray
+const SPRAY_VERT = /* glsl */ `
+${GLSL_COMMON}
+${GLSL_BILLBOARD}
+attribute vec4 aSeed;
+uniform float uWidth, uDrop, uThrow, uFlow, uSpray;
+varying vec2 vUv; varying float vA; varying vec3 vP; varying vec3 vVel;
+void main() {
+    vUv = uv;
+    vec3 c; vec3 vel; float life, t;
+    if (aSeed.x < 0.55) {
+        // off the sheet edges and face, falling with it
+        life = 0.4 + aSeed.z * 0.5;
+        t = mod(uTime * 1.1 + aSeed.w * 10.0, life);
+        float v0 = 0.1 + aSeed.y * 0.85;
+        float edge = aSeed.x < 0.25 ? -1.0 : (aSeed.x < 0.4 ? 1.0 : 0.0);
+        float x0 = edge == 0.0 ? (aSeed.y - 0.5) * uWidth : edge * uWidth * (0.5 + aSeed.z * 0.04);
+        float y0 = v0 * uDrop;
+        float vy = -sqrt(2.0 * 9.81 * (uDrop - y0)) * 0.5;
+        vel = vec3((edge == 0.0 ? (hash11(aSeed.w * 7.0) - 0.5) * 2.0 : edge) * (0.3 + aSeed.z * 1.2), vy, 0.6 + aSeed.w * 1.4);
+        c = vec3(x0, y0, uThrow * sqrt(1.0 - v0) + 0.2) + vel * t + vec3(0.0, -4.9 * t * t, 0.0);
+    } else {
+        // bouncing up out of the churn at the foot
+        life = 0.5 + aSeed.z * 0.4;
+        t = mod(uTime * 1.3 + aSeed.w * 10.0, life);
+        float x0 = (aSeed.y - 0.5) * uWidth * 1.05;
+        float a0 = aSeed.w * 6.2832;
+        vel = vec3(cos(a0) * (0.5 + aSeed.z * 2.5), 2.5 + aSeed.z * 4.5, sin(a0) * (0.5 + aSeed.z * 2.5) + 1.0);
+        c = vec3(x0, 0.05, uThrow + 0.3 + (aSeed.x - 0.55) * 2.0) + vel * t + vec3(0.0, -4.9 * t * t, 0.0);
+    }
+    vVel = vel + vec3(0.0, -9.81 * t, 0.0);
+    if (c.y < 0.03) c.y = 0.03;
+    vec3 wc = (modelMatrix * vec4(c, 1.0)).xyz;
+    vP = wc; vA = uSpray * 0.9 * (1.0 - t / life);
+    gl_Position = billboard(wc, position.xy, 0.012 + aSeed.z * 0.022, 2.0, vVel);
+}
+`;
+const SPRAY_FRAG = /* glsl */ `
+${GLSL_COMMON}
+uniform vec3 uFoamColor, uCamPos;
+varying vec2 vUv; varying float vA; varying vec3 vP; varying vec3 vVel;
+void main() {
+    vec2 d = vUv - 0.5; float r = length(d) * 2.0;
+    float a = smoothstep(1.0, 0.35, r) * vA;
+    if (a < 0.01) discard;
+    vec3 V = normalize(uCamPos - vP); vec3 L = normalize(uSunDir);
+    vec3 N = normalize(vec3(d * 2.0, sqrt(max(0.0, 1.0 - r * r))));
+    vec3 col = skyColor(reflect(-V, N)) * 0.8 + uFoamColor * uSkyAmbient * 0.3 + uSunColor * pow(max(dot(reflect(-L, N), V), 0.0), 20.0) * 1.2;
+    gl_FragColor = vec4(col * a, a);
+    #include <colorspace_fragment>
+}
+`;
+export function build(u, cfg) {
+    const c = { ...cfg };
+    applyConfig(u, c);
+    const group = new THREE.Group();
+    const parts = [];
+    const premul = { transparent: true, depthWrite: false, blending: THREE.CustomBlending, blendSrc: THREE.OneFactor, blendDst: THREE.OneMinusSrcAlphaFactor };
+    // sheet: three layers, back to front
+    const sheetGeo = new THREE.PlaneGeometry(c.width, c.drop, Math.max(8, Math.round(c.width * 4)), Math.max(24, Math.round(c.drop * 8)));
+    sheetGeo.translate(0, c.drop / 2, 0);
+    for (let layer = 0; layer < 3; layer++) {
+        const m = new THREE.ShaderMaterial({ uniforms: { ...u, uLayer: { value: layer } }, vertexShader: SHEET_VERT, fragmentShader: SHEET_FRAG, side: THREE.DoubleSide, ...premul });
+        const mesh = new THREE.Mesh(sheetGeo, m);
+        mesh.frustumCulled = false;
+        mesh.renderOrder = 10 + layer;
+        group.add(mesh);
+        parts.push(mesh);
+    }
+    // lip run-up
+    const lipGeo = new THREE.PlaneGeometry(c.width, 1.6, Math.max(8, Math.round(c.width * 3)), 12);
+    lipGeo.rotateX(-Math.PI / 2);
+    lipGeo.translate(0, c.drop + 0.02, -0.8);
+    const lip = new THREE.Mesh(lipGeo, new THREE.ShaderMaterial({ uniforms: u, vertexShader: LIP_VERT, fragmentShader: LIP_FRAG, side: THREE.DoubleSide, ...premul }));
+    lip.renderOrder = 9;
+    group.add(lip);
+    parts.push(lip);
+    // plunge pool
+    const bu = createBasinUniforms();
+    const poolW = c.width * 2.0, poolD = c.poolDepth;
+    const pool = createBasin(bu, poolW, poolD, 110);
+    pool.position.set(0, 0, poolD / 2 - 0.8);
+    bu.uDeepColor.value.set(c.waterColor).multiplyScalar(0.22);
+    bu.uShallowColor.value.set(c.waterColor).multiplyScalar(0.5);
+    bu.uFoamColor.value.set(c.foamColor);
+    bu.uRough.value = 0.07;
+    bu.uDetail.value = 0.7;
+    bu.uDetailSize.value = 0.3;
+    bu.uEdgeFade.value = 0.08;
+    applyBasinWind(bu, 1.8, 180, poolW, 55);
+    const nCh = Math.min(4, Math.max(1, Math.round(c.width / 2.5)));
+    const setChurn = () => { for (let i = 0; i < 4; i++) {
+        if (i < nCh)
+            bu.uChurn.value[i].set(-c.width / 2 + c.width * (i + 0.5) / nCh, c.throw + 0.3 - pool.position.z, Math.max(1.4, c.width / nCh * 0.95), 0.6 + 0.6 * c.aeration);
+        else
+            bu.uChurn.value[i].set(0, 0, 0, 0);
+    } };
+    setChurn();
+    group.add(pool);
+    parts.push(pool);
+    // mist: a dense volume at the foot and a thin haze along the sheet
+    const foot = createMistVolume(u, new THREE.Vector3(0, c.drop * 0.1 + 0.5, c.throw + 1.2), new THREE.Vector3(c.width * 2.2, c.drop * 0.35 + 3, Math.min(poolD, c.width) * 1.1), 18, c.mist * 0.42, '#d8e0e6');
+    foot.mesh.renderOrder = 20;
+    const haze = createMistVolume(u, new THREE.Vector3(0, c.drop * 0.55, c.throw * 0.5 + 0.4), new THREE.Vector3(c.width * 1.5, c.drop * 1.1, 3.5 + c.throw), 12, c.mist * 0.12, '#dde5ea');
+    haze.mesh.renderOrder = 19;
+    haze.u.uRise.value = 0.1;
+    group.add(foot.mesh, haze.mesh);
+    parts.push(foot.mesh, haze.mesh);
+    // spray
+    const rng = mulberry32(3);
+    const spray = new THREE.Mesh(instancedQuads(700, () => [rng(), rng(), rng(), rng()]), new THREE.ShaderMaterial({ uniforms: u, vertexShader: SPRAY_VERT, fragmentShader: SPRAY_FRAG, ...premul }));
+    spray.frustumCulled = false;
+    spray.renderOrder = 15;
+    group.add(spray);
+    parts.push(spray);
+    return {
+        object: group,
+        apply(patch) {
+            Object.assign(c, patch);
+            applyConfig(u, patch);
+            if (patch.waterColor) {
+                bu.uDeepColor.value.set(patch.waterColor).multiplyScalar(0.55);
+                bu.uShallowColor.value.set(patch.waterColor);
+            }
+            if (patch.foamColor)
+                bu.uFoamColor.value.set(patch.foamColor);
+            if (patch.aeration !== undefined || patch.throw !== undefined)
+                setChurn();
+            if (patch.mist !== undefined) {
+                foot.u.uDensity.value = c.mist * 0.42;
+                haze.u.uDensity.value = c.mist * 0.12;
+            }
+        },
+        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;
+        },
+        dispose() { for (const p of parts) {
+            p.geometry.dispose();
+            p.material.dispose();
+        } },
+    };
+}

package/dist/components/water/index.d.ts

@@ -6,4 +6,12 @@ export { default as Sea } from './Sea';
 export { default as Lake } from './Lake';
 export { default as Storm } from './Storm';
 export { default as Shore } from './Shore';
+export { useWaterInstance } from './useWaterInstance';
+export type { WaterInstance, WaterVariantProps, WaterCore } from './useWaterInstance';
+export type { WaterWaterfallProps } from './WaterWaterfall';
+export { default as WaterWaterfall } from './WaterWaterfall';
+export type { WaterFountainProps } from './WaterFountain';
+export { default as WaterFountain } from './WaterFountain';
+export type { WaterStreamProps } from './WaterStream';
+export { default as WaterStream } from './WaterStream';
 //# sourceMappingURL=index.d.ts.map

package/dist/components/water/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/water/index.ts"],"names":[],"mappings":"AAKA,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,OAAO,IAAI,GAAG,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,QAAQ,CAAC;AACzC,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/water/index.ts"],"names":[],"mappings":"AAKA,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,OAAO,IAAI,GAAG,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,QAAQ,CAAC;AACzC,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,SAAS,CAAC;AAK3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,YAAY,EAAE,aAAa,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACtF,YAAY,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC7D,YAAY,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC3D,YAAY,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,eAAe,CAAC"}

package/dist/components/water/index.js

@@ -9,3 +9,10 @@ export { default as Sea } from './Sea.js';
 export { default as Lake } from './Lake.js';
 export { default as Storm } from './Storm.js';
 export { default as Shore } from './Shore.js';
+// Moving-water variants (type 'water', config.type waterfall / fountain / stream). One line per variant, written by
+// the integrator. waterCore is the family's own (imported by core/<key>.ts), not re-exported: its helper names
+// (mulberry32, createBasin, …) would collide with other families' cores in the components barrel.
+export { useWaterInstance } from './useWaterInstance.js';
+export { default as WaterWaterfall } from './WaterWaterfall.js';
+export { default as WaterFountain } from './WaterFountain.js';
+export { default as WaterStream } from './WaterStream.js';

package/dist/components/water/types.d.ts

@@ -16,6 +16,9 @@ export interface OceanLayerProps extends ObjectReadyProps {
     sunIntensity?: number;
     /** Object host only — the placed body's transform. */
     meshSettings?: OceanMeshSettings;
+    /** Object host only — the parent (ObjectNode's CreatedObject wrapper) applies
+     *  `meshSettings`; the body then reads it only for sizing. */
+    transformOwned?: boolean;
     /** Keyframes; the `ocean` domain drives config knobs per frame. */
     animations?: ObjectAnimations;
     /** Pointer bindings; same `ocean` domain. */

package/dist/components/water/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/water/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAExJ,6EAA6E;AAC7E,MAAM,WAAW,eAAgB,SAAQ,gBAAgB;IACrD,4EAA4E;IAC5E,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,EAAE,kBAAkB,CAAC;IAC5B;;4DAEwD;IACxD,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,2EAA2E;IAC3E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,sDAAsD;IACtD,YAAY,CAAC,EAAE,iBAAiB,CAAC;IACjC,mEAAmE;IACnE,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,6CAA6C;IAC7C,SAAS,CAAC,EAAE,qBAAqB,CAAC;IAClC,mFAAmF;IACnF,OAAO,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;CAClC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/water/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAExJ,6EAA6E;AAC7E,MAAM,WAAW,eAAgB,SAAQ,gBAAgB;IACrD,4EAA4E;IAC5E,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,EAAE,kBAAkB,CAAC;IAC5B;;4DAEwD;IACxD,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,2EAA2E;IAC3E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,sDAAsD;IACtD,YAAY,CAAC,EAAE,iBAAiB,CAAC;IACjC;kEAC8D;IAC9D,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,mEAAmE;IACnE,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,6CAA6C;IAC7C,SAAS,CAAC,EAAE,qBAAqB,CAAC;IAClC,mFAAmF;IACnF,OAAO,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;CAClC"}