@3driseai/3drise-viewer 0.1.6 → 0.1.8

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

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { LandscapeLayerProps } from './types';
+/**
+ * The landscape renderer, shared by the world ground and the placed object.
+ *
+ * Unlike the cloud pass this does not take over the render loop, and unlike the
+ * terrain it is a bounded tile — which is what buys the two things the
+ * procedural terrain cannot have: it frustum-culls per chunk, and it CASTS into
+ * the scene's shadow map, because the sun's shadow camera already covers it.
+ *
+ * Three things happen per frame and none of them re-render React: the config is
+ * pushed into uniforms (with any live controller overrides on top), the bounds
+ * are refreshed if the elevation moved, and the height field's world origin is
+ * kept in step for CPU queries.
+ */
+declare const LandscapeMesh: React.FC<LandscapeLayerProps>;
+export default LandscapeMesh;
+//# sourceMappingURL=LandscapeMesh.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LandscapeMesh.d.ts","sourceRoot":"","sources":["../../../src/components/landscape/LandscapeMesh.tsx"],"names":[],"mappings":"AACA,OAAO,KAAkD,MAAM,OAAO,CAAA;AA0BtE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAElD;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,mBAAmB,CA8QhD,CAAA;AA8BD,eAAe,aAAa,CAAA"}

package/dist/components/landscape/LandscapeMesh.js

