@3driseai/3drise-viewer 0.1.42 → 0.1.43

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

@@ -0,0 +1,43 @@
+import { type RefObject } from 'react';
+import * as THREE from 'three';
+import type { AnimationOptions, MouseMoveDomain } from '@3driseai/3drise-core';
+import { type CloudSunState } from '../../hooks/useCloudSun';
+import type { ObjectReadyProps } from '../../types/objectReady';
+import { type SunModel } from './waterCore';
+export interface WaterInstance {
+    object: THREE.Object3D;
+    apply(cfg: Record<string, unknown>): void;
+    update(dt: number, camera: THREE.Camera): void;
+    dispose(): void;
+}
+export interface WaterVariantProps extends ObjectReadyProps {
+    config: {
+        type: string;
+    };
+    /** Scene object id: the live-edit handle is found by it. */
+    id?: string;
+    /** Keyframes on the config knobs (animations.water.animations). */
+    keyframes?: AnimationOptions[];
+    /** Pointer bindings on the config knobs (mouseMove.water). */
+    mouseMove?: MouseMoveDomain;
+}
+export interface WaterCore {
+    DEFAULTS: Record<string, unknown>;
+    STRUCTURAL: readonly string[];
+    ANIMATABLE: ReadonlySet<string>;
+    createUniforms(): Record<string, any>;
+    applyConfig(u: Record<string, any>, cfg: Record<string, unknown>): void;
+    build(u: Record<string, any>, cfg: Record<string, unknown>): WaterInstance;
+}
+/**
+ * The scene sun → the lab's sun model, in place. The zenith and the 20° band are the sky
+ * actually drawn (skyRadianceAt, what SkyMesh and the terrain use), scaled by the dome's own
+ * brightness curve (skyBrightnessForSunElevation) so the water goes dark at night instead of
+ * reflecting a daytime sky.
+ */
+export declare function sceneSunToWater(sun: CloudSunState, out: SunModel): void;
+export declare function useWaterInstance(core: WaterCore, props: WaterVariantProps): {
+    rootRef: RefObject<THREE.Group | null>;
+    instance: WaterInstance;
+};
+//# sourceMappingURL=useWaterInstance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useWaterInstance.d.ts","sourceRoot":"","sources":["../../../src/components/water/useWaterInstance.ts"],"names":[],"mappings":"AAkBA,OAAO,EAA4D,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACjG,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAK/E,OAAO,EAAe,KAAK,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAY,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEtD,MAAM,WAAW,aAAa;IAC1B,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC;IACvB,KAAK,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC1C,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC;IAC/C,OAAO,IAAI,IAAI,CAAC;CACnB;AAED,MAAM,WAAW,iBAAkB,SAAQ,gBAAgB;IACvD,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACzB,4DAA4D;IAC5D,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,mEAAmE;IACnE,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC/B,8DAA8D;IAC9D,SAAS,CAAC,EAAE,eAAe,CAAC;CAC/B;AAED,MAAM,WAAW,SAAS;IACtB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAChC,cAAc,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACtC,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACxE,KAAK,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,aAAa,CAAC;CAC9E;AAYD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,aAAa,EAAE,GAAG,EAAE,QAAQ,GAAG,IAAI,CAoBvE;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,iBAAiB,GAAG;IAAE,OAAO,EAAE,SAAS,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC;IAAC,QAAQ,EAAE,aAAa,CAAA;CAAE,CA6B/I"}

package/dist/components/water/useWaterInstance.js

@@ -0,0 +1,89 @@
+// =============================================================================
+// useWaterInstance — the React side every moving-water component shares
+// =============================================================================
+//
+// A variant's core (water/core/<key>.ts, emitted from the lab module) is plain three.js:
+// createUniforms(), applyConfig(u, cfg), build(u, cfg) -> { object, apply, update(dt, camera),
+// dispose }. This hook wires it into the config pattern:
+//
+//   - base config over the type's defaults (withConfigDefaults);
+//   - built once; a change of a STRUCTURAL knob rebuilds (dispose + build, the uniforms outlive
+//     it); every other committed change and every per-frame override goes through
+//     instance.apply (the one door: live drag, keyframes, pointer bindings, timeline clips —
+//     useConfigDriver);
+//   - the scene sun and sky, read-only, into the core's sun uniforms every frame (useCloudSun →
+//     the lab's sun model: direction, sun colour, sky / ground ambient, zenith and horizon
+//     radiance, night), so the water follows the Environment clock like the water bodies do;
+//   - readiness (useObjectReady) and disposal.
+//
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef } from 'react';
+import * as THREE from 'three';
+import { useFrame } from '@react-three/fiber';
+import { skyBrightnessForSunElevation } from '@3driseai/3drise-core';
+import { withConfigDefaults } from '../../utils/configAnimations.js';
+import { useObjectReady } from '../../hooks/useObjectReady.js';
+import { useConfigDriver } from '../../hooks/useConfigDriver.js';
+import { useCloudSun } from '../../hooks/useCloudSun.js';
+import { skyRadianceAt } from '../../utils/terrainUniforms.js';
+import { applySun } from './waterCore.js';
+/** Sun elevation (deg) over which direct sunlight fades out — the window SunLight and the water bodies use. */
+const SUN_FADE_START = -1, SUN_FADE_END = 4;
+const smooth01 = (e0, e1, x) => { const t = Math.max(0, Math.min(1, (x - e0) / (e1 - e0))); return t * t * (3 - 2 * t); };
+/** The lab's sun colour magnitude at noon; the scene's transmission colour (≤ 1) is scaled to it. */
+const SUN_STRENGTH = 1.6;
+const _up = new THREE.Vector3(0, 1, 0);
+const _rd = new THREE.Vector3();
+const _c = new THREE.Color();
+/**
+ * The scene sun → the lab's sun model, in place. The zenith and the 20° band are the sky
+ * actually drawn (skyRadianceAt, what SkyMesh and the terrain use), scaled by the dome's own
+ * brightness curve (skyBrightnessForSunElevation) so the water goes dark at night instead of
+ * reflecting a daytime sky.
+ */
+export function sceneSunToWater(sun, out) {
+    const el = THREE.MathUtils.radToDeg(Math.asin(THREE.MathUtils.clamp(sun.direction.y, -1, 1)));
+    const bright = skyBrightnessForSunElevation(el);
+    const sunUp = smooth01(SUN_FADE_START, SUN_FADE_END, el);
+    out.direction.copy(sun.direction);
+    out.color.copy(sun.color).multiplyScalar(SUN_STRENGTH * sunUp);
+    skyRadianceAt(_up, sun, out.skyTop).multiplyScalar(bright);
+    // four samples around the compass at 20°, averaged (the aureole at a quarter weight)
+    const hx = sun.direction.x, hz = sun.direction.z, hl = Math.hypot(hx, hz) || 1;
+    const ux = hx / hl, uz = hz / hl, c = 0.94, y = 0.342;
+    out.skyHorizon.setRGB(0, 0, 0);
+    for (const [dx, dz] of [[ux, uz], [-ux, -uz], [-uz, ux], [uz, -ux]]) {
+        skyRadianceAt(_rd.set(dx * c, y, dz * c), sun, _c);
+        out.skyHorizon.add(_c);
+    }
+    out.skyHorizon.multiplyScalar(0.25 * bright);
+    out.skyAmbient.copy(out.skyTop).multiplyScalar(0.45).add(_c.copy(out.skyHorizon).multiplyScalar(0.55));
+    const lit = Math.max(sun.direction.y, 0);
+    out.groundAmbient.copy(out.skyAmbient).multiplyScalar(0.45).add(_c.copy(sun.color).multiplyScalar(lit * 0.35));
+    out.night = 1 - smooth01(-6, 4, el);
+}
+export function useWaterInstance(core, props) {
+    const { config, id, keyframes, mouseMove, onObjectReady, onObjectDispose } = props;
+    const rootRef = useRef(null);
+    useObjectReady(rootRef, config, onObjectReady, onObjectDispose);
+    const cfg = useMemo(() => withConfigDefaults(core.DEFAULTS, config), [config]); // eslint-disable-line react-hooks/exhaustive-deps
+    // uniforms outlive rebuilds
+    const uniforms = useMemo(() => core.createUniforms(), []); // eslint-disable-line react-hooks/exhaustive-deps
+    const structuralKey = JSON.stringify(core.STRUCTURAL.map((k) => cfg[k]));
+    const instance = useMemo(() => core.build(uniforms, cfg), [uniforms, structuralKey]); // eslint-disable-line react-hooks/exhaustive-deps
+    useEffect(() => () => instance.dispose(), [instance]);
+    useLayoutEffect(() => { core.applyConfig(uniforms, cfg); instance.apply(cfg); }, [instance, uniforms, cfg]); // eslint-disable-line react-hooks/exhaustive-deps
+    const push = useCallback((merged) => { core.applyConfig(uniforms, merged); instance.apply(merged); }, [instance, uniforms]); // eslint-disable-line react-hooks/exhaustive-deps
+    useConfigDriver({ rootRef, id, family: 'water', base: cfg, structural: core.STRUCTURAL, allowed: core.ANIMATABLE, keyframes, mouseMove, push });
+    // the scene sun, read-only (follows the Environment clock and the rendered sky)
+    const { update: updateSun } = useCloudSun();
+    const sunModel = useMemo(() => ({
+        direction: new THREE.Vector3(), color: new THREE.Color(), skyAmbient: new THREE.Color(), groundAmbient: new THREE.Color(),
+        skyTop: new THREE.Color(), skyHorizon: new THREE.Color(), night: 0,
+    }), []);
+    useFrame((state, delta) => {
+        sceneSunToWater(updateSun(), sunModel);
+        applySun(uniforms, sunModel);
+        instance.update(Math.min(delta, 0.1), state.camera);
+    });
+    return { rootRef, instance };
+}

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

