@types/three 0.168.0 → 0.170.0

three/examples/jsm/helpers/LightProbeHelper.d.ts

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

three/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 };

three/examples/jsm/helpers/TextureHelperGPU.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;
+}

three/examples/jsm/lighting/TiledLighting.d.ts

@@ -0,0 +1,10 @@
+import { ShaderNodeObject } from "three/tsl";
+import { Lighting } from "three/webgpu";
+import { Light } from "../../../src/lights/Light.js";
+import TiledLightsNode from "../tsl/lighting/TiledLightsNode.js";
+
+export class TiledLighting extends Lighting {
+    constructor();
+
+    createNode(lights?: Light[]): ShaderNodeObject<TiledLightsNode>;
+}

three/examples/jsm/lights/LightProbeGenerator.d.ts

@@ -1,6 +1,10 @@
 import { CubeTexture, LightProbe, WebGLCubeRenderTarget, WebGLRenderer } from "three";
+import { WebGPURenderer } from "three/webgpu";
 
 export namespace LightProbeGenerator {
     function fromCubeTexture(cubeTexture: CubeTexture): LightProbe;
-    function fromCubeRenderTarget(renderer: WebGLRenderer, cubeRenderTarget: WebGLCubeRenderTarget): LightProbe;
+    function fromCubeRenderTarget(
+        renderer: WebGLRenderer | WebGPURenderer,
+        cubeRenderTarget: WebGLCubeRenderTarget,
+    ): Promise<LightProbe>;
 }

three/examples/jsm/lines/Line2.d.ts

@@ -2,10 +2,24 @@ import { LineGeometry } from "./LineGeometry.js";
 import { LineMaterial } from "./LineMaterial.js";
 import { LineSegments2 } from "./LineSegments2.js";
 
+/**
+ * A polyline drawn between vertices.
+ *
+ * This adds functionality beyond {@link Line}, like arbitrary line width and changing width to be in world units. It
+ * extends {@link LineSegments2}, simplifying constructing segments from a chain of points.
+ */
 export class Line2 extends LineSegments2 {
     geometry: LineGeometry;
     material: LineMaterial;
 
-    constructor(geometry?: LineGeometry, material?: LineMaterial);
+    /**
+     * Read-only flag to check if a given object is of type Line2.
+     */
     readonly isLine2: true;
+
+    /**
+     * @param geometry (optional) Pair(s) of vertices representing each line segment
+     * @param material (optional) Material for the line. Default is a {@link LineMaterial} with random color.
+     */
+    constructor(geometry?: LineGeometry, material?: LineMaterial);
 }

three/examples/jsm/lines/LineGeometry.d.ts

@@ -2,9 +2,26 @@ import { Line } from "three";
 
 import { LineSegmentsGeometry } from "./LineSegmentsGeometry.js";
 
+/**
+ * A chain of vertices, forming a polyline.
+ *
+ * This is used in {@link Line2} to describe the shape.
+ */
 export class LineGeometry extends LineSegmentsGeometry {
-    constructor();
+    /**
+     * Read-only flag to check if a given object is of type LineGeometry.
+     */
     readonly isLineGeometry: true;
 
+    /**
+     * Creates a new geometry.
+     * Call [setPositions]{@link LineGeometry.setPositions} to add segments.
+     */
+    constructor();
+
+    /**
+     * Copy the vertex positions of a {@link Line} object into this geometry.
+     * Assumes the source geometry is not using indices.
+     */
     fromLine(line: Line): this;
 }

three/examples/jsm/lines/LineMaterial.d.ts

@@ -12,18 +12,71 @@ export interface LineMaterialParameters extends ShaderMaterialParameters {
     worldUnits?: boolean | undefined;
 }
 
