three-low-poly 0.9.28 → 1.0.1

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,15 @@ 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 +217,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 +344,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();
 }
@@ -738,9 +543,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();
 }
@@ -914,87 +716,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).
  */
@@ -1328,12 +1049,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;
 
@@ -1440,9 +1155,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
  *
@@ -1476,22 +1188,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.
  */
@@ -1568,45 +1264,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.
  *
@@ -2164,49 +1821,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;
@@ -2404,10 +2018,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
@@ -3136,65 +2746,11 @@ export declare interface MossyRockOptions extends MossyRockGeometryOptions {
  */
 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];
 
 /**
@@ -3714,9 +3270,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;
 
 /**
@@ -3731,84 +3284,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.
  */
@@ -3996,256 +3471,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.
  *
@@ -4538,11 +3763,11 @@ export declare class Star extends Mesh<StarGeometry, MeshStandardMaterial> {
 }
 
 export declare interface StarBurstShapeOptions {
-    /** Burst ray count. Defaults to `4`. */
+    /** Burst ray count. Defaults to `4` point diffraction spike. */
     sides?: number;
     innerRadius?: number;
     outerRadius?: number;
-    /** Extrusion depth; keep small for flat starbursts. Defaults to `0.05`. */
+    /** Extrusion depth (`orientation: "radial"` only — billboards are flat). Defaults to `0.05`. */
     depth?: number;
 }
 
@@ -4554,27 +3779,27 @@ export declare interface StarBurstShapeOptions {
  * every frame. Parenting to the camera is not supported: Three.js does not render
  * objects attached to the active camera.
  *
- * **Styles**
+ * **Orientation** — the only axis that distinguishes how stars are drawn:
+ *
+ * - `billboard` — screen-aligned via `SpriteNodeMaterial`, with per-star position, scale,
+ *   and rotation supplied as instanced attributes. The field stays visually fixed as the
+ *   camera orbits. Flat by construction: only the geometry's XY profile is used.
+ * - `radial` — instanced 3D meshes rotated to face the shell center, drawn `DoubleSide` so
+ *   stars stay visible from inside the shell.
  *
- * - `points` — lightweight `Points` sprites using a canvas starburst texture.
- * - `burst` — instanced 3D starbursts ({@link BurstGeometry}) that face the shell center.
- *   Uses `DoubleSide` so stars remain visible when the camera sits inside the shell.
+ * Both orientations render as a single instanced draw call, so the geometry you pass is a
+ * matter of looks rather than cost.
  *
  * **Sizing** — `sizeMin` / `sizeMax` are angular extents (radians at unit distance),
  * multiplied by each star's distance from the origin so stars look similar regardless
  * of shell depth (`minRadius`–`maxRadius`).
  *
- * **Rendering** — `frustumCulled` is disabled and materials use `depthWrite: false` so
- * the field draws reliably as a background layer. For per-star color variation in burst
- * mode, colors are written via `InstancedMesh.setColorAt`, not `vertexColors` on the
- * base material.
- *
  * @example
  * ```typescript
  * const stars = new StarFieldEffect({
- *   style: "burst",
  *   count: 2500,
  *   radius: 480,
+ *   rotationJitter: 0, // every burst locked vertical on screen
  *   twinkle: true,
  * });
  *
@@ -4587,52 +3812,61 @@ export declare interface StarBurstShapeOptions {
  * }
  * ```
  *
- * Call {@link dispose} when removing the effect to free geometry, materials, and the
- * points sprite texture.
+ * Call {@link dispose} when removing the effect to free geometry and materials.
  */
 export declare class StarFieldEffect extends Object3D {
-    readonly style: "points" | "burst";
+    readonly orientation: StarFieldOrientation;
     private readonly field;
     private readonly twinkle;
-    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?;
+    /** Billboard scale attribute, rewritten each frame while twinkling. */
+    private scaleAttribute?;
     private readonly dummy;
     constructor(options?: StarFieldEffectOptions);
-    get drawable(): Points | InstancedMesh;
+    get mesh(): InstancedMesh;
     get geometry(): BufferGeometry;
     get material(): Material | Material[];
-    /** Release GPU resources held by the field (and sprite texture, if any). */
+    /** Release GPU resources held by the field. */
     dispose(): void;
     /**
      * Animate twinkling. No-op when `twinkle` is `false`.
      *
-     * 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()`).
+     * Each star pulses on its own phase offset so the field twinkles out of sync. Billboards
+     * rewrite the instanced scale attribute; radial stars rebuild each instance matrix.
+     * Pass elapsed time in seconds (defaults to `performance.now()`).
      */
     update(elapsed?: number): void;
-    private createPointsField;
-    private createBurstField;
+    /**
+     * Screen-aligned stars. `SpriteNodeMaterial` builds its quad from the geometry's XY and
+     * reads the sprite center from `positionNode` — it never consults `instanceMatrix` — so
+     * every per-star value has to arrive as an instanced attribute.
+     */
+    private createBillboardField;
+    /** Full 3D stars rotated to face the shell center. */
+    private createRadialField;
 }
 
 export declare interface StarFieldEffectOptions {
     /**
-     * Rendering style.
+     * How each star faces the viewer.
      *
-     * - `points` (default) — billboard sprites with a procedural starburst texture
-     *   (not the default square `Points` marker).
-     * - `burst` — instanced {@link BurstGeometry} meshes oriented toward the shell center.
+     * - `billboard` (default) — every star is screen-aligned, so the field holds its
+     *   orientation as the camera orbits. Only the geometry's **XY profile** is drawn;
+     *   any Z extent is ignored.
+     * - `radial` — full 3D geometry rotated to face the shell center. Depth is real here,
+     *   and stars shear as the camera moves, the way any world-space mesh does.
      */
-    style?: "points" | "burst";
-    /** Shape parameters for both styles; `burst` uses them for geometry, `points` for the sprite. */
+    orientation?: StarFieldOrientation;
+    /** Star shape used to build the default {@link BurstGeometry}. */
     burst?: StarBurstShapeOptions;
-    /** Override the burst mesh geometry (`style: "burst"` only). */
+    /** Replace the star geometry entirely. Billboards use its XY profile; radial uses all of it. */
     geometry?: BufferGeometry;
-    /** Override the default field material. */
+    /**
+     * Override the default field material. In `billboard` mode this must be a
+     * `SpriteNodeMaterial` — per-star position, scale, and rotation are assigned onto it
+     * as node inputs.
+     */
     material?: Material;
     /** Number of stars. Defaults to `1500`. */
     count?: number;
@@ -4653,8 +3887,26 @@ export declare interface StarFieldEffectOptions {
     color?: ColorRepresentation | ColorRepresentation[];
     /** Enable pulsing brightness; call {@link StarFieldEffect.update} each frame when `true`. */
     twinkle?: boolean;
+    /**
+     * Base star rotation, in radians. Defaults to `0`.
+     *
+     * Measured in screen space for `billboard` and world space for `radial` — the same knob
+     * means different things, because a billboard re-aligns every frame and a radial star
+     * does not.
+     */
+    rotation?: number;
+    /**
+     * Random rotation spread added per star, in radians. Defaults to `Math.PI * 2`.
+     *
+     * `0` aligns every star — with `billboard` that yields a coherent diffraction-spike field
+     * that stays locked as the camera orbits. `2π` is fully random.
+     */
+    rotationJitter?: number;
 }
 
+/** How each star is turned to face the viewer. */
+export declare type StarFieldOrientation = "billboard" | "radial";
+
 /**
  * Extruded star prism.
  */
@@ -4959,20 +4211,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}