@needle-tools/three 0.169.12 → 0.169.13

package/types/examples/jsm/effects/ParallaxBarrierEffect.d.ts

@@ -0,0 +1,11 @@
+import { Camera, Scene, WebGLRenderer } from "three";
+
+declare class ParallaxBarrierEffect {
+    setSize: (width: number, height: number) => void;
+    render: (scene: Scene, camera: Camera) => void;
+    dispose: () => void;
+
+    constructor(renderer: WebGLRenderer);
+}
+
+export { ParallaxBarrierEffect };

package/types/examples/jsm/effects/PeppersGhostEffect.d.ts

@@ -0,0 +1,10 @@
+import { Camera, Scene, WebGLRenderer } from "three";
+
+export class PeppersGhostEffect {
+    constructor(renderer: WebGLRenderer);
+    cameraDistance: number;
+    reflectFromAbove: boolean;
+
+    render(scene: Scene, camera: Camera): void;
+    setSize(width: number, height: number): void;
+}

package/types/examples/jsm/effects/StereoEffect.d.ts

@@ -0,0 +1,9 @@
+import { Camera, Scene, WebGLRenderer } from "three";
+
+export class StereoEffect {
+    constructor(renderer: WebGLRenderer);
+
+    setEyeSeparation(eyeSep: number): void;
+    render(scene: Scene, camera: Camera): void;
+    setSize(width: number, height: number): void;
+}

package/types/examples/jsm/environments/DebugEnvironment.d.ts

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

package/types/examples/jsm/environments/RoomEnvironment.d.ts

@@ -0,0 +1,6 @@
+import { Scene } from "three";
+
+export class RoomEnvironment extends Scene {
+    constructor();
+    dispose(): void;
+}

package/types/examples/jsm/exporters/DRACOExporter.d.ts

@@ -0,0 +1,17 @@
+import { Mesh, Points } from "three";
+
+export interface DRACOExporterOptions {
+    decodeSpeed?: number;
+    encodeSpeed?: number;
+    encoderMethod?: number;
+    quantization?: number[];
+    exportUvs?: boolean;
+    exportNormals?: boolean;
+    exportColor?: boolean;
+}
+
+export class DRACOExporter {
+    constructor();
+
+    parse(object: Mesh | Points, options?: DRACOExporterOptions): Int8Array;
+}

package/types/examples/jsm/exporters/EXRExporter.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @author sciecode / https://github.com/sciecode
+ *
+ * EXR format references:
+ * https://www.openexr.com/documentation/openexrfilelayout.pdf
+ */
+
+import { DataTexture, TextureDataType, WebGLRenderer, WebGLRenderTarget } from "three";
+import { WebGPURenderer } from "three/webgpu";
+
+export const NO_COMPRESSION: 0;
+export const ZIPS_COMPRESSION: 2;
+export const ZIP_COMPRESSION: 3;
+
+export interface EXRExporterParseOptions {
+    compression?: number;
+    type?: TextureDataType;
+}
+
+export class EXRExporter {
+    parse(
+        renderer: WebGLRenderer | WebGPURenderer,
+        renderTarget: WebGLRenderTarget,
+        options?: EXRExporterParseOptions,
+    ): Promise<Uint8Array>;
+    parse(dataTexture: DataTexture, options?: EXRExporterParseOptions): Promise<Uint8Array>;
+}

package/types/examples/jsm/exporters/GLTFExporter.d.ts

