three-low-poly 0.9.22 → 0.9.23

package/dist/index.d.ts

@@ -19,6 +19,7 @@ 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';
@@ -390,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();
 }
@@ -644,6 +654,87 @@ export declare function cameraPendulumAnimation(camera: Camera, center: Vector3,
  */
 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).
  *
@@ -775,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;
@@ -1087,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
@@ -1310,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();
 }
@@ -1420,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: {
@@ -1441,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;
@@ -1534,6 +1677,10 @@ 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;
@@ -2189,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.
@@ -2305,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.
  *
@@ -2331,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.