three-low-poly 0.9.12 → 0.9.13

package/dist/index.d.ts

@@ -0,0 +1,1360 @@
+import { BoxGeometry } from 'three';
+import { BufferGeometry } 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 { ShaderMaterial } from 'three';
+import { Shape } from 'three';
+import { SphereGeometry } from 'three';
+import { Uniform } from 'three';
+import { Vector2 } from 'three';
+import { Vector3 } from 'three';
+
+/**
+ * Utility function to add noise-based vertex displacement to an existing Three.js material.
+ * @param {Material} material - The material to mutate, e.g., MeshStandardMaterial.
+ * @param {Object} options - Options for noise modification.
+ * @param {number} [options.time=0.0] - The time value for the noise function.
+ * @param {number} [options.intensity=1.0] - The intensity of the displacement.
+ * @param {Vector3} [options.direction=new Vector3(1, 1, 1)] - The direction of displacement.
+ * @param {number} [options.scale=10.0] - The scale of the noise effect.
+ */
+export declare function addNoiseDisplacement<T extends Material>(material: T, { time, intensity, direction, scale }?: NoiseDisplacementOptions): void;
+
+/**
+ * Utility function to add water-like vertex displacement to an existing Three.js material.
+ * @param {Material} material - The material to mutate, e.g., MeshStandardMaterial.
+ * @param {Object} options - Options for water wave modification.
+ * @param {number} [options.time=0.0] - The time value for the wave function.
+ * @param {number} [options.waveFrequency=0.2] - The frequency of the water waves.
+ * @param {number} [options.waveAmplitude=0.5] - The amplitude of the water waves.
+ */
+export declare function addWaterDisplacement<T extends Material>(material: T, { time, waveFrequency, waveAmplitude }?: {
+    time?: number | undefined;
+    waveFrequency?: number | undefined;
+    waveAmplitude?: number | undefined;
+}): void;
+
+/**
+ * Atmospheric scattering shader.
+ *
+ * Based on "A Practical Analytic Model for Daylight"
+ * aka The Preetham Model, the de facto standard analytic skydome model
+ * https://www.researchgate.net/publication/220720443_A_Practical_Analytic_Model_for_Daylight
+ *
+ * First implemented by Simon Wallner
+ * http://simonwallner.at/project/atmospheric-scattering/
+ *
+ * Improved by Martin Upitis
+ * http://blenderartists.org/forum/showthread.php?245954-preethams-sky-impementation-HDR
+ *
+ * Three.js integration by zz85 http://twitter.com/blurspline
+ *
+ * Example:
+ * ```
+ *     const geometry = new BoxGeometry(1, 1, 1);
+ *
+ *     const material = new ShaderMaterial({
+ *       uniforms: atmosphericShader.uniforms,
+ *       vertexShader: atmosphericShader.vertexShader,
+ *       fragmentShader: atmosphericShader.fragmentShader,
+ *       depthWrite: false,
+ *       side: BackSide,
+ *     }) as ShaderMaterial & { uniforms: AtmosphericShaderUniforms };
+ *
+ *     const theta = MathUtils.degToRad(89);
+ *     const phi = MathUtils.degToRad(180);
+ *     const sun = new Vector3().setFromSphericalCoords(1, theta, phi);
+ *
+ *     material.uniforms.sunPosition.value = sun;
+ *
+ *     const mesh = new Mesh(geometry, material);
+ *     mesh.scale.setScalar(450000);
+ * ```
+ */
+export declare const atmosphericShader: {
+    uniforms: {
+        turbidity: {
+            value: number;
+        };
+        rayleigh: {
+            value: number;
+        };
+        mieCoefficient: {
+            value: number;
+        };
+        mieDirectionalG: {
+            value: number;
+        };
+        sunPosition: {
+            value: Vector3;
+        };
+        up: {
+            value: Vector3;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+
+export declare interface AtmosphericShaderUniforms {
+    turbidity: Uniform<number>;
+    rayleigh: Uniform<number>;
+    mieCoefficient: Uniform<number>;
+    mieDirectionalG: Uniform<number>;
+    sunPosition: Uniform<Vector3>;
+    up: Uniform<Vector3>;
+}
+
+/**
+ * Atmospheric scattering skybox.
+ *
+ * Elevation (theta, θ): Angle measured above or below the horizon (from the xy-plane towards the zenith or nadir).
+ * Azimuth (phi, φ): Angle measured around the horizon from a reference direction (e.g., north, east).
+ */
+export declare class AtmosphericSkybox extends Mesh {
+    geometry: BoxGeometry;
+    material: ShaderMaterial & {
+        uniforms: AtmosphericShaderUniforms;
+    };
+    constructor();
+    /**
+     * Set the sun position.
+     *
+     * Elevation (theta, θ)
+     * - Angle measured above or below the horizon (from the xy-plane towards the zenith or nadir).
+     * - Ranges from 0 to π/2 radians (or 0 to 90 degrees).
+     * - This is the vertical angle in the xy-plane.
+     *
+     * Azimuth (phi, φ)
+     * - Angle measured around the horizon from a reference direction (e.g., north, east).
+     * - Ranges from 0 to 2π radians (or 0 to 360 degrees).
+     * - This is the horizontal angle in the xy-plane.
+     */
+    sunPosition(theta: number, phi: number): void;
+}
+
+export declare class Beaker extends Group {
+    constructor();
+}
+
+export declare class BeakerGeometry extends BufferGeometry {
+    constructor();
+}
+
+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 {
+    constructor();
+}
+
+/**
+ * Bone Geometry, a simple bone shape
+ * @extends BufferGeometry
+ *
+ * @example
+ * // Create a bone
+ * const boneGeometry = new BoneGeometry();
+ * const boneMaterial = new MeshStandardMaterial({ color: 0xffffff });
+ * const bone = new Mesh(boneGeometry, boneMaterial);
+ * scene.add(bone);
+ */
+export declare class BoneGeometry extends BufferGeometry {
+    constructor(radiusTop?: number, radiusBottom?: number, height?: number, radialSegments?: number);
+}
+
+export declare class Book extends Mesh {
+    constructor({ width, height, depth, coverThickness, pageIndent, coverColor, pageColor, }?: {
+        width?: number | undefined;
+        height?: number | undefined;
+        depth?: number | undefined;
+        coverThickness?: number | undefined;
+        pageIndent?: number | undefined;
+        coverColor?: number | undefined;
+        pageColor?: number | undefined;
+    });
+}
+
+export declare class BookGeometry extends BufferGeometry {
+    constructor(width?: number, height?: number, depth?: number, coverThickness?: number, pageIndent?: number);
+}
+
+export declare class Bookshelf extends Mesh {
+    constructor({ width, //
+        height, depth, shelves, frameThickness, open, }?: {
+        width?: number | undefined;
+        height?: number | undefined;
+        depth?: number | undefined;
+        shelves?: number | undefined;
+        frameThickness?: number | undefined;
+        open?: boolean | undefined;
+    });
+}
+
+export declare class BookshelfGeometry extends BufferGeometry {
+    constructor({ width, //
+        height, depth, shelves, frameThickness, open, }?: {
+        width?: number | undefined;
+        height?: number | undefined;
+        depth?: number | undefined;
+        shelves?: number | undefined;
+        frameThickness?: number | undefined;
+        open?: boolean | undefined;
+    });
+}
+
+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();
+    /**
+     * Updates bubble positions, moving them upward and resetting them
+     * to the bottom if they reach the top.
+     */
+    private updateBubbles;
+    /**
+     * Animates the bubbles by updating their positions in a loop.
+     */
+    private animateBubbles;
+}
+
+export declare class BunsenBurner extends Group {
+    constructor();
+}
+
+export declare class Burst extends Mesh {
+    constructor(sides?: number, innerRadius?: number, outerRadius?: number, depth?: number);
+}
+
+export declare class BurstShape extends Shape {
+    constructor(sides?: number, innerRadius?: number, outerRadius?: number);
+}
+
+export declare class Candle extends Group {
+    private candle;
+    private flame;
+    private candleLight;
+    private height;
+    private radius;
+    constructor(height?: number, radius?: number);
+    animateFlicker(): void;
+}
+
+/**
+ * Calculate the height of a spherical cap.
+ *   h = R * (1 - cos(thetaLength))
+ */
+export declare const capHeightFromRadius: (radius: number, thetaLength: number) => number;
+
+/**
+ * Calculate the width of a spherical cap.
+ *   w = 2 * R * sin(thetaLength)
+ */
+export declare const capWidthFromRadius: (radius: number, thetaLength: number) => number;
+
+/**
+ * Convert Cartesian coordinates to spherical coordinates.
+ * @param {number} x - The x-coordinate.
+ * @param {number} y - The y-coordinate.
+ * @param {number} z - The z-coordinate.
+ * @returns {{radius: number, theta: number, phi: number}} The spherical coordinates.
+ */
+export declare const cartesianToSpherical: (x: number, y: number, z: number) => {
+    radius: number;
+    theta: 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;
+
+/**
+ * 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.
+ */
+export declare function centerMeshGeometry<T extends Mesh>(mesh: T): void;
+
+/**
+ * Create a checkerboard texture
+ *
+ * Example:
+ * ```
+ * const material = new MeshStandardMaterial();
+ * material.map = createCheckerboardTexture(8);
+ * ```
+ */
+export declare const checkerboardTexture: (size: number) => DataTexture;
+
+export declare const circularEaseIn: (t: number) => number;
+
+export declare const circularEaseInOut: (t: number) => number;
+
+export declare const circularEaseOut: (t: number) => number;
+
+export declare const concave: (t: number) => number;
+
+export declare const convex: (t: number) => number;
+
+/**
+ * Function to create cubic Bezier curve points
+ *
+ * Example:
+ * ```
+ * const points = [
+ *   ...ParametricCurveUtils.createCubicCurvePoints(
+ *     new THREE.Vector2(0.5, 2),    // Start of the cubic curve
+ *     new THREE.Vector2(1.5, 3),    // First control point (outward curve)
+ *     new THREE.Vector2(1.5, 4),    // Second control point (outward curve)
+ *     new THREE.Vector2(0.5, 5),    // End of the curve
+ *     24,                           // Resolution of the quadratic curve
+ * ),
+ * ]
+ * ```
+ */
+export declare const createCubicCurvePoints: (start: Vector2, control1: Vector2, control2: Vector2, end: Vector2, segments?: number) => Vector2[];
+
+/**
+ * Function to create damped curve points
+ *
+ * Example:
+ * ```
+ * const points = [
+ *   ...ParametricCurveUtils.createDampedCurvePoints(
+ *     new THREE.Vector2(0.5, 2),    // Start of the damped curve
+ *     new THREE.Vector2(1.5, 5),    // End of the damped curve
+ *     5,                            // Damping factor
+ *     24,                           // Resolution of the damped curve
+ *   ),
+ * ]
+ * ```
+ */
+export declare const createDampedCurvePoints: (start: Vector2, end: Vector2, damping: number, segments?: number) => Vector2[];
+
+/**
+ * Function to create exponential curve points
+ *
+ * Example:
+ * ```
+ * const points = [
+ *   ...ParametricCurveUtils.createExponentialCurvePoints(
+ *     new THREE.Vector2(0.5, 2),    // Start of the exponential curve
+ *     new THREE.Vector2(1.5, 5),    // End of the exponential curve
+ *     0.5,                          // Base of the exponential function
+ *     2,                            // Exponential factor
+ *     24                            // Resolution of the exponential curve
+ *   ),
+ * ]
+ * ```
+ */
+export declare const createExponentialCurvePoints: (start: Vector2, end: Vector2, base: number, factor: number, segments?: number) => Vector2[];
+
+/**
+ * Function to create logarithmic curve points
+ *
+ * Example:
+ * ```
+ * const points = [
+ *   ...ParametricCurveUtils.createLogarithmicCurvePoints(
+ *     new THREE.Vector2(0.5, 2),    // Start of the logarithmic curve
+ *     new THREE.Vector2(1.5, 5),    // End of the logarithmic curve
+ *     0.5,                          // Base of the logarithmic function
+ *     10,                           // Logarithmic factor
+ *     24,                           // Resolution of the logarithmic curve
+ *   ),
+ * ]
+ * ```
+ */
+export declare const createLogarithmicCurvePoints: (start: Vector2, end: Vector2, base: number, factor: number, segments?: number) => Vector2[];
+
+/**
+ * Function to create parabolic curve points
+ *
+ * Example:
+ * ```
+ * const points = [
+ *   ...ParametricCurveUtils.createParabolicCurvePoints(
+ *     new THREE.Vector2(0.5, 2),    // Start point
+ *     new THREE.Vector2(0.5, 5),    // End point
+ *     1,                            // Coefficient for t^2 (controls curvature)
+ *     0,                            // Coefficient for t (linear component)
+ *     0,                            // Constant term (vertical offset)
+ *     24,                           // Resolution
+ *   ),
+ * ]
+ * ```
+ */
+export declare const createParabolicCurvePoints: (start: Vector2, end: Vector2, a: number, b: number, c: number, segments?: number) => Vector2[];
+
+/**
+ * Function to create quadratic Bezier curve points
+ *
+ * Example:
+ * ```
+ * const points = [
+ *   ...ParametricCurveUtils.createQuadraticCurvePoints(
+ *     new THREE.Vector2(0.5, 2),    // Start of the quadratic curve
+ *     new THREE.Vector2(1.5, 5),    // Control point (outward curve)
+ *     new THREE.Vector2(0.5, 5),    // End of the curve
+ *     24,                           // Resolution of the quadratic curve
+ *   ),
+ * ]
+ * ```
+ */
+export declare const createQuadraticCurvePoints: (start: Vector2, control: Vector2, end: Vector2, segments?: number) => Vector2[];
+
+/**
+ * Function to create sigmoid curve points
+ *
+ * Example:
+ * ```
+ * const points = [
+ *   ...ParametricCurveUtils.createSigmoidCurvePoints(
+ *     new THREE.Vector2(0.5, 2),    // Start of the sigmoid curve
+ *     new THREE.Vector2(1.5, 5),    // End of the sigmoid curve
+ *     20,                           // Sigmoid steepness factor
+ *     24,                           // Resolution of the sigmoid curve
+ *   ),
+ * ]
+ */
+export declare const createSigmoidCurvePoints: (start: Vector2, end: Vector2, a: number, segments?: number) => Vector2[];
+
+export declare class CrossHeadstone extends Mesh {
+    constructor({ width, height, depth, material, }?: CrossHeadstoneOptions);
+}
+
+export declare class CrossHeadstoneGeometry extends BufferGeometry {
+    constructor(width?: number, height?: number, depth?: number);
+}
+
+declare interface CrossHeadstoneOptions {
+    width?: number;
+    height?: number;
+    depth?: number;
+    material?: Material;
+}
+
+export declare const cubicCurve: (t: number, p0: number, p1: number, p2: number, p3: number) => number;
+
+export declare const cubicEaseIn: (t: number) => number;
+
+export declare const cubicEaseInOut: (t: number) => number;
+
+export declare const cubicEaseOut: (t: number) => number;
+
+export declare const dampedCurve: (t: number, damping?: number) => number;
+
+export declare class DaySkybox extends Mesh {
+    geometry: BoxGeometry;
+    material: ShaderMaterial & {
+        uniforms: DaySkyUniforms;
+    };
+    constructor(size?: number);
+}
+
+/**
+ * Shader for a day skybox.
+ *
+ * Example:
+ * ```
+ * this.material = new ShaderMaterial({
+ *   uniforms: daySkyShader.uniforms,
+ *   vertexShader: daySkyShader.vertexShader,
+ *   fragmentShader: daySkyShader.fragmentShader,
+ *   side: BackSide,
+ * }) as ShaderMaterial & { uniforms: DaySkyUniforms };
+ * ```
+ */
+export declare const daySkyShader: {
+    uniforms: {
+        topColor: {
+            value: Color;
+        };
+        bottomColor: {
+            value: Color;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+
+export declare interface DaySkyUniforms {
+    topColor: Uniform<Color>;
+    bottomColor: Uniform<Color>;
+}
+
+export declare class Desk extends Group {
+    constructor();
+}
+
+export declare class DioramaGeometry extends BufferGeometry {
+    constructor(width?: number, height?: number, depth?: number, wallThickness?: number);
+}
+
+/**
+ * Examples
+ *
+ * Moving an Object Along a Direction
+ * ```
+ * const speed = 1; // Movement speed
+ * const direction = Direction.FORWARD; // Choose a direction
+ *
+ * object.position.add(direction.clone().multiplyScalar(speed * deltaTime));
+ * ```
+ *
+ * Snapping Positions to a Direction
+ * ```
+ * const targetPosition = new Vector3(5, 0, 3);
+ * const snapDirection = Direction.UP; // Align upwards
+ *
+ * object.position.copy(targetPosition.clone().add(snapDirection.clone().multiplyScalar(10)));
+ * ```
+ *
+ * Rotating or Orienting an Object
+ * ```
+ * const targetDirection = Direction.XY; // Diagonal upward
+ * object.lookAt(object.position.clone().add(targetDirection));
+ * ```
+ *
+ * Procedural Geometry
+ * ```
+ * const vertex = new Vector3(0, 0, 0);
+ * const direction = Direction.XZ; // Diagonal direction on XZ plane
+ *
+ * const offset = direction.clone().multiplyScalar(5);
+ * vertex.add(offset); // Move vertex in direction
+ * geometry.vertices.push(vertex);
+ * ```
+ *
+ * Animating Along a Direction
+ * ```
+ * const distance = 10; // Total distance to travel
+ * const duration = 2; // Animation duration in seconds
+ * const startPosition = object.position.clone();
+ * const targetPosition = startPosition.clone().add(Direction.BACKWARD.clone().multiplyScalar(distance));
+ *
+ * let elapsed = 0;
+ * function animate(deltaTime) {
+ *   elapsed += deltaTime;
+ *   const t = Math.min(elapsed / duration, 1); // Normalize time to [0, 1]
+ *   object.position.lerpVectors(startPosition, targetPosition, t);
+ * }
+ * ```
+ *
+ * Shader Uniforms
+ * ```
+ * material.uniforms.uDirection.value = Direction.FORWARD; // Use as light or flow direction
+ * ```
+ *
+ * Particle Systems
+ * ```
+ * particles.forEach(particle => {
+ *   particle.velocity.add(Direction.FORWARD.clone().multiplyScalar(0.1));
+ * });
+ * ```
+ *
+ * Directional Raycasting
+ * ```
+ * const rayOrigin = new Vector3(0, 0, 0);
+ * const rayDirection = Direction.FORWARD;
+ * const raycaster = new THREE.Raycaster(rayOrigin, rayDirection);
+ *
+ * // Find intersected objects
+ * const intersects = raycaster.intersectObjects(scene.children);
+ * ```
+ *
+ * Physics Forces
+ * ```
+ * const forceDirection = Direction.UP; // Push upwards
+ * const forceMagnitude = 50;
+ *
+ * rigidBody.applyForce(forceDirection.clone().multiplyScalar(forceMagnitude));
+ * ```
+ */
+export declare const Direction: {
+    UP: Vector3;
+    DOWN: Vector3;
+    LEFT: Vector3;
+    RIGHT: Vector3;
+    FORWARD: Vector3;
+    BACKWARD: Vector3;
+    X: Vector3;
+    Y: Vector3;
+    Z: Vector3;
+    XY: Vector3;
+    XZ: Vector3;
+    YZ: Vector3;
+    XYZ: Vector3;
+};
+
+/**
+ * Moves vertices within a specified radius around a target position along a given 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;
+
+/**
+ * Easing functions for interpolating values over time.
+ */
+export declare const Easing: {
+    SINE_EASE_IN: (t: number) => number;
+    SINE_EASE_OUT: (t: number) => number;
+    SINE_EASE_IN_OUT: (t: number) => number;
+    QUADRATIC_EASE_IN: (t: number) => number;
+    QUADRATIC_EASE_OUT: (t: number) => number;
+    QUADRATIC_EASE_IN_OUT: (t: number) => number;
+    CUBIC_EASE_IN: (t: number) => number;
+    CUBIC_EASE_OUT: (t: number) => number;
+    CUBIC_EASE_IN_OUT: (t: number) => number;
+    QUARTIC_EASE_IN: (t: number) => number;
+    QUARTIC_EASE_OUT: (t: number) => number;
+    QUARTIC_EASE_IN_OUT: (t: number) => number;
+    QUINTIC_EASE_IN: (t: number) => number;
+    QUINTIC_EASE_OUT: (t: number) => number;
+    QUINTIC_EASE_IN_OUT: (t: number) => number;
+    EXPONENTIAL_EASE_IN: (t: number) => number;
+    EXPONENTIAL_EASE_OUT: (t: number) => number;
+    EXPONENTIAL_EASE_IN_OUT: (t: number) => number;
+    CIRCULAR_EASE_IN: (t: number) => number;
+    CIRCULAR_EASE_OUT: (t: number) => number;
+    CIRCULAR_EASE_IN_OUT: (t: number) => number;
+    LINEAR: (t: number) => number;
+    SMOOTHSTEP: (t: number) => number;
+    CONCAVE: (t: number) => number;
+    CONVEX: (t: number) => number;
+    LOGARITHMIC: (t: number) => number;
+    SQUARE_ROOT: (t: number) => number;
+    INVERSE: (t: number) => number;
+    GAUSSIAN: (t: number) => number;
+};
+
+export declare class ElectricPanel extends Group {
+    constructor();
+}
+
+export declare class ErlenmeyerFlask extends Mesh {
+    constructor({ flaskRadius, //
+        neckRadius, height, neckHeight, radialSegments, }?: {
+        flaskRadius?: number | undefined;
+        neckRadius?: number | undefined;
+        height?: number | undefined;
+        neckHeight?: number | undefined;
+        radialSegments?: number | undefined;
+    });
+}
+
+export declare class ErlenmeyerFlaskGeometry extends BufferGeometry {
+    constructor({ flaskRadius, //
+        neckRadius, height, neckHeight, radialSegments, }?: {
+        flaskRadius?: number | undefined;
+        neckRadius?: number | undefined;
+        height?: number | undefined;
+        neckHeight?: number | undefined;
+        radialSegments?: number | undefined;
+    });
+}
+
+export declare const exponentialCurve: (t: number, base?: number, factor?: number) => number;
+
+export declare const exponentialEaseIn: (t: number) => number;
+
+export declare const exponentialEaseInOut: (t: number) => number;
+
+export declare const exponentialEaseOut: (t: number) => number;
+
+export declare const fadeShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        opacity: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+
+export declare const Falloff: {
+    LINEAR: (distance: number, radius: number) => number;
+    QUADRATIC: (distance: number, radius: number) => number;
+    SQUARE_ROOT: (distance: number, radius: number) => number;
+    LOGARITHMIC: (distance: number, radius: number) => number;
+    SINE: (distance: number, radius: number) => number;
+    EXPONENTIAL: (distance: number, radius: number) => number;
+    CUBIC: (distance: number, radius: number) => number;
+    GAUSSIAN: (distance: number, radius: number) => number;
+    INVERSE: (distance: number, radius: number) => number;
+    SMOOTHSTEP: (distance: number, radius: number) => number;
+};
+
+export declare class FenceColumn extends Mesh {
+    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 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 const gaussian: (t: number) => number;
+
+export declare class Gear extends Mesh {
+    constructor(sides?: number, innerRadius?: number, outerRadius?: number, holeSides?: number, holeRadius?: number, depth?: number);
+}
+
+export declare class GearShape extends Shape {
+    constructor(sides?: number, innerRadius?: number, outerRadius?: number, holeSides?: number, holeRadius?: number);
+}
+
+export declare class Heart extends Mesh {
+    constructor(size?: number, width?: number, height?: number, tipDepth?: number, depth?: number);
+}
+
+export declare class HeartShape extends Shape {
+    constructor(size?: number, width?: number, height?: number, tipDepth?: number);
+}
+
+export declare class Hill extends Mesh {
+    constructor({ radius, //
+        height, widthSegments, heightSegments, phiStart, phiLength, }?: {
+        radius?: number | undefined;
+        height?: number | undefined;
+        widthSegments?: number | undefined;
+        heightSegments?: number | undefined;
+        phiStart?: number | undefined;
+        phiLength?: number | undefined;
+    });
+}
+
+export declare class HillGeometry extends BufferGeometry {
+    constructor({ radius, //
+        height, widthSegments, heightSegments, phiStart, phiLength, }?: {
+        radius?: number | undefined;
+        height?: number | undefined;
+        widthSegments?: number | undefined;
+        heightSegments?: number | undefined;
+        phiStart?: number | undefined;
+        phiLength?: number | undefined;
+    });
+}
+
+/**
+ * Generates an array of interpolated 2D points using an easing function.
+ * @param curveFunction - The easing function to apply to the normalized value.
+ * @param startRadius - The starting radius for interpolation.
+ * @param endRadius - The ending radius for interpolation.
+ * @param startHeight - The starting height for interpolation.
+ * @param endHeight - The ending height for interpolation.
+ * @param segments - The number of segments for interpolation (default is 20).
+ * @param min - The minimum value of the normalization range (default is 0).
+ * @param max - The maximum value of the normalization range (default is 1).
+ * @returns An array of `Vector2` points representing the interpolated curve.
+ */
+export declare function interpolateCurve(curveFunction: (t: number) => number, startRadius: number, endRadius: number, startHeight: number, endHeight: number, segments?: number, min?: number, max?: number): Vector2[];
+
+export declare const inverse: (t: number) => number;
+
+export declare class Lantern extends Group {
+    constructor(height?: number, baseWidth?: number);
+}
+
+export declare class LeverPanel extends Group {
+    constructor();
+}
+
+export declare const linear: (t: number) => number;
+
+export declare const logarithmic: (t: number) => number;
+
+export declare const logarithmicCurve: (t: number, base?: number, factor?: number) => number;
+
+/**
+ * Generates a random number skewed towards the maximum value.
+ *
+ * @param {number} [exponent=0.5] - Controls the skew of the distribution.
+ *                                  A smaller value (e.g., 0.3) skews the values towards the max.
+ *                                  A larger value (e.g., 0.8) creates a more even distribution.
+ * @param {number} [min=0] - Minimum value of the range.
+ * @param {number} [max=1] - Maximum value of the range.
+ * @returns {number} A random number between `min` and `max`, skewed towards `max`.
+ */
+export declare function logarithmicRandomMax(exponent?: number, min?: number, max?: number): number;
+
+/**
+ * Generates a random number skewed towards the minimum value.
+ *
+ * @param {number} [exponent=0.5] - Controls the skew of the distribution.
+ *                                  A smaller value (e.g., 0.3) skews the values towards the min.
+ *                                  A larger value (e.g., 0.8) creates a more even distribution.
+ * @param {number} [min=0] - Minimum value of the range.
+ * @param {number} [max=1] - Maximum value of the range.
+ * @returns {number} A random number between `min` and `max`, skewed towards `min`.
+ */
+export declare function logarithmicRandomMin(exponent?: number, min?: number, max?: number): number;
+
+export declare class LShapedStaircaseGeometry extends BufferGeometry {
+    constructor(stepWidth?: number, stepHeight?: number, stepDepth?: number, numStepsPerFlight?: number, landingDepth?: number);
+}
+
+export declare class Mausoleum extends Group {
+    constructor();
+}
+
+export declare class Microscope extends Group {
+    constructor();
+}
+
+export declare class Moon extends Group {
+    constructor();
+}
+
+export declare class MortarAndPestle extends Group {
+    constructor();
+}
+
+export declare class MortarGeometry extends BufferGeometry {
+    constructor();
+}
+
+export declare class MossyRocks extends Group {
+    constructor();
+}
+
+/**
+ * Mound-like mesh with a flat top.
+ *
+ * To create a radius based on a desired width:
+ * ```
+ * const mound = new Mound({
+ *   radius: radiusFromCapWidth(5, Math.PI / 10),
+ * }
+ * ```
+ *
+ * To create a radius based on a desired height:
+ * ```
+ * const mound = new Mound({
+ *  radius: radiusFromCapHeight(5, Math.PI / 10),
+ * }
+ * ```
+ */
+export declare class Mound extends Mesh {
+    constructor({ radius, //
+        widthSegments, heightSegments, phiStart, phiLength, thetaLength, }?: {
+        radius?: number | undefined;
+        widthSegments?: number | undefined;
+        heightSegments?: number | undefined;
+        phiStart?: number | undefined;
+        phiLength?: number | undefined;
+        thetaLength?: number | undefined;
+    });
+}
+
+/**
+ * Mound-like geometry with a flat top.
+ *
+ * To create a radius based on a desired width:
+ * ```
+ * const moundGeometry = new MoundGeometry({
+ *   radius: radiusFromCapWidth(5, Math.PI / 10),
+ * }
+ * ```
+ *
+ * To create a radius based on a desired height:
+ * ```
+ * const moundGeometry = new MoundGeometry({
+ *  radius: radiusFromCapHeight(5, Math.PI / 10),
+ * }
+ * ```
+ */
+export declare class MoundGeometry extends BufferGeometry {
+    constructor({ radius, //
+        widthSegments, heightSegments, phiStart, phiLength, thetaLength, }?: {
+        radius?: number | undefined;
+        widthSegments?: number | undefined;
+        heightSegments?: number | undefined;
+        phiStart?: number | undefined;
+        phiLength?: number | undefined;
+        thetaLength?: number | undefined;
+    });
+}
+
+export declare class NightSkybox extends Mesh {
+    geometry: SphereGeometry;
+    material: ShaderMaterial & {
+        uniforms: NightSkyUniforms;
+    };
+    constructor(size?: number);
+}
+
+/**
+ * Shader for a night skybox.
+ *
+ * Example:
+ * ```
+ * this.material = new ShaderMaterial({
+ *   vertexShader: nightSkyShader.vertexShader,
+ *   fragmentShader: nightSkyShader.fragmentShader,
+ *   uniforms: nightSkyShader.uniforms,
+ *   side: BackSide,
+ * }) as ShaderMaterial & { uniforms: NightSkyUniforms };
+ * ```
+ */
+export declare const nightSkyShader: {
+    uniforms: {
+        topColor: {
+            value: Color;
+        };
+        bottomColor: {
+            value: Color;
+        };
+        offset: {
+            value: number;
+        };
+        exponent: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+
+export declare interface NightSkyUniforms {
+    topColor: Uniform<Color>;
+    bottomColor: Uniform<Color>;
+    offset: Uniform<number>;
+    exponent: Uniform<number>;
+}
+
+/**
+ * Adds random noise to the vertices within the specified radius to create a more rugged or natural look.
+ */
+export declare const noiseBrush: <T extends BufferGeometry>(geometry: T, position: Vector3, radius: number, strength: number, direction?: Vector3, falloffFn?: (distance: number, radius: number) => number) => void;
+
+declare interface NoiseDisplacementOptions {
+    time?: number;
+    intensity?: number;
+    direction?: Vector3;
+    scale?: number;
+}
+
+export declare class ObeliskHeadstone extends Mesh {
+    constructor({ totalHeight, baseWidth }?: ObeliskHeadstoneOptions);
+}
+
+export declare class ObeliskHeadstoneGeometry extends BufferGeometry {
+    constructor(totalHeight?: number, baseWidth?: number);
+}
+
+declare interface ObeliskHeadstoneOptions {
+    baseWidth?: number;
+    totalHeight?: number;
+}
+
+export declare const parabolicCurve: (t: number, a?: number, b?: number, c?: number) => number;
+
+export declare const ParametricCurve: {
+    CUBIC: (t: number, p0: number, p1: number, p2: number, p3: number) => number;
+    DAMPED: (t: number, damping?: number) => number;
+    EXPONENTIAL: (t: number, base?: number, factor?: number) => number;
+    LOGARITHMIC: (t: number, base?: number, factor?: number) => number;
+    PARABOLIC: (t: number, a?: number, b?: number, c?: number) => number;
+    QUADRATIC: (t: number, p0: number, p1: number, p2: number) => number;
+    SIGMOID: (t: number, a?: number) => number;
+    SINUSOIDAL: (t: number) => number;
+};
+
+export declare const ParametricCurveUtils: {
+    createCubicCurvePoints: (start: Vector2, control1: Vector2, control2: Vector2, end: Vector2, segments?: number) => Vector2[];
+    createDampedCurvePoints: (start: Vector2, end: Vector2, damping: number, segments?: number) => Vector2[];
+    createExponentialCurvePoints: (start: Vector2, end: Vector2, base: number, factor: number, segments?: number) => Vector2[];
+    createLogarithmicCurvePoints: (start: Vector2, end: Vector2, base: number, factor: number, segments?: number) => Vector2[];
+    createParabolicCurvePoints: (start: Vector2, end: Vector2, a: number, b: number, c: number, segments?: number) => Vector2[];
+    createQuadraticCurvePoints: (start: Vector2, control: Vector2, end: Vector2, segments?: number) => Vector2[];
+    createSigmoidCurvePoints: (start: Vector2, end: Vector2, a: number, segments?: number) => Vector2[];
+};
+
+export declare const quadraticCurve: (t: number, p0: number, p1: number, p2: number) => number;
+
+export declare const quadraticEaseIn: (t: number) => number;
+
+export declare const quadraticEaseInOut: (t: number) => number;
+
+export declare const quadraticEaseOut: (t: number) => number;
+
+export declare const quarticEaseIn: (t: number) => number;
+
+export declare const quarticEaseInOut: (t: number) => number;
+
+export declare const quarticEaseOut: (t: number) => number;
+
+export declare const quinticEaseIn: (t: number) => number;
+
+export declare const quinticEaseInOut: (t: number) => number;
+
+export declare const quinticEaseOut: (t: number) => number;
+
+/**
+ * Calculate the radius to achieve a spherical cap height.
+ *   R = r / (1 - cos(thetaLength))
+ */
+export declare const radiusFromCapHeight: (height: number, thetaLength: number) => number;
+
+/**
+ * Calculate the radius to achieve a spherical cap width.
+ *   R = w / (2 * sin(thetaLength))
+ */
+export declare const radiusFromCapWidth: (width: number, thetaLength: number) => number;
+
+/**
+ * Generates a random number between `min` and `max`.
+ */
+export declare function randomFloat(min?: number, max?: number): number;
+
+/**
+ * Generates a random integer between `min` and `max`.
+ */
+export declare function randomInteger(min?: number, max?: number): number;
+
+export declare function randomTransformVertices<T extends BufferGeometry>(geometry: T, direction?: Vector3, minScale?: number, maxScale?: number): T;
+
+export declare class Rock extends Mesh {
+    constructor(radius?: number, widthSegments?: number, heightSegments?: number);
+}
+
+export declare class RockGeometry extends BufferGeometry {
+    constructor(radius?: number, widthSegments?: number, heightSegments?: number);
+}
+
+export declare class Rocks extends Group {
+    constructor();
+}
+
+export declare class RoundedHeadstone extends Mesh {
+    constructor(width?: number, height?: number, depth?: number, radius?: number);
+}
+
+export declare class RoundedHeadstoneGeometry extends BufferGeometry {
+    constructor(width?: number, height?: number, depth?: number, radius?: number);
+}
+
+/**
+ * Creates a row of books with a given count.
+ */
+export declare function rowOfBooksByCount<T extends Material>({ coverMaterial, pagesMaterial, count, scaleXMin, scaleXMax, scaleYMin, scaleYMax, scaleZMin, scaleZMax, }: RowOfBooksOptions<T>): InstancedMesh;
+
+/**
+ * Creates a row of books with a total length.
+ */
+export declare function rowOfBooksByLength<T extends Material>({ coverMaterial, pagesMaterial, length, scaleXMin, scaleXMax, scaleYMin, scaleYMax, scaleZMin, scaleZMax, }: RowOfBooksOptions<T>): InstancedMesh;
+
+/**
+ * Creates a row of books from the scales array of Vector3.
+ */
+export declare function rowOfBooksByScales<T extends Material>({ coverMaterial, pagesMaterial, scales, }: RowOfBooksByScalesOptions<T>): InstancedMesh;
+
+declare interface RowOfBooksByScalesOptions<T extends Material = Material> {
+    coverMaterial: T;
+    pagesMaterial: T;
+    scales: Vector3[];
+}
+
+declare interface RowOfBooksOptions<T extends Material = Material> {
+    coverMaterial: T;
+    pagesMaterial: T;
+    count?: number;
+    length?: number;
+    scaleXMin?: number;
+    scaleXMax?: number;
+    scaleYMin?: number;
+    scaleYMax?: number;
+    scaleZMin?: number;
+    scaleZMax?: number;
+}
+
+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;
+
+export declare const sineEaseOut: (t: number) => number;
+
+/**
+ * Smooths out the vertices by averaging their positions with neighboring vertices within a given radius.
+ */
+export declare const smoothBrush: <T extends BufferGeometry>(geometry: T, position: Vector3, radius: number, strength: number) => void;
+
+export declare const smoothstep: (t: number) => number;
+
+/**
+ * Convert spherical coordinates to Cartesian coordinates.
+ * @param {number} radius - The radius of the sphere.
+ * @param {number} theta - The azimuthal angle in radians (from the x-axis in the x-y plane).
+ * @param {number} phi - The polar angle in radians (from the positive z-axis).
+ * @returns {{x: number, y: number, z: number}} The Cartesian coordinates.
+ */
+export declare const sphericalToCartesian: (radius: number, theta: number, phi: number) => {
+    x: number;
+    y: number;
+    z: number;
+};
+
+/**
+ * Creates spikes or depressions centered on the target position, pushing vertices away or pulling them towards the center.
+ */
+export declare const spikeBrush: <T extends BufferGeometry>(geometry: T, position: Vector3, radius: number, strength: number, inward?: boolean, falloffFn?: (distance: number, radius: number) => number) => void;
+
+export declare class SpiralStaircaseGeometry extends BufferGeometry {
+    constructor(stepWidth?: number, stepDepth?: number, stepHeight?: number, numSteps?: number, radius?: number, angleIncrement?: number);
+}
+
+export declare class SpiralTube extends Group {
+    constructor();
+}
+
+export declare class SquareHeadstone extends Mesh {
+    constructor(width?: number, height?: number, depth?: number);
+}
+
+export declare class SquareHeadstoneGeometry extends BufferGeometry {
+    constructor(width?: number, height?: number, depth?: number);
+}
+
+export declare const squareRoot: (t: number) => number;
+
+export declare class StaircaseGeometry extends BufferGeometry {
+    constructor(width?: number, stepHeight?: number, stepDepth?: number, numSteps?: number);
+}
+
+export declare class Stand extends Mesh {
+    constructor({ radius, //
+        height, count, thickness, radialSegments, }?: {
+        radius?: number | undefined;
+        height?: number | undefined;
+        count?: number | undefined;
+        thickness?: number | undefined;
+        radialSegments?: number | undefined;
+    });
+}
+
+export declare class StandGeometry extends BufferGeometry {
+    constructor({ radius, //
+        height, count, thickness, radialSegments, }?: {
+        radius?: number | undefined;
+        height?: number | undefined;
+        count?: number | undefined;
+        thickness?: number | undefined;
+        radialSegments?: number | undefined;
+    });
+}
+
+export declare class Star extends Mesh {
+    constructor(points?: number, innerRadius?: number, outerRadius?: number, depth?: number);
+}
+
+export declare class StarShape extends Shape {
+    constructor(points?: number, innerRadius?: number, outerRadius?: number);
+}
+
+export declare class TeslaCoil extends Group {
+    constructor();
+}
+
+export declare class TestTube extends Group {
+    constructor(radiusTop?: number, radiusBottom?: number, height?: number, segments?: number);
+}
+
+export declare class TestTubeGeometry extends BufferGeometry {
+    constructor(radiusTop?: number, radiusBottom?: number, height?: number, segments?: number, openEnded?: boolean);
+}
+
+export declare class TestTubeRack extends Group {
+    constructor(count?: number, colors?: number[]);
+}
+
+/**
+ * @example
+ * const tree = new Tree({
+ *   trunkRadiusTop: 0.25,
+ *   trunkRadiusBottom: 0.4,
+ *   trunkHeight: 2.5,
+ *   trunkSegments: 14,
+ *   trunkColor: 0x8b4513,
+ *   leafSize: 0.8,
+ *   leafCount: 6,
+ *   leafDetail: 0,
+ *   leafSpreadRadius: 1.5,
+ *   leafColor: 0x228b22,
+ * });
+ */
+export declare class Tree extends Mesh {
+    constructor({ trunkRadiusTop, trunkRadiusBottom, trunkHeight, trunkSegments, trunkColor, leafSize, leafCount, leafDetail, leafSpreadRadius, leafColor, }?: {
+        trunkRadiusTop?: number | undefined;
+        trunkRadiusBottom?: number | undefined;
+        trunkHeight?: number | undefined;
+        trunkSegments?: number | undefined;
+        trunkColor?: number | undefined;
+        leafSize?: number | undefined;
+        leafCount?: number | undefined;
+        leafDetail?: number | undefined;
+        leafSpreadRadius?: number | undefined;
+        leafColor?: number | undefined;
+    });
+}
+
+/**
+ * Tree geometry, consisting of a trunk and leaves.
+ *
+ * Group order:
+ * - Trunk Material
+ * - Leaf Material
+ */
+export declare class TreeGeometry extends BufferGeometry {
+    constructor({ trunkRadiusTop, trunkRadiusBottom, trunkHeight, trunkSegments, leafSize, leafCount, leafDetail, leafSpreadRadius, }?: {
+        trunkRadiusTop?: number | undefined;
+        trunkRadiusBottom?: number | undefined;
+        trunkHeight?: number | undefined;
+        trunkSegments?: number | undefined;
+        leafSize?: number | undefined;
+        leafCount?: number | undefined;
+        leafDetail?: number | undefined;
+        leafSpreadRadius?: number | undefined;
+    });
+}
+
+/**
+ * Applies a twisting force to the vertices, rotating them around the direction defined by the target position.
+ */
+export declare const twistBrush: <T extends BufferGeometry>(geometry: T, position: Vector3, radius: number, strength: number, direction?: Vector3, falloffFn?: (distance: number, radius: number) => number) => void;
+
+/**
+ * Updates the time uniform of the material's shader to animate the noise effect.
+ * @param {Material} material - The material to update.
+ * @param {number} deltaTime - The time increment to add.
+ */
+export declare function updateNoiseDisplacementTime<T extends Material>(material: T, deltaTime: number): void;
+
+/**
+ * Updates the time uniform of the material's shader to animate the water effect.
+ * @param {Material} material - The material to update.
+ * @param {number} deltaTime - The time increment to add.
+ */
+export declare function updateWaterDisplacementTime<T extends Material>(material: T, deltaTime: number): void;
+
+export declare class WineBottle extends Mesh {
+    constructor();
+}
+
+export declare class WineBottleGeometry extends BufferGeometry {
+    constructor({ radius, neckRadius, height, neckHeight, segments }?: {
+        radius?: number | undefined;
+        neckRadius?: number | undefined;
+        height?: number | undefined;
+        neckHeight?: number | undefined;
+        segments?: number | undefined;
+    });
+}
+
+export declare class WroughtIronBar extends Mesh {
+    constructor({ barHeight, //
+        barRadius, spikeHeight, spikeRadius, spikeScaleZ, radialSegments, }?: {
+        barHeight?: number | undefined;
+        barRadius?: number | undefined;
+        spikeHeight?: number | undefined;
+        spikeRadius?: number | undefined;
+        spikeScaleZ?: number | undefined;
+        radialSegments?: number | undefined;
+    });
+}
+
+/**
+ * Wrought Iron Bar Geometry, a simple wrought iron bar shape
+ */
+export declare class WroughtIronBarGeometry extends BufferGeometry {
+    constructor({ barHeight, //
+        barRadius, spikeHeight, spikeRadius, spikeScaleZ, radialSegments, }?: {
+        barHeight?: number | undefined;
+        barRadius?: number | undefined;
+        spikeHeight?: number | undefined;
+        spikeRadius?: number | undefined;
+        spikeScaleZ?: number | undefined;
+        radialSegments?: number | undefined;
+    });
+}
+
+export declare class WroughtIronFence extends Mesh {
+    constructor({ count, //
+        spacing, barHeight, barRadius, spikeHeight, spikeRadius, spikeScaleZ, railHeight, railDepth, railOffset, radialSegments, }?: {
+        count?: number | undefined;
+        spacing?: number | undefined;
+        barHeight?: number | undefined;
+        barRadius?: number | undefined;
+        spikeHeight?: number | undefined;
+        spikeRadius?: number | undefined;
+        spikeScaleZ?: number | undefined;
+        railHeight?: number | undefined;
+        railDepth?: number | undefined;
+        railOffset?: number | undefined;
+        radialSegments?: number | undefined;
+    });
+}
+
+export declare class WroughtIronFenceGeometry extends BufferGeometry {
+    constructor({ count, //
+        spacing, barHeight, barRadius, spikeHeight, spikeRadius, spikeScaleZ, railHeight, railDepth, railOffset, radialSegments, }?: {
+        count?: number | undefined;
+        spacing?: number | undefined;
+        barHeight?: number | undefined;
+        barRadius?: number | undefined;
+        spikeHeight?: number | undefined;
+        spikeRadius?: number | undefined;
+        spikeScaleZ?: number | undefined;
+        railHeight?: number | undefined;
+        railDepth?: number | undefined;
+        railOffset?: number | undefined;
+        radialSegments?: number | undefined;
+    });
+}
+
+export { }