@3driseai/3drise-viewer 0.1.7 → 0.1.8

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/landscape/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC1D,YAAY,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA"}

package/dist/components/landscape/index.js

@@ -0,0 +1 @@
+export { default as LandscapeMesh } from './LandscapeMesh.js';

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

@@ -0,0 +1,13 @@
+import type { ObjectReadyProps } from '../../types/objectReady';
+import type { LandscapeConfig, LandscapeQualityConfig } from '../../types/landscapeConfigs';
+/** Shared by both hosts. The ground host reads its transform out of the config;
+ *  the placed host is wrapped in a CreatedObject and leaves those at zero. */
+export interface LandscapeLayerProps extends ObjectReadyProps {
+    /** Scene id, so a controller can findById() the landscape and drive it live. */
+    id?: string;
+    config: LandscapeConfig;
+    quality: LandscapeQualityConfig;
+    /** Ground host only. The placed host gets its transform from CreatedObject. */
+    applyTransform?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/landscape/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAA;AAE3F;8EAC8E;AAC9E,MAAM,WAAW,mBAAoB,SAAQ,gBAAgB;IACzD,gFAAgF;IAChF,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,eAAe,CAAA;IACvB,OAAO,EAAE,sBAAsB,CAAA;IAC/B,+EAA+E;IAC/E,cAAc,CAAC,EAAE,OAAO,CAAA;CAC3B"}

package/dist/components/landscape/types.js

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

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

@@ -0,0 +1,23 @@
+import React from 'react';
+import type { TerrainLayerProps } from './types';
+/**
+ * Mesa and canyon country — built by subtraction, which is what makes it read
+ * correctly.
+ *
+ * A canyon is not a mountain range with the sign flipped: it is a plateau with a
+ * drainage network cut into it. So `plateau` flattens the top of the height range
+ * first, and `valleyDepth` then removes material along the zero set of a ridged
+ * noise field — which is a connected, branching line, so the channels join up
+ * into a network instead of appearing as unrelated gouges.
+ *
+ * `terraces` is doing more work here than anywhere else. Sedimentary rock erodes
+ * in bands, and the horizontal banding on the walls is most of what makes a mesa
+ * read as a mesa rather than as a lumpy plateau. `terraceSharpness` near 1 gives
+ * the near-vertical riser that a hard stratum leaves standing.
+ *
+ * The most expensive of the four: near-vertical walls mean the shadow march walks
+ * a long way before it clears an occluder.
+ */
+declare const Canyon: React.FC<TerrainLayerProps>;
+export default Canyon;
+//# sourceMappingURL=Canyon.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Canyon.d.ts","sourceRoot":"","sources":["../../../src/components/terrain/Canyon.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAEvC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD;;;;;;;;;;;;;;;;;GAiBG;AACH,QAAA,MAAM,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CASvC,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/components/terrain/Canyon.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import TerrainSurface from './TerrainSurface.js';
+/**
+ * Mesa and canyon country — built by subtraction, which is what makes it read
+ * correctly.
+ *
+ * A canyon is not a mountain range with the sign flipped: it is a plateau with a
+ * drainage network cut into it. So `plateau` flattens the top of the height range
+ * first, and `valleyDepth` then removes material along the zero set of a ridged
+ * noise field — which is a connected, branching line, so the channels join up
+ * into a network instead of appearing as unrelated gouges.
+ *
+ * `terraces` is doing more work here than anywhere else. Sedimentary rock erodes
+ * in bands, and the horizontal banding on the walls is most of what makes a mesa
+ * read as a mesa rather than as a lumpy plateau. `terraceSharpness` near 1 gives
+ * the near-vertical riser that a hard stratum leaves standing.
+ *
+ * The most expensive of the four: near-vertical walls mean the shadow march walks
+ * a long way before it clears an occluder.
+ */
+const Canyon = ({ config, quality, ...rest }) => {
+    // Cliff faces are where the analytic shadow earns its keep and also where it
+    // is most likely to run out of march before it escapes the wall. Floored, the
+    // same way Cumulonimbus floors its step budget.
+    const resolvedQuality = useMemo(() => ({ ...quality, shadowSteps: Math.max(quality.shadowSteps, 16) }), [quality]);
+    return _jsx(TerrainSurface, { config: config, quality: resolvedQuality, ...rest });
+};
+export default Canyon;

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

@@ -0,0 +1,22 @@
+import React from 'react';
+import type { TerrainLayerProps } from './types';
+/**
+ * A dune field. The one landform that is not primarily fBm.
+ *
+ * Dunes form transverse to the prevailing wind, so the shape is a wave train:
+ * `bearing` sets its direction, `duneWavelength` its spacing, and the fBm's job
+ * is to bend the crest lines and vary the height along them rather than to be the
+ * terrain. `duneAsymmetry` is what stops it looking like corrugated iron — a real
+ * dune is a long windward ramp and a short slip face at the angle of repose, and
+ * at zero the two sides are mirror images.
+ *
+ * Strata and canyon carving are forced off; sand has no bedding planes.
+ *
+ * The defaults also carry more specular and more ground bounce than the other
+ * three, which is not decoration: sand's low-sun sheen and the light it throws
+ * back into its own lee are most of why a dune field reads as sand rather than as
+ * beige hills.
+ */
+declare const Dunes: React.FC<TerrainLayerProps>;
+export default Dunes;
+//# sourceMappingURL=Dunes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Dunes.d.ts","sourceRoot":"","sources":["../../../src/components/terrain/Dunes.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAEvC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD;;;;;;;;;;;;;;;;GAgBG;AACH,QAAA,MAAM,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAMtC,CAAC;AAEF,eAAe,KAAK,CAAC"}

package/dist/components/terrain/Dunes.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import TerrainSurface from './TerrainSurface.js';
+/**
+ * A dune field. The one landform that is not primarily fBm.
+ *
+ * Dunes form transverse to the prevailing wind, so the shape is a wave train:
+ * `bearing` sets its direction, `duneWavelength` its spacing, and the fBm's job
+ * is to bend the crest lines and vary the height along them rather than to be the
+ * terrain. `duneAsymmetry` is what stops it looking like corrugated iron — a real
+ * dune is a long windward ramp and a short slip face at the angle of repose, and
+ * at zero the two sides are mirror images.
+ *
+ * Strata and canyon carving are forced off; sand has no bedding planes.
+ *
+ * The defaults also carry more specular and more ground bounce than the other
+ * three, which is not decoration: sand's low-sun sheen and the light it throws
+ * back into its own lee are most of why a dune field reads as sand rather than as
+ * beige hills.
+ */
+const Dunes = ({ config, ...rest }) => {
+    const resolved = useMemo(() => ({ ...config, terraces: 0, plateau: 0, valleyDepth: 0 }), [config]);
+    return _jsx(TerrainSurface, { config: resolved, ...rest });
+};
+export default Dunes;

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

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { TerrainLayerProps } from './types';
+/**
+ * Rolling hills and plains — the same fBm with the ridge fold near zero, so the
+ * crests stay rounded, and a heavier domain warp so the shapes still have a grain
+ * rather than reading as billows.
+ *
+ * The friendly default, and the one worth reaching for when the terrain is a
+ * setting rather than the subject: it is the cheapest of the four (fewest
+ * octaves, shallow relief, so the shadow march exits early) and the least likely
+ * to fight whatever is placed on it.
+ *
+ * Strata and canyon carving are forced off — a terraced hill is a quarry.
+ */
+declare const Hills: React.FC<TerrainLayerProps>;
+export default Hills;
+//# sourceMappingURL=Hills.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Hills.d.ts","sourceRoot":"","sources":["../../../src/components/terrain/Hills.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAEvC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAMtC,CAAC;AAEF,eAAe,KAAK,CAAC"}

package/dist/components/terrain/Hills.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import TerrainSurface from './TerrainSurface.js';
+/**
+ * Rolling hills and plains — the same fBm with the ridge fold near zero, so the
+ * crests stay rounded, and a heavier domain warp so the shapes still have a grain
+ * rather than reading as billows.
+ *
+ * The friendly default, and the one worth reaching for when the terrain is a
+ * setting rather than the subject: it is the cheapest of the four (fewest
+ * octaves, shallow relief, so the shadow march exits early) and the least likely
+ * to fight whatever is placed on it.
+ *
+ * Strata and canyon carving are forced off — a terraced hill is a quarry.
+ */
+const Hills = ({ config, ...rest }) => {
+    const resolved = useMemo(() => ({ ...config, terraces: 0, plateau: 0, valleyDepth: 0 }), [config]);
+    return _jsx(TerrainSurface, { config: resolved, ...rest });
+};
+export default Hills;

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

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { TerrainLayerProps } from './types';
+/**
+ * Alpine terrain — ridged fBm with derivative damping, rock splatted by slope and
+ * a snow line held off the steep faces.
+ *
+ * The reference case for the height field, because its silhouette shows every
+ * term at once: the ridge fold makes the crest lines, the domain warp bends them
+ * into a range instead of a field of bumps, and the erosion damping is what puts
+ * flat floors in the valleys between them. Turn erosion to zero and it reads as
+ * noise immediately.
+ *
+ * Canyon-only shaping is forced off. Both terms are gated on the landform inside
+ * the shader anyway, so a stale value would do nothing visible while making the
+ * panel read as though it should.
+ */
+declare const Mountains: React.FC<TerrainLayerProps>;
+export default Mountains;
+//# sourceMappingURL=Mountains.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Mountains.d.ts","sourceRoot":"","sources":["../../../src/components/terrain/Mountains.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAEvC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,SAAS,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAG1C,CAAC;AAEF,eAAe,SAAS,CAAC"}

package/dist/components/terrain/Mountains.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import TerrainSurface from './TerrainSurface.js';
+/**
+ * Alpine terrain — ridged fBm with derivative damping, rock splatted by slope and
+ * a snow line held off the steep faces.
+ *
+ * The reference case for the height field, because its silhouette shows every
+ * term at once: the ridge fold makes the crest lines, the domain warp bends them
+ * into a range instead of a field of bumps, and the erosion damping is what puts
+ * flat floors in the valleys between them. Turn erosion to zero and it reads as
+ * noise immediately.
+ *
+ * Canyon-only shaping is forced off. Both terms are gated on the landform inside
+ * the shader anyway, so a stale value would do nothing visible while making the
+ * panel read as though it should.
+ */
+const Mountains = ({ config, ...rest }) => {
+    const resolved = useMemo(() => ({ ...config, plateau: 0, valleyDepth: 0 }), [config]);
+    return _jsx(TerrainSurface, { config: resolved, ...rest });
+};
+export default Mountains;

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

@@ -0,0 +1,22 @@
+import React from 'react';
+import type { TerrainLayerProps } from './types';
+/**
+ * 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.
+ */
+declare const TerrainSurface: React.FC<TerrainLayerProps>;
+export default TerrainSurface;
+//# sourceMappingURL=TerrainSurface.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TerrainSurface.d.ts","sourceRoot":"","sources":["../../../src/components/terrain/TerrainSurface.tsx"],"names":[],"mappings":"AACA,OAAO,KAAqC,MAAM,OAAO,CAAC;AAU1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD;;;;;;;;;;;;;;;;GAgBG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAgG/C,CAAC;AAEF,eAAe,cAAc,CAAC"}

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"}