@3driseai/3drise-viewer 0.1.6 → 0.1.8

package/dist/components/terrain/TerrainSurface.js

@@ -0,0 +1,94 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import { useFrame } from '@react-three/fiber';
+import { useObjectReady } from '../../hooks/useObjectReady.js';
+import { useTerrainClipmap } from '../../hooks/useTerrainClipmap.js';
+import { useCloudSun } from '../../hooks/useCloudSun.js';
+import { TERRAIN_LIVE_KEY } from '../../hooks/useTerrainLive.js';
+import { TerrainMaterial } from '../../shaders/terrain/TerrainMaterial.js';
+import { applySunUniforms } from '../../utils/cloudUniforms.js';
+import { applyTerrainAmbient, applyTerrainUniforms } from '../../utils/terrainUniforms.js';
+/**
+ * The terrain renderer. One clipmap, one material, four landforms — they differ
+ * by the shaping operator the height field applies, not by having separate
+ * renderers, the same way three of the four cloud types share one marcher.
+ *
+ * Unlike the cloud pass this does NOT take over the render loop, and that is the
+ * entire reason to build terrain as geometry: it depth-sorts against scene
+ * objects, it receives the sun's shadow map so anything standing on it casts onto
+ * it, scene fog applies, and the cloud pass composites over it correctly because
+ * it is simply in the scene when that pass renders. A raymarched terrain would
+ * have none of that.
+ *
+ * Per frame it does three things: resolves the sun (from the same
+ * `skySystemManager` the sun rig and the clouds read, so a time slider moves all
+ * three together), pushes the config into uniforms, and re-snaps the clipmap to
+ * the camera. Nothing here re-renders React.
+ */
+const TerrainSurface = ({ id = '3drise-terrain', config, quality, skySettings, timeSettings, sunIntensity = 1, onObjectReady, onObjectDispose, }) => {
+    const clipmap = useTerrainClipmap(quality.levels, quality.segments, quality.cellSize);
+    const { state: sun, update: updateSun } = useCloudSun({ skySettings, timeSettings });
+    const material = useMemo(() => new TerrainMaterial(), []);
+    useEffect(() => () => { material.dispose(); }, [material]);
+    // Live controller overrides. A slider drag writes here every pointer-move and
+    // the frame loop reads it on top of the config, so the terrain responds without
+    // a dispatch per frame — which for `quality` also means without rebuilding
+    // every clipmap ring sixty times a second. Cleared when the config identity
+    // changes, which is exactly slider-end committing the same value.
+    const liveConfig = useRef({});
+    const liveQuality = useRef({});
+    useEffect(() => { liveConfig.current = {}; }, [config]);
+    useEffect(() => { liveQuality.current = {}; }, [quality]);
+    const rootRef = useRef(null);
+    const meshRefs = useRef([]);
+    // The handle a controller reaches through findById(id).userData. Set in an
+    // effect, never as a userData JSX prop: R3F replaces the whole userData object
+    // on every render, which would drop the handle whenever anything above
+    // re-rendered.
+    const liveHandle = useMemo(() => ({
+        config: (key, value) => { liveConfig.current[key] = value; },
+        quality: (key, value) => { liveQuality.current[key] = value; },
+    }), []);
+    useEffect(() => {
+        const root = rootRef.current;
+        if (!root)
+            return;
+        root.userData.id = id;
+        root.userData[TERRAIN_LIVE_KEY] = liveHandle;
+        return () => { delete root.userData[TERRAIN_LIVE_KEY]; };
+    }, [id, liveHandle]);
+    useObjectReady(rootRef, { id, type: 'terrain', config, quality }, onObjectReady, onObjectDispose);
+    useFrame((state) => {
+        const camera = state.camera;
+        updateSun();
+        applySunUniforms(material, sun, sunIntensity);
+        // Overwrites the two ambient colours applySunUniforms just set. Those are
+        // the cloud curve, tuned for cloud interiors; the ground has to be lit by
+        // the sky that is actually being drawn behind it or a sunset landscape
+        // comes out black under a blazing sky.
+        applyTerrainAmbient(material, sun);
+        const cfg = { ...config, ...liveConfig.current };
+        const qual = { ...quality, ...liveQuality.current };
+        applyTerrainUniforms(material, cfg, qual);
+        // ONE origin for the whole pyramid, snapped to twice the finest cell.
+        //
+        // Snapping each ring to its own cell grid is the textbook clipmap and it is
+        // what tears the seams open: neighbouring rings then sit on origins up to a
+        // cell apart, and boundaries that match exactly in local space miss each
+        // other in the world by that offset. Sharing the origin makes them coincide
+        // by construction. Twice the cell, so index parity — and with it the
+        // geomorph — never flips as the camera crosses a cell boundary.
+        const snap = clipmap.sharedSnap;
+        const ox = Math.round(camera.position.x / snap) * snap;
+        const oz = Math.round(camera.position.z / snap) * snap;
+        for (let i = 0; i < clipmap.levels.length; i++) {
+            meshRefs.current[i]?.position.set(ox, 0, oz);
+        }
+    });
+    return (_jsx("group", { ref: rootRef, children: clipmap.levels.map((ring, i) => (_jsx("mesh", { ref: (m) => { meshRefs.current[i] = m; }, geometry: ring.geometry, material: material, receiveShadow: quality.receiveShadows, 
+            // Displacement happens in the vertex shader, so the object-space
+            // bounds describe a flat plane. Culling against them hides the
+            // terrain the moment the camera tilts up.
+            frustumCulled: false }, ring.level))) }));
+};
+export default TerrainSurface;

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

