three-low-poly 0.9.27 → 1.0.0

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 import { BoxGeometry } from 'three';
 import { BufferGeometry } from 'three';
-import { Color } from 'three';
 import { ColorRepresentation } from 'three';
 import { DataTexture } from 'three';
 import { DirectionalLight } from 'three';
@@ -8,7 +7,6 @@ import { ExtrudeGeometry } from 'three';
 import { Group } from 'three';
 import { InstancedMesh } from 'three';
 import { Material } from 'three';
-import { MaterialEventMap } from 'three';
 import { Mesh } from 'three';
 import { MeshBasicMaterial } from 'three';
 import { MeshLambertMaterial } from 'three';
@@ -19,84 +17,16 @@ import { Object3D } from 'three';
 import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
 import { ParametricGeometry } from 'three/addons/geometries/ParametricGeometry.js';
 import { PerspectiveCamera } from 'three';
-import { Plane } from 'three';
 import { PlaneGeometry } from 'three';
 import { PointLight } from 'three';
 import { Points } from 'three';
 import { Quaternion } from 'three';
-import { ShaderMaterial } from 'three';
 import { Shape } from 'three';
 import { ShapeGeometry } from 'three';
 import { SphereGeometry } from 'three';
-import * as THREE from 'three';
-import { Uniform } from 'three';
 import { Vector2 } from 'three';
 import { Vector3 } from 'three';
 
-/**
- * Shader modification to support instance-specific colors.
- * This function modifies the provided material to accept instance-specific colors.
- *
- * This is not generally necessary for materials that already support vertex colors,
- * but it can be useful for custom materials or when using InstancedMesh.
- *
- * Instanced meshes already allow for per-instance colors, implemented as:
- * ```ts
- *     const colors = new Float32Array(instancedMesh.count * 3);
- *     for (let i = 0; i < instancedMesh.count; i++) {
- *       const [r, g, b] = [Math.random(), Math.random(), Math.random()];
- *       colors.set([r, g, b], i * 3); // Normalized to [0, 1]
- *     }
- *     instancedMesh.instanceColor = new THREE.InstancedBufferAttribute(colors, 3);
- * ```
- *
- * Example usage:
- * ```ts
- *     // Material
- *     const material = new THREE.MeshStandardMaterial();
- *
- *     // Add instance color modifier
- *     addInstanceColor(material);
- *
- *     // RGB color for each instance
- *     const colors = new Float32Array(instancedMesh.count * 3);
- *     for (let i = 0; i < instancedMesh.count; i++) {
- *       getAnalogousColors(hue).forEach((color, index) => {
- *         colors[i * 3 + index] = color / 0xff;
- *       });
- *     }
- *
- *     // Add the instance color attribute to the geometry
- *     instancedMesh.geometry.setAttribute("instanceColor", new THREE.InstancedBufferAttribute(colors, 3));
- * ```
- */
-export declare function addInstanceColor(material: Material): Material< MaterialEventMap>;
-
-/**
- * Utility function to add noise-based vertex displacement to an existing Three.js material.
- * @param {Material} material - The material to mutate, e.g., MeshStandardMaterial.
- * @param {Object} options - Options for noise modification.
- * @param {number} [options.time=0.0] - The time value for the noise function.
- * @param {number} [options.intensity=1.0] - The intensity of the displacement.
- * @param {Vector3} [options.axis=new Vector3(1, 1, 1)] - The axis of displacement.
- * @param {number} [options.scale=10.0] - The scale of the noise effect.
- */
-export declare function addNoiseDisplacement<T extends Material>(material: T, { time, intensity, axis, scale }?: NoiseDisplacementOptions): void;
-
-/**
- * Utility function to add water-like vertex displacement to an existing Three.js material.
- * @param {Material} material - The material to mutate, e.g., MeshStandardMaterial.
- * @param {Object} options - Options for water wave modification.
- * @param {number} [options.time=0.0] - The time value for the wave function.
- * @param {number} [options.waveFrequency=0.2] - The frequency of the water waves.
- * @param {number} [options.waveAmplitude=0.5] - The amplitude of the water waves.
- */
-export declare function addWaterDisplacement<T extends Material>(material: T, { time, waveFrequency, waveAmplitude }?: {
-    time?: number | undefined;
-    waveFrequency?: number | undefined;
-    waveAmplitude?: number | undefined;
-}): void;
-
 /**
  * Align a BufferGeometry to a surface by adjusting its vertices.
  */
@@ -288,105 +218,6 @@ declare interface ArchedOutlineTarget {
     closePath(): unknown;
 }
 
