three-low-poly 0.9.21 → 0.9.22

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';
@@ -22,6 +23,45 @@ 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.
@@ -464,6 +504,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 +580,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 +592,7 @@ export declare function cameraDollyAnimation(camera: Camera, distance: number, d
  *
  * Example:
  * ```
- * flythroughAnimation(
+ * cameraFlythroughAnimation(
  *   camera,
  *   [
  *     new THREE.Vector3(0, 5, 5),
@@ -561,7 +613,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 +625,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,7 +637,7 @@ 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");
  * });
  * ```
@@ -597,7 +649,7 @@ export declare function cameraSpiralAscensionAnimation(camera: Camera, center: V
  *
  * Example:
  * ```
- * wobbleAnimation(camera, 0.5, 1000, () => {
+ * cameraWobbleAnimation(camera, 0.5, 1000, () => {
  *   console.log("Wobble animation complete");
  * });
  * ```
@@ -610,7 +662,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");
  * });
  * ```
@@ -858,24 +910,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
@@ -1432,6 +1503,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);
 }
 
@@ -1450,6 +1535,19 @@ export declare class GearShape extends Shape {
 export declare function getAnalogousColors(baseHue: number): [number, number, 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 +1555,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 +1580,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];
 
 /**
@@ -2299,6 +2424,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);
 }