@needle-tools/three 0.169.12 → 0.169.13

package/types/examples/jsm/misc/ProgressiveLightMap.d.ts

@@ -0,0 +1,60 @@
+import {
+    Camera,
+    Material,
+    Mesh,
+    MeshBasicMaterial,
+    MeshPhongMaterial,
+    Object3D,
+    PlaneGeometry,
+    Scene,
+    Texture,
+    Vector3,
+    WebGLRenderer,
+    WebGLRenderTarget,
+} from "three";
+
+export interface UVBoxes {
+    w: number;
+    h: number;
+    index: number;
+}
+
+export interface LightMapContainers {
+    basicMat: Material | Material[];
+    object: Object3D;
+}
+
+export class ProgressiveLightMap {
+    renderer: WebGLRenderer;
+    res: number;
+    lightMapContainers: LightMapContainers[];
+    compiled: boolean;
+    scene: Scene;
+    tinyTarget: WebGLRenderTarget;
+    buffer1Active: boolean;
+    firstUpdate: boolean;
+    warned: boolean;
+
+    progressiveLightMap1: WebGLRenderTarget;
+    progressiveLightMap2: WebGLRenderTarget;
+
+    uvMat: MeshPhongMaterial;
+
+    uv_boxes: UVBoxes[];
+
+    blurringPlane: Mesh<PlaneGeometry, MeshBasicMaterial>;
+
+    labelMaterial: MeshBasicMaterial;
+    labelPlane: PlaneGeometry;
+    labelMesh: Mesh<PlaneGeometry, MeshBasicMaterial>;
+
+    constructor(renderer: WebGLRenderer, res?: number);
+
+    addObjectsToLightMap(objects: Object3D[]): void;
+
+    update(camera: Camera, blendWindow?: number, blurEdges?: boolean): void;
+
+    showDebugLightmap(visible: boolean, position?: Vector3): void;
+
+    private _initializeBlurPlane(res: number, lightMap?: Texture | null): void;
+}

package/types/examples/jsm/misc/RollerCoaster.d.ts

@@ -0,0 +1,26 @@
+import { BufferGeometry, Mesh, Vector3 } from "three";
+
+interface Curve {
+    getPointAt(u: number): Vector3;
+    getTangentAt(u: number): Vector3;
+}
+
+export class RollerCoasterGeometry extends BufferGeometry {
+    constructor(curve: Curve, divisions: number);
+}
+
+export class RollerCoasterLiftersGeometry extends BufferGeometry {
+    constructor(curve: Curve, divisions: number);
+}
+
+export class RollerCoasterShadowGeometry extends BufferGeometry {
+    constructor(curve: Curve, divisions: number);
+}
+
+export class SkyGeometry extends BufferGeometry {
+    constructor();
+}
+
+export class TreesGeometry extends BufferGeometry {
+    constructor(landscape: Mesh);
+}

package/types/examples/jsm/misc/Timer.d.ts

@@ -0,0 +1,80 @@
+/**
+ * This class is an alternative to {@link THREE.Clock} with a different API design and behavior
+ * The goal is to avoid the conceptual flaws that became apparent in {@link THREE.Clock} over time.
+ *
+ * - {@link Timer} has an {@link .update()} method that updates its internal state. That makes it possible to call
+ *   {@link .getDelta()} and {@link .getElapsed()} multiple times per simulation step without getting different values.
+ * - The class uses the Page Visibility API to avoid large time delta values when the app is inactive (e.g. tab switched
+ *   or browser hidden).
+ *
+ * @example
+ * const timer = new Timer();
+ *
+ * function animate(timestamp) {
+ *   requestAnimationFrame(animate);
+ *   // timestamp is optional
+ *   timer.update(timestamp);
+ *   const delta = timer.getDelta();
+ *   // do something with delta
+ *   renderer.render(scene, camera);
+ * }
+ *
+ * @see https://threejs.org/examples/#webgl_morphtargets_sphere
+ */
+export class Timer {
+    constructor();
+
+    /**
+     * Returns the time delta in seconds.
+     */
+    getDelta(): number;
+
+    /**
+     * Returns the elapsed time in seconds.
+     */
+    getElapsed(): number;
+
+    /**
+     * Returns the time scale.
+     */
+    getTimescale(): number;
+
+    /**
+     * Sets a time scale that scales the time delta in {@link .update()}.
+     */
+    setTimescale(timescale: number): this;
+
+    /**
+     * Resets the time computation for the current simulation step.
+     */
+    reset(): this;
+
+    /**
+     * Can be used to free all internal resources. Usually called when the timer instance isn't required anymore.
+     */
+    dispose(): this;
+
+    /**
+     * Updates the internal state of the timer. This method should be called once per simulation step and before you
+     * perform queries against the timer (e.g. via {@link getDelta()}).
+     *
+     * @param timescale (optional) The current time in milliseconds. Can be obtained from the {@link https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame | requestAnimationFrame} callback argument. If not provided, the current time will be determined with {@link https://developer.mozilla.org/en-US/docs/Web/API/Performance/now | performance.now}.
+     */
+    update(timestamp?: number): this;
+}
+
+/**
+ * A timer that uses a fixed delta.
+ */
+export class FixedTimer extends Timer {
+    /**
+     * @param fps The desired fixed delta expressed in frames per second.
+     */
+    constructor(fps?: number);
+
+    /**
+     * Updates the internal state of the timer. This method should be called once per simulation step and before you
+     * perform queries against the timer (e.g. via {@link getDelta()}).
+     */
+    override update(): this;
+}