@@ -0,0 +1,123 @@
+import { AnimationClip, Material, Mesh, Object3D, Texture } from "three";
+
+export interface GLTFExporterOptions {
+    /**
+     * Export position, rotation and scale instead of matrix per node. Default is false
+     */
+    trs?: boolean;
+
+    /**
+     * Export only visible objects. Default is true.
+     */
+    onlyVisible?: boolean;
+
+    /**
+     * Export just the attributes within the drawRange, if defined, instead of exporting the whole array. Default is true.
+     */
+    truncateDrawRange?: boolean;
+
+    /**
+     * Export in binary (.glb) format, returning an ArrayBuffer. Default is false.
+     */
+    binary?: boolean;
+
+    /**
+     * Export with images embedded into the glTF asset. Default is true.
+     */
+    embedImages?: boolean;
+
+    /**
+     * Restricts the image maximum size (both width and height) to the given value. This option works only if embedImages is true. Default is Infinity.
+     */
+    maxTextureSize?: number;
+
+    /**
+     * List of animations to be included in the export.
+     */
+    animations?: AnimationClip[];
+
+    /**
+     * Generate indices for non-index geometry and export with them. Default is false.
+     */
+    forceIndices?: boolean;
+
+    /**
+     * Export custom glTF extensions defined on an object's userData.gltfExtensions property. Default is false.
+     */
+    includeCustomExtensions?: boolean;
+}
+
+export class GLTFExporter {
+    constructor();
+
+    register(callback: (writer: GLTFWriter) => GLTFExporterPlugin): this;
+    unregister(callback: (writer: GLTFWriter) => GLTFExporterPlugin): this;
+
+    /**
+     * Generates a .gltf (JSON) or .glb (binary) output from the input (Scenes or Objects)
+     *
+     * @param input Scenes or objects to export. Valid options:
+     * - Export scenes
+     *   ```js
+     *   exporter.parse( scene1, ... )
+     *   exporter.parse( [ scene1, scene2 ], ... )
+     *   ```
+     * - Export objects (It will create a new Scene to hold all the objects)
+     *   ```js
+     *   exporter.parse( object1, ... )
+     *   exporter.parse( [ object1, object2 ], ... )
+     *   ```
+     * - Mix scenes and objects (It will export the scenes as usual but it will create a new scene to hold all the single objects).
+     *   ```js
+     *   exporter.parse( [ scene1, object1, object2, scene2 ], ... )
+     *   ```
+     * @param onDone Will be called when the export completes. The argument will be the generated glTF JSON or binary ArrayBuffer.
+     * @param onError Will be called if there are any errors during the gltf generation.
+     * @param options Export options
+     */
+    parse(
+        input: Object3D | Object3D[],
+        onDone: (gltf: ArrayBuffer | { [key: string]: any }) => void,
+        onError: (error: ErrorEvent) => void,
+        options?: GLTFExporterOptions,
+    ): void;
+
+    /**
+     * Generates a .gltf (JSON) or .glb (binary) output from the input (Scenes or Objects).
+     *
+     * This is just like the {@link parse}() method, but instead of accepting callbacks it returns a promise that
+     * resolves with the result, and otherwise accepts the same options.
+     */
+    parseAsync(
+        input: Object3D | Object3D[],
+        options?: GLTFExporterOptions,
+    ): Promise<ArrayBuffer | { [key: string]: any }>;
+}
+
+export class GLTFWriter {
+    constructor();
+
+    setPlugins(plugins: GLTFExporterPlugin[]): void;
+
+    /**
+     * Parse scenes and generate GLTF output
+     *
+     * @param input Scene or Array of THREE.Scenes
+     * @param onDone Callback on completed
+     * @param options options
+     */
+    write(
+        input: Object3D | Object3D[],
+        onDone: (gltf: ArrayBuffer | { [key: string]: any }) => void,
+        options?: GLTFExporterOptions,
+    ): Promise<void>;
+}
+
+export interface GLTFExporterPlugin {
+    writeTexture?: (map: Texture, textureDef: { [key: string]: any }) => void;
+    writeMaterial?: (material: Material, materialDef: { [key: string]: any }) => void;
+    writeMesh?: (mesh: Mesh, meshDef: { [key: string]: any }) => void;
+    writeNode?: (object: Object3D, nodeDef: { [key: string]: any }) => void;
+    beforeParse?: (input: Object3D | Object3D[]) => void;
+    afterParse?: (input: Object3D | Object3D[]) => void;
+}

package/types/examples/jsm/exporters/KTX2Exporter.d.ts

