@needle-tools/three 0.169.12 → 0.169.14

package/types/examples/jsm/loaders/TDSLoader.d.ts

@@ -0,0 +1,35 @@
+import { Color, Group, Loader, LoadingManager, Material, Mesh, Texture } from "three";
+
+export class TDSLoader extends Loader<Group> {
+    constructor(manager?: LoadingManager);
+    debug: boolean;
+    group: Group;
+    manager: LoadingManager;
+    materials: Material[];
+    meshes: Mesh[];
+    position: number;
+
+    parse(arraybuffer: ArrayBuffer, path: string): Group;
+
+    debugMessage(message: object): void;
+    endChunk(chunk: object): void;
+    nextChunk(data: DataView, chunk: object): void;
+    readByte(data: DataView): number;
+    readChunk(data: DataView): object;
+    readColor(data: DataView): Color;
+    readDWord(data: DataView): number;
+    readFaceArray(data: DataView, mesh: Mesh): void;
+    readFile(arraybuffer: ArrayBuffer, path: string): void;
+    readFloat(data: DataView): number;
+    readInt(data: DataView): number;
+    readMap(data: DataView, path: string): Texture;
+    readMesh(data: DataView): Mesh;
+    readMeshData(data: DataView, path: string): void;
+    readMaterialEntry(data: DataView, path: string): void;
+    readMaterialGroup(data: DataView): object;
+    readNamedObject(data: DataView): void;
+    readShort(data: DataView): number;
+    readString(data: DataView, maxLength: number): string;
+    readWord(data: DataView): number;
+    resetPosition(): void;
+}

package/types/examples/jsm/loaders/TGALoader.d.ts

@@ -0,0 +1,7 @@
+import { DataTexture, DataTextureLoader, LoadingManager } from "three";
+
+export class TGALoader extends DataTextureLoader {
+    constructor(manager?: LoadingManager);
+
+    parse(data: ArrayBuffer): DataTexture;
+}

package/types/examples/jsm/loaders/TIFFLoader.d.ts

@@ -0,0 +1,16 @@
+import { DataTextureLoader, LoadingManager, TextureFilter } from "three";
+
+export interface TIFFResult {
+    width: number;
+    height: number;
+    data: Uint8Array;
+    flipY: true;
+    magFilter: TextureFilter;
+    minFilter: TextureFilter;
+}
+
+export class TIFFLoader extends DataTextureLoader {
+    constructor(manager?: LoadingManager);
+
+    parse(buffer: Iterable<number>): TIFFResult;
+}

package/types/examples/jsm/loaders/TTFLoader.d.ts

@@ -0,0 +1,10 @@
+import { Loader, LoadingManager } from "three";
+import { FontData } from "./FontLoader.js";
+
+export class TTFLoader extends Loader<FontData> {
+    reversed: boolean;
+
+    constructor(manager?: LoadingManager);
+
+    parse(arraybuffer: ArrayBuffer): FontData;
+}

package/types/examples/jsm/loaders/USDZLoader.d.ts

@@ -0,0 +1,11 @@
+import { Group, Loader, LoadingManager, Mesh } from "three";
+
+export class USDAParser {
+    parse(text: string): object;
+}
+
+export class USDZLoader extends Loader<Mesh> {
+    constructor(manager?: LoadingManager);
+
+    parse(buffer: ArrayBuffer | string): Group;
+}

package/types/examples/jsm/loaders/UltraHDRLoader.d.ts

@@ -0,0 +1,21 @@
+import { DataTexture, Loader, LoadingManager, RGBAFormat, TextureDataType } from "three";
+
+interface UltraHDRLoaderTextureData {
+    width: number;
+    height: number;
+    hdrBuffer: Uint16Array | Float32Array;
+    format: typeof RGBAFormat;
+    type: TextureDataType;
+}
+
+declare class UltraHDRLoader extends Loader<DataTexture> {
+    type: TextureDataType;
+
+    constructor(manager?: LoadingManager);
+
+    setDataType(value: TextureDataType): this;
+
+    parse(buffer: ArrayBuffer, onLoad: (texData: UltraHDRLoaderTextureData) => void): void;
+}
+
+export { UltraHDRLoader };