package/types/examples/jsm/misc/TubePainter.d.ts

@@ -0,0 +1,10 @@
+import { Matrix4, Mesh, Vector3 } from "three";
+
+export class TubePainter {
+    constructor();
+
+    mesh: Mesh;
+
+    stroke(position1: Vector3, position2: Vector3, matrix1: Matrix4, matrix2: Matrix4): void;
+    updateGeometry(start: number, end: number): void;
+}

package/types/examples/jsm/misc/Volume.d.ts

@@ -0,0 +1,37 @@
+import { Matrix3, TypedArray } from "three";
+
+import { VolumeSlice } from "./VolumeSlice.js";
+
+export class Volume {
+    constructor(xLength?: number, yLength?: number, zLength?: number, type?: string, arrayBuffer?: ArrayLike<number>);
+
+    xLength: number;
+    yLength: number;
+    zLength: number;
+
+    axisOrder: Array<"x" | "y" | "z">;
+
+    data: TypedArray;
+
+    spacing: number[];
+    offset: number[];
+
+    matrix: Matrix3;
+
+    lowerThreshold: number;
+    upperThreshold: number;
+
+    sliceList: VolumeSlice[];
+
+    getData(i: number, j: number, k: number): number;
+    access(i: number, j: number, k: number): number;
+    reverseAccess(index: number): number[];
+
+    map(functionToMap: () => void, context: this): this;
+
+    extractPerpendicularPlane(axis: string, RASIndex: number): object;
+    extractSlice(axis: string, index: number): VolumeSlice;
+
+    repaintAllSlices(): this;
+    computeMinMax(): number[];
+}

package/types/examples/jsm/misc/VolumeSlice.d.ts

@@ -0,0 +1,28 @@
+import { Matrix3, Mesh } from "three";
+
+import { Volume } from "./Volume.js";
+
+export class VolumeSlice {
+    constructor(volume: Volume, index?: number, axis?: string);
+
+    index: number;
+    axis: string;
+
+    canvas: HTMLCanvasElement;
+    canvasBuffer: HTMLCanvasElement;
+
+    ctx: CanvasRenderingContext2D;
+    ctxBuffer: CanvasRenderingContext2D;
+
+    mesh: Mesh;
+
+    geometryNeedsUpdate: boolean;
+
+    sliceAccess: number;
+    jLength: number;
+    iLength: number;
+    matrix: Matrix3;
+
+    repaint(): void;
+    updateGeometry(): void;
+}

package/types/examples/jsm/modifiers/CurveModifier.d.ts

@@ -0,0 +1,41 @@
+import { BufferGeometry, Curve, DataTexture, InstancedMesh, IUniform, Material, Mesh, Vector3 } from "three";
+
+export interface SplineUniform {
+    spineTexture: IUniform;
+    pathOffset: IUniform;
+    pathSegment: IUniform;
+    spineOffset: IUniform;
+    flow: IUniform;
+}
+export function initSplineTexture(numberOfCurves?: number): DataTexture;
+
+export function updateSplineTexture(texture: DataTexture, splineCurve: Curve<Vector3>, offset?: number): void;
+
+export function getUniforms(splineTexture: DataTexture): SplineUniform;
+
+export function modifyShader(material: Material, uniforms: SplineUniform, numberOfCurves?: number): void;
+
+export class Flow {
+    curveArray: number[];
+    curveLengthArray: number[];
+
+    object3D: Mesh;
+    splineTexure: DataTexture;
+    uniforms: SplineUniform;
+
+    constructor(mesh: Mesh, numberOfCurves?: number);
+    updateCurve(index: number, curve: Curve<Vector3>): void;
+    moveAlongCurve(amount: number): void;
+}
+
+export class InstancedFlow extends Flow {
+    object3D: InstancedMesh;
+
+    offsets: number[];
+    whichCurve: number[];
+
+    constructor(count: number, curveCount: number, geometry: BufferGeometry, material: Material);
+
+    moveIndividualAlongCurve(index: number, offset: number): void;
+    setCurve(index: number, curveNo: number): void;
+}

