three-low-poly 0.9.18 → 0.9.20

package/dist/index.d.ts

@@ -12,6 +12,8 @@ import { MeshLambertMaterial } from 'three';
 import { MeshPhongMaterial } from 'three';
 import { MeshPhysicalMaterial } from 'three';
 import { MeshStandardMaterial } from 'three';
+import { Object3D } from 'three';
+import { ParametricGeometry } from 'three-stdlib';
 import { PerspectiveCamera } from 'three';
 import { ShaderMaterial } from 'three';
 import { Shape } from 'three';
@@ -45,6 +47,37 @@ export declare function addWaterDisplacement<T extends Material>(material: T, {
     waveAmplitude?: number | undefined;
 }): void;
 
+/**
+ * Align a BufferGeometry to a surface by adjusting its vertices.
+ */
+export declare function alignBufferGeometryToSurface(geometry: BufferGeometry, targetPositionY: number): void;
+
+/**
+ * Align a specific instance in an InstancedMesh to a surface.
+ */
+export declare function alignInstancedMeshIndexToSurface(instancedMesh: InstancedMesh, targetPosition: Vector3, instanceIndex: number, offset?: Vector3): void;
+
+/**
+ * Align an InstancedMesh to a surface.
+ */
+export declare function alignInstancedMeshToSurface(instancedMesh: InstancedMesh, targetPosition: Vector3, offset?: Vector3): void;
+
+/**
+ * Align an Object3D to a surface by adjusting its position.
+ */
+export declare function alignObjectToSurface(object: Object3D, targetPosition: Vector3, offset?: Vector3): void;
+
+/**
+ * Aligns an array of Object3D objects (or subclasses) to a specified side
+ * (left, right, top, bottom, front, or back) based on their world-space bounding boxes.
+ */
+export declare function alignToEdge<T extends Object3D>(objects: T[], side: BoxSide): void;
+
+/**
+ * Aligns an array of `Object3D` objects along a specified direction with optional spacing.
+ */
+export declare function alignToRow<T extends Object3D>(objects: T[], direction?: Vector3, spacing?: number): void;
+
 /**
  * Generates spherical curve profile points, for use with geometry.
  * Enables connective geometry via holes at the top and bottom of the sphere.
@@ -390,6 +423,15 @@ export declare class BookshelfGeometry extends BufferGeometry {
     });
 }
 
+export declare enum BoxSide {
+    LEFT = "left",
+    RIGHT = "right",
+    TOP = "top",
+    BOTTOM = "bottom",
+    FRONT = "front",
+    BACK = "back"
+}
+
 export declare class BubblingEffect extends InstancedMesh {
     private bubblePositions;
     private velocities;
@@ -575,14 +617,38 @@ export declare function cameraWobbleAnimation(camera: Camera, intensity: number,
  */
 export declare function cameraZoomInAnimation(camera: PerspectiveCamera, target: Vector3, startFov: number, endFov: number, duration: number, onComplete?: () => void): void;
 