package/types/examples/jsm/loaders/VOXLoader.d.ts

@@ -0,0 +1,21 @@
+import { Data3DTexture, Loader, LoadingManager, Mesh } from "three";
+
+export interface Chunk {
+    palette: number[];
+    size: { x: number; y: number; z: number };
+    data: Uint8Array;
+}
+
+export class VOXLoader extends Loader<Chunk[]> {
+    constructor(manager?: LoadingManager);
+
+    parse(data: ArrayBuffer): object[];
+}
+
+export class VOXMesh extends Mesh {
+    constructor(chunk: Chunk);
+}
+
+export class VOXData3DTexture extends Data3DTexture {
+    constructor(chunk: Chunk);
+}

package/types/examples/jsm/loaders/VRMLLoader.d.ts

@@ -0,0 +1,7 @@
+import { Loader, LoadingManager, Scene } from "three";
+
+export class VRMLLoader extends Loader<Scene> {
+    constructor(manager?: LoadingManager);
+
+    parse(data: string, path: string): Scene;
+}

package/types/examples/jsm/loaders/VTKLoader.d.ts

@@ -0,0 +1,7 @@
+import { BufferGeometry, Loader, LoadingManager } from "three";
+
+export class VTKLoader extends Loader<BufferGeometry> {
+    constructor(manager?: LoadingManager);
+
+    parse(data: ArrayBuffer | string, path: string): BufferGeometry;
+}

package/types/examples/jsm/loaders/XYZLoader.d.ts

@@ -0,0 +1,7 @@
+import { BufferGeometry, Loader, LoadingManager } from "three";
+
+export class XYZLoader extends Loader<BufferGeometry> {
+    constructor(manager?: LoadingManager);
+
+    parse(data: string, onLoad: (geometry: BufferGeometry) => void): object;
+}

package/types/examples/jsm/materials/MeshGouraudMaterial.d.ts

@@ -0,0 +1,16 @@
+/**
+ * MeshGouraudMaterial
+ *
+ * Lambert illumination model with Gouraud (per-vertex) shading
+ */
+
+import { ShaderMaterial, ShaderMaterialParameters } from "three";
+
+export class MeshGouraudMaterial extends ShaderMaterial {
+    isMeshGouraudMaterial: true;
+    type: "MeshGouraudMaterial";
+
+    constructor(parameters?: ShaderMaterialParameters);
+
+    copy(source: MeshGouraudMaterial): this;
+}

package/types/examples/jsm/materials/MeshPostProcessingMaterial.d.ts

@@ -0,0 +1,13 @@
+import { MeshPhysicalMaterial, MeshPhysicalMaterialParameters, Texture } from "three";
+
+export interface MeshPostProcessingMaterialParameters extends MeshPhysicalMaterialParameters {
+    aoPassMap?: Texture | null | undefined;
+    aoPassMapScale?: number | undefined;
+}
+
+export class MeshPostProcessingMaterial extends MeshPhysicalMaterial {
+    constructor(parameters: MeshPostProcessingMaterialParameters);
+
+    get aoPassMap(): Texture | null | undefined;
+    set aoPassMap(aoPassMap: Texture | null | undefined);
+}

package/types/examples/jsm/math/Capsule.d.ts

@@ -0,0 +1,26 @@
+import { Box3, Line3, Vector3 } from "three";
+
+export class Capsule {
+    constructor(start?: Vector3, end?: Vector3, radius?: number);
+    start: Vector3;
+    end: Vector3;
+    radius: number;
+
+    set(start: Vector3, end: Vector3, radius: number): this;
+    clone(): Capsule;
+    copy(capsule: Capsule): this;
+    getCenter(target: Vector3): Vector3;
+    translate(v: Vector3): this;
+    checkAABBAxis(
+        p1x: number,
+        p1y: number,
+        p2x: number,
+        p2y: number,
+        minx: number,
+        maxx: number,
+        miny: number,
+        maxy: number,
+        radius: number,
+    ): boolean;
+    intersectsBox(box: Box3): boolean;
+}

package/types/examples/jsm/math/ColorConverter.d.ts