+/**
+ * A material for drawing wireframe-style geometries.
+ * Unlike {@link LineBasicMaterial}, it supports arbitrary line widths and allows using world units instead of screen
+ * space units. This material is used with {@link LineSegments2} and {@link Line2}.
+ *
+ * Lines are always rendered with round caps and round joints.
+ */
 export class LineMaterial extends ShaderMaterial {
-    constructor(parameters?: LineMaterialParameters);
-    color: Color;
-    dashed: boolean;
-    dashScale: number;
-    dashSize: number;
-    dashOffset: number;
-    gapSize: number;
-    opacity: number;
     readonly isLineMaterial: true;
-    linewidth: number;
-    resolution: Vector2;
-    alphaToCoverage: boolean;
-    worldUnits: boolean;
+
+    /**
+     * @param parameters (optional) an object with one or more properties defining the material's appearance. Any
+     * property of the material (including any property inherited from {@link ShaderMaterial}) can be passed in here.
+     *
+     * The exception is the property color, which can be passed in as a number or hexadecimal string and is `0xffffff`
+     * (white) by default. Color.set( color ) is called internally.
+     */
+    constructor(parameters?: LineMaterialParameters);
+
+    /**
+     * {@link Color} of the material, by default set to white (0xffffff).
+     */
+    get color(): Color;
+    set color(value: Color);
+
+    /**
+     * Whether the material's sizes (width, dash gaps) are in world units. Default is `false` (screen space units.)
+     */
+    get worldUnits(): boolean;
+    set worldUnits(value: boolean);
+
+    /**
+     * Whether the line is dashed, or solid. Default is `false`.
+     */
+    get dashed(): boolean;
+    set dashed(value: boolean);
+
+    /**
+     * The scale of the dashes and gaps. Default is `1`.
+     */
+    get dashScale(): number;
+    set dashScale(value: number);
+
+    /**
+     * The size of the dash. Default is `1`.
+     */
+    get dashSize(): number;
+    set dashSize(value: number);
+
+    /**
+     * Where in the dash cycle the dash starts. Default is `0`.
+     */
+    get dashOffset(): number;
+    set dashOffset(value: number);
+
+    /**
+     * The size of the gap. Default is `1`.
+     */
+    get gapSize(): number;
+    set gapSize(value: number);
+
+    /**
+     * The size of the viewport, in screen pixels. This must be kept updated to make screen-space rendering accurate.
+     * The {@link LineSegments2.onBeforeRender} callback performs the update for visible objects. Default is `[1, 1]`.
+     */
+    get resolution(): Vector2;
+    set resolution(value: Vector2);
 }

three/examples/jsm/lines/LineSegments2.d.ts

@@ -1,14 +1,37 @@
-import { Mesh } from "three";
+import { Mesh, WebGLRenderer } from "three";
 
 import { LineMaterial } from "./LineMaterial.js";
 import { LineSegmentsGeometry } from "./LineSegmentsGeometry.js";
 
+/**
+ * A series of lines drawn between pairs of vertices.
+ *
+ * This adds functionality beyond {@link LineSegments}, like arbitrary line width and changing width to be in world
+ * units. The {@link Line2} extends this object, forming a polyline instead of individual segments.
+ */
 export class LineSegments2 extends Mesh {
     geometry: LineSegmentsGeometry;
     material: LineMaterial;
 
-    constructor(geometry?: LineSegmentsGeometry, material?: LineMaterial);
+    /**
+     * Read-only flag to check if a given object is of type LineSegments2.
+     */
     readonly isLineSegments2: true;
 
+    /**
+     * @param geometry (optional) Pair(s) of vertices representing each line segment.
+     * @param material (optional) Material for the line. Default is a {@link LineMaterial} with random color.
+     */
+    constructor(geometry?: LineSegmentsGeometry, material?: LineMaterial);
+
     computeLineDistances(): this;
+
+    /**
+     * Called by the framework to update the material's resolution property, needed for screen-scaled widths.
+     *
+     * If your object is not visible to a camera (e.g. by [layers]{@link Object3D.layers} or
+     * [visible]{@link Object3D.visible}), you must call this manually whenever the viewport changes.
+     * @param renderer
+     */
+    onBeforeRender(renderer: WebGLRenderer): void;
 }

three/examples/jsm/lines/LineSegmentsGeometry.d.ts

@@ -1,16 +1,53 @@
-import { EdgesGeometry, InstancedBufferGeometry, LineSegments, Matrix4, Mesh, WireframeGeometry } from "three";
+import { EdgesGeometry, InstancedBufferGeometry, LineSegments, Mesh, WireframeGeometry } from "three";
 
