three-low-poly 0.9.21 → 0.9.23

package/dist/index.d.ts

@@ -3,6 +3,7 @@ import { BufferGeometry } from 'three';
 import { Camera } from 'three';
 import { Color } from 'three';
 import { DataTexture } from 'three';
+import { ExtrudeGeometry } from 'three';
 import { Group } from 'three';
 import { InstancedMesh } from 'three';
 import { Light } from 'three';
@@ -18,10 +19,50 @@ import { PerspectiveCamera } from 'three';
 import { ShaderMaterial } from 'three';
 import { Shape } 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;
+
 /**
  * Utility function to add noise-based vertex displacement to an existing Three.js material.
  * @param {Material} material - The material to mutate, e.g., MeshStandardMaterial.
@@ -350,6 +391,15 @@ export declare class BifurcatedStaircaseGeometry extends BufferGeometry {
     constructor(stepWidth?: number, stepHeight?: number, stepDepth?: number, numStepsCentral?: number, numStepsBranch?: number, branchAngle?: number);
 }
 
+declare interface BloomTransitionOptions extends SceneTransitionFXOptions {
+    maxBloom?: number;
+}
+
+declare interface BlurTransitionOptions extends SceneTransitionFXOptions {
+    maxBlur?: number;
+    kernelSize?: number;
+}
+
 export declare class Bone extends Mesh<BoneGeometry, MeshStandardMaterial> {
     constructor();
 }
@@ -464,6 +514,18 @@ export declare class BunsenBurner extends Group {
 }
 
 export declare class Burst extends Mesh {
+    constructor({ sides, innerRadius, outerRadius, depth }?: {
+        sides?: number | undefined;
+        innerRadius?: number | undefined;
+        outerRadius?: number | undefined;
+        depth?: number | undefined;
+    });
+}
+
+/**
+ * Extrude geometry of Burst Shape.
+ */
+export declare class BurstGeometry extends ExtrudeGeometry {
     constructor(sides?: number, innerRadius?: number, outerRadius?: number, depth?: number);
 }
 