@@ -0,0 +1,19 @@
+import { Color } from "three";
+
+export interface HSL {
+    h: number;
+    s: number;
+    l: number;
+}
+
+export interface CMYK {
+    c: number;
+    m: number;
+    y: number;
+    k: number;
+}
+
+export namespace ColorConverter {
+    function setHSV(color: Color, h: number, s: number, v: number): Color;
+    function getHSV(color: Color, target: HSL): HSL;
+}

package/types/examples/jsm/math/ConvexHull.d.ts

@@ -0,0 +1,89 @@
+import { Object3D, Ray, Vector3 } from "three";
+
+export class Face {
+    constructor();
+    normal: Vector3;
+    midpoint: Vector3;
+    area: number;
+    constant: number;
+    outside: VertexNode;
+    mark: number;
+    edge: HalfEdge;
+
+    static create(a: VertexNode, b: VertexNode, c: VertexNode): Face;
+
+    compute(): this;
+    getEdge(i: number): HalfEdge;
+}
+
+export class HalfEdge {
+    constructor(vertex: VertexNode, face: Face);
+    vertex: VertexNode;
+    prev: HalfEdge;
+    next: HalfEdge;
+    twin: HalfEdge;
+    face: Face;
+
+    head(): VertexNode;
+    length(): number;
+    lengthSquared(): number;
+    setTwin(edge: HalfEdge): this;
+    tail(): VertexNode;
+}
+
+export class VertexNode {
+    constructor(point: Vector3);
+    point: Vector3;
+    prev: VertexNode;
+    next: VertexNode;
+    face: Face;
+}
+
+export class VertexList {
+    constructor();
+    head: VertexNode;
+    tail: VertexNode;
+
+    append(vertex: VertexNode): this;
+    appendChain(vertex: VertexNode): this;
+    clear(): this;
+    first(): VertexNode;
+    insertAfter(target: VertexNode, vertex: VertexNode): this;
+    insertBefore(target: VertexNode, vertex: VertexNode): this;
+    isEmpty(): boolean;
+    last(): VertexNode;
+    remove(vertex: VertexNode): this;
+    removeSubList(a: VertexNode, b: VertexNode): this;
+}
+
+export class ConvexHull {
+    constructor();
+    tolerance: number;
+    faces: Face[];
+    newFaces: Face[];
+    assigned: VertexList;
+    unassigned: VertexList;
+    vertices: VertexNode[];
+
+    addAdjoiningFace(eyeVertex: VertexNode, horizonEdge: HalfEdge): HalfEdge;
+    addNewFaces(eyeVertex: VertexNode, horizon: HalfEdge[]): this;
+    addVertexToFace(vertex: VertexNode, face: Face): this;
+    addVertexToHull(eyeVertex: VertexNode): this;
+    cleanup(): this;
+    compute(): this;
+    computeExtremes(): object;
+    computeHorizon(eyePoint: Vector3, crossEdge: HalfEdge, face: Face, horizon: HalfEdge[]): this;
+    computeInitialHull(): this;
+    containsPoint(point: Vector3): boolean;
+    deleteFaceVertices(face: Face, absorbingFace: Face): this;
+    intersectRay(ray: Ray, target: Vector3): Vector3 | null;
+    intersectsRay(ray: Ray): boolean;
+    makeEmpty(): this;
+    nextVertexToAdd(): VertexNode | undefined;
+    reindexFaces(): this;
+    removeAllVerticesFromFace(face: Face): VertexNode | undefined;
+    removeVertexFromFace(vertex: VertexNode, face: Face): this;
+    resolveUnassignedPoints(newFaces: Face[]): this;
+    setFromPoints(points: Vector3[]): this;
+    setFromObject(object: Object3D): this;
+}

package/types/examples/jsm/math/ImprovedNoise.d.ts

@@ -0,0 +1,4 @@
+export class ImprovedNoise {
+    constructor();
+    noise(x: number, y: number, z: number): number;
+}

package/types/examples/jsm/math/Lut.d.ts