package/types/examples/jsm/modifiers/CurveModifierGPU.d.ts

@@ -0,0 +1,31 @@
+import { BufferGeometry, Curve, DataTexture, InstancedMesh, IUniform, Material, Mesh, Vector3 } from "three";
+
+export interface SplineUniform {
+    spineTexture: DataTexture;
+    pathOffset: number;
+    pathSegment: number;
+    spineOffset: number;
+    spineLength: number;
+    flow: number;
+}
+export function initSplineTexture(numberOfCurves?: number): DataTexture;
+
+export function updateSplineTexture(texture: DataTexture, splineCurve: Curve<Vector3>, offset?: number): void;
+
+export function getUniforms(splineTexture: DataTexture): SplineUniform;
+
+export function modifyShader(material: Material, uniforms: SplineUniform, numberOfCurves: number): void;
+
+export class Flow {
+    curveArray: number[];
+    curveLengthArray: number[];
+
+    object3D: Mesh;
+    splineTexure: DataTexture;
+    uniforms: SplineUniform;
+
+    constructor(mesh: Mesh, numberOfCurves?: number);
+
+    updateCurve(index: number, curve: Curve<Vector3>): void;
+    moveAlongCurve(amount: number): void;
+}

package/types/examples/jsm/modifiers/EdgeSplitModifier.d.ts

@@ -0,0 +1,26 @@
+import { BufferGeometry } from "three";
+
+/**
+ * {@link EdgeSplitModifier} is intended to modify the geometry "dissolving" the edges to give a smoother look.
+ *
+ * @example
+ * const geometry = new THREE.IcosahedronGeometry( 10, 3 );
+ * const modifier = new EdgeSplitModifier();
+ * const cutOffAngle = 0.5;
+ * const tryKeepNormals = false;
+ *
+ * modifier.modify( geometry, cutOffAngle, tryKeepNormals );
+ */
+export class EdgeSplitModifier {
+    /**
+     * Create a new {@link EdgeSplitModifier} object.
+     */
+    constructor();
+
+    /**
+     * Using interpolated vertex normals, the mesh faces will blur at the edges and appear smooth.
+     * You can control the smoothness by setting the `cutOffAngle`.
+     * To try to keep the original normals, set `tryKeepNormals` to `true`.
+     */
+    modify(geometry: BufferGeometry, cutOffPoint: number, tryKeepNormals: boolean): BufferGeometry;
+}

package/types/examples/jsm/modifiers/SimplifyModifier.d.ts

@@ -0,0 +1,6 @@
+import { BufferGeometry } from "three";
+
+export class SimplifyModifier {
+    constructor();
+    modify(geometry: BufferGeometry, count: number): BufferGeometry;
+}

package/types/examples/jsm/modifiers/TessellateModifier.d.ts

@@ -0,0 +1,9 @@
+import { BufferGeometry } from "three";
+
+export class TessellateModifier {
+    constructor(maxEdgeLength?: number, maxIterations?: number);
+    maxEdgeLength: number;
+    maxIterations: number;
+
+    modify<TGeometry extends BufferGeometry>(geometry: TGeometry): TGeometry;
+}

package/types/examples/jsm/objects/GroundedSkybox.d.ts

@@ -0,0 +1,5 @@
+import { Mesh, MeshBasicMaterial, SphereGeometry, Texture } from "three";
+
+export class GroundedSkybox extends Mesh<SphereGeometry, MeshBasicMaterial> {
+    constructor(map: Texture, height: number, radius: number, resolution?: number);
+}

package/types/examples/jsm/objects/Lensflare.d.ts

@@ -0,0 +1,21 @@
+import { Color, Mesh, Texture } from "three";
+
+declare class Lensflare extends Mesh {
+    readonly isLensflare: true;
+
+    constructor();
+
+    addElement: (element: LensflareElement) => void;
+    dispose: () => void;
+}
+
+declare class LensflareElement {
+    texture: Texture;
+    size: number;
+    distance: number;
+    color: Color;
+
+    constructor(texture: Texture, size?: number, distance?: number, color?: Color);
+}
+
+export { Lensflare, LensflareElement };

package/types/examples/jsm/objects/LensflareMesh.d.ts

