@3driseai/3drise-viewer 0.1.30 → 0.1.32

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

@@ -20,4 +20,6 @@ export { default as ShapeBurstParticles } from './ShapeBurstParticles';
 export type { ShapeBurstParticlesProps } from './ShapeBurstParticles';
 export { default as ShapeFlowParticles } from './ShapeFlowParticles';
 export type { ShapeFlowParticlesProps } from './ShapeFlowParticles';
+export { default as FireworksParticles } from './FireworksParticles';
+export type { FireworksParticlesProps } from './FireworksParticles';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/particles/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACzE,YAAY,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAC3E,YAAY,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AAC1E,OAAO,EAAE,OAAO,IAAI,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AACvF,YAAY,EAAE,gCAAgC,EAAE,MAAM,+BAA+B,CAAC;AACtF,OAAO,EAAE,OAAO,IAAI,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AACnF,YAAY,EAAE,8BAA8B,EAAE,MAAM,6BAA6B,CAAC;AAClF,OAAO,EAAE,OAAO,IAAI,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAC7E,YAAY,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC;AAC5E,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACzE,YAAY,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,EAAE,OAAO,IAAI,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAC7E,YAAY,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC;AAC5E,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACnE,YAAY,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,EAAE,OAAO,IAAI,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAC/E,YAAY,EAAE,4BAA4B,EAAE,MAAM,2BAA2B,CAAC;AAC9E,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACvE,YAAY,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACrE,YAAY,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/particles/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACzE,YAAY,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAC3E,YAAY,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AAC1E,OAAO,EAAE,OAAO,IAAI,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AACvF,YAAY,EAAE,gCAAgC,EAAE,MAAM,+BAA+B,CAAC;AACtF,OAAO,EAAE,OAAO,IAAI,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AACnF,YAAY,EAAE,8BAA8B,EAAE,MAAM,6BAA6B,CAAC;AAClF,OAAO,EAAE,OAAO,IAAI,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAC7E,YAAY,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC;AAC5E,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACzE,YAAY,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,EAAE,OAAO,IAAI,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAC7E,YAAY,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC;AAC5E,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACnE,YAAY,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,EAAE,OAAO,IAAI,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAC/E,YAAY,EAAE,4BAA4B,EAAE,MAAM,2BAA2B,CAAC;AAC9E,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACvE,YAAY,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACrE,YAAY,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AACpE,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACrE,YAAY,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/components/particles/index.js

@@ -10,3 +10,4 @@ export { default as NeonRainParticles } from './NeonRainParticles.js';
 export { default as MagneticBottleParticles } from './MagneticBottleParticles.js';
 export { default as ShapeBurstParticles } from './ShapeBurstParticles.js';
 export { default as ShapeFlowParticles } from './ShapeFlowParticles.js';
+export { default as FireworksParticles } from './FireworksParticles.js';

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

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

package/dist/components/terrain/TerrainSurface.js

@@ -11,6 +11,21 @@ import { applyTerrainAmbient, applyTerrainTextures, applyTerrainUniforms } from
 import { useTerrainTextures } from '../../hooks/useTerrainTextures.js';
 import { getAnimatableProperties } from '@3driseai/3drise-core';
 import { applyConfigKeyframeAnimations, applyConfigMouseMove, } from '../../utils/configAnimations.js';