@@ -0,0 +1,27 @@
+import { Color } from "three";
+
+export class Lut {
+    constructor(colormap?: string, numberofcolors?: number);
+    lut: Color[];
+    map: object[];
+    n: number;
+    minV: number;
+    maxV: number;
+
+    set(value: Lut): this;
+    setMin(min: number): this;
+    setMax(max: number): this;
+    setColorMap(colormap?: string, numberofcolors?: number): this;
+    copy(lut: Lut): this;
+    getColor(alpha: number): Color;
+    addColorMap(colormapName: string, arrayOfColors: number[][]): void;
+    createCanvas(): HTMLCanvasElement;
+    updateCanvas(canvas: HTMLCanvasElement): HTMLCanvasElement;
+}
+
+export interface ColorMapKeywords {
+    rainbow: number[][];
+    cooltowarm: number[][];
+    blackbody: number[][];
+    grayscale: number[][];
+}

package/types/examples/jsm/math/MeshSurfaceSampler.d.ts

@@ -0,0 +1,21 @@
+import { BufferGeometry, Color, Mesh, Vector2, Vector3 } from "three";
+
+export class MeshSurfaceSampler {
+    distribution: Float32Array | null;
+    geometry: BufferGeometry;
+    positionAttribute: Float32Array;
+    weightAttribute: string | null;
+
+    constructor(mesh: Mesh);
+    binarySearch(x: number): number;
+    build(): this;
+    sample(targetPosition: Vector3, targetNormal?: Vector3, targetColor?: Color, targetUV?: Vector2): this;
+    sampleFace(
+        faceIndex: number,
+        targetPosition: Vector3,
+        targetNormal?: Vector3,
+        targetColor?: Color,
+        targetUV?: Vector2,
+    ): this;
+    setWeightAttribute(name: string | null): this;
+}

package/types/examples/jsm/math/OBB.d.ts

@@ -0,0 +1,24 @@
+import { Box3, Matrix3, Matrix4, Plane, Ray, Sphere, Vector3 } from "three";
+
+export class OBB {
+    center: Vector3;
+    halfSize: Vector3;
+    rotation: Matrix3;
+
+    constructor(center?: Vector3, halfSize?: Vector3, rotation?: Matrix3);
+    set(center: Vector3, halfSize: Vector3, rotation: Matrix3): this;
+    copy(obb: OBB): this;
+    clone(): this;
+    getSize(result: Vector3): Vector3;
+    clampPoint(point: Vector3, result: Vector3): Vector3;
+    containsPoint(point: Vector3): boolean;
+    intersectsBox3(box3: Box3): boolean;
+    intersectsSphere(sphere: Sphere): boolean;
+    intersectsOBB(obb: OBB, epsilon?: number): boolean;
+    intersectsPlane(plane: Plane): boolean;
+    intersectRay(ray: Ray, result: Vector3): Vector3 | null;
+    intersectsRay(ray: Ray): boolean;
+    fromBox3(box3: Box3): this;
+    equals(obb: OBB): boolean;
+    applyMatrix4(matrix: Matrix4): this;
+}

package/types/examples/jsm/math/Octree.d.ts

@@ -0,0 +1,29 @@
+import { Box3, Layers, Object3D, Ray, Sphere, Triangle } from "three";
+
+import { Capsule } from "./Capsule.js";
+
+export class Octree {
+    box: Box3 | null | undefined;
+    bounds: Box3;
+
+    subTrees: Octree[];
+    triangles: Triangle[];
+    layers: Layers;
+
+    constructor(box?: Box3 | null);
+
+    addTriangle(triangle: Triangle): this;
+    calcBox(): this;
+    split(level: number): this;
+    build(): this;
+    getRayTriangles(ray: Ray, triangles: Triangle[]): Triangle[];
+    triangleCapsuleIntersect(capsule: Capsule, triangle: Triangle): any;
+    triangleSphereIntersect(sphere: Sphere, triangle: Triangle): any;
+    getSphereTriangles(sphere: Sphere, triangles: Triangle[]): Triangle[];
+    getCapsuleTriangles(capsule: Capsule, triangles: Triangle[]): Triangle[];
+    sphereIntersect(sphere: Sphere): any;
+    capsuleIntersect(capsule: Capsule): any;
+    rayIntersect(ray: Ray): any;
+    fromGraphNode(group: Object3D): this;
+    clear(): this;
+}

