@3driseai/3drise-viewer 0.1.42 → 0.1.43

package/dist/components/volumetricClouds/VolumetricCloudsPass.d.ts

@@ -21,6 +21,11 @@ import type { ObjectAnimations, MouseMoveInteractions } from '@3driseai/3drise-c
  * history, so a still view converges to the same image within four frames. The cost
  * is a little temporal lag and this component owning the loop.
  *
+ * With post-processing on, the composer hosts steps 2-5 instead (see
+ * composerHostedPass): its RenderPass has drawn the scene, so step 1 is skipped,
+ * and step 5 writes the composer's next buffer untonemapped — the chain's own
+ * ToneMapping runs last. Drawing the scene here as well doubled the frame.
+ *
  * If it unmounts, R3F resumes its own auto-render and the scene draws normally
  * without clouds — so hiding it is safe.
  */

package/dist/components/volumetricClouds/VolumetricCloudsPass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VolumetricCloudsPass.d.ts","sourceRoot":"","sources":["../../../src/components/volumetricClouds/VolumetricCloudsPass.tsx"],"names":[],"mappings":"AACA,OAAO,KAAkD,MAAM,OAAO,CAAC;AAKvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAQvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEpH,OAAO,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAErF;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,WAAW,yBAA0B,SAAQ,gBAAgB;IAC/D,6EAA6E;IAC7E,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC;IAC9B,MAAM,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAClC,OAAO,EAAE,mBAAmB,CAAC;IAC7B;oDACgD;IAChD,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,qFAAqF;IACrF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,6DAA6D;IAC7D,SAAS,CAAC,EAAE,qBAAqB,CAAC;CACrC;AA8BD,QAAA,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC,yBAAyB,CAqW7D,CAAC;AAEF,eAAe,oBAAoB,CAAC"}
+{"version":3,"file":"VolumetricCloudsPass.d.ts","sourceRoot":"","sources":["../../../src/components/volumetricClouds/VolumetricCloudsPass.tsx"],"names":[],"mappings":"AACA,OAAO,KAAkD,MAAM,OAAO,CAAC;AAMvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAQvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEpH,OAAO,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAErF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,MAAM,WAAW,yBAA0B,SAAQ,gBAAgB;IAC/D,6EAA6E;IAC7E,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC;IAC9B,MAAM,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAClC,OAAO,EAAE,mBAAmB,CAAC;IAC7B;oDACgD;IAChD,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,qFAAqF;IACrF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,6DAA6D;IAC7D,SAAS,CAAC,EAAE,qBAAqB,CAAC;CACrC;AA8BD,QAAA,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC,yBAAyB,CA4X7D,CAAC;AAEF,eAAe,oBAAoB,CAAC"}

package/dist/components/volumetricClouds/VolumetricCloudsPass.js

@@ -3,6 +3,7 @@ import * as THREE from 'three';
 import { useCallback, useEffect, useMemo, useRef } from 'react';
 import { useFrame, useThree } from '@react-three/fiber';
 import { useFrameRenderer } from '../../hooks/useFrameRenderer.js';
+import { createHostedPass, publishHostedPass } from '../../utils/composerHostedPass.js';
 import { useThunder } from '../../hooks/useThunder.js';
 import { useObjectReady } from '../../hooks/useObjectReady.js';
 import { CLOUD_LIVE_KEY } from '../../hooks/useCloudLive.js';