@@ -0,0 +1,7 @@
+export type { TerrainLayerProps } from './types';
+export { default as TerrainSurface } from './TerrainSurface';
+export { default as Mountains } from './Mountains';
+export { default as Dunes } from './Dunes';
+export { default as Hills } from './Hills';
+export { default as Canyon } from './Canyon';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/terrain/index.ts"],"names":[],"mappings":"AAGA,YAAY,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,UAAU,CAAC"}

package/dist/components/terrain/index.js

@@ -0,0 +1,7 @@
+// Terrain landforms. Each renders the shared clipmap surface with the coercions
+// its type needs; exactly one is mounted at a time, by TerrainBuilder.
+export { default as TerrainSurface } from './TerrainSurface.js';
+export { default as Mountains } from './Mountains.js';
+export { default as Dunes } from './Dunes.js';
+export { default as Hills } from './Hills.js';
+export { default as Canyon } from './Canyon.js';

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

@@ -0,0 +1,17 @@
+import type { SkySettings, TimeSettings } from '@3driseai/3drise-core';
+import type { ObjectReadyProps } from '../../types/objectReady';
+import type { TerrainConfig, TerrainQualityConfig } from '../../types/terrainConfigs';
+/** Shared by every landform component. The builder hands all four the same shape. */
+export interface TerrainLayerProps extends ObjectReadyProps {
+    /** Scene id, so a controller can findById() the terrain and drive it live. */
+    id?: string;
+    config: TerrainConfig;
+    quality: TerrainQualityConfig;
+    /** The four Preetham parameters, so the ground is lit by the same atmosphere
+     *  the sky is drawn with and the clouds are lit by. */
+    skySettings?: SkySettings;
+    timeSettings?: TimeSettings;
+    /** Matches SkySystem's sunIntensity, so terrain brightens with the scene. */
+    sunIntensity?: number;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/terrain/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAEtF,qFAAqF;AACrF,MAAM,WAAW,iBAAkB,SAAQ,gBAAgB;IACvD,8EAA8E;IAC9E,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,aAAa,CAAC;IACtB,OAAO,EAAE,oBAAoB,CAAC;IAC9B;2DACuD;IACvD,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,6EAA6E;IAC7E,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB"}

package/dist/components/terrain/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { CloudLayerProps } from './types';
+/**
+ * The cirrus-only sky: high ice with no deck beneath it.
+ *
+ * Cirrus normally rides along with whatever deck is enabled — the pass composites
+ * it above, which is correct while the camera is below both. This component is the
+ * case where the deck is switched off entirely, so the deck march is skipped and
+ * only the three-sample ice pass runs. That is a fraction of the cost of any
+ * volumetric type, which is why a clear-with-cirrus sky is close to free.
+ */
+declare const Cirrus: React.FC<CloudLayerProps>;
+export default Cirrus;
+//# sourceMappingURL=Cirrus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Cirrus.d.ts","sourceRoot":"","sources":["../../../src/components/volumetricClouds/Cirrus.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;;;;GAQG;AACH,QAAA,MAAM,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAErC,CAAC;AACF,eAAe,MAAM,CAAC"}

package/dist/components/volumetricClouds/Cirrus.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import VolumetricCloudsPass from './VolumetricCloudsPass.js';
+/**
+ * The cirrus-only sky: high ice with no deck beneath it.
+ *
+ * Cirrus normally rides along with whatever deck is enabled — the pass composites
+ * it above, which is correct while the camera is below both. This component is the
+ * case where the deck is switched off entirely, so the deck march is skipped and
+ * only the three-sample ice pass runs. That is a fraction of the cost of any
+ * volumetric type, which is why a clear-with-cirrus sky is close to free.
+ */
+const Cirrus = ({ cirrus, quality, skySettings, timeSettings, sunIntensity, animations, mouseMove, id, onObjectReady, onObjectDispose }) => (_jsx(VolumetricCloudsPass, { deck: null, cirrus: cirrus, quality: quality, skySettings: skySettings, timeSettings: timeSettings, sunIntensity: sunIntensity, animations: animations, mouseMove: mouseMove, id: id, onObjectReady: onObjectReady, onObjectDispose: onObjectDispose }));
+export default Cirrus;

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

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { CloudLayerProps } from './types';
+/**
+ * A storm cell — the deepest and most expensive type.
+ *
+ * Three config values carry its identity, and with any of them at zero it reads as
+ * an oversized cumulus: `shear` leans the tower and drags the anvil downwind,
+ * `anvil` flattens the top at the tropopause instead of rounding it, and
+ * `precipitation` drops scattering albedo at the base, which is the only thing that
+ * makes it charcoal — extinction alone will not.
+ *
+ * Cost scales with depth, since the fine step is derived from it, so a shallow step
+ * budget on a 9 km tower gives kilometre steps and loses the structure. Floored here.
+ */
+declare const Cumulonimbus: React.FC<CloudLayerProps>;
+export default Cumulonimbus;
+//# sourceMappingURL=Cumulonimbus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Cumulonimbus.d.ts","sourceRoot":"","sources":["../../../src/components/volumetricClouds/Cumulonimbus.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAEvC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAG3C,CAAC;AACF,eAAe,YAAY,CAAC"}

package/dist/components/volumetricClouds/Cumulonimbus.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import VolumetricCloudsPass from './VolumetricCloudsPass.js';
+/**
+ * A storm cell — the deepest and most expensive type.
+ *
+ * Three config values carry its identity, and with any of them at zero it reads as
+ * an oversized cumulus: `shear` leans the tower and drags the anvil downwind,
+ * `anvil` flattens the top at the tropopause instead of rounding it, and
+ * `precipitation` drops scattering albedo at the base, which is the only thing that
+ * makes it charcoal — extinction alone will not.
+ *
+ * Cost scales with depth, since the fine step is derived from it, so a shallow step
+ * budget on a 9 km tower gives kilometre steps and loses the structure. Floored here.
+ */
+const Cumulonimbus = ({ deck, cirrus, quality, skySettings, timeSettings, sunIntensity, animations, mouseMove, id, onObjectReady, onObjectDispose }) => {
+    const resolvedQuality = useMemo(() => ({ ...quality, steps: Math.max(quality.steps, 96) }), [quality]);
+    return (_jsx(VolumetricCloudsPass, { deck: deck, cirrus: cirrus, quality: resolvedQuality, skySettings: skySettings, timeSettings: timeSettings, sunIntensity: sunIntensity, animations: animations, mouseMove: mouseMove, id: id, onObjectReady: onObjectReady, onObjectDispose: onObjectDispose }));
+};
+export default Cumulonimbus;

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

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { CloudLayerProps } from './types';
+/**
+ * Fair-weather cumulus — flat condensation base, cauliflower top, sky between the
+ * cells. The reference case for the scattering model, because its silhouette shows
+ * every term at once: lit flank, powder-dark base, silver rim, blue underside.
+ *
+ * Anvil and precipitation are forced off. Both are gated on the vertical profile
+ * inside the shader anyway, so leaving a stale value in the config would do nothing
+ * visible while making the panel read as though it should.
+ */
+declare const Cumulus: React.FC<CloudLayerProps>;
+export default Cumulus;
+//# sourceMappingURL=Cumulus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Cumulus.d.ts","sourceRoot":"","sources":["../../../src/components/volumetricClouds/Cumulus.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAEvC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;;;;GAQG;AACH,QAAA,MAAM,OAAO,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAGtC,CAAC;AACF,eAAe,OAAO,CAAC"}

package/dist/components/volumetricClouds/Cumulus.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import VolumetricCloudsPass from './VolumetricCloudsPass.js';
+/**
+ * Fair-weather cumulus — flat condensation base, cauliflower top, sky between the
+ * cells. The reference case for the scattering model, because its silhouette shows
+ * every term at once: lit flank, powder-dark base, silver rim, blue underside.
+ *
+ * Anvil and precipitation are forced off. Both are gated on the vertical profile
+ * inside the shader anyway, so leaving a stale value in the config would do nothing
+ * visible while making the panel read as though it should.
+ */
+const Cumulus = ({ deck, cirrus, quality, skySettings, timeSettings, sunIntensity, animations, mouseMove, id, onObjectReady, onObjectDispose }) => {
+    const resolved = useMemo(() => ({ ...deck, anvil: 0, precipitation: 0 }), [deck]);
+    return (_jsx(VolumetricCloudsPass, { deck: resolved, cirrus: cirrus, quality: quality, skySettings: skySettings, timeSettings: timeSettings, sunIntensity: sunIntensity, animations: animations, mouseMove: mouseMove, id: id, onObjectReady: onObjectReady, onObjectDispose: onObjectDispose }));
+};
+export default Cumulus;

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

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { CloudLayerProps } from './types';
+/**
+ * A low overcast deck — rolls, lumpy undersides, little vertical development.
+ *
+ * The deck is shallow, so the march's fine step (derived from depth) is already
+ * small and a large step budget is wasted; it is capped here. Anvil and
+ * precipitation are off for the same reason as cumulus.
+ */
+declare const Stratocumulus: React.FC<CloudLayerProps>;
+export default Stratocumulus;
+//# sourceMappingURL=Stratocumulus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Stratocumulus.d.ts","sourceRoot":"","sources":["../../../src/components/volumetricClouds/Stratocumulus.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAEvC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;;GAMG;AACH,QAAA,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAI5C,CAAC;AACF,eAAe,aAAa,CAAC"}

package/dist/components/volumetricClouds/Stratocumulus.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import VolumetricCloudsPass from './VolumetricCloudsPass.js';
+/**
+ * A low overcast deck — rolls, lumpy undersides, little vertical development.
+ *
+ * The deck is shallow, so the march's fine step (derived from depth) is already
+ * small and a large step budget is wasted; it is capped here. Anvil and
+ * precipitation are off for the same reason as cumulus.
+ */
+const Stratocumulus = ({ deck, cirrus, quality, skySettings, timeSettings, sunIntensity, animations, mouseMove, id, onObjectReady, onObjectDispose }) => {
+    const resolved = useMemo(() => ({ ...deck, anvil: 0, precipitation: 0 }), [deck]);
+    const resolvedQuality = useMemo(() => ({ ...quality, steps: Math.min(quality.steps, 112) }), [quality]);
+    return (_jsx(VolumetricCloudsPass, { deck: resolved, cirrus: cirrus, quality: resolvedQuality, skySettings: skySettings, timeSettings: timeSettings, sunIntensity: sunIntensity, animations: animations, mouseMove: mouseMove, id: id, onObjectReady: onObjectReady, onObjectDispose: onObjectDispose }));
+};
+export default Stratocumulus;

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

@@ -0,0 +1,42 @@
+import React from 'react';
+import type { ObjectReadyProps } from '../../types/objectReady';
+import type { SkySettings, TimeSettings } from '@3driseai/3drise-core';
+import type { CirrusLayerConfig, CloudDeckConfig, CloudsQualityConfig } from '../../types/cloudConfigs';
+import type { ObjectAnimations, MouseMoveInteractions } from '@3driseai/3drise-core';
+/**
+ * The cloud render pipeline. The only component in this package that takes over
+ * rendering, and there must be exactly one.
+ *
+ * Per frame:
+ *   1. scene, into an HDR target with a depth texture
+ *   2. deck march at `resolutionScale`, jittered a sub-pixel per frame
+ *   3. temporal resolve against a reprojected history, neighbourhood-clamped
+ *   4. cirrus at the same scale — smooth enough to need no temporal pass
+ *   5. depth-aware upsample, composite, tonemap
+ *
+ * Half resolution plus a temporal resolve buys roughly four times the march steps
+ * for the same cost, which is the difference between a cloud with structure and a
+ * cloud made of fog. The cost is one frame of latency and this component owning
+ * the loop.
+ *
+ * If it unmounts, R3F resumes its own auto-render and the scene draws normally
+ * without clouds — so hiding it is safe.
+ */
+export interface VolumetricCloudsPassProps extends ObjectReadyProps {
+    /** Scene id, so a controller can findById() this layer and drive it live. */
+    id?: string;
+    deck?: CloudDeckConfig | null;
+    cirrus?: CirrusLayerConfig | null;
+    quality: CloudsQualityConfig;
+    skySettings?: SkySettings;
+    timeSettings?: TimeSettings;
+    /** Multiplies sun radiance for the clouds only. Matches SkySystem's sunIntensity. */
+    sunIntensity?: number;
+    /** Per-domain keyframes; the `clouds` domain drives deck properties. */
+    animations?: ObjectAnimations;
+    /** Per-domain pointer interactions; same `clouds` domain. */
+    mouseMove?: MouseMoveInteractions;
+}
+declare const VolumetricCloudsPass: React.FC<VolumetricCloudsPassProps>;
+export default VolumetricCloudsPass;
+//# sourceMappingURL=VolumetricCloudsPass.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VolumetricCloudsPass.d.ts","sourceRoot":"","sources":["../../../src/components/volumetricClouds/VolumetricCloudsPass.tsx"],"names":[],"mappings":"AACA,OAAO,KAAkD,MAAM,OAAO,CAAC;AAIvE,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,MAAM,0BAA0B,CAAC;AAExG,OAAO,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAErF;;;;;;;;;;;;;;;;;;GAkBG;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,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;AAkBD,QAAA,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC,yBAAyB,CA0S7D,CAAC;AAEF,eAAe,oBAAoB,CAAC"}

package/dist/components/volumetricClouds/VolumetricCloudsPass.js

@@ -0,0 +1,298 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+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 { useObjectReady } from '../../hooks/useObjectReady.js';
+import { CLOUD_LIVE_KEY } from '../../hooks/useCloudLive.js';
+import { useCloudNoise } from '../../hooks/useCloudNoise.js';
+import { useCloudSun } from '../../hooks/useCloudSun.js';
+import { CloudVolumeMaterial } from '../../shaders/clouds/CloudVolumeMaterial.js';
+import { CirrusMaterial } from '../../shaders/clouds/CirrusMaterial.js';
+import { CloudResolveMaterial } from '../../shaders/clouds/CloudResolveMaterial.js';
+import { CloudCompositeMaterial } from '../../shaders/clouds/CloudCompositeMaterial.js';
+import { applyCameraUniforms, applyCirrusUniforms, applyDeckUniforms, applySunUniforms, } from '../../utils/cloudUniforms.js';
+import { applyCloudsKeyframeAnimations, applyCloudsMouseMove, resolveDeckConfig, } from '../../utils/handleCloudsAnimations.js';
+const quad = new THREE.PlaneGeometry(2, 2);
+const orthoCam = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 1);
+function passScene(material) {
+    const scene = new THREE.Scene();
+    scene.add(new THREE.Mesh(quad, material));
+    return scene;
+}
+/** rgb 0, alpha 1 — composites as "nothing here", so a disabled layer costs one texel. */
+function emptyTexture() {
+    const tex = new THREE.DataTexture(Uint8Array.from([0, 0, 0, 255]), 1, 1, THREE.RGBAFormat, THREE.UnsignedByteType);
+    tex.needsUpdate = true;
+    return tex;
+}
+const VolumetricCloudsPass = ({ id = '3drise-clouds', deck, cirrus, quality, skySettings, timeSettings, sunIntensity = 1, animations, mouseMove, onObjectReady, onObjectDispose, }) => {
+    const gl = useThree((s) => s.gl);
+    const scene = useThree((s) => s.scene);
+    const size = useThree((s) => s.size);
+    const dpr = useThree((s) => s.viewport.dpr);
+    const noise = useCloudNoise();
+    const { state: sun, update: updateSun } = useCloudSun({ skySettings, timeSettings });
+    const deckOn = !!deck?.enabled;
+    const cirrusOn = !!cirrus?.enabled;
+    const width = Math.max(2, Math.floor(size.width * dpr));
+    const height = Math.max(2, Math.floor(size.height * dpr));
+    const lowW = Math.max(2, Math.floor(width * quality.resolutionScale));
+    const lowH = Math.max(2, Math.floor(height * quality.resolutionScale));
+    const targets = useMemo(() => {
+        const makeSceneTarget = () => {
+            const depthTexture = new THREE.DepthTexture(width, height);
+            depthTexture.type = THREE.UnsignedIntType;
+            depthTexture.minFilter = THREE.NearestFilter;
+            depthTexture.magFilter = THREE.NearestFilter;
+            return new THREE.WebGLRenderTarget(width, height, {
+                minFilter: THREE.LinearFilter,
+                magFilter: THREE.LinearFilter,
+                type: THREE.HalfFloatType,
+                depthBuffer: true,
+                depthTexture,
+            });
+        };
+        const lowOpts = {
+            minFilter: THREE.LinearFilter,
+            magFilter: THREE.LinearFilter,
+            type: THREE.HalfFloatType,
+            depthBuffer: false,
+            stencilBuffer: false,
+        };
+        return {
+            // Ping-ponged so nothing ever samples the depth attachment it is writing.
+            sceneA: makeSceneTarget(),
+            sceneB: makeSceneTarget(),
+            deck: new THREE.WebGLRenderTarget(lowW, lowH, lowOpts),
+            cirrus: new THREE.WebGLRenderTarget(lowW, lowH, lowOpts),
+            histA: new THREE.WebGLRenderTarget(lowW, lowH, lowOpts),
+            histB: new THREE.WebGLRenderTarget(lowW, lowH, lowOpts),
+        };
+    }, [width, height, lowW, lowH]);
+    useEffect(() => () => { Object.values(targets).forEach((t) => t.dispose()); }, [targets]);
+    const passes = useMemo(() => {
+        const deckMat = new CloudVolumeMaterial();
+        const cirrusMat = new CirrusMaterial();
+        const resolveMat = new CloudResolveMaterial();
+        const compositeMat = new CloudCompositeMaterial();
+        for (const m of [deckMat, cirrusMat, resolveMat, compositeMat]) {
+            m.glslVersion = THREE.GLSL3;
+            m.depthTest = false;
+            m.depthWrite = false;
+        }
+        return {
+            deckMat, cirrusMat, resolveMat, compositeMat,
+            deckScene: passScene(deckMat),
+            cirrusScene: passScene(cirrusMat),
+            resolveScene: passScene(resolveMat),
+            compositeScene: passScene(compositeMat),
+        };
+    }, []);
+    useEffect(() => () => {
+        [passes.deckMat, passes.cirrusMat, passes.resolveMat, passes.compositeMat]
+            .forEach((m) => m.dispose());
+    }, [passes]);
+    const empty = useMemo(emptyTexture, []);
+    const prevViewProj = useRef(new THREE.Matrix4());
+    const jitProj = useRef(new THREE.Matrix4());
+    const jitInv = useRef(new THREE.Matrix4());
+    const frame = useRef(0);
+    const validHistory = useRef(0);
+    const time = useRef(0);
+    const histFlip = useRef(0);
+    const prevCamPos = useRef(new THREE.Vector3());
+    const prevCamQuat = useRef(new THREE.Quaternion());
+    // Animation scratch. Kept in refs so a keyframed coverage does not re-render the
+    // React tree sixty times a second.
+    const override = useRef({});
+    const startValues = useRef({});
+    // Live controller overrides. A slider drag writes here every pointer-move and the
+    // frame loop reads it on top of the config, so the deck responds without a Redux
+    // dispatch per frame. Cleared when the config identity changes, which is exactly
+    // slider-end committing the same value.
+    const liveDeck = useRef({});
+    const liveCirrus = useRef({});
+    const liveQuality = useRef({});
+    useEffect(() => { liveDeck.current = {}; }, [deck]);
+    useEffect(() => { liveCirrus.current = {}; }, [cirrus]);
+    useEffect(() => { liveQuality.current = {}; }, [quality]);
+    // The handle a controller reaches through findById(id).userData. Set in an effect,
+    // never as a userData JSX prop: R3F replaces the whole userData object on every
+    // render, which would drop the handle the moment anything above re-renders.
+    const rootRef = useRef(null);
+    const liveHandle = useMemo(() => ({
+        deck: (key, value) => { liveDeck.current[key] = value; },
+        cirrus: (key, value) => { liveCirrus.current[key] = value; },
+        quality: (key, value) => { liveQuality.current[key] = value; },
+    }), []);
+    useEffect(() => {
+        const root = rootRef.current;
+        if (!root)
+            return;
+        root.userData.id = id;
+        root.userData[CLOUD_LIVE_KEY] = liveHandle;
+        return () => {
+            delete root.userData[CLOUD_LIVE_KEY];
+        };
+    }, [id, liveHandle]);
+    // ObjectReadySource's union is widened by Record<string, any>, but spelling the
+    // cast out keeps the intent: this reports the layer's settings, not a mesh's.
+    useObjectReady(rootRef, { id, type: 'clouds', deck, cirrus, quality }, onObjectReady, onObjectDispose);
+    // Only a resolution change genuinely invalidates the history — the buffers are
+    // reallocated and nothing in them maps to the new grid.
+    //
+    // Config edits deliberately do NOT reset it. Dragging a slider dispatches a new
+    // config object every pointer-move, so resetting here would restart the temporal
+    // accumulation on every frame of the drag and the deck would boil while you tune
+    // it. The neighbourhood clamp in the resolve is exactly what absorbs a field that
+    // changes under the history.
+    useEffect(() => { validHistory.current = 0; }, [width, height, lowW, lowH]);
+    // The frame body, extracted so it can be driven from two places: the render loop,
+    // and an off-loop caller that needs a finished image (see useFrameRenderer). It is
+    // 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) => {
+        if (!noise)
+            return;
+        frame.current += 1;
+        time.current += Math.min(delta, 0.05);
+        updateSun();
+        // ---- 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);
+        // Sub-pixel rotation, applied ONLY to the cloud ray basis. Jittering
+        // camera.projectionMatrix would shimmer the scene pass, which nothing resolves.
+        const jx = ((frame.current & 1) ? 0.5 : -0.5) / lowW;
+        const jy = ((frame.current & 2) ? 0.5 : -0.5) / lowH;
+        jitProj.current.copy(camera.projectionMatrix);
+        jitProj.current.elements[8] = jx * 2;
+        jitProj.current.elements[9] = jy * 2;
+        jitInv.current.copy(jitProj.current).invert();
+        const bindShared = (m) => {
+            applySunUniforms(m, sun, sunIntensity);
+            applyCameraUniforms(m, camera, jitInv.current, lowW, lowH);
+            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_screenSpace.value = 1;
+        };
+        // ---- 2 & 3. deck march, then temporal resolve ----
+        let deckTex = empty;
+        if (deckOn && deck) {
+            // Keyframes first, then pointer on top, so the two compose rather than
+            // the pointer snapping back to the stored config every frame.
+            for (const k in override.current)
+                delete override.current[k];
+            applyCloudsKeyframeAnimations(animations?.clouds?.animations, startValues.current, deck, override.current, time.current);
+            if (mouseMove?.enabled && mouseMove.clouds?.enabled) {
+                applyCloudsMouseMove(mouseMove.clouds.properties, deck, override.current, pointer);
+            }
+            // config -> keyframe/pointer domain -> live controller drag, in that order.
+            const animated = resolveDeckConfig(deck, override.current);
+            const live = resolveDeckConfig(animated, liveDeck.current);
+            const liveQual = { ...quality, ...liveQuality.current };
+            const m = passes.deckMat;
+            applyDeckUniforms(m, live, liveQual);
+            m.uniforms.u_base.value = noise.base;
+            m.uniforms.u_detail.value = noise.detail;
+            m.uniforms.u_weather.value = noise.weather;
+            m.uniforms.u_curl.value = noise.curl;
+            m.uniforms.u_host.value = 1;
+            bindShared(m);
+            gl.setRenderTarget(targets.deck);
+            gl.render(passes.deckScene, orthoCam);
+            const history = histFlip.current ? targets.histB : targets.histA;
+            const destination = histFlip.current ? targets.histA : targets.histB;
+            const r = passes.resolveMat.uniforms;
+            r.u_current.value = targets.deck.texture;
+            r.u_history.value = history.texture;
+            r.u_prevViewProj.value.copy(prevViewProj.current);
+            // UNJITTERED, deliberately. The march samples along jittered rays, but the
+            // reprojection maps pixel CENTRES between frames. Feeding it the jittered
+            // inverse offsets every history fetch by the current sub-pixel jitter, and
+            // since that cycles through four offsets the resolved image shifts about a
+            // full-res pixel every frame even with the camera locked. That reads as jitter.
+            r.u_invProj.value.copy(camera.projectionMatrixInverse);
+            r.u_camWorld.value.copy(camera.matrixWorld);
+            r.u_camPos.value.copy(camera.position);
+            r.u_texel.value.set(1 / lowW, 1 / lowH);
+            // Reprojection proxy: the deck's mid-height. Cheaper than storing
+            // per-pixel cloud depth and, for a layer far relative to per-frame
+            // camera motion, indistinguishable.
+            r.u_proxyHeight.value = (live.baseAltitude + live.topAltitude) * 0.5;
+            r.u_valid.value = validHistory.current > 1 ? 1 : 0;
+            // While the camera moves, the proxy-plane reprojection is only approximate
+            // and a high history weight smears. Ease off, and restore it once still.
+            const moved = camera.position.distanceToSquared(prevCamPos.current) > 1e-8
+                || Math.abs(camera.quaternion.dot(prevCamQuat.current)) < 0.9999995;
+            r.u_blend.value = moved ? Math.min(quality.temporalBlend, 0.7) : quality.temporalBlend;
+            gl.setRenderTarget(destination);
+            gl.render(passes.resolveScene, orthoCam);
+            histFlip.current ^= 1;
+            validHistory.current += 1;
+            deckTex = destination.texture;
+        }
+        else {
+            validHistory.current = 0;
+        }
+        // ---- 4. cirrus ----
+        let cirrusTex = empty;
+        if (cirrusOn && cirrus) {
+            const m = passes.cirrusMat;
+            applyCirrusUniforms(m, { ...cirrus, ...liveCirrus.current }, quality);
+            m.uniforms.u_weather.value = noise.weather;
+            bindShared(m);
+            gl.setRenderTarget(targets.cirrus);
+            gl.render(passes.cirrusScene, orthoCam);
+            cirrusTex = targets.cirrus.texture;
+        }
+        // ---- 5. composite ----
+        const c = passes.compositeMat.uniforms;
+        c.u_scene.value = sceneRT.texture;
+        c.u_clouds.value = deckTex;
+        c.u_cirrus.value = cirrusTex;
+        c.u_depth.value = sceneRT.depthTexture;
+        c.u_lowTexel.value.set(1 / lowW, 1 / lowH);
+        c.u_exposure.value = quality.exposure;
+        c.u_tonemap.value = quality.tonemap ? 1 : 0;
+        c.u_hasCirrus.value = cirrusOn ? 1 : 0;
+        gl.setRenderTarget(prevTarget);
+        gl.render(passes.compositeScene, orthoCam);
+        gl.autoClear = prevAutoClear;
+        prevViewProj.current.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
+        prevCamPos.current.copy(camera.position);
+        prevCamQuat.current.copy(camera.quaternion);
+    };
+    // Keep the latest body and pointer reachable from the off-loop path without
+    // making either a dependency of the registration.
+    const drawRef = useRef(drawFrame);
+    drawRef.current = drawFrame;
+    const pointerRef = useRef(new THREE.Vector2());
+    useFrame((state, delta) => {
+        pointerRef.current.copy(state.pointer);
+        drawRef.current(state.camera, state.pointer, delta);
+    }, 1);
+    // This pass composites to the canvas itself, so gl.render(scene, camera) is not a
+    // complete frame while it is mounted — it draws the scene graph and drops the
+    // clouds, which is what made screenshots come back with everything but the sky.
+    // delta 0: an off-loop frame must not advance cloud time or the animation jumps.
+    const renderCompleteFrame = useCallback((camera) => {
+        drawRef.current(camera, pointerRef.current, 0);
+    }, []);
+    useFrameRenderer(renderCompleteFrame);
+    // An empty group, but a real one: it carries userData.id so findById() can reach
+    // this layer, and the live handle so a controller can drive it without Redux.
+    return _jsx("group", { ref: rootRef });
+};
+export default VolumetricCloudsPass;