@types/three 0.140.0 → 0.143.0

three/README.md

@@ -8,8 +8,8 @@ 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: Tue, 03 May 2022 17:01:38 GMT
- * Dependencies: none
+ * Last updated: Thu, 28 Jul 2022 16:32:18 GMT
+ * Dependencies: [@types/webxr](https://npmjs.com/package/@types/webxr)
  * Global values: `THREE`
 
 # Credits

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

@@ -4,7 +4,7 @@ export class FirstPersonControls {
     constructor(object: Camera, domElement?: HTMLElement);
 
     object: Camera;
-    domElement: HTMLElement | HTMLDocument;
+    domElement: HTMLElement | Document;
 
     enabled: boolean;
     movementSpeed: number;

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

@@ -4,7 +4,7 @@ export class FlyControls extends EventDispatcher {
     constructor(object: Camera, domElement?: HTMLElement);
 
     object: Camera;
-    domElement: HTMLElement | HTMLDocument;
+    domElement: HTMLElement | Document;
 
     movementSpeed: number;
     rollSpeed: number;

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

@@ -4,7 +4,7 @@ export class OrbitControls {
     constructor(object: Camera, domElement?: HTMLElement);
 
     object: Camera;
-    domElement: HTMLElement | HTMLDocument;
+    domElement: HTMLElement | Document;
 
     // API
     enabled: boolean;
@@ -43,8 +43,8 @@ export class OrbitControls {
     autoRotateSpeed: number;
 
     keys: { LEFT: string; UP: string; RIGHT: string; BOTTOM: string };
-    mouseButtons: { LEFT: MOUSE; MIDDLE: MOUSE; RIGHT: MOUSE };
-    touches: { ONE: TOUCH; TWO: TOUCH };
+    mouseButtons: Partial<{ LEFT: MOUSE; MIDDLE: MOUSE; RIGHT: MOUSE }>;
+    touches: Partial<{ ONE: TOUCH; TWO: TOUCH }>;
 
     target0: Vector3;
     position0: Vector3;

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

@@ -1,22 +1,20 @@
 import { Vector3, Vector4 } from '../../../src/Three';
 
-export namespace NURBSUtils {
-    function findSpan(p: number, u: number, U: number[]): number;
-    function calcBasisFunctions(span: number, u: number, p: number, U: number[]): number[];
-    function calcBSplinePoint(p: number, U: number[], P: Vector4[], u: number): Vector4;
-    function calcBasisFunctionDerivatives(span: number, u: number, p: number, n: number, U: number[]): number[][];
-    function calcBSplineDerivatives(p: number, U: number[], P: Vector4[], u: number, nd: number): Vector4[];
-    function calcKoverI(k: number, i: number): number;
-    function calcRationalCurveDerivatives(Pders: Vector4[]): Vector3[];
-    function calcNURBSDerivatives(p: number, U: number[], P: Vector4[], u: number, nd: number): Vector3[];
-    function calcSurfacePoint(
-        p: number,
-        q: number,
-        U: number[],
-        V: number[],
-        P: Vector4[],
-        u: number,
-        v: number,
-        target: Vector3,
-    ): Vector3;
-}
+export function findSpan(p: number, u: number, U: number[]): number;
+export function calcBasisFunctions(span: number, u: number, p: number, U: number[]): number[];
+export function calcBSplinePoint(p: number, U: number[], P: Vector4[], u: number): Vector4;
+export function calcBasisFunctionDerivatives(span: number, u: number, p: number, n: number, U: number[]): number[][];
+export function calcBSplineDerivatives(p: number, U: number[], P: Vector4[], u: number, nd: number): Vector4[];
+export function calcKoverI(k: number, i: number): number;
+export function calcRationalCurveDerivatives(Pders: Vector4[]): Vector3[];
+export function calcNURBSDerivatives(p: number, U: number[], P: Vector4[], u: number, nd: number): Vector3[];
+export function calcSurfacePoint(
+    p: number,
+    q: number,
+    U: number[],
+    V: number[],
+    P: Vector4[],
+    u: number,
+    v: number,
+    target: Vector3,
+): Vector3;

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

@@ -91,7 +91,7 @@ export class GLTFExporter {
 export class GLTFWriter {
     constructor();
 
-    setPlugins(plugins: GLTFExporterPlugin[]);
+    setPlugins(plugins: GLTFExporterPlugin[]): void;
 
     /**
      * Parse scenes and generate GLTF output

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

@@ -0,0 +1,5 @@
+import { Data3DTexture, DataTexture, WebGLRenderer, WebGLRenderTarget } from '../../../src/Three';
+
+export class KTX2Exporter {
+    parse(arg1: Data3DTexture | DataTexture | WebGLRenderer, arg2?: WebGLRenderTarget): Uint8Array;
+}

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

@@ -1,4 +1,4 @@
-import { Vector3 } from '../../../src/Three';
+import { BufferGeometry, Vector3 } from '../../../src/Three';
 
 export interface RandomGenerator {
     random(): number;
@@ -87,7 +87,7 @@ export interface RayParameters {
     ) => void;
 }
 
-export class LightningStrike {
+export class LightningStrike extends BufferGeometry {
     constructor(rayParameters?: RayParameters);
     copyParameters(dest?: RayParameters, source?: RayParameters): RayParameters;
 
@@ -103,6 +103,6 @@ export class LightningStrike {
 
     update(time: number): void;
 
-    copy(source: LightningStrike): LightningStrike;
+    copy(source: LightningStrike): this;
     clone(): this;
 }

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

@@ -65,7 +65,7 @@ export class GLTFLoader extends Loader {
         onError?: (event: ErrorEvent) => void,
     ): void;
 
-    parseAsync(data: ArrayBuffer | string, path: string): Promise<void>;
+    parseAsync(data: ArrayBuffer | string, path: string): Promise<GLTF>;
 }
 
 export type GLTFReferenceType = 'materials' | 'nodes' | 'textures' | 'meshes';

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

@@ -1,8 +1,8 @@
-import { LoadingManager } from '../../../src/Three';
+import { Loader, LoadingManager } from '../../../src/Three';
 
 import { Volume } from '../misc/Volume';
 
-export class NRRDLoader {
+export class NRRDLoader extends Loader {
     constructor(manager?: LoadingManager);
     manager: LoadingManager;
     path: string;

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

@@ -9,5 +9,5 @@ export class MorphAnimMesh extends Mesh {
     setDirectionBackward(): void;
     playAnimation(label: string, fps: number): void;
     updateAnimation(delta: number): void;
-    copy(source: MorphAnimMesh): this;
+    copy(source: MorphAnimMesh, recursive?: boolean): this;
 }

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

@@ -0,0 +1,13 @@
+import { Mesh, IcosahedronGeometry, ShaderMaterial, Texture } from '../../../src/Three';
+
+export class GroundProjectedEnv extends Mesh<IcosahedronGeometry, ShaderMaterial> {
+    constructor(texture: Texture, options?: { height?: number; radius?: number });
+
+    set radius(radius: number);
+
+    get radius(): number;
+
+    set height(height: number);
+
+    get height(): number;
+}

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

@@ -1,4 +1,4 @@
-import { Material, Vector3 } from '../../../src/Three';
+import { Material, Object3D, Vector3 } from '../../../src/Three';
 
 import { LightningStrike, RayParameters } from '../geometries/LightningStrike';
 
@@ -24,9 +24,9 @@ export interface StormParams {
     onLightningDown?: (lightning: LightningStrike) => void;
 }
 
-export class LightningStorm {
+export class LightningStorm extends Object3D {
     constructor(stormParams?: StormParams);
     update(time: number): void;
-    copy(source: LightningStorm): LightningStorm;
+    copy(source: LightningStorm, recursive?: boolean): this;
     clone(): this;
 }

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

@@ -60,7 +60,7 @@ export class SAOPass extends Pass {
     fsQuad: object;
     params: SAOPassParams;
 
-    static OUTPUT: OUTPUT;
+    static OUTPUT: typeof OUTPUT;
 
     renderPass(
         renderer: WebGLRenderer,

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

@@ -0,0 +1,10 @@
+import { IUniform, Texture } from '../../../src/Three';
+
+export const ACESFilmicToneMappingShader: {
+    uniforms: {
+        tDiffuse: IUniform<Texture>;
+        exposure: IUniform<number>;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

three/examples/jsm/textures/FlakesTexture.d.ts

@@ -0,0 +1,3 @@
+export class FlakesTexture extends HTMLCanvasElement {
+    constructor(width?: number, height?: number);
+}

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

@@ -1,11 +1,9 @@
 import { PerspectiveCamera, Vector3 } from '../../../src/Three.js';
 
-export namespace CameraUtils {
-    function frameCorners(
-        camera: PerspectiveCamera,
-        bottomLeftCorner: Vector3,
-        bottomRightCorner: Vector3,
-        topLeftCorner: Vector3,
-        estimateViewFrustum?: boolean,
-    ): void;
-}
+export function frameCorners(
+    camera: PerspectiveCamera,
+    bottomLeftCorner: Vector3,
+    bottomRightCorner: Vector3,
+    topLeftCorner: Vector3,
+    estimateViewFrustum?: boolean,
+): void;

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

@@ -1,7 +1,5 @@
 import { Mesh } from '../../../src/Three';
 
-export namespace GeometryCompressionUtils {
-    function compressNormals(mesh: Mesh, encodeMethod: string): void;
-    function compressPositions(mesh: Mesh): void;
-    function compressUvs(mesh: Mesh): void;
-}
+export function compressNormals(mesh: Mesh, encodeMethod: string): void;
+export function compressPositions(mesh: Mesh): void;
+export function compressUvs(mesh: Mesh): void;

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

@@ -1,27 +1,25 @@
 import { Vector3 } from '../../../src/Three';
 
-export namespace GeometryUtils {
-    function hilbert2D(
-        center?: Vector3,
-        size?: number,
-        iterations?: number,
-        v0?: number,
-        v1?: number,
-        v2?: number,
-        v3?: number,
-    ): Vector3[];
-    function hilbert3D(
-        center?: Vector3,
-        size?: number,
-        iterations?: number,
-        v0?: number,
-        v1?: number,
-        v2?: number,
-        v3?: number,
-        v4?: number,
-        v5?: number,
-        v6?: number,
-        v7?: number,
-    ): Vector3[];
-    function gosper(size?: number): number[];
-}
+export function hilbert2D(
+    center?: Vector3,
+    size?: number,
+    iterations?: number,
+    v0?: number,
+    v1?: number,
+    v2?: number,
+    v3?: number,
+): Vector3[];
+export function hilbert3D(
+    center?: Vector3,
+    size?: number,
+    iterations?: number,
+    v0?: number,
+    v1?: number,
+    v2?: number,
+    v3?: number,
+    v4?: number,
+    v5?: number,
+    v6?: number,
+    v7?: number,
+): Vector3[];
+export function gosper(size?: number): number[];

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

@@ -1,34 +1,28 @@
 import { AnimationClip, Bone, Matrix4, Object3D, Skeleton, SkeletonHelper } from '../../../src/Three';
 
-export namespace SkeletonUtils {
-    export function retarget(target: Object3D | Skeleton, source: Object3D | Skeleton, options: {}): void;
+export function retarget(target: Object3D | Skeleton, source: Object3D | Skeleton, options: {}): void;
 
-    export function retargetClip(
-        target: Skeleton | Object3D,
-        source: Skeleton | Object3D,
-        clip: AnimationClip,
-        options: {},
-    ): AnimationClip;
+export function retargetClip(
+    target: Skeleton | Object3D,
+    source: Skeleton | Object3D,
+    clip: AnimationClip,
+    options: {},
+): AnimationClip;
 
-    export function getHelperFromSkeleton(skeleton: Skeleton): SkeletonHelper;
+export function getHelperFromSkeleton(skeleton: Skeleton): SkeletonHelper;
 
-    export function getSkeletonOffsets(
-        target: Object3D | Skeleton,
-        source: Object3D | Skeleton,
-        options: {},
-    ): Matrix4[];
+export function getSkeletonOffsets(target: Object3D | Skeleton, source: Object3D | Skeleton, options: {}): Matrix4[];
 
-    export function renameBones(skeleton: Skeleton, names: {}): any;
+export function renameBones(skeleton: Skeleton, names: {}): any;
 
-    export function getBones(skeleton: Skeleton | Bone[]): Bone[];
+export function getBones(skeleton: Skeleton | Bone[]): Bone[];
 
-    export function getBoneByName(name: string, skeleton: Skeleton): Bone;
+export function getBoneByName(name: string, skeleton: Skeleton): Bone;
 
-    export function getNearestBone(bone: Bone, names: {}): Bone;
+export function getNearestBone(bone: Bone, names: {}): Bone;
 
-    export function findBoneTrackData(name: string, tracks: any[]): {};
+export function findBoneTrackData(name: string, tracks: any[]): {};
 
-    export function getEqualsBonesNames(skeleton: Skeleton, targetSkeleton: Skeleton): string[];
+export function getEqualsBonesNames(skeleton: Skeleton, targetSkeleton: Skeleton): string[];
 
-    export function clone(source: Object3D): Object3D;
-}
+export function clone(source: Object3D): Object3D;

three/examples/jsm/webxr/ARButton.d.ts

@@ -1,5 +1,9 @@
 import { WebGLRenderer } from '../../../src/Three';
 
+export interface ARButtonSessionInit extends XRSessionInit {
+    domOverlay: { root: HTMLElement };
+}
+
 export namespace ARButton {
-    function createButton(renderer: WebGLRenderer, sessionInit?: any): HTMLElement;
+    function createButton(renderer: WebGLRenderer, sessionInit?: Partial<ARButtonSessionInit>): HTMLElement;
 }

three/examples/jsm/webxr/OculusHandModel.d.ts

@@ -1,8 +1,9 @@
-import { Object3D, Sphere, Box3, Mesh, Texture, Vector3 } from '../../../src/Three';
+import { Mesh, Object3D, Texture, Vector3 } from '../../../src/Three';
+import { XRHandMeshModel } from './XRHandMeshModel';
 
 export class OculusHandModel extends Object3D {
     controller: Object3D;
-    motionController: Object3D | null;
+    motionController: XRHandMeshModel | null;
     envMap: Texture | null;
 
     mesh: Mesh | null;

three/examples/jsm/webxr/OculusHandPointerModel.d.ts

@@ -1,3 +1,5 @@
+import 'webxr';
+
 import {
     BufferGeometry,
     Intersection,
@@ -10,10 +12,12 @@ import {
     Vector3,
 } from '../../../src/Three';
 
+import { XRHandMeshModel } from './XRHandMeshModel';
+
 export class OculusHandPointerModel extends Object3D {
     hand: Object3D;
     controller: Object3D;
-    motionController: Object3D | null;
+    motionController: XRHandMeshModel | null;
 
     envMap: Texture | null;
 
@@ -31,7 +35,7 @@ export class OculusHandPointerModel extends Object3D {
     raycaster: Raycaster;
 
     visible: boolean;
-    xrInputSource: unknown;
+    xrInputSource: XRInputSource;
 
     constructor(hand: Object3D, controller: Object3D);
 

three/examples/jsm/webxr/XRControllerModelFactory.d.ts

@@ -7,6 +7,8 @@ export class XRControllerModel extends Object3D {
 
     motionController: any;
 
+    envMap: Texture;
+
     setEnvironmentMap(envMap: Texture): XRControllerModel;
 }
 

three/examples/jsm/webxr/XREstimatedLight.d.ts

@@ -1,24 +1,24 @@
-import { DirectionalLight, Group, LightProbe, XRFrame, WebGLRenderer, Texture } from '../../../src/Three';
+import { DirectionalLight, Group, LightProbe, Texture, WebGLRenderer } from '../../../src/Three';
 
 export class SessionLightProbe {
     xrLight: XREstimatedLight;
     renderer: WebGLRenderer;
-    lightProbe: unknown;
-    xrWebGLBinding: unknown | null;
+    lightProbe: LightProbe;
+    xrWebGLBinding: XRWebGLBinding | null;
     estimationStartCallback: () => void;
     frameCallback: (this: SessionLightProbe, time: number, xrFrame: XRFrame) => void;
 
     constructor(
         xrLight: XREstimatedLight,
         renderer: WebGLRenderer,
-        lightProbe: unknown,
+        lightProbe: LightProbe,
         environmentEstimation: boolean,
         estimationStartCallback: () => void,
     );
 
     updateReflection: () => void;
 
-    onXRFrame: (time: number, xrFrame: XRFrame) => void;
+    onXRFrame: XRFrameRequestCallback;
 
     dispose: () => void;
 }

three/examples/jsm/webxr/XRHandModelFactory.d.ts

@@ -19,7 +19,7 @@ export class XRHandModelFactory {
 
     createHandModel(
         controller: Group,
-        profile?: 'spheres' | 'boxes' | 'oculus',
+        profile?: 'spheres' | 'boxes' | 'mesh',
         options?: XRHandPrimitiveModelOptions,
     ): XRHandModel;
 }

three/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for three 0.140
+// Type definitions for three 0.143
 // 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.140.0",
+    "version": "0.143.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -24,7 +24,9 @@
         "directory": "types/three"
     },
     "scripts": {},
-    "dependencies": {},
-    "typesPublisherContentHash": "0003f52bd6b42bfc5b77be02ad5eee29a50d1ddc25ce1b64506a2253f0420782",
-    "typeScriptVersion": "3.9"
+    "dependencies": {
+        "@types/webxr": "*"
+    },
+    "typesPublisherContentHash": "2bd0a51b5f45c12a91bfe51f4e168b8c1ee7815e8f870ba4861a9e839d92d8f2",
+    "typeScriptVersion": "4.0"
 }

three/src/Three.d.ts

@@ -16,7 +16,8 @@ export * from './animation/tracks/BooleanKeyframeTrack';
 export * from './animation/PropertyMixer';
 export * from './animation/PropertyBinding';
 export * from './animation/KeyframeTrack';
-export * from './animation/AnimationUtils';
+import * as AnimationUtils from './animation/AnimationUtils';
+export { AnimationUtils };
 export * from './animation/AnimationObjectGroup';
 export * from './animation/AnimationMixer';
 export * from './animation/AnimationClip';
@@ -42,6 +43,7 @@ export * from './cameras/Camera';
  * Core
  */
 export * from './core/Uniform';
+export * from './core/UniformsGroup';
 export * from './core/InstancedBufferGeometry';
 export * from './core/BufferGeometry';
 export * from './core/InterleavedBufferAttribute';
@@ -207,7 +209,7 @@ export * from './renderers/webgl/WebGLShadowMap';
 export * from './renderers/webgl/WebGLState';
 export * from './renderers/webgl/WebGLTextures';
 export * from './renderers/webgl/WebGLUniforms';
-export * from './renderers/webxr/WebXR';
+export * from './renderers/webgl/WebGLUniformsGroups';
 export * from './renderers/webxr/WebXRController';
 export * from './renderers/webxr/WebXRManager';
 export { WebGLUtils } from './renderers/webgl/WebGLUtils.js';

three/src/animation/AnimationUtils.d.ts

@@ -1,38 +1,36 @@
 import { AnimationClip } from './AnimationClip';
 
-export namespace AnimationUtils {
-    function arraySlice(array: any, from: number, to: number): any;
-    function convertArray(array: any, type: any, forceClone: boolean): any;
-    function isTypedArray(object: any): boolean;
-    function getKeyframeOrder(times: number[]): number[];
-    function sortedArray(values: any[], stride: number, order: number[]): any[];
-    function flattenJSON(jsonKeys: string[], times: any[], values: any[], valuePropertyName: string): void;
+export function arraySlice(array: any, from: number, to: number): any;
+export function convertArray(array: any, type: any, forceClone: boolean): any;
+export function isTypedArray(object: any): boolean;
+export function getKeyframeOrder(times: number[]): number[];
+export function sortedArray(values: any[], stride: number, order: number[]): any[];
+export function flattenJSON(jsonKeys: string[], times: any[], values: any[], valuePropertyName: string): void;
 
-    /**
-     * @param sourceClip
-     * @param name
-     * @param startFrame
-     * @param endFrame
-     * @param [fps=30]
-     */
-    function subclip(
-        sourceClip: AnimationClip,
-        name: string,
-        startFrame: number,
-        endFrame: number,
-        fps?: number,
-    ): AnimationClip;
+/**
+ * @param sourceClip
+ * @param name
+ * @param startFrame
+ * @param endFrame
+ * @param [fps=30]
+ */
+export function subclip(
+    sourceClip: AnimationClip,
+    name: string,
+    startFrame: number,
+    endFrame: number,
+    fps?: number,
+): AnimationClip;
 
-    /**
-     * @param targetClip
-     * @param [referenceFrame=0]
-     * @param [referenceClip=targetClip]
-     * @param [fps=30]
-     */
-    function makeClipAdditive(
-        targetClip: AnimationClip,
-        referenceFrame?: number,
-        referenceClip?: AnimationClip,
-        fps?: number,
-    ): AnimationClip;
-}
+/**
+ * @param targetClip
+ * @param [referenceFrame=0]
+ * @param [referenceClip=targetClip]
+ * @param [fps=30]
+ */
+export function makeClipAdditive(
+    targetClip: AnimationClip,
+    referenceFrame?: number,
+    referenceClip?: AnimationClip,
+    fps?: number,
+): AnimationClip;

three/src/audio/AudioContext.d.ts

@@ -4,5 +4,5 @@
 export namespace AudioContext {
     function getContext(): AudioContext;
 
-    function setContext(): void;
+    function setContext(context: AudioContext): void;
 }

three/src/core/UniformsGroup.d.ts

@@ -0,0 +1,27 @@
+import { EventDispatcher } from './EventDispatcher';
+import { Uniform } from './Uniform';
+
+import { Usage } from '../constants';
+
+export class UniformsGroup extends EventDispatcher {
+    isUniformsGroup: true;
+    id: number;
+    usage: Usage;
+    uniforms: Uniform[];
+
+    constructor();
+
+    add(uniform: Uniform): this;
+
+    remove(uniform: Uniform): this;
+
+    setName(name: string): this;
+
+    setUsage(value: Usage): this;
+
+    dispose(): this;
+
+    copy(source: UniformsGroup): this;
+
+    clone(): UniformsGroup;
+}

three/src/extras/DataUtils.d.ts

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

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/renderers/WebGLRenderTarget.d.ts

@@ -17,6 +17,12 @@ 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 {

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';
@@ -128,11 +127,6 @@ export class WebGLRenderer implements Renderer {
      */
     domElement: HTMLCanvasElement;
 
-    /**
-     * The HTML5 Canvas's 'webgl' context obtained from the canvas where the renderer will draw.
-     */
-    context: WebGLRenderingContext;
-
     /**
      * Defines whether the renderer should automatically clear its output before rendering.
      * @default true
@@ -336,7 +330,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/shaders/UniformsUtils.d.ts

@@ -1,5 +1,10 @@
+import { Uniform } from '../../core/Uniform';
+import { UniformsGroup } from '../../core/UniformsGroup';
+
 export function cloneUniforms(uniforms_src: any): any;
-export function mergeUniforms(uniforms: any[]): any;
+export function mergeUniforms(uniforms: any): any;
+
+export function cloneUniformsGroups(src: UniformsGroup[]): UniformsGroup[];
 
 export namespace UniformsUtils {
     export { mergeUniforms as merge, cloneUniforms as clone };

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

@@ -0,0 +1,17 @@
+import { UniformsGroup } from '../../core/UniformsGroup';
+
+import { WebGLCapabilities } from './WebGLCapabilities';
+import { WebGLInfo } from './WebGLInfo';
+import { WebGLProgram } from './WebGLProgram';
+import { WebGLState } from './WebGLState';
+
+export function WebGLUniformsGroups(
+    gl: WebGLRenderingContext,
+    info: WebGLInfo,
+    capabilities: WebGLCapabilities,
+    state: WebGLState,
+): {
+    dispose: () => void;
+    update: (uniformsGroup: UniformsGroup, program: WebGLProgram) => void;
+    bind: (uniformsGroup: UniformsGroup, program: WebGLProgram) => void;
+};

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/examples/jsm/shaders/SSRrShader.d.ts

@@ -1,48 +0,0 @@
-import { Matrix4, Vector2, IUniform, Texture } from '../../../src/Three';
-
-export interface SSRrShader {
-    defines: {
-        MAX_STEP: number;
-        PERSPECTIVE_CAMERA: boolean;
-        SPECULAR: boolean;
-        FILL_HOLE: boolean;
-        INFINITE_THICK: boolean;
-    };
-
-    uniforms: {
-        tDiffuse: IUniform<Texture | null>;
-        tSpecular: IUniform<Texture | null>;
-        tNormalSelects: IUniform<Texture | null>;
-        tRefractive: IUniform<Texture | null>;
-        tDepthSelects: IUniform<Texture | null>;
-        cameraNear: IUniform<number | null>;
-        cameraFar: IUniform<number | null>;
-        resolution: IUniform<Vector2>;
-        cameraProjectionMatrix: IUniform<Matrix4>;
-        cameraInverseProjectionMatrix: IUniform<Matrix4>;
-        ior: IUniform<number>;
-        cameraRange: IUniform<number>;
-        maxDistance: IUniform<number>;
-        surfDist: IUniform<number>;
-    };
-
-    vertexShader: string;
-
-    fragmentShader: string;
-}
-
-export interface SSRrDepthShader {
-    defines: {
-        PERSPECTIVE_CAMERA: number;
-    };
-
-    uniforms: {
-        tDepth: IUniform<Texture | null>;
-        cameraNear: IUniform<number | null>;
-        cameraFar: IUniform<number | null>;
-    };
-
-    vertexShader: string;
-
-    fragmentShader: string;
-}

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

@@ -1,328 +0,0 @@
-export type XRSessionMode = 'inline' | 'immersive-vr' | 'immersive-ar';
-
-export type XRReferenceSpaceType = 'viewer' | 'local' | 'local-floor' | 'bounded-floor' | 'unbounded';
-
-export type XREnvironmentBlendMode = 'opaque' | 'additive' | 'alpha-blend';
-
-export type XRVisibilityState = 'visible' | 'visible-blurred' | 'hidden';
-
-export type XRHandedness = 'none' | 'left' | 'right';
-
-export type XRTargetRayMode = 'gaze' | 'tracked-pointer' | 'screen';
-
-export type XREye = 'none' | 'left' | 'right';
-
-export type XREventType =
-    | 'end'
-    | 'select'
-    | 'selectstart'
-    | 'selectend'
-    | 'squeeze'
-    | 'squeezestart'
-    | 'squeezeend'
-    | 'inputsourceschange';
-
-export type XRAnimationLoopCallback = (time: number, frame?: XRFrame) => void;
-
-export type XRFrameRequestCallback = (time: number, frame: XRFrame) => void;
-
-export interface XR extends EventTarget {
-    requestSession(mode: XRSessionMode, options?: XRSessionInit): Promise<XRSession>;
-    isSessionSupported(mode: XRSessionMode): Promise<boolean>;
-}
-
-export interface Window {
-    XRSession?: Constructor<XRSession> | undefined;
-    XR?: Constructor<XR> | undefined;
-}
-
-export interface Navigator {
-    xr?: XR | undefined;
-}
-
-export interface XRReferenceSpace extends EventTarget {
-    getOffsetReferenceSpace(originOffset: XRRigidTransform): XRReferenceSpace;
-}
-export interface XRHitTestOptionsInit {
-    space: EventTarget;
-    offsetRay?: XRRay | undefined;
-}
-
-export interface XRTransientInputHitTestOptionsInit {
-    profile: string;
-    offsetRay?: XRRay | undefined;
-}
-
-export interface XRViewport {
-    readonly x: number;
-    readonly y: number;
-    readonly width: number;
-    readonly height: number;
-}
-
-export interface WebGLRenderingContext {
-    makeXRCompatible(): Promise<void>;
-}
-
-export interface XRRenderState {
-    readonly depthNear: number;
-    readonly depthFar: number;
-    readonly inlineVerticalFieldOfView?: number | undefined;
-    readonly baseLayer?: XRWebGLLayer | undefined;
-}
-
-export interface XRRenderStateInit {
-    depthNear?: number | undefined;
-    depthFar?: number | undefined;
-    inlineVerticalFieldOfView?: number | undefined;
-    baseLayer?: XRWebGLLayer | undefined;
-}
-
-export interface XRGamepad {
-    readonly id: string;
-    readonly index: number; // long
-    readonly connected: boolean;
-    readonly timestamp: DOMHighResTimeStamp;
-    readonly mapping: GamepadMappingType;
-    readonly axes: Float32Array; // FrozenArray<double>;
-    readonly buttons: GamepadButton[]; // FrozenArray<GamepadButton>;
-}
-
-export interface XRInputSource {
-    readonly handedness: XRHandedness;
-    readonly targetRayMode: XRTargetRayMode;
-    readonly targetRaySpace: EventTarget;
-    readonly gripSpace?: EventTarget | undefined;
-    readonly profiles: string[];
-    readonly gamepad: XRGamepad;
-    readonly hand?: XRHand | undefined;
-}
-
-export interface XRSessionInit {
-    optionalFeatures?: string[] | undefined;
-    requiredFeatures?: string[] | undefined;
-}
-
-export interface XRSession extends EventTarget {
-    requestReferenceSpace(type: XRReferenceSpaceType): Promise<XRReferenceSpace>;
-    updateRenderState(renderStateInit: XRRenderStateInit): Promise<void>;
-    requestAnimationFrame(callback: XRFrameRequestCallback): number;
-    cancelAnimationFrame(id: number): void;
-    end(): Promise<void>;
-    renderState: XRRenderState;
-    inputSources: XRInputSource[];
-    environmentBlendMode: XREnvironmentBlendMode;
-    visibilityState: XRVisibilityState;
-
-    // hit test
-    requestHitTestSource(options: XRHitTestOptionsInit): Promise<XRHitTestSource>;
-    requestHitTestSourceForTransientInput(
-        options: XRTransientInputHitTestOptionsInit,
-    ): Promise<XRTransientInputHitTestSource>;
-
-    // legacy AR hit test
-    requestHitTest(ray: XRRay, referenceSpace: XRReferenceSpace): Promise<XRHitResult[]>;
-
-    // legacy plane detection
-    updateWorldTrackingState(options: { planeDetectionState?: { enabled: boolean } | undefined }): void;
-}
-
-export interface XRReferenceSpace extends EventTarget {
-    getOffsetReferenceSpace(originOffset: XRRigidTransform): XRReferenceSpace;
-    onreset: any;
-}
-
-export type XRPlaneSet = Set<XRPlane>;
-export type XRAnchorSet = Set<XRAnchor>;
-
-export interface XRFrame {
-    readonly session: XRSession;
-    getViewerPose(referenceSpace: XRReferenceSpace): XRViewerPose | undefined;
-    getPose(space: EventTarget, baseSpace: EventTarget): XRPose | undefined;
-
-    // AR
-    getHitTestResults(hitTestSource: XRHitTestSource): XRHitTestResult[];
-    getHitTestResultsForTransientInput(hitTestSource: XRTransientInputHitTestSource): XRTransientInputHitTestResult[];
-    // Anchors
-    trackedAnchors?: XRAnchorSet | undefined;
-    createAnchor(pose: XRRigidTransform, space: EventTarget): Promise<XRAnchor>;
-    // Planes
-    worldInformation: {
-        detectedPlanes?: XRPlaneSet | undefined;
-    };
-    // Hand tracking
-    getJointPose(joint: XRJointSpace, baseSpace: EventTarget): XRJointPose;
-}
-
-export interface XRViewerPose {
-    readonly transform: XRRigidTransform;
-    readonly views: XRView[];
-}
-
-export interface XRPose {
-    readonly emulatedPosition: boolean;
-    readonly transform: XRRigidTransform;
-}
-
-export interface XRWebGLLayerInit {
-    antialias?: boolean | undefined;
-    depth?: boolean | undefined;
-    stencil?: boolean | undefined;
-    alpha?: boolean | undefined;
-    ignoreDepthValues?: boolean | undefined;
-    framebufferScaleFactor?: number | undefined;
-}
-
-export class XRWebGLLayer {
-    constructor(session: XRSession, gl: WebGLRenderingContext | undefined, options?: XRWebGLLayerInit);
-    framebuffer: WebGLFramebuffer;
-    framebufferWidth: number;
-    framebufferHeight: number;
-    getViewport(view: XRView): XRViewport;
-}
-
-export interface DOMPointInit {
-    w?: number | undefined;
-    x?: number | undefined;
-    y?: number | undefined;
-    z?: number | undefined;
-}
-
-export class XRRigidTransform {
-    constructor(matrix: Float32Array | DOMPointInit, direction?: DOMPointInit);
-    position: DOMPointReadOnly;
-    orientation: DOMPointReadOnly;
-    matrix: Float32Array;
-    inverse: XRRigidTransform;
-}
-
-export interface XRView {
-    readonly eye: XREye;
-    readonly projectionMatrix: Float32Array;
-    readonly viewMatrix: Float32Array;
-    readonly transform: XRRigidTransform;
-}
-
-export interface XRRayDirectionInit {
-    x?: number | undefined;
-    y?: number | undefined;
-    z?: number | undefined;
-    w?: number | undefined;
-}
-
-export class XRRay {
-    readonly origin: DOMPointReadOnly;
-    readonly direction: XRRayDirectionInit;
-    matrix: Float32Array;
-
-    constructor(transformOrOrigin: XRRigidTransform | DOMPointInit, direction?: XRRayDirectionInit);
-}
-
-export enum XRHitTestTrackableType {
-    'point',
-    'plane',
-    'mesh',
-}
-
-export interface XRHitResult {
-    hitMatrix: Float32Array;
-}
-
-export interface XRTransientInputHitTestResult {
-    readonly inputSource: XRInputSource;
-    readonly results: XRHitTestResult[];
-}
-
-export interface XRHitTestResult {
-    getPose(baseSpace: EventTarget): XRPose | undefined | null;
-    // When anchor system is enabled
-    createAnchor?(pose: XRRigidTransform): Promise<XRAnchor>;
-}
-
-export interface XRHitTestSource {
-    cancel(): void;
-}
-
-export interface XRTransientInputHitTestSource {
-    cancel(): void;
-}
-
-export interface XRHitTestOptionsInit {
-    space: EventTarget;
-    entityTypes?: XRHitTestTrackableType[] | undefined;
-    offsetRay?: XRRay | undefined;
-}
-
-export interface XRTransientInputHitTestOptionsInit {
-    profile: string;
-    entityTypes?: XRHitTestTrackableType[] | undefined;
-    offsetRay?: XRRay | undefined;
-}
-
-export interface XRAnchor {
-    anchorSpace: EventTarget;
-    delete(): void;
-}
-
-export interface XRPlane {
-    orientation: 'Horizontal' | 'Vertical';
-    planeSpace: EventTarget;
-    polygon: DOMPointReadOnly[];
-    lastChangedTime: number;
-}
-
-export enum XRHandJoint {
-    'wrist',
-    'thumb-metacarpal',
-    'thumb-phalanx-proximal',
-    'thumb-phalanx-distal',
-    'thumb-tip',
-    'index-finger-metacarpal',
-    'index-finger-phalanx-proximal',
-    'index-finger-phalanx-intermediate',
-    'index-finger-phalanx-distal',
-    'index-finger-tip',
-    'middle-finger-metacarpal',
-    'middle-finger-phalanx-proximal',
-    'middle-finger-phalanx-intermediate',
-    'middle-finger-phalanx-distal',
-    'middle-finger-tip',
-    'ring-finger-metacarpal',
-    'ring-finger-phalanx-proximal',
-    'ring-finger-phalanx-intermediate',
-    'ring-finger-phalanx-distal',
-    'ring-finger-tip',
-    'pinky-finger-metacarpal',
-    'pinky-finger-phalanx-proximal',
-    'pinky-finger-phalanx-intermediate',
-    'pinky-finger-phalanx-distal',
-    'pinky-finger-tip',
-}
-
-export interface XRJointSpace extends EventTarget {
-    readonly jointName: XRHandJoint;
-}
-
-export interface XRJointPose extends XRPose {
-    readonly radius: number | undefined;
-}
-
-export interface XRHand extends Map<XRHandJoint, XRJointSpace> {
-    readonly size: number;
-}
-
-export interface Constructor<T = object> {
-    new (...args: any[]): T;
-    prototype: T;
-}
-
-export interface XRInputSourceChangeEvent {
-    session: XRSession;
-    removed: XRInputSource[];
-    added: XRInputSource[];
-}
-
-export interface XRInputSourceEvent extends Event {
-    readonly frame: XRFrame;
-    readonly inputSource: XRInputSource;
-}