@3driseai/3drise-viewer 0.1.7 → 0.1.8

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

@@ -0,0 +1,31 @@
+import React from 'react';
+import type { OceanLayerProps } from './types';
+/**
+ * A placed body of water — a pool, a pond, a canal, a flooded room.
+ *
+ * The object host, and the counterpart to the clouds' object host: bounded,
+ * transformable, and as many of them in a scene as you like. It runs the same
+ * material and the same wave field as the world ocean; what differs is the mesh
+ * and two uniforms.
+ *
+ * Three things follow from being bounded:
+ *
+ * **It has a transform, and its level comes from that.** `meshSettings.position.y`
+ * is the surface height, so two bodies at different heights in one scene need no
+ * coordination — and none of them is tied to the terrain's sea level either.
+ *
+ * **Waves are evaluated in its own space,** so they rotate with it and a rotated
+ * canal has waves running along the canal rather than along the world axes. The
+ * material switches on `u_bodyHalf` being non-zero.
+ *
+ * **Waves longer than the body are meaningless,** so the spectrum is clamped by
+ * its size before it reaches the table: a three-metre pool with forty-metre swell
+ * is one rigid slab tilting up and down. `OBJECT_HOST_OVERRIDES` sets the
+ * defaults for that; this clamps whatever the user then asks for.
+ *
+ * The rim taper (`edgeFade`) is in the vertex shader — without it the boundary
+ * is a sawn-off cliff of water.
+ */
+declare const WaterBody: React.FC<OceanLayerProps>;
+export default WaterBody;
+//# sourceMappingURL=WaterBody.d.ts.map

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

@@ -0,0 +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,CAsExC,CAAC;AAEF,eAAe,SAAS,CAAC"}

package/dist/components/water/WaterBody.js

