@types/three 0.138.0 → 0.141.0

three/src/core/InstancedBufferGeometry.d.ts

@@ -13,12 +13,8 @@ export class InstancedBufferGeometry extends BufferGeometry {
 
     isInstancedBufferGeometry: boolean;
 
-    groups: Array<{ start: number; count: number; instances: number }>;
-
     /**
      * @default Infinity
      */
     instanceCount: number;
-
-    addGroup(start: number, count: number, instances: number): void;
 }

three/src/core/Uniform.d.ts

@@ -13,7 +13,6 @@ export class Uniform {
      * @deprecated Use {@link Object3D#onBeforeRender object.onBeforeRender()} instead.
      */
     dynamic: boolean;
-    onUpdateCallback: () => void;
 
     /**
      * @deprecated Use {@link Object3D#onBeforeRender object.onBeforeRender()} instead.

three/src/extras/DataUtils.d.ts

@@ -1,3 +1,4 @@
 export namespace DataUtils {
     function toHalfFloat(val: number): number;
+    function fromHalfFloat(val: number): number;
 }

three/src/extras/Earcut.d.ts

@@ -0,0 +1,4 @@
+import { Triangle } from '../Three';
+export namespace Earcut {
+    function triangulate(data: number[], holeIndices: number[], dim: number): Triangle[];
+}

three/src/geometries/CapsuleGeometry.d.ts

@@ -0,0 +1,27 @@
+import { BufferGeometry } from '../core/BufferGeometry';
+
+export class CapsuleGeometry extends BufferGeometry {
+    /**
+     * @param [radius=1] — Radius of the capsule.
+     * @param [length=1] — Length of the middle section.
+     * @param [capSegments=4] — Number of curve segments used to build the caps.
+     * @param [radialSegments=8] — Number of segmented faces around the circumference of the capsule.
+     */
+    constructor(radius?: number, length?: number, capSegments?: number, radialSegments?: number);
+
+    /**
+     * @default 'CapsuleGeometry'
+     */
+    type: string;
+
+    parameters: {
+        radius: number;
+        length: number;
+        capSegments: number;
+        radialSegments: number;
+    };
+
+    static fromJSON(data: any): CapsuleGeometry;
+}
+
+export { CapsuleGeometry as CapsuleBufferGeometry };

three/src/geometries/Geometries.d.ts

@@ -1,4 +1,5 @@
 export * from './BoxGeometry';
+export * from './CapsuleGeometry';
 export * from './CircleGeometry';
 export * from './ConeGeometry';
 export * from './CylinderGeometry';

three/src/materials/Material.d.ts

@@ -13,9 +13,6 @@ import {
     StencilOp,
     PixelFormat,
 } from '../constants';
-import { ColorRepresentation } from '../utils';
-import { Color } from '../math/Color';
-import { Texture } from '../textures/Texture';
 
 export interface MaterialParameters {
     alphaTest?: number | undefined;
@@ -35,7 +32,6 @@ export interface MaterialParameters {
     depthFunc?: DepthModes | undefined;
     depthTest?: boolean | undefined;
     depthWrite?: boolean | undefined;
-    fog?: boolean | undefined;
     name?: string | undefined;
     opacity?: number | undefined;
     polygonOffset?: boolean | undefined;
@@ -80,11 +76,6 @@ export class Material extends EventDispatcher {
      */
     alphaToCoverage: boolean;
 
-    /**
-     * @default false
-     */
-    alphaWrite: boolean;
-
     /**
      * Blending destination. It's one of the blending mode constants defined in Three.js. Default is {@link OneMinusSrcAlphaFactor}.
      * @default THREE.OneMinusSrcAlphaFactor
@@ -180,12 +171,6 @@ export class Material extends EventDispatcher {
      */
     depthWrite: boolean;
 
-    /**
-     * Whether the material is affected by fog. Default is true.
-     * @default fog
-     */
-    fog: boolean;
-
     /**
      * Unique number of this material instance.
      */

three/src/materials/MeshBasicMaterial.d.ts

@@ -16,6 +16,7 @@ export interface MeshBasicMaterialParameters extends MaterialParameters {
     aoMapIntensity?: number | undefined;
     specularMap?: Texture | null | undefined;
     alphaMap?: Texture | null | undefined;
+    fog?: boolean | undefined;
     envMap?: Texture | null | undefined;
     combine?: Combine | undefined;
     reflectivity?: number | undefined;
@@ -114,5 +115,11 @@ export class MeshBasicMaterial extends Material {
      */
     wireframeLinejoin: string;
 
+    /**
+     * Whether the material is affected by fog. Default is true.
+     * @default fog
+     */
+    fog: boolean;
+
     setValues(parameters: MeshBasicMaterialParameters): void;
 }

three/src/materials/MeshLambertMaterial.d.ts

@@ -24,6 +24,7 @@ export interface MeshLambertMaterialParameters extends MaterialParameters {
     wireframeLinewidth?: number | undefined;
     wireframeLinecap?: string | undefined;
     wireframeLinejoin?: string | undefined;
+    fog?: boolean | undefined;
 }
 
 export class MeshLambertMaterial extends Material {
@@ -129,5 +130,11 @@ export class MeshLambertMaterial extends Material {
      */
     wireframeLinejoin: string;
 
+    /**
+     * Whether the material is affected by fog. Default is true.
+     * @default fog
+     */
+    fog: boolean;
+
     setValues(parameters: MeshLambertMaterialParameters): void;
 }

three/src/materials/MeshMatcapMaterial.d.ts

@@ -18,7 +18,7 @@ export interface MeshMatcapMaterialParameters extends MaterialParameters {
     displacementScale?: number | undefined;
     displacementBias?: number | undefined;
     alphaMap?: Texture | null | undefined;
-
+    fog?: boolean | undefined;
     flatShading?: boolean | undefined;
 }
 
@@ -101,5 +101,11 @@ export class MeshMatcapMaterial extends Material {
      */
     flatShading: boolean;
 
+    /**
+     * Whether the material is affected by fog. Default is true.
+     * @default fog
+     */
+    fog: boolean;
+
     setValues(parameters: MeshMatcapMaterialParameters): void;
 }

three/src/materials/MeshPhongMaterial.d.ts

@@ -37,7 +37,7 @@ export interface MeshPhongMaterialParameters extends MaterialParameters {
     wireframeLinewidth?: number | undefined;
     wireframeLinecap?: string | undefined;
     wireframeLinejoin?: string | undefined;
-
+    fog?: boolean | undefined;
     flatShading?: boolean | undefined;
 }
 
@@ -205,5 +205,11 @@ export class MeshPhongMaterial extends Material {
      */
     metal: boolean;
 
+    /**
+     * Whether the material is affected by fog. Default is true.
+     * @default fog
+     */
+    fog: boolean;
+
     setValues(parameters: MeshPhongMaterialParameters): void;
 }

three/src/materials/MeshPhysicalMaterial.d.ts

@@ -156,4 +156,24 @@ export class MeshPhysicalMaterial extends MeshStandardMaterial {
      * @default null
      */
     specularColorMap: Texture | null;
+
+    /**
+     * @default null
+     */
+    iridescenceMap: Texture | null;
+
+    /**
+     * @default 1.3
+     */
+    iridescenceIOR: number;
+
+    /**
+     * @default [100, 400]
+     */
+    iridescenceThicknessRange: number[];
+
+    /**
+     * @default null
+     */
+    iridescenceThicknessMap: Texture | null;
 }

three/src/materials/MeshStandardMaterial.d.ts

@@ -30,10 +30,9 @@ export interface MeshStandardMaterialParameters extends MaterialParameters {
     alphaMap?: Texture | null | undefined;
     envMap?: Texture | null | undefined;
     envMapIntensity?: number | undefined;
-    refractionRatio?: number | undefined;
     wireframe?: boolean | undefined;
     wireframeLinewidth?: number | undefined;
-
+    fog?: boolean | undefined;
     flatShading?: boolean | undefined;
 }
 
@@ -170,11 +169,6 @@ export class MeshStandardMaterial extends Material {
      */
     envMapIntensity: number;
 
-    /**
-     * @default 0.98
-     */
-    refractionRatio: number;
-
     /**
      * @default false
      */
@@ -201,6 +195,12 @@ export class MeshStandardMaterial extends Material {
      */
     flatShading: boolean;
 
+    /**
+     * Whether the material is affected by fog. Default is true.
+     * @default fog
+     */
+    fog: boolean;
+
     isMeshStandardMaterial: boolean;
 
     setValues(parameters: MeshStandardMaterialParameters): void;

three/src/materials/MeshToonMaterial.d.ts

@@ -31,6 +31,7 @@ export interface MeshToonMaterialParameters extends MaterialParameters {
     wireframeLinewidth?: number | undefined;
     wireframeLinecap?: string | undefined;
     wireframeLinejoin?: string | undefined;
+    fog?: boolean | undefined;
 }
 
 export class MeshToonMaterial extends Material {
@@ -161,5 +162,11 @@ export class MeshToonMaterial extends Material {
      */
     wireframeLinejoin: string;
 
+    /**
+     * Whether the material is affected by fog. Default is true.
+     * @default fog
+     */
+    fog: boolean;
+
     setValues(parameters: MeshToonMaterialParameters): void;
 }

three/src/materials/PointsMaterial.d.ts

@@ -9,6 +9,7 @@ export interface PointsMaterialParameters extends MaterialParameters {
     alphaMap?: Texture | null | undefined;
     size?: number | undefined;
     sizeAttenuation?: boolean | undefined;
+    fog?: boolean | undefined;
 }
 
 export class PointsMaterial extends Material {
@@ -44,5 +45,11 @@ export class PointsMaterial extends Material {
      */
     sizeAttenuation: boolean;
 
+    /**
+     * Whether the material is affected by fog. Default is true.
+     * @default fog
+     */
+    fog: boolean;
+
     setValues(parameters: PointsMaterialParameters): void;
 }

three/src/materials/ShadowMaterial.d.ts

@@ -4,6 +4,7 @@ import { MaterialParameters, Material } from './Material';
 
 export interface ShadowMaterialParameters extends MaterialParameters {
     color?: ColorRepresentation | undefined;
+    fog?: boolean | undefined;
 }
 
 export class ShadowMaterial extends Material {
@@ -23,4 +24,10 @@ export class ShadowMaterial extends Material {
      * @default true
      */
     transparent: boolean;
+
+    /**
+     * Whether the material is affected by fog. Default is true.
+     * @default fog
+     */
+    fog: boolean;
 }

three/src/materials/SpriteMaterial.d.ts

@@ -9,6 +9,7 @@ export interface SpriteMaterialParameters extends MaterialParameters {
     alphaMap?: Texture | null | undefined;
     rotation?: number | undefined;
     sizeAttenuation?: boolean | undefined;
+    fog?: boolean | undefined;
 }
 
 export class SpriteMaterial extends Material {
@@ -48,6 +49,12 @@ export class SpriteMaterial extends Material {
      */
     transparent: boolean;
 
+    /**
+     * Whether the material is affected by fog. Default is true.
+     * @default fog
+     */
+    fog: boolean;
+
     readonly isSpriteMaterial: true;
 
     setValues(parameters: SpriteMaterialParameters): void;

three/src/math/Color.d.ts

@@ -1,13 +1,21 @@
+import { ColorSpace } from '../constants';
 import { ColorRepresentation } from '../utils';
+
 import { BufferAttribute } from './../core/BufferAttribute';
 
+export { SRGBToLinear } from './ColorManagement';
+
 export interface HSL {
     h: number;
     s: number;
     l: number;
 }
 
-export function SRGBToLinear(c: number): number;
+export interface RGB {
+    r: number;
+    g: number;
+    b: number;
+}
 
 /**
  * Represents a color. See also {@link ColorUtils}.
@@ -43,7 +51,7 @@ export class Color {
 
     set(color: ColorRepresentation): Color;
     setScalar(scalar: number): Color;
-    setHex(hex: number): Color;
+    setHex(hex: number, colorSpace?: ColorSpace): Color;
 
     /**
      * Sets this color from RGB values.
@@ -51,7 +59,7 @@ export class Color {
      * @param g Green channel value between 0 and 1.
      * @param b Blue channel value between 0 and 1.
      */
-    setRGB(r: number, g: number, b: number): Color;
+    setRGB(r: number, g: number, b: number, colorSpace?: ColorSpace): Color;
 
     /**
      * Sets this color from HSL values.
@@ -61,20 +69,20 @@ export class Color {
      * @param s Saturation value channel between 0 and 1.
      * @param l Value channel value between 0 and 1.
      */
-    setHSL(h: number, s: number, l: number): Color;
+    setHSL(h: number, s: number, l: number, colorSpace?: ColorSpace): Color;
 
     /**
      * Sets this color from a CSS context style string.
      * @param contextStyle Color in CSS context style format.
      */
-    setStyle(style: string): Color;
+    setStyle(style: string, colorSpace?: ColorSpace): Color;
 
     /**
      * Sets this color from a color name.
      * Faster than {@link Color#setStyle .setStyle()} method if you don't need the other CSS-style formats.
      * @param style Color name in X11 format.
      */
-    setColorName(style: string): Color;
+    setColorName(style: string, colorSpace?: ColorSpace): Color;
 
     /**
      * Clones this color.
@@ -112,20 +120,22 @@ export class Color {
     /**
      * Returns the hexadecimal value of this color.
      */
-    getHex(): number;
+    getHex(colorSpace?: ColorSpace): number;
 
     /**
      * Returns the string formated hexadecimal value of this color.
      */
-    getHexString(): string;
+    getHexString(colorSpace?: ColorSpace): string;
 
-    getHSL(target: HSL): HSL;
+    getHSL(target: HSL, colorSpace?: ColorSpace): HSL;
+
+    getRGB(target: RGB, colorSpace?: ColorSpace): RGB;
 
     /**
      * Returns the value of this color in CSS context style.
      * Example: rgb(r, g, b)
      */
-    getStyle(): string;
+    getStyle(colorSpace?: ColorSpace): string;
 
     offsetHSL(h: number, s: number, l: number): this;
 
@@ -165,6 +175,8 @@ export class Color {
 
     fromBufferAttribute(attribute: BufferAttribute, index: number): this;
 
+    [Symbol.iterator](): Generator<number, void>;
+
     /**
      * List of X11 color names.
      */

three/src/math/ColorManagement.d.ts

@@ -0,0 +1,18 @@
+import { LinearSRGBColorSpace, SRGBColorSpace } from '../constants';
+import { Color } from './Color';
+
+export function SRGBToLinear(c: number): number;
+
+export function LinearToSRGB(c: number): number;
+
+export namespace ColorManagement {
+    function convert(
+        color: Color,
+        sourceColorSpace: SRGBColorSpace | LinearSRGBColorSpace,
+        targetColorSpace: SRGBColorSpace | LinearSRGBColorSpace,
+    ): Color;
+
+    function fromWorkingColorSpace(color: Color, targetColorSpace: SRGBColorSpace | LinearSRGBColorSpace): Color;
+
+    function toWorkingColorSpace(color: Color, sourceColorSpace: SRGBColorSpace | LinearSRGBColorSpace): Color;
+}

three/src/math/Euler.d.ts

@@ -42,4 +42,6 @@ export class Euler {
 
     static RotationOrders: string[];
     static DefaultOrder: string;
+
+    [Symbol.iterator](): Generator<string | number, void>;
 }

three/src/math/Plane.d.ts

@@ -31,7 +31,6 @@ export class Plane {
     distanceToPoint(point: Vector3): number;
     distanceToSphere(sphere: Sphere): number;
     projectPoint(point: Vector3, target: Vector3): Vector3;
-    orthoPoint(point: Vector3, target: Vector3): Vector3;
     intersectLine(line: Line3, target: Vector3): Vector3 | null;
     intersectsLine(line: Line3): boolean;
     intersectsBox(box: Box3): boolean;

three/src/math/Quaternion.d.ts

@@ -174,4 +174,6 @@ export class Quaternion {
     inverse(): Quaternion;
 
     random(): Quaternion;
+
+    [Symbol.iterator](): Generator<number, void>;
 }

three/src/renderers/WebGLRenderTarget.d.ts

@@ -17,12 +17,17 @@ export interface WebGLRenderTargetOptions {
     generateMipmaps?: boolean | undefined; // true;
     depthTexture?: DepthTexture | undefined;
     encoding?: TextureEncoding | undefined;
+
+    /**
+     * Defines the count of MSAA samples. Can only be used with WebGL 2. Default is **0**.
+     * @default 0
+     */
+    samples?: number;
 }
 
 export class WebGLRenderTarget extends EventDispatcher {
     constructor(width: number, height: number, options?: WebGLRenderTargetOptions);
 
-    uuid: string;
     width: number;
     height: number;
     depth: number;

three/src/renderers/WebGLRenderer.d.ts

@@ -19,7 +19,6 @@ import { WebXRManager } from '../renderers/webxr/WebXRManager';
 import { BufferGeometry } from './../core/BufferGeometry';
 import { Texture } from '../textures/Texture';
 import { Data3DTexture } from '../textures/Data3DTexture';
-import { XRAnimationLoopCallback } from './webxr/WebXR';
 import { Vector3 } from '../math/Vector3';
 import { Box3 } from '../math/Box3';
 import { DataArrayTexture } from '../textures/DataArrayTexture';
@@ -218,7 +217,7 @@ export class WebGLRenderer implements Renderer {
     /**
      * Return the WebGL context.
      */
-    getContext(): WebGLRenderingContext;
+    getContext(): WebGLRenderingContext | WebGL2RenderingContext;
     getContextAttributes(): any;
     forceContextLoss(): void;
     forceContextRestore(): void;
@@ -336,7 +335,7 @@ export class WebGLRenderer implements Renderer {
      * A build in function that can be used instead of requestAnimationFrame. For WebXR projects this function must be used.
      * @param callback The function will be called every available frame. If `null` is passed it will stop any already ongoing animation.
      */
-    setAnimationLoop(callback: XRAnimationLoopCallback | null): void;
+    setAnimationLoop(callback: XRFrameRequestCallback | null): void;
 
     /**
      * @deprecated Use {@link WebGLRenderer#setAnimationLoop .setAnimationLoop()} instead.

three/src/renderers/webgl/WebGLUtils.d.ts

@@ -1,7 +1,7 @@
-import { CompressedPixelFormat, TextureEncoding } from '../../constants';
+import { CompressedPixelFormat, PixelFormat, TextureEncoding, TextureDataType } from '../../constants';
 
 export class WebGLUtils {
     constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, extensions: any, capabilities: any);
 
-    convert(p: CompressedPixelFormat, encoding?: TextureEncoding | null): void;
+    convert(p: PixelFormat | CompressedPixelFormat | TextureDataType, encoding?: TextureEncoding | null): number | null;
 }

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

@@ -1,14 +1,40 @@
 import { Group } from '../../objects/Group';
-import { XREventType, XRFrame, XRInputSource, XRReferenceSpace } from './WebXR';
+import { Vector3 } from '../../math/Vector3';
 
-export type XRControllerEventType = XREventType | 'disconnected' | 'connected';
+export type XRControllerEventType = XRSessionEventType | XRInputSourceEventType | 'disconnected' | 'connected';
+
+export type XRHandJoints = Record<XRHandJoint, number>;
+
+export interface XRHandInputState {
+    pinching: boolean;
+}
+
+export class XRHandSpace extends Group {
+    readonly joints: Partial<XRHandJoints>;
+    readonly inputState: XRHandInputState;
+}
+
+export class XRTargetRaySpace extends Group {
+    hasLinearVelocity: boolean;
+    readonly linearVelocity: Vector3;
+    hasAngularVelocity: boolean;
+    readonly angularVelocity: Vector3;
+}
+
+export class XRGripSpace extends Group {
+    hasLinearVelocity: boolean;
+    readonly linearVelocity: Vector3;
+    hasAngularVelocity: boolean;
+    readonly angularVelocity: Vector3;
+}
 
 export class WebXRController {
     constructor();
 
-    getTargetRaySpace(): Group;
-    getGripSpace(): Group;
-    dispatchEvent(event: { type: XRControllerEventType; data?: XRInputSource | undefined }): this;
+    getHandSpace(): XRHandSpace;
+    getTargetRaySpace(): XRTargetRaySpace;
+    getGripSpace(): XRGripSpace;
+    dispatchEvent(event: { type: XRControllerEventType; data?: XRInputSource }): this;
     disconnect(inputSource: XRInputSource): this;
     update(inputSource: XRInputSource, frame: XRFrame, referenceSpace: XRReferenceSpace): this;
 }

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

@@ -1,7 +1,13 @@
-import { Group } from '../../objects/Group';
-import { Camera } from '../../cameras/Camera';
+/// <reference types="webxr" />
+
+import { Vector4 } from '../../math/Vector4';
+import { ArrayCamera } from '../../cameras/ArrayCamera';
+import { PerspectiveCamera } from '../../cameras/PerspectiveCamera';
 import { EventDispatcher } from '../../core/EventDispatcher';
-import { XRFrameRequestCallback, XRReferenceSpace, XRReferenceSpaceType, XRSession } from './WebXR';
+import { XRTargetRaySpace, XRGripSpace, XRHandSpace } from './WebXRController';
+
+export type WebXRCamera = PerspectiveCamera & { viewport: Vector4 };
+export type WebXRArrayCamera = Omit<ArrayCamera, 'cameras'> & { cameras: [WebXRCamera, WebXRCamera] };
 
 export class WebXRManager extends EventDispatcher {
     constructor(renderer: any, gl: WebGLRenderingContext);
@@ -16,15 +22,25 @@ export class WebXRManager extends EventDispatcher {
      */
     isPresenting: boolean;
 
-    getController(index: number): Group;
-    getControllerGrip(index: number): Group;
-    getHand(index: number): Group;
+    /**
+     * @default true
+     */
+    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): Promise<void>;
-    getCamera(camera: Camera): Camera;
+    getCamera(): WebXRArrayCamera;
+    updateCamera(camera: PerspectiveCamera): void;
     setAnimationLoop(callback: XRFrameRequestCallback | null): void;
     getFoveation(): number | undefined;
     setFoveation(foveation: number): void;

three/src/scenes/Scene.d.ts

@@ -45,20 +45,5 @@ export class Scene extends Object3D {
 
     readonly isScene: true;
 
-    /**
-     * Calls before rendering scene
-     */
-    onBeforeRender: (
-        renderer: WebGLRenderer,
-        scene: Scene,
-        camera: Camera,
-        renderTarget: any, // any required for Object3D.onBeforeRender compatibility
-    ) => void;
-
-    /**
-     * Calls after rendering scene
-     */
-    onAfterRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera) => void;
-
     toJSON(meta?: any): any;
 }