three-low-poly 0.9.19 → 0.9.21

package/dist/index.d.ts

@@ -12,6 +12,7 @@ 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';
@@ -46,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.
@@ -391,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;
@@ -635,34 +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 function centerInstancedMesh<T extends InstancedMesh>(mesh: T): 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.
- */
-export declare function centerMesh<T extends Mesh>(mesh: T): void;
+export declare const Center: {
+    object: typeof centerObject;
+    objectGeometry: typeof centerObjectGeometry;
+    meshGeometry: typeof centerMeshGeometry;
+};
 
 /**
- * Centers a Mesh at the specified target position.
+ * 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 centerMeshAtTarget<T extends Mesh>(mesh: T, target?: Vector3): void;
+export declare function centerMeshGeometry<T extends Mesh>(mesh: T, target?: Vector3, offset?: Vector3): void;
 
 /**
- * Centers the geometry of the 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 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 centerMeshGeometry<T extends Mesh>(mesh: T): void;
+export declare function centerObject<T extends Object3D>(object: T, target?: Vector3, offset?: Vector3): void;
 
 /**
- * Centers the geometry of a Mesh at the specified target position.
+ * 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 centerMeshGeometryAtTarget<T extends Mesh>(mesh: T, target?: Vector3): void;
+export declare function centerObjectGeometry<T extends Object3D>(object: T, target?: Vector3, offset?: Vector3): void;
 
 /**
  * Create a checkerboard texture
@@ -687,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;
@@ -708,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;
@@ -808,6 +858,25 @@ 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.
+ *
+ * Example usage:
+ * ```ts
+ *     const hexTile = createHexagonalTile({
+ *       width: 10,
+ *       depth: 10,
+ *       height: 0.01,
+ *       radius: 0.1,
+ *       gap: 0.01,
+ *       material: new THREE.MeshStandardMaterial({ color: ColorPalette.White }),
+ *     });
+ *
+ *     scene.add(hexTile);
+ * ```
+ */
+export declare function createHexagonalTile(options: HexagonalTileOptions): InstancedMesh;
+
 /**
  * Function to create logarithmic curve points
  *
@@ -1051,8 +1120,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;
+    });
 }
 
 /**
@@ -1285,6 +1387,17 @@ export declare function findClosestColor(inputColor: number, dataset: number[]):
 
 export declare function findClosestColorChannelWise(inputColor: number, dataset: number[]): number | null;
 
+/**
+ * Get the closest point on a mesh to a specified point.
+ *
+ * Example usage:
+ * ```ts
+ * const point = new Vector3(5, 2, 1); // The point to check against the mesh
+ * const closestPoint = getClosestPointOnMesh(point, targetMesh);
+ * ```
+ */
+export declare function findClosestPoint(point: Vector3, mesh: Mesh): Vector3;
+
 export declare class Flame extends Mesh<FlameGeometry, MeshStandardMaterial> {
     constructor({ height, radius, segmentsU, segmentsV }?: {
         height?: number | undefined;
@@ -1344,6 +1457,15 @@ export declare class HeartShape extends Shape {
     constructor(size?: number, width?: number, height?: number, tipDepth?: number);
 }
 
+export declare interface HexagonalTileOptions {
+    width: number;
+    depth: number;
+    height: number;
+    radius: number;
+    gap: number;
+    material?: Material;
+}
+
 export declare function hexToHsl(hex: number): [number, number, number];
 
 /**
@@ -1851,6 +1973,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;