three-low-poly 0.9.13 → 0.9.14

package/dist/index.d.ts

@@ -1,11 +1,13 @@
 import { BoxGeometry } from 'three';
 import { BufferGeometry } from 'three';
+import { Camera } from 'three';
 import { Color } from 'three';
 import { DataTexture } from 'three';
 import { Group } from 'three';
 import { InstancedMesh } from 'three';
 import { Material } from 'three';
 import { Mesh } from 'three';
+import { PerspectiveCamera } from 'three';
 import { ShaderMaterial } from 'three';
 import { Shape } from 'three';
 import { SphereGeometry } from 'three';
@@ -212,23 +214,31 @@ export declare class Bottle extends Group {
     constructor();
 }
 
-/**
- * Bubbling class creates a group of small, semi-transparent bubbles that
- * rise upwards in a loop, mimicking bubbling inside a flask.
- */
-export declare class Bubbling extends Group {
-    private bubbles;
-    private bubbleCount;
-    constructor();
+export declare class BubblingEffect extends InstancedMesh {
+    private bubblePositions;
+    private velocities;
+    private width;
+    private height;
+    private depth;
+    constructor(options?: BubblingEffectOptions);
     /**
-     * Updates bubble positions, moving them upward and resetting them
-     * to the bottom if they reach the top.
+     * Updates the position of a specific bubble instance in the InstancedMesh.
      */
-    private updateBubbles;
+    private updateInstanceMatrix;
     /**
-     * Animates the bubbles by updating their positions in a loop.
+     * Updates bubble positions, moving them upward and resetting them
+     * to the bottom if they reach the top.
      */
-    private animateBubbles;
+    update(): void;
+}
+
+export declare interface BubblingEffectOptions {
+    geometry?: BufferGeometry;
+    material?: Material;
+    count?: number;
+    height?: number;
+    width?: number;
+    depth?: number;
 }
 
 export declare class BunsenBurner extends Group {
@@ -614,6 +624,18 @@ export declare const Direction: {
  */
 export declare const displacementBrush: <T extends BufferGeometry>(geometry: T, position: Vector3, radius: number, strength: number, direction?: Vector3, falloffFn?: (distance: number, radius: number) => number) => void;
 
+/**
+ * Dolly backward
+ *
+ * Example:
+ * ```
+ * dollyAnimation(camera, 5, 3000, () => {
+ *   console.log("Dolly animation complete");
+ * });
+ * ```
+ */
+export declare function dollyAnimation(camera: Camera, distance: number, duration: number, onComplete?: () => void): void;
+
 /**
  * Easing functions for interpolating values over time.
  */
@@ -653,6 +675,10 @@ export declare class ElectricPanel extends Group {
     constructor();
 }
 
+export declare class EllipticLeafGeometry extends BufferGeometry {
+    constructor(size?: number);
+}
+
 export declare class ErlenmeyerFlask extends Mesh {
     constructor({ flaskRadius, //
         neckRadius, height, neckHeight, radialSegments, }?: {
@@ -733,6 +759,27 @@ export declare class Flask extends Group {
  */
 export declare const flattenBrush: <T extends BufferGeometry>(geometry: T, position: Vector3, radius: number, targetHeight: number, strength: number, direction?: Vector3, falloffFn?: (distance: number, radius: number) => number) => void;
 
+/**
+ * The camera flies through a sequence of points, ideal for showcasing specific elements in the scene.
+ *
+ * Example:
+ * ```
+ * flythroughAnimation(
+ *   camera,
+ *   [
+ *     new THREE.Vector3(0, 5, 5),
+ *     new THREE.Vector3(0, 5, -25.5),
+ *     new THREE.Vector3(-20.5, 5, 0),
+ *   ],
+ *   6000,
+ *   () => {
+ *     console.log("Flythrough animation complete");
+ *   }
+ * );
+ * ```
+ */
+export declare function flythroughAnimation(camera: Camera, waypoints: Vector3[], duration: number, onComplete?: () => void): void;
+
 export declare const gaussian: (t: number) => number;
 
 export declare class Gear extends Mesh {
@@ -795,6 +842,25 @@ export declare class Lantern extends Group {
     constructor(height?: number, baseWidth?: number);
 }
 
+export declare class LeafEffect extends InstancedMesh {
+    private dummyMatrix;
+    private velocities;
+    private width;
+    private height;
+    private depth;
+    constructor(options?: LeafEffectOptions);
+    update(): void;
+}
+
+export declare interface LeafEffectOptions {
+    geometry?: BufferGeometry;
+    material?: Material;
+    count?: number;
+    width?: number;
+    height?: number;
+    depth?: number;
+}
+
 export declare class LeverPanel extends Group {
     constructor();
 }
@@ -987,6 +1053,18 @@ declare interface ObeliskHeadstoneOptions {
     totalHeight?: number;
 }
 
+/**
+ * Orbit around a target
+ *
+ * Example:
+ * ```
+ * orbitAnimation(camera, new THREE.Vector3(0, 0, 0), 10, 5000, () => {
+ *   console.log("Orbit animation complete");
+ * });
+ * ```
+ */
+export declare function orbitAnimation(camera: Camera, target: Vector3, radius: number, duration: number, onComplete?: () => void): void;
+
 export declare const parabolicCurve: (t: number, a?: number, b?: number, c?: number) => number;
 
 export declare const ParametricCurve: {
@@ -1010,6 +1088,18 @@ export declare const ParametricCurveUtils: {
     createSigmoidCurvePoints: (start: Vector2, end: Vector2, a: number, segments?: number) => Vector2[];
 };
 
+/**
+ * The camera swings back and forth like a pendulum.
+ *
+ * Example:
+ * ```
+ * pendulumAnimation(camera, new THREE.Vector3(0, 5, 5), 0.5, 9000, 3, () => {
+ *   console.log("Pendulum animation complete");
+ * });
+ * ```
+ */
+export declare function pendulumAnimation(camera: Camera, center: Vector3, radius: number, duration: number, oscillations: number, onComplete?: () => void): void;
+
 export declare const quadraticCurve: (t: number, p0: number, p1: number, p2: number) => number;
 
 export declare const quadraticEaseIn: (t: number) => number;
@@ -1110,10 +1200,6 @@ declare interface RowOfBooksOptions<T extends Material = Material> {
 
 export declare const sigmoidCurve: (t: number, a?: number) => number;
 
-export declare class SimpleLeafGeometry extends BufferGeometry {
-    constructor(size?: number);
-}
-
 export declare const sineEaseIn: (t: number) => number;
 
 export declare const sineEaseInOut: (t: number) => number;
@@ -1145,6 +1231,18 @@ export declare const sphericalToCartesian: (radius: number, theta: number, phi:
  */
 export declare const spikeBrush: <T extends BufferGeometry>(geometry: T, position: Vector3, radius: number, strength: number, inward?: boolean, falloffFn?: (distance: number, radius: number) => number) => void;
 
+/**
+ * The camera spirals upward, perfect for revealing a large scene or structure.
+ *
+ * Example:
+ * ```
+ * spiralAscensionAnimation(camera, new THREE.Vector3(0, 0, 0), 10, 300, 7, 12000, () => {
+ *   console.log("Spiral ascension animation complete");
+ * });
+ * ```
+ */
+export declare function spiralAscensionAnimation(camera: Camera, center: Vector3, radius: number, height: number, revolutions: number, duration: number, onComplete?: () => void): void;
+
 export declare class SpiralStaircaseGeometry extends BufferGeometry {
     constructor(stepWidth?: number, stepDepth?: number, stepHeight?: number, numSteps?: number, radius?: number, angleIncrement?: number);
 }
@@ -1296,6 +1394,18 @@ export declare class WineBottleGeometry extends BufferGeometry {
     });
 }
 
+/**
+ * Add a slight random wobble for intensity or realism (e.g., during an explosion).
+ *
+ * Example:
+ * ```
+ * wobbleAnimation(camera, 0.5, 1000, () => {
+ *   console.log("Wobble animation complete");
+ * });
+ * ```
+ */
+export declare function wobbleAnimation(camera: Camera, intensity: number, duration: number, onComplete?: () => void): void;
+
 export declare class WroughtIronBar extends Mesh {
     constructor({ barHeight, //
         barRadius, spikeHeight, spikeRadius, spikeScaleZ, radialSegments, }?: {
@@ -1357,4 +1467,17 @@ export declare class WroughtIronFenceGeometry extends BufferGeometry {
     });
 }
 
+/**
+ * The camera smoothly zooms in toward a target, focusing attention on a specific point,
+ * and resets to its original FOV after completion.
+ *
+ * Example:
+ * ```
+ * zoomInAnimation(camera, new THREE.Vector3(0, 0, 0), 120, 75, 2000, () => {
+ *   console.log("Zoom in animation complete");
+ * });
+ * ```
+ */
+export declare function zoomInAnimation(camera: PerspectiveCamera, target: Vector3, startFov: number, endFov: number, duration: number, onComplete?: () => void): void;
+
 export { }