@types/three 0.137.0 → 0.138.0

three/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for three (https://threejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three.
 
 ### Additional Details
- * Last updated: Thu, 27 Jan 2022 22:31:34 GMT
+ * Last updated: Wed, 02 Mar 2022 16:01:44 GMT
  * Dependencies: none
  * Global values: `THREE`
 

three/examples/jsm/{WebGL.d.ts → capabilities/WebGL.d.ts}

@@ -1,7 +1,9 @@
-export namespace WEBGL {
+declare namespace WEBGL {
     function isWebGLAvailable(): boolean;
     function isWebGL2Available(): boolean;
     function getWebGLErrorMessage(): HTMLElement;
     function getWebGL2ErrorMessage(): HTMLElement;
     function getErrorMessage(version: number): HTMLElement;
 }
+
+export default WEBGL;

three/examples/jsm/controls/OrbitControls.d.ts

@@ -42,7 +42,6 @@ export class OrbitControls {
     autoRotate: boolean;
     autoRotateSpeed: number;
 
-    enableKeys: boolean;
     keys: { LEFT: string; UP: string; RIGHT: string; BOTTOM: string };
     mouseButtons: { LEFT: MOUSE; MIDDLE: MOUSE; RIGHT: MOUSE };
     touches: { ONE: TOUCH; TWO: TOUCH };

three/examples/jsm/curves/CurveExtras.d.ts

@@ -1,70 +1,68 @@
 import { Curve, Vector3 } from '../../../src/Three';
 
-export namespace Curves {
-    class GrannyKnot extends Curve<Vector3> {
-        constructor();
-    }
+export class GrannyKnot extends Curve<Vector3> {
+    constructor();
+}
 
-    class HeartCurve extends Curve<Vector3> {
-        constructor(scale?: number);
-        scale: number;
-    }
+export class HeartCurve extends Curve<Vector3> {
+    constructor(scale?: number);
+    scale: number;
+}
 
-    class VivianiCurve extends Curve<Vector3> {
-        constructor(scale?: number);
-        scale: number;
-    }
+export class VivianiCurve extends Curve<Vector3> {
+    constructor(scale?: number);
+    scale: number;
+}
 
-    class KnotCurve extends Curve<Vector3> {
-        constructor();
-    }
+export class KnotCurve extends Curve<Vector3> {
+    constructor();
+}
 
-    class HelixCurve extends Curve<Vector3> {
-        constructor();
-    }
+export class HelixCurve extends Curve<Vector3> {
+    constructor();
+}
 
-    class TrefoilKnot extends Curve<Vector3> {
-        constructor(scale?: number);
-        scale: number;
-    }
+export class TrefoilKnot extends Curve<Vector3> {
+    constructor(scale?: number);
+    scale: number;
+}
 
-    class TorusKnot extends Curve<Vector3> {
-        constructor(scale?: number);
-        scale: number;
-    }
+export class TorusKnot extends Curve<Vector3> {
+    constructor(scale?: number);
+    scale: number;
+}
 
-    class CinquefoilKnot extends Curve<Vector3> {
-        constructor(scale?: number);
-        scale: number;
-    }
+export class CinquefoilKnot extends Curve<Vector3> {
+    constructor(scale?: number);
+    scale: number;
+}
 
-    class TrefoilPolynomialKnot extends Curve<Vector3> {
-        constructor(scale?: number);
-        scale: number;
-    }
+export class TrefoilPolynomialKnot extends Curve<Vector3> {
+    constructor(scale?: number);
+    scale: number;
+}
 
-    class FigureEightPolynomialKnot extends Curve<Vector3> {
-        constructor(scale?: number);
-        scale: number;
-    }
+export class FigureEightPolynomialKnot extends Curve<Vector3> {
+    constructor(scale?: number);
+    scale: number;
+}
 
-    class DecoratedTorusKnot4a extends Curve<Vector3> {
-        constructor(scale?: number);
-        scale: number;
-    }
+export class DecoratedTorusKnot4a extends Curve<Vector3> {
+    constructor(scale?: number);
+    scale: number;
+}
 
-    class DecoratedTorusKnot4b extends Curve<Vector3> {
-        constructor(scale?: number);
-        scale: number;
-    }
+export class DecoratedTorusKnot4b extends Curve<Vector3> {
+    constructor(scale?: number);
+    scale: number;
+}
 
-    class DecoratedTorusKnot5a extends Curve<Vector3> {
-        constructor(scale?: number);
-        scale: number;
-    }
+export class DecoratedTorusKnot5a extends Curve<Vector3> {
+    constructor(scale?: number);
+    scale: number;
+}
 
-    class DecoratedTorusKnot5c extends Curve<Vector3> {
-        constructor(scale?: number);
-        scale: number;
-    }
+export class DecoratedTorusKnot5c extends Curve<Vector3> {
+    constructor(scale?: number);
+    scale: number;
 }

three/examples/jsm/exporters/EXRExporter.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @author sciecode / https://github.com/sciecode
+ *
+ * EXR format references: https://www.openexr.com/documentation/openexrfilelayout.pdf
+ */
+
+import { WebGLRenderer, WebGLRenderTarget, TextureDataType } from '../../../src/Three';
+
+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, renderTarget: WebGLRenderTarget, options?: EXRExporterParseOptions): Uint8Array;
+}

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

@@ -0,0 +1,14 @@
+import { ColorRepresentation, LineSegments } from '../../../src/Three';
+import { Octree } from '../math/Octree';
+
+export class OctreeHelper extends LineSegments {
+    constructor(octree: Octree, color: ColorRepresentation);
+
+    octree: Octree;
+    color: ColorRepresentation;
+
+    /**
+     * @default 'OctreeHelper'
+     */
+    type: 'OctreeHelper' | string;
+}

three/examples/jsm/interactive/HTMLMesh.d.ts

@@ -2,4 +2,5 @@ import { Mesh } from 'three';
 
 export class HTMLMesh extends Mesh {
     constructor(dom: HTMLElement);
+    dispose(): void;
 }

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

@@ -101,15 +101,8 @@ export class GLTFParser {
     loadBufferView: (bufferViewIndex: number) => Promise<ArrayBuffer>;
     loadAccessor: (accessorIndex: number) => Promise<BufferAttribute | InterleavedBufferAttribute>;
     loadTexture: (textureIndex: number) => Promise<Texture>;
-    loadTextureImage: (
-        textureIndex: number,
-        /**
-         * GLTF.Image
-         * See: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/schema/image.schema.json
-         */
-        source: { [key: string]: any },
-        loader: Loader,
-    ) => Promise<Texture>;
+    loadTextureImage: (textureIndex: number, sourceIndex: number, loader: Loader) => Promise<Texture>;
+    loadImageSource: (sourceIndex: number, loader: Loader) => Promise<Texture>;
     assignTexture: (
         materialParams: { [key: string]: any },
         mapName: string,

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

@@ -1,9 +1,9 @@
-import { Loader, LoadingManager, DataTexture, DataTexture3D } from '../../../src/Three';
+import { Loader, LoadingManager, DataTexture, Data3DTexture } from '../../../src/Three';
 
 export interface LUT3dlResult {
     size: number;
     texture: DataTexture;
-    texture3D: DataTexture3D;
+    texture3D: Data3DTexture;
 }
 
 export class LUT3dlLoader extends Loader {

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

@@ -1,4 +1,4 @@
-import { Loader, LoadingManager, Vector3, DataTexture, DataTexture3D } from '../../../src/Three';
+import { Loader, LoadingManager, Vector3, DataTexture, Data3DTexture } from '../../../src/Three';
 
 export interface LUTCubeResult {
     title: string;
@@ -6,7 +6,7 @@ export interface LUTCubeResult {
     domainMin: Vector3;
     domainMax: Vector3;
     texture: DataTexture;
-    texture3D: DataTexture3D;
+    texture3D: Data3DTexture;
 }
 
 export class LUTCubeLoader extends Loader {

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

@@ -1,4 +1,4 @@
-import { DataTexture3D, Mesh, Loader, LoadingManager } from '../../../src/Three';
+import { Data3DTexture, Mesh, Loader, LoadingManager } from '../../../src/Three';
 
 export interface Chunk {
     palette: number[];
@@ -23,6 +23,6 @@ export class VOXMesh extends Mesh {
     constructor(chunk: Chunk);
 }
 
-export class VOXDataTexture3D extends DataTexture3D {
+export class VOXData3DTexture extends Data3DTexture {
     constructor(chunk: Chunk);
 }

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

@@ -7,6 +7,7 @@ export interface ReflectorOptions {
     clipBias?: number;
     shader?: object;
     encoding?: TextureEncoding;
+    multisample?: number;
 }
 
 export class Reflector extends Mesh {

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

@@ -7,6 +7,7 @@ export interface RefractorOptions {
     clipBias?: number;
     shader?: object;
     encoding?: TextureEncoding;
+    multisample?: number;
 }
 
 export class Refractor extends Mesh {

three/examples/jsm/postprocessing/LUTPass.d.ts

@@ -1,13 +1,13 @@
-import { DataTexture, DataTexture3D } from '../../../src/Three';
+import { DataTexture, Data3DTexture } from '../../../src/Three';
 import { ShaderPass } from './ShaderPass';
 
 export interface LUTPassParameters {
-    lut?: DataTexture | DataTexture3D;
+    lut?: DataTexture | Data3DTexture;
     intensity?: number;
 }
 
 export class LUTPass extends ShaderPass {
-    lut?: DataTexture | DataTexture3D;
+    lut?: DataTexture | Data3DTexture;
     intensity?: number;
     constructor(params: LUTPassParameters);
 }

three/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for three 0.137
+// Type definitions for three 0.138
 // Project: https://threejs.org/
 // Definitions by: Josh Ellis <https://github.com/joshuaellis>
 //                 Nathan Bierema <https://github.com/Methuselah96>

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.137.0",
+    "version": "0.138.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -25,6 +25,6 @@
     },
     "scripts": {},
     "dependencies": {},
-    "typesPublisherContentHash": "dad1fe1dce939480949b1f93552d8ca03cab08b655aca66703302855e9fb414d",
-    "typeScriptVersion": "3.8"
+    "typesPublisherContentHash": "7873774346bfbeaa8143902909709f9b2a5154afc0017f590bff41e5d3e5e0b7",
+    "typeScriptVersion": "3.9"
 }

three/src/Three.d.ts

@@ -181,6 +181,8 @@ export * from './renderers/WebGLMultipleRenderTargets';
 export * from './renderers/WebGLRenderTarget';
 export * from './renderers/WebGLRenderer';
 export * from './renderers/WebGL1Renderer';
+export * from './renderers/WebGL3DRenderTarget';
+export * from './renderers/WebGLArrayRenderTarget';
 export * from './renderers/shaders/ShaderLib';
 export * from './renderers/shaders/UniformsLib';
 export * from './renderers/shaders/UniformsUtils';
@@ -222,7 +224,10 @@ export * from './textures/DataTexture2DArray';
 export * from './textures/DataTexture3D';
 export * from './textures/CompressedTexture';
 export * from './textures/CubeTexture';
+export * from './textures/Data3DTexture';
+export * from './textures/DataArrayTexture';
 export * from './textures/CanvasTexture';
 export * from './textures/DepthTexture';
 export * from './textures/FramebufferTexture';
+export * from './textures/Source';
 export * from './textures/Texture';

three/src/constants.d.ts

@@ -302,8 +302,6 @@ export enum TextureEncoding {}
 export const LinearEncoding: TextureEncoding;
 export const sRGBEncoding: TextureEncoding;
 export const LogLuvEncoding: TextureEncoding;
-export const RGBM7Encoding: TextureEncoding;
-export const RGBM16Encoding: TextureEncoding;
 
 // Depth packing strategies
 export enum DepthPackingStrategies {}

three/src/core/Raycaster.d.ts

@@ -95,7 +95,7 @@ export class Raycaster {
     /**
      * Checks all intersection between the ray and the object with or without the descendants. Intersections are returned sorted by distance, closest first.
      * @param object The object to check for intersection with the ray.
-     * @param recursive If true, it also checks all descendants. Otherwise it only checks intersecton with the object. Default is false.
+     * @param recursive If true, it also checks all descendants. Otherwise it only checks intersecton with the object. Default is true.
      * @param optionalTarget (optional) target to set the result. Otherwise a new Array is instantiated. If set, you must clear this array prior to each call (i.e., array.length = 0;).
      */
     intersectObject<TIntersected extends Object3D>(
@@ -109,7 +109,7 @@ export class Raycaster {
      * Intersections are returned sorted by distance, closest first.
      * Intersections are of the same form as those returned by .intersectObject.
      * @param objects The objects to check for intersection with the ray.
-     * @param recursive If true, it also checks all descendants of the objects. Otherwise it only checks intersecton with the objects. Default is false.
+     * @param recursive If true, it also checks all descendants of the objects. Otherwise it only checks intersecton with the objects. Default is true.
      * @param optionalTarget (optional) target to set the result. Otherwise a new Array is instantiated. If set, you must clear this array prior to each call (i.e., array.length = 0;).
      */
     intersectObjects<TIntersected extends Object3D>(

three/src/math/Euler.d.ts

@@ -38,7 +38,6 @@ export class Euler {
     equals(euler: Euler): boolean;
     fromArray(xyzo: any[]): Euler;
     toArray(array?: number[], offset?: number): number[];
-    toVector3(optionalResult?: Vector3): Vector3;
     _onChange(callback: () => void): this;
 
     static RotationOrders: string[];

three/src/math/Vector3.d.ts

@@ -252,6 +252,11 @@ export class Vector3 implements Vector {
     setFromMatrixColumn(matrix: Matrix4, index: number): this;
     setFromMatrix3Column(matrix: Matrix3, index: number): this;
 
+    /**
+     * Sets this vector's {@link x}, {@link y} and {@link z} components from the x, y, and z components of the specified {@link Euler Euler Angle}.
+     */
+    setFromEuler(e: Euler): this;
+
     /**
      * Checks for strict equality of this vector and v.
      */

three/src/renderers/WebGL3DRenderTarget.d.ts

@@ -0,0 +1,28 @@
+import { Data3DTexture } from '../textures/Data3DTexture';
+import { WebGLRenderTarget } from './WebGLRenderTarget';
+
+/**
+ * Represents a three-dimensional render target.
+ */
+export class WebGL3DRenderTarget extends WebGLRenderTarget {
+    /**
+     * Creates a new WebGL3DRenderTarget.
+     *
+     * @param width the width of the render target, in pixels.
+     * @param height the height of the render target, in pixels.
+     * @param depth the depth of the render target.
+     */
+    constructor(width: number, height: number, depth: number);
+
+    /**
+     * The depth of the render target.
+     */
+    depth: number;
+
+    /**
+     * The texture property is overwritten with an instance of {@link Data3DTexture}.
+     */
+    texture: Data3DTexture;
+
+    readonly isWebGL3DRenderTarget: true;
+}

three/src/renderers/WebGLArrayRenderTarget.d.ts

@@ -0,0 +1,28 @@
+import { DataArrayTexture } from '../textures/DataArrayTexture';
+import { WebGLRenderTarget } from './WebGLRenderTarget';
+
+/**
+ * This type of render target represents an array of textures.
+ */
+export class WebGLArrayRenderTarget extends WebGLRenderTarget {
+    /**
+     * Creates a new WebGLArrayRenderTarget.
+     *
+     * @param width the width of the render target, in pixels.
+     * @param height the height of the render target, in pixels.
+     * @param depth the depth/layer count of the render target.
+     */
+    constructor(width: number, height: number, depth: number);
+
+    /**
+     * The depth of the render target.
+     */
+    depth: number;
+
+    /**
+     * The texture property is overwritten with an instance of {@link DataArrayTexture}.
+     */
+    texture: DataArrayTexture;
+
+    readonly isWebGLArrayRenderTarget: true;
+}

three/src/renderers/WebGLMultipleRenderTargets.d.ts

@@ -1,5 +1,6 @@
 import { EventDispatcher } from '../core/EventDispatcher';
 import { Texture } from '../textures/Texture';
+import { WebGLRenderTargetOptions } from './WebGLRenderTarget';
 
 /**
  * This class originall extended WebGLMultipleRenderTarget
@@ -10,7 +11,14 @@ export class WebGLMultipleRenderTargets extends EventDispatcher {
 
     readonly isWebGLMultipleRenderTargets = true;
 
-    constructor(width: number, height: number, count: number);
+    /**
+     * @param width The width of the render target.
+     * @param height The height of the render target.
+     * @param count The number of render targets.
+     * @param options object that holds texture parameters for an auto-generated target texture and depthBuffer/stencilBuffer booleans.
+     * For an explanation of the texture parameters see {@link Texture}.
+     */
+    constructor(width: number, height: number, count: number, options?: WebGLRenderTargetOptions);
 
     setSize(width: number, height: number, depth?: number): this;
     copy(source: WebGLMultipleRenderTargets): this;

three/src/renderers/WebGLMultisampleRenderTarget.d.ts

@@ -1,13 +1,6 @@
-import { WebGLRenderTarget, WebGLRenderTargetOptions } from './WebGLRenderTarget';
+import { WebGLRenderTarget } from './WebGLRenderTarget';
 
-export class WebGLMultisampleRenderTarget extends WebGLRenderTarget {
-    constructor(width: number, height: number, options?: WebGLRenderTargetOptions);
-
-    readonly isWebGLMultisampleRenderTarget: true;
-
-    /**
-     * Specifies the number of samples to be used for the renderbuffer storage.However, the maximum supported size for multisampling is platform dependent and defined via gl.MAX_SAMPLES.
-     * @default 4
-     */
-    samples: number;
-}
+/**
+ * @deprecated THREE.WebGLMultisampleRenderTarget has been removed. Use a normal {@link WebGLRenderTarget render target} and set the "samples" property to greater 0 to enable multisampling.
+ */
+export class WebGLMultisampleRenderTarget extends WebGLRenderTarget {}

three/src/renderers/WebGLRenderTarget.d.ts

@@ -49,6 +49,13 @@ export class WebGLRenderTarget extends EventDispatcher {
      * @default null
      */
     depthTexture: DepthTexture;
+
+    /**
+     * Defines the count of MSAA samples. Can only be used with WebGL 2. Default is **0**.
+     * @default 0
+     */
+    samples: number;
+
     readonly isWebGLRenderTarget: true;
 
     /**
@@ -92,7 +99,6 @@ export class WebGLRenderTarget extends EventDispatcher {
      */
     generateMipmaps: any;
 
-    setTexture(texture: Texture): void;
     setSize(width: number, height: number, depth?: number): void;
     clone(): this;
     copy(source: WebGLRenderTarget): this;

three/src/renderers/WebGLRenderer.d.ts

@@ -5,7 +5,6 @@ import { WebGLInfo } from './webgl/WebGLInfo';
 import { WebGLShadowMap } from './webgl/WebGLShadowMap';
 import { WebGLCapabilities } from './webgl/WebGLCapabilities';
 import { WebGLProperties } from './webgl/WebGLProperties';
-import { WebGLProgram } from './webgl/WebGLProgram';
 import { WebGLRenderLists } from './webgl/WebGLRenderLists';
 import { WebGLState } from './webgl/WebGLState';
 import { Vector2 } from './../math/Vector2';
@@ -19,11 +18,11 @@ import { ToneMapping, ShadowMapType, CullFace, TextureEncoding } from '../consta
 import { WebXRManager } from '../renderers/webxr/WebXRManager';
 import { BufferGeometry } from './../core/BufferGeometry';
 import { Texture } from '../textures/Texture';
-import { DataTexture3D } from '../textures/DataTexture3D';
+import { Data3DTexture } from '../textures/Data3DTexture';
 import { XRAnimationLoopCallback } from './webxr/WebXR';
 import { Vector3 } from '../math/Vector3';
 import { Box3 } from '../math/Box3';
-import { DataTexture2DArray } from '../textures/DataTexture2DArray';
+import { DataArrayTexture } from '../textures/DataArrayTexture';
 import { ColorRepresentation } from '../utils';
 
 export interface Renderer {
@@ -437,7 +436,7 @@ export class WebGLRenderer implements Renderer {
         sourceBox: Box3,
         position: Vector3,
         srcTexture: Texture,
-        dstTexture: DataTexture3D | DataTexture2DArray,
+        dstTexture: Data3DTexture | DataArrayTexture,
         level?: number,
     ): void;
 

three/src/textures/CompressedTexture.d.ts

@@ -38,7 +38,8 @@ export class CompressedTexture extends Texture {
         encoding?: TextureEncoding,
     );
 
-    image: { width: number; height: number };
+    get image(): { width: number; height: number };
+    set image(value: { width: number; height: number });
 
     mipmaps: ImageData[];
 

three/src/textures/Data3DTexture.d.ts

@@ -0,0 +1,33 @@
+import { Texture } from './Texture';
+import { TextureFilter } from '../constants';
+
+export class Data3DTexture extends Texture {
+    constructor(data: BufferSource, width: number, height: number, depth: number);
+
+    /**
+     * @default THREE.NearestFilter
+     */
+    magFilter: TextureFilter;
+
+    /**
+     * @default THREE.NearestFilter
+     */
+    minFilter: TextureFilter;
+
+    /**
+     * @default THREE.ClampToEdgeWrapping
+     */
+    wrapR: boolean;
+
+    /**
+     * @default false
+     */
+    flipY: boolean;
+
+    /**
+     * @default false
+     */
+    generateMipmaps: boolean;
+
+    readonly isData3DTexture: true;
+}

three/src/textures/DataArrayTexture.d.ts

@@ -0,0 +1,33 @@
+import { Texture } from './Texture';
+import { TextureFilter } from '../constants';
+
+export class DataArrayTexture extends Texture {
+    constructor(data?: BufferSource, width?: number, height?: number, depth?: number);
+
+    /**
+     * @default THREE.NearestFilter
+     */
+    magFilter: TextureFilter;
+
+    /**
+     * @default THREE.NearestFilter
+     */
+    minFilter: TextureFilter;
+
+    /**
+     * @default THREE.ClampToEdgeWrapping
+     */
+    wrapR: boolean;
+
+    /**
+     * @default false
+     */
+    flipY: boolean;
+
+    /**
+     * @default false
+     */
+    generateMipmaps: boolean;
+
+    readonly isDataArrayTexture: true;
+}

three/src/textures/DataTexture.d.ts

@@ -31,7 +31,8 @@ export class DataTexture extends Texture {
         encoding?: TextureEncoding,
     );
 
-    image: ImageData;
+    get image(): ImageData;
+    set image(value: ImageData);
 
     /**
      * @default false