@3driseai/3drise-viewer 0.1.42 → 0.1.44

package/dist/components/water/waterCore.js

@@ -0,0 +1,516 @@
+// Emitted from Claude outputs/water-lab/common.mjs by gen_family.mjs — edit the lab module and re-emit.
+// water-lab common: the lab's sun model hooks, noise GLSL, the basin water surface
+// (a small Gerstner body lit like the app's ocean: Fresnel sky, sun glitter, body
+// colour) with two analytic disturbance channels every construction writes into —
+// expanding RINGS (rain drops, fountain impacts) and CHURN zones (the foot of a
+// waterfall, the mouth of a stream) — plus instanced quad helpers for spray/mist.
+// Lab only: the app's basin is WaterBody / OceanSurfaceMaterial; what ships from
+// here is each construction's own geometry + GLSL, which is byte-identical.
+import * as THREE from 'three';
+export const MAX_RINGS = 24;
+export const MAX_CHURN = 24;
+export function mulberry32(a) {
+    return function () {
+        a |= 0;
+        a = (a + 0x6D2B79F5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+export const clamp01 = (x) => Math.min(1, Math.max(0, x));
+// ---------------------------------------------------------------------------- sun
+export function createSunUniforms() {
+    return {
+        uSunDir: { value: new THREE.Vector3(0.3, 0.8, 0.5).normalize() },
+        uSunColor: { value: new THREE.Color(1, 0.95, 0.85) },
+        uSkyAmbient: { value: new THREE.Color(0.36, 0.44, 0.6) },
+        uGroundAmbient: { value: new THREE.Color(0.2, 0.2, 0.2) },
+        uSkyTop: { value: new THREE.Color(0.3, 0.5, 0.9) },
+        uSkyHorizon: { value: new THREE.Color(0.7, 0.8, 0.9) },
+        uNight: { value: 0 },
+        uTime: { value: 0 },
+    };
+}
+export function applySun(u, sun) {
+    u.uSunDir.value.copy(sun.direction);
+    u.uSunColor.value.copy(sun.color);
+    u.uSkyAmbient.value.copy(sun.skyAmbient);
+    u.uGroundAmbient.value.copy(sun.groundAmbient);
+    u.uSkyTop.value.copy(sun.skyTop);
+    u.uSkyHorizon.value.copy(sun.skyHorizon);
+    u.uNight.value = sun.night;
+}
+// ---------------------------------------------------------------------------- GLSL
+export const GLSL_COMMON = /* glsl */ `
+uniform vec3 uSunDir;
+uniform vec3 uSunColor;
+uniform vec3 uSkyAmbient;
+uniform vec3 uGroundAmbient;
+uniform vec3 uSkyTop;
+uniform vec3 uSkyHorizon;
+uniform float uNight;
+uniform float uTime;
+
+float hash11(float p) { p = fract(p * 0.1031); p *= p + 33.33; p *= p + p; return fract(p); }
+float hash21(vec2 p) { vec3 p3 = fract(vec3(p.xyx) * 0.1031); p3 += dot(p3, p3.yzx + 33.33); return fract((p3.x + p3.y) * p3.z); }
+vec2 hash22(vec2 p) { vec3 p3 = fract(vec3(p.xyx) * vec3(0.1031, 0.1030, 0.0973)); p3 += dot(p3, p3.yzx + 33.33); return fract((p3.xx + p3.yz) * p3.zy); }
+float vnoise21(vec2 p) { vec2 i = floor(p), f = fract(p); f = f * f * (3.0 - 2.0 * f); return mix(mix(hash21(i), hash21(i + vec2(1.0, 0.0)), f.x), mix(hash21(i + vec2(0.0, 1.0)), hash21(i + vec2(1.0, 1.0)), f.x), f.y); }
+float fbm21(vec2 p) { float a = 0.5, s = 0.0; for (int i = 0; i < 4; i++) { s += a * vnoise21(p); p = p * 2.03 + 17.1; a *= 0.5; } return s; }
+// Gradient-ish noise with derivative, for normals: central differences on vnoise are fine at this scale.
+vec3 noised21(vec2 p, float e) { float c = vnoise21(p); return vec3(c, vnoise21(p + vec2(e, 0.0)) - c, vnoise21(p + vec2(0.0, e)) - c); }
+float hash31(vec3 p) { p = fract(p * 0.1031); p += dot(p, p.zyx + 31.32); return fract((p.x + p.y) * p.z); }
+float vnoise31(vec3 p) {
+    vec3 i = floor(p), f = fract(p); f = f * f * (3.0 - 2.0 * f);
+    float a = mix(mix(hash31(i), hash31(i + vec3(1,0,0)), f.x), mix(hash31(i + vec3(0,1,0)), hash31(i + vec3(1,1,0)), f.x), f.y);
+    float b = mix(mix(hash31(i + vec3(0,0,1)), hash31(i + vec3(1,0,1)), f.x), mix(hash31(i + vec3(0,1,1)), hash31(i + vec3(1,1,1)), f.x), f.y);
+    return mix(a, b, f.z);
+}
+float fbm31(vec3 p) { float a = 0.5, s = 0.0; for (int i = 0; i < 4; i++) { s += a * vnoise31(p); p = p * 2.07 + 11.3; a *= 0.5; } return s; }
+/** Worley-ish cell distance in 2D (pebbles). Returns (F1, cell id hash). */
+vec2 cells21(vec2 p) {
+    vec2 i = floor(p), f = fract(p); float d = 8.0; float id = 0.0;
+    for (int y = -1; y <= 1; y++) for (int x = -1; x <= 1; x++) {
+        vec2 g = vec2(float(x), float(y)); vec2 o = hash22(i + g); vec2 r = g + o - f; float dd = dot(r, r);
+        if (dd < d) { d = dd; id = hash21(i + g); }
+    }
+    return vec2(sqrt(d), id);
+}
+
+/** The lab sky by direction: a gradient between the horizon and zenith colours set by the hour. */
+vec3 skyColor(vec3 d) { float t = clamp(d.y, 0.0, 1.0); return mix(uSkyHorizon, uSkyTop, pow(t, 0.55)); }
+
+float fresnelWater(vec3 N, vec3 V) { return 0.02 + 0.98 * pow(1.0 - clamp(dot(N, V), 0.0, 1.0), 5.0); }
+
+/** GGX lobe for the sun glitter on a water normal. */
+float ggx(vec3 N, vec3 L, vec3 V, float rough) {
+    vec3 H = normalize(L + V); float a = max(rough * rough, 2e-4); float ndh = max(dot(N, H), 0.0);
+    float d = ndh * ndh * (a * a - 1.0) + 1.0; return (a * a) / (3.14159 * d * d);
+}
+
+/** Water shading shared by every surface in the lab: body colour under sky fill + sun,
+ *  reflected sky through Fresnel, a glitter path. foam (0..1) switches to a rough white. */
+vec3 shadeWater(vec3 P, vec3 N, vec3 camPos, vec3 body, vec3 foamColor, float foam, float rough, float specular) {
+    vec3 V = normalize(camPos - P);
+    vec3 L = normalize(uSunDir);
+    float NdotL = max(dot(N, L), 0.0);
+    vec3 sun = uSunColor;
+    vec3 R = reflect(-V, N); R.y = max(R.y, 0.02);
+    vec3 sky = skyColor(R);
+    float f = fresnelWater(N, V);
+    vec3 bodyLit = body * (uSkyAmbient * 0.5 + sun * (0.2 + 0.5 * NdotL));
+    vec3 col = mix(bodyLit, sky, f) + sun * ggx(N, L, V, rough) * specular * f;
+    vec3 foamLit = foamColor * (uSkyAmbient * 0.6 + sun * (0.3 + 0.7 * NdotL));
+    return mix(col, foamLit, clamp(foam, 0.0, 1.0));
+}
+`;
+// ---------------------------------------------------------------------------- rings + churn (the disturbance channels)
+export function createDisturbanceUniforms() {
+    return {
+        uRings: { value: Array.from({ length: MAX_RINGS }, () => new THREE.Vector4(0, 0, -1e3, 0)) }, // x, z, birth time, amplitude
+        uRingSize: { value: new THREE.Vector3(0.6, 1.6, 3.0) }, // speed (m/s), life (s), wavelength scale
+        uChurn: { value: Array.from({ length: MAX_CHURN }, () => new THREE.Vector4(0, 0, 0, 0)) }, // x, z, radius, strength
+    };
+}
+/** A small ring pool: spawn(x, z, amp) writes the oldest slot. */
+export function ringSpawner(u) {
+    let i = 0;
+    return (x, z, amp, now) => { u.uRings.value[i].set(x, z, now, amp); i = (i + 1) % MAX_RINGS; };
+}
+export const GLSL_DISTURB = /* glsl */ `
+uniform vec4 uRings[${MAX_RINGS}];
+uniform vec3 uRingSize;
+uniform vec4 uChurn[${MAX_CHURN}];
+
+/** Height + gradient of every live ring at xz (world/local metres). Each ring is a
+ *  damped wave packet expanding at uRingSize.x m/s, dying over uRingSize.y s. */
+vec3 ringField(vec2 p) {
+    vec3 acc = vec3(0.0);
+    for (int i = 0; i < ${MAX_RINGS}; i++) {
+        vec4 r = uRings[i];
+        float age = uTime - r.z;
+        if (age < 0.0 || age > uRingSize.y) continue;
+        vec2 d = p - r.xy; float dist = length(d);
+        float front = age * uRingSize.x;
+        float x = (dist - front) * uRingSize.z;      // phase across the packet
+        float env = exp(-x * x * 0.35) * (1.0 - age / uRingSize.y) * r.w / (1.0 + front * 1.5);
+        float h = env * sin(x * 2.2);
+        float dh = env * (2.2 * cos(x * 2.2) - 0.7 * x * sin(x * 2.2)) * uRingSize.z;
+        acc += vec3(h, dh * d / max(dist, 1e-3));
+    }
+    return acc;
+}
+/** Churn zones: boiling noise inside a radius — foam amount and a wobbling normal. */
+vec2 churnField(vec2 p, float t) {
+    float foam = 0.0; float bump = 0.0;
+    for (int i = 0; i < ${MAX_CHURN}; i++) {
+        vec4 c = uChurn[i];
+        if (c.w <= 0.0) continue;
+        float d = length(p - c.xy) / max(c.z, 1e-3);
+        float w = (1.0 - smoothstep(0.55, 1.0, d)) * c.w;
+        if (w <= 0.0) continue;
+        float n = fbm21(p * 2.4 + vec2(t * 0.9, -t * 1.3)) * 0.6 + fbm21(p * 5.0 - vec2(t * 2.1, t * 1.7)) * 0.4;
+        foam += w * smoothstep(0.35, 0.75, n + 0.25 * (1.0 - d));
+        bump += w * n;
+    }
+    return vec2(foam, bump);
+}
+`;
+// ---------------------------------------------------------------------------- the basin
+export function createBasinUniforms() {
+    return {
+        ...createSunUniforms(),
+        ...createDisturbanceUniforms(),
+        uWaves: { value: Array.from({ length: 6 }, () => new THREE.Vector4(1, 0, 0, 1)) }, // dir.x, dir.z, amp, k
+        uWaveSpeed: { value: Array.from({ length: 6 }, () => 0) },
+        uDeepColor: { value: new THREE.Color('#1a7ea6') },
+        uShallowColor: { value: new THREE.Color('#4fd6c8') },
+        uFoamColor: { value: new THREE.Color('#eef6f8') },
+        uRough: { value: 0.03 },
+        uSpecular: { value: 1.2 },
+        uDetail: { value: 0.5 },
+        uDetailSize: { value: 0.4 },
+        uHalf: { value: new THREE.Vector2(5, 5) },
+        uEdgeFade: { value: 0.08 },
+        uRound: { value: 0 },
+        uFloor: { value: 0 }, // 1: a floor is visible through the water
+        uFloorDepth: { value: 0.6 }, // metres of water over it
+        uAbsorb: { value: new THREE.Vector3(0.9, 0.35, 0.25) }, // per-channel absorption (1/m): red dies first
+        uFloorA: { value: new THREE.Color('#b9b2a4') }, uFloorB: { value: new THREE.Color('#8f8779') },
+        uFloorTile: { value: 0.5 }, // tile size (m); 0 = pebbles
+        uCamPos: { value: new THREE.Vector3() },
+    };
+}
+/** Wind -> a small wave table (lab stand-in for the ocean's spectrum). */
+export function applyBasinWind(u, windSpeed, bearingDeg, fetchM, spread = 40) {
+    const rng = mulberry32(7);
+    const U = Math.max(windSpeed, 0.05);
+    const peak = Math.min(Math.max(0.88 * U * U * Math.pow(Math.max(fetchM / 1000, 0.001) / (0.05 * U * U + 1), 0.4), 0.12), fetchM * 0.5);
+    const hs = 0.0246 * U * U * Math.pow(Math.max(fetchM / 1000, 0.001) / (0.05 * U * U + 1), 0.4);
+    const b = (bearingDeg * Math.PI) / 180, s = (spread * Math.PI) / 180;
+    for (let i = 0; i < 6; i++) {
+        const t = i / 5;
+        const wl = peak * Math.pow(0.08, t);
+        const k = (2 * Math.PI) / wl;
+        const amp = (hs / 4) * Math.pow(0.55, i) * 0.5;
+        const a = b + (rng() * 2 - 1) * s * (0.4 + 0.6 * t);
+        u.uWaves.value[i].set(Math.sin(a), Math.cos(a), amp, k);
+        u.uWaveSpeed.value[i] = Math.sqrt(9.81 * k);
+    }
+}
+export const BASIN_VERT = /* glsl */ `
+${GLSL_COMMON}
+${GLSL_DISTURB}
+uniform vec4 uWaves[6];
+uniform float uWaveSpeed[6];
+uniform vec2 uHalf;
+uniform float uEdgeFade;
+uniform float uRound;
+varying vec3 vP;
+varying vec3 vN;
+varying vec2 vLocal;
+varying float vFoam;
+varying float vEdge;
+void main() {
+    vec2 p = position.xz;
+    float ext = uRound > 0.5 ? length(p / uHalf) : max(abs(p.x) / uHalf.x, abs(p.y) / uHalf.y);
+    float edge = 1.0 - smoothstep(1.0 - uEdgeFade, 1.0, ext);
+    float h = 0.0; vec2 g = vec2(0.0);
+    for (int i = 0; i < 6; i++) {
+        vec4 w = uWaves[i];
+        float ph = dot(w.xy, p) * w.w - uWaveSpeed[i] * uTime;
+        h += w.z * sin(ph);
+        g += w.z * w.w * cos(ph) * w.xy;
+    }
+    vec3 rf = ringField(p);
+    vec2 ch = churnField(p, uTime);
+    h += rf.x + ch.y * 0.04;
+    g += rf.yz;
+    h *= edge; g *= edge;
+    vP = (modelMatrix * vec4(p.x, h, p.y, 1.0)).xyz;
+    vN = normalize(mat3(modelMatrix) * normalize(vec3(-g.x, 1.0, -g.y)));
+    vLocal = p; vFoam = ch.x; vEdge = edge;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(p.x, h, p.y, 1.0);
+}
+`;
+export const BASIN_FRAG = /* glsl */ `
+${GLSL_COMMON}
+${GLSL_DISTURB}
+uniform vec3 uDeepColor, uShallowColor, uFoamColor;
+uniform float uRough, uSpecular, uDetail, uDetailSize;
+uniform vec3 uCamPos;
+uniform float uFloor, uFloorDepth, uFloorTile;
+uniform vec3 uAbsorb, uFloorA, uFloorB;
+/** The basin floor seen through the surface: refracted lookup, tiles or pebbles, caustic light,
+ *  Beer-Lambert absorption over the depth so the floor is tinted by the water. */
+vec3 floorThrough(vec2 p, vec3 N, vec3 V, vec3 fallback) {
+    // refraction: the view ray bends toward the normal; offset the floor lookup by the normal's tilt
+    vec2 off = -N.xz * uFloorDepth * 1.6 - V.xz / max(V.y, 0.2) * uFloorDepth * 0.35;
+    vec2 fp = p + off;
+    vec3 fc;
+    if (uFloorTile > 0.0) {
+        vec2 g = fract(fp / uFloorTile); vec2 id = floor(fp / uFloorTile);
+        float grout = smoothstep(0.0, 0.06, g.x) * smoothstep(1.0, 0.94, g.x) * smoothstep(0.0, 0.06, g.y) * smoothstep(1.0, 0.94, g.y);
+        fc = mix(uFloorA, uFloorB, hash21(id) * 0.6 + vnoise21(fp * 3.0) * 0.4) * (0.55 + 0.45 * grout);
+    } else {
+        vec2 cl = cells21(fp * 2.5);
+        fc = mix(uFloorA, uFloorB, cl.y) * (0.6 + 0.4 * smoothstep(0.45, 0.1, cl.x)) * (0.8 + 0.4 * vnoise21(fp * 9.0));
+    }
+    // caustics: bright web from the surface ripples
+    float ca = pow(vnoise21(fp * 4.0 + uTime * 0.6) * vnoise21(fp * 4.0 - uTime * 0.5 + 3.0), 1.5) * 2.5;
+    vec3 L = normalize(uSunDir);
+    fc *= uSkyAmbient * 0.6 + uSunColor * (0.35 + 0.5 * ca) * max(L.y, 0.0);
+    vec3 T = exp(-uAbsorb * uFloorDepth * 2.0);
+    return mix(fallback, fc * T + uDeepColor * (1.0 - T) * 0.6, uFloor);
+}
+varying vec3 vP; varying vec3 vN; varying vec2 vLocal; varying float vFoam; varying float vEdge;
+void main() {
+    vec3 N = normalize(vN);
+    // sub-mesh ripple detail, advected by a slow drift
+    vec3 n1 = noised21(vLocal / uDetailSize + vec2(uTime * 0.35, uTime * 0.2), 0.05);
+    vec3 n2 = noised21(vLocal / (uDetailSize * 0.45) - vec2(uTime * 0.5, -uTime * 0.3), 0.05);
+    vec2 dn = (n1.yz + n2.yz * 0.5) * uDetail * 2.5;
+    N = normalize(N + vec3(-dn.x, 0.0, -dn.y) * vEdge);
+    // churn roughens the surface too
+    vec2 ch = churnField(vLocal, uTime);
+    float rough = uRough + ch.x * 0.3;
+    vec3 body = mix(uDeepColor, uShallowColor, 0.15);
+    vec3 V = normalize(uCamPos - vP);
+    body = floorThrough(vLocal, N, V, body);
+    vec3 col = shadeWater(vP, N, uCamPos, body, uFoamColor, ch.x, rough, uSpecular);
+    gl_FragColor = vec4(col, 1.0);
+    #include <colorspace_fragment>
+}
+`;
+export function createBasinMaterial(u) {
+    return new THREE.ShaderMaterial({ uniforms: u, vertexShader: BASIN_VERT, fragmentShader: BASIN_FRAG, side: THREE.DoubleSide });
+}
+/** A basin mesh: w x d metres in XZ, segments per side. */
+export function createBasin(u, w, d, segs = 96, round = false) {
+    const geo = round ? new THREE.CircleGeometry(w / 2, Math.max(48, segs)) : new THREE.PlaneGeometry(w, d, segs, Math.max(4, Math.round(segs * d / w)));
+    if (round) {
+        // a round basin still needs interior vertices for the rings: subdivide the fan into a disc grid
+        const g = new THREE.PlaneGeometry(w, w, segs, segs);
+        g.rotateX(-Math.PI / 2);
+        const pos = g.attributes.position;
+        const r = w / 2;
+        for (let i = 0; i < pos.count; i++) {
+            const x = pos.getX(i), z = pos.getZ(i);
+            const l = Math.hypot(x, z);
+            if (l > r) {
+                pos.setX(i, x / l * r);
+                pos.setZ(i, z / l * r);
+            }
+        }
+        geo.dispose();
+        u.uRound.value = 1;
+        u.uHalf.value.set(r, r);
+        const mesh = new THREE.Mesh(g, createBasinMaterial(u));
+        mesh.frustumCulled = false;
+        return mesh;
+    }
+    geo.rotateX(-Math.PI / 2);
+    u.uRound.value = 0;
+    u.uHalf.value.set(w / 2, d / 2);
+    const mesh = new THREE.Mesh(geo, createBasinMaterial(u));
+    mesh.frustumCulled = false;
+    return mesh;
+}
+// ---------------------------------------------------------------------------- instanced quads (spray, mist, droplets)
+/** N camera-facing quads with per-instance aSeed (4 floats). The vertex shader decides
+ *  everything else from the seed and time, so there is no per-frame upload. */
+export function instancedQuads(n, seedFn) {
+    const geo = new THREE.InstancedBufferGeometry();
+    const base = new THREE.PlaneGeometry(1, 1);
+    geo.index = base.index;
+    geo.attributes.position = base.attributes.position;
+    geo.attributes.uv = base.attributes.uv;
+    const seeds = new Float32Array(n * 4);
+    for (let i = 0; i < n; i++) {
+        const s = seedFn(i);
+        seeds[i * 4] = s[0];
+        seeds[i * 4 + 1] = s[1];
+        seeds[i * 4 + 2] = s[2];
+        seeds[i * 4 + 3] = s[3];
+    }
+    geo.setAttribute('aSeed', new THREE.InstancedBufferAttribute(seeds, 4));
+    geo.instanceCount = n;
+    geo.boundingSphere = new THREE.Sphere(new THREE.Vector3(), 1e5);
+    return geo;
+}
+/** Billboard helper for the vertex stage: world position of the quad centre + size (m) -> clip. */
+export const GLSL_BILLBOARD = /* glsl */ `
+vec4 billboard(vec3 worldCentre, vec2 corner, float size, float stretchY, vec3 stretchDir) {
+    vec4 mv = viewMatrix * vec4(worldCentre, 1.0);
+    vec3 dirV = normalize((viewMatrix * vec4(stretchDir, 0.0)).xyz);
+    vec3 up = stretchY > 0.0 ? dirV : vec3(0.0, 1.0, 0.0);
+    vec3 right = vec3(up.y, -up.x, 0.0);
+    if (length(right) < 1e-4) right = vec3(1.0, 0.0, 0.0);
+    right = normalize(right);
+    mv.xyz += right * corner.x * size + up * corner.y * size * (1.0 + stretchY);
+    return projectionMatrix * mv;
+}
+`;
+// ---------------------------------------------------------------------------- paths (streams)
+export function samplePath(points, curve = 0.5, closed = false, step = 1.0) {
+    const pts = points.map((p) => new THREE.Vector3(p[0], 0, p[1]));
+    const c = new THREE.CatmullRomCurve3(pts, closed, 'centripetal', curve);
+    const len = c.getLength();
+    const n = Math.max(2, Math.round(len / step));
+    const out = [];
+    for (let i = 0; i <= n; i++) {
+        const t = i / n;
+        const p = c.getPointAt(t), tan = c.getTangentAt(t);
+        out.push({ p, t: tan, u: t * len });
+    }
+    // curvature from tangent turn rate
+    for (let i = 0; i < out.length; i++) {
+        const a = out[Math.max(0, i - 1)].t, b = out[Math.min(out.length - 1, i + 1)].t;
+        out[i].curv = Math.atan2(a.x * b.z - a.z * b.x, a.dot(b)) / (2 * step);
+    }
+    return { samples: out, length: len };
+}
+// ---------------------------------------------------------------------------- rock (lab staging; the app has real textures)
+// JS value noise for the CPU displacement (smooth normals come from computeVertexNormals)
+function jhash(x, y, z) { let h = Math.sin(x * 127.1 + y * 311.7 + z * 74.7) * 43758.5453; return h - Math.floor(h); }
+function jnoise(x, y, z) {
+    const ix = Math.floor(x), iy = Math.floor(y), iz = Math.floor(z);
+    let fx = x - ix, fy = y - iy, fz = z - iz;
+    fx = fx * fx * (3 - 2 * fx);
+    fy = fy * fy * (3 - 2 * fy);
+    fz = fz * fz * (3 - 2 * fz);
+    const l = (a, b, t) => a + (b - a) * t;
+    return l(l(l(jhash(ix, iy, iz), jhash(ix + 1, iy, iz), fx), l(jhash(ix, iy + 1, iz), jhash(ix + 1, iy + 1, iz), fx), fy), l(l(jhash(ix, iy, iz + 1), jhash(ix + 1, iy, iz + 1), fx), l(jhash(ix, iy + 1, iz + 1), jhash(ix + 1, iy + 1, iz + 1), fx), fy), fz);
+}
+export function jfbm(x, y, z, oct = 4) { let a = 0.5, s = 0, f = 1; for (let i = 0; i < oct; i++) {
+    s += a * jnoise(x * f + 11 * i, y * f + 7 * i, z * f + 3 * i);
+    f *= 2.07;
+    a *= 0.5;
+} return s; }
+/** Displace a geometry along its normals by fbm (in the geometry's own space) and recompute smooth normals. */
+export function displaceRock(geo, amount, scale = 0.35, seed = 0) {
+    const pos = geo.attributes.position, nrm = geo.attributes.normal;
+    for (let i = 0; i < pos.count; i++) {
+        const x = pos.getX(i), y = pos.getY(i), z = pos.getZ(i);
+        const d = (jfbm(x * scale + seed, y * scale, z * scale) - 0.5) * 2.0 + (jfbm(x * scale * 4 + seed, y * scale * 4, z * scale * 4, 3) - 0.5) * 0.5;
+        pos.setXYZ(i, x + nrm.getX(i) * d * amount, y + nrm.getY(i) * d * amount, z + nrm.getZ(i) * d * amount);
+    }
+    pos.needsUpdate = true;
+    geo.computeVertexNormals();
+    return geo;
+}
+export const ROCK_VERT = /* glsl */ `
+${GLSL_COMMON}
+varying vec3 vP; varying vec3 vN;
+void main() {
+    vP = (modelMatrix * vec4(position, 1.0)).xyz;
+    vN = normalize(mat3(modelMatrix) * normal);
+    gl_Position = projectionMatrix * viewMatrix * vec4(vP, 1.0);
+}
+`;
+export const ROCK_FRAG = /* glsl */ `
+${GLSL_COMMON}
+uniform vec3 uRockA, uRockB, uMoss;
+uniform float uWet;        // 0..1 darkens + glosses the rock near water
+uniform float uWetHeight;  // world y under which the rock is wet
+varying vec3 vP; varying vec3 vN;
+void main() {
+    vec3 N = normalize(vN);
+    // triplanar-ish detail: strata + grain
+    float strata = smoothstep(0.3, 0.7, fbm31(vec3(vP.x * 0.5, vP.y * 2.5, vP.z * 0.5)));
+    float grain = fbm31(vP * 5.0);
+    float crack = 1.0 - smoothstep(0.0, 0.02, abs(fbm31(vP * 1.6) - 0.5));
+    // bump: a small tilt from fine noise derivatives
+    float e = 0.08;
+    float b0 = fbm31(vP * 7.0), bx = fbm31(vP * 7.0 + vec3(e, 0.0, 0.0)), by = fbm31(vP * 7.0 + vec3(0.0, e, 0.0)), bz = fbm31(vP * 7.0 + vec3(0.0, 0.0, e));
+    N = normalize(N - vec3(bx - b0, by - b0, bz - b0) * 1.6);
+    vec3 col = mix(uRockA, uRockB, strata * 0.55 + grain * 0.45) * (1.0 - 0.18 * crack);
+    float moss = smoothstep(0.2, 0.8, N.y) * smoothstep(0.45, 0.7, fbm31(vP * 1.3 + 5.0));
+    col = mix(col, uMoss, moss * 0.8);
+    float wet = uWet * smoothstep(uWetHeight + 1.5, uWetHeight - 0.5, vP.y);
+    col *= 1.0 - 0.45 * wet;
+    vec3 L = normalize(uSunDir);
+    float NdotL = max(dot(N, L), 0.0);
+    vec3 amb = mix(uGroundAmbient, uSkyAmbient, N.y * 0.5 + 0.5);
+    vec3 lit = col * (amb * 0.9 + uSunColor * NdotL * 0.9);
+    vec3 V = normalize(cameraPosition - vP);
+    lit += uSunColor * ggx(N, L, V, 0.35 - 0.2 * wet) * (0.02 + 0.3 * wet) * fresnelWater(N, V);
+    gl_FragColor = vec4(lit, 1.0);
+    #include <colorspace_fragment>
+}
+`;
+export function createRockMaterial(sunU, options = undefined) {
+    const opts = options || {};
+    return new THREE.ShaderMaterial({
+        uniforms: { ...sunU, uRockA: { value: new THREE.Color(opts.a ?? '#5b5650') }, uRockB: { value: new THREE.Color(opts.b ?? '#8a8075') }, uMoss: { value: new THREE.Color(opts.moss ?? '#4f6a2e') }, uWet: { value: opts.wet ?? 1 }, uWetHeight: { value: opts.wetHeight ?? 0.5 } },
+        vertexShader: ROCK_VERT, fragmentShader: ROCK_FRAG,
+    });
+}
+// ---------------------------------------------------------------------------- mist volume: N view-aligned slices through 3D noise, back to front, one draw
+/** box: { center: Vector3, size: Vector3 } in the object's local space. */
+export const MIST_VERT = /* glsl */ `
+${GLSL_COMMON}
+attribute float aSlice;     // 0 (far) .. 1 (near)
+uniform vec3 uBoxCenter, uBoxSize;
+uniform float uSlices;
+varying vec3 vWorld; varying float vSlice;
+void main() {
+    vSlice = aSlice;
+    vec3 c = (modelMatrix * vec4(uBoxCenter, 1.0)).xyz;
+    vec3 viewDir = normalize(cameraPosition - c);
+    float radius = length(uBoxSize) * 0.5;
+    vec3 centre = c - viewDir * radius * (1.0 - 2.0 * aSlice) * 0.95;
+    vec3 right = normalize(cross(vec3(0.0, 1.0, 0.0), viewDir));
+    vec3 up = cross(viewDir, right);
+    vec3 wp = centre + right * position.x * radius * 2.0 + up * position.y * radius * 2.0;
+    vWorld = wp;
+    gl_Position = projectionMatrix * viewMatrix * vec4(wp, 1.0);
+}
+`;
+export const MIST_FRAG = /* glsl */ `
+${GLSL_COMMON}
+uniform vec3 uBoxCenter, uBoxSize;
+uniform float uSlices, uDensity, uRise;
+uniform vec3 uMistColor;
+uniform mat4 uInvModel;
+varying vec3 vWorld; varying float vSlice;
+void main() {
+    vec3 lp = (uInvModel * vec4(vWorld, 1.0)).xyz - uBoxCenter;
+    vec3 q = lp / (uBoxSize * 0.5);
+    float r2 = dot(q, q);
+    if (r2 > 1.0) discard;
+    // density: dense at the foot, thinning upward and outward; drifting + rising noise
+    vec3 np = lp * 0.9 + vec3(uTime * 0.25, -uTime * uRise, uTime * 0.1);
+    float n = fbm31(np) * 0.7 + fbm31(np * 2.3 + 9.0) * 0.3;
+    float shape = (1.0 - r2) * (1.0 - smoothstep(-0.2, 1.0, q.y) * 0.85);
+    float d = max(n - 0.42, 0.0) * 2.2 * shape * uDensity;
+    float thickness = length(uBoxSize) / uSlices;
+    float a = 1.0 - exp(-d * thickness);
+    if (a < 0.003) discard;
+    // lit by the sky with a little forward-scattered sun
+    vec3 V = normalize(cameraPosition - vWorld);
+    float fwd = pow(max(dot(-V, normalize(uSunDir)), 0.0), 3.0);
+    vec3 lit = uMistColor * (uSkyAmbient * 0.75 + uSunColor * (0.18 + 0.35 * fwd));
+    gl_FragColor = vec4(lit * a, a);
+    #include <colorspace_fragment>
+}
+`;
+export function createMistVolume(sunU, center, size, slices = 16, density = 1, color = '#e9eff3') {
+    const geo = new THREE.InstancedBufferGeometry();
+    const base = new THREE.PlaneGeometry(1, 1);
+    geo.index = base.index;
+    geo.attributes.position = base.attributes.position;
+    geo.attributes.uv = base.attributes.uv;
+    const s = new Float32Array(slices);
+    for (let i = 0; i < slices; i++)
+        s[i] = i / (slices - 1);
+    geo.setAttribute('aSlice', new THREE.InstancedBufferAttribute(s, 1));
+    geo.instanceCount = slices;
+    geo.boundingSphere = new THREE.Sphere(new THREE.Vector3(), 1e5);
+    const u = { ...sunU, uBoxCenter: { value: center.clone() }, uBoxSize: { value: size.clone() }, uSlices: { value: slices }, uDensity: { value: density }, uRise: { value: 0.35 }, uMistColor: { value: new THREE.Color(color) }, uInvModel: { value: new THREE.Matrix4() } };
+    const mat = new THREE.ShaderMaterial({ uniforms: u, vertexShader: MIST_VERT, fragmentShader: MIST_FRAG, transparent: true, depthWrite: false, blending: THREE.CustomBlending, blendSrc: THREE.OneFactor, blendDst: THREE.OneMinusSrcAlphaFactor });
+    const mesh = new THREE.Mesh(geo, mat);
+    mesh.frustumCulled = false;
+    mesh.onBeforeRender = () => { u.uInvModel.value.copy(mesh.matrixWorld).invert(); };
+    return { mesh, u };
+}

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,gBAAgB,QAA4B,CAAC;AAE1D,eAAO,MAAM,qBAAqB,aAuBhC,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,gBAAgB,QAA4B,CAAC;AAE1D,eAAO,MAAM,qBAAqB,aA+BhC,CAAC"}

package/dist/constants.js

@@ -32,10 +32,18 @@ export const SELF_MANAGED_MATERIAL = new Set([
     'text',
     // Image variants (shards, …) draw the picture with their own shaders.
     'image',
+    // Urban variants (building, block, road, streetFurniture) own their facade / asphalt / fixture shaders.
+    'urban',
+    // Vegetation variants (tree, bush, grass, …) own their bark / leaf / produce materials.
+    'vegetation',
+    // Sports variants (court, ball, …) own their surface / leather / net materials.
+    'sports',
+    // Water variants (waterfall, fountain, …) own their water shaders.
+    'water',
     // The water surface owns its shader — one material for both hosts, built
     // around the wave field. Left out of this set, useMaterialApplication
     // overwrites it with whatever the registry has under materialType, which for
     // a legacy ocean is the old flat-plane water material.
-    // 'ocean',
+    'water',
     // 'moon'
 ]);

package/dist/hooks/index.d.ts

@@ -20,8 +20,14 @@ export { SKY_LIVE_KEY, useSkyLive } from './useSkyLive';
 export { useOceanMaterial } from './useOceanMaterial';
 export type { ConfigLiveHandle, ConfigLiveValue, ConfigLiveFamily } from './useConfigLive';
 export { CONFIG_LIVE_KEY, findConfigHandles, useConfigLive, useConfigLiveHandle } from './useConfigLive';
+export { useGridLayout } from './useGridLayout';
+export { useResolvedLayout, useLayoutRefVersion } from './useResolvedLayout';
 export type { ConfigDriverOptions } from './useConfigDriver';
 export { useConfigDriver } from './useConfigDriver';
+export type { Disposable } from './useCommittedInstance';
+export { useCommittedInstance } from './useCommittedInstance';
+export type { LampTarget, TimeLit, TimeLightingOptions } from './useTimeLighting';
+export { useTimeLighting } from './useTimeLighting';
 export type { UseOceanMaterialOptions, OceanMaterialHandle } from './useOceanMaterial';
 export type { UseContinuousEffectsOptions, UseContinuousEffectsResult } from './useContinuousEffects';
 export { useContinuousEffects } from './useContinuousEffects';
@@ -85,11 +91,10 @@ export { useSkySystem } from './useSkySystem';
 export { useSkyUniforms } from './useSkyUniforms';
 export { useTransformControls } from './useTransformControls';
 export { useVolumePoints } from './useVolumePoints';
-export { useWaterEnvironment } from './useWaterEnvironment';
-export { useWaterReflections } from './useWaterReflections';
 export type { LandscapeLiveHandle } from './useLandscapeLive';
 export { LANDSCAPE_LIVE_KEY, useLandscapeLive } from './useLandscapeLive';
 export { useLandscapeMaps } from './useLandscapeMaps';
 export type { LandscapeMapsState } from './useLandscapeMaps';
 export { useRuntimeSettings } from './useRuntimeSettings';
+export { useActionPatch, useRuntimeTime, useRuntimeSunSystem } from './useActionPatch';
 //# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"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"}

package/dist/hooks/index.js

@@ -14,7 +14,11 @@ export { OCEAN_LIVE_KEY, useOceanLive } from './useOceanLive.js';
 export { SKY_LIVE_KEY, useSkyLive } from './useSkyLive.js';
 export { useOceanMaterial } from './useOceanMaterial.js';
 export { CONFIG_LIVE_KEY, findConfigHandles, useConfigLive, useConfigLiveHandle } from './useConfigLive.js';
+export { useGridLayout } from './useGridLayout.js';
+export { useResolvedLayout, useLayoutRefVersion } from './useResolvedLayout.js';
 export { useConfigDriver } from './useConfigDriver.js';
+export { useCommittedInstance } from './useCommittedInstance.js';
+export { useTimeLighting } from './useTimeLighting.js';
 export { useContinuousEffects } from './useContinuousEffects.js';
 export { useCubeCamera } from './useCubeCamera.js';
 export { useEnvironmentProbe } from './useEnvironmentProbe.js';
@@ -61,8 +65,7 @@ export { useSkySystem } from './useSkySystem.js';
 export { useSkyUniforms } from './useSkyUniforms.js';
 export { useTransformControls } from './useTransformControls.js';
 export { useVolumePoints } from './useVolumePoints.js';
-export { useWaterEnvironment } from './useWaterEnvironment.js';
-export { useWaterReflections } from './useWaterReflections.js';
 export { LANDSCAPE_LIVE_KEY, useLandscapeLive } from './useLandscapeLive.js';
 export { useLandscapeMaps } from './useLandscapeMaps.js';
 export { useRuntimeSettings } from './useRuntimeSettings.js';
+export { useActionPatch, useRuntimeTime, useRuntimeSunSystem } from './useActionPatch.js';

package/dist/hooks/useActionPatch.d.ts

@@ -0,0 +1,23 @@
+import { type TimeSettings } from '@3driseai/3drise-core';
+/**
+ * The applied action patch for one action address, or undefined.
+ *
+ * For the keyed views ('render', 'time'): their patch is not laid over one
+ * settings object but split across several (post-processing, sky.sunSystem, the
+ * HDR block, time settings), so each renderer reads the patch and lays its own
+ * part over its own settings (patchPostProcessing, patchHdr, patchSunShadows,
+ * patchTimeSettings, patchSunMultipliers). Subscribes to that one address only.
+ * For everything else use useRuntimeSettings.
+ */
+export declare function useActionPatch<T = Record<string, unknown>>(state: 'render' | 'time'): T | undefined;
+export default useActionPatch;
+/** Time settings with an applied 'time' action laid over them (`t` itself when none). */
+export declare function useRuntimeTime<T extends Partial<TimeSettings>>(t: T): T;
+/**
+ * sky settings whose sunSystem carries the applied 'render' (shadows) and 'time'
+ * (sun / moon multipliers) actions. Same object when neither touches it.
+ */
+export declare function useRuntimeSunSystem<T extends {
+    sunSystem?: any;
+} | null | undefined>(sky: T): T;
+//# sourceMappingURL=useActionPatch.d.ts.map

package/dist/hooks/useActionPatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useActionPatch.d.ts","sourceRoot":"","sources":["../../src/hooks/useActionPatch.ts"],"names":[],"mappings":"AACA,OAAO,EAA2G,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAInK;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,MAAM,GAAG,CAAC,GAAG,SAAS,CAInG;AAED,eAAe,cAAc,CAAC;AAE9B,yFAAyF;AACzF,wBAAgB,cAAc,CAAC,CAAC,SAAS,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAGvE;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS;IAAE,SAAS,CAAC,EAAE,GAAG,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAQ/F"}