+/**
+ * A series of vertex pairs, forming line segments.
+ *
+ * This is used in {@link LineSegments2} to describe the shape.
+ */
 export class LineSegmentsGeometry extends InstancedBufferGeometry {
-    constructor();
+    /**
+     * Read-only flag to check if a given object is of type LineSegmentsGeometry.
+     */
     readonly isLineSegmentsGeometry: true;
 
-    applyMatrix4(matrix: Matrix4): this;
-    computeBoundingBox(): void;
-    computeBoundingSphere(): void;
+    /**
+     * Creates a new geometry. Call [setPositions]{@link LineSegmentsGeometry.setPositions} to add segments.
+     */
+    constructor();
+
+    /**
+     * Replace the vertex positions with a new set. The array can be an `Array` or `Float32Array`. The length must be a
+     * multiple of six.
+     * @param array
+     */
+    setPositions(array: number[] | Float32Array): this;
+
+    /**
+     * Replace the per-vertex colors. Every sixtuple describes a segment: `[r1, g1, b1, r2, g2, b2]`. The array can be
+     * an `Array` or `Float32Array`.
+     * @param array
+     */
+    setColors(array: number[] | Float32Array): this;
+
+    /**
+     * Copy the vertex positions of a wireframe geometry into this geometry.
+     */
+    fromWireframeGeometry(geometry: WireframeGeometry): this;
+
+    /**
+     * Copy the vertex positions of an edge geometry into this geometry.
+     */
     fromEdgesGeometry(geometry: EdgesGeometry): this;
-    fromLineSegments(lineSegments: LineSegments): this;
+
+    /**
+     * Copy the vertex positions of a mesh object into this geometry.
+     */
     fromMesh(mesh: Mesh): this;
-    fromWireframeGeometry(geometry: WireframeGeometry): this;
-    setColors(array: number[] | Float32Array): this;
-    setPositions(array: number[] | Float32Array): this;
+
+    /**
+     * Copy the vertex positions of a {@link LineSegments} object into this geometry. Assumes the source geometry is not
+     * using indices.
+     */
+    fromLineSegments(lineSegments: LineSegments): this;
 }

three/examples/jsm/lines/Wireframe.d.ts

@@ -3,9 +3,12 @@ import { Mesh } from "three";
 import { LineMaterial } from "./LineMaterial.js";
 import { LineSegmentsGeometry } from "./LineSegmentsGeometry.js";
 
-export class Wireframe extends Mesh {
-    constructor(geometry?: LineSegmentsGeometry, material?: LineMaterial);
+declare class Wireframe extends Mesh {
     readonly isWireframe: true;
 
+    constructor(geometry?: LineSegmentsGeometry, material?: LineMaterial);
+
     computeLineDistances(): this;
 }
+
+export { Wireframe };

three/examples/jsm/lines/WireframeGeometry2.d.ts

@@ -4,5 +4,5 @@ import { LineSegmentsGeometry } from "./LineSegmentsGeometry.js";
 
 export class WireframeGeometry2 extends LineSegmentsGeometry {
     constructor(geometry: BufferGeometry);
-    readonly sWireframeGeometry2: boolean;
+    readonly isWireframeGeometry2: boolean;
 }

three/examples/jsm/lines/webgpu/Wireframe.d.ts

@@ -0,0 +1,13 @@
+import { Line2NodeMaterial, Mesh } from "three/webgpu";
+
+import { WireframeGeometry2 } from "../WireframeGeometry2.js";
+
+declare class Wireframe extends Mesh {
+    readonly isWireframe: true;
+
+    constructor(geometry?: WireframeGeometry2, material?: Line2NodeMaterial);
+
+    computeLineDistances(): this;
+}
+
+export { Wireframe };

three/examples/jsm/loaders/DRACOLoader.d.ts

@@ -14,6 +14,12 @@ export class DRACOLoader extends Loader<BufferGeometry> {
         onError?: (err: unknown) => void,
     ): void;
 
+    parse(
+        buffer: ArrayBuffer,
+        onLoad?: (geometry: BufferGeometry) => void,
+        onError?: (err: unknown) => void,
+    ): void;
+
     preload(): DRACOLoader;
     dispose(): DRACOLoader;
 }

three/examples/jsm/loaders/EXRLoader.d.ts