@@ -0,0 +1,7 @@
+import { Data3DTexture, DataTexture, WebGLRenderer, WebGLRenderTarget } from "three";
+import { WebGPURenderer } from "three/webgpu";
+
+export class KTX2Exporter {
+    parse(renderer: WebGLRenderer | WebGPURenderer, rtt?: WebGLRenderTarget): Promise<Uint8Array>;
+    parse(texture: Data3DTexture | DataTexture): Promise<Uint8Array>;
+}

package/types/examples/jsm/exporters/MMDExporter.d.ts

@@ -0,0 +1,7 @@
+import { Object3D } from "three";
+
+export class MMDExporter {
+    constructor();
+
+    parseVpd(skin: Object3D, outputShiftJis: boolean, useOriginalBones: boolean): [] | Uint8Array;
+}

package/types/examples/jsm/exporters/OBJExporter.d.ts

@@ -0,0 +1,7 @@
+import { Object3D } from "three";
+
+export class OBJExporter {
+    constructor();
+
+    parse(object: Object3D): string;
+}

package/types/examples/jsm/exporters/PLYExporter.d.ts

@@ -0,0 +1,30 @@
+import { Object3D } from "three";
+
+export interface PLYExporterOptionsBase {
+    excludeAttributes?: string[];
+    littleEndian?: boolean;
+}
+
+export interface PLYExporterOptionsBinary extends PLYExporterOptionsBase {
+    binary: true;
+}
+
+export interface PLYExporterOptionsString extends PLYExporterOptionsBase {
+    binary?: false;
+}
+
+export interface PLYExporterOptions extends PLYExporterOptionsBase {
+    binary?: boolean;
+}
+
+export class PLYExporter {
+    constructor();
+
+    parse(object: Object3D, onDone: (res: ArrayBuffer) => void, options: PLYExporterOptionsBinary): ArrayBuffer | null;
+    parse(object: Object3D, onDone: (res: string) => void, options?: PLYExporterOptionsString): string | null;
+    parse(
+        object: Object3D,
+        onDone: (res: string | ArrayBuffer) => void,
+        options?: PLYExporterOptions,
+    ): string | ArrayBuffer | null;
+}

package/types/examples/jsm/exporters/STLExporter.d.ts

@@ -0,0 +1,21 @@
+import { Object3D } from "three";
+
+export interface STLExporterOptionsBinary {
+    binary: true;
+}
+
+export interface STLExporterOptionsString {
+    binary?: false;
+}
+
+export interface STLExporterOptions {
+    binary?: boolean;
+}
+
+export class STLExporter {
+    constructor();
+
+    parse(scene: Object3D, options: STLExporterOptionsBinary): DataView;
+    parse(scene: Object3D, options?: STLExporterOptionsString): string;
+    parse(scene: Object3D, options?: STLExporterOptions): string | DataView;
+}

package/types/examples/jsm/exporters/USDZExporter.d.ts

@@ -0,0 +1,21 @@
+import { Object3D } from "three";
+
+export interface USDZExporterOptions {
+    ar?: { anchoring: { type: "plane" }; planeAnchoring: { alignment: "horizontal" | "vertical" | "any" } } | undefined;
+    includeAnchoringProperties?: boolean | undefined;
+    quickLookCompatible?: boolean | undefined;
+    maxTextureSize?: number | undefined;
+}
+
+export class USDZExporter {
+    constructor();
+
+    parse(
+        scene: Object3D,
+        onDone: (result: Uint8Array) => void,
+        onError: (error: unknown) => void,
+        options?: USDZExporterOptions,
+    ): void;
+
+    parseAsync(scene: Object3D, options?: USDZExporterOptions): Promise<Uint8Array>;
+}

package/types/examples/jsm/geometries/BoxLineGeometry.d.ts

@@ -0,0 +1,12 @@
+import { BufferGeometry } from "three";
+
+export class BoxLineGeometry extends BufferGeometry {
+    constructor(
+        width?: number,
+        height?: number,
+        depth?: number,
+        widthSegments?: number,
+        heightSegments?: number,
+        depthSegments?: number,
+    );
+}