@@ -0,0 +1,21 @@
+import { Color, Mesh, Texture } from "three";
+
+declare class LensflareMesh extends Mesh {
+    readonly isLensflare: true;
+
+    constructor();
+
+    addElement: (element: LensflareElement) => void;
+    dispose: () => void;
+}
+
+declare class LensflareElement {
+    texture: Texture;
+    size: number;
+    distance: number;
+    color: Color;
+
+    constructor(texture: Texture, size?: number, distance?: number, color?: Color);
+}
+
+export { LensflareElement, LensflareMesh };

package/types/examples/jsm/objects/MarchingCubes.d.ts

@@ -0,0 +1,76 @@
+import { BufferGeometry, Color, Material, Mesh } from "three";
+
+export class MarchingCubes extends Mesh {
+    constructor(
+        resolution: number,
+        material: Material,
+        enableUvs?: boolean,
+        enableColors?: boolean,
+        maxPolyCount?: number,
+    );
+
+    enableUvs: boolean;
+    enableColors: boolean;
+
+    resolution: number;
+
+    // parameters
+
+    isolation: number;
+
+    // size of field, 32 is pushing it in Javascript :)
+
+    size: number;
+    size2: number;
+    size3: number;
+    halfsize: number;
+
+    // deltas
+
+    delta: number;
+    yd: number;
+    zd: number;
+
+    field: Float32Array;
+    normal_cache: Float32Array;
+    palette: Float32Array;
+
+    maxCount: number;
+    count: number;
+
+    hasPositions: boolean;
+    hasNormals: boolean;
+    hasColors: boolean;
+    hasUvs: boolean;
+
+    positionArray: Float32Array;
+    normalArray: Float32Array;
+
+    uvArray: Float32Array;
+    colorArray: Float32Array;
+
+    begin(): void;
+    end(): void;
+
+    init(resolution: number): void;
+
+    addBall(ballx: number, bally: number, ballz: number, strength: number, subtract: number, colors?: Color): void;
+
+    addPlaneX(strength: number, subtract: number): void;
+    addPlaneY(strength: number, subtract: number): void;
+    addPlaneZ(strength: number, subtract: number): void;
+
+    setCell(x: number, y: number, z: number, value: number): void;
+    getCell(x: number, y: number, z: number): number;
+
+    blur(intensity: number): void;
+
+    reset(): void;
+    update(): void;
+    render(renderCallback: any): void;
+    generateGeometry(): BufferGeometry;
+    generateBufferGeometry(): BufferGeometry;
+}
+
+export const edgeTable: Int32Array[];
+export const triTable: Int32Array[];

package/types/examples/jsm/objects/Reflector.d.ts

@@ -0,0 +1,21 @@
+import { BufferGeometry, ColorRepresentation, Mesh, PerspectiveCamera, WebGLRenderTarget } from "three";
+
+export interface ReflectorOptions {
+    color?: ColorRepresentation | undefined;
+    textureWidth?: number | undefined;
+    textureHeight?: number | undefined;
+    clipBias?: number | undefined;
+    shader?: object | undefined;
+    multisample?: number | undefined;
+}
+
+export class Reflector extends Mesh {
+    type: "Reflector";
+    camera: PerspectiveCamera;
+
+    constructor(geometry?: BufferGeometry, options?: ReflectorOptions);
+
+    getRenderTarget(): WebGLRenderTarget;
+
+    dispose(): void;
+}

package/types/examples/jsm/objects/ReflectorForSSRPass.d.ts

@@ -0,0 +1,62 @@
+import {
+    BufferGeometry,
+    Camera,
+    Color,
+    IUniform,
+    Mesh,
+    Scene,
+    ShaderMaterial,
+    Vector2,
+    WebGLRenderer,
+    WebGLRenderTarget,
+} from "three";
+
+export interface ReflectorShader {
+    name: string;
+    defines: {
+        DISTANCE_ATTENUATION: boolean;
+        FRESNEL: boolean;
+    };
+    uniforms: {
+        [key: string]: IUniform;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+}
+
+export interface ReflectorForSSRPassOptions {
+    clipBias?: number | undefined;
+    textureWidth?: number | undefined;
+    textureHeight?: number | undefined;
+    color?: number | undefined;
+    useDepthTexture?: boolean | undefined;
+    shader?: ReflectorShader | undefined;
+}
+
+export class ReflectorForSSRPass<TGeometry extends BufferGeometry = BufferGeometry> extends Mesh<TGeometry> {
+    type: "ReflectorForSSRPass";
+    options: ReflectorForSSRPassOptions;
+
+    static ReflectorShader: ReflectorShader;
+
+    needsUpdate: boolean;
+    maxDistance: number;
+    opacity: number;
+    color: Color;
+    resolution: Vector2;
+
+    get distanceAttenuation(): boolean;
+    set distanceAttenuation(val: boolean);
+    get fresnel(): boolean;
+    set fresnel(val: boolean);
+
+    material: ShaderMaterial;
+
+    renderTarget: WebGLRenderTarget;
+
+    constructor(geometry: TGeometry, options: ReflectorForSSRPassOptions);
+
+    doRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera) => void;
+
+    getRenderTarget: () => WebGLRenderTarget;
+}