-/**
- * Atmospheric scattering shader.
- *
- * Based on "A Practical Analytic Model for Daylight"
- * aka The Preetham Model, the de facto standard analytic skydome model
- * https://www.researchgate.net/publication/220720443_A_Practical_Analytic_Model_for_Daylight
- *
- * First implemented by Simon Wallner
- * http://simonwallner.at/project/atmospheric-scattering/
- *
- * Improved by Martin Upitis
- * http://blenderartists.org/forum/showthread.php?245954-preethams-sky-impementation-HDR
- *
- * Three.js integration by zz85 http://twitter.com/blurspline
- *
- * Example:
- * ```
- *     const geometry = new BoxGeometry(1, 1, 1);
- *
- *     const material = new ShaderMaterial({
- *       uniforms: atmosphericShader.uniforms,
- *       vertexShader: atmosphericShader.vertexShader,
- *       fragmentShader: atmosphericShader.fragmentShader,
- *       depthWrite: false,
- *       side: BackSide,
- *     }) as ShaderMaterial & { uniforms: AtmosphericShaderUniforms };
- *
- *     const theta = MathUtils.degToRad(89);
- *     const phi = MathUtils.degToRad(180);
- *     const sun = new Vector3().setFromSphericalCoords(1, theta, phi);
- *
- *     material.uniforms.sunPosition.value = sun;
- *
- *     const mesh = new Mesh(geometry, material);
- *     mesh.scale.setScalar(450000);
- * ```
- */
-export declare const atmosphericShader: {
-    uniforms: {
-        turbidity: {
-            value: number;
-        };
-        rayleigh: {
-            value: number;
-        };
-        mieCoefficient: {
-            value: number;
-        };
-        mieDirectionalG: {
-            value: number;
-        };
-        sunPosition: {
-            value: Vector3;
-        };
-        up: {
-            value: Vector3;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};
-
-export declare interface AtmosphericShaderUniforms {
-    turbidity: Uniform<number>;
-    rayleigh: Uniform<number>;
-    mieCoefficient: Uniform<number>;
-    mieDirectionalG: Uniform<number>;
-    sunPosition: Uniform<Vector3>;
-    up: Uniform<Vector3>;
-}
-
-/**
- * Atmospheric scattering skybox.
- *
- * Elevation (theta, θ): Angle measured above or below the horizon (from the xy-plane towards the zenith or nadir).
- * Azimuth (phi, φ): Angle measured around the horizon from a reference direction (e.g., north, east).
- */
-export declare class AtmosphericSkybox extends Mesh {
-    geometry: BoxGeometry;
-    material: ShaderMaterial & {
-        uniforms: AtmosphericShaderUniforms;
-    };
-    constructor();
-    /**
-     * Set the sun position.
-     *
-     * Elevation (theta, θ)
-     * - Angle measured above or below the horizon (from the xy-plane towards the zenith or nadir).
-     * - Ranges from 0 to π/2 radians (or 0 to 90 degrees).
-     * - This is the vertical angle in the xy-plane.
-     *
-     * Azimuth (phi, φ)
-     * - Angle measured around the horizon from a reference direction (e.g., north, east).
-     * - Ranges from 0 to 2π radians (or 0 to 360 degrees).
-     * - This is the horizontal angle in the xy-plane.
-     */
-    sunPosition(theta: number, phi: number): void;
-}
-
 /**
  * Geometric and mathematical role of the vectors as axes in 3D space.
  *
@@ -514,31 +345,6 @@ export declare const Axis: {
     XYZ: Vector3;
 };
 
-declare interface BloomTransitionOptions extends SceneTransitionFXOptions {
-    maxBloom?: number;
-}
-
-declare interface BlurTransitionOptions extends SceneTransitionFXOptions {
-    maxBlur?: number;
-    kernelSize?: number;
-}
-
-export declare const blurTransitionShader: {
-    uniforms: {
-        tDiffuse: {
-            value: null;
-        };
-        kernelSize: {
-            value: number;
-        };
-        resolution: {
-            value: null;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};
-
 export declare class Bone extends Mesh<BoneGeometry, MeshStandardMaterial> {
     constructor();
 }
@@ -648,6 +454,59 @@ export declare interface BookshelfOptions extends BookshelfGeometryOptions {
     color?: ColorRepresentation;
 }
 
+/**
+ * Boulder prefab — a {@link BoulderGeometry} lumped by coherent 3D noise, with a
+ * matte flat-shaded stone material. Centered on the origin; casts and receives
+ * shadows. Vary `seed` per instance for a field of unique boulders.
+ */
+export declare class Boulder extends Mesh<BoulderGeometry, MeshStandardMaterial> {
+    readonly radius: number;
+    constructor({ color, flatShading, ...geometryOptions }?: BoulderOptions);
+}
+
+/**
+ * Boulder — an icosphere lumped by coherent 3D fbm ({@link fbm3}) displaced along
+ * each vertex's radial direction. The 3D counterpart to the terrain heightfields:
+ * same noise strategy, applied over a closed surface instead of a height map.
+ *
+ * The icosphere is welded (`mergeVertices` after stripping seam UVs) so coincident
+ * vertices share one displacement — the coherent noise then moves neighbors together,
+ * so the surface stays watertight and never cracks (the failure mode of displacing a
+ * non-indexed polyhedron along normals). Real baked geometry, so shadows, raycasts,
+ * and physics colliders match what's drawn, on WebGL and WebGPU/TSL alike.
+ *
+ * Centered on the origin. Pair with a `flatShading` material for a faceted low-poly
+ * look. Vary `seed` per instance to fill a field with unique boulders.
+ */
+export declare class BoulderGeometry extends BufferGeometry {
+    readonly radius: number;
+    constructor({ radius, detail, noiseHeight, noiseScale, octaves, persistence, seed, }?: BoulderGeometryOptions);
+}
+
+export declare interface BoulderGeometryOptions {
+    /** Base radius before displacement (world units). Defaults to `1`. */
+    radius?: number;
+    /** Icosahedron subdivision — more detail = more, finer facets. Defaults to `2`. */
+    detail?: number;
+    /** Radial relief amplitude (world units, ±). Keep below `radius`. Defaults to `0.35`. */
+    noiseHeight?: number;
+    /** Noise frequency over the unit sphere — higher packs more, smaller lumps. Defaults to `1.6`. */
+    noiseScale?: number;
+    /** fbm octaves (detail layers). Defaults to `3`. */
+    octaves?: number;
+    /** fbm gain per octave (0–1); lower is smoother, higher is rougher. Defaults to `0.5`. */
+    persistence?: number;
+    /** Seed for reproducible shape. Defaults to `1`. */
+    seed?: number;
+}
+
+export declare interface BoulderOptions extends BoulderGeometryOptions {
+    /** Stone tint. Defaults to `#6f6f6f`. */
+    color?: ColorRepresentation;
+    /** Faceted low-poly shading. Defaults to `true`. */
+    flatShading?: boolean;
+}
+
 export declare enum BoxSide {
     LEFT = "left",
     RIGHT = "right",
@@ -685,9 +544,6 @@ export declare function buildDiamondLatticeParts({ width, height, centerY, grid,
  */
 export declare function buildGregorianLatticeParts({ width, height, centerY, cellsX, cellsY, mullionThickness: barT, mullionDepth: barD, }: GregorianLatticePartOptions): BoxGeometry[];
 
-/** Outer frame bars — shared topology across lattice window openings. */
-export declare function buildRingLatticeFrameParts({ width, height, centerY, frameThickness: barT, frameDepth: barD, }: RingLatticeFramePartOptions): BoxGeometry[];
-
 export declare class BunsenBurner extends Group {
     constructor();
 }
@@ -861,87 +717,6 @@ export declare interface CameraSnapshot {
     target: Vector3;
 }
 
-/**
- * CameraTransition provides smooth animated transitions between perspective and orthographic cameras.
- *
- * The transition works by rendering both camera views to separate render targets and blending between them.
- * This provides a true, accurate transition between the two camera types.
- *
- * @example
- * ```typescript
- * const transition = new CameraTransition(
- *   perspectiveCamera,
- *   orthographicCamera,
- *   renderer
- * );
- *
- * transition.transitionTo(orthographicCamera, {
- *   duration: 1000,
- *   easing: 'easeInOutCubic'
- * });
- * ```
- */
-export declare class CameraTransition {
-    private perspectiveCamera;
-    private orthographicCamera;
-    private renderer;
-    private scene;
-    private currentCamera;
-    private targetCamera;
-    private transitionProgress;
-    private transitionDuration;
-    private transitionStartTime;
-    private isTransitioning;
-    private easingFunction;
-    private renderTargetA;
-    private renderTargetB;
-    private blendScene;
-    private blendCamera;
-    private blendMaterial;
-    private onUpdateCallback?;
-    private onCompleteCallback?;
-    constructor(perspectiveCamera: THREE.PerspectiveCamera, orthographicCamera: THREE.OrthographicCamera, renderer: THREE.WebGLRenderer);
-    /**
-     * Start a transition to the target camera
-     */
-    transitionTo(targetCamera: THREE.PerspectiveCamera | THREE.OrthographicCamera, options?: CameraTransitionOptions): void;
-    /**
-     * Update the transition. Call this in your render loop.
-     */
-    update(scene: THREE.Scene): THREE.Camera;
-    /**
-     * Render the scene with camera transition blending
-     */
-    render(scene: THREE.Scene): void;
-    /**
-     * Get the current active camera
-     */
-    getCurrentCamera(): THREE.Camera;
-    /**
-     * Check if a transition is currently in progress
-     */
-    getIsTransitioning(): boolean;
-    /**
-     * Get the current transition progress (0-1)
-     */
-    getProgress(): number;
-    /**
-     * Resize the render targets when the renderer size changes
-     */
-    setSize(width: number, height: number): void;
-    /**
-     * Dispose of resources
-     */
-    dispose(): void;
-}
-
-export declare interface CameraTransitionOptions {
-    duration?: number;
-    easing?: EasingFunction | keyof typeof Easing;
-    onUpdate?: (progress: number) => void;
-    onComplete?: () => void;
-}
-
 /**
  * Candle prefab — wax stick and emissive flame (separate material groups).
  */
@@ -1275,12 +1050,6 @@ export declare function createHexagonalTilesByRadius(options: HexagonalTileRadiu
  */
 export declare const createLogarithmicCurvePoints: (start: Vector2, end: Vector2, base: number, factor: number, segments?: number) => Vector2[];
 
-/**
- * Four clipping planes for a rectangular opening (shadow + mesh clip).
- * Fragments are discarded when `dot(normal, position) > constant`.
- */
-export declare function createOpeningClippingPlanes(width: number, height: number, centerY?: number): Plane[];
-
 /** Circle the scene — showcase reel orbit. */
 export declare function createOrbitClip(options: OrbitClipOptions): CameraClip;
 
@@ -1387,9 +1156,6 @@ export declare const createQuadraticCurvePoints: (start: Vector2, control: Vecto
  */
 export declare function createRandom(seed?: number): RandomSource;
 
-/** Hollow square profile extruded for one lattice ring (local XY, facing +Z). */
-export declare function createRingLatticeGeometry(outer: number, wall: number, depth: number): ExtrudeGeometry;
-
 /**
  * Function to create sigmoid curve points
  *
@@ -1423,22 +1189,6 @@ export declare function createWobbleClip(options: WobbleClipOptions): CameraClip
 /** Focus punch — smooth FOV narrow toward a target. Restores FOV on cancel; keeps end FOV on complete. */
 export declare function createZoomClip(options: ZoomClipOptions): CameraClip;
 
-export declare const crossfadeShader: {
-    uniforms: {
-        tDiffuseA: {
-            value: null;
-        };
-        tDiffuseB: {
-            value: null;
-        };
-        mixRatio: {
-            value: number;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};
-
 /**
  * Cross headstone prefab.
  */
@@ -1515,45 +1265,6 @@ export declare function cubicUVMappingBatch(vertices: [number, number, number][]
  */
 export declare function cylindricalUVMapping(vertices: [number, number, number][]): [number, number][];
 
-export declare class DaySkybox extends Mesh {
-    geometry: BoxGeometry;
-    material: ShaderMaterial & {
-        uniforms: DaySkyUniforms;
-    };
-    constructor(size?: number);
-}
-
-/**
- * Shader for a day skybox.
- *
- * Example:
- * ```
- * this.material = new ShaderMaterial({
- *   uniforms: daySkyShader.uniforms,
- *   vertexShader: daySkyShader.vertexShader,
- *   fragmentShader: daySkyShader.fragmentShader,
- *   side: BackSide,
- * }) as ShaderMaterial & { uniforms: DaySkyUniforms };
- * ```
- */
-export declare const daySkyShader: {
-    uniforms: {
-        topColor: {
-            value: Color;
-        };
-        bottomColor: {
-            value: Color;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};
-
-export declare interface DaySkyUniforms {
-    topColor: Uniform<Color>;
-    bottomColor: Uniform<Color>;
-}
-
 /**
  * Derive an independent sub-stream seed from a master seed and domain salt.
  *
@@ -1784,6 +1495,90 @@ export declare interface DollyClipOptions extends CameraClipTiming {
     ease?: EasingFunction;
 }
 
+/**
+ * Fine dust drifting through a lit interior — tiny additive specks slowly
+ * settling and wafting, twinkling as they catch the light and all but vanishing
+ * in shadow. This is the thing that sells a light shaft as volumetric. Additive
+ * spheres read the same from any angle, so no billboarding is needed.
+ *
+ * Call {@link DustMotesEffect.update} each frame with elapsed time in seconds.
+ *
+ * @example
+ * ```typescript
+ * const dust = new DustMotesEffect({
+ *   count: 150,
+ *   width: 8,
+ *   height: 9,
+ *   depth: 8,
+ *   color: "#aebfe6",
+ * });
+ * scene.add(dust);
+ *
+ * onFrame((dt) => dust.update(dt));
+ * ```
+ */
+export declare class DustMotesEffect extends InstancedMesh {
+    private readonly width;
+    private readonly height;
+    private readonly depth;
+    private readonly floorY;
+    private readonly waft;
+    private readonly scaleMin;
+    private readonly scaleMax;
+    private readonly px;
+    private readonly py;
+    private readonly pz;
+    private readonly settle;
+    private readonly twinkle;
+    private readonly phase;
+    private readonly dummy;
+    private clock;
+    constructor(options?: DustMotesEffectOptions);
+    /**
+     * Advance the drift and twinkle. Pass elapsed frame time in seconds.
+     */
+    update(dt: number): void;
+    /** Release geometry and materials held by the field. */
+    dispose(): this;
+    private respawn;
+    private writeMatrices;
+}
+
+export declare interface DustMotesEffectOptions {
+    /** Number of dust instances. Defaults to `150`. */
+    count?: number;
+    /** Horizontal spread (world units). Defaults to `12`. */
+    width?: number;
+    /** Vertical spawn span (world units). Defaults to `8`. */
+    height?: number;
+    /** Depth spread (world units). Defaults to `12`. */
+    depth?: number;
+    /** World Y of the volume floor; motes respawn at the top after settling past it. Defaults to `0`. */
+    floorY?: number;
+    /** Speck tint. Defaults to `#aebfe6`. */
+    color?: ColorRepresentation;
+    /** Speck radius (world units). Defaults to `0.02`. */
+    radius?: number;
+    /** Base material opacity. Defaults to `0.9`. */
+    opacity?: number;
+    /** Override the default additive speck material. */
+    material?: Material;
+    /** Minimum settle (fall) speed (units/s). Defaults to `0.1`. */
+    settleMin?: number;
+    /** Maximum settle (fall) speed (units/s). Defaults to `0.35`. */
+    settleMax?: number;
+    /** Lateral waft amplitude (units/s). Defaults to `0.08`. */
+    waft?: number;
+    /** Smallest twinkle scale multiplier. Defaults to `0.6`. */
+    scaleMin?: number;
+    /** Largest twinkle scale multiplier. Defaults to `1.2`. */
+    scaleMax?: number;
+    /** Minimum twinkle frequency (rad/s). Defaults to `0.7`. */
+    twinkleMin?: number;
+    /** Maximum twinkle frequency (rad/s). Defaults to `1.6`. */
+    twinkleMax?: number;
+}
+
 /**
  * Easing functions for interpolating values over time.
  *
@@ -2027,49 +1822,6 @@ export declare interface ErlenmeyerFlaskOptions extends ErlenmeyerFlaskGeometryO
     opacity?: number;
 }
 
-export declare const fadeShader: {
-    uniforms: {
-        tDiffuse: {
-            value: null;
-        };
-        fadeAmount: {
-            value: number;
-        };
-        fadeColor: {
-            value: null;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};
-
-declare interface FadeTransitionOptions extends SceneTransitionOptions {
-    color?: THREE.ColorRepresentation;
-}
-
-declare interface FadeTransitionOptions_2 extends SceneTransitionFXOptions {
-    color?: THREE.ColorRepresentation;
-}
-
-export declare const fadeTransitionSceneShader: {
-    uniforms: {
-        tDiffuseA: {
-            value: null;
-        };
-        tDiffuseB: {
-            value: null;
-        };
-        mixRatio: {
-            value: number;
-        };
-        fadeColor: {
-            value: null;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};
-
 export declare const Falloff: {
     linear: (distance: number, radius: number) => number;
     quadratic: (distance: number, radius: number) => number;
@@ -2267,10 +2019,6 @@ export declare class GearShape extends Shape {
  */
 export declare function getAnalogousColors(baseHue: number): [number, number, number];
 
-declare interface GlitchTransitionOptions extends SceneTransitionFXOptions {
-    maxIntensity?: number;
-}
-
 /**
  * Soft additive glow billboard — reads as light without a {@link PointLight}.
  * Pair with {@link FlameFlickerEffect} for organic pulse, or use alone for
@@ -2618,44 +2366,6 @@ export declare function hexToHsl(hex: number): [number, number, number];
  */
 export declare function hexToRgb(hex: number): [number, number, number];
 
-/**
- * Hill prefab — hemispherical terrain mound.
- */
-export declare class Hill extends Mesh<HillGeometry, MeshStandardMaterial> {
-    readonly radius: number;
-    readonly height: number;
-    constructor({ color, ...geometryOptions }?: HillOptions);
-}
-
-/**
- * Hemispherical hill — a sphere cap scaled on Y, base on the Y=0 plane.
- */
-export declare class HillGeometry extends BufferGeometry {
-    readonly radius: number;
-    readonly height: number;
-    constructor({ radius, height, widthSegments, heightSegments, phiStart, phiLength, }?: HillGeometryOptions);
-}
-
-export declare interface HillGeometryOptions {
-    /** Base sphere radius before vertical squash. Defaults to `3`. */
-    radius?: number;
-    /** Peak height. Defaults to `0.6`. */
-    height?: number;
-    /** Horizontal segments. Defaults to `64`. */
-    widthSegments?: number;
-    /** Vertical segments. Defaults to `16`. */
-    heightSegments?: number;
-    /** Azimuth start angle (radians). Defaults to `0`. */
-    phiStart?: number;
-    /** Azimuth sweep (radians). Defaults to `2π`. */
-    phiLength?: number;
-}
-
-export declare interface HillOptions extends HillGeometryOptions {
-    /** Surface tint. Defaults to `#00ff00`. */
-    color?: ColorRepresentation;
-}
-
 /**
  * Example usage:
  * ```
@@ -3031,108 +2741,17 @@ export declare interface MossyRockOptions extends MossyRockGeometryOptions {
     mossOpacity?: number;
 }
 
-/**
- * Mound prefab — flat-topped terrain cap.
- */
-export declare class Mound extends Mesh<MoundGeometry, MeshStandardMaterial> {
-    readonly radius: number;
-    constructor({ color, radius, ...geometryOptions }?: MoundOptions);
-}
-
-/**
- * Mound-like geometry with a flat top — sphere cap, base on Y=0.
- */
-export declare class MoundGeometry extends BufferGeometry {
-    readonly radius: number;
-    readonly thetaLength: number;
-    constructor({ radius, widthSegments, heightSegments, phiStart, phiLength, thetaLength, }?: MoundGeometryOptions);
-}
-
-export declare interface MoundGeometryOptions {
-    /** Sphere radius. Defaults to a cap width of `5` at `thetaLength`. */
-    radius?: number;
-    /** Horizontal segments. Defaults to `64`. */
-    widthSegments?: number;
-    /** Vertical segments. Defaults to `32`. */
-    heightSegments?: number;
-    /** Azimuth start angle (radians). Defaults to `0`. */
-    phiStart?: number;
-    /** Azimuth sweep (radians). Defaults to `2π`. */
-    phiLength?: number;
-    /** Polar sweep from the north pole (radians). Defaults to `π/10`. */
-    thetaLength?: number;
-}
-
-export declare interface MoundOptions extends MoundGeometryOptions {
-    /** Surface tint. Defaults to `#00ff00`. */
-    color?: ColorRepresentation;
-}
-
 /**
  * Fast seeded PRNG — portfolio Gotham/Water parity.
  * Returns a closure yielding floats in [0, 1).
  */
 export declare function mulberry32(seed: number): RandomStream;
 
-export declare class NightSkybox extends Mesh {
-    geometry: SphereGeometry;
-    material: ShaderMaterial & {
-        uniforms: NightSkyUniforms;
-    };
-    constructor(size?: number);
-}
-
-/**
- * Shader for a night skybox.
- *
- * Example:
- * ```
- * this.material = new ShaderMaterial({
- *   vertexShader: nightSkyShader.vertexShader,
- *   fragmentShader: nightSkyShader.fragmentShader,
- *   uniforms: nightSkyShader.uniforms,
- *   side: BackSide,
- * }) as ShaderMaterial & { uniforms: NightSkyUniforms };
- * ```
- */
-export declare const nightSkyShader: {
-    uniforms: {
-        topColor: {
-            value: Color;
-        };
-        bottomColor: {
-            value: Color;
-        };
-        offset: {
-            value: number;
-        };
-        exponent: {
-            value: number;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};
-
-export declare interface NightSkyUniforms {
-    topColor: Uniform<Color>;
-    bottomColor: Uniform<Color>;
-    offset: Uniform<number>;
-    exponent: Uniform<number>;
-}
-
 /**
  * Adds random noise to the vertices within the specified radius to create a more rugged or natural look.
  */
 export declare const noiseBrush: <T extends BufferGeometry>(geometry: T, position: Vector3, radius: number, strength: number, direction?: Vector3, falloffFn?: (distance: number, radius: number) => number) => void;
 
-declare interface NoiseDisplacementOptions {
-    time?: number;
-    intensity?: number;
-    axis?: Vector3;
-    scale?: number;
-}
-
 export declare function normalizeRgb(r: number, g: number, b: number): [number, number, number];
 
 /**
@@ -3652,9 +3271,6 @@ export declare type RandomStream = () => number;
 
 export declare function randomTransformVertices<T extends BufferGeometry>(geometry: T, axis?: Vector3, minScale?: number, maxScale?: number): T;
 
-/** Resolve uniform ring spacing — `cell` wins over the `cellsX` density hint. */
-export declare function resolveRingLatticeCell(width: number, _height: number, cell?: number, cellsX?: number): number;
-
 export declare function rgbToHex(r: number, g: number, b: number): number;
 
 /**
@@ -3669,84 +3285,6 @@ export declare function rgbToHex(r: number, g: number, b: number): number;
  */
 export declare function rgbToHsl(r: number, g: number, b: number): [number, number, number];
 
-/** Ring-spacing factor — overlap tightens as this approaches 1. */
-export declare const RING_LATTICE_SPACING_FACTOR = 0.96;
-
-declare interface RingLatticeFramePartOptions {
-    width: number;
-    height: number;
-    centerY?: number;
-    frameThickness: number;
-    frameDepth: number;
-}
-
-export declare interface RingLatticeGrid {
-    /** Requested ring-center spacing before the overlap factor. */
-    cell: number;
-    /** Effective center spacing (`cell × 0.96`). */
-    latticeCell: number;
-    /** Outer half-extent of each square ring profile. */
-    ringOuter: number;
-    /** Ring instance count. */
-    count: number;
-}
-
-declare interface RingLatticeSpotOptions {
-    width: number;
-    height: number;
-    centerY?: number;
-    cell: number;
-}
-
-/** Ring-center positions overscanning the opening (stencil trims the excess). */
-export declare function ringLatticeSpots({ width, height, centerY, cell, }: RingLatticeSpotOptions): {
-    spots: [number, number][];
-    grid: RingLatticeGrid;
-};
-
-/**
- * Ring lattice window — overlapping square rings on a uniform grid (diaper /
- * trellis fretwork), stencil-clipped to a rectangular opening.
- */
-export declare class RingLatticeWindow extends Group {
-    readonly lattice: InstancedMesh;
-    readonly frame: Mesh;
-    readonly glass?: Mesh<PlaneGeometry, MeshPhysicalMaterial>;
-    readonly cell: number;
-    readonly fittedGrid: RingLatticeGrid;
-    private readonly clipPlanesLocal;
-    private readonly clipPlanesWorld;
-    constructor({ width, height, cell: cellOption, cellsX, centerY, ringThickness, ringDepth, frameThickness, frameDepth, latticeColor, glass, glassColor, glassEmissive, glassEmissiveIntensity, }?: RingLatticeWindowOptions);
-}
-
-declare interface RingLatticeWindowOptions {
-    /** Opening width (world units). */
-    width?: number;
-    /** Opening height (world units). */
-    height?: number;
-    /** Uniform ring-center spacing. Overrides `cellsX` when set. Defaults to `0.55`. */
-    cell?: number;
-    /** Density hint — `cell = width / cellsX` when `cell` is omitted. */
-    cellsX?: number;
-    /** Wall thickness of each square ring profile. Defaults to `0.05`. */
-    ringThickness?: number;
-    /** Extrusion depth of each ring. Defaults to `0.06`. */
-    ringDepth?: number;
-    /** Outer frame bar thickness. Defaults to `0.055`. */
-    frameThickness?: number;
-    /** Outer frame depth (Z). Defaults to `0.11`. */
-    frameDepth?: number;
-    /** Vertical center of the opening in local space. Defaults to `0`. */
-    centerY?: number;
-    /** Lattice + frame tint. Defaults to `#0c0f14`. */
-    latticeColor?: ColorRepresentation;
-    /** Optional glass pane recessed slightly on −Z. */
-    glass?: boolean;
-    glassColor?: ColorRepresentation;
-    glassEmissive?: ColorRepresentation;
-    glassEmissiveIntensity?: number;
-}
-
 /**
  * Single rock prefab — noisy sphere mesh.
  */
@@ -3844,6 +3382,51 @@ export declare interface RowOfBooksOptions<T extends Material = Material> {
     seed?: number;
 }
 
+/**
+ * Scatter a field of instanced boulders inside a horizontal bounds region — a "created
+ * layer" of the noise-lumped {@link BoulderGeometry}. Unlike {@link scatterRocks}, which
+ * rotates a single shared shape, this generates several distinct boulder geometries
+ * (see `variants`) and distributes instances across them, so the field reads as unique
+ * rocks while staying to a few draw calls.
+ *
+ * Returns a {@link Group} of {@link InstancedMesh}es (one per variant), each sharing the
+ * stone material. Pass a `seed` for a reproducible field. Dispose each child's geometry
+ * and the shared material when removing it.
+ *
+ * @example
+ * ```ts
+ * const boulders = scatterBoulders({ count: 24, width: 12, depth: 12, seed: 1337 });
+ * scene.add(boulders);
+ * ```
+ */
+export declare function scatterBoulders({ count, width, depth, heightJitter, scaleMin, scaleMax, seed, radius, detail, noiseHeight, noiseScale, octaves, persistence, variants, material, color, }?: ScatterBouldersOptions): Group;
+
+export declare interface ScatterBouldersOptions extends RockScatterPlacementOptions {
+    /** Base radius for each boulder geometry. Defaults to `1`. */
+    radius?: number;
+    /** Icosphere subdivision per boulder. Defaults to `2`. */
+    detail?: number;
+    /** Radial relief amplitude per boulder. Defaults to `0.35`. */
+    noiseHeight?: number;
+    /** Noise frequency per boulder. Defaults to `1.6`. */
+    noiseScale?: number;
+    /** fbm octaves per boulder. Defaults to `3`. */
+    octaves?: number;
+    /** fbm gain per octave. Defaults to `0.5`. */
+    persistence?: number;
+    /**
+     * Distinct boulder geometries generated and distributed across the field. Each is
+     * a real, unique lumped shape (unlike rotating one shared mesh); instances round-robin
+     * across them, so the field stays batch-friendly (one draw call per variant).
+     * Defaults to `4`.
+     */
+    variants?: number;
+    /** Override the default stone material (shared across all instances). */
+    material?: Material;
+    /** Stone tint when `material` is omitted. Defaults to `#6f6f6f`. */
+    color?: ColorRepresentation;
+}
+
 /**
  * Scatter instanced mossy rocks inside a horizontal bounds region.
  *
@@ -3889,256 +3472,6 @@ export declare interface ScatterRocksOptions extends RockScatterPlacementOptions
     color?: ColorRepresentation;
 }
 
-/**
- * SceneTransition provides smooth animated transitions between Three.js scenes.
- *
- * Supports multiple transition types:
- * - Fade: Fade to a color (black, white, etc.) and back
- * - Crossfade: Directly blend from one scene to another
- * - Blur: Blur out the first scene and blur in the second
- *
- * @example
- * ```typescript
- * const sceneTransition = new SceneTransition(renderer);
- *
- * // Fade to black transition
- * sceneTransition.fade(sceneA, sceneB, camera, {
- *   duration: 1000,
- *   color: 0x000000,
- *   easing: 'easeInOutCubic'
- * });
- *
- * // Direct crossfade
- * sceneTransition.crossfade(sceneA, sceneB, camera, {
- *   duration: 1500
- * });
- * ```
- */
-export declare class SceneTransition {
-    private renderer;
-    private currentScene;
-    private targetScene;
-    private camera;
-    private transitionProgress;
-    private transitionDuration;
-    private transitionStartTime;
-    private isTransitioning;
-    private transitionType;
-    private easingFunction;
-    private renderTargetA;
-    private renderTargetB;
-    private blendScene;
-    private blendCamera;
-    private fadeMaterial;
-    private crossfadeMaterial;
-    private fadeColor;
-    private onUpdateCallback?;
-    private onCompleteCallback?;
-    constructor(renderer: THREE.WebGLRenderer);
-    /**
-     * Fade transition: Fades to a color and then fades in the new scene
-     */
-    fade(fromScene: THREE.Scene, toScene: THREE.Scene, camera: THREE.Camera, options?: FadeTransitionOptions): void;
-    /**
-     * Crossfade transition: Directly blends from one scene to another
-     */
-    crossfade(fromScene: THREE.Scene, toScene: THREE.Scene, camera: THREE.Camera, options?: SceneTransitionOptions): void;
-    /**
-     * Blur transition: Blurs out first scene, then blurs in second scene
-     * Note: This uses the fade material with a neutral gray for a blur-like effect
-     * For true blur, you'd need post-processing passes
-     */
-    blur(fromScene: THREE.Scene, toScene: THREE.Scene, camera: THREE.Camera, options?: SceneTransitionOptions): void;
-    /**
-     * Internal method to start a transition
-     */
-    private startTransition;
-    /**
-     * Update the transition. Call this in your render loop.
-     */
-    update(): void;
-    /**
-     * Render the scene with transition blending
-     */
-    render(): void;
-    /**
-     * Get the current active scene
-     */
-    getCurrentScene(): THREE.Scene | null;
-    /**
-     * Check if a transition is currently in progress
-     */
-    getIsTransitioning(): boolean;
-    /**
-     * Get the current transition progress (0-1)
-     */
-    getProgress(): number;
-    /**
-     * Set the current scene (useful for initialization)
-     */
-    setCurrentScene(scene: THREE.Scene): void;
-    /**
-     * Resize the render targets when the renderer size changes
-     */
-    setSize(width: number, height: number): void;
-    /**
-     * Dispose of resources
-     */
-    dispose(): void;
-}
-
-/**
- * SceneTransitionFX provides advanced post-processing transitions between Three.js scenes.
- *
- * Uses EffectComposer for sophisticated visual effects:
- * - Bloom: Bright bloom effect that peaks at transition midpoint, washing out to white
- * - Blur: Progressive blur effect that peaks at midpoint, blurring scenes to oblivion
- * - Fade: Classic fade through a color (black, white, or custom)
- * - Glitch: Digital distortion/glitch effect with heavy artifacts
- *
- * Built-in shader passes for blur and fade are automatically created. For bloom and glitch
- * effects, you'll need to provide those passes manually.
- *
- * Note: Requires post-processing imports from three/addons
- *
- * @example
- * ```typescript
- * import { EffectComposer } from 'three/addons/postprocessing/EffectComposer.js';
- * import { RenderPass } from 'three/addons/postprocessing/RenderPass.js';
- * import { UnrealBloomPass } from 'three/addons/postprocessing/UnrealBloomPass.js';
- * import { ShaderPass } from 'three/addons/postprocessing/ShaderPass.js';
- *
- * const composer = new EffectComposer(renderer);
- * const renderPass = new RenderPass(sceneA, camera);
- * composer.addPass(renderPass);
- *
- * // Pass ShaderPass to enable built-in blur and fade effects
- * const sceneTransitionFX = new SceneTransitionFX(renderer, composer, ShaderPass);
- *
- * // Blur and fade transitions work out of the box
- * sceneTransitionFX.blur(sceneA, sceneB, camera, { duration: 2000 });
- * sceneTransitionFX.fade(sceneA, sceneB, camera, { duration: 2000, color: 0x000000 });
- *
- * // For bloom, provide the pass manually
- * const bloomPass = new UnrealBloomPass(new THREE.Vector2(width, height), 0, 0.4, 0.85);
- * bloomPass.enabled = false;
- * composer.addPass(bloomPass);
- * sceneTransitionFX.setBloomPass(bloomPass);
- * sceneTransitionFX.bloom(sceneA, sceneB, camera, { duration: 2000, maxBloom: 15.0 });
- * ```
- */
-export declare class SceneTransitionFX {
-    private renderer;
-    private composer;
-    private currentScene;
-    private targetScene;
-    private camera;
-    private transitionProgress;
-    private transitionDuration;
-    private transitionStartTime;
-    private isTransitioning;
-    private transitionType;
-    private easingFunction;
-    private renderPass;
-    private bloomPass;
-    private glitchPass;
-    private blurPass;
-    private fadePass;
-    private maxBloomStrength;
-    private maxBlurAmount;
-    private maxGlitchIntensity;
-    private fadeColor;
-    private onUpdateCallback?;
-    private onCompleteCallback?;
-    constructor(renderer: THREE.WebGLRenderer, composer: any, ShaderPass?: any);
-    /**
-     * Create default shader passes for blur and fade effects
-     */
-    private createDefaultPasses;
-    /**
-     * Set the bloom pass for bloom transitions
-     */
-    setBloomPass(bloomPass: any): void;
-    /**
-     * Set the glitch pass for glitch transitions
-     */
-    setGlitchPass(glitchPass: any): void;
-    /**
-     * Set the blur pass for blur transitions
-     */
-    setBlurPass(blurPass: any): void;
-    /**
-     * Set the fade pass for fade transitions
-     */
-    setFadePass(fadePass: any): void;
-    /**
-     * Bloom transition: Bright bloom effect that peaks at transition midpoint
-     */
-    bloom(fromScene: THREE.Scene, toScene: THREE.Scene, camera: THREE.Camera, options?: BloomTransitionOptions): void;
-    /**
-     * Blur transition: Progressively blur scenes to oblivion and back
-     */
-    blur(fromScene: THREE.Scene, toScene: THREE.Scene, camera: THREE.Camera, options?: BlurTransitionOptions): void;
-    /**
-     * Fade transition: Classic fade through a color (black, white, or custom)
-     */
-    fade(fromScene: THREE.Scene, toScene: THREE.Scene, camera: THREE.Camera, options?: FadeTransitionOptions_2): void;
-    /**
-     * Glitch transition: Digital distortion effect
-     */
-    glitch(fromScene: THREE.Scene, toScene: THREE.Scene, camera: THREE.Camera, options?: GlitchTransitionOptions): void;
-    /**
-     * Internal method to start a transition
-     */
-    private startTransition;
-    /**
-     * Update the transition. Call this in your render loop.
-     */
-    update(): void;
-    /**
-     * Render using the effect composer
-     */
-    render(): void;
-    /**
-     * Get the current active scene
-     */
-    getCurrentScene(): THREE.Scene | null;
-    /**
-     * Check if a transition is currently in progress
-     */
-    getIsTransitioning(): boolean;
-    /**
-     * Get the current transition progress (0-1)
-     */
-    getProgress(): number;
-    /**
-     * Set the current scene (useful for initialization)
-     */
-    setCurrentScene(scene: THREE.Scene): void;
-    /**
-     * Resize the composer when the renderer size changes
-     */
-    setSize(width: number, height: number): void;
-    /**
-     * Dispose of resources
-     */
-    dispose(): void;
-}
-
-export declare interface SceneTransitionFXOptions {
-    duration?: number;
-    easing?: EasingFunction | keyof typeof Easing;
-    onUpdate?: (progress: number) => void;
-    onComplete?: () => void;
-}
-
-export declare interface SceneTransitionOptions {
-    duration?: number;
-    easing?: EasingFunction | keyof typeof Easing;
-    onUpdate?: (progress: number) => void;
-    onComplete?: () => void;
-}
-
 /**
  * Set a random interval that will call the callback function with a random delay between minDelay and maxDelay.
  *
@@ -4490,6 +3823,8 @@ export declare class StarFieldEffect extends Object3D {
     private readonly baseSize;
     private readonly baseScales?;
     private readonly twinklePhases?;
+    /** Untwinkled per-point RGB (points style), multiplied by each star's pulse each frame. */
+    private baseColors?;
     private spriteTexture?;
     private readonly dummy;
     constructor(options?: StarFieldEffectOptions);
@@ -4501,8 +3836,9 @@ export declare class StarFieldEffect extends Object3D {
     /**
      * Animate twinkling. No-op when `twinkle` is `false`.
      *
-     * Points style modulates sprite size; burst style pulses each instance scale with
-     * a per-star phase offset. Pass elapsed time in seconds (defaults to `performance.now()`).
+     * Both styles pulse with a per-star phase offset so stars twinkle out of sync:
+     * points modulate per-point brightness (via the color attribute), burst pulses
+     * each instance scale. Pass elapsed time in seconds (defaults to `performance.now()`).
      */
     update(elapsed?: number): void;
     private createPointsField;
@@ -4604,6 +3940,130 @@ export declare interface StoneFencePostOptions extends StoneFencePostGeometryOpt
     color?: ColorRepresentation;
 }
 
+/**
+ * Rounded terrain mound prefab — a {@link TerrainMoundGeometry} with a matte,
+ * flat-shaded material. Base sits on Y=0; drop it into a scene as a diorama
+ * ground or a small rise. Casts and receives shadows.
+ */
+export declare class TerrainMound extends Mesh<TerrainMoundGeometry, MeshStandardMaterial> {
+    readonly radius: number;
+    readonly height: number;
+    constructor({ color, flatShading, ...geometryOptions }?: TerrainMoundOptions);
+}
+
+/**
+ * Rounded terrain cap — a circular disc bulged into a gentle dome, then broken up
+ * with coherent fbm noise so it reads as rolling terrain rather than a smooth lens.
+ * The relief tapers to a clean circular rim seated on the Y=0 plane.
+ *
+ * Displacement is baked into real vertices (no shader), so shadows, raycasts, and
+ * any physics collider derived from the mesh match exactly what's drawn — and it
+ * renders identically on WebGL and WebGPU/TSL. Pair with a `flatShading` material
+ * for a faceted low-poly look; the coherent noise keeps neighboring vertices moving
+ * together, so faces never tear.
+ *
+ * Local frame: base on Y=0, peak toward +Y, centered on the origin.
+ */
+export declare class TerrainMoundGeometry extends BufferGeometry {
+    readonly radius: number;
+    readonly height: number;
+    constructor({ radius, height, radialSegments, angularSegments, noiseHeight, noiseScale, octaves, persistence, rim, seed, }?: TerrainMoundGeometryOptions);
+}
+
+export declare interface TerrainMoundGeometryOptions {
+    /** Footprint radius (world units). Defaults to `8`. */
+    radius?: number;
+    /** Dome peak height at the center. Defaults to `1.2`. */
+    height?: number;
+    /** Concentric rings from center to rim. Defaults to `40`. */
+    radialSegments?: number;
+    /** Segments around the circumference. Defaults to `64`. */
+    angularSegments?: number;
+    /** Amplitude of the terrain relief added on top of the dome. Defaults to `0.5`. */
+    noiseHeight?: number;
+    /** Noise frequency — higher packs more, smaller bumps into the footprint. Defaults to `0.35`. */
+    noiseScale?: number;
+    /** fbm octaves (detail layers). Defaults to `4`. */
+    octaves?: number;
+    /** fbm gain per octave (0–1); lower is smoother, higher is rougher. Defaults to `0.5`. */
+    persistence?: number;
+    /** Normalized radius (0–1) where the rim begins fading relief to a flat edge. Defaults to `0.82`. */
+    rim?: number;
+    /** Seed for reproducible terrain. Defaults to `1`. */
+    seed?: number;
+}
+
+export declare interface TerrainMoundOptions extends TerrainMoundGeometryOptions {
+    /** Surface tint. Defaults to `#3a5a3a`. */
+    color?: ColorRepresentation;
+    /** Faceted low-poly shading. Defaults to `true`. */
+    flatShading?: boolean;
+}
+
+/**
+ * Rectangular terrain patch prefab — a {@link TerrainPlaneGeometry} with a matte,
+ * flat-shaded material. Base grid on Y=0; drop it into a scene as a diorama ground
+ * or a tileable terrain field. Casts and receives shadows.
+ */
+export declare class TerrainPlane extends Mesh<TerrainPlaneGeometry, MeshStandardMaterial> {
+    readonly width: number;
+    readonly depth: number;
+    constructor({ color, flatShading, ...geometryOptions }?: TerrainPlaneOptions);
+}
+
+/**
+ * Rectangular terrain patch — a flat grid displaced on Y by the shared coherent fbm
+ * sampler ({@link fbm2}). The rectangular counterpart to {@link TerrainMoundGeometry}:
+ * same noise strategy, grid layout instead of a radial disc.
+ *
+ * A pure heightfield (Y is single-valued per XZ) so faces can never fold, and it's
+ * baked into real vertices — shadows, raycasts, and physics colliders match what's
+ * drawn, on WebGL and WebGPU/TSL alike. Pair with a `flatShading` material for a
+ * faceted low-poly look. Leave `edgeFalloff` at `0` for a tileable field; raise it to
+ * seat the edges flat at Y=0.
+ *
+ * Local frame: base grid on Y=0, relief toward ±Y, centered on the origin.
+ */
+export declare class TerrainPlaneGeometry extends BufferGeometry {
+    readonly width: number;
+    readonly depth: number;
+    constructor({ width, depth, widthSegments, depthSegments, noiseHeight, noiseScale, octaves, persistence, edgeFalloff, seed, }?: TerrainPlaneGeometryOptions);
+}
+
+export declare interface TerrainPlaneGeometryOptions {
+    /** Extent along X (world units). Defaults to `16`. */
+    width?: number;
+    /** Extent along Z (world units). Defaults to `16`. */
+    depth?: number;
+    /** Grid segments along X. Defaults to `48`. */
+    widthSegments?: number;
+    /** Grid segments along Z. Defaults to `48`. */
+    depthSegments?: number;
+    /** Amplitude of the terrain relief (world units, ±). Defaults to `0.8`. */
+    noiseHeight?: number;
+    /** Noise frequency — higher packs more, smaller features into the footprint. Defaults to `0.35`. */
+    noiseScale?: number;
+    /** fbm octaves (detail layers). Defaults to `4`. */
+    octaves?: number;
+    /** fbm gain per octave (0–1); lower is smoother, higher is rougher. Defaults to `0.5`. */
+    persistence?: number;
+    /**
+     * Border band (0–1 fraction of the half-extent) over which relief fades to a flat
+     * edge at Y=0. `0` leaves a raw, seamless heightfield (tileable); higher values
+     * seat the slab like a contained diorama patch. Defaults to `0`.
+     */
+    edgeFalloff?: number;
+    /** Seed for reproducible terrain. Defaults to `1`. */
+    seed?: number;
+}
+
+export declare interface TerrainPlaneOptions extends TerrainPlaneGeometryOptions {
+    /** Surface tint. Defaults to `#3a5a3a`. */
+    color?: ColorRepresentation;
+    /** Faceted low-poly shading. Defaults to `true`. */
+    flatShading?: boolean;
+}
+
 /**
  * Material indices
  * 0: Base
@@ -4725,20 +4185,6 @@ export declare interface TreeOptions extends TreeGeometryOptions {
  */
 export declare const twistBrush: <T extends BufferGeometry>(geometry: T, position: Vector3, radius: number, strength: number, direction?: Vector3, falloffFn?: (distance: number, radius: number) => number) => void;
 
-/**
- * Updates the time uniform of the material's shader to animate the noise effect.
- * @param {Material} material - The material to update.
- * @param {number} deltaTime - The time increment to add.
- */
-export declare function updateNoiseDisplacementTime<T extends Material>(material: T, deltaTime: number): void;
-
-/**
- * Updates the time uniform of the material's shader to animate the water effect.
- * @param {Material} material - The material to update.
- * @param {number} deltaTime - The time increment to add.
- */
-export declare function updateWaterDisplacementTime<T extends Material>(material: T, deltaTime: number): void;
-
 /**
  * Wall-mounted oil-lamp sconce — iron mount and cap/bowl frame around an
  * emissive glass chimney. Pair {@link GlowHalo} and {@link FlameFlickerEffect}