+import { TERRAIN_DRAW_ORDER, ringDrawOrder } from '../../utils/environmentDrawOrder.js';
+import { isMobileDevice } from '../../utils/deviceTier.js';
+/**
+ * Phone / tablet tier, applied at render time only — the saved scene keeps its
+ * numbers, so the same project is full quality on a desktop. Measured on the
+ * desktop: textures within 100 m instead of 1500 saved ~2.8 ms, 5 octaves
+ * instead of 8 ~1.7 ms; the shadow march costs nothing measurable, so it stays.
+ * Fewer, coarser rings cut the vertex load by roughly half.
+ */
+const MOBILE = {
+    maxSegments: 96,
+    maxLevels: 8,
+    maxOctaves: 5,
+    maxTextureDistance: 400,
+};
 /**
  * The terrain renderer. One clipmap, one material, four landforms — they differ
  * by the shaping operator the height field applies, not by having separate
@@ -29,7 +44,8 @@ import { applyConfigKeyframeAnimations, applyConfigMouseMove, } from '../../util
  * the camera. Nothing here re-renders React.
  */
 const TerrainSurface = ({ id = '3drise-terrain', config, quality, skySettings, timeSettings, sunIntensity = 1, animations, mouseMove, onObjectReady, onObjectDispose, }) => {
-    const clipmap = useTerrainClipmap(quality.levels, quality.segments, quality.cellSize);
+    const mobile = isMobileDevice();
+    const clipmap = useTerrainClipmap(mobile ? Math.min(quality.levels, MOBILE.maxLevels) : quality.levels, mobile ? Math.min(quality.segments, MOBILE.maxSegments) : quality.segments, quality.cellSize);
     const { state: sun, update: updateSun } = useCloudSun({ skySettings, timeSettings });
     const material = useMemo(() => new TerrainMaterial(), []);
     // The four ground textures, packed into arrays. Repacks only when a map URL
@@ -46,9 +62,9 @@ const TerrainSurface = ({ id = '3drise-terrain', config, quality, skySettings, t
     useEffect(() => { liveConfig.current = {}; }, [config]);
     useEffect(() => { liveQuality.current = {}; }, [quality]);
     // The `terrain` keyframe / pointer domains: config -> keyframes -> pointer ->
-    // live drag, the clouds' order. Only the surface's lighting and colour knobs are
-    // in the set — the registry marks every land-shape knob non-animatable, so the
-    // ground itself never moves.
+    // live drag, the clouds' order. Every numeric / colour knob is in the set — shape
+    // and surface alike are shader uniforms, so the ground can rise or shift per frame;
+    // only the integer counts (octaves, strata) are structural in the registry.
     const animatable = useMemo(() => new Set(getAnimatableProperties({ type: 'terrain', config }, 'terrain').map(p => p.value)), [config.terrainType]);
     const override = useRef({});
     const startValues = useRef({});
@@ -91,6 +107,10 @@ const TerrainSurface = ({ id = '3drise-terrain', config, quality, skySettings, t
             applyConfigMouseMove(mouseMove.terrain.properties, config, o, state.pointer, animatable);
         }
         const cfg = { ...config, ...o, ...liveConfig.current };
+        if (mobile) {
+            cfg.octaves = Math.min(cfg.octaves, MOBILE.maxOctaves);
+            cfg.textureDistance = Math.min(cfg.textureDistance ?? 4000, MOBILE.maxTextureDistance);
+        }
         const qual = { ...quality, ...liveQuality.current };
         applyTerrainUniforms(material, cfg, qual);
         applyTerrainTextures(material, cfg, textures);
@@ -110,6 +130,8 @@ const TerrainSurface = ({ id = '3drise-terrain', config, quality, skySettings, t
         }
     });
     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, 
+            // After the water, inner ring first: see environmentDrawOrder.
+            renderOrder: ringDrawOrder(TERRAIN_DRAW_ORDER, ring.level), 
             // 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.

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

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

package/dist/components/water/OceanSurface.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+import { OCEAN_DRAW_ORDER, ringDrawOrder } from '../../utils/environmentDrawOrder.js';
 import { useRef } from 'react';
 import { useObjectReady } from '../../hooks/useObjectReady.js';
 import { useClipmap } from '../../hooks/useClipmap.js';
@@ -25,7 +26,7 @@ import { useOceanMaterial } from '../../hooks/useOceanMaterial.js';
  * a sea at 0. What connects them is computed — the shoreline is where the ground
  * crosses this surface — never configured.
  */
-const OceanSurface = ({ id = '3drise-water', config, quality, skySettings, timeSettings, sunIntensity = 1, animations, mouseMove, onObjectReady, onObjectDispose, }) => {
+const OceanSurface = ({ id = '3drise-water', config, quality, skySettings, timeSettings, sunIntensity = 1, animations, mouseMove, terrain, onObjectReady, onObjectDispose, }) => {
     const clipmap = useClipmap(quality.levels, quality.segments, quality.cellSize);
     const meshRefs = useRef([]);
     const { material, rootRef } = useOceanMaterial({
@@ -37,6 +38,7 @@ const OceanSurface = ({ id = '3drise-water', config, quality, skySettings, timeS
         sunIntensity,
         animations,
         mouseMove,
+        terrain,
         onFrame: (cfg, _qual, state) => {
             // ONE origin for the whole pyramid, snapped to twice the finest cell.
             //
@@ -54,6 +56,8 @@ const OceanSurface = ({ id = '3drise-water', config, quality, skySettings, timeS
     });
     useObjectReady(rootRef, { id, type: 'ocean', config, quality }, onObjectReady, onObjectDispose);
     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, 
+            // Before the terrain, inner ring first: see environmentDrawOrder.
+            renderOrder: ringDrawOrder(OCEAN_DRAW_ORDER, ring.level), 
             // Displacement happens in the vertex shader, so the
             // object-space bounds describe a flat plane. Culling against
             // them hides the water the moment the camera tilts up.

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

@@ -1,6 +1,6 @@
 import type { SkySettings, TimeSettings } from '@3driseai/3drise-core';
 import type { ObjectReadyProps } from '../../types/objectReady';
-import type { OceanConfig, OceanMeshSettings, OceanQualityConfig, ObjectAnimations, MouseMoveInteractions } from '@3driseai/3drise-core';
+import type { OceanConfig, OceanMeshSettings, OceanQualityConfig, ObjectAnimations, MouseMoveInteractions, TerrainConfig } from '@3driseai/3drise-core';
 /** 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. */
@@ -20,5 +20,7 @@ export interface OceanLayerProps extends ObjectReadyProps {
     animations?: ObjectAnimations;
     /** Pointer bindings; same `ocean` domain. */
     mouseMove?: MouseMoveInteractions;
+    /** The environment terrain, for the world ocean's shoreline and terrain shadow. */
+    terrain?: TerrainConfig | null;
 }
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +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,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAEzI,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;IACjC,mEAAmE;IACnE,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,6CAA6C;IAC7C,SAAS,CAAC,EAAE,qBAAqB,CAAC;CACrC"}
+{"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,gBAAgB,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAExJ,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;IACjC,mEAAmE;IACnE,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,6CAA6C;IAC7C,SAAS,CAAC,EAAE,qBAAqB,CAAC;IAClC,mFAAmF;IACnF,OAAO,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;CAClC"}

package/dist/hooks/useOceanMaterial.d.ts

@@ -2,7 +2,7 @@ import * as THREE from 'three';
 import { type RootState } from '@react-three/fiber';
 import type { SkySettings, TimeSettings } from '@3driseai/3drise-core';
 import { OceanSurfaceMaterial } from '../shaders/ocean/OceanSurfaceMaterial';
-import type { OceanConfig, OceanQualityConfig, ObjectAnimations, MouseMoveInteractions } from '@3driseai/3drise-core';
+import type { OceanConfig, OceanQualityConfig, ObjectAnimations, MouseMoveInteractions, TerrainConfig } from '@3driseai/3drise-core';
 /**
  * Everything the two water hosts share: the material, the live-edit handle, and
  * the per-frame uniform push.
@@ -27,6 +27,10 @@ export interface UseOceanMaterialOptions {
     animations?: ObjectAnimations;
     /** Pointer bindings; same `ocean` domain. */
     mouseMove?: MouseMoveInteractions;
+    /** The environment terrain's config, when it is on: the water reads the ground
+     *  under it for the shoreline (waves shoal, shallow colour, shore foam) and
+     *  marches the terrain's shadow. World host only. */
+    terrain?: TerrainConfig | null;
     /** Runs after the uniforms are pushed, with the live overrides already
      *  merged in — where a host does its own per-frame work (snapping the
      *  clipmap to the camera, say) with the config it is actually rendering. */
@@ -38,6 +42,6 @@ export interface OceanMaterialHandle {
      *  handle a controller reaches through `findById`. */
     rootRef: React.RefObject<THREE.Group | null>;
 }
-export declare function useOceanMaterial({ id, config, quality, skySettings, timeSettings, sunIntensity, animations, mouseMove, onFrame, }: UseOceanMaterialOptions): OceanMaterialHandle;
+export declare function useOceanMaterial({ id, config, quality, skySettings, timeSettings, sunIntensity, animations, mouseMove, terrain, onFrame, }: UseOceanMaterialOptions): OceanMaterialHandle;
 export default useOceanMaterial;
 //# sourceMappingURL=useOceanMaterial.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useOceanMaterial.d.ts","sourceRoot":"","sources":["../../src/hooks/useOceanMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,EAAY,KAAK,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAGvE,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAU7E,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAStH;;;;;;;;;;;;GAYG;AAEH,MAAM,WAAW,uBAAuB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,EAAE,kBAAkB,CAAC;IAC5B,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,mEAAmE;IACnE,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,6CAA6C;IAC7C,SAAS,CAAC,EAAE,qBAAqB,CAAC;IAClC;;gFAE4E;IAC5E,OAAO,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,kBAAkB,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;CACtF;AAED,MAAM,WAAW,mBAAmB;IAChC,QAAQ,EAAE,oBAAoB,CAAC;IAC/B;0DACsD;IACtD,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC;CAChD;AAED,wBAAgB,gBAAgB,CAAC,EAC7B,EAAE,EACF,MAAM,EACN,OAAO,EACP,WAAW,EACX,YAAY,EACZ,YAAgB,EAChB,UAAU,EACV,SAAS,EACT,OAAO,GACV,EAAE,uBAAuB,GAAG,mBAAmB,CAuG/C;AAED,eAAe,gBAAgB,CAAC"}
+{"version":3,"file":"useOceanMaterial.d.ts","sourceRoot":"","sources":["../../src/hooks/useOceanMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,EAAY,KAAK,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAGvE,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAU7E,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AASrI;;;;;;;;;;;;GAYG;AAEH,MAAM,WAAW,uBAAuB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,EAAE,kBAAkB,CAAC;IAC5B,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,mEAAmE;IACnE,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,6CAA6C;IAC7C,SAAS,CAAC,EAAE,qBAAqB,CAAC;IAClC;;yDAEqD;IACrD,OAAO,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IAC/B;;gFAE4E;IAC5E,OAAO,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,kBAAkB,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;CACtF;AAED,MAAM,WAAW,mBAAmB;IAChC,QAAQ,EAAE,oBAAoB,CAAC;IAC/B;0DACsD;IACtD,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC;CAChD;AAED,wBAAgB,gBAAgB,CAAC,EAC7B,EAAE,EACF,MAAM,EACN,OAAO,EACP,WAAW,EACX,YAAY,EACZ,YAAgB,EAChB,UAAU,EACV,SAAS,EACT,OAAO,EACP,OAAO,GACV,EAAE,uBAAuB,GAAG,mBAAmB,CA0H/C;AAED,eAAe,gBAAgB,CAAC"}

package/dist/hooks/useOceanMaterial.js

@@ -5,7 +5,7 @@ import { useCloudSun } from './useCloudSun.js';
 import { OCEAN_LIVE_KEY } from './useOceanLive.js';
 import { OceanSurfaceMaterial } from '../shaders/ocean/OceanSurfaceMaterial.js';
 import { applySunUniforms } from '../utils/cloudUniforms.js';
-import { applyTerrainAmbient } from '../utils/terrainUniforms.js';
+import { applyTerrainAmbient, applyTerrainFieldUniforms } from '../utils/terrainUniforms.js';
 import { applyOceanUniforms } from '../utils/oceanUniforms.js';
 import { resolveMoon, moonlightFactor, MOON_LIGHT_COLOR } from '../utils/skyMoon.js';
 /** Moonlight on the water relative to the sun's (sunIntensity 1). The key light
@@ -14,7 +14,7 @@ import { resolveMoon, moonlightFactor, MOON_LIGHT_COLOR } from '../utils/skyMoon
 const MOON_WATER_STRENGTH = 0.15;
 import { getAnimatableProperties } from '@3driseai/3drise-core';
 import { applyConfigKeyframeAnimations, applyConfigMouseMove, } from '../utils/configAnimations.js';
-export function useOceanMaterial({ id, config, quality, skySettings, timeSettings, sunIntensity = 1, animations, mouseMove, onFrame, }) {
+export function useOceanMaterial({ id, config, quality, skySettings, timeSettings, sunIntensity = 1, animations, mouseMove, terrain, onFrame, }) {
     const { state: sun, update: updateSun } = useCloudSun({ skySettings, timeSettings });
     const moon = useRef({ direction: new THREE.Vector3(), illumination: 0 });
     const material = useMemo(() => new OceanSurfaceMaterial(), []);
@@ -82,6 +82,26 @@ export function useOceanMaterial({ id, config, quality, skySettings, timeSetting
         const cfg = { ...config, ...o, ...liveConfig.current };
         const qual = { ...quality, ...liveQuality.current };
         applyOceanUniforms(shader, cfg, qual);
+        // The shoreline. OCEAN_TERRAIN compiles the terrain field into the water;
+        // it flips only when terrain is switched on or off, never per frame.
+        const withTerrain = !!terrain?.enabled;
+        const defines = (shader.defines ??= {});
+        if (withTerrain !== ('OCEAN_TERRAIN' in defines)) {
+            if (withTerrain)
+                defines.OCEAN_TERRAIN = '';
+            else
+                delete defines.OCEAN_TERRAIN;
+            shader.needsUpdate = true;
+        }
+        const u = shader.uniforms;
+        u.u_shoreDepth.value = Math.max(cfg.shoreDepth ?? 3, 0.05);
+        u.u_shoreFoam.value = cfg.shoreFoam ?? 1;
+        if (withTerrain && terrain) {
+            applyTerrainFieldUniforms(shader, terrain);
+            u.u_sunShadow.value = cfg.terrainShadow ?? 1;
+            u.u_shadowSteps.value = Math.round(qual.terrainShadowSteps ?? 10);
+            u.u_shadowDistance.value = Math.max(qual.terrainShadowDistance ?? 4000, 1);
+        }
         shader.uniforms.u_time.value = state.clock.getElapsedTime();
         // World size of one pixel at unit distance. The detail fade and the
         // specular filtering are both screen-space decisions — whether a ripple

package/dist/hooks/useOrbitTargetFollow.d.ts

@@ -0,0 +1,10 @@
+import type { ControlsConfig, OrbitTargetObject } from '@3driseai/3drise-core';
+export declare function useOrbitTargetFollow(controlsRef: React.MutableRefObject<any>, targetObject: OrbitTargetObject | null | undefined, followObject: OrbitTargetObject | null | undefined, 
+/** True while something else owns the camera position (a camera animation). */
+isCameraBusy: () => boolean, 
+/** False when the orbit controls are switched off: the camera keeps its own orientation. */
+orbiting: boolean, 
+/** The authored controls — their limits are what the widening falls back to. */
+authored: ControlsConfig): void;
+export default useOrbitTargetFollow;
+//# sourceMappingURL=useOrbitTargetFollow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useOrbitTargetFollow.d.ts","sourceRoot":"","sources":["../../src/hooks/useOrbitTargetFollow.ts"],"names":[],"mappings":"AA+CA,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAsE/E,wBAAgB,oBAAoB,CAChC,WAAW,EAAE,KAAK,CAAC,gBAAgB,CAAC,GAAG,CAAC,EACxC,YAAY,EAAE,iBAAiB,GAAG,IAAI,GAAG,SAAS,EAClD,YAAY,EAAE,iBAAiB,GAAG,IAAI,GAAG,SAAS;AAClD,+EAA+E;AAC/E,YAAY,EAAE,MAAM,OAAO;AAC3B,4FAA4F;AAC5F,QAAQ,EAAE,OAAO;AACjB,gFAAgF;AAChF,QAAQ,EAAE,cAAc,QAqE3B;AAED,eAAe,oBAAoB,CAAC"}

package/dist/hooks/useOrbitTargetFollow.js

@@ -0,0 +1,194 @@
+// =============================================================================
+// useOrbitTargetFollow — the camera tracks scene objects
+// =============================================================================
+//
+// Two independent settings on `controls`:
+//
+//   targetObject   ORBIT TARGET — the orbit point (what the camera looks at) sits on the
+//                  object's centre every frame. The camera position is not touched; it
+//                  only turns to keep looking at the object.
+//   followObject   FOLLOW — the camera travels with the object: it (and the orbit point)
+//                  moves by exactly as much as the object moved, so the distance and
+//                  angle stay the same. Translation only — the object spinning in place
+//                  does not swing the camera around.
+//
+// Both together: the camera rides along with one object and looks at another (or the
+// same one).
+//
+// Smoothness — why this runs in scene.onBeforeRender and not in useFrame:
+// clips, actions, effects and physics move objects in useFrame callbacks, some of them
+// after this component's. Reading the object in useFrame would see last frame's position
+// half the time, so the camera would trail the object by a frame and stutter. Three calls
+// scene.onBeforeRender inside gl.render, after it has updated every matrixWorld and before
+// it builds the view — so here every object is exactly where it is drawn this frame. We
+// move the camera, re-aim it and update its matrix ourselves, and this frame's image is
+// already right.
+//
+// The object's centre is its bounding-box centre, measured once in the object's own space
+// when it is found and then carried by its matrixWorld every frame — exact under animation
+// and cheap (no per-frame box).
+//
+// Limits vs a moving target: OrbitControls clamps the camera's distance and angles to
+// the target on every update. When the TARGET moves (the plane climbs above a camera
+// limited to 88°), that clamp would drag the camera along — the camera must not move.
+// So while looking at an object, the limits are widened each frame just enough to hold
+// where the camera is now: the object can take the view outside the authored range,
+// the user still can't rotate / zoom further out of it, and moving back in tightens
+// them to the authored values again. The authored values come from `controls`.
+//
+// Height limits (controls.minHeight / maxHeight) are world Y, not relative to the target,
+// and are applied after everything else in the frame.
+//
+// While a camera animation (path / gsap) runs, follow does not move the camera — the
+// animation owns its position; the follow just keeps counting, so nothing jumps after.
+//
+import { useEffect, useRef } from 'react';
+import { useFrame, useThree } from '@react-three/fiber';
+import { Box3, Vector3 } from 'three';
+import { orbitAngleLimits } from '@3driseai/3drise-core';
+import { findById } from '../utils/sceneQuery.js';
+const RESOLVE_EVERY = 30; // frames between lookups while the object is missing
+const _box = new Box3();
+const _p = new Vector3();
+const _d = new Vector3();
+const _off = new Vector3();
+const keyOf = (t) => (t?.id ? `${t.id}|${t.node ?? ''}` : '');
+/** Finds one object and gives its centre in world space, every frame, without lag. */
+class Tracker {
+    key = '';
+    obj = null;
+    local = new Vector3(); // bounding-box centre in the object's own space
+    missingSince = -1e9;
+    locked = false; // first point taken
+    last = new Vector3(); // point at the previous frame
+    sync(t) {
+        const key = keyOf(t);
+        if (key === this.key)
+            return;
+        this.key = key;
+        this.obj = null;
+        this.missingSince = -1e9;
+        this.locked = false;
+    }
+    /** Writes the object's centre into `out`; false while the object is not there. */
+    point(t, frame, out) {
+        if (!this.obj || !this.obj.parent) {
+            if (frame - this.missingSince < RESOLVE_EVERY)
+                return false;
+            const root = findById(t.id);
+            const obj = root && t.node ? root.getObjectByName(t.node) ?? null : root;
+            if (!obj) {
+                this.missingSince = frame;
+                this.obj = null;
+                return false;
+            }
+            this.obj = obj;
+            this.locked = false;
+            obj.updateWorldMatrix(true, true);
+            _box.setFromObject(obj);
+            if (_box.isEmpty())
+                this.local.set(0, 0, 0);
+            else
+                obj.worldToLocal(_box.getCenter(this.local));
+        }
+        out.copy(this.local).applyMatrix4(this.obj.matrixWorld);
+        return true;
+    }
+}
+/** Authored limits, widened to include the camera's current distance and angles to the target. */
+function widenLimits(controls, cameraPos, auth) {
+    _off.copy(cameraPos).sub(controls.target);
+    const r = _off.length();
+    if (r < 1e-6)
+        return;
+    const phi = Math.acos(Math.min(1, Math.max(-1, _off.y / r)));
+    const theta = Math.atan2(_off.x, _off.z);
+    const lim = orbitAngleLimits(auth);
+    const minD = auth.minDistance ?? 0, maxD = auth.maxDistance ?? Infinity;
+    controls.minDistance = Math.min(minD, r);
+    controls.maxDistance = Math.max(maxD, r);
+    controls.minPolarAngle = Math.min(lim.minPolarAngle, phi);
+    controls.maxPolarAngle = Math.max(lim.maxPolarAngle, phi);
+    // Azimuth: only when it is limited (the full circle needs nothing).
+    if (lim.maxAzimuthAngle - lim.minAzimuthAngle < Math.PI * 2 - 1e-6) {
+        controls.minAzimuthAngle = Math.min(lim.minAzimuthAngle, theta);
+        controls.maxAzimuthAngle = Math.max(lim.maxAzimuthAngle, theta);
+    }
+}
+export function useOrbitTargetFollow(controlsRef, targetObject, followObject, 
+/** True while something else owns the camera position (a camera animation). */
+isCameraBusy, 
+/** False when the orbit controls are switched off: the camera keeps its own orientation. */
+orbiting, 
+/** The authored controls — their limits are what the widening falls back to. */
+authored) {
+    const { scene, camera } = useThree();
+    const live = useRef({ targetObject, followObject, isCameraBusy, orbiting, authored });
+    live.current = { targetObject, followObject, isCameraBusy, orbiting, authored };
+    const frame = useRef(0);
+    const done = useRef(-1);
+    const aim = useRef(new Tracker());
+    const follow = useRef(new Tracker());
+    // A frame counter, so the render hook runs once per frame even if the scene is
+    // rendered more than once (reflections, previews).
+    useFrame(() => { frame.current++; });
+    useEffect(() => {
+        const prev = scene.onBeforeRender;
+        scene.onBeforeRender = function (...args) {
+            prev.apply(this, args);
+            const cam = args[2];
+            if (cam !== camera || done.current === frame.current)
+                return;
+            done.current = frame.current;
+            const controls = controlsRef.current;
+            const { targetObject: tObj, followObject: fObj, isCameraBusy: busy, orbiting: orb, authored: auth } = live.current;
+            const f = follow.current, a = aim.current;
+            f.sync(fObj);
+            a.sync(tObj);
+            let moved = false;
+            // FOLLOW: move the camera and the orbit point with the object.
+            if (fObj && f.point(fObj, frame.current, _p)) {
+                if (!f.locked) {
+                    f.last.copy(_p);
+                    f.locked = true;
+                }
+                _d.copy(_p).sub(f.last);
+                f.last.copy(_p);
+                if (_d.lengthSq() > 0 && !busy()) {
+                    camera.position.add(_d);
+                    if (controls)
+                        controls.target.add(_d);
+                    moved = true;
+                }
+            }
+            // ORBIT TARGET: look at the object; the camera stays where it is.
+            if (tObj && controls && a.point(tObj, frame.current, _p)) {
+                if (!a.locked || !controls.target.equals(_p)) {
+                    controls.target.copy(_p);
+                    if (orb)
+                        camera.lookAt(_p);
+                    a.locked = true;
+                    moved = true;
+                }
+            }
+            // HEIGHT LIMITS (world Y): last, so nothing — user, target, follow, a clip — ends
+            // the frame under the floor or over the ceiling. The camera keeps facing the target.
+            const minH = typeof auth.minHeight === 'number' ? auth.minHeight : -Infinity;
+            const maxH = typeof auth.maxHeight === 'number' ? auth.maxHeight : Infinity;
+            const y = Math.min(maxH, Math.max(minH, camera.position.y));
+            if (y !== camera.position.y) {
+                camera.position.y = y;
+                if (orb && controls)
+                    camera.lookAt(controls.target);
+                moved = true;
+            }
+            if (moved)
+                camera.updateMatrixWorld();
+            // Limits hold the camera where the moving target left it (see the header).
+            if (tObj && controls && a.locked)
+                widenLimits(controls, camera.position, auth);
+        };
+        return () => { scene.onBeforeRender = prev; };
+    }, [scene, camera, controlsRef]);
+}
+export default useOrbitTargetFollow;

package/dist/index.d.ts

@@ -25,6 +25,7 @@ export type { Object3DRefLike, Object3DSource } from './utils/resolveObject3D';
 export { applyTerrainUniforms, applyTerrainTextures } from './utils/terrainUniforms';
 export { useTerrainTextures } from './hooks/useTerrainTextures';
 export { terrainHeightAt } from './utils/terrainHeight';
+export { isMobileDevice } from './utils/deviceTier';
 export { setTerrainTextureResolver, resolveTerrainTextureSets, useTerrainTextureResolverVersion, type TerrainTextureResolver } from './utils/terrainTextureResolver';
 export { landHeightAt, landWorldHeightAt, landSeedOffset, landToTerrainConfig, LAND_SEGMENTS } from './utils/landPatch';
 export type { TerrainTextureState } from './hooks/useTerrainTextures';

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -26,6 +26,7 @@ export { resolveObject3D } from './utils/resolveObject3D.js';
 export { applyTerrainUniforms, applyTerrainTextures } from './utils/terrainUniforms.js';
 export { useTerrainTextures } from './hooks/useTerrainTextures.js';
 export { terrainHeightAt } from './utils/terrainHeight.js';
+export { isMobileDevice } from './utils/deviceTier.js';
 export { setTerrainTextureResolver, resolveTerrainTextureSets, useTerrainTextureResolverVersion } from './utils/terrainTextureResolver.js';
 export { landHeightAt, landWorldHeightAt, landSeedOffset, landToTerrainConfig, LAND_SEGMENTS } from './utils/landPatch.js';
 export { applyLandscapeMaps, applyLandscapeUniforms } from './utils/landscapeUniforms.js';

package/dist/shaders/glsl/terrainCore.glsl.d.ts

@@ -26,8 +26,14 @@
  *    per octave, nine octaves, several evaluations per pixel puts it into the
  *    billions of transcendentals per frame.
  */
-/** Every uniform the height field and the shading read. */
-export declare const terrainUniforms = "\nuniform int   u_terrainType;\n\nuniform float u_elevation;\nuniform float u_seaLevel;\nuniform float u_baseScale;      // 1 / featureSize\nuniform int   u_octaves;\nuniform float u_lacunarity;\nuniform float u_gain;\nuniform float u_ridge;\nuniform float u_warpStrength;\nuniform float u_warpScale;\nuniform float u_erosion;\nuniform float u_terraces;\nuniform float u_terraceSharp;\nuniform vec2  u_bearingDir;\nuniform float u_duneFreq;       // 2pi / duneWavelength\nuniform float u_duneAsym;\nuniform float u_plateau;\nuniform float u_valleyDepth;\nuniform float u_valleyWidth;\n\nuniform float u_cellSize;\nuniform float u_curvature;\n\n// surface\nuniform vec3  u_lowColor, u_midColor, u_rockColor, u_peakColor;\nuniform float u_slopeRockStart, u_slopeRockEnd;\nuniform float u_peakLevel, u_peakBlend, u_peakSlopeFalloff;\nuniform float u_macroVariation, u_macroScale;\nuniform float u_detailStrength, u_detailScale, u_detailFade;\nuniform float u_roughness, u_specular;\n\n// lighting. u_skyAmbient and u_groundAmbient come from useCloudSun through\n// applySunUniforms - the same objects that light the clouds. They are constant\n// across the frame, so computing them on the CPU rather than calling skyRadiance\n// per pixel removes an acos, a pow and three exps from every fragment.\nuniform vec3  u_skyAmbient;\nuniform vec3  u_groundAmbient;\nuniform float u_ambient, u_bounce, u_sunShadow, u_shadowSoftness;\nuniform float u_shadowDistance;\nuniform float u_fogDensity, u_exposure;\nuniform int   u_shadowSteps;\n\n// Ground textures. The far colour per layer is always set: the flat colour for an\n// untextured layer, the texture's own mean x tint for a textured one, so the\n// near-to-far fade has no colour jump.\nuniform vec3  u_tFar[4];\n#ifdef TERRAIN_TEXTURED\nuniform sampler2DArray u_tColor;    // albedo, sRGB\nuniform sampler2DArray u_tNormal;   // rgb tangent normal (GL), a surface height\nuniform sampler2DArray u_tOrm;      // r ambient occlusion, g roughness\nuniform vec4  u_tLayer[4];          // 1/tileSize, normalStrength, textured 0|1, -\nuniform vec3  u_tTint[4];           // layer colour / texture mean: the texture averages to the layer colour\nuniform vec4  u_tMeanC[4];          // per-array layer means, for the stochastic blend\nuniform vec4  u_tMeanN[4];\nuniform vec4  u_tMeanO[4];\nuniform float u_tDistance;\nuniform float u_tHeightBlend;\n#endif\n\n// A land object: a bounded patch of this field, placed by its object's transform.\n// Its \"terrain space\" is metres from the object's origin, unrotated, plus a seed\n// offset; height is above the object's base. See TerrainMaterial's patch vertex.\n#ifdef TERRAIN_PATCH\nuniform vec2  u_patchSize;      // footprint in metres (object scale x / z)\nuniform vec2  u_patchOffset;    // terrain-space centre: the seed's offset into the field\nuniform float u_edgeWidth;      // metres over which the land eases down to its base\nuniform vec3  u_camTerrain;     // the camera, in terrain space\nuniform float u_scaleY;         // object scale y: terrain metres = local y x this\nuniform float u_patchCell;      // metres per grid cell\n#define TERRAIN_CAM u_camTerrain\n#else\n#define TERRAIN_CAM cameraPosition\n#endif\n";
+/**
+ * The uniforms the height field and the sun-shadow march read — and nothing else,
+ * so another material (the ocean) can include the field without redeclaring its
+ * own u_curvature, u_exposure, u_roughness… GLSL refuses a uniform declared twice.
+ */
+export declare const terrainFormUniforms = "\nuniform int   u_terrainType;\n\nuniform float u_elevation;\nuniform float u_seaLevel;\nuniform float u_baseScale;      // 1 / featureSize\nuniform int   u_octaves;\nuniform float u_lacunarity;\nuniform float u_gain;\nuniform float u_ridge;\nuniform float u_warpStrength;\nuniform float u_warpScale;\nuniform float u_erosion;\nuniform float u_terraces;\nuniform float u_terraceSharp;\nuniform vec2  u_bearingDir;\nuniform float u_duneFreq;       // 2pi / duneWavelength\nuniform float u_duneAsym;\nuniform float u_plateau;\nuniform float u_valleyDepth;\nuniform float u_valleyWidth;\n\n// The analytic sun-shadow march (terrainShadow) - shared with the ocean, which\n// marches the same field to put headland shadows on the water.\nuniform float u_sunShadow, u_shadowSoftness;\nuniform float u_shadowDistance;\nuniform int   u_shadowSteps;\n\n// A land object: a bounded patch of this field, placed by its object's transform.\n// Its \"terrain space\" is metres from the object's origin, unrotated, plus a seed\n// offset; height is above the object's base. See TerrainMaterial's patch vertex.\n#ifdef TERRAIN_PATCH\nuniform vec2  u_patchSize;      // footprint in metres (object scale x / z)\nuniform vec2  u_patchOffset;    // terrain-space centre: the seed's offset into the field\nuniform float u_edgeWidth;      // metres over which the land eases down to its base\nuniform vec3  u_camTerrain;     // the camera, in terrain space\nuniform float u_scaleY;         // object scale y: terrain metres = local y x this\nuniform float u_patchCell;      // metres per grid cell\n#define TERRAIN_CAM u_camTerrain\n#else\n#define TERRAIN_CAM cameraPosition\n#endif\n";
+/** The terrain surface's own uniforms: shading, lighting, textures. */
+export declare const terrainSurfaceUniforms = "\nuniform float u_cellSize;\nuniform float u_curvature;\n\n// surface\nuniform vec3  u_lowColor, u_midColor, u_rockColor, u_peakColor;\nuniform float u_slopeRockStart, u_slopeRockEnd;\nuniform float u_peakLevel, u_peakBlend, u_peakSlopeFalloff;\nuniform float u_macroVariation, u_macroScale;\nuniform float u_detailStrength, u_detailScale, u_detailFade;\nuniform float u_roughness, u_specular;\n\n// lighting. u_skyAmbient and u_groundAmbient come from useCloudSun through\n// applySunUniforms - the same objects that light the clouds. They are constant\n// across the frame, so computing them on the CPU rather than calling skyRadiance\n// per pixel removes an acos, a pow and three exps from every fragment.\nuniform vec3  u_skyAmbient;\nuniform vec3  u_groundAmbient;\nuniform float u_ambient, u_bounce;\nuniform float u_fogDensity, u_exposure;\n\n// Ground textures. The far colour per layer is always set: the flat colour for an\n// untextured layer, the texture's own mean x tint for a textured one, so the\n// near-to-far fade has no colour jump.\nuniform vec3  u_tFar[4];\n#ifdef TERRAIN_TEXTURED\nuniform sampler2DArray u_tColor;    // albedo, sRGB\nuniform sampler2DArray u_tNormal;   // rgb tangent normal (GL), a surface height\nuniform sampler2DArray u_tOrm;      // r ambient occlusion, g roughness\nuniform vec4  u_tLayer[4];          // 1/tileSize, normalStrength, textured 0|1, -\nuniform vec3  u_tTint[4];           // layer colour / texture mean: the texture averages to the layer colour\nuniform vec4  u_tMeanC[4];          // per-array layer means, for the stochastic blend\nuniform vec4  u_tMeanN[4];\nuniform vec4  u_tMeanO[4];\nuniform float u_tDistance;\nuniform float u_tHeightBlend;\n#endif\n\n";
 /**
  * Gradient noise with an analytic derivative.
  *
@@ -70,7 +76,8 @@ export declare const terrainHeight = "\n#define TERRAIN_MOUNTAINS 0\n#define TER
  * The terminator itself stays per-pixel: `terrainLight` takes N·L from the
  * fragment's own normal, so only the CAST shadow is interpolated.
  */
-export declare const terrainShading = "\n/** 1 lit, 0 shadowed, soft in between. */\nfloat terrainSunShadow(vec3 p, vec3 n, float lodCell, int steps){\n  if (steps < 1 || u_sunShadow <= 0.0) return 1.0;\n  // Below the horizon there is nothing to shadow; the march would also walk\n  // downhill forever.\n  if (u_sunDir.y <= 0.015) return 1.0;\n  // A surface facing away from the sun is shadowed by definition, and marching\n  // from it only finds the ground it is already part of.\n  if (dot(n, u_sunDir) <= 0.0) return 0.0;\n\n  // Lift off the surface before starting, or every sample on a steep face - a\n  // terrace riser above all - reads its own ground as an occluder and the whole\n  // wall goes black in a grid of triangles. Start ON the offset surface and\n  // compare raw heights; subtracting the bias from the height difference instead\n  // makes the first sample fail on any slope tilted a few degrees from the sun.\n  float bias = max(lodCell, u_elevation * 0.003);\n  vec3 origin = p + n * bias;\n\n  float shadowLod = (1.0 / max(u_baseScale, 1e-9)) * 0.008;\n\n  float res = 1.0;\n  float t = bias * 3.0;\n  float maxT = (u_elevation * 2.5) / max(u_sunDir.y, 0.05);\n\n  for (int i = 0; i < 48; i++){\n    if (i >= steps || t > maxT) break;\n    vec3 sp = origin + u_sunDir * t;\n    // The occluder is sampled at the SHADING lod, coarsening with distance -\n    // never at a fixed coarse lod. Testing a fine surface point against a coarse\n    // height field puts the whole valley floor in shadow, because the coarse\n    // field sits above the fine one wherever the fine one has been cut down.\n    // Sampled MUCH coarser than the surface being shaded. A shadow does not need\n    // nine octaves: what casts a visible shadow is the landform, and marching the\n    // fine field costs the same nine octaves per step for detail that is below a\n    // pixel by the time it lands. Floored against the landform's own size, so the\n    // march runs about five octaves instead of nine wherever it starts.\n    float h = terrainOccluderAt(sp.xz, max(max(lodCell * 2.0, t * 0.06), shadowLod));\n    float diff = sp.y - h;\n    res = min(res, u_shadowSoftness * diff / t);\n    if (res <= 0.0) return 0.0;\n    // Geometric growth: near the surface the occluder is metres away, at the end\n    // of the march it is kilometres, and a linear step wastes every sample at one\n    // end or the other. 1.7 rather than 1.42 so twelve steps actually reach maxT -\n    // at 1.42 the march ran out around 700 m and long shadows at low sun simply\n    // did not exist, which is a quality bug that happened to look like a cheap one.\n    t = t * 1.7 + bias;\n  }\n  return saturate(res);\n}\n\n/**\n * The shadow, faded out with distance and given a step budget that falls with it.\n *\n * The march is the most expensive thing left in the renderer, and past a few\n * kilometres it is buying nothing: aerial perspective has already washed most of\n * the contrast out of the ground, and a ridge shadow out there is a couple of\n * pixels wide. Skipping it entirely beyond u_shadowDistance drops the outer\n * clipmap rings - which are two thirds of the vertices - out of the march\n * completely, and the rings in between run four steps instead of fourteen.\n *\n * Faded rather than cut, or the cut-off would draw a visible circle on the ground.\n */\nfloat terrainShadowAt(vec3 p, vec3 n, float lodCell, float dist){\n  float fade = 1.0 - saturate(dist / max(u_shadowDistance, 1.0));\n  if (fade <= 0.002) return 1.0;\n  int steps = int(mix(4.0, float(u_shadowSteps), fade));\n  return mix(1.0, terrainSunShadow(p, n, lodCell, steps), fade);\n}\n\n/**\n * Albedo.\n *\n * Rock is splatted by SLOPE, everything else by height. That ordering is the\n * whole trick: it means a cliff is bare rock whether it is in a valley or on a\n * summit, which is how real ground works and why height-only splatting always\n * reads as a painted contour map.\n */\n/**\n * Splat weights for the four layers, in layer order: low, mid, rock, peak.\n * Exactly the old colour mixes written as weights \u2014 low/mid by height, the peak\n * held back on steep ground (snow does not sit on a vertical face), rock by slope\n * and applied last, which is why a cliff reads as a cliff at any altitude.\n */\nvec4 terrainLayerWeights(float h01, float slope){\n  float m = smoothstep(0.05, 0.55, h01);\n  float p = saturate(smoothstep(u_peakLevel, u_peakLevel + u_peakBlend, h01 - slope * u_peakSlopeFalloff * 0.6));\n  float r = smoothstep(u_slopeRockStart, u_slopeRockEnd, slope);\n  return vec4((1.0 - m) * (1.0 - p) * (1.0 - r), m * (1.0 - p) * (1.0 - r), r, p * (1.0 - r));\n}\n\n/** Large-scale variation. Without it a splat layer is one flat colour across\n *  kilometres, and the eye reads flat colour as untextured rather than as ground. */\nfloat terrainMacro(vec3 wp){\n  float macro = tNoise(wp.xz * u_macroScale) * 0.5 + 0.5;\n  return 1.0 + u_macroVariation * (macro - 0.5) * 2.0;\n}\n\n/** The far-field albedo: each layer's far colour by its weight. */\nvec3 terrainAlbedo(vec3 wp, vec4 w){\n  vec3 col = u_tFar[0] * w.x + u_tFar[1] * w.y + u_tFar[2] * w.z + u_tFar[3] * w.w;\n  return col * terrainMacro(wp);\n}\n\n/** High-frequency bump, well below the mesh resolution, faded out with distance\n *  so it never becomes a field of crawling pixels on the horizon. One evaluation:\n *  the noise carries its own derivative, so the three taps a finite difference\n *  would need are not. */\nvec3 terrainDetailNormal(vec3 n, vec3 wp, float dist){\n  float fade = 1.0 - saturate(dist * u_detailFade);\n  float amt = u_detailStrength * fade * fade;\n  if (amt <= 0.001) return n;\n  vec3 d = tNoised(wp.xz * u_detailScale);\n  return normalize(n + vec3(-d.y, 0.0, -d.z) * amt * 0.9);\n}\n\n/**\n * Direct sun, sky fill and ground bounce.\n *\n * Sun irradiance is in the units skyRadiance returns, calibrated against it rather\n * than guessed: a 0.3-albedo surface in full sun lands a little below the sky at\n * the horizon, which is the relationship the eye reads as daylight. Set it to the\n * clouds' SUN_RADIANCE and every ground surface clips to white.\n */\nconst float TERRAIN_SUN = 2.2;\n\nvec3 terrainLight(vec3 albedo, vec3 n, vec3 viewDir, float shadow, float sceneShadow, float roughness, float ao){\n  float ndl = max(dot(n, u_sunDir), 0.0);\n  // Wrap the terminator slightly: bare ground is not a Lambertian sphere, and a\n  // hard terminator across a whole hillside reads as CG.\n  float wrap = max((dot(n, u_sunDir) + 0.2) / 1.2, 0.0);\n  float diff = mix(ndl, wrap, 0.4);\n\n  vec3 sun = u_sunColor * u_sunIntensity * TERRAIN_SUN * diff * shadow * sceneShadow;\n\n  // Sky fill from the same atmosphere the sky is drawn with, so it darkens and\n  // warms with the sun instead of freezing at a constant blue - but supplied as a\n  // uniform rather than evaluated here, since it is the same for every pixel.\n  // Whitened a little: a single-scattering zenith colour is very saturated, and\n  // at full saturation every shadowed slope - snow above all - comes out cyan.\n  vec3 fill = mix(u_skyAmbient, vec3(dot(u_skyAmbient, vec3(0.3333))), 0.4);\n  vec3 ambient = fill * (0.5 + 0.5 * n.y) * u_ambient * 1.05;\n\n  // Ground bounce, tinted by whatever the ground is. Keeps overhangs and shaded\n  // faces off pure black without flattening them the way raising ambient does.\n  vec3 bounce = u_tFar[0] * u_groundAmbient * (0.5 - 0.5 * n.y) * u_bounce * 1.3;\n\n  // Occlusion is a property of the small-scale surface, so it darkens the light\n  // that arrives from everywhere \u2014 sky fill and bounce \u2014 and leaves the sun alone.\n  vec3 col = albedo * (sun + (ambient + bounce) * ao);\n\n  // A single specular lobe. Rock barely needs it; wet sand and snow at low sun\n  // are almost entirely this.\n  if (u_specular > 0.0){\n    vec3 hv = normalize(u_sunDir - viewDir);\n    float a = max(roughness * roughness, 0.002);\n    float nh = max(dot(n, hv), 0.0);\n    float dd = nh * nh * (a - 1.0) + 1.0;\n    float d = a / max(3.14159265 * dd * dd, 1e-4);\n    col += u_sunColor * u_sunIntensity * TERRAIN_SUN * d * u_specular * shadow * sceneShadow * ndl;\n  }\n\n  return col;\n}\n\n/**\n * Aerial perspective.\n *\n * The single most important line in this shader for the horizon. Ground fades\n * into the exact sky colour it is seen through, at a rate that thins with\n * altitude because the atmosphere does \u2014 so a distant ridge sits behind the haze\n * and a peak above it stands clear of it, which is what tells you the scene is\n * kilometres across rather than metres.\n *\n * The one remaining per-pixel skyRadiance call, and it has to be: the colour is\n * the sky in the view direction, which is different for every fragment.\n */\nvec3 terrainAerial(vec3 col, vec3 rd, float dist, float height){\n  float scaleHeight = exp(-max(height - u_seaLevel, 0.0) / 1400.0);\n  float f = 1.0 - exp(-dist * u_fogDensity * scaleHeight);\n  if (f < 0.002) return col;\n  return mix(col, skyRadiance(rd), saturate(f));\n}\n";
+export declare const terrainShadow = "\n/** 1 lit, 0 shadowed, soft in between. */\nfloat terrainSunShadow(vec3 p, vec3 n, float lodCell, int steps){\n  if (steps < 1 || u_sunShadow <= 0.0) return 1.0;\n  // Below the horizon there is nothing to shadow; the march would also walk\n  // downhill forever.\n  if (u_sunDir.y <= 0.015) return 1.0;\n  // A surface facing away from the sun is shadowed by definition, and marching\n  // from it only finds the ground it is already part of.\n  if (dot(n, u_sunDir) <= 0.0) return 0.0;\n\n  // Lift off the surface before starting, or every sample on a steep face - a\n  // terrace riser above all - reads its own ground as an occluder and the whole\n  // wall goes black in a grid of triangles. Start ON the offset surface and\n  // compare raw heights; subtracting the bias from the height difference instead\n  // makes the first sample fail on any slope tilted a few degrees from the sun.\n  float bias = max(lodCell, u_elevation * 0.003);\n  vec3 origin = p + n * bias;\n\n  float shadowLod = (1.0 / max(u_baseScale, 1e-9)) * 0.008;\n\n  float res = 1.0;\n  float t = bias * 3.0;\n  float maxT = (u_elevation * 2.5) / max(u_sunDir.y, 0.05);\n\n  for (int i = 0; i < 48; i++){\n    if (i >= steps || t > maxT) break;\n    vec3 sp = origin + u_sunDir * t;\n    // The occluder is sampled at the SHADING lod, coarsening with distance -\n    // never at a fixed coarse lod. Testing a fine surface point against a coarse\n    // height field puts the whole valley floor in shadow, because the coarse\n    // field sits above the fine one wherever the fine one has been cut down.\n    // Sampled MUCH coarser than the surface being shaded. A shadow does not need\n    // nine octaves: what casts a visible shadow is the landform, and marching the\n    // fine field costs the same nine octaves per step for detail that is below a\n    // pixel by the time it lands. Floored against the landform's own size, so the\n    // march runs about five octaves instead of nine wherever it starts.\n    float h = terrainOccluderAt(sp.xz, max(max(lodCell * 2.0, t * 0.06), shadowLod));\n    float diff = sp.y - h;\n    res = min(res, u_shadowSoftness * diff / t);\n    if (res <= 0.0) return 0.0;\n    // Geometric growth: near the surface the occluder is metres away, at the end\n    // of the march it is kilometres, and a linear step wastes every sample at one\n    // end or the other. 1.7 rather than 1.42 so twelve steps actually reach maxT -\n    // at 1.42 the march ran out around 700 m and long shadows at low sun simply\n    // did not exist, which is a quality bug that happened to look like a cheap one.\n    t = t * 1.7 + bias;\n  }\n  return saturate(res);\n}\n\n/**\n * The shadow, faded out with distance and given a step budget that falls with it.\n *\n * The march is the most expensive thing left in the renderer, and past a few\n * kilometres it is buying nothing: aerial perspective has already washed most of\n * the contrast out of the ground, and a ridge shadow out there is a couple of\n * pixels wide. Skipping it entirely beyond u_shadowDistance drops the outer\n * clipmap rings - which are two thirds of the vertices - out of the march\n * completely, and the rings in between run four steps instead of fourteen.\n *\n * Faded rather than cut, or the cut-off would draw a visible circle on the ground.\n */\nfloat terrainShadowAt(vec3 p, vec3 n, float lodCell, float dist){\n  float fade = 1.0 - saturate(dist / max(u_shadowDistance, 1.0));\n  if (fade <= 0.002) return 1.0;\n  int steps = int(mix(4.0, float(u_shadowSteps), fade));\n  return mix(1.0, terrainSunShadow(p, n, lodCell, steps), fade);\n}\n\n";
+export declare const terrainShading = "\n/**\n * Albedo.\n *\n * Rock is splatted by SLOPE, everything else by height. That ordering is the\n * whole trick: it means a cliff is bare rock whether it is in a valley or on a\n * summit, which is how real ground works and why height-only splatting always\n * reads as a painted contour map.\n */\n/**\n * Splat weights for the four layers, in layer order: low, mid, rock, peak.\n * Exactly the old colour mixes written as weights \u2014 low/mid by height, the peak\n * held back on steep ground (snow does not sit on a vertical face), rock by slope\n * and applied last, which is why a cliff reads as a cliff at any altitude.\n */\nvec4 terrainLayerWeights(float h01, float slope){\n  float m = smoothstep(0.05, 0.55, h01);\n  float p = saturate(smoothstep(u_peakLevel, u_peakLevel + u_peakBlend, h01 - slope * u_peakSlopeFalloff * 0.6));\n  float r = smoothstep(u_slopeRockStart, u_slopeRockEnd, slope);\n  return vec4((1.0 - m) * (1.0 - p) * (1.0 - r), m * (1.0 - p) * (1.0 - r), r, p * (1.0 - r));\n}\n\n/** Large-scale variation. Without it a splat layer is one flat colour across\n *  kilometres, and the eye reads flat colour as untextured rather than as ground. */\nfloat terrainMacro(vec3 wp){\n  float macro = tNoise(wp.xz * u_macroScale) * 0.5 + 0.5;\n  return 1.0 + u_macroVariation * (macro - 0.5) * 2.0;\n}\n\n/** The far-field albedo: each layer's far colour by its weight. */\nvec3 terrainAlbedo(vec3 wp, vec4 w){\n  vec3 col = u_tFar[0] * w.x + u_tFar[1] * w.y + u_tFar[2] * w.z + u_tFar[3] * w.w;\n  return col * terrainMacro(wp);\n}\n\n/** High-frequency bump, well below the mesh resolution, faded out with distance\n *  so it never becomes a field of crawling pixels on the horizon. One evaluation:\n *  the noise carries its own derivative, so the three taps a finite difference\n *  would need are not. */\nvec3 terrainDetailNormal(vec3 n, vec3 wp, float dist){\n  float fade = 1.0 - saturate(dist * u_detailFade);\n  float amt = u_detailStrength * fade * fade;\n  if (amt <= 0.001) return n;\n  vec3 d = tNoised(wp.xz * u_detailScale);\n  return normalize(n + vec3(-d.y, 0.0, -d.z) * amt * 0.9);\n}\n\n/**\n * Direct sun, sky fill and ground bounce.\n *\n * Sun irradiance is in the units skyRadiance returns, calibrated against it rather\n * than guessed: a 0.3-albedo surface in full sun lands a little below the sky at\n * the horizon, which is the relationship the eye reads as daylight. Set it to the\n * clouds' SUN_RADIANCE and every ground surface clips to white.\n */\nconst float TERRAIN_SUN = 2.2;\n\nvec3 terrainLight(vec3 albedo, vec3 n, vec3 viewDir, float shadow, float sceneShadow, float roughness, float ao){\n  float ndl = max(dot(n, u_sunDir), 0.0);\n  // Wrap the terminator slightly: bare ground is not a Lambertian sphere, and a\n  // hard terminator across a whole hillside reads as CG.\n  float wrap = max((dot(n, u_sunDir) + 0.2) / 1.2, 0.0);\n  float diff = mix(ndl, wrap, 0.4);\n\n  vec3 sun = u_sunColor * u_sunIntensity * TERRAIN_SUN * diff * shadow * sceneShadow;\n\n  // Sky fill from the same atmosphere the sky is drawn with, so it darkens and\n  // warms with the sun instead of freezing at a constant blue - but supplied as a\n  // uniform rather than evaluated here, since it is the same for every pixel.\n  // Whitened a little: a single-scattering zenith colour is very saturated, and\n  // at full saturation every shadowed slope - snow above all - comes out cyan.\n  vec3 fill = mix(u_skyAmbient, vec3(dot(u_skyAmbient, vec3(0.3333))), 0.4);\n  vec3 ambient = fill * (0.5 + 0.5 * n.y) * u_ambient * 1.05;\n\n  // Ground bounce, tinted by whatever the ground is. Keeps overhangs and shaded\n  // faces off pure black without flattening them the way raising ambient does.\n  vec3 bounce = u_tFar[0] * u_groundAmbient * (0.5 - 0.5 * n.y) * u_bounce * 1.3;\n\n  // Occlusion is a property of the small-scale surface, so it darkens the light\n  // that arrives from everywhere \u2014 sky fill and bounce \u2014 and leaves the sun alone.\n  vec3 col = albedo * (sun + (ambient + bounce) * ao);\n\n  // A single specular lobe. Rock barely needs it; wet sand and snow at low sun\n  // are almost entirely this.\n  if (u_specular > 0.0){\n    vec3 hv = normalize(u_sunDir - viewDir);\n    float a = max(roughness * roughness, 0.002);\n    float nh = max(dot(n, hv), 0.0);\n    float dd = nh * nh * (a - 1.0) + 1.0;\n    float d = a / max(3.14159265 * dd * dd, 1e-4);\n    col += u_sunColor * u_sunIntensity * TERRAIN_SUN * d * u_specular * shadow * sceneShadow * ndl;\n  }\n\n  return col;\n}\n\n/**\n * Aerial perspective.\n *\n * The single most important line in this shader for the horizon. Ground fades\n * into the exact sky colour it is seen through, at a rate that thins with\n * altitude because the atmosphere does \u2014 so a distant ridge sits behind the haze\n * and a peak above it stands clear of it, which is what tells you the scene is\n * kilometres across rather than metres.\n *\n * The one remaining per-pixel skyRadiance call, and it has to be: the colour is\n * the sky in the view direction, which is different for every fragment.\n */\nvec3 terrainAerial(vec3 col, vec3 rd, float dist, float height){\n  float scaleHeight = exp(-max(height - u_seaLevel, 0.0) / 1400.0);\n  float f = 1.0 - exp(-dist * u_fogDensity * scaleHeight);\n  if (f < 0.002) return col;\n  return mix(col, skyRadiance(rd), saturate(f));\n}\n";
 /**
  * The textured near field. Needs `surfaceSampling` (surfaceCore.glsl) before it.
  *
@@ -86,6 +93,14 @@ export declare const terrainShading = "\n/** 1 lit, 0 shadowed, soft in between.
 export declare const terrainTextured = "\n#ifdef TERRAIN_TEXTURED\nstruct TerrainGrads { vec2 topX; vec2 topY; vec2 sideXX; vec2 sideXY; vec2 sideZX; vec2 sideZY; };\n\n// The large-scale sample is the same texture, T_MACRO times bigger.\n#define T_MACRO 8.0\n\n/**\n * One layer's three arrays at one projection, at two scales.\n *\n * A ground scan is millimetres per texel: a gravel tile shows its pebbles for a\n * few metres and is a flat average colour from fifty. So past the point where a\n * pixel covers a fifth of a tile, the same texture is sampled again T_MACRO times\n * larger, and its pebbles become patches, its cracks become streaks \u2014 the set's\n * character survives out to hundreds of metres instead of dissolving into a flat\n * colour, and picking a different set is visible from where people actually look\n * at terrain. The switch is by pixel footprint, so it is the same at any tile\n * size and any camera height. Each scale is skipped when its weight is zero.\n */\nvoid terrainTap(int L, vec2 uv, vec2 dx, vec2 dy, out vec4 c, out vec4 nh, out vec4 o){\n  float layer = float(L);\n  float fp = max(length(dx), length(dy));\n  float m = smoothstep(0.04, 0.25, fp);\n  vec4 cd = vec4(0.0);\n  vec4 nd = vec4(0.0);\n  vec4 od = vec4(0.0);\n  vec4 cm = vec4(0.0);\n  vec4 nm = vec4(0.0);\n  vec4 om = vec4(0.0);\n  if (m < 0.999){\n    cd = sfSample(u_tColor,  uv, dx, dy, layer, u_tMeanC[L]);\n    nd = sfSample(u_tNormal, uv, dx, dy, layer, u_tMeanN[L]);\n    od = sfSample(u_tOrm,    uv, dx, dy, layer, u_tMeanO[L]);\n  }\n  if (m > 0.001){\n    vec2 mu = uv / T_MACRO;\n    vec2 mdx = dx / T_MACRO;\n    vec2 mdy = dy / T_MACRO;\n    cm = sfSample(u_tColor,  mu, mdx, mdy, layer, u_tMeanC[L]);\n    nm = sfSample(u_tNormal, mu, mdx, mdy, layer, u_tMeanN[L]);\n    om = sfSample(u_tOrm,    mu, mdx, mdy, layer, u_tMeanO[L]);\n    // No height blending at the large scale. A height map blown up 8x has\n    // tens-of-metres blobs, and blending layers along those contours paints\n    // the ground in camouflage. Mid height = an ordinary cross-fade.\n    nm.a = 0.5;\n  }\n  c  = mix(cd, cm, m);\n  nh = mix(nd, nm, m);\n  o  = mix(od, om, m);\n}\n\n/** One layer: albedo (tinted), an unnormalised world normal, surface height,\n *  roughness and occlusion. An untextured layer returns its flat colour. */\nvoid terrainLayerSample(int L, vec3 wp, vec3 n, TerrainGrads g,\n                        out vec3 col, out vec3 wn, out float h, out float rough, out float ao){\n  col = u_tFar[L];\n  wn = n;\n  h = 0.5;\n  rough = u_roughness;\n  ao = 1.0;\n  if (u_tLayer[L].z > 0.5){\n    float inv = u_tLayer[L].x;\n    float ns = u_tLayer[L].y;\n    vec4 c = vec4(0.0);\n    vec4 nh = vec4(0.0);\n    vec4 o = vec4(0.0);\n    vec3 acc = vec3(0.0);\n    if (L == 2){\n      // Biplanar: the two strongest axes. The third adds a fraction of a percent\n      // anywhere that is not an exact corner and costs a third of the fetches.\n      vec3 an = abs(n);\n      an = an * an * an;\n      an /= max(an.x + an.y + an.z, 1e-4);\n      float lo = min(an.x, min(an.y, an.z));\n      vec3 bw = max(an - lo, 0.0);\n      bw /= max(bw.x + bw.y + bw.z, 1e-4);\n      vec4 c1, n1, o1;\n      if (bw.y > 0.002){\n        terrainTap(L, wp.xz * inv, g.topX * inv, g.topY * inv, c1, n1, o1);\n        c += c1 * bw.y; nh += n1 * bw.y; o += o1 * bw.y;\n        acc += sfWhiteoutTop(n, sfUnpackNormal(n1.rgb, ns)) * bw.y;\n      }\n      if (bw.x > 0.002){\n        terrainTap(L, wp.zy * inv, g.sideXX * inv, g.sideXY * inv, c1, n1, o1);\n        c += c1 * bw.x; nh += n1 * bw.x; o += o1 * bw.x;\n        acc += sfWhiteoutX(n, sfUnpackNormal(n1.rgb, ns)) * bw.x;\n      }\n      if (bw.z > 0.002){\n        terrainTap(L, wp.xy * inv, g.sideZX * inv, g.sideZY * inv, c1, n1, o1);\n        c += c1 * bw.z; nh += n1 * bw.z; o += o1 * bw.z;\n        acc += sfWhiteoutZ(n, sfUnpackNormal(n1.rgb, ns)) * bw.z;\n      }\n    } else {\n      terrainTap(L, wp.xz * inv, g.topX * inv, g.topY * inv, c, nh, o);\n      acc = sfWhiteoutTop(n, sfUnpackNormal(nh.rgb, ns));\n    }\n    col = c.rgb * u_tTint[L];\n    wn = acc;\n    h = nh.a;\n    rough = o.g;\n    ao = o.r;\n  }\n}\n\n/** Near-field surface for weights w. Outputs albedo (no macro), normal,\n *  roughness and occlusion. */\nvoid terrainSurfaceNear(vec3 wp, vec3 n, vec4 w, TerrainGrads g,\n                        out vec3 albedo, out vec3 nrm, out float rough, out float ao){\n  float ws[4];\n  ws[0] = w.x; ws[1] = w.y; ws[2] = w.z; ws[3] = w.w;\n  int i0 = 0;\n  float b0 = -1.0;\n  for (int i = 0; i < 4; i++){ if (ws[i] > b0){ b0 = ws[i]; i0 = i; } }\n  ws[i0] = -1.0;\n  int i1 = 0;\n  float b1 = -1.0;\n  for (int i = 0; i < 4; i++){ if (ws[i] > b1){ b1 = ws[i]; i1 = i; } }\n  b0 = max(b0, 0.0);\n  b1 = max(b1, 0.0);\n  float bs = max(b0 + b1, 1e-4);\n  b0 /= bs;\n  b1 /= bs;\n\n  vec3 c0, n0, c1, n1;\n  float h0, r0, a0, h1, r1, a1;\n  terrainLayerSample(i0, wp, n, g, c0, n0, h0, r0, a0);\n  if (b1 > 0.001){\n    terrainLayerSample(i1, wp, n, g, c1, n1, h1, r1, a1);\n  } else {\n    c1 = c0; n1 = n0; h1 = h0; r1 = r0; a1 = a0;\n  }\n\n  // Height blend: the layer whose own surface is higher at this texel wins, so\n  // gravel comes through grass along the gravel's grain and rock emerges from\n  // soil along its cracks, instead of the two cross-fading into mud.\n  float hb = u_tHeightBlend;\n  float range = mix(1.0, 0.04, hb);\n  float v0 = b0 + h0 * hb;\n  float v1 = b1 + h1 * hb;\n  float peak = max(v0, v1);\n  float w0 = max(v0 - (peak - range), 0.0);\n  float w1 = max(v1 - (peak - range), 0.0);\n  if (b1 <= 0.001) w1 = 0.0;\n  float ws2 = max(w0 + w1, 1e-4);\n  w0 /= ws2;\n  w1 /= ws2;\n\n  albedo = c0 * w0 + c1 * w1;\n  nrm = normalize(n0 * w0 + n1 * w1);\n  rough = r0 * w0 + r1 * w1;\n  ao = a0 * w0 + a1 * w1;\n}\n#endif\n";
 /** Everything a surface material needs, in include order. Requires three's
  *  `<common>` and `skyLib` from cloudCore before it. */
+/** Every uniform the terrain material reads. */
+export declare const terrainUniforms: string;
 export declare const terrainField: string;
+/**
+ * The height field and its sun-shadow march, with only the uniforms they read.
+ * What another material includes to stand water (or anything else) on the
+ * terrain: the ocean uses it for shoreline depth and headland shadows.
+ */
+export declare const terrainFieldOnly: string;
 export declare const terrainFull: string;
 //# sourceMappingURL=terrainCore.glsl.d.ts.map

package/dist/shaders/glsl/terrainCore.glsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"terrainCore.glsl.d.ts","sourceRoot":"","sources":["../../../src/shaders/glsl/terrainCore.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,2DAA2D;AAC3D,eAAO,MAAM,eAAe,wpGA2E3B,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,YAAY,uiCAiCxB,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,mqbAiVzB,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,s0RAuL1B,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,4pLAyJ3B,CAAA;AAED;wDACwD;AACxD,eAAO,MAAM,YAAY,QAA4D,CAAA;AAErF,eAAO,MAAM,WAAW,QAA4C,CAAA"}
+{"version":3,"file":"terrainCore.glsl.d.ts","sourceRoot":"","sources":["../../../src/shaders/glsl/terrainCore.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,ooDA0C/B,CAAA;AAED,uEAAuE;AACvE,eAAO,MAAM,sBAAsB,8rDAsClC,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,YAAY,uiCAiCxB,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,mqbAiVzB,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,aAAa,gjHAsEzB,CAAA;AAED,eAAO,MAAM,cAAc,6xKAkH1B,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,4pLAyJ3B,CAAA;AAED;wDACwD;AACxD,gDAAgD;AAChD,eAAO,MAAM,eAAe,QAA2D,CAAA;AAEvF,eAAO,MAAM,YAAY,QAA4D,CAAA;AAErF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,QAA+E,CAAA;AAE5G,eAAO,MAAM,WAAW,QAA2D,CAAA"}