package/types/examples/jsm/objects/Refractor.d.ts

@@ -0,0 +1,21 @@
+import { BufferGeometry, ColorRepresentation, Mesh, PerspectiveCamera, ShaderMaterial, WebGLRenderTarget } from "three";
+
+export interface RefractorOptions {
+    color?: ColorRepresentation | undefined;
+    textureWidth?: number | undefined;
+    textureHeight?: number | undefined;
+    clipBias?: number | undefined;
+    shader?: object | undefined;
+    multisample?: number | undefined;
+}
+
+export class Refractor extends Mesh<BufferGeometry, ShaderMaterial> {
+    type: "Refractor";
+    camera: PerspectiveCamera;
+
+    constructor(geometry?: BufferGeometry, options?: RefractorOptions);
+
+    getRenderTarget(): WebGLRenderTarget;
+
+    dispose(): void;
+}

package/types/examples/jsm/objects/ShadowMesh.d.ts

@@ -0,0 +1,10 @@
+import { BufferGeometry, Matrix4, Mesh, MeshBasicMaterial, Plane, Vector4 } from "three";
+
+export class ShadowMesh extends Mesh<BufferGeometry, MeshBasicMaterial> {
+    readonly isShadowMesh: true;
+    meshMatrix: Matrix4;
+
+    constructor(mesh: Mesh);
+
+    update(plane: Plane, lightPosition4D: Vector4): void;
+}

package/types/examples/jsm/objects/Sky.d.ts

@@ -0,0 +1,28 @@
+import { BoxGeometry, Mesh, ShaderMaterial } from "three";
+
+/**
+ * {@link Sky} creates a ready to go sky environment for your scenes.
+ *
+ * @example
+ * const sky = new Sky();
+ * sky.scale.setScalar( 450000 );
+ *
+ * const phi = MathUtils.degToRad( 90 );
+ * const theta = MathUtils.degToRad( 180 );
+ * const sunPosition = new Vector3().setFromSphericalCoords( 1, phi, theta );
+ *
+ * sky.material.uniforms.sunPosition.value = sunPosition;
+ *
+ * scene.add( sky );
+ */
+export class Sky extends Mesh {
+    /**
+     * Create a new {@link Sky} instance.
+     */
+    constructor();
+
+    geometry: BoxGeometry;
+    material: ShaderMaterial;
+
+    static SkyShader: object;
+}

package/types/examples/jsm/objects/SkyMesh.d.ts

@@ -0,0 +1,17 @@
+import { ShaderNodeObject, UniformNode } from "three/tsl";
+import { BoxGeometry, Mesh, NodeMaterial, Vector3 } from "three/webgpu";
+
+declare class SkyMesh extends Mesh<BoxGeometry, NodeMaterial> {
+    turbidity: ShaderNodeObject<UniformNode<number>>;
+    rayleigh: ShaderNodeObject<UniformNode<number>>;
+    mieCoefficient: ShaderNodeObject<UniformNode<number>>;
+    mieDirectionalG: ShaderNodeObject<UniformNode<number>>;
+    sunPosition: ShaderNodeObject<UniformNode<Vector3>>;
+    upUniform: ShaderNodeObject<UniformNode<Vector3>>;
+
+    readonly isSky: true;
+
+    constructor();
+}
+
+export { SkyMesh };

package/types/examples/jsm/objects/Water.d.ts

@@ -0,0 +1,22 @@
+import { BufferGeometry, ColorRepresentation, Mesh, ShaderMaterial, Side, Texture, Vector3 } from "three";
+
+export interface WaterOptions {
+    textureWidth?: number;
+    textureHeight?: number;
+    clipBias?: number;
+    alpha?: number;
+    time?: number;
+    waterNormals?: Texture;
+    sunDirection?: Vector3;
+    sunColor?: ColorRepresentation;
+    waterColor?: ColorRepresentation;
+    eye?: Vector3;
+    distortionScale?: number;
+    side?: Side;
+    fog?: boolean;
+}
+
+export class Water extends Mesh {
+    material: ShaderMaterial;
+    constructor(geometry: BufferGeometry, options: WaterOptions);
+}