package/types/examples/jsm/geometries/ConvexGeometry.d.ts

@@ -0,0 +1,5 @@
+import { BufferGeometry, Vector3 } from "three";
+
+export class ConvexGeometry extends BufferGeometry {
+    constructor(points?: Vector3[]);
+}

package/types/examples/jsm/geometries/DecalGeometry.d.ts

@@ -0,0 +1,10 @@
+import { BufferGeometry, Euler, Mesh, Vector3 } from "three";
+
+export class DecalGeometry extends BufferGeometry {
+    constructor(mesh: Mesh, position: Vector3, orientation: Euler, size: Vector3);
+}
+
+export class DecalVertex {
+    constructor(position: Vector3, normal: Vector3);
+    clone(): this;
+}

package/types/examples/jsm/geometries/ParametricGeometries.d.ts

@@ -0,0 +1,32 @@
+import { Curve, Vector3 } from "three";
+
+import { ParametricGeometry } from "./ParametricGeometry.js";
+
+export namespace ParametricGeometries {
+    function klein(v: number, u: number, target: Vector3): Vector3;
+    function plane(width: number, height: number): (u: number, v: number, target: Vector3) => Vector3;
+    function mobius(u: number, t: number, target: Vector3): Vector3;
+    function mobius3d(u: number, t: number, target: Vector3): Vector3;
+
+    class TubeGeometry extends ParametricGeometry {
+        constructor(
+            path: Curve<Vector3>,
+            segments?: number,
+            radius?: number,
+            segmentsRadius?: number,
+            closed?: boolean,
+        );
+    }
+
+    class TorusKnotGeometry extends TubeGeometry {
+        constructor(radius?: number, tube?: number, segmentsT?: number, segmentsR?: number, p?: number, q?: number);
+    }
+
+    class SphereGeometry extends ParametricGeometry {
+        constructor(size: number, u: number, v: number);
+    }
+
+    class PlaneGeometry extends ParametricGeometry {
+        constructor(width: number, depth: number, segmentsWidth: number, segmentsDepth: number);
+    }
+}

package/types/examples/jsm/geometries/ParametricGeometry.d.ts

@@ -0,0 +1,18 @@
+import { BufferGeometry, Vector3 } from "three";
+
+export class ParametricGeometry extends BufferGeometry {
+    constructor(func?: (u: number, v: number, target: Vector3) => void, slices?: number, stacks?: number);
+
+    /**
+     * @default 'ParametricGeometry'
+     */
+    type: string;
+
+    parameters: {
+        func: (u: number, v: number, dest: Vector3) => void;
+        slices: number;
+        stacks: number;
+    };
+}
+
+export { ParametricGeometry as ParametricBufferGeometry };

package/types/examples/jsm/geometries/RoundedBoxGeometry.d.ts

@@ -0,0 +1,5 @@
+import { BoxGeometry } from "three";
+
+export class RoundedBoxGeometry extends BoxGeometry {
+    constructor(width?: number, height?: number, depth?: number, segments?: number, radius?: number);
+}

package/types/examples/jsm/geometries/TeapotGeometry.d.ts