@@ -0,0 +1,179 @@
+import * as THREE from 'three';
+export declare const MAX_RINGS = 24;
+export declare const MAX_CHURN = 24;
+export declare function mulberry32(a: any): () => number;
+export declare const clamp01: (x: any) => number;
+export declare function createSunUniforms(): {
+    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 applySun(u: any, sun: any): void;
+export declare const GLSL_COMMON = "\nuniform vec3 uSunDir;\nuniform vec3 uSunColor;\nuniform vec3 uSkyAmbient;\nuniform vec3 uGroundAmbient;\nuniform vec3 uSkyTop;\nuniform vec3 uSkyHorizon;\nuniform float uNight;\nuniform float uTime;\n\nfloat hash11(float p) { p = fract(p * 0.1031); p *= p + 33.33; p *= p + p; return fract(p); }\nfloat 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); }\nvec2 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); }\nfloat 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); }\nfloat 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; }\n// Gradient-ish noise with derivative, for normals: central differences on vnoise are fine at this scale.\nvec3 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); }\nfloat hash31(vec3 p) { p = fract(p * 0.1031); p += dot(p, p.zyx + 31.32); return fract((p.x + p.y) * p.z); }\nfloat vnoise31(vec3 p) {\n    vec3 i = floor(p), f = fract(p); f = f * f * (3.0 - 2.0 * f);\n    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);\n    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);\n    return mix(a, b, f.z);\n}\nfloat 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; }\n/** Worley-ish cell distance in 2D (pebbles). Returns (F1, cell id hash). */\nvec2 cells21(vec2 p) {\n    vec2 i = floor(p), f = fract(p); float d = 8.0; float id = 0.0;\n    for (int y = -1; y <= 1; y++) for (int x = -1; x <= 1; x++) {\n        vec2 g = vec2(float(x), float(y)); vec2 o = hash22(i + g); vec2 r = g + o - f; float dd = dot(r, r);\n        if (dd < d) { d = dd; id = hash21(i + g); }\n    }\n    return vec2(sqrt(d), id);\n}\n\n/** The lab sky by direction: a gradient between the horizon and zenith colours set by the hour. */\nvec3 skyColor(vec3 d) { float t = clamp(d.y, 0.0, 1.0); return mix(uSkyHorizon, uSkyTop, pow(t, 0.55)); }\n\nfloat fresnelWater(vec3 N, vec3 V) { return 0.02 + 0.98 * pow(1.0 - clamp(dot(N, V), 0.0, 1.0), 5.0); }\n\n/** GGX lobe for the sun glitter on a water normal. */\nfloat ggx(vec3 N, vec3 L, vec3 V, float rough) {\n    vec3 H = normalize(L + V); float a = max(rough * rough, 2e-4); float ndh = max(dot(N, H), 0.0);\n    float d = ndh * ndh * (a * a - 1.0) + 1.0; return (a * a) / (3.14159 * d * d);\n}\n\n/** Water shading shared by every surface in the lab: body colour under sky fill + sun,\n *  reflected sky through Fresnel, a glitter path. foam (0..1) switches to a rough white. */\nvec3 shadeWater(vec3 P, vec3 N, vec3 camPos, vec3 body, vec3 foamColor, float foam, float rough, float specular) {\n    vec3 V = normalize(camPos - P);\n    vec3 L = normalize(uSunDir);\n    float NdotL = max(dot(N, L), 0.0);\n    vec3 sun = uSunColor;\n    vec3 R = reflect(-V, N); R.y = max(R.y, 0.02);\n    vec3 sky = skyColor(R);\n    float f = fresnelWater(N, V);\n    vec3 bodyLit = body * (uSkyAmbient * 0.5 + sun * (0.2 + 0.5 * NdotL));\n    vec3 col = mix(bodyLit, sky, f) + sun * ggx(N, L, V, rough) * specular * f;\n    vec3 foamLit = foamColor * (uSkyAmbient * 0.6 + sun * (0.3 + 0.7 * NdotL));\n    return mix(col, foamLit, clamp(foam, 0.0, 1.0));\n}\n";
+export declare function createDisturbanceUniforms(): {
+    uRings: {
+        value: THREE.Vector4[];
+    };
+    uRingSize: {
+        value: THREE.Vector3;
+    };
+    uChurn: {
+        value: THREE.Vector4[];
+    };
+};
+/** A small ring pool: spawn(x, z, amp) writes the oldest slot. */
+export declare function ringSpawner(u: any): (x: any, z: any, amp: any, now: any) => void;
+export declare const GLSL_DISTURB = "\nuniform vec4 uRings[24];\nuniform vec3 uRingSize;\nuniform vec4 uChurn[24];\n\n/** Height + gradient of every live ring at xz (world/local metres). Each ring is a\n *  damped wave packet expanding at uRingSize.x m/s, dying over uRingSize.y s. */\nvec3 ringField(vec2 p) {\n    vec3 acc = vec3(0.0);\n    for (int i = 0; i < 24; i++) {\n        vec4 r = uRings[i];\n        float age = uTime - r.z;\n        if (age < 0.0 || age > uRingSize.y) continue;\n        vec2 d = p - r.xy; float dist = length(d);\n        float front = age * uRingSize.x;\n        float x = (dist - front) * uRingSize.z;      // phase across the packet\n        float env = exp(-x * x * 0.35) * (1.0 - age / uRingSize.y) * r.w / (1.0 + front * 1.5);\n        float h = env * sin(x * 2.2);\n        float dh = env * (2.2 * cos(x * 2.2) - 0.7 * x * sin(x * 2.2)) * uRingSize.z;\n        acc += vec3(h, dh * d / max(dist, 1e-3));\n    }\n    return acc;\n}\n/** Churn zones: boiling noise inside a radius \u2014 foam amount and a wobbling normal. */\nvec2 churnField(vec2 p, float t) {\n    float foam = 0.0; float bump = 0.0;\n    for (int i = 0; i < 24; i++) {\n        vec4 c = uChurn[i];\n        if (c.w <= 0.0) continue;\n        float d = length(p - c.xy) / max(c.z, 1e-3);\n        float w = (1.0 - smoothstep(0.55, 1.0, d)) * c.w;\n        if (w <= 0.0) continue;\n        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;\n        foam += w * smoothstep(0.35, 0.75, n + 0.25 * (1.0 - d));\n        bump += w * n;\n    }\n    return vec2(foam, bump);\n}\n";
+export declare function createBasinUniforms(): {
+    uWaves: {
+        value: THREE.Vector4[];
+    };
+    uWaveSpeed: {
+        value: number[];
+    };
+    uDeepColor: {
+        value: THREE.Color;
+    };
+    uShallowColor: {
+        value: THREE.Color;
+    };
+    uFoamColor: {
+        value: THREE.Color;
+    };
+    uRough: {
+        value: number;
+    };
+    uSpecular: {
+        value: number;
+    };
+    uDetail: {
+        value: number;
+    };
+    uDetailSize: {
+        value: number;
+    };
+    uHalf: {
+        value: THREE.Vector2;
+    };
+    uEdgeFade: {
+        value: number;
+    };
+    uRound: {
+        value: number;
+    };
+    uFloor: {
+        value: number;
+    };
+    uFloorDepth: {
+        value: number;
+    };
+    uAbsorb: {
+        value: THREE.Vector3;
+    };
+    uFloorA: {
+        value: THREE.Color;
+    };
+    uFloorB: {
+        value: THREE.Color;
+    };
+    uFloorTile: {
+        value: number;
+    };
+    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;
+    };
+};
+/** Wind -> a small wave table (lab stand-in for the ocean's spectrum). */
+export declare function applyBasinWind(u: any, windSpeed: any, bearingDeg: any, fetchM: any, spread?: number): void;
+export declare const BASIN_VERT = "\n\nuniform vec3 uSunDir;\nuniform vec3 uSunColor;\nuniform vec3 uSkyAmbient;\nuniform vec3 uGroundAmbient;\nuniform vec3 uSkyTop;\nuniform vec3 uSkyHorizon;\nuniform float uNight;\nuniform float uTime;\n\nfloat hash11(float p) { p = fract(p * 0.1031); p *= p + 33.33; p *= p + p; return fract(p); }\nfloat 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); }\nvec2 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); }\nfloat 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); }\nfloat 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; }\n// Gradient-ish noise with derivative, for normals: central differences on vnoise are fine at this scale.\nvec3 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); }\nfloat hash31(vec3 p) { p = fract(p * 0.1031); p += dot(p, p.zyx + 31.32); return fract((p.x + p.y) * p.z); }\nfloat vnoise31(vec3 p) {\n    vec3 i = floor(p), f = fract(p); f = f * f * (3.0 - 2.0 * f);\n    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);\n    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);\n    return mix(a, b, f.z);\n}\nfloat 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; }\n/** Worley-ish cell distance in 2D (pebbles). Returns (F1, cell id hash). */\nvec2 cells21(vec2 p) {\n    vec2 i = floor(p), f = fract(p); float d = 8.0; float id = 0.0;\n    for (int y = -1; y <= 1; y++) for (int x = -1; x <= 1; x++) {\n        vec2 g = vec2(float(x), float(y)); vec2 o = hash22(i + g); vec2 r = g + o - f; float dd = dot(r, r);\n        if (dd < d) { d = dd; id = hash21(i + g); }\n    }\n    return vec2(sqrt(d), id);\n}\n\n/** The lab sky by direction: a gradient between the horizon and zenith colours set by the hour. */\nvec3 skyColor(vec3 d) { float t = clamp(d.y, 0.0, 1.0); return mix(uSkyHorizon, uSkyTop, pow(t, 0.55)); }\n\nfloat fresnelWater(vec3 N, vec3 V) { return 0.02 + 0.98 * pow(1.0 - clamp(dot(N, V), 0.0, 1.0), 5.0); }\n\n/** GGX lobe for the sun glitter on a water normal. */\nfloat ggx(vec3 N, vec3 L, vec3 V, float rough) {\n    vec3 H = normalize(L + V); float a = max(rough * rough, 2e-4); float ndh = max(dot(N, H), 0.0);\n    float d = ndh * ndh * (a * a - 1.0) + 1.0; return (a * a) / (3.14159 * d * d);\n}\n\n/** Water shading shared by every surface in the lab: body colour under sky fill + sun,\n *  reflected sky through Fresnel, a glitter path. foam (0..1) switches to a rough white. */\nvec3 shadeWater(vec3 P, vec3 N, vec3 camPos, vec3 body, vec3 foamColor, float foam, float rough, float specular) {\n    vec3 V = normalize(camPos - P);\n    vec3 L = normalize(uSunDir);\n    float NdotL = max(dot(N, L), 0.0);\n    vec3 sun = uSunColor;\n    vec3 R = reflect(-V, N); R.y = max(R.y, 0.02);\n    vec3 sky = skyColor(R);\n    float f = fresnelWater(N, V);\n    vec3 bodyLit = body * (uSkyAmbient * 0.5 + sun * (0.2 + 0.5 * NdotL));\n    vec3 col = mix(bodyLit, sky, f) + sun * ggx(N, L, V, rough) * specular * f;\n    vec3 foamLit = foamColor * (uSkyAmbient * 0.6 + sun * (0.3 + 0.7 * NdotL));\n    return mix(col, foamLit, clamp(foam, 0.0, 1.0));\n}\n\n\nuniform vec4 uRings[24];\nuniform vec3 uRingSize;\nuniform vec4 uChurn[24];\n\n/** Height + gradient of every live ring at xz (world/local metres). Each ring is a\n *  damped wave packet expanding at uRingSize.x m/s, dying over uRingSize.y s. */\nvec3 ringField(vec2 p) {\n    vec3 acc = vec3(0.0);\n    for (int i = 0; i < 24; i++) {\n        vec4 r = uRings[i];\n        float age = uTime - r.z;\n        if (age < 0.0 || age > uRingSize.y) continue;\n        vec2 d = p - r.xy; float dist = length(d);\n        float front = age * uRingSize.x;\n        float x = (dist - front) * uRingSize.z;      // phase across the packet\n        float env = exp(-x * x * 0.35) * (1.0 - age / uRingSize.y) * r.w / (1.0 + front * 1.5);\n        float h = env * sin(x * 2.2);\n        float dh = env * (2.2 * cos(x * 2.2) - 0.7 * x * sin(x * 2.2)) * uRingSize.z;\n        acc += vec3(h, dh * d / max(dist, 1e-3));\n    }\n    return acc;\n}\n/** Churn zones: boiling noise inside a radius \u2014 foam amount and a wobbling normal. */\nvec2 churnField(vec2 p, float t) {\n    float foam = 0.0; float bump = 0.0;\n    for (int i = 0; i < 24; i++) {\n        vec4 c = uChurn[i];\n        if (c.w <= 0.0) continue;\n        float d = length(p - c.xy) / max(c.z, 1e-3);\n        float w = (1.0 - smoothstep(0.55, 1.0, d)) * c.w;\n        if (w <= 0.0) continue;\n        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;\n        foam += w * smoothstep(0.35, 0.75, n + 0.25 * (1.0 - d));\n        bump += w * n;\n    }\n    return vec2(foam, bump);\n}\n\nuniform vec4 uWaves[6];\nuniform float uWaveSpeed[6];\nuniform vec2 uHalf;\nuniform float uEdgeFade;\nuniform float uRound;\nvarying vec3 vP;\nvarying vec3 vN;\nvarying vec2 vLocal;\nvarying float vFoam;\nvarying float vEdge;\nvoid main() {\n    vec2 p = position.xz;\n    float ext = uRound > 0.5 ? length(p / uHalf) : max(abs(p.x) / uHalf.x, abs(p.y) / uHalf.y);\n    float edge = 1.0 - smoothstep(1.0 - uEdgeFade, 1.0, ext);\n    float h = 0.0; vec2 g = vec2(0.0);\n    for (int i = 0; i < 6; i++) {\n        vec4 w = uWaves[i];\n        float ph = dot(w.xy, p) * w.w - uWaveSpeed[i] * uTime;\n        h += w.z * sin(ph);\n        g += w.z * w.w * cos(ph) * w.xy;\n    }\n    vec3 rf = ringField(p);\n    vec2 ch = churnField(p, uTime);\n    h += rf.x + ch.y * 0.04;\n    g += rf.yz;\n    h *= edge; g *= edge;\n    vP = (modelMatrix * vec4(p.x, h, p.y, 1.0)).xyz;\n    vN = normalize(mat3(modelMatrix) * normalize(vec3(-g.x, 1.0, -g.y)));\n    vLocal = p; vFoam = ch.x; vEdge = edge;\n    gl_Position = projectionMatrix * modelViewMatrix * vec4(p.x, h, p.y, 1.0);\n}\n";
+export declare const BASIN_FRAG = "\n\nuniform vec3 uSunDir;\nuniform vec3 uSunColor;\nuniform vec3 uSkyAmbient;\nuniform vec3 uGroundAmbient;\nuniform vec3 uSkyTop;\nuniform vec3 uSkyHorizon;\nuniform float uNight;\nuniform float uTime;\n\nfloat hash11(float p) { p = fract(p * 0.1031); p *= p + 33.33; p *= p + p; return fract(p); }\nfloat 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); }\nvec2 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); }\nfloat 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); }\nfloat 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; }\n// Gradient-ish noise with derivative, for normals: central differences on vnoise are fine at this scale.\nvec3 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); }\nfloat hash31(vec3 p) { p = fract(p * 0.1031); p += dot(p, p.zyx + 31.32); return fract((p.x + p.y) * p.z); }\nfloat vnoise31(vec3 p) {\n    vec3 i = floor(p), f = fract(p); f = f * f * (3.0 - 2.0 * f);\n    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);\n    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);\n    return mix(a, b, f.z);\n}\nfloat 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; }\n/** Worley-ish cell distance in 2D (pebbles). Returns (F1, cell id hash). */\nvec2 cells21(vec2 p) {\n    vec2 i = floor(p), f = fract(p); float d = 8.0; float id = 0.0;\n    for (int y = -1; y <= 1; y++) for (int x = -1; x <= 1; x++) {\n        vec2 g = vec2(float(x), float(y)); vec2 o = hash22(i + g); vec2 r = g + o - f; float dd = dot(r, r);\n        if (dd < d) { d = dd; id = hash21(i + g); }\n    }\n    return vec2(sqrt(d), id);\n}\n\n/** The lab sky by direction: a gradient between the horizon and zenith colours set by the hour. */\nvec3 skyColor(vec3 d) { float t = clamp(d.y, 0.0, 1.0); return mix(uSkyHorizon, uSkyTop, pow(t, 0.55)); }\n\nfloat fresnelWater(vec3 N, vec3 V) { return 0.02 + 0.98 * pow(1.0 - clamp(dot(N, V), 0.0, 1.0), 5.0); }\n\n/** GGX lobe for the sun glitter on a water normal. */\nfloat ggx(vec3 N, vec3 L, vec3 V, float rough) {\n    vec3 H = normalize(L + V); float a = max(rough * rough, 2e-4); float ndh = max(dot(N, H), 0.0);\n    float d = ndh * ndh * (a * a - 1.0) + 1.0; return (a * a) / (3.14159 * d * d);\n}\n\n/** Water shading shared by every surface in the lab: body colour under sky fill + sun,\n *  reflected sky through Fresnel, a glitter path. foam (0..1) switches to a rough white. */\nvec3 shadeWater(vec3 P, vec3 N, vec3 camPos, vec3 body, vec3 foamColor, float foam, float rough, float specular) {\n    vec3 V = normalize(camPos - P);\n    vec3 L = normalize(uSunDir);\n    float NdotL = max(dot(N, L), 0.0);\n    vec3 sun = uSunColor;\n    vec3 R = reflect(-V, N); R.y = max(R.y, 0.02);\n    vec3 sky = skyColor(R);\n    float f = fresnelWater(N, V);\n    vec3 bodyLit = body * (uSkyAmbient * 0.5 + sun * (0.2 + 0.5 * NdotL));\n    vec3 col = mix(bodyLit, sky, f) + sun * ggx(N, L, V, rough) * specular * f;\n    vec3 foamLit = foamColor * (uSkyAmbient * 0.6 + sun * (0.3 + 0.7 * NdotL));\n    return mix(col, foamLit, clamp(foam, 0.0, 1.0));\n}\n\n\nuniform vec4 uRings[24];\nuniform vec3 uRingSize;\nuniform vec4 uChurn[24];\n\n/** Height + gradient of every live ring at xz (world/local metres). Each ring is a\n *  damped wave packet expanding at uRingSize.x m/s, dying over uRingSize.y s. */\nvec3 ringField(vec2 p) {\n    vec3 acc = vec3(0.0);\n    for (int i = 0; i < 24; i++) {\n        vec4 r = uRings[i];\n        float age = uTime - r.z;\n        if (age < 0.0 || age > uRingSize.y) continue;\n        vec2 d = p - r.xy; float dist = length(d);\n        float front = age * uRingSize.x;\n        float x = (dist - front) * uRingSize.z;      // phase across the packet\n        float env = exp(-x * x * 0.35) * (1.0 - age / uRingSize.y) * r.w / (1.0 + front * 1.5);\n        float h = env * sin(x * 2.2);\n        float dh = env * (2.2 * cos(x * 2.2) - 0.7 * x * sin(x * 2.2)) * uRingSize.z;\n        acc += vec3(h, dh * d / max(dist, 1e-3));\n    }\n    return acc;\n}\n/** Churn zones: boiling noise inside a radius \u2014 foam amount and a wobbling normal. */\nvec2 churnField(vec2 p, float t) {\n    float foam = 0.0; float bump = 0.0;\n    for (int i = 0; i < 24; i++) {\n        vec4 c = uChurn[i];\n        if (c.w <= 0.0) continue;\n        float d = length(p - c.xy) / max(c.z, 1e-3);\n        float w = (1.0 - smoothstep(0.55, 1.0, d)) * c.w;\n        if (w <= 0.0) continue;\n        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;\n        foam += w * smoothstep(0.35, 0.75, n + 0.25 * (1.0 - d));\n        bump += w * n;\n    }\n    return vec2(foam, bump);\n}\n\nuniform vec3 uDeepColor, uShallowColor, uFoamColor;\nuniform float uRough, uSpecular, uDetail, uDetailSize;\nuniform vec3 uCamPos;\nuniform float uFloor, uFloorDepth, uFloorTile;\nuniform vec3 uAbsorb, uFloorA, uFloorB;\n/** The basin floor seen through the surface: refracted lookup, tiles or pebbles, caustic light,\n *  Beer-Lambert absorption over the depth so the floor is tinted by the water. */\nvec3 floorThrough(vec2 p, vec3 N, vec3 V, vec3 fallback) {\n    // refraction: the view ray bends toward the normal; offset the floor lookup by the normal's tilt\n    vec2 off = -N.xz * uFloorDepth * 1.6 - V.xz / max(V.y, 0.2) * uFloorDepth * 0.35;\n    vec2 fp = p + off;\n    vec3 fc;\n    if (uFloorTile > 0.0) {\n        vec2 g = fract(fp / uFloorTile); vec2 id = floor(fp / uFloorTile);\n        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);\n        fc = mix(uFloorA, uFloorB, hash21(id) * 0.6 + vnoise21(fp * 3.0) * 0.4) * (0.55 + 0.45 * grout);\n    } else {\n        vec2 cl = cells21(fp * 2.5);\n        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));\n    }\n    // caustics: bright web from the surface ripples\n    float ca = pow(vnoise21(fp * 4.0 + uTime * 0.6) * vnoise21(fp * 4.0 - uTime * 0.5 + 3.0), 1.5) * 2.5;\n    vec3 L = normalize(uSunDir);\n    fc *= uSkyAmbient * 0.6 + uSunColor * (0.35 + 0.5 * ca) * max(L.y, 0.0);\n    vec3 T = exp(-uAbsorb * uFloorDepth * 2.0);\n    return mix(fallback, fc * T + uDeepColor * (1.0 - T) * 0.6, uFloor);\n}\nvarying vec3 vP; varying vec3 vN; varying vec2 vLocal; varying float vFoam; varying float vEdge;\nvoid main() {\n    vec3 N = normalize(vN);\n    // sub-mesh ripple detail, advected by a slow drift\n    vec3 n1 = noised21(vLocal / uDetailSize + vec2(uTime * 0.35, uTime * 0.2), 0.05);\n    vec3 n2 = noised21(vLocal / (uDetailSize * 0.45) - vec2(uTime * 0.5, -uTime * 0.3), 0.05);\n    vec2 dn = (n1.yz + n2.yz * 0.5) * uDetail * 2.5;\n    N = normalize(N + vec3(-dn.x, 0.0, -dn.y) * vEdge);\n    // churn roughens the surface too\n    vec2 ch = churnField(vLocal, uTime);\n    float rough = uRough + ch.x * 0.3;\n    vec3 body = mix(uDeepColor, uShallowColor, 0.15);\n    vec3 V = normalize(uCamPos - vP);\n    body = floorThrough(vLocal, N, V, body);\n    vec3 col = shadeWater(vP, N, uCamPos, body, uFoamColor, ch.x, rough, uSpecular);\n    gl_FragColor = vec4(col, 1.0);\n    #include <colorspace_fragment>\n}\n";
+export declare function createBasinMaterial(u: any): THREE.ShaderMaterial;
+/** A basin mesh: w x d metres in XZ, segments per side. */
+export declare function createBasin(u: any, w: any, d: any, segs?: number, round?: boolean): THREE.Mesh<THREE.PlaneGeometry | THREE.CircleGeometry, THREE.ShaderMaterial, THREE.Object3DEventMap>;
+/** 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 declare function instancedQuads(n: any, seedFn: any): THREE.InstancedBufferGeometry;
+/** Billboard helper for the vertex stage: world position of the quad centre + size (m) -> clip. */
+export declare const GLSL_BILLBOARD = "\nvec4 billboard(vec3 worldCentre, vec2 corner, float size, float stretchY, vec3 stretchDir) {\n    vec4 mv = viewMatrix * vec4(worldCentre, 1.0);\n    vec3 dirV = normalize((viewMatrix * vec4(stretchDir, 0.0)).xyz);\n    vec3 up = stretchY > 0.0 ? dirV : vec3(0.0, 1.0, 0.0);\n    vec3 right = vec3(up.y, -up.x, 0.0);\n    if (length(right) < 1e-4) right = vec3(1.0, 0.0, 0.0);\n    right = normalize(right);\n    mv.xyz += right * corner.x * size + up * corner.y * size * (1.0 + stretchY);\n    return projectionMatrix * mv;\n}\n";
+export declare function samplePath(points: any, curve?: number, closed?: boolean, step?: number): {
+    samples: any[];
+    length: number;
+};
+export declare function jfbm(x: any, y: any, z: any, oct?: number): number;
+/** Displace a geometry along its normals by fbm (in the geometry's own space) and recompute smooth normals. */
+export declare function displaceRock(geo: any, amount: any, scale?: number, seed?: number): any;
+export declare const ROCK_VERT = "\n\nuniform vec3 uSunDir;\nuniform vec3 uSunColor;\nuniform vec3 uSkyAmbient;\nuniform vec3 uGroundAmbient;\nuniform vec3 uSkyTop;\nuniform vec3 uSkyHorizon;\nuniform float uNight;\nuniform float uTime;\n\nfloat hash11(float p) { p = fract(p * 0.1031); p *= p + 33.33; p *= p + p; return fract(p); }\nfloat 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); }\nvec2 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); }\nfloat 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); }\nfloat 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; }\n// Gradient-ish noise with derivative, for normals: central differences on vnoise are fine at this scale.\nvec3 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); }\nfloat hash31(vec3 p) { p = fract(p * 0.1031); p += dot(p, p.zyx + 31.32); return fract((p.x + p.y) * p.z); }\nfloat vnoise31(vec3 p) {\n    vec3 i = floor(p), f = fract(p); f = f * f * (3.0 - 2.0 * f);\n    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);\n    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);\n    return mix(a, b, f.z);\n}\nfloat 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; }\n/** Worley-ish cell distance in 2D (pebbles). Returns (F1, cell id hash). */\nvec2 cells21(vec2 p) {\n    vec2 i = floor(p), f = fract(p); float d = 8.0; float id = 0.0;\n    for (int y = -1; y <= 1; y++) for (int x = -1; x <= 1; x++) {\n        vec2 g = vec2(float(x), float(y)); vec2 o = hash22(i + g); vec2 r = g + o - f; float dd = dot(r, r);\n        if (dd < d) { d = dd; id = hash21(i + g); }\n    }\n    return vec2(sqrt(d), id);\n}\n\n/** The lab sky by direction: a gradient between the horizon and zenith colours set by the hour. */\nvec3 skyColor(vec3 d) { float t = clamp(d.y, 0.0, 1.0); return mix(uSkyHorizon, uSkyTop, pow(t, 0.55)); }\n\nfloat fresnelWater(vec3 N, vec3 V) { return 0.02 + 0.98 * pow(1.0 - clamp(dot(N, V), 0.0, 1.0), 5.0); }\n\n/** GGX lobe for the sun glitter on a water normal. */\nfloat ggx(vec3 N, vec3 L, vec3 V, float rough) {\n    vec3 H = normalize(L + V); float a = max(rough * rough, 2e-4); float ndh = max(dot(N, H), 0.0);\n    float d = ndh * ndh * (a * a - 1.0) + 1.0; return (a * a) / (3.14159 * d * d);\n}\n\n/** Water shading shared by every surface in the lab: body colour under sky fill + sun,\n *  reflected sky through Fresnel, a glitter path. foam (0..1) switches to a rough white. */\nvec3 shadeWater(vec3 P, vec3 N, vec3 camPos, vec3 body, vec3 foamColor, float foam, float rough, float specular) {\n    vec3 V = normalize(camPos - P);\n    vec3 L = normalize(uSunDir);\n    float NdotL = max(dot(N, L), 0.0);\n    vec3 sun = uSunColor;\n    vec3 R = reflect(-V, N); R.y = max(R.y, 0.02);\n    vec3 sky = skyColor(R);\n    float f = fresnelWater(N, V);\n    vec3 bodyLit = body * (uSkyAmbient * 0.5 + sun * (0.2 + 0.5 * NdotL));\n    vec3 col = mix(bodyLit, sky, f) + sun * ggx(N, L, V, rough) * specular * f;\n    vec3 foamLit = foamColor * (uSkyAmbient * 0.6 + sun * (0.3 + 0.7 * NdotL));\n    return mix(col, foamLit, clamp(foam, 0.0, 1.0));\n}\n\nvarying vec3 vP; varying vec3 vN;\nvoid main() {\n    vP = (modelMatrix * vec4(position, 1.0)).xyz;\n    vN = normalize(mat3(modelMatrix) * normal);\n    gl_Position = projectionMatrix * viewMatrix * vec4(vP, 1.0);\n}\n";
+export declare const ROCK_FRAG = "\n\nuniform vec3 uSunDir;\nuniform vec3 uSunColor;\nuniform vec3 uSkyAmbient;\nuniform vec3 uGroundAmbient;\nuniform vec3 uSkyTop;\nuniform vec3 uSkyHorizon;\nuniform float uNight;\nuniform float uTime;\n\nfloat hash11(float p) { p = fract(p * 0.1031); p *= p + 33.33; p *= p + p; return fract(p); }\nfloat 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); }\nvec2 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); }\nfloat 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); }\nfloat 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; }\n// Gradient-ish noise with derivative, for normals: central differences on vnoise are fine at this scale.\nvec3 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); }\nfloat hash31(vec3 p) { p = fract(p * 0.1031); p += dot(p, p.zyx + 31.32); return fract((p.x + p.y) * p.z); }\nfloat vnoise31(vec3 p) {\n    vec3 i = floor(p), f = fract(p); f = f * f * (3.0 - 2.0 * f);\n    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);\n    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);\n    return mix(a, b, f.z);\n}\nfloat 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; }\n/** Worley-ish cell distance in 2D (pebbles). Returns (F1, cell id hash). */\nvec2 cells21(vec2 p) {\n    vec2 i = floor(p), f = fract(p); float d = 8.0; float id = 0.0;\n    for (int y = -1; y <= 1; y++) for (int x = -1; x <= 1; x++) {\n        vec2 g = vec2(float(x), float(y)); vec2 o = hash22(i + g); vec2 r = g + o - f; float dd = dot(r, r);\n        if (dd < d) { d = dd; id = hash21(i + g); }\n    }\n    return vec2(sqrt(d), id);\n}\n\n/** The lab sky by direction: a gradient between the horizon and zenith colours set by the hour. */\nvec3 skyColor(vec3 d) { float t = clamp(d.y, 0.0, 1.0); return mix(uSkyHorizon, uSkyTop, pow(t, 0.55)); }\n\nfloat fresnelWater(vec3 N, vec3 V) { return 0.02 + 0.98 * pow(1.0 - clamp(dot(N, V), 0.0, 1.0), 5.0); }\n\n/** GGX lobe for the sun glitter on a water normal. */\nfloat ggx(vec3 N, vec3 L, vec3 V, float rough) {\n    vec3 H = normalize(L + V); float a = max(rough * rough, 2e-4); float ndh = max(dot(N, H), 0.0);\n    float d = ndh * ndh * (a * a - 1.0) + 1.0; return (a * a) / (3.14159 * d * d);\n}\n\n/** Water shading shared by every surface in the lab: body colour under sky fill + sun,\n *  reflected sky through Fresnel, a glitter path. foam (0..1) switches to a rough white. */\nvec3 shadeWater(vec3 P, vec3 N, vec3 camPos, vec3 body, vec3 foamColor, float foam, float rough, float specular) {\n    vec3 V = normalize(camPos - P);\n    vec3 L = normalize(uSunDir);\n    float NdotL = max(dot(N, L), 0.0);\n    vec3 sun = uSunColor;\n    vec3 R = reflect(-V, N); R.y = max(R.y, 0.02);\n    vec3 sky = skyColor(R);\n    float f = fresnelWater(N, V);\n    vec3 bodyLit = body * (uSkyAmbient * 0.5 + sun * (0.2 + 0.5 * NdotL));\n    vec3 col = mix(bodyLit, sky, f) + sun * ggx(N, L, V, rough) * specular * f;\n    vec3 foamLit = foamColor * (uSkyAmbient * 0.6 + sun * (0.3 + 0.7 * NdotL));\n    return mix(col, foamLit, clamp(foam, 0.0, 1.0));\n}\n\nuniform vec3 uRockA, uRockB, uMoss;\nuniform float uWet;        // 0..1 darkens + glosses the rock near water\nuniform float uWetHeight;  // world y under which the rock is wet\nvarying vec3 vP; varying vec3 vN;\nvoid main() {\n    vec3 N = normalize(vN);\n    // triplanar-ish detail: strata + grain\n    float strata = smoothstep(0.3, 0.7, fbm31(vec3(vP.x * 0.5, vP.y * 2.5, vP.z * 0.5)));\n    float grain = fbm31(vP * 5.0);\n    float crack = 1.0 - smoothstep(0.0, 0.02, abs(fbm31(vP * 1.6) - 0.5));\n    // bump: a small tilt from fine noise derivatives\n    float e = 0.08;\n    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    N = normalize(N - vec3(bx - b0, by - b0, bz - b0) * 1.6);\n    vec3 col = mix(uRockA, uRockB, strata * 0.55 + grain * 0.45) * (1.0 - 0.18 * crack);\n    float moss = smoothstep(0.2, 0.8, N.y) * smoothstep(0.45, 0.7, fbm31(vP * 1.3 + 5.0));\n    col = mix(col, uMoss, moss * 0.8);\n    float wet = uWet * smoothstep(uWetHeight + 1.5, uWetHeight - 0.5, vP.y);\n    col *= 1.0 - 0.45 * wet;\n    vec3 L = normalize(uSunDir);\n    float NdotL = max(dot(N, L), 0.0);\n    vec3 amb = mix(uGroundAmbient, uSkyAmbient, N.y * 0.5 + 0.5);\n    vec3 lit = col * (amb * 0.9 + uSunColor * NdotL * 0.9);\n    vec3 V = normalize(cameraPosition - vP);\n    lit += uSunColor * ggx(N, L, V, 0.35 - 0.2 * wet) * (0.02 + 0.3 * wet) * fresnelWater(N, V);\n    gl_FragColor = vec4(lit, 1.0);\n    #include <colorspace_fragment>\n}\n";
+export declare function createRockMaterial(sunU: any, options?: any): THREE.ShaderMaterial;
+/** box: { center: Vector3, size: Vector3 } in the object's local space. */
+export declare const MIST_VERT = "\n\nuniform vec3 uSunDir;\nuniform vec3 uSunColor;\nuniform vec3 uSkyAmbient;\nuniform vec3 uGroundAmbient;\nuniform vec3 uSkyTop;\nuniform vec3 uSkyHorizon;\nuniform float uNight;\nuniform float uTime;\n\nfloat hash11(float p) { p = fract(p * 0.1031); p *= p + 33.33; p *= p + p; return fract(p); }\nfloat 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); }\nvec2 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); }\nfloat 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); }\nfloat 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; }\n// Gradient-ish noise with derivative, for normals: central differences on vnoise are fine at this scale.\nvec3 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); }\nfloat hash31(vec3 p) { p = fract(p * 0.1031); p += dot(p, p.zyx + 31.32); return fract((p.x + p.y) * p.z); }\nfloat vnoise31(vec3 p) {\n    vec3 i = floor(p), f = fract(p); f = f * f * (3.0 - 2.0 * f);\n    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);\n    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);\n    return mix(a, b, f.z);\n}\nfloat 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; }\n/** Worley-ish cell distance in 2D (pebbles). Returns (F1, cell id hash). */\nvec2 cells21(vec2 p) {\n    vec2 i = floor(p), f = fract(p); float d = 8.0; float id = 0.0;\n    for (int y = -1; y <= 1; y++) for (int x = -1; x <= 1; x++) {\n        vec2 g = vec2(float(x), float(y)); vec2 o = hash22(i + g); vec2 r = g + o - f; float dd = dot(r, r);\n        if (dd < d) { d = dd; id = hash21(i + g); }\n    }\n    return vec2(sqrt(d), id);\n}\n\n/** The lab sky by direction: a gradient between the horizon and zenith colours set by the hour. */\nvec3 skyColor(vec3 d) { float t = clamp(d.y, 0.0, 1.0); return mix(uSkyHorizon, uSkyTop, pow(t, 0.55)); }\n\nfloat fresnelWater(vec3 N, vec3 V) { return 0.02 + 0.98 * pow(1.0 - clamp(dot(N, V), 0.0, 1.0), 5.0); }\n\n/** GGX lobe for the sun glitter on a water normal. */\nfloat ggx(vec3 N, vec3 L, vec3 V, float rough) {\n    vec3 H = normalize(L + V); float a = max(rough * rough, 2e-4); float ndh = max(dot(N, H), 0.0);\n    float d = ndh * ndh * (a * a - 1.0) + 1.0; return (a * a) / (3.14159 * d * d);\n}\n\n/** Water shading shared by every surface in the lab: body colour under sky fill + sun,\n *  reflected sky through Fresnel, a glitter path. foam (0..1) switches to a rough white. */\nvec3 shadeWater(vec3 P, vec3 N, vec3 camPos, vec3 body, vec3 foamColor, float foam, float rough, float specular) {\n    vec3 V = normalize(camPos - P);\n    vec3 L = normalize(uSunDir);\n    float NdotL = max(dot(N, L), 0.0);\n    vec3 sun = uSunColor;\n    vec3 R = reflect(-V, N); R.y = max(R.y, 0.02);\n    vec3 sky = skyColor(R);\n    float f = fresnelWater(N, V);\n    vec3 bodyLit = body * (uSkyAmbient * 0.5 + sun * (0.2 + 0.5 * NdotL));\n    vec3 col = mix(bodyLit, sky, f) + sun * ggx(N, L, V, rough) * specular * f;\n    vec3 foamLit = foamColor * (uSkyAmbient * 0.6 + sun * (0.3 + 0.7 * NdotL));\n    return mix(col, foamLit, clamp(foam, 0.0, 1.0));\n}\n\nattribute float aSlice;     // 0 (far) .. 1 (near)\nuniform vec3 uBoxCenter, uBoxSize;\nuniform float uSlices;\nvarying vec3 vWorld; varying float vSlice;\nvoid main() {\n    vSlice = aSlice;\n    vec3 c = (modelMatrix * vec4(uBoxCenter, 1.0)).xyz;\n    vec3 viewDir = normalize(cameraPosition - c);\n    float radius = length(uBoxSize) * 0.5;\n    vec3 centre = c - viewDir * radius * (1.0 - 2.0 * aSlice) * 0.95;\n    vec3 right = normalize(cross(vec3(0.0, 1.0, 0.0), viewDir));\n    vec3 up = cross(viewDir, right);\n    vec3 wp = centre + right * position.x * radius * 2.0 + up * position.y * radius * 2.0;\n    vWorld = wp;\n    gl_Position = projectionMatrix * viewMatrix * vec4(wp, 1.0);\n}\n";
+export declare const MIST_FRAG = "\n\nuniform vec3 uSunDir;\nuniform vec3 uSunColor;\nuniform vec3 uSkyAmbient;\nuniform vec3 uGroundAmbient;\nuniform vec3 uSkyTop;\nuniform vec3 uSkyHorizon;\nuniform float uNight;\nuniform float uTime;\n\nfloat hash11(float p) { p = fract(p * 0.1031); p *= p + 33.33; p *= p + p; return fract(p); }\nfloat 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); }\nvec2 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); }\nfloat 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); }\nfloat 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; }\n// Gradient-ish noise with derivative, for normals: central differences on vnoise are fine at this scale.\nvec3 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); }\nfloat hash31(vec3 p) { p = fract(p * 0.1031); p += dot(p, p.zyx + 31.32); return fract((p.x + p.y) * p.z); }\nfloat vnoise31(vec3 p) {\n    vec3 i = floor(p), f = fract(p); f = f * f * (3.0 - 2.0 * f);\n    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);\n    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);\n    return mix(a, b, f.z);\n}\nfloat 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; }\n/** Worley-ish cell distance in 2D (pebbles). Returns (F1, cell id hash). */\nvec2 cells21(vec2 p) {\n    vec2 i = floor(p), f = fract(p); float d = 8.0; float id = 0.0;\n    for (int y = -1; y <= 1; y++) for (int x = -1; x <= 1; x++) {\n        vec2 g = vec2(float(x), float(y)); vec2 o = hash22(i + g); vec2 r = g + o - f; float dd = dot(r, r);\n        if (dd < d) { d = dd; id = hash21(i + g); }\n    }\n    return vec2(sqrt(d), id);\n}\n\n/** The lab sky by direction: a gradient between the horizon and zenith colours set by the hour. */\nvec3 skyColor(vec3 d) { float t = clamp(d.y, 0.0, 1.0); return mix(uSkyHorizon, uSkyTop, pow(t, 0.55)); }\n\nfloat fresnelWater(vec3 N, vec3 V) { return 0.02 + 0.98 * pow(1.0 - clamp(dot(N, V), 0.0, 1.0), 5.0); }\n\n/** GGX lobe for the sun glitter on a water normal. */\nfloat ggx(vec3 N, vec3 L, vec3 V, float rough) {\n    vec3 H = normalize(L + V); float a = max(rough * rough, 2e-4); float ndh = max(dot(N, H), 0.0);\n    float d = ndh * ndh * (a * a - 1.0) + 1.0; return (a * a) / (3.14159 * d * d);\n}\n\n/** Water shading shared by every surface in the lab: body colour under sky fill + sun,\n *  reflected sky through Fresnel, a glitter path. foam (0..1) switches to a rough white. */\nvec3 shadeWater(vec3 P, vec3 N, vec3 camPos, vec3 body, vec3 foamColor, float foam, float rough, float specular) {\n    vec3 V = normalize(camPos - P);\n    vec3 L = normalize(uSunDir);\n    float NdotL = max(dot(N, L), 0.0);\n    vec3 sun = uSunColor;\n    vec3 R = reflect(-V, N); R.y = max(R.y, 0.02);\n    vec3 sky = skyColor(R);\n    float f = fresnelWater(N, V);\n    vec3 bodyLit = body * (uSkyAmbient * 0.5 + sun * (0.2 + 0.5 * NdotL));\n    vec3 col = mix(bodyLit, sky, f) + sun * ggx(N, L, V, rough) * specular * f;\n    vec3 foamLit = foamColor * (uSkyAmbient * 0.6 + sun * (0.3 + 0.7 * NdotL));\n    return mix(col, foamLit, clamp(foam, 0.0, 1.0));\n}\n\nuniform vec3 uBoxCenter, uBoxSize;\nuniform float uSlices, uDensity, uRise;\nuniform vec3 uMistColor;\nuniform mat4 uInvModel;\nvarying vec3 vWorld; varying float vSlice;\nvoid main() {\n    vec3 lp = (uInvModel * vec4(vWorld, 1.0)).xyz - uBoxCenter;\n    vec3 q = lp / (uBoxSize * 0.5);\n    float r2 = dot(q, q);\n    if (r2 > 1.0) discard;\n    // density: dense at the foot, thinning upward and outward; drifting + rising noise\n    vec3 np = lp * 0.9 + vec3(uTime * 0.25, -uTime * uRise, uTime * 0.1);\n    float n = fbm31(np) * 0.7 + fbm31(np * 2.3 + 9.0) * 0.3;\n    float shape = (1.0 - r2) * (1.0 - smoothstep(-0.2, 1.0, q.y) * 0.85);\n    float d = max(n - 0.42, 0.0) * 2.2 * shape * uDensity;\n    float thickness = length(uBoxSize) / uSlices;\n    float a = 1.0 - exp(-d * thickness);\n    if (a < 0.003) discard;\n    // lit by the sky with a little forward-scattered sun\n    vec3 V = normalize(cameraPosition - vWorld);\n    float fwd = pow(max(dot(-V, normalize(uSunDir)), 0.0), 3.0);\n    vec3 lit = uMistColor * (uSkyAmbient * 0.75 + uSunColor * (0.18 + 0.35 * fwd));\n    gl_FragColor = vec4(lit * a, a);\n    #include <colorspace_fragment>\n}\n";
+export declare function createMistVolume(sunU: any, center: any, size: any, slices?: number, density?: number, color?: string): {
+    mesh: THREE.Mesh<THREE.InstancedBufferGeometry, THREE.ShaderMaterial, THREE.Object3DEventMap>;
+    u: any;
+};
+/** The sun model the water cores read (applySun): filled from the scene by useWaterInstance. */
+export type SunModel = {
+    direction: THREE.Vector3;
+    color: THREE.Color;
+    skyAmbient: THREE.Color;
+    groundAmbient: THREE.Color;
+    skyTop: THREE.Color;
+    skyHorizon: THREE.Color;
+    night: number;
+};
+//# sourceMappingURL=waterCore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"waterCore.d.ts","sourceRoot":"","sources":["../../../src/components/water/waterCore.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,eAAO,MAAM,SAAS,KAAK,CAAC;AAC5B,eAAO,MAAM,SAAS,KAAK,CAAC;AAE5B,wBAAgB,UAAU,CAAC,CAAC,KAAA,gBAO3B;AACD,eAAO,MAAM,OAAO,GAAI,MAAC,WAAgC,CAAC;AAG1D,wBAAgB,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;EAWhC;AACD,wBAAgB,QAAQ,CAAC,CAAC,KAAA,EAAE,GAAG,KAAA,QAQ9B;AAGD,eAAO,MAAM,WAAW,mrHA6DvB,CAAC;AAGF,wBAAgB,yBAAyB;;;;;;;;;;EAMxC;AACD,kEAAkE;AAClE,wBAAgB,WAAW,CAAC,CAAC,KAAA,IAEjB,MAAC,EAAE,MAAC,EAAE,QAAG,EAAE,QAAG,UACzB;AAED,eAAO,MAAM,YAAY,+jDAsCxB,CAAC;AAGF,wBAAgB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBlC;AAED,0EAA0E;AAC1E,wBAAgB,cAAc,CAAC,CAAC,KAAA,EAAE,SAAS,KAAA,EAAE,UAAU,KAAA,EAAE,MAAM,KAAA,EAAE,MAAM,SAAK,QAe3E;AAED,eAAO,MAAM,UAAU,myMAkCtB,CAAC;AACF,eAAO,MAAM,UAAU,0tPAgDtB,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,CAAC,KAAA,wBAEpC;AAED,2DAA2D;AAC3D,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,EAAE,CAAC,KAAA,EAAE,IAAI,SAAK,EAAE,KAAK,UAAQ,wGAiB5D;AAGD;+EAC+E;AAC/E,wBAAgB,cAAc,CAAC,CAAC,KAAA,EAAE,MAAM,KAAA,iCAUvC;AAED,mGAAmG;AACnG,eAAO,MAAM,cAAc,whBAW1B,CAAC;AAGF,wBAAgB,UAAU,CAAC,MAAM,KAAA,EAAE,KAAK,SAAM,EAAE,MAAM,UAAQ,EAAE,IAAI,SAAM;;;EAiBzE;AAaD,wBAAgB,IAAI,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,EAAE,CAAC,KAAA,EAAE,GAAG,SAAI,UAAgK;AACrM,+GAA+G;AAC/G,wBAAgB,YAAY,CAAC,GAAG,KAAA,EAAE,MAAM,KAAA,EAAE,KAAK,SAAO,EAAE,IAAI,SAAI,OAU/D;AAED,eAAO,MAAM,SAAS,k5HAQrB,CAAC;AACF,eAAO,MAAM,SAAS,ysKA8BrB,CAAC;AACF,wBAAgB,kBAAkB,CAAC,IAAI,KAAA,EAAE,OAAO,MAAY,wBAM3D;AAGD,2EAA2E;AAC3E,eAAO,MAAM,SAAS,k3IAkBrB,CAAC;AACF,eAAO,MAAM,SAAS,m0JA2BrB,CAAC;AACF,wBAAgB,gBAAgB,CAAC,IAAI,KAAA,EAAE,MAAM,KAAA,EAAE,IAAI,KAAA,EAAE,MAAM,SAAK,EAAE,OAAO,SAAI,EAAE,KAAK,SAAY;;;EAY/F;AAED,gGAAgG;AAChG,MAAM,MAAM,QAAQ,GAAG;IACnB,SAAS,EAAE,KAAK,CAAC,OAAO,CAAC;IAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;IAAC,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC;IAAC,aAAa,EAAE,KAAK,CAAC,KAAK,CAAC;IAClG,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC;IAAC,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;CAC/D,CAAC"}