three-low-poly 0.9.16 → 0.9.18

package/dist/index.d.ts

@@ -45,6 +45,48 @@ export declare function addWaterDisplacement<T extends Material>(material: T, {
     waveAmplitude?: number | undefined;
 }): void;
 
+/**
+ * Generates spherical curve profile points, for use with geometry.
+ * Enables connective geometry via holes at the top and bottom of the sphere.
+ *
+ * Example usage:
+ *
+ * Tube that connect with a sphere on the bottom:
+ * ```
+ *    const points: Vector2[] = [
+ *       new Vector2(1, 0),
+ *       ...appendSphericalCurve(
+ *         2,  // Radius x
+ *         2,  // Radius y
+ *         5,  // Start y
+ *         0,  // Hole top radius
+ *         1,  // Hole bottom radius
+ *         32, // Segments
+ *       ),
+ *     ];
+ *
+ *     const latheGeometry = new LatheGeometry(points, 32);
+ * ```
+ *
+ * Tube that connect with a sphere on the top:
+ * ```
+ *    const points: Vector2[] = [
+ *       ...appendSphericalCurve(
+ *         2,  // Radius x
+ *         2,  // Radius y
+ *         1,  // Start y
+ *         1,  // Hole top radius
+ *         0,  // Hole bottom radius
+ *         32, // Segments
+ *       ),
+ *       new Vector2(1, 5),
+ *     ];
+ *
+ *     const latheGeometry = new LatheGeometry(points, 32);
+ * ```
+ */
+export declare function appendSphericalCurve(sphereRadiusX: number, sphereRadiusY: number, sphereStartY: number, holeTopRadius?: number, holeBottomRadius?: number, segments?: number): Vector2[];
+
 /**
  * Atmospheric scattering shader.
  *
@@ -275,7 +317,7 @@ export declare class BifurcatedStaircaseGeometry extends BufferGeometry {
     constructor(stepWidth?: number, stepHeight?: number, stepDepth?: number, numStepsCentral?: number, numStepsBranch?: number, branchAngle?: number);
 }
 
-export declare class Bone extends Mesh {
+export declare class Bone extends Mesh<BoneGeometry, MeshStandardMaterial> {
     constructor();
 }
 
@@ -295,9 +337,11 @@ export declare class BoneGeometry extends BufferGeometry {
 }
 
 /**
- * Material Order:
- *   1. Cover
- *   2. Page
+ * Book prefab
+ *
+ * Material indices:
+ * 0. cover
+ * 1. page
  */
 export declare class Book extends Mesh<BookGeometry, MeshStandardMaterial[]> {
     constructor({ width, height, depth, coverThickness, pageIndent, coverColor, pageColor, }?: {
@@ -311,11 +355,18 @@ export declare class Book extends Mesh<BookGeometry, MeshStandardMaterial[]> {
     });
 }
 
+/**
+ * Book
+ *
+ * Group indices:
+ * 0. cover
+ * 1. page
+ */
 export declare class BookGeometry extends BufferGeometry {
     constructor(width?: number, height?: number, depth?: number, coverThickness?: number, pageIndent?: number);
 }
 
-export declare class Bookshelf extends Mesh {
+export declare class Bookshelf extends Mesh<BookshelfGeometry, MeshStandardMaterial> {
     constructor({ width, //
         height, depth, shelves, frameThickness, open, }?: {
         width?: number | undefined;
@@ -339,10 +390,6 @@ export declare class BookshelfGeometry extends BufferGeometry {
     });
 }
 
-export declare class Bottle extends Group {
-    constructor();
-}
-
 export declare class BubblingEffect extends InstancedMesh {
     private bubblePositions;
     private velocities;
@@ -408,6 +455,126 @@ export declare function calculateUVBounds(uvs: [number, number][]): {
     maxBounds: [number, number];
 };
 
+/**
+ * Calculate the x-coordinate for a given y-coordinate using the slope-intercept equation of a line.
+ * x = x1 + (y - y1) / m
+ *
+ * Example usage
+ * ```
+ * const x1 = 0.8, y1 = 0, x2 = 1, y2 = 1.5, y = 1.0;
+ * const x = calculateXForY(x1, y1, x2, y2, y);
+ * console.log(`The x-position for y=${y} is x=${x.toFixed(4)}`);
+ * ```
+ */
+export declare function calculateXFromSlopeIntercept(x1: number, y1: number, x2: number, y2: number, y: number): number;
+
+/**
+ * Calculate the y-coordinate for a given x-coordinate using the slope-intercept equation of a line.
+ * y = y1 + m * (x - x1)
+ *
+ * Example usage
+ * ```
+ * const x1 = 0.8, y1 = 0, x2 = 1, y2 = 1.5, x = 0.9333;
+ * const y = calculateYForX(x1, y1, x2, y2, x);
+ * console.log(`The y-position for x=${x} is y=${y.toFixed(4)}`);
+ * ```
+ */
+export declare function calculateYFromSlopeIntercept(x1: number, y1: number, x2: number, y2: number, x: number): number;
+
+/**
+ * Dolly backward
+ *
+ * Example:
+ * ```
+ * dollyAnimation(camera, 5, 3000, () => {
+ *   console.log("Dolly animation complete");
+ * });
+ * ```
+ */
+export declare function cameraDollyAnimation(camera: Camera, distance: number, duration: number, onComplete?: () => void): 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 cameraFlythroughAnimation(camera: Camera, waypoints: Vector3[], duration: number, onComplete?: () => void): void;
+
+/**
+ * Orbit around a target
+ *
+ * Example:
+ * ```
+ * orbitAnimation(camera, new THREE.Vector3(0, 0, 0), 10, 5000, () => {
+ *   console.log("Orbit animation complete");
+ * });
+ * ```
+ */
+export declare function cameraOrbitAnimation(camera: Camera, target: Vector3, radius: number, duration: number, onComplete?: () => void): void;
+
+/**
+ * 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 cameraPendulumAnimation(camera: Camera, center: Vector3, radius: number, duration: number, oscillations: number, onComplete?: () => void): 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 cameraSpiralAscensionAnimation(camera: Camera, center: Vector3, radius: number, height: number, revolutions: number, duration: number, onComplete?: () => void): void;
+
+/**
+ * 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 cameraWobbleAnimation(camera: Camera, intensity: number, duration: number, onComplete?: () => void): void;
+
+/**
+ * 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 cameraZoomInAnimation(camera: PerspectiveCamera, target: Vector3, startFov: number, endFov: number, duration: number, onComplete?: () => void): void;
+
 export declare class Candle extends Group {
     private candle;
     private flame;
@@ -480,15 +647,19 @@ export declare const circularEaseInOut: (t: number) => number;
 export declare const circularEaseOut: (t: number) => number;
 
 export declare const ColorPalette: {
+    CADMIUM_RED: number;
     CARDINAL_RED: number;
     CHERRY_RED: number;
     CRIMSON: number;
+    ALIZARIN_CRIMSON: number;
     RUST: number;
     DARK_RED: number;
     TANGERINE: number;
     ORANGE_PEEL: number;
+    CADMIUM_ORANGE: number;
     ORANGE: number;
     AMBER: number;
+    CADMIUM_YELLOW: number;
     GOLD: number;
     YELLOW: number;
     LIME_GREEN: number;
@@ -496,41 +667,53 @@ export declare const ColorPalette: {
     MOSS_GREEN: number;
     FERN_GREEN: number;
     FOREST_GREEN: number;
+    SAP_GREEN: number;
     OLIVE_DRAB: number;
+    VIRIDIAN_GREEN: number;
     MINT_GREEN: number;
     AQUAMARINE: number;
+    PHTHALO_BLUE: number;
     SKY_BLUE: number;
     CERULEAN_BLUE: number;
     AZURE: number;
     OCEAN_BLUE: number;
     ROYAL_BLUE: number;
     MIDNIGHT_BLUE: number;
+    ULTRAMARINE_BLUE: number;
+    COBALT_VIOLET: number;
+    DEEP_VIOLET: number;
     CORAL_PINK: number;
     VIVID_MAGENTA: number;
     MAGENTA: number;
     HOT_PINK: number;
     PINK_SHERBET: number;
     SOFT_PINK: number;
-    DEEP_VIOLET: number;
-    TAUPE: number;
+    BURNT_SIENNA: number;
+    BURNT_UMBER: number;
     SIENNA: number;
     SADDLE_BROWN: number;
     COFFEE_BROWN: number;
     DARK_UMBER: number;
+    RAW_UMBER: number;
+    YELLOW_OCHRE: number;
+    RAW_SIENNA: number;
+    TAUPE: number;
     ONYX: number;
     CARBON: number;
     CHARCOAL: number;
     SLATE_GRAY: number;
     ASH_GRAY: number;
+    GRAPHITE: number;
     STEEL_GRAY: number;
-    COOL_GRAY: number;
+    DIM_GRAY: number;
     IRON: number;
     GRAY: number;
     STONE: number;
     SILVER: number;
+    LIGHT_GRAY: number;
     PALE_GRAY: number;
     WHITE_SMOKE: number;
-    WHITE: number;
+    TITANIUM_WHITE: number;
 };
 
 export declare const concave: (t: number) => number;
@@ -815,12 +998,20 @@ export declare interface DaySkyUniforms {
     bottomColor: Uniform<Color>;
 }
 
-export declare class Desk extends Mesh {
-    geometry: DeskGeometry;
-    material: MeshStandardMaterial[];
+/**
+ * Material indices:
+ * 0. Desk surface
+ * 1. Desk legs
+ */
+export declare class Desk extends Mesh<DeskGeometry, MeshStandardMaterial[]> {
     constructor();
 }
 
+/**
+ * Group indices:
+ * 0. Desk surface
+ * 1. Desk legs
+ */
 export declare class DeskGeometry extends BufferGeometry {
     constructor();
 }
@@ -909,18 +1100,6 @@ 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.
  */
@@ -965,18 +1144,26 @@ export declare class EllipticLeafGeometry extends BufferGeometry {
 }
 
 /**
- * Emissive pulse effect, designed for flickering lights.
+ * Emissive pulse animation, producing a flickering light effect for materials that have emissive properties.
  * The emissive intensity of the material will oscillate between `minIntensity` and `maxIntensity`.
  *
- * Use with materials that have emissive properties.
- *
  * Oscillation time = 2π / speed
  *  - Low speed values (e.g., 0.5) will result in a slow pulse
  *  - High speed values (e.g., 10) will result in a rapid flicker
  *
  *  Requires `update()` frame handler with `clock.getElapsedTime()` for animation.
+ *
+ *  Example usage:
+ *  ```
+ *  const pulseAnimation = new EmissivePulseAnimation();
+ *  const clock = new THREE.Clock();
+ *
+ *  function animate() {
+ *    pulseAnimation.update(clock.getElapsedTime());
+ *  }
+ *  ```
  */
-export declare class EmissivePulseEffect {
+export declare class EmissivePulseAnimation {
     speed: number;
     maxIntensity: number;
     minIntensity: number;
@@ -1003,7 +1190,7 @@ export declare interface EmissivePulseEffectOptions {
     material: MeshStandardMaterial | MeshPhysicalMaterial | MeshLambertMaterial | MeshPhongMaterial;
 }
 
-export declare class ErlenmeyerFlask extends Mesh {
+export declare class ErlenmeyerFlask extends Mesh<ErlenmeyerFlaskGeometry, MeshPhysicalMaterial> {
     constructor({ flaskRadius, //
         neckRadius, height, neckHeight, radialSegments, }?: {
         flaskRadius?: number | undefined;
@@ -1059,37 +1246,16 @@ export declare const Falloff: {
     SMOOTHSTEP: (distance: number, radius: number) => number;
 };
 
-export declare class FenceColumn extends Mesh<FenceColumnGeometry, MeshStandardMaterial> {
-    constructor({ height }?: {
-        height?: number | undefined;
-    });
-}
-
-/**
- * Fence Column Geometry, a stone slab fence column shape
- */
-export declare class FenceColumnGeometry extends BufferGeometry {
-    constructor({ height }?: {
-        height?: number | undefined;
-    });
-}
-
 export declare function findClosestColor(inputColor: number, dataset: number[]): number | null;
 
 export declare function findClosestColorChannelWise(inputColor: number, dataset: number[]): number | null;
 
-export declare class Flask extends Group {
-    constructor();
-}
-
 /**
  * Flattens vertices to a given plane defined by a target height or normal direction.
  */
 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;
 
-export declare class FlorenceFlask extends Mesh {
-    geometry: FlorenceFlaskGeometry;
-    material: MeshPhysicalMaterial;
+export declare class FlorenceFlask extends Mesh<FlorenceFlaskGeometry, MeshPhysicalMaterial> {
     constructor();
 }
 
@@ -1097,27 +1263,6 @@ export declare class FlorenceFlaskGeometry extends BufferGeometry {
     constructor();
 }
 
-/**
- * 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 {
@@ -1154,7 +1299,7 @@ export declare function hexToHsl(hex: number): [number, number, number];
  */
 export declare function hexToRgb(hex: number): [number, number, number];
 
-export declare class Hill extends Mesh {
+export declare class Hill extends Mesh<HillGeometry, MeshStandardMaterial> {
     constructor({ radius, //
         height, widthSegments, heightSegments, phiStart, phiLength, }?: {
         radius?: number | undefined;
@@ -1208,6 +1353,24 @@ export declare function interpolateCurve(curveFunction: (t: number) => number, s
 
 export declare const inverse: (t: number) => number;
 
+/**
+ * Material indices
+ * 0. Jar
+ * 1. Cork
+ */
+export declare class Jar extends Mesh<JarGeometry, MeshStandardMaterial[]> {
+    constructor();
+}
+
+/**
+ * Group indices
+ * 0. Jar
+ * 1. Cork
+ */
+export declare class JarGeometry extends BufferGeometry {
+    constructor();
+}
+
 export declare class Lantern extends Group {
     constructor(height?: number, baseWidth?: number);
 }
@@ -1236,7 +1399,7 @@ export declare class LeverPanel extends Group {
 }
 
 /**
- * A lightning effect that can be used to simulate a lightning storm.
+ * A lightning animation that can be used to simulate a lightning storm.
  * This effect is applied to a light source.
  *
  * Example usage:
@@ -1245,12 +1408,14 @@ export declare class LeverPanel extends Group {
  * scene.add(lightning);
  * lightning.position.set(5, 10, -5);
  *
+ * const lightningAnimation = new LightningAnimation();
+ *
  * setRandomInterval(() => {
  *   lightningEffect.triggerLightning();
  * }, 250, 1250);
  * ```
  */
-export declare class LightningEffect {
+export declare class LightningAnimation {
     private light?;
     minIntensity: number;
     maxIntensity: number;
@@ -1272,6 +1437,11 @@ declare interface LightningEffectOptions {
 
 export declare const linear: (t: number) => number;
 
+export declare const LineEquations: {
+    calculateXFromSlopeIntercept: typeof calculateXFromSlopeIntercept;
+    calculateYFromSlopeIntercept: typeof calculateYFromSlopeIntercept;
+};
+
 export declare const logarithmic: (t: number) => number;
 
 export declare const logarithmicCurve: (t: number, base?: number, factor?: number) => number;
@@ -1304,7 +1474,27 @@ export declare class LShapedStaircaseGeometry extends BufferGeometry {
     constructor(stepWidth?: number, stepHeight?: number, stepDepth?: number, numStepsPerFlight?: number, landingDepth?: number);
 }
 
-export declare class Mausoleum extends Group {
+/**
+ * Material indices:
+ * 0. Base
+ * 1. Building
+ * 2. Roof
+ * 3. Arched entrance
+ */
+export declare class Mausoleum extends Mesh<MausoleumGeometry, MeshStandardMaterial[]> {
+    constructor();
+}
+
+/**
+ * Mausoleum Geometry
+ *
+ * Group indices:
+ * 0. Base
+ * 1. Building
+ * 2. Roof
+ * 3. Arched entrance
+ */
+export declare class MausoleumGeometry extends BufferGeometry {
     constructor();
 }
 
@@ -1338,7 +1528,21 @@ export declare class MortarGeometry extends BufferGeometry {
     constructor();
 }
 
-export declare class MossyRocks extends Group {
+/**
+ * Material indices:
+ * 0. Rocks
+ * 1. Moss
+ */
+export declare class MossyRocks extends Mesh<MossyRocksGeometry, MeshStandardMaterial[]> {
+    constructor();
+}
+
+/**
+ * Group indices:
+ * 0. Rocks
+ * 1. Moss
+ */
+export declare class MossyRocksGeometry extends BufferGeometry {
     constructor();
 }
 
@@ -1359,7 +1563,7 @@ export declare class MossyRocks extends Group {
  * }
  * ```
  */
-export declare class Mound extends Mesh {
+export declare class Mound extends Mesh<MoundGeometry, MeshStandardMaterial> {
     constructor({ radius, //
         widthSegments, heightSegments, phiStart, phiLength, thetaLength, }?: {
         radius?: number | undefined;
@@ -1499,18 +1703,6 @@ 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;
-
 /**
  * Prefab for a panel.
  * Designed to be used as a control panel for switches, lights, levels, dials, and gauges.
@@ -1573,18 +1765,6 @@ export declare const ParametricCurveUtils: {
  */
 export declare function parseHexCode(hex: string): [number, number, number];
 
-/**
- * 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;
-
 /**
  * Planar UV Mapping
  * Projects UVs onto the geometry from a single direction (like shining a projector onto a surface).
@@ -1619,6 +1799,30 @@ export declare function planarUVMapping(vertices: [number, number, number][], ax
  */
 export declare function polarUVMapping(vertices: [number, number, number][]): [number, number][];
 
+/**
+ * Potion bottle, with optional liquid fill
+ *
+ * Material indices
+ * 0. Bottle
+ * 1. Cork
+ * 2. Liquid (optional)
+ */
+export declare class PotionBottle extends Mesh<PotionBottleGeometry, MeshStandardMaterial[]> {
+    constructor();
+}
+
+/**
+ * Potion bottle geometry
+ *
+ * Group indices
+ * 0. Bottle
+ * 1. Cork
+ * 2. Liquid (optional)
+ */
+export declare class PotionBottleGeometry extends BufferGeometry {
+    constructor();
+}
+
 export declare const quadraticCurve: (t: number, p0: number, p1: number, p2: number) => number;
 
 export declare const quadraticEaseIn: (t: number) => number;
@@ -1677,7 +1881,7 @@ export declare function rgbToHex(r: number, g: number, b: number): number;
  */
 export declare function rgbToHsl(r: number, g: number, b: number): [number, number, number];
 
-export declare class Rock extends Mesh {
+export declare class Rock extends Mesh<RockGeometry, MeshStandardMaterial> {
     constructor(radius?: number, widthSegments?: number, heightSegments?: number);
 }
 
@@ -1685,7 +1889,11 @@ export declare class RockGeometry extends BufferGeometry {
     constructor(radius?: number, widthSegments?: number, heightSegments?: number);
 }
 
-export declare class Rocks extends Group {
+export declare class Rocks extends Mesh<RocksGeometry, MeshStandardMaterial> {
+    constructor();
+}
+
+export declare class RocksGeometry extends BufferGeometry {
     constructor();
 }
 
@@ -1805,18 +2013,6 @@ export declare function sphericalUVMapping(vertices: [number, number, number][])
  */
 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);
 }
@@ -1839,9 +2035,7 @@ export declare class StaircaseGeometry extends BufferGeometry {
     constructor(width?: number, stepHeight?: number, stepDepth?: number, numSteps?: number);
 }
 
-export declare class Stand extends Mesh {
-    geometry: StandGeometry;
-    material: MeshStandardMaterial;
+export declare class Stand extends Mesh<StandGeometry, MeshStandardMaterial> {
     constructor({ radius, //
         height, count, thickness, radialSegments, }?: {
         radius?: number | undefined;
@@ -1871,11 +2065,40 @@ export declare class StarShape extends Shape {
     constructor(points?: number, innerRadius?: number, outerRadius?: number);
 }
 
-export declare class TeslaCoil extends Group {
+export declare class StoneFencePost extends Mesh<StoneFencePostGeometry, MeshStandardMaterial> {
+    constructor({ height }?: {
+        height?: number | undefined;
+    });
+}
+
+/**
+ * Fence Column Geometry, a stone slab fence column shape
+ */
+export declare class StoneFencePostGeometry extends BufferGeometry {
+    constructor({ height }?: {
+        height?: number | undefined;
+    });
+}
+
+/**
+ * Material indices
+ * 0: Base
+ * 1: Coil
+ */
+export declare class TeslaCoil extends Mesh<TeslaCoilGeometry, MeshStandardMaterial[]> {
     constructor();
 }
 
-export declare class TestTube extends Group {
+/**
+ * Group indices
+ * 0: Base
+ * 1: Coil
+ */
+export declare class TeslaCoilGeometry extends BufferGeometry {
+    constructor();
+}
+
+export declare class TestTube extends Mesh<TestTubeGeometry, MeshPhysicalMaterial> {
     constructor(radiusTop?: number, radiusBottom?: number, height?: number, segments?: number);
 }
 
@@ -1888,7 +2111,27 @@ export declare class TestTubeRack extends Group {
 }
 
 /**
- * @example
+ * Calculate the thetaLength to achieve a specific hole radius in a sphere.
+ *   thetaLength = asin(w / (2 * R))
+ *
+ * Returns the thetaLength in radians.
+ *
+ * Example usage:
+ * ```
+ * const sphereRadius = 5; // Radius of the sphere
+ * const holeRadius = 1;   // Desired radius of the hole at the top
+ * const thetaLength = thetaLengthForRadius(sphereRadius, holeRadius);
+ * ```
+ */
+export declare const thetaLengthForRadius: (sphereRadius: number, holeRadius: number) => number;
+
+/**
+ * Material indices:
+ * 0. Trunk
+ * 1. leafSize
+ *
+ * Example usage:
+ * ```
  * const tree = new Tree({
  *   trunkRadiusTop: 0.25,
  *   trunkRadiusBottom: 0.4,
@@ -1901,8 +2144,9 @@ export declare class TestTubeRack extends Group {
  *   leafSpreadRadius: 1.5,
  *   leafColor: 0x228b22,
  * });
+ * ```
  */
-export declare class Tree extends Mesh {
+export declare class Tree extends Mesh<TreeGeometry, MeshStandardMaterial[]> {
     constructor({ trunkRadiusTop, trunkRadiusBottom, trunkHeight, trunkSegments, trunkColor, leafSize, leafCount, leafDetail, leafSpreadRadius, leafColor, }?: {
         trunkRadiusTop?: number | undefined;
         trunkRadiusBottom?: number | undefined;
@@ -1956,7 +2200,7 @@ export declare function updateNoiseDisplacementTime<T extends Material>(material
  */
 export declare function updateWaterDisplacementTime<T extends Material>(material: T, deltaTime: number): void;
 
-export declare class WineBottle extends Mesh {
+export declare class WineBottle extends Mesh<WineBottleGeometry, MeshPhysicalMaterial> {
     constructor();
 }
 
@@ -1970,18 +2214,6 @@ 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<WroughtIronBarGeometry, MeshStandardMaterial> {
     constructor({ barHeight, //
         barRadius, spikeHeight, spikeRadius, spikeScaleZ, radialSegments, }?: {
@@ -2043,17 +2275,4 @@ 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 { }