-export declare class Candle extends Group {
-    private candle;
-    private flame;
-    private candleLight;
-    private height;
-    private radius;
-    constructor(height?: number, radius?: number);
-    animateFlicker(): void;
+/**
+ * Material indices
+ * 0: Stick
+ * 1: Flame
+ */
+export declare class Candle extends Mesh<CandleGeometry, MeshStandardMaterial[]> {
+    constructor({ radiusTop, //
+        radiusBottom, height, flameHeight, flameRadius, segments, }?: {
+        radiusTop?: number | undefined;
+        radiusBottom?: number | undefined;
+        height?: number | undefined;
+        flameHeight?: number | undefined;
+        flameRadius?: number | undefined;
+        segments?: number | undefined;
+    });
+}
+
+/**
+ * Group indices
+ * 0: Stick
+ * 1: Flame
+ */
+export declare class CandleGeometry extends BufferGeometry {
+    constructor({ radiusTop, //
+        radiusBottom, height, flameHeight, flameRadius, segments, }?: {
+        radiusTop?: number | undefined;
+        radiusBottom?: number | undefined;
+        height?: number | undefined;
+        flameHeight?: number | undefined;
+        flameRadius?: number | undefined;
+        segments?: number | undefined;
+    });
 }
 
 /**
@@ -610,24 +676,41 @@ export declare const cartesianToSpherical: (x: number, y: number, z: number) =>
     phi: number;
 };
 
-export declare function centerGroup<T extends Group>(group: T): void;
-
-export declare function centerGroupAtTarget<T extends Group>(group: T, target?: Vector3): void;
+export declare const Center: {
+    object: typeof centerObject;
+    objectGeometry: typeof centerObjectGeometry;
+    meshGeometry: typeof centerMeshGeometry;
+};
 
-export declare function centerInstancedMesh<T extends InstancedMesh>(mesh: T): void;
+/**
+ * Centers the geometry of a `Mesh` relative to a target position with an optional offset.
+ *
+ * This function calculates the bounding box center of the `Mesh` geometry and adjusts its
+ * position by translating the geometry such that it is centered at the specified target
+ * position, with an optional offset applied. The function modifies the geometry directly,
+ * leaving the `Mesh`'s transformation properties (`position`, `rotation`, `scale`) unchanged.
+ */
+export declare function centerMeshGeometry<T extends Mesh>(mesh: T, target?: Vector3, offset?: Vector3): void;
 
 /**
- * Centers the given mesh at the origin (0, 0, 0) of the scene by adjusting its position.
- * The mesh is moved so that its bounding box center is placed at the origin.
+ * Centers an `Object3D` relative to a specified target position with an optional offset.
+ *
+ * This function calculates the bounding box center of the given `Object3D` and adjusts
+ * its position so that it is centered at the specified target position, with an optional
+ * offset applied. The centering respects the object's current transformation, including
+ * its scale and rotation.
  */
-export declare function centerMesh<T extends Mesh>(mesh: T): void;
+export declare function centerObject<T extends Object3D>(object: T, target?: Vector3, offset?: Vector3): void;
 
 /**
- * Centers the geometry of the given mesh at the local origin (0, 0, 0) by modifying the geometry vertices.
- * This method moves the geometry itself so that its center is at the local origin,
- * without affecting the position, rotation, or scale of the mesh.
+ * Centers the geometry of an `Object3D` relative to a target position with an optional offset.
+ *
+ * This function calculates the bounding box center of the given `Object3D` and adjusts its
+ * geometry's position by translating it such that the geometry is centered at the specified
+ * target position, with an optional offset applied. Unlike modifying the `position` property,
+ * this function directly translates the geometry within the object's local space.
  */
-export declare function centerMeshGeometry<T extends Mesh>(mesh: T): void;
+export declare function centerObjectGeometry<T extends Object3D>(object: T, target?: Vector3, offset?: Vector3): void;
 
 /**
  * Create a checkerboard texture
@@ -652,8 +735,9 @@ export declare const ColorPalette: {
     CHERRY_RED: number;
     CRIMSON: number;
     ALIZARIN_CRIMSON: number;
-    RUST: number;
     DARK_RED: number;
+    RUST: number;
+    CORAL_ORANGE: number;
     TANGERINE: number;
     ORANGE_PEEL: number;
     CADMIUM_ORANGE: number;
@@ -673,6 +757,7 @@ export declare const ColorPalette: {
     MINT_GREEN: number;
     AQUAMARINE: number;
     PHTHALO_BLUE: number;
+    AETHER_BLUE: number;
     SKY_BLUE: number;
     CERULEAN_BLUE: number;
     AZURE: number;
@@ -1016,8 +1101,41 @@ export declare class DeskGeometry extends BufferGeometry {
     constructor();
 }
 
+/**
+ * A diorama with a floor and walls.
+ *
+ * Material indices:
+ * 0: Interior walls
+ * 1: Floor
+ * 2: Exterior walls
+ */
+export declare class Diorama extends Mesh<DioramaGeometry, MeshStandardMaterial[]> {
+    constructor({ width, height, depth, wallThickness, interiorColor, floorColor, exteriorColor, }?: {
+        width?: number | undefined;
+        height?: number | undefined;
+        depth?: number | undefined;
+        wallThickness?: number | undefined;
+        interiorColor?: number | undefined;
+        floorColor?: number | undefined;
+        exteriorColor?: number | undefined;
+    });
+}
+
+/**
+ * Geometry for a diorama with a floor and walls.
+ *
+ * Group indices:
+ * 0: Interior walls
+ * 1: Floor
+ * 2: Exterior walls
+ */
 export declare class DioramaGeometry extends BufferGeometry {
-    constructor(width?: number, height?: number, depth?: number, wallThickness?: number);
+    constructor({ width, height, depth, wallThickness }?: {
+        width?: number | undefined;
+        height?: number | undefined;
+        depth?: number | undefined;
+        wallThickness?: number | undefined;
+    });
 }
 
 /**
@@ -1250,6 +1368,24 @@ export declare function findClosestColor(inputColor: number, dataset: number[]):
 
 export declare function findClosestColorChannelWise(inputColor: number, dataset: number[]): number | null;
 
+export declare class Flame extends Mesh<FlameGeometry, MeshStandardMaterial> {
+    constructor({ height, radius, segmentsU, segmentsV }?: {
+        height?: number | undefined;
+        radius?: number | undefined;
+        segmentsU?: number | undefined;
+        segmentsV?: number | undefined;
+    });
+}
+
+export declare class FlameGeometry extends ParametricGeometry {
+    constructor({ height, radius, segmentsU, segmentsV }?: {
+        height?: number | undefined;
+        radius?: number | undefined;
+        segmentsU?: number | undefined;
+        segmentsV?: number | undefined;
+    });
+}
+
 /**
  * Flattens vertices to a given plane defined by a target height or normal direction.
  */
@@ -1398,6 +1534,65 @@ export declare class LeverPanel extends Group {
     constructor();
 }
 
+/**
+ * Create a light flicker animation that will randomly change the intensity and position of a light.
+ * Effect resembles a flickering flame of candlelight.
+ *
+ * Example usage:
+ * ```
+ *    // Create a candle
+ *    const candle = new Candle({
+ *      height: 1,
+ *      flameHeight: 0.25,
+ *    });
+ *    scene.add(candle);
+ *
+ *    // Create a point light
+ *    const candleLight = new THREE.PointLight(0xffa500, 1, 5);
+ *    scene.add(candleLight);
+ *
+ *    // Apply the animator to the light
+ *    const lightAnimation = new LightFlickerAnimation({
+ *      light: candleLight,
+ *      maxIntensity: 2.2,
+ *      x: candle.position.x,
+ *      y: candle.position.y + 1 + 0.125, // height + half flame height
+ *      z: candle.position.z,
+ *    });
+ *    animations.push(lightAnimation);
+ *
+ *    // Update the light animation in the render loop
+ *    renderer.setAnimationLoop(() => {
+ *      lightAnimation.update();
+ *    });
+ * ```
+ */
+export declare class LightFlickerAnimation {
+    private light?;
+    minIntensity: number;
+    maxIntensity: number;
+    x: number;
+    y: number;
+    z: number;
+    jitterX: number;
+    jitterY: number;
+    jitterZ: number;
+    constructor({ light, minIntensity, maxIntensity, x, y, z, jitterX, jitterY, jitterZ, }?: Partial<LightFlickerAnimationOptions>);
+    update(): void;
+}
+
+export declare interface LightFlickerAnimationOptions {
+    light?: Light;
+    minIntensity: number;
+    maxIntensity: number;
+    x: number;
+    y: number;
+    z: number;
+    jitterX: number;
+    jitterY: number;
+    jitterZ: number;
+}
+
 /**
  * A lightning animation that can be used to simulate a lightning storm.
  * This effect is applied to a light source.
@@ -1739,6 +1934,13 @@ export declare interface PanelOptions {
 
 export declare const parabolicCurve: (t: number, a?: number, b?: number, c?: number) => number;
 
+/**
+ * Prismatic parallelogram, with horizontal skew (offset in X for the slant).
+ */
+export declare class ParallelogramBoxGeometry extends BufferGeometry {
+    constructor(width?: number, height?: number, depth?: number, angle?: number);
+}
+
 export declare const ParametricCurve: {
     CUBIC: (t: number, p0: number, p1: number, p2: number, p3: number) => number;
     DAMPED: (t: number, damping?: number) => number;