@@ -528,7 +590,7 @@ export declare function calculateYFromSlopeIntercept(x1: number, y1: number, x2:
  *
  * Example:
  * ```
- * dollyAnimation(camera, 5, 3000, () => {
+ * cameraDollyAnimation(camera, 5, 3000, () => {
  *   console.log("Dolly animation complete");
  * });
  * ```
@@ -540,7 +602,7 @@ export declare function cameraDollyAnimation(camera: Camera, distance: number, d
  *
  * Example:
  * ```
- * flythroughAnimation(
+ * cameraFlythroughAnimation(
  *   camera,
  *   [
  *     new THREE.Vector3(0, 5, 5),
@@ -561,7 +623,7 @@ export declare function cameraFlythroughAnimation(camera: Camera, waypoints: Vec
  *
  * Example:
  * ```
- * orbitAnimation(camera, new THREE.Vector3(0, 0, 0), 10, 5000, () => {
+ * cameraOrbitAnimation(camera, new THREE.Vector3(0, 0, 0), 10, 5000, () => {
  *   console.log("Orbit animation complete");
  * });
  * ```
@@ -573,7 +635,7 @@ export declare function cameraOrbitAnimation(camera: Camera, target: Vector3, ra
  *
  * Example:
  * ```
- * pendulumAnimation(camera, new THREE.Vector3(0, 5, 5), 0.5, 9000, 3, () => {
+ * cameraPendulumAnimation(camera, new THREE.Vector3(0, 5, 5), 0.5, 9000, 3, () => {
  *   console.log("Pendulum animation complete");
  * });
  * ```
@@ -585,19 +647,100 @@ export declare function cameraPendulumAnimation(camera: Camera, center: Vector3,
  *
  * Example:
  * ```
- * spiralAscensionAnimation(camera, new THREE.Vector3(0, 0, 0), 10, 300, 7, 12000, () => {
+ * cameraSpiralAscensionAnimation(camera, new THREE.Vector3(0, 0, 0), 10, 300, 7, 12000, () => {
  *   console.log("Spiral ascension animation complete");
  * });
  * ```
  */
 export declare function cameraSpiralAscensionAnimation(camera: Camera, center: Vector3, radius: number, height: number, revolutions: number, duration: number, onComplete?: () => void): void;
 
+/**
+ * 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;
+}
+
 /**
  * Add a slight random wobble for intensity or realism (e.g., during an explosion).
  *
  * Example:
  * ```
- * wobbleAnimation(camera, 0.5, 1000, () => {
+ * cameraWobbleAnimation(camera, 0.5, 1000, () => {
  *   console.log("Wobble animation complete");
  * });
  * ```
@@ -610,7 +753,7 @@ export declare function cameraWobbleAnimation(camera: Camera, intensity: number,
  *
  * Example:
  * ```
- * zoomInAnimation(camera, new THREE.Vector3(0, 0, 0), 120, 75, 2000, () => {
+ * cameraZoomInAnimation(camera, new THREE.Vector3(0, 0, 0), 120, 75, 2000, () => {
  *   console.log("Zoom in animation complete");
  * });
  * ```
@@ -723,11 +866,11 @@ export declare function centerObjectGeometry<T extends Object3D>(object: T, targ
  */
 export declare const checkerboardTexture: (size: number) => DataTexture;
 
-export declare const circularEaseIn: (t: number) => number;
+export declare const circIn: (t: number) => number;
 
-export declare const circularEaseInOut: (t: number) => number;
+export declare const circInOut: (t: number) => number;
 
-export declare const circularEaseOut: (t: number) => number;
+export declare const circOut: (t: number) => number;
 
 export declare const ColorPalette: {
     CADMIUM_RED: number;
@@ -858,24 +1001,43 @@ export declare const createDampedCurvePoints: (start: Vector2, end: Vector2, dam
  */
 export declare const createExponentialCurvePoints: (start: Vector2, end: Vector2, base: number, factor: number, segments?: number) => Vector2[];
 
+/**
+ * Hexagonal tile pattern factory with density control.
+ *
+ * Example usage:
+ * ```ts
+ * const hexTile = createHexagonalTilesByCount({
+ *   width: 10,
+ *   depth: 10,
+ *   height: 0.01,
+ *   count: 10, // 10 tiles along the x-axis
+ *   gap: 0.01,
+ *   material: new THREE.MeshStandardMaterial({ color: 0xffffff }),
+ * });
+ *
+ * scene.add(hexTile);
+ * ```
+ */
+export declare function createHexagonalTilesByCount(options: HexagonalTileCountOptions): InstancedMesh;
+
 /**
  * Hexagonal tile pattern factory.
  *
  * Example usage:
  * ```ts
- *     const hexTile = createHexagonalTile({
+ *     const hexTile = createHexagonalTilesByRadius({
  *       width: 10,
  *       depth: 10,
  *       height: 0.01,
  *       radius: 0.1,
  *       gap: 0.01,
- *       material: new THREE.MeshStandardMaterial({ color: ColorPalette.White }),
+ *       material: new THREE.MeshStandardMaterial({ color: 0xffffff }),
  *     });
  *
  *     scene.add(hexTile);
  * ```
  */
-export declare function createHexagonalTile(options: HexagonalTileOptions): InstancedMesh;
+export declare function createHexagonalTilesByRadius(options: HexagonalTileRadiusOptions): InstancedMesh;
 
 /**
  * Function to create logarithmic curve points
@@ -1016,11 +1178,11 @@ declare interface CrossHeadstoneOptions {
 
 export declare const cubicCurve: (t: number, p0: number, p1: number, p2: number, p3: number) => number;
 
-export declare const cubicEaseIn: (t: number) => number;
+export declare const cubicIn: (t: number) => number;
 
-export declare const cubicEaseInOut: (t: number) => number;
+export declare const cubicInOut: (t: number) => number;
 
-export declare const cubicEaseOut: (t: number) => number;
+export declare const cubicOut: (t: number) => number;
 
 /**
  * Cubic UV Mapping
@@ -1239,39 +1401,83 @@ export declare const displacementBrush: <T extends BufferGeometry>(geometry: T,
 
 /**
  * Easing functions for interpolating values over time.
+ *
+ * Use these functions to create smooth animations and transitions.
+ * All easing functions take a value t between 0 and 1 and return an eased value between 0 and 1.
+ *
+ * @example
+ * ```typescript
+ * import { Easing, cubicInOut } from 'three-low-poly';
+ *
+ * // Using with transitions (namespace)
+ * cameraTransition.transitionTo(camera, {
+ *   duration: 1000,
+ *   easing: Easing.cubicInOut  // Function reference
+ * });
+ *
+ * // Or using direct import
+ * cameraTransition.transitionTo(camera, {
+ *   duration: 1000,
+ *   easing: cubicInOut  // Direct function reference
+ * });
+ *
+ * // Or using string reference
+ * cameraTransition.transitionTo(camera, {
+ *   duration: 1000,
+ *   easing: 'cubicInOut'  // String reference
+ * });
+ *
+ * // Using the function directly in custom animation
+ * const progress = 0.5;
+ * const easedValue = Easing.cubicInOut(progress);
+ *
+ * // Custom animation loop
+ * const startValue = 0;
+ * const endValue = 100;
+ * const t = elapsedTime / duration;
+ * const easedT = Easing.sineInOut(t);
+ * const currentValue = startValue + (endValue - startValue) * easedT;
+ * ```
  */
 export declare const Easing: {
-    SINE_EASE_IN: (t: number) => number;
-    SINE_EASE_OUT: (t: number) => number;
-    SINE_EASE_IN_OUT: (t: number) => number;
-    QUADRATIC_EASE_IN: (t: number) => number;
-    QUADRATIC_EASE_OUT: (t: number) => number;
-    QUADRATIC_EASE_IN_OUT: (t: number) => number;
-    CUBIC_EASE_IN: (t: number) => number;
-    CUBIC_EASE_OUT: (t: number) => number;
-    CUBIC_EASE_IN_OUT: (t: number) => number;
-    QUARTIC_EASE_IN: (t: number) => number;
-    QUARTIC_EASE_OUT: (t: number) => number;
-    QUARTIC_EASE_IN_OUT: (t: number) => number;
-    QUINTIC_EASE_IN: (t: number) => number;
-    QUINTIC_EASE_OUT: (t: number) => number;
-    QUINTIC_EASE_IN_OUT: (t: number) => number;
-    EXPONENTIAL_EASE_IN: (t: number) => number;
-    EXPONENTIAL_EASE_OUT: (t: number) => number;
-    EXPONENTIAL_EASE_IN_OUT: (t: number) => number;
-    CIRCULAR_EASE_IN: (t: number) => number;
-    CIRCULAR_EASE_OUT: (t: number) => number;
-    CIRCULAR_EASE_IN_OUT: (t: number) => number;
-    LINEAR: (t: number) => number;
-    SMOOTHSTEP: (t: number) => number;
-    CONCAVE: (t: number) => number;
-    CONVEX: (t: number) => number;
-    LOGARITHMIC: (t: number) => number;
-    SQUARE_ROOT: (t: number) => number;
-    INVERSE: (t: number) => number;
-    GAUSSIAN: (t: number) => number;
+    sineIn: (t: number) => number;
+    sineOut: (t: number) => number;
+    sineInOut: (t: number) => number;
+    quadIn: (t: number) => number;
+    quadOut: (t: number) => number;
+    quadInOut: (t: number) => number;
+    cubicIn: (t: number) => number;
+    cubicOut: (t: number) => number;
+    cubicInOut: (t: number) => number;
+    quartIn: (t: number) => number;
+    quartOut: (t: number) => number;
+    quartInOut: (t: number) => number;
+    quintIn: (t: number) => number;
+    quintOut: (t: number) => number;
+    quintInOut: (t: number) => number;
+    expoIn: (t: number) => number;
+    expoOut: (t: number) => number;
+    expoInOut: (t: number) => number;
+    circIn: (t: number) => number;
+    circOut: (t: number) => number;
+    circInOut: (t: number) => number;
+    linear: (t: number) => number;
+    smoothstep: (t: number) => number;
+    concave: (t: number) => number;
+    convex: (t: number) => number;
+    logarithmic: (t: number) => number;
+    squareRoot: (t: number) => number;
+    inverse: (t: number) => number;
+    gaussian: (t: number) => number;
 };
 
+/**
+ * Easing function type for interpolating values over time.
+ * @param t - Progress value between 0 and 1
+ * @returns Eased value between 0 and 1
+ */
+export declare type EasingFunction = (t: number) => number;
+
 export declare class ElectricPanel extends Group {
     constructor();
 }
@@ -1349,13 +1555,13 @@ export declare class ErlenmeyerFlaskGeometry extends BufferGeometry {
     });
 }
 
-export declare const exponentialCurve: (t: number, base?: number, factor?: number) => number;
+export declare const expoIn: (t: number) => number;
 
-export declare const exponentialEaseIn: (t: number) => number;
+export declare const expoInOut: (t: number) => number;
 
-export declare const exponentialEaseInOut: (t: number) => number;
+export declare const exponentialCurve: (t: number, base?: number, factor?: number) => number;
 
-export declare const exponentialEaseOut: (t: number) => number;
+export declare const expoOut: (t: number) => number;
 
 export declare const fadeShader: {
     uniforms: {
@@ -1370,6 +1576,14 @@ export declare const fadeShader: {
     fragmentShader: string;
 };
 
+declare interface FadeTransitionOptions extends SceneTransitionOptions {
+    color?: THREE.ColorRepresentation;
+}
+
+declare interface FadeTransitionOptions_2 extends SceneTransitionFXOptions {
+    color?: THREE.ColorRepresentation;
+}
+
 export declare const Falloff: {
     LINEAR: (distance: number, radius: number) => number;
     QUADRATIC: (distance: number, radius: number) => number;
@@ -1432,6 +1646,20 @@ export declare class FlorenceFlaskGeometry extends BufferGeometry {
 export declare const gaussian: (t: number) => number;
 
 export declare class Gear extends Mesh {
+    constructor({ sides, innerRadius, outerRadius, holeSides, holeRadius, depth }?: {
+        sides?: number | undefined;
+        innerRadius?: number | undefined;
+        outerRadius?: number | undefined;
+        holeSides?: number | undefined;
+        holeRadius?: number | undefined;
+        depth?: number | undefined;
+    });
+}
+
+/**
+ * Extrude geometry of Gear Shape.
+ */
+export declare class GearGeometry extends ExtrudeGeometry {
     constructor(sides?: number, innerRadius?: number, outerRadius?: number, holeSides?: number, holeRadius?: number, depth?: number);
 }
 
@@ -1449,7 +1677,24 @@ export declare class GearShape extends Shape {
  */
 export declare function getAnalogousColors(baseHue: number): [number, number, number];
 
+declare interface GlitchTransitionOptions extends SceneTransitionFXOptions {
+    maxIntensity?: number;
+}
+
 export declare class Heart extends Mesh {
+    constructor({ size, width, height, tipDepth, depth }?: {
+        size?: number | undefined;
+        width?: number | undefined;
+        height?: number | undefined;
+        tipDepth?: number | undefined;
+        depth?: number | undefined;
+    });
+}
+
+/**
+ * Extrude geometry of Heart Shape.
+ */
+export declare class HeartGeometry extends ExtrudeGeometry {
     constructor(size?: number, width?: number, height?: number, tipDepth?: number, depth?: number);
 }
 
@@ -1457,7 +1702,23 @@ export declare class HeartShape extends Shape {
     constructor(size?: number, width?: number, height?: number, tipDepth?: number);
 }
 
-export declare interface HexagonalTileOptions {
+export declare class Hexagon extends Mesh {
+    constructor({ radius, depth }?: {
+        radius?: number | undefined;
+        depth?: number | undefined;
+    });
+}
+
+export declare interface HexagonalTileCountOptions {
+    width: number;
+    depth: number;
+    height: number;
+    count: number;
+    gap: number;
+    material?: Material;
+}
+
+export declare interface HexagonalTileRadiusOptions {
     width: number;
     depth: number;
     height: number;
@@ -1466,6 +1727,17 @@ export declare interface HexagonalTileOptions {
     material?: Material;
 }
 
+/**
+ * Extrude geometry of Hexagon Shape.
+ */
+export declare class HexagonGeometry extends ExtrudeGeometry {
+    constructor(radius?: number, depth?: number);
+}
+
+export declare class HexagonShape extends Shape {
+    constructor(radius?: number);
+}
+
 export declare function hexToHsl(hex: number): [number, number, number];
 
 /**
@@ -2064,25 +2336,25 @@ export declare class PotionBottleGeometry extends BufferGeometry {
     constructor();
 }
 
-export declare const quadraticCurve: (t: number, p0: number, p1: number, p2: number) => number;
+export declare const quadIn: (t: number) => number;
 
-export declare const quadraticEaseIn: (t: number) => number;
+export declare const quadInOut: (t: number) => number;
 
-export declare const quadraticEaseInOut: (t: number) => number;
+export declare const quadOut: (t: number) => number;
 
-export declare const quadraticEaseOut: (t: number) => number;
+export declare const quadraticCurve: (t: number, p0: number, p1: number, p2: number) => number;
 
-export declare const quarticEaseIn: (t: number) => number;
+export declare const quartIn: (t: number) => number;
 
-export declare const quarticEaseInOut: (t: number) => number;
+export declare const quartInOut: (t: number) => number;
 
-export declare const quarticEaseOut: (t: number) => number;
+export declare const quartOut: (t: number) => number;
 
-export declare const quinticEaseIn: (t: number) => number;
+export declare const quintIn: (t: number) => number;
 
-export declare const quinticEaseInOut: (t: number) => number;
+export declare const quintInOut: (t: number) => number;
 
-export declare const quinticEaseOut: (t: number) => number;
+export declare const quintOut: (t: number) => number;
 
 /**
  * Calculate the radius to achieve a spherical cap height.
@@ -2180,6 +2452,239 @@ declare interface RowOfBooksOptions<T extends Material = Material> {
     scaleZMax?: number;
 }
 
+/**
+ * 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
+ *
+ * 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 sceneTransitionFX = new SceneTransitionFX(renderer, composer);
+ *
+ * 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);
+    /**
+     * 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.
  *
@@ -2206,11 +2711,11 @@ export declare function setRandomTimeout(callback: () => void, minDelay: number,
 
 export declare const sigmoidCurve: (t: number, a?: number) => number;
 
-export declare const sineEaseIn: (t: number) => number;
+export declare const sineIn: (t: number) => number;
 
-export declare const sineEaseInOut: (t: number) => number;
+export declare const sineInOut: (t: number) => number;
 
-export declare const sineEaseOut: (t: number) => number;
+export declare const sineOut: (t: number) => number;
 
 /**
  * Smooths out the vertices by averaging their positions with neighboring vertices within a given radius.
@@ -2299,6 +2804,18 @@ export declare class StandGeometry extends BufferGeometry {
 }
 
 export declare class Star extends Mesh {
+    constructor({ points, innerRadius, outerRadius, depth }?: {
+        points?: number | undefined;
+        innerRadius?: number | undefined;
+        outerRadius?: number | undefined;
+        depth?: number | undefined;
+    });
+}
+
+/**
+ * Extrude geometry of Star Shape.
+ */
+export declare class StarGeometry extends ExtrudeGeometry {
     constructor(points?: number, innerRadius?: number, outerRadius?: number, depth?: number);
 }