@@ -0,0 +1,278 @@
+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 { useObjectReady } from '../../hooks/useObjectReady.js';
+import { useLandscapeMaps } from '../../hooks/useLandscapeMaps.js';
+import { LANDSCAPE_LIVE_KEY } from '../../hooks/useLandscapeLive.js';
+import { LandscapeMaterial, createLandscapeDepthMaterial, createLandscapeDistanceMaterial, createLandscapeUniforms, landscapeShapeKey, } from '../../shaders/landscape/LandscapeMaterial.js';
+import { applyLandscapeMaps, applyLandscapeUniforms } from '../../utils/landscapeUniforms.js';
+import { buildLandscapeGeometry, setLandscapeBounds } from '../../utils/landscapeGeometry.js';
+import { registerLandscapeHeightField, unregisterLandscapeHeightField, } from '../../utils/landscapeHeight.js';
+import { LANDSCAPE_LIVE_AUTOSPLAT_KEYS, LANDSCAPE_LIVE_CONFIG_KEYS, LANDSCAPE_LIVE_QUALITY_KEYS, LANDSCAPE_LIVE_SURFACE_KEYS, } from '../../types/landscapeConfigs.js';
+/**
+ * The landscape renderer, shared by the world ground and the placed object.
+ *
+ * Unlike the cloud pass this does not take over the render loop, and unlike the
+ * terrain it is a bounded tile — which is what buys the two things the
+ * procedural terrain cannot have: it frustum-culls per chunk, and it CASTS into
+ * the scene's shadow map, because the sun's shadow camera already covers it.
+ *
+ * Three things happen per frame and none of them re-render React: the config is
+ * pushed into uniforms (with any live controller overrides on top), the bounds
+ * are refreshed if the elevation moved, and the height field's world origin is
+ * kept in step for CPU queries.
+ */
+const LandscapeMesh = ({ id = '3drise-landscape', config, quality, applyTransform = true, onObjectReady, onObjectDispose, }) => {
+    const gl = useThree((state) => state.gl);
+    const maps = useLandscapeMaps(config, quality);
+    const surfaces = useMemo(() => config.surfaces.filter((s) => !!s.diffuse), [config.surfaces]);
+    const count = Math.max(1, surfaces.length);
+    // Uniforms are shared by reference with the depth and distance materials, so
+    // a write here reaches the shadow pass too and the shadow cannot drift from
+    // the surface it belongs to.
+    const uniforms = useMemo(() => createLandscapeUniforms(count), [count]);
+    const shape = useMemo(() => ({
+        count,
+        samples: config.surfaceSamples,
+        splats: config.splatMaps.length,
+        auto: config.splatSource === 'auto' || config.splatMaps.length === 0,
+        stochastic: quality.stochastic && surfaces.some((s) => s.aperiodic),
+        triplanar: quality.triplanar && surfaces.some((s) => s.triplanar),
+        ao: !!config.aoMap,
+    }), [
+        count,
+        config.surfaceSamples,
+        config.splatMaps.length,
+        config.splatSource,
+        config.aoMap,
+        quality.stochastic,
+        quality.triplanar,
+        surfaces,
+    ]);
+    const shapeKey = landscapeShapeKey(shape);
+    // Shape lives in #defines, so a change of shape is a new program. Rebuilding
+    // the material is the honest way to say that; the controller commits those
+    // knobs on release so it happens once per edit, not once per frame of a drag.
+    const material = useMemo(() => new LandscapeMaterial(shape, uniforms), [shapeKey, uniforms]);
+    const depthMaterial = useMemo(() => createLandscapeDepthMaterial(uniforms), [uniforms]);
+    const distanceMaterial = useMemo(() => createLandscapeDistanceMaterial(uniforms), [uniforms]);
+    useEffect(() => () => {
+        material.dispose();
+        depthMaterial.dispose();
+        distanceMaterial.dispose();
+    }, [material, depthMaterial, distanceMaterial]);
+    // RTIN's error map is normalised, so a world-unit budget divides by the
+    // elevation scale. Quantised, because a float that jitters in the last digit
+    // would rebuild the mesh for nothing. Note this reads the COMMITTED
+    // elevation: a live drag moves the surface without re-meshing, and the error
+    // catches up on release.
+    const normalisedError = useMemo(() => {
+        const raw = quality.meshError / Math.max(config.elevationScale, 1e-3);
+        return Math.round(raw * 1e5) / 1e5;
+    }, [quality.meshError, config.elevationScale]);
+    const geometry = useMemo(() => {
+        if (!maps.heightField)
+            return null;
+        return buildLandscapeGeometry(maps.heightField, {
+            size: config.size,
+            chunks: quality.chunks,
+            maxError: normalisedError,
+        });
+    }, [maps.heightField, config.size, quality.chunks, normalisedError]);
+    useEffect(() => () => { geometry?.dispose(); }, [geometry]);
+    useEffect(() => {
+        if (maps.ready)
+            applyLandscapeMaps(uniforms, maps);
+    }, [maps, uniforms]);
+    // ---- live controller overrides -----------------------------------------
+    // A drag writes here every pointer-move and the frame loop reads it on top of
+    // the config, so the landscape responds without a dispatch per frame. Cleared
+    // when the config identity changes, which is exactly slider-end committing
+    // the same value.
+    const liveConfig = useRef({});
+    const liveSurfaces = useRef({});
+    const liveAutoSplat = useRef({});
+    const liveQuality = useRef({});
+    const dirty = useRef(true);
+    // Cleared by the block they belong to, and by that block only: surfaces and
+    // the auto-splat rows live in `config`, so a quality edit must not drop a
+    // surface override that has not been committed yet.
+    useEffect(() => {
+        liveConfig.current = {};
+        liveSurfaces.current = {};
+        liveAutoSplat.current = {};
+        dirty.current = true;
+    }, [config]);
+    useEffect(() => { liveQuality.current = {}; dirty.current = true; }, [quality]);
+    const rootRef = useRef(null);
+    const meshRefs = useRef([]);
+    // The live handle a controller reaches through findById(id).userData.
+    //
+    // It filters. A controller hands over every key its slider owns and this
+    // drops anything that is not purely a uniform, because a rebuild key applied
+    // live half-applies: `size` scales the triplanar projection from a uniform
+    // while the mesh, built at the committed size, stays where it was. The key
+    // sets live in landscapeConfigs so the panel and the renderer cannot drift.
+    const liveHandle = useMemo(() => ({
+        config: (key, value) => {
+            if (!LANDSCAPE_LIVE_CONFIG_KEYS.includes(key))
+                return;
+            liveConfig.current[key] = value;
+            dirty.current = true;
+        },
+        quality: (key, value) => {
+            if (!LANDSCAPE_LIVE_QUALITY_KEYS.includes(key))
+                return;
+            liveQuality.current[key] = value;
+            dirty.current = true;
+        },
+        surface: (index, key, value) => {
+            if (!LANDSCAPE_LIVE_SURFACE_KEYS.includes(key))
+                return;
+            liveSurfaces.current[`${index}:${key}`] = value;
+            dirty.current = true;
+        },
+        autoSplat: (key, value) => {
+            if (!LANDSCAPE_LIVE_AUTOSPLAT_KEYS.includes(key))
+                return;
+            liveAutoSplat.current[key] = value;
+            dirty.current = true;
+        },
+    }), []);
+    // Attached from a CALLBACK REF, not from an effect, and 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).
+    //
+    // The effect version is what broke live editing outright. This component used
+    // to return null until the maps had loaded, so on the first render there was
+    // no group; the effect ran, found `rootRef.current` null, and returned. Its
+    // deps were [id, liveHandle], neither of which changes when the maps finish
+    // loading — so it never ran again, `userData.id` was never set, findById()
+    // never resolved the landscape, and every controller's live handle fell back
+    // to the no-op for the rest of the session. Nothing errored; the panel simply
+    // did nothing until the pointer came up. A callback ref cannot miss the
+    // mount, whatever the render gating does later.
+    const attachRoot = useCallback((group) => {
+        rootRef.current = group;
+        if (!group)
+            return;
+        group.userData.id = id;
+        group.userData[LANDSCAPE_LIVE_KEY] = liveHandle;
+    }, [id, liveHandle]);
+    useEffect(() => () => {
+        const root = rootRef.current;
+        if (root)
+            delete root.userData[LANDSCAPE_LIVE_KEY];
+    }, []);
+    useObjectReady(rootRef, { id, type: 'landscape', config, quality }, onObjectReady, onObjectDispose);
+    // ---- CPU height field ---------------------------------------------------
+    useEffect(() => {
+        if (!maps.heightField)
+            return;
+        return () => unregisterLandscapeHeightField(id);
+    }, [id, maps.heightField]);
+    const appliedElevation = useRef({ scale: NaN, bias: NaN });
+    useFrame(() => {
+        if (!geometry)
+            return;
+        const merged = mergeLive(config, liveConfig.current, liveSurfaces.current, liveAutoSplat.current);
+        const mergedQuality = Object.keys(liveQuality.current).length === 0
+            ? quality
+            : { ...quality, ...liveQuality.current };
+        if (dirty.current) {
+            applyLandscapeUniforms(uniforms, merged, mergedQuality);
+            material.wireframe = mergedQuality.wireframe;
+            material.envMapIntensity = merged.envMapIntensity;
+            // Shadow flags are per mesh, so the live path has to reach the chunks
+            // rather than the material.
+            for (const mesh of meshRefs.current) {
+                if (!mesh)
+                    continue;
+                mesh.castShadow = mergedQuality.castShadows;
+                mesh.receiveShadow = mergedQuality.receiveShadows;
+            }
+            applyAnisotropy(mergedQuality.anisotropy);
+            // rotationY is a live key, and it is a transform rather than a
+            // uniform — the JSX prop carries the committed value, so the drag has
+            // to be written onto the object itself or the slider moves nothing.
+            const root = rootRef.current;
+            if (root && applyTransform) {
+                root.rotation.y = THREE.MathUtils.degToRad(merged.rotationY);
+            }
+            dirty.current = false;
+        }
+        if (appliedElevation.current.scale !== merged.elevationScale
+            || appliedElevation.current.bias !== merged.elevationBias) {
+            appliedElevation.current = { scale: merged.elevationScale, bias: merged.elevationBias };
+            setLandscapeBounds(geometry, merged.elevationScale, merged.elevationBias);
+        }
+        const root = rootRef.current;
+        if (root && maps.heightField) {
+            registerLandscapeHeightField(id, {
+                data: maps.heightField.data,
+                gridSize: maps.heightField.gridSize,
+                tileSize: maps.heightField.tileSize,
+                size: merged.size,
+                origin: root.getWorldPosition(new THREE.Vector3()),
+                rotationY: root.rotation.y,
+                elevationScale: merged.elevationScale,
+                elevationBias: merged.elevationBias,
+            });
+        }
+    });
+    // Anisotropy is capped by the device, not by the panel, and re-uploading the
+    // arrays is not free — so it is applied only when the value actually changes,
+    // whether that came from a commit or from a live drag.
+    const appliedAnisotropy = useRef(NaN);
+    const applyAnisotropy = useCallback((requested) => {
+        const value = Math.min(requested, gl.capabilities.getMaxAnisotropy());
+        if (appliedAnisotropy.current === value)
+            return;
+        appliedAnisotropy.current = value;
+        if (maps.diffuse) {
+            maps.diffuse.anisotropy = value;
+            maps.diffuse.needsUpdate = true;
+        }
+        if (maps.normal) {
+            maps.normal.anisotropy = value;
+            maps.normal.needsUpdate = true;
+        }
+    }, [gl, maps.diffuse, maps.normal]);
+    useEffect(() => {
+        appliedAnisotropy.current = NaN;
+        applyAnisotropy(quality.anisotropy);
+    }, [applyAnisotropy, quality.anisotropy]);
+    // The group is ALWAYS rendered, even before the maps have loaded and even when
+    // the config is incomplete — only the chunks inside it are gated. TerrainSurface
+    // does the same, and this is why: the root is what carries `userData.id`, so it
+    // is what findById() resolves, and a controller that opens before the ground
+    // exists has to find something to write into. Returning null here is what broke
+    // live editing.
+    const ready = !!geometry && maps.ready;
+    return (_jsx("group", { ref: attachRoot, position: applyTransform ? config.origin : undefined, rotation: applyTransform ? [0, THREE.MathUtils.degToRad(config.rotationY), 0] : undefined, children: ready && geometry.chunks.map((chunk, i) => (_jsx("mesh", { ref: (m) => { meshRefs.current[i] = m; }, geometry: chunk.geometry, material: material, castShadow: quality.castShadows, receiveShadow: quality.receiveShadows, customDepthMaterial: depthMaterial, customDistanceMaterial: distanceMaterial }, i))) }));
+};
+/** Config with the live controller's overrides on top. Cheap enough to build per
+ *  frame — it is at most eight small objects — and only rebuilt when something
+ *  actually wrote. */
+function mergeLive(config, live, liveSurfaces, liveAutoSplat) {
+    const keys = Object.keys(liveSurfaces);
+    const surfaces = keys.length === 0
+        ? config.surfaces
+        : config.surfaces.map((surface, index) => {
+            let next = null;
+            for (const key of keys) {
+                const [i, field] = key.split(':');
+                if (Number(i) !== index)
+                    continue;
+                next = next ?? { ...surface };
+                next[field] = liveSurfaces[key];
+            }
+            return next ?? surface;
+        });
+    const autoSplat = Object.keys(liveAutoSplat).length === 0
+        ? config.autoSplat
+        : { ...config.autoSplat, ...liveAutoSplat };
+    return { ...config, ...live, surfaces, autoSplat };
+}
+export default LandscapeMesh;

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

@@ -0,0 +1,3 @@
+export { default as LandscapeMesh } from './LandscapeMesh';
+export type { LandscapeLayerProps } from './types';
+//# sourceMappingURL=index.d.ts.map

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