@@ -0,0 +1,37 @@
+import { BufferGeometry } from "three";
+
+/**
+ * {@link TeapotGeometry} tesselates the famous Utah teapot database by Martin Newell.
+ *
+ * {@link TeapotGeometry} is an add-on, and must be imported explicitly. See
+ * [Installation / Addons]{@link https://threejs.org/docs/#manual/en/introduction/Installation}.
+ *
+ * @example
+ * import { TeapotGeometry } from 'three/addons/geometries/TeapotGeometry.js';
+ *
+ * const geometry = new TeapotGeometry( 50, 18 );
+ * const material = new THREE.MeshBasicMaterial( { color: 0x00ff00 } );
+ * const teapot = new THREE.Mesh( geometry, material );
+ * scene.add( teapot );
+ */
+export class TeapotGeometry extends BufferGeometry {
+    /**
+     * @param size Relative scale of the teapot. Optional; Defaults to `50`.
+     * @param segments Number of line segments to subdivide each patch edge. Optional; Defaults to `10`.
+     * @param bottom Whether the bottom of the teapot is generated or not. Optional; Defaults to `true`.
+     * @param lid Whether the lid is generated or not. Optional; Defaults to `true`.
+     * @param body Whether the body is generated or not. Optional; Defaults to `true`.
+     * @param fitLid Whether the lid is slightly stretched to prevent gaps between the body and lid or not. Optional;
+     * Defaults to `true`.
+     * @param blinn Whether the teapot is scaled vertically for better aesthetics or not. Optional; Defaults to `true`.
+     */
+    constructor(
+        size?: number,
+        segments?: number,
+        bottom?: boolean,
+        lid?: boolean,
+        body?: boolean,
+        fitLid?: boolean,
+        blinn?: boolean,
+    );
+}

package/types/examples/jsm/geometries/TextGeometry.d.ts

@@ -0,0 +1,123 @@
+import { ExtrudeGeometry, ExtrudeGeometryOptions, Shape } from "three";
+
+import { Font } from "../loaders/FontLoader.js";
+
+export interface TextGeometryParameters extends ExtrudeGeometryOptions {
+    font: Font;
+
+    /**
+     * Size of the text
+     * Expects a `Float`.
+     * @defaultValue `100`
+     */
+    size?: number | undefined;
+
+    /**
+     * Thickness to extrude text.
+     * Expects a `Float`.
+     * @defaultValue `50`
+     * @deprecated THREE.TextGeometry: .height is now deprecated. Please use .depth instead
+     */
+    height?: number | undefined;
+
+    /**
+     * Thickness to extrude text.
+     * Expects a `Float`.
+     * @defaultValue `50`
+     */
+    depth?: number | undefined;
+
+    /**
+     * @override
+     * @defaultValue `12`
+     */
+    curveSegments?: number | undefined;
+
+    /**
+     * @defaultValue `false`
+     */
+    bevelEnabled?: boolean | undefined;
+
+    /**
+     * How deep into text bevel goes.
+     * Expects a `Float`.
+     * @override
+     * @defaultValue `10`
+     */
+    bevelThickness?: number | undefined;
+
+    /**
+     * How far from text outline is bevel.
+     * Expects a `Float`.
+     * @override
+     * @defaultValue `8`
+     */
+    bevelSize?: number | undefined;
+
+    /**
+     * How far from text outline bevel starts.
+     * Expects a `Float`.
+     * @override
+     * @defaultValue `0`
+     */
+    bevelOffset?: number | undefined;
+
+    /**
+     * @override
+     * @defaultValue `3`
+     */
+    bevelSegments?: number | undefined;
+}
+
+/**
+ * A class for generating text as a single geometry
+ * @remarks
+ * It is constructed by providing a string of text, and a set of parameters consisting of a loaded font and settings for the geometry's parent {@link THREE.ExtrudeGeometry | ExtrudeGeometry}
+ * See the {@link THREE.FontLoader | FontLoader} page for additional details.
+ * @example
+ * ```typescript
+ * const loader = new FontLoader();
+ * loader.load('fonts/helvetiker_regular.typeface.json', function (font) {
+ *     const geometry = new TextGeometry('Hello three.js!', {
+ *         font: font,
+ *         size: 80,
+ *         height: 5,
+ *         curveSegments: 12,
+ *         bevelEnabled: true,
+ *         bevelThickness: 10,
+ *         bevelSize: 8,
+ *         bevelOffset: 0,
+ *         bevelSegments: 5
+ *     });
+ * });
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_geometry_text | geometry / text }
+ * @see {@link https://threejs.org/docs/index.html#api/en/C:/rafaelsc/Source/threejs/three.js/docs/examples/en/geometries/TextGeometry | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/examples/jsm/geometries/TextGeometry.js | Source}
+ */
+export class TextGeometry extends ExtrudeGeometry {
+    /**
+     * Create a new instance of {@link TextGeometry}
+     * @param text The text that needs to be shown.
+     * @param parameters Object that can contain the following parameters. @see {@link TextGeometryParameters} for defaults.
+     */
+    constructor(text: string, parameters?: TextGeometryParameters);
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `TextGeometry`
+     */
+    override readonly type: string | "TextGeometry";
+
+    /**
+     * An object with a property for each of the constructor parameters.
+     * @remarks Any modification after instantiation does not change the geometry.
+     */
+    readonly parameters: {
+        readonly shapes: Shape | Shape[];
+        readonly options: TextGeometryParameters;
+    };
+}
+
+export { TextGeometry as TextBufferGeometry };