@@ -1,4 +1,4 @@
-import { ColorSpace, DataTextureLoader, LoadingManager, PixelFormat, TextureDataType } from "three";
+import { DataTextureLoader, LoadingManager, PixelFormat, TextureDataType } from "three";
 
 export interface EXR {
     header: object;
@@ -6,7 +6,7 @@ export interface EXR {
     height: number;
     data: Float32Array | Uint16Array;
     format: PixelFormat;
-    colorSpace: ColorSpace;
+    colorSpace: string;
     type: TextureDataType;
 }
 

three/examples/jsm/loaders/GLTFLoader.d.ts

@@ -3,7 +3,6 @@ import {
     BufferAttribute,
     BufferGeometry,
     Camera,
-    ColorSpace,
     FileLoader,
     Group,
     ImageBitmapLoader,
@@ -113,7 +112,7 @@ export class GLTFParser {
             texCoord?: number | undefined;
             extensions?: any;
         },
-        colorSpace?: ColorSpace | undefined,
+        colorSpace?: string | undefined,
     ) => Promise<Texture | null>;
     assignFinalMaterial: (object: Mesh) => void;
     getMaterialType: () => typeof MeshStandardMaterial;

three/examples/jsm/loaders/KTX2Loader.d.ts

@@ -4,6 +4,7 @@ import { WorkerPool } from "../utils/WorkerPool.js";
 
 export interface KTX2LoaderWorkerConfig {
     astcSupported: boolean;
+    astcHDRSupported: boolean;
     etc1Supported: boolean;
     etc2Supported: boolean;
     dxtSupported: boolean;

three/examples/jsm/loaders/LDrawLoader.d.ts

@@ -1,13 +1,23 @@
 import { Group, Loader, LoadingManager, Material } from "three";
+import { LDrawConditionalLineMaterial } from "../materials/LDrawConditionalLineMaterial.js";
+import { LDrawConditionalLineMaterial as LDrawConditionalLineNodeMaterial } from "../materials/LDrawConditionalLineNodeMaterial.js";
 
 export class LDrawLoader extends Loader<Group> {
     materials: Material[];
     materialsLibrary: Record<string, Material>;
+
     fileMap: Record<string, string>;
+
     smoothNormals: boolean;
 
+    ConditionalLineMaterial: typeof LDrawConditionalLineMaterial | typeof LDrawConditionalLineNodeMaterial | null;
+
     constructor(manager?: LoadingManager);
 
+    setConditionalLineMaterial(
+        type: typeof LDrawConditionalLineMaterial | typeof LDrawConditionalLineNodeMaterial,
+    ): this;
+
     preloadMaterials(url: string): Promise<void>;
     setFileMap(fileMap: Record<string, string>): void;
     setMaterials(materials: Material[]): void;

three/examples/jsm/loaders/MMDLoader.d.ts

@@ -5,6 +5,10 @@ export interface MMDLoaderAnimationObject {
     mesh: SkinnedMesh;
 }
 
+/**
+ * @deprecated The module has been deprecated and will be removed with r172. Please migrate to
+ * https://github.com/takahirox/three-mmd-loader instead.
+ */
 export class MMDLoader extends Loader<SkinnedMesh> {
     constructor(manager?: LoadingManager);
     animationBuilder: object;

three/examples/jsm/materials/LDrawConditionalLineMaterial.d.ts

@@ -0,0 +1,9 @@
+import { ShaderMaterial, ShaderMaterialParameters } from "three";
+
+declare class LDrawConditionalLineMaterial extends ShaderMaterial {
+    readonly isLDrawConditionalLineMaterial: true;
+
+    constructor(parameters?: ShaderMaterialParameters);
+}
+
+export { LDrawConditionalLineMaterial };

three/examples/jsm/materials/LDrawConditionalLineNodeMaterial.d.ts

@@ -0,0 +1,9 @@
+import { NodeMaterial, NodeMaterialParameters } from "three/tsl";
+
+declare class LDrawConditionalLineMaterial extends NodeMaterial {
+    readonly isLDrawConditionalLineMaterial: true;
+
+    constructor(parameters?: NodeMaterialParameters);
+}
+
+export { LDrawConditionalLineMaterial };

three/examples/jsm/materials/MeshGouraudMaterial.d.ts

@@ -8,7 +8,6 @@ import { ShaderMaterial, ShaderMaterialParameters } from "three";
 
 export class MeshGouraudMaterial extends ShaderMaterial {
     isMeshGouraudMaterial: true;
-    type: "MeshGouraudMaterial";
 
     constructor(parameters?: ShaderMaterialParameters);
 

three/examples/jsm/math/ColorSpaces.d.ts

@@ -0,0 +1,11 @@
+import { ColorSpaceDefinition } from "three";
+
+export const DisplayP3ColorSpace: "display-p3";
+export const LinearDisplayP3ColorSpace: "display-p3-linear";
+
+export const DisplayP3ColorSpaceImpl: ColorSpaceDefinition;
+export const LinearDisplayP3ColorSpaceImpl: ColorSpaceDefinition;
+
+export const LinearRec2020ColorSpace: "rec2020-linear";
+
+export const LinearRec2020ColorSpaceImpl: ColorSpaceDefinition;

three/examples/jsm/misc/ProgressiveLightMap.d.ts

@@ -24,29 +24,23 @@ export interface LightMapContainers {
     object: Object3D;
 }
 
-export class ProgressiveLightMap {
+declare class ProgressiveLightMap {
     renderer: WebGLRenderer;
     res: number;
     lightMapContainers: LightMapContainers[];
-    compiled: boolean;
     scene: Scene;
-    tinyTarget: WebGLRenderTarget;
     buffer1Active: boolean;
     firstUpdate: boolean;
     warned: boolean;
+    labelMesh: Mesh<PlaneGeometry, MeshBasicMaterial> | null;
+    blurringPlane: Mesh<PlaneGeometry, MeshBasicMaterial> | null;
 
     progressiveLightMap1: WebGLRenderTarget;
     progressiveLightMap2: WebGLRenderTarget;
 
     uvMat: MeshPhongMaterial;
 
-    uv_boxes: UVBoxes[];
-
-    blurringPlane: Mesh<PlaneGeometry, MeshBasicMaterial>;
-
-    labelMaterial: MeshBasicMaterial;
-    labelPlane: PlaneGeometry;
-    labelMesh: Mesh<PlaneGeometry, MeshBasicMaterial>;
+    uv_boxes?: UVBoxes[];
 
     constructor(renderer: WebGLRenderer, res?: number);
 
@@ -57,4 +51,8 @@ export class ProgressiveLightMap {
     showDebugLightmap(visible: boolean, position?: Vector3): void;
 
     private _initializeBlurPlane(res: number, lightMap?: Texture | null): void;
+
+    dispose(): void;
 }
+
+export { ProgressiveLightMap };

three/examples/jsm/misc/ProgressiveLightMapGPU.d.ts

@@ -0,0 +1,27 @@
+import { Camera, Material, Object3D, Vector3, WebGPURenderer } from "three/webgpu";
+
+export interface UVBoxes {
+    w: number;
+    h: number;
+    index: number;
+}
+
+export interface LightMapContainers {
+    basicMat: Material | Material[];
+    object: Object3D;
+}
+
+declare class ProgressiveLightMap {
+    renderer: WebGPURenderer;
+    resolution: number;
+
+    constructor(renderer: WebGPURenderer, resolution?: number);
+
+    addObjectsToLightMap(objects: Object3D[]): void;
+
+    update(camera: Camera, blendWindow?: number, blurEdges?: boolean): void;
+
+    showDebugLightmap(visible: boolean, position?: Vector3 | null): void;
+}
+
+export { ProgressiveLightMap };

three/examples/jsm/modifiers/CurveModifier.d.ts

@@ -7,7 +7,7 @@ export interface SplineUniform {
     spineOffset: IUniform;
     flow: IUniform;
 }
-export function initSplineTexture(size?: number): DataTexture;
+export function initSplineTexture(numberOfCurves?: number): DataTexture;
 
 export function updateSplineTexture(texture: DataTexture, splineCurve: Curve<Vector3>, offset?: number): void;
 
@@ -16,22 +16,26 @@ export function getUniforms(splineTexture: DataTexture): SplineUniform;
 export function modifyShader(material: Material, uniforms: SplineUniform, numberOfCurves?: number): void;
 
 export class Flow {
-    constructor(mesh: Mesh, numberOfCurves?: number);
     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 {
-    constructor(count: number, curveCount: number, geometry: BufferGeometry, material: Material);
     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;
 }

three/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;
+}

three/examples/jsm/objects/Lensflare.d.ts

@@ -1,17 +1,21 @@
 import { Color, Mesh, Texture } from "three";
 
-export class LensflareElement {
-    constructor(texture: Texture, size?: number, distance?: number, color?: Color);
+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;
-}
-
-export class Lensflare extends Mesh {
-    constructor();
-    readonly isLensflare: true;
 
-    addElement(element: LensflareElement): void;
-    dispose(): void;
+    constructor(texture: Texture, size?: number, distance?: number, color?: Color);
 }
+
+export { Lensflare, LensflareElement };