@@ -180,7 +181,7 @@ const VolumetricCloudsPass = ({ id = '3drise-clouds', deck, cirrus, quality, thu
     // held in a ref rather than a useCallback because it closes over a dozen pieces of
     // per-frame state, and a dependency array over all of them would be re-created
     // every render anyway — which would re-register the frame renderer every render.
-    const drawFrame = (camera, pointer, delta) => {
+    const drawFrame = (camera, pointer, delta, host) => {
         if (!noise)
             return;
         frame.current += 1;
@@ -210,15 +211,26 @@ const VolumetricCloudsPass = ({ id = '3drise-clouds', deck, cirrus, quality, thu
             }
         }
         // ---- 1. scene ----
-        const sceneRT = (frame.current & 1) ? targets.sceneA : targets.sceneB;
         const prevTarget = gl.getRenderTarget();
         const prevAutoClear = gl.autoClear;
         gl.autoClear = true;
-        gl.setRenderTarget(sceneRT);
-        // No sky pass. SkyController / Skybox already drew the background into this
-        // target; the clouds only borrow the atmosphere function for ambient and
-        // aerial perspective, so a second sky would just fight the first.
-        gl.render(scene, camera);
+        let sceneTex;
+        let depthTex;
+        if (host) {
+            // Hosted: the composer's RenderPass already drew the scene, depth included.
+            sceneTex = host.scene;
+            depthTex = host.depth;
+        }
+        else {
+            const sceneRT = (frame.current & 1) ? targets.sceneA : targets.sceneB;
+            gl.setRenderTarget(sceneRT);
+            // No sky pass. SkyController / Skybox already drew the background into this
+            // target; the clouds only borrow the atmosphere function for ambient and
+            // aerial perspective, so a second sky would just fight the first.
+            gl.render(scene, camera);
+            sceneTex = sceneRT.texture;
+            depthTex = sceneRT.depthTexture;
+        }
         // Which pixel of every 2x2 block the deck traces this frame. A diagonal-first
         // order, so two consecutive frames never trace neighbours on the same row.
         const [ox, oy] = INTERLEAVE[frame.current & 3];
@@ -231,8 +243,8 @@ const VolumetricCloudsPass = ({ id = '3drise-clouds', deck, cirrus, quality, thu
             m.uniforms.u_time.value = time.current;
             if (m.uniforms.u_frame)
                 m.uniforms.u_frame.value = frame.current;
-            m.uniforms.u_depth.value = sceneRT.depthTexture;
-            m.uniforms.u_hasDepth.value = 1;
+            m.uniforms.u_depth.value = depthTex ?? empty;
+            m.uniforms.u_hasDepth.value = depthTex ? 1 : 0;
             m.uniforms.u_screenSpace.value = 1;
         };
         // ---- 2 & 3. deck march, then temporal resolve ----
@@ -322,16 +334,19 @@ const VolumetricCloudsPass = ({ id = '3drise-clouds', deck, cirrus, quality, thu
         }
         // ---- 5. composite ----
         const c = passes.compositeMat.uniforms;
-        c.u_scene.value = sceneRT.texture;
+        c.u_scene.value = sceneTex;
         c.u_clouds.value = deckTex;
         c.u_cirrus.value = cirrusTex;
-        c.u_depth.value = sceneRT.depthTexture;
+        c.u_depth.value = depthTex ?? empty;
         c.u_lowTexel.value.set(1 / lowW, 1 / lowH);
         c.u_exposure.value = quality.exposure;
-        c.u_tonemap.value = quality.tonemap ? 1 : 0;
+        // Hosted mid-chain, the output stays linear HDR: the chain's ToneMapping is the
+        // one tonemap. Only as the canvas writer does this pass tonemap itself.
+        c.u_tonemap.value = (quality.tonemap && (!host || host.toScreen)) ? 1 : 0;
         c.u_hasCirrus.value = cirrusOn ? 1 : 0;
-        gl.setRenderTarget(prevTarget);
+        gl.setRenderTarget(host ? host.output : prevTarget);
         gl.render(passes.compositeScene, orthoCam);
+        gl.setRenderTarget(prevTarget);
         gl.autoClear = prevAutoClear;
         prevViewProj.current.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
         prevCamPos.current.copy(camera.position);
@@ -342,8 +357,19 @@ const VolumetricCloudsPass = ({ id = '3drise-clouds', deck, cirrus, quality, thu
     const drawRef = useRef(drawFrame);
     drawRef.current = drawFrame;
     const pointerRef = useRef(new THREE.Vector2());
+    const stateCamera = useThree((s) => s.camera);
+    const cameraRef = useRef(stateCamera);
+    cameraRef.current = stateCamera;
+    // Offered to the post-processing composer. While one hosts it, the composer drives
+    // the frame and calls this from inside its chain; the loop below stands down.
+    const hostedPass = useMemo(() => createHostedPass('VolumetricClouds', (input, deltaTime) => {
+        drawRef.current(cameraRef.current, pointerRef.current, deltaTime, input);
+    }), []);
+    useEffect(() => publishHostedPass(gl, hostedPass), [gl, hostedPass]);
     useFrame((state, delta) => {
         pointerRef.current.copy(state.pointer);
+        if (hostedPass.hosted)
+            return;
         drawRef.current(state.camera, state.pointer, delta);
     }, 1);
     // This pass composites to the canvas itself, so gl.render(scene, camera) is not a

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

@@ -1 +1 @@
-{"version":3,"file":"OceanSurface.d.ts","sourceRoot":"","sources":["../../../src/components/water/OceanSurface.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAiB,MAAM,OAAO,CAAC;AAItC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CA+D3C,CAAC;AAEF,eAAe,YAAY,CAAC"}
+{"version":3,"file":"OceanSurface.d.ts","sourceRoot":"","sources":["../../../src/components/water/OceanSurface.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAiB,MAAM,OAAO,CAAC;AAItC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAiE3C,CAAC;AAEF,eAAe,YAAY,CAAC"}

package/dist/components/water/OceanSurface.js

@@ -29,8 +29,9 @@ import { useOceanMaterial } from '../../hooks/useOceanMaterial.js';
 const OceanSurface = ({ id = '3drise-water', config, quality, skySettings, timeSettings, sunIntensity = 1, animations, mouseMove, terrain, onObjectReady, onObjectDispose, }) => {
     const clipmap = useClipmap(quality.levels, quality.segments, quality.cellSize);
     const meshRefs = useRef([]);
-    const { material, rootRef } = useOceanMaterial({
+    const { material, rootRef, onBeforeRender } = useOceanMaterial({
         id,
+        world: true,
         config,
         quality,
         skySettings,
@@ -61,6 +62,6 @@ const OceanSurface = ({ id = '3drise-water', config, quality, skySettings, timeS
             // Displacement happens in the vertex shader, so the
             // object-space bounds describe a flat plane. Culling against
             // them hides the water the moment the camera tilts up.
-            frustumCulled: false }, ring.level))) }));
+            frustumCulled: false, onBeforeRender: onBeforeRender }, ring.level))) }));
 };
 export default OceanSurface;

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

@@ -1 +1 @@
-{"version":3,"file":"WaterBody.d.ts","sourceRoot":"","sources":["../../../src/components/water/WaterBody.tsx"],"names":[],"mappings":"AACA,OAAO,KAA6B,MAAM,OAAO,CAAC;AAGlD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,QAAA,MAAM,SAAS,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CA0ExC,CAAC;AAEF,eAAe,SAAS,CAAC"}
+{"version":3,"file":"WaterBody.d.ts","sourceRoot":"","sources":["../../../src/components/water/WaterBody.tsx"],"names":[],"mappings":"AACA,OAAO,KAA6B,MAAM,OAAO,CAAC;AAGlD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,QAAA,MAAM,SAAS,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAwGxC,CAAC;AAEF,eAAe,SAAS,CAAC"}

package/dist/components/water/WaterBody.js

@@ -29,22 +29,40 @@ import { useOceanMaterial } from '../../hooks/useOceanMaterial.js';
  * The rim taper (`edgeFade`) is in the vertex shader — without it the boundary
  * is a sawn-off cliff of water.
  */
-const WaterBody = ({ id = '3drise-water-body', config, quality, skySettings, timeSettings, sunIntensity = 1, animations, mouseMove, meshSettings, onObjectReady, onObjectDispose, }) => {
+const WaterBody = ({ id = '3drise-water-body', config, quality, skySettings, timeSettings, sunIntensity = 1, animations, mouseMove, meshSettings, transformOwned = false, onObjectReady, onObjectDispose, }) => {
     const [width, depth] = config.size;
+    // The body is sized by its transform: `size` is the grid's base extent and the
+    // transform's scale multiplies it (a catalogue pool is a 1 x 1 grid scaled to
+    // metres). The shader evaluates the waves in world metres either way.
+    const sx = Math.abs(meshSettings?.scale?.[0] ?? 1);
+    const sz = Math.abs(meshSettings?.scale?.[2] ?? 1);
+    const worldExtent = Math.max(width * sx, depth * sz, 0.01);
     // A body cannot carry a wave longer than it is: fetch is capped at its own
     // extent, which is physically what fetch MEANS — the open water upwind.
     const bounded = useMemo(() => ({
         ...config,
-        fetch: Math.min(config.fetch, Math.max(width, depth) / 1000),
-    }), [config, width, depth]);
+        fetch: Math.min(config.fetch, worldExtent / 1000),
+    }), [config, worldExtent]);
+    // Cells square in METRES: `segments` runs along the body's longer side and the
+    // shorter side gets proportionally fewer. An N x N grid on a long canal makes
+    // cells several times longer than wide, and those sliver triangles shade in
+    // streaks along their diagonals — lines running down the water as soon as the
+    // waves are aligned (a current, a narrow spread). Rebuilt when the transform's
+    // scale changes the proportions, which is a commit, not a frame.
+    const segments = Math.max(4, Math.min(Math.round(config.segments), 1024));
+    const spanX = Math.max(width * sx, 1e-3), spanZ = Math.max(depth * sz, 1e-3);
+    const longest = Math.max(spanX, spanZ);
+    const segX = Math.max(4, Math.round(segments * spanX / longest));
+    const segZ = Math.max(4, Math.round(segments * spanZ / longest));
     const geometry = useMemo(() => {
-        const segments = Math.max(4, Math.min(Math.round(config.segments), 1024));
-        const geo = new THREE.PlaneGeometry(Math.max(width, 0.01), Math.max(depth, 0.01), segments, segments);
+        const geo = new THREE.PlaneGeometry(Math.max(width, 0.01), Math.max(depth, 0.01), segX, segZ);
         // PlaneGeometry is built in XY; the water field is XZ, and rotating the
         // mesh instead would rotate the transform the user edits.
         geo.rotateX(-Math.PI / 2);
         const count = geo.attributes.position.count;
-        const cell = Math.max(width, depth) / segments;
+        // Local units, measured along the longer side (the cells are square in
+        // metres); the material multiplies by the transform's largest scale.
+        const cell = (Math.max(width * sx, depth * sz) / segments) / Math.max(sx, sz, 1e-6);
         // The material reads all three on both hosts. A body has no coarser ring
         // to morph toward, so the morph attributes are zero and `cellLod` is just
         // the cell — which is still what the per-wave LOD fade needs, so a pool
@@ -60,9 +78,9 @@ const WaterBody = ({ id = '3drise-water-body', config, quality, skySettings, tim
         if (geo.boundingSphere)
             geo.boundingSphere.radius *= 1.2;
         return geo;
-    }, [width, depth, config.segments]);
+    }, [width, depth, segments, segX, segZ, sx, sz]);
     useEffect(() => () => { geometry.dispose(); }, [geometry]);
-    const { material, rootRef } = useOceanMaterial({
+    const { material, rootRef, onBeforeRender, onAfterRender } = useOceanMaterial({
         id,
         config: bounded,
         quality,
@@ -72,7 +90,10 @@ const WaterBody = ({ id = '3drise-water-body', config, quality, skySettings, tim
         animations,
         mouseMove,
     });
-    useObjectReady(rootRef, { id, type: 'ocean', config, quality }, onObjectReady, onObjectDispose);
-    return (_jsx("group", { ref: rootRef, position: meshSettings?.position ?? [0, config.seaLevel, 0], rotation: meshSettings?.rotation ?? [0, 0, 0], scale: meshSettings?.scale ?? [1, 1, 1], visible: meshSettings ? meshSettings.visible !== false : true, children: _jsx("mesh", { geometry: geometry, material: material, receiveShadow: quality.receiveShadows }) }));
+    useObjectReady(rootRef, { id, type: 'water', config, quality }, onObjectReady, onObjectDispose);
+    // As a scene object (ObjectNode) the CreatedObject wrapper already applies
+    // meshSettings; applying it here too would place the pool twice as far out.
+    const own = !transformOwned && meshSettings ? meshSettings : undefined;
+    return (_jsx("group", { ref: rootRef, position: own?.position ?? [0, 0, 0], rotation: own?.rotation ?? [0, 0, 0], scale: own?.scale ?? [1, 1, 1], visible: own ? own.visible !== false : true, children: _jsx("mesh", { geometry: geometry, material: material, receiveShadow: quality.receiveShadows, onBeforeRender: onBeforeRender, onAfterRender: onAfterRender }) }));
 };
 export default WaterBody;

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { FountainWaterConfig } from '@3driseai/3drise-core';
+import type { WaterVariantProps } from './useWaterInstance';
+export interface WaterFountainProps extends WaterVariantProps {
+    config: FountainWaterConfig;
+}
+declare const WaterFountain: React.FC<WaterFountainProps>;
+export default WaterFountain;
+//# sourceMappingURL=WaterFountain.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WaterFountain.d.ts","sourceRoot":"","sources":["../../../src/components/water/WaterFountain.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,OAAO,KAAK,EAAa,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAoBvE,MAAM,WAAW,kBAAmB,SAAQ,iBAAiB;IACzD,MAAM,EAAE,mBAAmB,CAAC;CAC/B;AAED,QAAA,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,kBAAkB,CAO/C,CAAC;AAEF,eAAe,aAAa,CAAC"}

package/dist/components/water/WaterFountain.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DEFAULT_WATER_OBJECTS, WATER_OBJECTS_ANIMATABLE } from '@3driseai/3drise-core';
+import { useWaterInstance } from './useWaterInstance.js';
+import { createUniforms, applyConfig, build, STRUCTURAL } from './core/fountain.js';
+// =============================================================================
+// WaterFountain — Fountain (type 'water', config.type 'fountain')
+// =============================================================================
+// Fountain water of six kinds — ballistic jets (single, ring, crown, fan), laminar glass arcs, dancing jets, a geyser column, a laminar bell and tiered bowl curtains — splashing with crowns, foam and rings into a water body, lit by the scene sun and sky. Use for plazas, hotel courtyards, gardens and parks.
+// The construction lives in core/fountain.ts (emitted from the lab); this component wires it into
+// the config pattern through useWaterInstance (scene sun and sky, live drag, keyframes, pointer).
+const CORE = {
+    DEFAULTS: DEFAULT_WATER_OBJECTS.fountain,
+    STRUCTURAL,
+    /** Knobs a keyframe or pointer binding may drive per frame — exactly what the push applies. */
+    ANIMATABLE: new Set(WATER_OBJECTS_ANIMATABLE.fountain.map((p) => p.value)),
+    createUniforms,
+    applyConfig,
+    build,
+};
+const WaterFountain = (props) => {
+    const { rootRef, instance } = useWaterInstance(CORE, props);
+    return (_jsx("group", { ref: rootRef, children: _jsx("primitive", { object: instance.object }) }));
+};
+export default WaterFountain;

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { StreamWaterConfig } from '@3driseai/3drise-core';
+import type { WaterVariantProps } from './useWaterInstance';
+export interface WaterStreamProps extends WaterVariantProps {
+    config: StreamWaterConfig;
+}
+declare const WaterStream: React.FC<WaterStreamProps>;
+export default WaterStream;
+//# sourceMappingURL=WaterStream.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WaterStream.d.ts","sourceRoot":"","sources":["../../../src/components/water/WaterStream.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,OAAO,KAAK,EAAa,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAoBvE,MAAM,WAAW,gBAAiB,SAAQ,iBAAiB;IACvD,MAAM,EAAE,iBAAiB,CAAC;CAC7B;AAED,QAAA,MAAM,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,gBAAgB,CAO3C,CAAC;AAEF,eAAe,WAAW,CAAC"}

package/dist/components/water/WaterStream.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DEFAULT_WATER_OBJECTS, WATER_OBJECTS_ANIMATABLE } from '@3driseai/3drise-core';
+import { useWaterInstance } from './useWaterInstance.js';
+import { createUniforms, applyConfig, build, STRUCTURAL } from './core/stream.js';
+// =============================================================================
+// WaterStream — Stream (type 'water', config.type 'stream')
+// =============================================================================
+// Flowing water along a path of points, drawn over the user's own bed or terrain: clear at the edges and deep mid-stream, ripples advected with a channel velocity profile, foam on the banks, the outer side of bends and around rocks, lit by the scene sun and sky. Use for parks, gardens, landscapes and village scenes.
+// The construction lives in core/stream.ts (emitted from the lab); this component wires it into
+// the config pattern through useWaterInstance (scene sun and sky, live drag, keyframes, pointer).
+const CORE = {
+    DEFAULTS: DEFAULT_WATER_OBJECTS.stream,
+    STRUCTURAL,
+    /** Knobs a keyframe or pointer binding may drive per frame — exactly what the push applies. */
+    ANIMATABLE: new Set(WATER_OBJECTS_ANIMATABLE.stream.map((p) => p.value)),
+    createUniforms,
+    applyConfig,
+    build,
+};
+const WaterStream = (props) => {
+    const { rootRef, instance } = useWaterInstance(CORE, props);
+    return (_jsx("group", { ref: rootRef, children: _jsx("primitive", { object: instance.object }) }));
+};
+export default WaterStream;

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { WaterfallWaterConfig } from '@3driseai/3drise-core';
+import type { WaterVariantProps } from './useWaterInstance';
+export interface WaterWaterfallProps extends WaterVariantProps {
+    config: WaterfallWaterConfig;
+}
+declare const WaterWaterfall: React.FC<WaterWaterfallProps>;
+export default WaterWaterfall;
+//# sourceMappingURL=WaterWaterfall.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WaterWaterfall.d.ts","sourceRoot":"","sources":["../../../src/components/water/WaterWaterfall.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAElE,OAAO,KAAK,EAAa,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAoBvE,MAAM,WAAW,mBAAoB,SAAQ,iBAAiB;IAC1D,MAAM,EAAE,oBAAoB,CAAC;CAChC;AAED,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,mBAAmB,CAOjD,CAAC;AAEF,eAAe,cAAc,CAAC"}

package/dist/components/water/WaterWaterfall.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DEFAULT_WATER_OBJECTS, WATER_OBJECTS_ANIMATABLE } from '@3driseai/3drise-core';
+import { useWaterInstance } from './useWaterInstance.js';
+import { createUniforms, applyConfig, build, STRUCTURAL } from './core/waterfall.js';
+// =============================================================================
+// WaterWaterfall — Waterfall (type 'water', config.type 'waterfall')
+// =============================================================================
+// An aerated sheet of water falling from a lip into a plunge pool: ropes and surges that stretch as the water accelerates, glassy at the lip and white with foam at the foot, a boiling pool streaking foam outward, mist rising from the base and spray off the edges, lit by the scene sun and sky. Use for cliffs, gardens, hotel atriums and fantasy scenes.
+// The construction lives in core/waterfall.ts (emitted from the lab); this component wires it into
+// the config pattern through useWaterInstance (scene sun and sky, live drag, keyframes, pointer).
+const CORE = {
+    DEFAULTS: DEFAULT_WATER_OBJECTS.waterfall,
+    STRUCTURAL,
+    /** Knobs a keyframe or pointer binding may drive per frame — exactly what the push applies. */
+    ANIMATABLE: new Set(WATER_OBJECTS_ANIMATABLE.waterfall.map((p) => p.value)),
+    createUniforms,
+    applyConfig,
+    build,
+};
+const WaterWaterfall = (props) => {
+    const { rootRef, instance } = useWaterInstance(CORE, props);
+    return (_jsx("group", { ref: rootRef, children: _jsx("primitive", { object: instance.object }) }));
+};
+export default WaterWaterfall;

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

@@ -0,0 +1,70 @@
+import * as THREE from 'three';
+export declare const STRUCTURAL: string[];
+export declare function createUniforms(): {
+    uJets: {
+        value: THREE.Vector4[];
+    };
+    uJetAux: {
+        value: THREE.Vector4[];
+    };
+    uJetCount: {
+        value: number;
+    };
+    uThickness: {
+        value: number;
+    };
+    uBreakup: {
+        value: number;
+    };
+    uSplash: {
+        value: number;
+    };
+    uSpin: {
+        value: number;
+    };
+    uFroth: {
+        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 layoutJets(u: any, c: any, now?: number): void;
+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=fountain.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fountain.d.ts","sourceRoot":"","sources":["../../../../src/components/water/core/fountain.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,eAAO,MAAM,UAAU,UAAmI,CAAC;AAK3J,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAU7B;AAcD,wBAAgB,UAAU,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,EAAE,GAAG,SAAI,QA0BvC;AACD,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,QAa/B;AA+TD,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,GAAG,KAAA;;;;;EA+F3B"}