package/types/examples/jsm/math/SimplexNoise.d.ts

@@ -0,0 +1,9 @@
+export class SimplexNoise {
+    constructor(r?: object);
+    dot(g: number[], x: number, y: number): number;
+    dot3(g: number[], x: number, y: number, z: number): number;
+    dot4(g: number[], x: number, y: number, z: number, w: number): number;
+    noise(xin: number, yin: number): number;
+    noise3d(xin: number, yin: number, zin: number): number;
+    noise4d(x: number, y: number, z: number, w: number): number;
+}

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

@@ -0,0 +1,25 @@
+import { Object3D, Plane, Vector3 } from "three";
+
+export interface CutByPlaneOutput {
+    object1: Object3D;
+    object2: Object3D;
+}
+
+export class ConvexObjectBreaker {
+    constructor(minSizeForBreak?: number, smallDelta?: number);
+    prepareBreakableObject(
+        object: Object3D,
+        mass: number,
+        velocity: Vector3,
+        angularVelocity: Vector3,
+        breakable: boolean,
+    ): void;
+    subdivideByImpact(
+        object: Object3D,
+        pointOfImpact: Vector3,
+        normal: Vector3,
+        maxRadialIterations: number,
+        maxRandomIterations: number,
+    ): Object3D[];
+    cutByPlane(object: Object3D, plane: Plane, output: CutByPlaneOutput): number;
+}

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

@@ -0,0 +1,55 @@
+import {
+    DataTexture,
+    IUniform,
+    MagnificationTextureFilter,
+    Material,
+    MinificationTextureFilter,
+    ShaderMaterial,
+    Texture,
+    TextureDataType,
+    TextureFilter,
+    WebGLRenderer,
+    WebGLRenderTarget,
+    Wrapping,
+} from "three";
+
+export interface Variable {
+    name: string;
+    initialValueTexture: Texture;
+    material: ShaderMaterial;
+    dependencies: Variable[];
+    renderTargets: WebGLRenderTarget[];
+    wrapS: number;
+    wrapT: number;
+    minFilter: number;
+    magFilter: number;
+}
+
+export class GPUComputationRenderer {
+    constructor(sizeX: number, sizeY: number, renderer: WebGLRenderer);
+
+    setDataType(type: TextureDataType): void;
+
+    addVariable(variableName: string, computeFragmentShader: string, initialValueTexture: Texture): Variable;
+    setVariableDependencies(variable: Variable, dependencies: Variable[] | null): void;
+
+    init(): string | null;
+    compute(): void;
+
+    getCurrentRenderTarget(variable: Variable): WebGLRenderTarget;
+    getAlternateRenderTarget(variable: Variable): WebGLRenderTarget;
+    addResolutionDefine(materialShader: ShaderMaterial): void;
+    createShaderMaterial(computeFragmentShader: string, uniforms?: { [uniform: string]: IUniform }): ShaderMaterial;
+    createRenderTarget(
+        sizeXTexture: number,
+        sizeYTexture: number,
+        wrapS: Wrapping,
+        wrapT: number,
+        minFilter: MinificationTextureFilter,
+        magFilter: MagnificationTextureFilter,
+    ): WebGLRenderTarget;
+    createTexture(): DataTexture;
+    renderTexture(input: Texture, output: WebGLRenderTarget): void;
+    doRenderTarget(material: Material, output: WebGLRenderTarget): void;
+    dispose(): void;
+}

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

@@ -0,0 +1,5 @@
+import { Object3D } from "three";
+
+export class Gyroscope extends Object3D {
+    constructor();
+}

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