package/types/examples/jsm/helpers/LightProbeHelper.d.ts

@@ -0,0 +1,12 @@
+import { LightProbe, Mesh } from "three";
+
+declare class LightProbeHelper extends Mesh {
+    lightProbe: LightProbe;
+    size: number;
+
+    constructor(lightProbe: LightProbe, size?: number);
+
+    dispose(): void;
+}
+
+export { LightProbeHelper };

package/types/examples/jsm/helpers/LightProbeHelperGPU.d.ts

@@ -0,0 +1,12 @@
+import { LightProbe, Mesh } from "three";
+
+declare class LightProbeHelper extends Mesh {
+    lightProbe: LightProbe;
+    size: number;
+
+    constructor(lightProbe: LightProbe, size?: number);
+
+    dispose(): void;
+}
+
+export { LightProbeHelper };

package/types/examples/jsm/helpers/OctreeHelper.d.ts

@@ -0,0 +1,17 @@
+import { ColorRepresentation, LineSegments } from "three";
+import { Octree } from "../math/Octree.js";
+
+export class OctreeHelper extends LineSegments {
+    constructor(octree: Octree, color?: ColorRepresentation);
+
+    octree: Octree;
+    color: ColorRepresentation;
+
+    /**
+     * @default 'OctreeHelper'
+     */
+    type: "OctreeHelper" | string;
+
+    update(): void;
+    dispose(): void;
+}

package/types/examples/jsm/helpers/PositionalAudioHelper.d.ts

@@ -0,0 +1,13 @@
+import { Line, PositionalAudio } from "three";
+
+export class PositionalAudioHelper extends Line {
+    constructor(audio: PositionalAudio, range?: number, divisionsInnerAngle?: number, divisionsOuterAngle?: number);
+
+    audio: PositionalAudio;
+    range: number;
+    divisionsInnerAngle: number;
+    divisionsOuterAngle: number;
+
+    dispose(): void;
+    update(): void;
+}

package/types/examples/jsm/helpers/RectAreaLightHelper.d.ts

@@ -0,0 +1,10 @@
+import { ColorRepresentation, Line, RectAreaLight } from "three";
+
+export class RectAreaLightHelper extends Line {
+    constructor(light: RectAreaLight, color?: ColorRepresentation);
+
+    light: RectAreaLight;
+    color: ColorRepresentation | undefined;
+
+    dispose(): void;
+}

package/types/examples/jsm/helpers/TextureHelper.d.ts

@@ -0,0 +1,10 @@
+import { Mesh, Texture } from "three";
+
+export class TextureHelper extends Mesh {
+    texture: Texture;
+    type: "TextureHelper";
+
+    constructor(texture: Texture, width?: number, height?: number, depth?: number);
+
+    dispose(): void;
+}

package/types/examples/jsm/helpers/VertexNormalsHelper.d.ts

@@ -0,0 +1,12 @@
+import { LineSegments, Object3D } from "three";
+
+export class VertexNormalsHelper extends LineSegments {
+    constructor(object: Object3D, size?: number, hex?: number);
+
+    object: Object3D;
+    size: number;
+
+    update(): void;
+
+    dispose(): void;
+}