@types/three 0.152.1 → 0.153.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, 25 May 2023 20:34:45 GMT
+ * Last updated: Thu, 06 Jul 2023 18:35:25 GMT
  * Dependencies: [@types/fflate](https://npmjs.com/package/@types/fflate), [@types/lil-gui](https://npmjs.com/package/@types/lil-gui), [@types/stats.js](https://npmjs.com/package/@types/stats.js), [@types/tweenjs__tween.js](https://npmjs.com/package/@types/tweenjs__tween.js), [@types/webxr](https://npmjs.com/package/@types/webxr)
  * Global values: `THREE`
 

three/examples/jsm/animation/MMDAnimationHelper.d.ts

@@ -17,6 +17,7 @@ export interface MMDAnimationHelperParameter {
     sync?: boolean | undefined;
     afterglow?: number | undefined;
     resetPhysicsOnLoop?: boolean | undefined;
+    pmxAnimation?: boolean | undefined;
 }
 
 export interface MMDAnimationHelperAddParameter {
@@ -55,6 +56,7 @@ export class MMDAnimationHelper {
         sync: boolean;
         afterglow: number;
         resetPhysicsOnLoop: boolean;
+        pmxAnimation: boolean;
     };
     enabled: {
         animation: boolean;

three/examples/jsm/csm/CSM.d.ts

@@ -24,7 +24,7 @@ export interface CMSParameters {
 }
 
 export class CSM {
-    constructor(data?: CMSParameters);
+    constructor(data: CMSParameters);
     camera: Camera;
     parent: Object3D;
     cascades: number;

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

@@ -13,5 +13,5 @@ export interface DRACOExporterOptions {
 export class DRACOExporter {
     constructor();
 
-    parse(object: Mesh | Points, options: DRACOExporterOptions): Int8Array;
+    parse(object: Mesh | Points, options?: DRACOExporterOptions): Int8Array;
 }

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

@@ -1,13 +1,30 @@
 import { Object3D } from '../../../src/Three';
 
-export interface PLYExporterOptions {
-    binary?: boolean;
+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: string) => void, options: PLYExporterOptions): string | null;
+    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;
 }

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

@@ -1,5 +1,13 @@
 import { Object3D } from '../../../src/Three';
 
+export interface STLExporterOptionsBinary {
+    binary: true;
+}
+
+export interface STLExporterOptionsString {
+    binary?: false;
+}
+
 export interface STLExporterOptions {
     binary?: boolean;
 }
@@ -7,5 +15,7 @@ export interface STLExporterOptions {
 export class STLExporter {
     constructor();
 
-    parse(scene: Object3D, options?: STLExporterOptions): string;
+    parse(scene: Object3D, options: STLExporterOptionsBinary): DataView;
+    parse(scene: Object3D, options?: STLExporterOptionsString): string;
+    parse(scene: Object3D, options?: STLExporterOptions): string | DataView;
 }

three/examples/jsm/geometries/TeapotGeometry.d.ts

@@ -8,6 +8,6 @@ export class TeapotGeometry extends BufferGeometry {
         lid?: boolean,
         body?: boolean,
         fitLid?: boolean,
-        blinn?: number,
+        blinn?: boolean,
     );
 }

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

@@ -199,7 +199,7 @@ export class IFCManager {
     /**
      * Removes the specified subset.
      * @param modelID ID of the IFC model.
-     * @parent The parent where the subset is (can be any `THREE.Object3D`).
+     * @param parent The parent where the subset is (can be any `THREE.Object3D`).
      * @param material Material assigned to the subset, if any.
      */
     removeSubset(modelID: number, parent?: Object3D, material?: Material): void;
@@ -378,7 +378,7 @@ export class IFCModel extends Mesh {
      * @deprecated Use `IfcModel.ifcManager.removeSubset` instead.
      *
      * Removes the specified subset.
-     * @parent The parent where the subset is (can be any `THREE.Object3D`).
+     * @param parent The parent where the subset is (can be any `THREE.Object3D`).
      * @param material Material assigned to the subset, if any.
      */
     removeSubset(parent?: Object3D, material?: Material): void;
@@ -602,13 +602,13 @@ export class IfcAPI {
     /**
      * Opens a model and returns a modelID number
      * @param data Buffer containing IFC data (bytes)
-     * @param settings Settings settings for loading the model
+     * @param settings Settings for loading the model
      */
     OpenModel(data: string | Uint8Array, settings?: LoaderSettings): number;
 
     /**
      * Creates a new model and returns a modelID number
-     * @param settings Settings settings for generating data the model
+     * @param settings Settings for generating data the model
      */
     CreateModel(settings?: LoaderSettings): number;
 

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

@@ -49,7 +49,7 @@ export class GPUComputationRenderer {
         magFilter: MagnificationTextureFilter,
     ): WebGLRenderTarget;
     createTexture(): DataTexture;
-    renderTexture(input: Texture, output: Texture): void;
+    renderTexture(input: Texture, output: WebGLRenderTarget): void;
     doRenderTarget(material: Material, output: WebGLRenderTarget): void;
     dispose(): void;
 }

three/examples/jsm/nodes/accessors/ModelViewProjectionNode.d.ts

@@ -2,5 +2,5 @@ import Node from '../core/Node';
 import PositionNode from './PositionNode';
 
 export default class ModelViewProjectionNode extends Node {
-    constructor(position?: PositionNode);
+    constructor(positionNode?: PositionNode);
 }

three/examples/jsm/nodes/core/NodeBuilder.d.ts

@@ -106,7 +106,7 @@ export default abstract class NodeBuilder {
     getVectorFromMatrix(type: NodeTypeOption): NodeTypeOption;
     getDataFromNode(node: Node, shaderStage?: NodeShaderStageOption): NodeData;
     getNodeProperties(node: Node, shaderStage?: NodeShaderStageOption): AnyObject;
-    getUniformFromNode(node: Node, shaderStage: NodeShaderStageOption, type: NodeTypeOption): NodeUniform;
+    getUniformFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): NodeUniform;
     getVarFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): NodeVar;
     getVaryFromNode(node: Node, type: NodeTypeOption): NodeVarying;
     getCodeFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): string;

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

@@ -3,7 +3,7 @@ import { ShaderMaterial } from '../../../src/Three';
 import { Pass, FullScreenQuad } from './Pass';
 
 export class FilmPass extends Pass {
-    constructor(noiseIntensity?: number, scanlinesIntensity?: number, scanlinesCount?: number, grayscale?: number);
+    constructor(noiseIntensity?: number, scanlinesIntensity?: number, scanlinesCount?: number, grayscale?: boolean);
     uniforms: object;
     material: ShaderMaterial;
     fsQuad: FullScreenQuad;

three/examples/jsm/utils/UVsDebug.d.ts

@@ -1,3 +1,3 @@
 import { BufferGeometry } from '../../../src/Three';
 
-export function UVsDebug(geometry: BufferGeometry, size: number): HTMLCanvasElement;
+export function UVsDebug(geometry: BufferGeometry, size?: number): HTMLCanvasElement;

three/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for three 0.152
+// Type definitions for three 0.153
 // 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.152.1",
+    "version": "0.153.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -31,7 +31,7 @@
         "fflate": "~0.6.9",
         "lil-gui": "~0.17.0"
     },
-    "typesPublisherContentHash": "4a1b7a1820d0565498723427b382216d64d91a892d84b4a3ad2c73c41a5fe823",
+    "typesPublisherContentHash": "776e445e303f817fc78a39d4f0acdac279c33b7cc46a10995a77955c8386f84d",
     "typeScriptVersion": "4.4",
     "exports": {
         ".": {

three/src/cameras/Camera.d.ts

@@ -1,7 +1,8 @@
-import { Matrix4 } from './../math/Matrix4';
-import { Vector3 } from './../math/Vector3';
-import { Object3D } from './../core/Object3D';
-import { Layers } from '../Three';
+import { Matrix4 } from '../math/Matrix4';
+import { Vector3 } from '../math/Vector3';
+import { Object3D } from '../core/Object3D';
+import { Layers } from '../core/Layers';
+import { CoordinateSystem } from '../constants';
 
 /**
  * Abstract base class for cameras
@@ -59,6 +60,8 @@ export abstract class Camera extends Object3D {
      */
     projectionMatrixInverse: Matrix4;
 
+    coordinateSystem: CoordinateSystem;
+
     /**
      * Returns a {@link THREE.Vector3 | Vector3} representing the world space direction in which the {@link Camera} is looking.
      * @remarks Note: A {@link Camera} looks down its local, negative z-axis.

three/src/cameras/CubeCamera.d.ts

@@ -2,6 +2,7 @@ import { WebGLCubeRenderTarget } from './../renderers/WebGLCubeRenderTarget';
 import { Scene } from './../scenes/Scene';
 import { WebGLRenderer } from './../renderers/WebGLRenderer';
 import { Object3D } from './../core/Object3D';
+import { CoordinateSystem } from '../constants';
 
 /**
  * Creates **6** {@link THREE.PerspectiveCamera | cameras} that render to a {@link THREE.WebGLCubeRenderTarget | WebGLCubeRenderTarget}.
@@ -53,6 +54,10 @@ export class CubeCamera extends Object3D {
      */
     renderTarget: WebGLCubeRenderTarget;
 
+    coordinateSystem: CoordinateSystem;
+
+    updateCoordinateSystem(): void;
+
     /**
      * Call this to update the {@link CubeCamera.renderTarget | renderTarget}.
      * @param renderer The current WebGL renderer

three/src/constants.d.ts

@@ -323,6 +323,8 @@ export const UnsignedShort4444Type: 1017;
 export const UnsignedShort5551Type: 1018;
 export const UnsignedInt248Type: 1020;
 
+export type AttributeGPUType = typeof FloatType | typeof IntType;
+
 /**
  * Texture Types.
  * @remarks Must correspond to the correct {@link PixelFormat | format}.
@@ -409,7 +411,7 @@ export const RGIntegerFormat: 1031;
  */
 export const RGBAIntegerFormat: 1033;
 
-export const _SRGBAFormat = 1035; // fallback for WebGL 1
+export const _SRGBAFormat: 1035; // fallback for WebGL 1
 
 /**
  * Texture Pixel Formats Modes. Compatible only with {@link WebGLRenderingContext | WebGL 1 Rendering Context}.
@@ -709,7 +711,7 @@ export type NormalMapTypes = typeof TangentSpaceNormalMap | typeof ObjectSpaceNo
 export const NoColorSpace: '';
 export const SRGBColorSpace: 'srgb';
 export const LinearSRGBColorSpace: 'srgb-linear';
-export const DisplayP3ColorSpace = 'display-p3';
+export const DisplayP3ColorSpace: 'display-p3';
 export type ColorSpace =
     | typeof NoColorSpace
     | typeof SRGBColorSpace
@@ -754,6 +756,24 @@ export type StencilFunc =
     | typeof GreaterEqualStencilFunc
     | typeof AlwaysStencilFunc;
 
+export const NeverCompare: 512;
+export const LessCompare: 513;
+export const EqualCompare: 514;
+export const LessEqualCompare: 515;
+export const GreaterCompare: 516;
+export const NotEqualCompare: 517;
+export const GreaterEqualCompare: 518;
+export const AlwaysCompare: 519;
+export type TextureComparisonFunction =
+    | typeof NeverCompare
+    | typeof LessCompare
+    | typeof EqualCompare
+    | typeof LessEqualCompare
+    | typeof GreaterCompare
+    | typeof NotEqualCompare
+    | typeof GreaterEqualCompare
+    | typeof AlwaysCompare;
+
 // usage types
 export const StaticDrawUsage: 35044;
 export const DynamicDrawUsage: 35048;
@@ -779,6 +799,10 @@ export const GLSL1: '100';
 export const GLSL3: '300 es';
 export type GLSLVersion = typeof GLSL1 | typeof GLSL3;
 
+export const WebGLCoordinateSystem: 2000;
+export const WebGPUCoordinateSystem: 2001;
+export type CoordinateSystem = typeof WebGLCoordinateSystem | typeof WebGPUCoordinateSystem;
+
 ///////////////////////////////////////////////////////////////////////////////
 // Texture - Internal Pixel Formats
 

three/src/core/BufferAttribute.d.ts

@@ -1,4 +1,4 @@
-import { Usage } from '../constants';
+import { Usage, AttributeGPUType } from '../constants';
 import { Matrix3 } from './../math/Matrix3';
 import { Matrix4 } from './../math/Matrix4';
 
@@ -66,6 +66,14 @@ export class BufferAttribute {
      */
     usage: Usage;
 
+    /**
+     * Configures the bound GPU type for use in shaders. Either {@link FloatType} or {@link IntType}, default is {@link FloatType}.
+     *
+     * Note: this only has an effect for integer arrays and is not configurable for float arrays. For lower precision
+     * float types, see https://threejs.org/docs/#api/en/core/bufferAttributeTypes/BufferAttributeTypes.
+     */
+    gpuType: AttributeGPUType;
+
     /**
      * This can be used to only update some components of stored vectors (for example, just the component related to color).
      * @defaultValue `{ offset: number = 0; count: number = -1 }`

three/src/helpers/GridHelper.d.ts

@@ -1,5 +1,7 @@
 import { ColorRepresentation } from '../math/Color';
 import { LineSegments } from './../objects/LineSegments';
+import { BufferGeometry } from '../core/BufferGeometry';
+import { LineBasicMaterial } from '../materials/LineBasicMaterial';
 
 /**
  * The {@link GridHelper} is an object to define grids
@@ -16,7 +18,7 @@ import { LineSegments } from './../objects/LineSegments';
  * @see {@link https://threejs.org/docs/index.html#api/en/helpers/GridHelper | Official Documentation}
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/helpers/GridHelper.js | Source}
  */
-export class GridHelper extends LineSegments {
+export class GridHelper extends LineSegments<BufferGeometry, LineBasicMaterial> {
     /**
      * Creates a new {@link GridHelper} of size 'size' and divided into 'divisions' segments per side
      * @remarks

three/src/lights/DirectionalLight.d.ts

@@ -65,7 +65,7 @@ export class DirectionalLight extends Light<DirectionalLightShadow> {
      * This is set equal to {@link THREE.Object3D.DEFAULT_UP}, so that the light shines from the top down.
      * @defaultValue {@link Object3D.DEFAULT_UP} _(0, 1, 0)_
      */
-    override position: Vector3;
+    override readonly position: Vector3;
 
     /**
      * A {@link THREE.DirectionalLightShadow | DirectionalLightShadow} used to calculate shadows for this light.

three/src/lights/Light.d.ts

@@ -38,7 +38,7 @@ export abstract class Light<TShadowSupport extends LightShadow | undefined = Lig
 
     /**
      * The light's intensity, or strength.
-     * In {@link THREE.WebGLRenderer.physicallyCorrectLights | physically correct} mode, the units of intensity depend on the type of light.
+     * When {@link THREE.WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled, the units of intensity depend on the type of light.
      * @remarks Expects a `Float`
      * @defaultValue `1`
      */

three/src/lights/PointLight.d.ts

@@ -37,7 +37,7 @@ export class PointLight extends Light<PointLightShadow> {
     /**
      * The light's intensity.
      *
-     * When **{@link WebGLRenderer.physicallyCorrectLights | physically correct} mode** — intensity is the luminous intensity of the light measured in candela (cd).
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — intensity is the luminous intensity of the light measured in candela (cd).
      * @remarks Changing the intensity will also change the light's power.
      * @remarks Expects a `Float`
      * @defaultValue `1`
@@ -48,7 +48,7 @@ export class PointLight extends Light<PointLightShadow> {
      * When **Default mode** — When distance is zero, light does not attenuate. When distance is non-zero,
      * light will attenuate linearly from maximum intensity at the light's position down to zero at this distance from the light.
      *
-     * When **{@link WebGLRenderer.physicallyCorrectLights | Physically correct} rendering mode** — When distance is zero,
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — When distance is zero,
      * light will attenuate according to inverse-square law to infinite distance.
      * When distance is non-zero, light will attenuate according to inverse-square law until near the distance cutoff,
      * where it will then attenuate quickly and smoothly to 0. Inherently, cutoffs are not physically correct.
@@ -68,7 +68,7 @@ export class PointLight extends Light<PointLightShadow> {
 
     /**
      * The amount the light dims along the distance of the light.
-     * In **{@link WebGLRenderer.physicallyCorrectLights | physically correct} rendering mode** — the default value **should not** be changed.
+     * In context of physically-correct rendering the default value should not be changed.
      * @remarks Expects a `Float`
      * @defaultValue `2`
      */
@@ -87,7 +87,7 @@ export class PointLight extends Light<PointLightShadow> {
 
     /**
      * The light's power.
-     * When **{@link WebGLRenderer.physicallyCorrectLights | physically correct} rendering mode** — power is the luminous power of the light measured in lumens (lm).
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — power is the luminous power of the light measured in lumens (lm).
      * @remarks Changing the power will also change the light's intensity.
      * @remarks Expects a `Float`
      */

three/src/lights/RectAreaLight.d.ts

@@ -66,7 +66,7 @@ export class RectAreaLight extends Light<undefined> {
     /**
      * The light's intensity.
      * @remarks Changing the intensity will also change the light's power.
-     * In **{@link WebGLRenderer.physicallyCorrectLights | physically correct} rendering mode** — intensity is the luminance (brightness) of the light measured in nits (cd/m^2).
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — intensity is the luminance (brightness) of the light measured in nits (cd/m^2).
      * @remarks Expects a `Float`
      * @defaultValue `1`
      */
@@ -75,7 +75,7 @@ export class RectAreaLight extends Light<undefined> {
     /**
      * The light's power.
      * @remarks Changing the power will also change the light's intensity.
-     * In **{@link WebGLRenderer.physicallyCorrectLights | physically correct} rendering mode** — power is the luminous power of the light measured in lumens (lm).
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — power is the luminous power of the light measured in lumens (lm).
      * @remarks Expects a `Float`
      */
     power: number;

three/src/lights/SpotLight.d.ts

@@ -63,7 +63,7 @@ export class SpotLight extends Light<SpotLightShadow> {
      * This is set equal to {@link THREE.Object3D.DEFAULT_UP | Object3D.DEFAULT_UP} (0, 1, 0), so that the light shines from the top down.
      * @defaultValue `{@link Object3D.DEFAULT_UP}`
      */
-    position: Vector3;
+    readonly position: Vector3;
 
     /**
      * The {@link SpotLight} points from its {@link SpotLight.position | position} to target.position.
@@ -97,7 +97,7 @@ export class SpotLight extends Light<SpotLightShadow> {
     /**
      * The light's intensity.
      * @remarks Changing the intensity will also change the light's power.
-     * When **{@link WebGLRenderer.physicallyCorrectLights | Physically correct} rendering mode** — intensity is the luminous intensity of the light measured in candela (cd).
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — intensity is the luminous intensity of the light measured in candela (cd).
      * @remarks Expects a `Float`
      * @defaultValue `1`
      */
@@ -107,7 +107,7 @@ export class SpotLight extends Light<SpotLightShadow> {
      * When **Default mode** — When distance is zero, light does not attenuate. When distance is non-zero,
      * light will attenuate linearly from maximum intensity at the light's position down to zero at this distance from the light.
      *
-     * When **{@link WebGLRenderer.physicallyCorrectLights | Physically correct} rendering mode** — When distance is zero,
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — When distance is zero,
      * light will attenuate according to inverse-square law to infinite distance.
      * When distance is non-zero, light will attenuate according to inverse-square law until near the distance cutoff,
      * where it will then attenuate quickly and smoothly to `0`. Inherently, cutoffs are not physically correct.
@@ -126,7 +126,7 @@ export class SpotLight extends Light<SpotLightShadow> {
 
     /**
      * The amount the light dims along the distance of the light.
-     * In **{@link WebGLRenderer.physicallyCorrectLights | physically correct} rendering mode** — the default value should not be changed.
+     * In context of physically-correct rendering the default value should not be changed.
      * @remarks Expects a `Float`
      * @defaultValue `2`
      */
@@ -141,7 +141,7 @@ export class SpotLight extends Light<SpotLightShadow> {
     /**
      * The light's power.
      * @remarks Changing the power will also change the light's intensity.
-     * In **{@link WebGLRenderer.physicallyCorrectLights | physically correct} rendering mode** —  power is the luminous power of the light measured in lumens (lm).
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** —  power is the luminous power of the light measured in lumens (lm).
      * @remarks Expects a `Float`
      */
     power: number;

three/src/materials/MeshPhysicalMaterial.d.ts

@@ -39,6 +39,10 @@ export interface MeshPhysicalMaterialParameters extends MeshStandardMaterialPara
     iridescence?: number | undefined;
     iridescenceThicknessRange?: [number, number] | undefined;
     iridescenceThicknessMap?: Texture | null | undefined;
+
+    anisotropy?: number | undefined;
+    anisotropyRotation?: number | undefined;
+    anisotropyMap?: Texture | null | undefined;
 }
 
 export class MeshPhysicalMaterial extends MeshStandardMaterial {
@@ -193,4 +197,19 @@ export class MeshPhysicalMaterial extends MeshStandardMaterial {
      * @default null
      */
     iridescenceThicknessMap: Texture | null;
+
+    /**
+     * @default 0
+     */
+    anisotropy?: number;
+
+    /**
+     * @default 0
+     */
+    anisotropyRotation?: number;
+
+    /**
+     * @default null
+     */
+    anisotropyMap?: Texture | null;
 }

three/src/math/Color.d.ts

@@ -204,7 +204,8 @@ export class Color {
      */
     b: number;
 
-    set(color: ColorRepresentation): Color;
+    set(color: ColorRepresentation): this;
+    set(r: number, g: number, b: number): this;
 
     /**
      * Sets this color's {@link r}, {@link g} and {@link b} components from the x, y, and z components of the specified

three/src/math/Frustum.d.ts

@@ -5,6 +5,7 @@ import { Sprite } from './../objects/Sprite';
 import { Sphere } from './Sphere';
 import { Box3 } from './Box3';
 import { Vector3 } from './Vector3';
+import { CoordinateSystem } from '../constants';
 
 /**
  * Frustums are used to determine what is inside the camera's field of view. They help speed up the rendering process.
@@ -20,7 +21,7 @@ export class Frustum {
     set(p0: Plane, p1: Plane, p2: Plane, p3: Plane, p4: Plane, p5: Plane): Frustum;
     clone(): this;
     copy(frustum: Frustum): this;
-    setFromProjectionMatrix(m: Matrix4): this;
+    setFromProjectionMatrix(m: Matrix4, coordinateSystem?: CoordinateSystem): this;
     intersectsObject(object: Object3D): boolean;
     intersectsSprite(sprite: Sprite): boolean;
     intersectsSphere(sphere: Sphere): boolean;

three/src/math/MathUtils.d.ts

@@ -5,6 +5,7 @@ import { Quaternion } from './Quaternion';
  */
 
 export const DEG2RAD: number;
+
 export const RAD2DEG: number;
 
 export function generateUUID(): string;
@@ -13,10 +14,11 @@ export function generateUUID(): string;
  * Clamps the x to be between a and b.
  *
  * @param value Value to be clamped.
- * @param min Minimum value
+ * @param min Minimum value.
  * @param max Maximum value.
  */
 export function clamp(value: number, min: number, max: number): number;
+
 export function euclideanModulo(n: number, m: number): number;
 
 /**
@@ -30,44 +32,6 @@ export function euclideanModulo(n: number, m: number): number;
  */
 export function mapLinear(x: number, a1: number, a2: number, b1: number, b2: number): number;
 
-export function smoothstep(x: number, min: number, max: number): number;
-
-export function smootherstep(x: number, min: number, max: number): number;
-
-/**
- * Random float from 0 to 1 with 16 bits of randomness.
- * Standard Math.random() creates repetitive patterns when applied over larger space.
- *
- * @deprecated Use {@link Math#random Math.random()}
- */
-export function random16(): number;
-
-/**
- * Random integer from low to high interval.
- */
-export function randInt(low: number, high: number): number;
-
-/**
- * Random float from low to high interval.
- */
-export function randFloat(low: number, high: number): number;
-
-/**
- * Random float from - range / 2 to range / 2 interval.
- */
-export function randFloatSpread(range: number): number;
-
-/**
- * Deterministic pseudo-random float in the interval [ 0, 1 ].
- */
-export function seededRandom(seed?: number): number;
-
-export function degToRad(degrees: number): number;
-
-export function radToDeg(radians: number): number;
-
-export function isPowerOfTwo(value: number): boolean;
-
 export function inverseLerp(x: number, y: number, t: number): number;
 
 /**
@@ -99,18 +63,75 @@ export function damp(x: number, y: number, lambda: number, dt: number): number;
  */
 export function pingpong(x: number, length?: number): number;
 
+export function smoothstep(x: number, min: number, max: number): number;
+
+export function smootherstep(x: number, min: number, max: number): number;
+
 /**
- * @deprecated Use {@link Math#floorPowerOfTwo .floorPowerOfTwo()}
+ * Random integer from low to high interval.
  */
-export function nearestPowerOfTwo(value: number): number;
+export function randInt(low: number, high: number): number;
 
 /**
- * @deprecated Use {@link Math#ceilPowerOfTwo .ceilPowerOfTwo()}
+ * Random float from low to high interval.
  */
-export function nextPowerOfTwo(value: number): number;
+export function randFloat(low: number, high: number): number;
 
-export function floorPowerOfTwo(value: number): number;
+/**
+ * Random float from - range / 2 to range / 2 interval.
+ */
+export function randFloatSpread(range: number): number;
+
+/**
+ * Deterministic pseudo-random float in the interval [ 0, 1 ].
+ */
+export function seededRandom(seed?: number): number;
+
+export function degToRad(degrees: number): number;
+
+export function radToDeg(radians: number): number;
+
+export function isPowerOfTwo(value: number): boolean;
 
 export function ceilPowerOfTwo(value: number): number;
 
+export function floorPowerOfTwo(value: number): number;
+
 export function setQuaternionFromProperEuler(q: Quaternion, a: number, b: number, c: number, order: string): void;
+
+export function denormalize(
+    value: number,
+    array: Float32Array | Uint32Array | Uint16Array | Uint8Array | Int32Array | Int16Array | Int8Array,
+): number;
+
+export function normalize(
+    value: number,
+    array: Float32Array | Uint32Array | Uint16Array | Uint8Array | Int32Array | Int16Array | Int8Array,
+): number;
+
+export const MathUtils: {
+    DEG2RAD: typeof DEG2RAD;
+    RAD2DEG: typeof RAD2DEG;
+    generateUUID: typeof generateUUID;
+    clamp: typeof clamp;
+    euclideanModulo: typeof euclideanModulo;
+    mapLinear: typeof mapLinear;
+    inverseLerp: typeof inverseLerp;
+    lerp: typeof lerp;
+    damp: typeof damp;
+    pingpong: typeof pingpong;
+    smoothstep: typeof smoothstep;
+    smootherstep: typeof smootherstep;
+    randInt: typeof randInt;
+    randFloat: typeof randFloat;
+    randFloatSpread: typeof randFloatSpread;
+    seededRandom: typeof seededRandom;
+    degToRad: typeof degToRad;
+    radToDeg: typeof radToDeg;
+    isPowerOfTwo: typeof isPowerOfTwo;
+    ceilPowerOfTwo: typeof ceilPowerOfTwo;
+    floorPowerOfTwo: typeof floorPowerOfTwo;
+    setQuaternionFromProperEuler: typeof setQuaternionFromProperEuler;
+    normalize: typeof normalize;
+    denormalize: typeof denormalize;
+};

three/src/math/Matrix3.d.ts

@@ -1,6 +1,7 @@
 // https://threejs.org/docs/#api/en/math/Matrix3
 
 import { Matrix4 } from './Matrix4';
+import { Vector2 } from './Vector2';
 import { Vector3 } from './Vector3';
 
 export type Matrix3Tuple = [number, number, number, number, number, number, number, number, number];
@@ -55,6 +56,20 @@ export class Matrix3 implements Matrix {
      * Creates an identity matrix.
      */
     constructor();
+    /**
+     * Creates a 3x3 matrix with the given arguments in row-major order.
+     */
+    constructor(
+        n11: number,
+        n12: number,
+        n13: number,
+        n21: number,
+        n22: number,
+        n23: number,
+        n31: number,
+        n32: number,
+        n33: number,
+    );
 
     /**
      * Array with matrix values.
@@ -113,8 +128,8 @@ export class Matrix3 implements Matrix {
      * @param x the amount to translate in the X axis.
      * @param y the amount to translate in the Y axis.
      */
+    makeTranslation(v: Vector2): this;
     makeTranslation(x: number, y: number): this;
-    makeTranslation(x: number, y: number): Matrix3;
 
     /**
      * Sets this matrix as a 2D rotational transformation by theta radians. The resulting matrix will be:

three/src/math/Matrix4.d.ts

@@ -2,6 +2,7 @@ import { Vector3 } from './Vector3';
 import { Euler } from './Euler';
 import { Quaternion } from './Quaternion';
 import { Matrix, Matrix3 } from './Matrix3';
+import { CoordinateSystem } from '../constants';
 
 export type Matrix4Tuple = [
     number,
@@ -41,7 +42,31 @@ export type Matrix4Tuple = [
  * m.multiply( m3 );
  */
 export class Matrix4 implements Matrix {
+    /**
+     * Creates an identity matrix.
+     */
     constructor();
+    /**
+     * Creates a 4x4 matrix with the given arguments in row-major order.
+     */
+    constructor(
+        n11: number,
+        n12: number,
+        n13: number,
+        n14: number,
+        n21: number,
+        n22: number,
+        n23: number,
+        n24: number,
+        n31: number,
+        n32: number,
+        n33: number,
+        n34: number,
+        n41: number,
+        n42: number,
+        n43: number,
+        n44: number,
+    );
 
     /**
      * Array with matrix values.
@@ -147,7 +172,8 @@ export class Matrix4 implements Matrix {
     /**
      * Sets this matrix as translation transform.
      */
-    makeTranslation(x: number, y: number, z: number): Matrix4;
+    makeTranslation(v: Vector3): this;
+    makeTranslation(x: number, y: number, z: number): this;
 
     /**
      * Sets this matrix as rotation transform around x axis by theta radians.
@@ -199,20 +225,31 @@ export class Matrix4 implements Matrix {
      */
     decompose(translation: Vector3, rotation: Quaternion, scale: Vector3): Matrix4;
 
-    /**
-     * Creates a frustum matrix.
-     */
-    makePerspective(left: number, right: number, bottom: number, top: number, near: number, far: number): Matrix4;
-
     /**
      * Creates a perspective projection matrix.
      */
-    makePerspective(fov: number, aspect: number, near: number, far: number): Matrix4;
+    makePerspective(
+        left: number,
+        right: number,
+        top: number,
+        bottom: number,
+        near: number,
+        far: number,
+        coordinateSystem?: CoordinateSystem,
+    ): Matrix4;
 
     /**
      * Creates an orthographic projection matrix.
      */
-    makeOrthographic(left: number, right: number, top: number, bottom: number, near: number, far: number): Matrix4;
+    makeOrthographic(
+        left: number,
+        right: number,
+        top: number,
+        bottom: number,
+        near: number,
+        far: number,
+        coordinateSystem?: CoordinateSystem,
+    ): Matrix4;
     equals(matrix: Matrix4): boolean;
 
     /**

three/src/math/Vector2.d.ts

@@ -448,4 +448,9 @@ export class Vector2 implements Vector {
      * Sets this vector's x and y from Math.random
      */
     random(): this;
+
+    /**
+     * Iterating through a Vector2 instance will yield its components (x, y) in the corresponding order.
+     */
+    [Symbol.iterator](): Iterator<number>;
 }

three/src/math/Vector3.d.ts

@@ -301,4 +301,9 @@ export class Vector3 implements Vector {
     random(): this;
 
     randomDirection(): this;
+
+    /**
+     * Iterating through a Vector3 instance will yield its components (x, y, z) in the corresponding order.
+     */
+    [Symbol.iterator](): Iterator<number>;
 }

three/src/math/Vector4.d.ts

@@ -220,4 +220,9 @@ export class Vector4 implements Vector {
      * Sets this vector's x, y, z and w from Math.random
      */
     random(): this;
+
+    /**
+     * Iterating through a Vector4 instance will yield its components (x, y, z, w) in the corresponding order.
+     */
+    [Symbol.iterator](): Iterator<number>;
 }

three/src/renderers/WebGLRenderer.d.ts

@@ -14,7 +14,7 @@ import { WebGLRenderTarget } from './WebGLRenderTarget';
 import { WebGLMultipleRenderTargets } from './WebGLMultipleRenderTargets';
 import { Object3D } from './../core/Object3D';
 import { Material } from './../materials/Material';
-import { ToneMapping, ShadowMapType, CullFace, TextureEncoding, ColorSpace } from '../constants';
+import { ToneMapping, ShadowMapType, CullFace, TextureEncoding, ColorSpace, WebGLCoordinateSystem } from '../constants';
 import { WebXRManager } from '../renderers/webxr/WebXRManager';
 import { BufferGeometry } from './../core/BufferGeometry';
 import { OffscreenCanvas, Texture } from '../textures/Texture';
@@ -200,6 +200,8 @@ export class WebGLRenderer implements Renderer {
      */
     outputColorSpace: ColorSpace;
 
+    get coordinateSystem(): typeof WebGLCoordinateSystem;
+
     /**
      * @default true
      */

three/src/renderers/webxr/WebXRManager.d.ts

@@ -26,31 +26,48 @@ export class WebXRManager extends EventDispatcher {
 
     /**
      * @default true
+     * @deprecated
      */
     cameraAutoUpdate: boolean;
 
     getController(index: number): XRTargetRaySpace;
+
     getControllerGrip(index: number): XRGripSpace;
+
     getHand(index: number): XRHandSpace;
+
     setFramebufferScaleFactor(value: number): void;
+
     setReferenceSpaceType(value: XRReferenceSpaceType): void;
+
     getReferenceSpace(): XRReferenceSpace | null;
+
     setReferenceSpace(value: XRReferenceSpace): void;
+
     getBaseLayer(): XRWebGLLayer | XRProjectionLayer;
+
     getBinding(): XRWebGLBinding;
+
     getFrame(): XRFrame;
+
     getSession(): XRSession | null;
+
     setSession(value: XRSession | null): Promise<void>;
+
+    /**
+     * @deprecated
+     */
     getCamera(): WebXRArrayCamera;
-    updateCamera(camera: PerspectiveCamera): void;
+
+    setUserCamera(camera: PerspectiveCamera): void;
+
+    updateCameraXR(camera: PerspectiveCamera): void;
+
     setAnimationLoop(callback: XRFrameRequestCallback | null): void;
+
     getFoveation(): number | undefined;
-    setFoveation(value: number): void;
 
-    /**
-     * Returns the set of planes detected by WebXR's plane detection API.
-     */
-    getPlanes(): Set<XRPlane>;
+    setFoveation(value: number): void;
 
     dispose(): void;
 }

three/src/textures/DepthTexture.d.ts

@@ -6,6 +6,7 @@ import {
     DeepTexturePixelFormat,
     MagnificationTextureFilter,
     MinificationTextureFilter,
+    TextureComparisonFunction,
 } from '../constants';
 
 /**
@@ -95,4 +96,12 @@ export class DepthTexture extends Texture {
      * @defaultValue {@link THREE.UnsignedInt248Type} when {@link format | .format} === {@link THREE.DepthStencilFormat}
      */
     type: TextureDataType;
+
+    /**
+     * This is used to define the comparison function used when comparing texels in the depth texture to the value in
+     * the depth buffer. Default is `null` which means comparison is disabled.
+     *
+     * See {@link THREE.TextureComparisonFunction} for functions.
+     */
+    compareFunction: TextureComparisonFunction | null;
 }

three/src/textures/FramebufferTexture.d.ts

@@ -1,5 +1,5 @@
 import { Texture } from './Texture';
-import { MagnificationTextureFilter, MinificationTextureFilter, PixelFormat } from '../constants';
+import { MagnificationTextureFilter, MinificationTextureFilter } from '../constants';
 
 /**
  * This class can only be used in combination with {@link THREE.WebGLRenderer.copyFramebufferToTexture | WebGLRenderer.copyFramebufferToTexture()}.
@@ -32,9 +32,8 @@ export class FramebufferTexture extends Texture {
      * Create a new instance of {@link FramebufferTexture}
      * @param width The width of the texture.
      * @param height The height of the texture.
-     * @param format See {@link Texture.format | .format}. Default {@link THREE.RGBAFormat}.
      */
-    constructor(width: number, height: number, format: PixelFormat);
+    constructor(width: number, height: number);
 
     /**
      * Read-only flag to check if a given object is of type {@link FramebufferTexture}.

three/src/textures/Source.d.ts

@@ -17,6 +17,8 @@ export class Source {
      */
     readonly isSource: true;
 
+    readonly id: number;
+
     /**
      * The actual data of a texture.
      * @remarks The type of this property depends on the texture that uses this instance.

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

@@ -1,22 +0,0 @@
-import { Object3D } from '../../../src/Three';
-
-export interface ColladaExporterOptions {
-    author?: string;
-    textureDirectory?: string;
-    version?: string;
-}
-
-export interface ColladaExporterResult {
-    data: string;
-    textures: object[];
-}
-
-export class ColladaExporter {
-    constructor();
-
-    parse(
-        object: Object3D,
-        onDone: (res: ColladaExporterResult) => void,
-        options: ColladaExporterOptions,
-    ): ColladaExporterResult | null;
-}

three/examples/jsm/geometries/LightningStrike.d.ts

@@ -1,108 +0,0 @@
-import { BufferGeometry, Vector3 } from '../../../src/Three';
-
-export interface RandomGenerator {
-    random(): number;
-    getSeed(): number;
-    setSeed(seed: number): void;
-}
-
-export interface LightningSegment {
-    iteration: number;
-    pos0: Vector3;
-    pos1: Vector3;
-    linPos0: Vector3;
-    linPos1: Vector3;
-    up0: Vector3;
-    up1: Vector3;
-    radius0: number;
-    radius1: number;
-    fraction0: number;
-    fraction1: number;
-    positionVariationFactor: number;
-}
-
-export interface LightningSubray {
-    seed: number;
-    maxIterations: number;
-    recursion: number;
-    pos0: Vector3;
-    pos1: Vector3;
-    linPos0: Vector3;
-    linPos1: Vector3;
-    up0: Vector3;
-    up1: Vector3;
-    radius0: number;
-    radius1: number;
-    birthTime: number;
-    deathTime: number;
-    timeScale: number;
-    roughness: number;
-    straightness: number;
-    propagationTimeFactor: number;
-    vanishingTimeFactor: number;
-    endPropagationTime: number;
-    beginVanishingTime: number;
-}
-
-export interface RayParameters {
-    sourceOffset?: Vector3;
-    destOffset?: Vector3;
-
-    timeScale?: number;
-    roughness?: number;
-    straightness?: number;
-
-    up0?: Vector3;
-    up1?: Vector3;
-    radius0?: number;
-    radius1?: number;
-    radius0Factor?: number;
-    radius1Factor?: number;
-    minRadius?: number;
-
-    isEternal?: boolean;
-    birthTime?: number;
-    deathTime?: number;
-    propagationTimeFactor?: number;
-    vanishingTimeFactor?: number;
-    subrayPeriod?: number;
-    subrayDutyCycle?: number;
-
-    maxIterations?: number;
-    isStatic?: boolean;
-    ramification?: number;
-    maxSubrayRecursion?: number;
-    recursionProbability?: number;
-    generateUVs?: boolean;
-
-    randomGenerator?: RandomGenerator;
-    noiseSeed?: number;
-
-    onDecideSubrayCreation?: (segment: LightningSegment, lightningStrike: LightningStrike) => void;
-    onSubrayCreation?: (
-        segment: LightningSegment,
-        parentSubray: LightningSubray,
-        childSubray: LightningSubray,
-        lightningStrike: LightningStrike,
-    ) => void;
-}
-
-export class LightningStrike extends BufferGeometry {
-    constructor(rayParameters?: RayParameters);
-    copyParameters(dest?: RayParameters, source?: RayParameters): RayParameters;
-
-    // Ray states
-    static readonly RAY_INITIALIZED: number;
-    static readonly RAY_UNBORN: number;
-    static readonly RAY_PROPAGATING: number;
-    static readonly RAY_STEADY: number;
-    static readonly RAY_VANISHING: number;
-    static readonly RAY_EXTINGUISHED: number;
-
-    state: number;
-
-    update(time: number): void;
-
-    copy(source: LightningStrike): this;
-    clone(): this;
-}

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

@@ -1,16 +0,0 @@
-import { BufferGeometry, Loader, LoadingManager } from '../../../src/Three';
-
-export class PRWMLoader extends Loader {
-    constructor(manager?: LoadingManager);
-
-    load(
-        url: string,
-        onLoad: (geometry: BufferGeometry) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BufferGeometry>;
-    parse(data: ArrayBuffer): BufferGeometry;
-
-    static isBigEndianPlatform(): boolean;
-}

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

@@ -1,32 +0,0 @@
-import { Material, Object3D, Vector3 } from '../../../src/Three';
-
-import { LightningStrike, RayParameters } from '../geometries/LightningStrike';
-
-export interface StormParams {
-    size?: number;
-    minHeight?: number;
-    maxHeight?: number;
-    maxSlope?: number;
-
-    maxLightnings?: number;
-
-    lightningMinPeriod?: number;
-    lightningMaxPeriod?: number;
-    lightningMinDuration?: number;
-    lightningMaxDuration?: number;
-
-    lightningParameters?: RayParameters;
-    lightningMaterial?: Material;
-
-    isEternal?: boolean;
-
-    onRayPosition?: (source: Vector3, dest: Vector3) => void;
-    onLightningDown?: (lightning: LightningStrike) => void;
-}
-
-export class LightningStorm extends Object3D {
-    constructor(stormParams?: StormParams);
-    update(time: number): void;
-    copy(source: LightningStorm, recursive?: boolean): this;
-    clone(): this;
-}

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

@@ -1,29 +0,0 @@
-import { WebGLRenderTarget, ShaderMaterial } from '../../../src/Three';
-
-import { Pass, FullScreenQuad } from './Pass';
-
-export class AdaptiveToneMappingPass extends Pass {
-    constructor(adaptive?: boolean, resolution?: number);
-    adaptive: boolean;
-    resolution: number;
-    needsInit: number;
-    luminanceRT: WebGLRenderTarget;
-    previousLuminanceRT: WebGLRenderTarget;
-    currentLuminanceRT: WebGLRenderTarget;
-    copyUniforms: object;
-    materialCopy: ShaderMaterial;
-    materialLuminance: ShaderMaterial;
-    adaptLuminanceShader: object;
-    materialAdaptiveLum: ShaderMaterial;
-    materialToneMap: ShaderMaterial;
-    fsQuad: FullScreenQuad;
-
-    reset(): void;
-    setAdaptive(adaptive: boolean): void;
-    setAdaptionRate(rate: number): void;
-    setMinLuminance(minLum: number): void;
-    setMaxLuminance(maxLum: number): void;
-    setAverageLuminance(avgLum: number): void;
-    setMiddleGrey(middleGrey: number): void;
-    dispose(): void;
-}

three/examples/jsm/shaders/ToneMapShader.d.ts

@@ -1,14 +0,0 @@
-import { IUniform } from '../../../src/Three';
-
-export const ToneMapShader: {
-    uniforms: {
-        tDiffuse: IUniform;
-        averageLuminance: IUniform;
-        luminanceMap: IUniform;
-        maxLuminance: IUniform;
-        minLuminance: IUniform;
-        middleGrey: IUniform;
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};