@@ -0,0 +1,33 @@
+import { AnimationMixer, Mesh, Object3D, Texture } from "three";
+
+export interface MD2PartsConfig {
+    baseUrl: string;
+    body: string;
+    skins: string[];
+    weapons: Array<[string, string]>;
+}
+
+export class MD2Character {
+    constructor();
+    scale: number;
+    animationFPS: number;
+    root: Object3D;
+    meshBody: Mesh | null;
+    meshWeapon: Mesh | null;
+    skinsBody: Texture[];
+    skinsWeapon: Texture[];
+    weapons: Mesh[];
+    activeAnimation: string | null;
+    mixer: AnimationMixer | null;
+    loadCounter: number;
+
+    onLoadComplete(): void;
+    loadParts(config: MD2PartsConfig): void;
+    setPlaybackRate(rate: number): void;
+    setWireframe(wireframeEnabled: boolean): void;
+    setSkin(index: number): void;
+    setWeapon(index: number): void;
+    setAnimation(clipName: string): void;
+    syncWeaponAnimation(): void;
+    update(delta: number): void;
+}

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

@@ -0,0 +1,55 @@
+import { Mesh, Object3D, Texture } from "three";
+
+export class MD2CharacterComplex {
+    constructor();
+    scale: number;
+    animationFPS: number;
+    transitionFrames: number;
+    maxSpeed: number;
+    maxReverseSpeed: number;
+    frontAcceleration: number;
+    backAcceleration: number;
+    frontDecceleration: number;
+    angularSpeed: number;
+    root: Object3D;
+    meshBody: Mesh | null;
+    meshWeapon: Mesh | null;
+    controls: {
+        crouch?: boolean | undefined;
+        jump?: boolean | undefined;
+        attack?: boolean | undefined;
+        moveForward?: boolean | undefined;
+        moveBackward?: boolean | undefined;
+        moveLeft?: boolean | undefined;
+        moveRight?: boolean | undefined;
+    } | null;
+    skinsBody: Texture[];
+    skinsWeapon: Texture[];
+    weapons: Mesh[];
+    currentSkin: number;
+    onLoadComplete: () => void;
+
+    meshes: Mesh[];
+    animations: object[];
+    loadCounter: number;
+    speed: number;
+    bodyOrientation: number;
+    walkSpeed: number;
+    crouchSpeed: number;
+    activeAnimation: string;
+    oldAnimation: string;
+
+    enableShadows(enable: boolean): void;
+    setVisible(enable: boolean): void;
+    shareParts(original: MD2CharacterComplex): void;
+    loadParts(config: object): void;
+    setPlaybackRate(rate: number): void;
+    setWireframe(wireframeEnabled: boolean): void;
+    setSkin(index: number): void;
+    setWeapon(index: number): void;
+    setAnimation(animationName: string): void;
+    update(delta: number): void;
+    updateAnimations(delta: number): void;
+    updateBehaviors(): void;
+    updateMovementModel(delta: number): void;
+}

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

@@ -0,0 +1,13 @@
+import { AnimationAction, AnimationMixer, BufferGeometry, Material, Mesh } from "three";
+
+export class MorphAnimMesh extends Mesh {
+    constructor(geometry: BufferGeometry, material: Material);
+    mixer: AnimationMixer;
+    activeAction: AnimationAction | null;
+
+    setDirectionForward(): void;
+    setDirectionBackward(): void;
+    playAnimation(label: string, fps: number): void;
+    updateAnimation(delta: number): void;
+    copy(source: MorphAnimMesh, recursive?: boolean): this;
+}

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

@@ -0,0 +1,21 @@
+import { BufferGeometry, Material, Mesh } from "three";
+
+export class MorphBlendMesh extends Mesh {
+    constructor(geometry: BufferGeometry, material: Material);
+    animationsMap: object;
+    animationsList: object[];
+
+    createAnimation(name: string, start: number, end: number, fps: number): void;
+    autoCreateAnimations(fps: number): void;
+    setAnimationDirectionForward(name: string): void;
+    setAnimationDirectionBackward(name: string): void;
+    setAnimationFPS(name: string, fps: number): void;
+    setAnimationDuration(name: string, duration: number): void;
+    setAnimationWeight(name: string, weight: number): void;
+    setAnimationTime(name: string, time: number): void;
+    getAnimationTime(name: string): number;
+    getAnimationDuration(name: string): number;
+    playAnimation(name: string): void;
+    stopAnimation(name: string): void;
+    update(delta: number): void;
+}