@@ -0,0 +1,76 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as THREE from 'three';
+import { useEffect, useMemo } from 'react';
+import { useObjectReady } from '../../hooks/useObjectReady.js';
+import { useOceanMaterial } from '../../hooks/useOceanMaterial.js';
+/**
+ * A placed body of water — a pool, a pond, a canal, a flooded room.
+ *
+ * The object host, and the counterpart to the clouds' object host: bounded,
+ * transformable, and as many of them in a scene as you like. It runs the same
+ * material and the same wave field as the world ocean; what differs is the mesh
+ * and two uniforms.
+ *
+ * Three things follow from being bounded:
+ *
+ * **It has a transform, and its level comes from that.** `meshSettings.position.y`
+ * is the surface height, so two bodies at different heights in one scene need no
+ * coordination — and none of them is tied to the terrain's sea level either.
+ *
+ * **Waves are evaluated in its own space,** so they rotate with it and a rotated
+ * canal has waves running along the canal rather than along the world axes. The
+ * material switches on `u_bodyHalf` being non-zero.
+ *
+ * **Waves longer than the body are meaningless,** so the spectrum is clamped by
+ * its size before it reaches the table: a three-metre pool with forty-metre swell
+ * is one rigid slab tilting up and down. `OBJECT_HOST_OVERRIDES` sets the
+ * defaults for that; this clamps whatever the user then asks for.
+ *
+ * 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, meshSettings, onObjectReady, onObjectDispose, }) => {
+    const [width, depth] = config.size;
+    // 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]);
+    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);
+        // 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;
+        // 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
+        // does not try to draw ripples finer than its own grid.
+        geo.setAttribute('aCell', new THREE.BufferAttribute(new Float32Array(count).fill(cell), 1));
+        geo.setAttribute('aMorph', new THREE.BufferAttribute(new Float32Array(count), 1));
+        geo.setAttribute('aCoarse', new THREE.BufferAttribute(new Float32Array(count * 2), 2));
+        // Displaced in the vertex shader, so the computed bounds are a flat
+        // rectangle. Unlike the clipmap this SHOULD cull — a pool behind the
+        // camera is not on screen — so the sphere is grown rather than made
+        // infinite.
+        geo.computeBoundingSphere();
+        if (geo.boundingSphere)
+            geo.boundingSphere.radius *= 1.2;
+        return geo;
+    }, [width, depth, config.segments]);
+    useEffect(() => () => { geometry.dispose(); }, [geometry]);
+    const { material, rootRef } = useOceanMaterial({
+        id,
+        config: bounded,
+        quality,
+        skySettings,
+        timeSettings,
+        sunIntensity,
+    });
+    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 }) }));
+};
+export default WaterBody;

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

@@ -0,0 +1,9 @@
+export type { OceanLayerProps } from './types';
+export { default as OceanSurface } from './OceanSurface';
+export { default as WaterBody } from './WaterBody';
+export { default as OceanHost } from './Host';
+export { default as Sea } from './Sea';
+export { default as Lake } from './Lake';
+export { default as Storm } from './Storm';
+export { default as Shore } from './Shore';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/water/index.ts"],"names":[],"mappings":"AAKA,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,OAAO,IAAI,GAAG,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,QAAQ,CAAC;AACzC,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,SAAS,CAAC"}

package/dist/components/water/index.js

@@ -0,0 +1,11 @@
+// Water bodies. Four spectra over one wave field, in either of two hosts —
+// the camera-following world ocean or a placed, transformable body. Exactly one
+// world ocean is mounted at a time, by OceanBuilder; placed bodies are ordinary
+// scene objects and there can be any number of them.
+export { default as OceanSurface } from './OceanSurface.js';
+export { default as WaterBody } from './WaterBody.js';
+export { default as OceanHost } from './Host.js';
+export { default as Sea } from './Sea.js';
+export { default as Lake } from './Lake.js';
+export { default as Storm } from './Storm.js';
+export { default as Shore } from './Shore.js';

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

@@ -0,0 +1,20 @@
+import type { SkySettings, TimeSettings } from '@3driseai/3drise-core';
+import type { ObjectReadyProps } from '../../types/objectReady';
+import type { OceanConfig, OceanMeshSettings, OceanQualityConfig } from '../../types/oceanConfigs';
+/** Shared by every water type. The builder hands all four the same shape. */
+export interface OceanLayerProps extends ObjectReadyProps {
+    /** Scene id, so a controller can findById() the water and drive it live. */
+    id?: string;
+    config: OceanConfig;
+    quality: OceanQualityConfig;
+    /** The four Preetham parameters, so the water reflects and is lit by the same
+     *  atmosphere the sky is drawn with. More important here than anywhere else:
+     *  most of what you see looking at water is the sky. */
+    skySettings?: SkySettings;
+    timeSettings?: TimeSettings;
+    /** Matches SkySystem's sunIntensity, so water brightens with the scene. */
+    sunIntensity?: number;
+    /** Object host only — the placed body's transform. */
+    meshSettings?: OceanMeshSettings;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/water/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,WAAW,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnG,6EAA6E;AAC7E,MAAM,WAAW,eAAgB,SAAQ,gBAAgB;IACrD,4EAA4E;IAC5E,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,EAAE,kBAAkB,CAAC;IAC5B;;4DAEwD;IACxD,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,2EAA2E;IAC3E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,sDAAsD;IACtD,YAAY,CAAC,EAAE,iBAAiB,CAAC;CACpC"}

package/dist/components/water/types.js

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

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,gBAAgB,gCAAgC,CAAC;AAC9D,eAAO,MAAM,qBAAqB,aAKhC,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,gBAAgB,gCAAgC,CAAC;AAC9D,eAAO,MAAM,qBAAqB,aAchC,CAAC"}

package/dist/constants.js

@@ -5,8 +5,17 @@ const isLocalHostRuntime = typeof window !== 'undefined' &&
 // export const dataCenterServer = isLocalHostRuntime ? LOCAL_DATA_CENTER_SERVER : PRODUCTION_DATA_CENTER_SERVER;
 export const dataCenterServer = PRODUCTION_DATA_CENTER_SERVER;
 export const SELF_MANAGED_MATERIAL = new Set([
+    // The landscape owns its shader: splat arrays, height blending and the
+    // heightmap displacement are the material. useMaterialApplication would
+    // replace it with whatever the registry has under materialType.
+    'landscape',
     'effect',
     'space',
     'grid',
+    // The water surface owns its shader — one material for both hosts, built
+    // around the wave field. Left out of this set, useMaterialApplication
+    // overwrites it with whatever the registry has under materialType, which for
+    // a legacy ocean is the old flat-plane water material.
+    'ocean',
     // 'moon'
 ]);

package/dist/hooks/index.d.ts

@@ -2,10 +2,29 @@ export type { Update3driseShaderOptions } from './use3driseShader';
 export { update3driseShaderUniforms, use3driseShader } from './use3driseShader';
 export { useAnimationEvents } from './useAnimationEvents';
 export { useCameraAnimation } from './useCameraAnimation';
+export type { CloudNoise } from './useCloudNoise';
+export { bakeCloudNoise, useCloudNoise } from './useCloudNoise';
+export type { CloudSunState, UseCloudSunOptions } from './useCloudSun';
+export { computeCloudSun, useCloudSun } from './useCloudSun';
+export type { CloudLiveHandle } from './useCloudLive';
+export { CLOUD_LIVE_KEY, useCloudLive } from './useCloudLive';
+export type { TerrainLiveHandle } from './useTerrainLive';
+export { TERRAIN_LIVE_KEY, useTerrainLive } from './useTerrainLive';
+export type { TerrainClipmap, TerrainClipmapLevel } from './useTerrainClipmap';
+export { useTerrainClipmap } from './useTerrainClipmap';
+export type { Clipmap, ClipmapLevel } from './useClipmap';
+export { useClipmap } from './useClipmap';
+export type { OceanLiveHandle } from './useOceanLive';
+export { OCEAN_LIVE_KEY, useOceanLive } from './useOceanLive';
+export { useOceanMaterial } from './useOceanMaterial';
+export type { UseOceanMaterialOptions, OceanMaterialHandle } from './useOceanMaterial';
 export type { UseContinuousEffectsOptions, UseContinuousEffectsResult } from './useContinuousEffects';
 export { useContinuousEffects } from './useContinuousEffects';
-export type { UseCubeCameraOptions } from './useCubeCamera';
+export type { UseCubeCameraOptions, UseCubeCameraReturn } from './useCubeCamera';
 export { useCubeCamera } from './useCubeCamera';
+export type { UseEnvironmentProbeOptions } from './useEnvironmentProbe';
+export { useEnvironmentProbe } from './useEnvironmentProbe';
+export { useFrameRenderer } from './useFrameRenderer';
 export type { UseEnvironmentEffectsOptions } from './useEnvironmentEffects';
 export { useEnvironmentEffects } from './useEnvironmentEffects';
 export { useFrameAnimations } from './useFrameAnimations';
@@ -56,4 +75,8 @@ export { useTransformControls } from './useTransformControls';
 export { useVolumePoints } from './useVolumePoints';
 export { useWaterEnvironment } from './useWaterEnvironment';
 export { useWaterReflections } from './useWaterReflections';
+export type { LandscapeLiveHandle } from './useLandscapeLive';
+export { LANDSCAPE_LIVE_KEY, useLandscapeLive } from './useLandscapeLive';
+export { useLandscapeMaps } from './useLandscapeMaps';
+export type { LandscapeMapsState } from './useLandscapeMaps';
 //# sourceMappingURL=index.d.ts.map

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

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

package/dist/hooks/index.js

@@ -5,8 +5,18 @@
 export { update3driseShaderUniforms, use3driseShader } from './use3driseShader.js';
 export { useAnimationEvents } from './useAnimationEvents.js';
 export { useCameraAnimation } from './useCameraAnimation.js';
+export { bakeCloudNoise, useCloudNoise } from './useCloudNoise.js';
+export { computeCloudSun, useCloudSun } from './useCloudSun.js';
+export { CLOUD_LIVE_KEY, useCloudLive } from './useCloudLive.js';
+export { TERRAIN_LIVE_KEY, useTerrainLive } from './useTerrainLive.js';
+export { useTerrainClipmap } from './useTerrainClipmap.js';
+export { useClipmap } from './useClipmap.js';
+export { OCEAN_LIVE_KEY, useOceanLive } from './useOceanLive.js';
+export { useOceanMaterial } from './useOceanMaterial.js';
 export { useContinuousEffects } from './useContinuousEffects.js';
 export { useCubeCamera } from './useCubeCamera.js';
+export { useEnvironmentProbe } from './useEnvironmentProbe.js';
+export { useFrameRenderer } from './useFrameRenderer.js';
 export { useEnvironmentEffects } from './useEnvironmentEffects.js';
 export { useFrameAnimations } from './useFrameAnimations.js';
 export { useFrameEffects } from './useFrameEffects.js';
@@ -46,3 +56,5 @@ export { useTransformControls } from './useTransformControls.js';
 export { useVolumePoints } from './useVolumePoints.js';
 export { useWaterEnvironment } from './useWaterEnvironment.js';
 export { useWaterReflections } from './useWaterReflections.js';
+export { LANDSCAPE_LIVE_KEY, useLandscapeLive } from './useLandscapeLive.js';
+export { useLandscapeMaps } from './useLandscapeMaps.js';

package/dist/hooks/useClipmap.d.ts

@@ -0,0 +1,71 @@
+import * as THREE from 'three';
+/**
+ * Geometry clipmap rings. Shared by the terrain and the ocean.
+ *
+ * A surface that reaches the horizon cannot be one grid: at 4 m cells, 25 km is
+ * 39 million quads. A clipmap spends its vertices where they are visible instead
+ * — level 0 is a dense square centred on the camera, and every level above it is
+ * a hollow ring of the SAME vertex count at twice the cell size, so each ring
+ * covers four times the area for the same cost. Seven levels of 96 segments at
+ * 4 m reach roughly 24 km for about 65k vertices.
+ *
+ * This hook knows nothing about what displaces it. It was written for terrain
+ * (`useTerrainClipmap`, now a shim over this) and the ocean uses it unchanged;
+ * the height field, the LOD rule and the material are the caller's business.
+ *
+ * Two details make it work, and both are baked into the attributes here rather
+ * than solved at runtime:
+ *
+ * **`aMorph`** ramps 0 to 1 across the outer band of every ring. In the vertex
+ * shader it slides odd-indexed vertices onto their even neighbours, so by the
+ * ring's outer edge the polyline is exactly the next ring's coarser polyline.
+ * That closes the T-junction cracks between levels — and because it is a
+ * continuous slide rather than a swap, it also removes the pop.
+ *
+ * **`aCoarse`** is the offset to that even neighbour, and it is zero on even
+ * indices. The ring boundaries are all at even indices (which is why `segments`
+ * must be a multiple of 8), so a boundary vertex only ever moves ALONG the
+ * boundary, never off it. A morph that displaced the edge inward would trade the
+ * crack for a gap.
+ *
+ * **`aCell`** is the ring's world cell size, so one material can serve every
+ * ring. Both consumers pair it with the same morph rule —
+ * `cellLod = aCell * (1.0 + aMorph)` — which makes a ring's outer edge sample the
+ * field at exactly the next ring's cell size. Terrain uses it to drop octaves;
+ * the ocean uses it to fade out waves shorter than the cell can carry. In both
+ * cases the two sides of a seam then agree on the surface, which the geomorph
+ * alone does not guarantee.
+ *
+ * And one thing that is NOT here, because getting it wrong is the classic way to
+ * open the seams: every ring shares ONE snapped origin, exposed as `sharedSnap`.
+ * Snapping each ring to its own cell grid — which is what a clipmap tutorial will
+ * tell you to do — puts neighbouring rings on origins up to a cell apart, and the
+ * boundaries that line up perfectly in local space then miss each other in world
+ * space by that offset. The published fix for that is Asirvatham & Hoppe's
+ * L-shaped trim piece in four rotations; sharing the origin avoids needing one.
+ * The price is that coarse rings re-tessellate in sub-cell steps as the camera
+ * moves rather than snapping cleanly, and at their cell sizes the octave cut-off
+ * has already smoothed away everything that would show it.
+ */
+export interface ClipmapLevel {
+    geometry: THREE.BufferGeometry;
+    /** World size of one cell at this level. */
+    cell: number;
+    level: number;
+}
+export interface Clipmap {
+    levels: ClipmapLevel[];
+    /** The grid every ring is snapped to: twice the finest cell. Twice, so index
+     *  parity — and with it the geomorph — never flips as the camera crosses a
+     *  cell boundary. Snapping to one cell inverts the morph every step and the
+     *  whole surface shimmers. */
+    sharedSnap: number;
+}
+/**
+ * `segments` is rounded to a multiple of 8: the ring boundaries sit at
+ * `segments/4` and `segments/2`, and both must land on even indices or the morph
+ * pulls boundary vertices off their own edge.
+ */
+export declare function useClipmap(levels: number, segments: number, cellSize: number): Clipmap;
+export default useClipmap;
+//# sourceMappingURL=useClipmap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useClipmap.d.ts","sourceRoot":"","sources":["../../src/hooks/useClipmap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH,MAAM,WAAW,YAAY;IACzB,QAAQ,EAAE,KAAK,CAAC,cAAc,CAAC;IAC/B,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,OAAO;IACpB,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB;;;kCAG8B;IAC9B,UAAU,EAAE,MAAM,CAAC;CACtB;AA4ED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAgBtF;AAED,eAAe,UAAU,CAAC"}

package/dist/hooks/useClipmap.js

@@ -0,0 +1,81 @@
+import * as THREE from 'three';
+import { useEffect, useMemo } from 'react';
+/** Fraction of the ring's half-extent over which the morph runs. */
+const MORPH_BAND = 0.25;
+function buildLevel(segments, cell, hollow, level) {
+    const side = segments + 1;
+    const half = segments / 2;
+    const count = side * side;
+    const positions = new Float32Array(count * 3);
+    const aCell = new Float32Array(count);
+    const aMorph = new Float32Array(count);
+    const aCoarse = new Float32Array(count * 2);
+    for (let j = 0; j < side; j++) {
+        for (let i = 0; i < side; i++) {
+            const v = j * side + i;
+            const x = (i - half) * cell;
+            const z = (j - half) * cell;
+            positions[v * 3] = x;
+            positions[v * 3 + 1] = 0;
+            positions[v * 3 + 2] = z;
+            aCell[v] = cell;
+            // Chebyshev distance from the centre, normalised to the half-extent.
+            // Square rings need a square metric, or the morph band bulges at the
+            // corners and the seam opens there.
+            const u = Math.max(Math.abs(i - half), Math.abs(j - half)) / half;
+            const t = (u - (1 - MORPH_BAND)) / MORPH_BAND;
+            aMorph[v] = Math.min(Math.max(t, 0), 1);
+            aCoarse[v * 2] = -(i % 2) * cell;
+            aCoarse[v * 2 + 1] = -(j % 2) * cell;
+        }
+    }
+    // The hole spans the middle half in each axis, which is exactly the extent of
+    // the level below — the two meet edge to edge with nothing between them.
+    const holeLo = segments / 4;
+    const holeHi = segments - segments / 4;
+    const indices = [];
+    for (let j = 0; j < segments; j++) {
+        for (let i = 0; i < segments; i++) {
+            if (hollow && i >= holeLo && i < holeHi && j >= holeLo && j < holeHi)
+                continue;
+            const a = j * side + i;
+            const b = a + 1;
+            const c = a + side;
+            const d = c + 1;
+            indices.push(a, c, b, b, c, d);
+        }
+    }
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+    geometry.setAttribute('aCell', new THREE.BufferAttribute(aCell, 1));
+    geometry.setAttribute('aMorph', new THREE.BufferAttribute(aMorph, 1));
+    geometry.setAttribute('aCoarse', new THREE.BufferAttribute(aCoarse, 2));
+    geometry.setIndex(indices);
+    // The mesh is flat in object space and displaced in the vertex shader, so a
+    // computed bounding volume describes a plane and the ring is frustum-culled
+    // the moment the camera looks up. Infinite sphere, culling handled by the
+    // clipmap itself: it only ever exists around the camera.
+    geometry.boundingSphere = new THREE.Sphere(new THREE.Vector3(), Infinity);
+    geometry.boundingBox = new THREE.Box3(new THREE.Vector3(-Infinity, -Infinity, -Infinity), new THREE.Vector3(Infinity, Infinity, Infinity));
+    return { geometry, cell, level };
+}
+/**
+ * `segments` is rounded to a multiple of 8: the ring boundaries sit at
+ * `segments/4` and `segments/2`, and both must land on even indices or the morph
+ * pulls boundary vertices off their own edge.
+ */
+export function useClipmap(levels, segments, cellSize) {
+    const safeLevels = Math.max(1, Math.min(Math.round(levels), 14));
+    const safeSegments = Math.max(16, Math.round(segments / 8) * 8);
+    const safeCell = Math.max(0.05, cellSize);
+    const clipmap = useMemo(() => {
+        const out = [];
+        for (let l = 0; l < safeLevels; l++) {
+            out.push(buildLevel(safeSegments, safeCell * Math.pow(2, l), l > 0, l));
+        }
+        return { levels: out, sharedSnap: safeCell * 2 };
+    }, [safeLevels, safeSegments, safeCell]);
+    useEffect(() => () => { clipmap.levels.forEach((r) => r.geometry.dispose()); }, [clipmap]);
+    return clipmap;
+}
+export default useClipmap;

package/dist/hooks/useCloudLive.d.ts

@@ -0,0 +1,29 @@
+import type { Object3D } from 'three';
+/**
+ * Live cloud editing, the counterpart to useMaterialUniforms.
+ *
+ * A slider drag fires on every pointer-move. Routing that through Redux would
+ * dispatch and re-render the tree sixty times a second, and — because the cloud
+ * pass keys its temporal history off the config — would also restart the
+ * accumulation on every one of those frames, so the deck would boil while you tune
+ * it. Instead the controller finds the layer with findById(id) and writes straight
+ * into the renderer here; Redux only hears about it on slider end.
+ *
+ *   const live = useCloudLive(settings.id);
+ *   <BaseControllerUi onLiveChange={live.deck} onSettingsChange={dispatchToRedux} ... />
+ */
+/** Where VolumetricCloudsPass stashes its handle on the root object's userData. */
+export declare const CLOUD_LIVE_KEY = "__cloudLive";
+export interface CloudLiveHandle {
+    deck(key: string, value: number | boolean): void;
+    cirrus(key: string, value: number | boolean): void;
+    quality(key: string, value: number | boolean): void;
+}
+/**
+ * Safe before the layer mounts and after it unmounts: the handle is resolved at call
+ * time, not at hook time, so a controller opened before the scene is ready still works
+ * once it is — and a stale object reference degrades to a no-op instead of throwing.
+ */
+export declare function useCloudLive(target?: Object3D | string | null): CloudLiveHandle;
+export default useCloudLive;
+//# sourceMappingURL=useCloudLive.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useCloudLive.d.ts","sourceRoot":"","sources":["../../src/hooks/useCloudLive.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAGtC;;;;;;;;;;;;GAYG;AAEH,mFAAmF;AACnF,eAAO,MAAM,cAAc,gBAAgB,CAAC;AAE5C,MAAM,WAAW,eAAe;IAC5B,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;IACjD,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;IACnD,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;CACvD;AAID;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,CAAC,EAAE,QAAQ,GAAG,MAAM,GAAG,IAAI,GAAG,eAAe,CAkB/E;AAED,eAAe,YAAY,CAAC"}

package/dist/hooks/useCloudLive.js

@@ -0,0 +1,43 @@
+import { useMemo } from 'react';
+import { findById } from '../utils/sceneQuery.js';
+/**
+ * Live cloud editing, the counterpart to useMaterialUniforms.
+ *
+ * A slider drag fires on every pointer-move. Routing that through Redux would
+ * dispatch and re-render the tree sixty times a second, and — because the cloud
+ * pass keys its temporal history off the config — would also restart the
+ * accumulation on every one of those frames, so the deck would boil while you tune
+ * it. Instead the controller finds the layer with findById(id) and writes straight
+ * into the renderer here; Redux only hears about it on slider end.
+ *
+ *   const live = useCloudLive(settings.id);
+ *   <BaseControllerUi onLiveChange={live.deck} onSettingsChange={dispatchToRedux} ... />
+ */
+/** Where VolumetricCloudsPass stashes its handle on the root object's userData. */
+export const CLOUD_LIVE_KEY = '__cloudLive';
+const NOOP = { deck: () => { }, cirrus: () => { }, quality: () => { } };
+/**
+ * Safe before the layer mounts and after it unmounts: the handle is resolved at call
+ * time, not at hook time, so a controller opened before the scene is ready still works
+ * once it is — and a stale object reference degrades to a no-op instead of throwing.
+ */
+export function useCloudLive(target) {
+    return useMemo(() => {
+        const resolve = () => {
+            // Resolved per call, never cached. A findById() memoised in the
+            // controller resolves once — and if the layer is not mounted yet, which
+            // it is not while the layer is switched off, it resolves to null and
+            // stays null until the controller remounts. Every slider then silently
+            // does nothing.
+            const object = typeof target === 'string' ? findById(target) : target;
+            const handle = object?.userData?.[CLOUD_LIVE_KEY];
+            return handle ?? NOOP;
+        };
+        return {
+            deck: (key, value) => resolve().deck(key, value),
+            cirrus: (key, value) => resolve().cirrus(key, value),
+            quality: (key, value) => resolve().quality(key, value),
+        };
+    }, [target]);
+}
+export default useCloudLive;

package/dist/hooks/useCloudNoise.d.ts

@@ -0,0 +1,28 @@
+import * as THREE from 'three';
+/**
+ * Bakes the four cloud noise textures once and shares them across the scene.
+ *
+ * A hook rather than a provider: the cache is keyed on the renderer, so every
+ * caller in a Canvas gets the same volumes with no wrapper component to remember.
+ * Two decks and four placed clouds should not mean six 128-cubed volumes — the
+ * base texture alone is 8 MB, and the field is identical for all of them. What
+ * differs per cloud is how it samples it.
+ *
+ * The bake is a handful of GPU draws plus one readback, a few hundred ms on
+ * integrated graphics, paid once per renderer for the life of the page.
+ */
+export interface CloudNoise {
+    base: THREE.Data3DTexture;
+    detail: THREE.Data3DTexture;
+    weather: THREE.Texture;
+    curl: THREE.Texture;
+    dispose(): void;
+}
+export declare function bakeCloudNoise(gl: THREE.WebGLRenderer): CloudNoise | null;
+/**
+ * Null when the context cannot support the volumes. Callers should render nothing
+ * rather than treat that as an error.
+ */
+export declare function useCloudNoise(): CloudNoise | null;
+export default useCloudNoise;
+//# sourceMappingURL=useCloudNoise.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useCloudNoise.d.ts","sourceRoot":"","sources":["../../src/hooks/useCloudNoise.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAK/B;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,UAAU;IACvB,IAAI,EAAE,KAAK,CAAC,aAAa,CAAC;IAC1B,MAAM,EAAE,KAAK,CAAC,aAAa,CAAC;IAC5B,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC;IACvB,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC;IACpB,OAAO,IAAI,IAAI,CAAC;CACnB;AAoGD,wBAAgB,cAAc,CAAC,EAAE,EAAE,KAAK,CAAC,aAAa,GAAG,UAAU,GAAG,IAAI,CAwBzE;AAED;;;GAGG;AACH,wBAAgB,aAAa,IAAI,UAAU,GAAG,IAAI,CAKjD;AAED,eAAe,aAAa,CAAC"}