@types/three 0.174.0 → 0.176.0

three/src/nodes/tsl/TSLCore.d.ts

@@ -9,7 +9,7 @@ import ConvertNode from "../utils/ConvertNode.js";
 export interface NodeElements {
     toGlobal: (node: Node) => Node;
 
-    append: typeof append;
+    toStack: typeof Stack;
 
     toColor: typeof color;
     toFloat: typeof float;
@@ -34,6 +34,8 @@ export interface NodeElements {
 
     element: typeof element;
     convert: typeof convert;
+
+    append: typeof append;
 }
 
 export function addMethodChaining(name: string, nodeElement: unknown): void;
@@ -113,7 +115,7 @@ type RemoveHeadAndTail<T extends readonly [...unknown[]]> = T extends [unknown,
  *
  * We use an object instead of tuple or union as it makes stuff easier, especially in Typescript 4.0.
  */
-interface Construtors<
+interface Constructors<
     A extends undefined | [...unknown[]],
     B extends undefined | [...unknown[]],
     C extends undefined | [...unknown[]],
@@ -136,20 +138,20 @@ type OverloadedConstructorsOf<T> = T extends {
     new(...args: infer A2): unknown;
     new(...args: infer A3): unknown;
     new(...args: infer A4): unknown;
-} ? Construtors<A1, A2, A3, A4>
+} ? Constructors<A1, A2, A3, A4>
     : T extends {
         new(...args: infer A1): unknown;
         new(...args: infer A2): unknown;
         new(...args: infer A3): unknown;
-    } ? Construtors<A1, A2, A3, undefined>
+    } ? Constructors<A1, A2, A3, undefined>
     : T extends {
         new(...args: infer A1): unknown;
         new(...args: infer A2): unknown;
-    } ? Construtors<A1, A2, undefined, undefined>
-    : T extends new(...args: infer A) => unknown ? Construtors<A, undefined, undefined, undefined>
-    : Construtors<undefined, undefined, undefined, undefined>;
+    } ? Constructors<A1, A2, undefined, undefined>
+    : T extends new(...args: infer A) => unknown ? Constructors<A, undefined, undefined, undefined>
+    : Constructors<undefined, undefined, undefined, undefined>;
 
-type AnyConstructors = Construtors<any, any, any, any>;
+type AnyConstructors = Constructors<any, any, any, any>;
 
 /**
  * Returns all constructors where the first paramter is assignable to given "scope"
@@ -259,30 +261,14 @@ export function Fn<T extends { readonly [key: string]: unknown }>(
     jsFunc: (args: T) => void,
 ): ShaderNodeFn<[ProxiedObject<T>]>;
 
-/**
- * @deprecated tslFn() has been renamed to Fn()
- */
-export function tslFn<R extends Node = ShaderNodeObject<Node>>(jsFunc: () => R): () => R;
-/**
- * @deprecated tslFn() has been renamed to Fn()
- */
-export function tslFn<T extends any[], R extends Node = ShaderNodeObject<Node>>(
-    jsFunc: (args: T) => R,
-): (...args: ProxiedTuple<T>) => R;
-/**
- * @deprecated tslFn() has been renamed to Fn()
- */
-export function tslFn<T extends { [key: string]: unknown }, R extends Node = ShaderNodeObject<Node>>(
-    jsFunc: (args: T) => R,
-): (args: ProxiedObject<T>) => R;
-
 export const setCurrentStack: (stack: StackNode | null) => void;
 
 export const getCurrentStack: () => StackNode | null;
 
 export const If: (boolNode: Node, method: () => void) => StackNode;
+export const Switch: (expression: NodeRepresentation) => StackNode;
 
-export function append(node: Node): Node;
+export function Stack(node: Node): Node;
 
 interface ColorFunction {
     (color?: ColorRepresentation): ShaderNodeObject<ConstNode<Color>>;
@@ -322,3 +308,25 @@ export const arrayBuffer: (value: ArrayBuffer) => ShaderNodeObject<ConstNode<Arr
 export const element: (node: NodeRepresentation, indexNode: NodeRepresentation) => ShaderNodeObject<Node>;
 export const convert: (node: NodeRepresentation, types: string) => ShaderNodeObject<Node>;
 export const split: (node: NodeRepresentation, channels?: string) => ShaderNodeObject<Node>;
+
+/**
+ * @deprecated append() has been renamed to Stack().
+ */
+export const append: (node: Node) => Node;
+
+/**
+ * @deprecated tslFn() has been renamed to Fn()
+ */
+export function tslFn<R extends Node = ShaderNodeObject<Node>>(jsFunc: () => R): () => R;
+/**
+ * @deprecated tslFn() has been renamed to Fn()
+ */
+export function tslFn<T extends any[], R extends Node = ShaderNodeObject<Node>>(
+    jsFunc: (args: T) => R,
+): (...args: ProxiedTuple<T>) => R;
+/**
+ * @deprecated tslFn() has been renamed to Fn()
+ */
+export function tslFn<T extends { [key: string]: unknown }, R extends Node = ShaderNodeObject<Node>>(
+    jsFunc: (args: T) => R,
+): (args: ProxiedObject<T>) => R;

three/src/nodes/utils/DebugNode.d.ts

@@ -0,0 +1,21 @@
+import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class DebugNode extends TempNode {
+    constructor(node: Node, callback?: ((code: string) => void) | null);
+}
+
+export default DebugNode;
+
+export const debug: (
+    node: NodeRepresentation,
+    callback?: ((node: NodeBuilder, code: string) => void) | null,
+) => ShaderNodeObject<DebugNode>;
+
+declare module "../tsl/TSLCore.js" {
+    interface NodeElements {
+        debug: typeof debug;
+    }
+}

three/src/nodes/utils/ReflectorNode.d.ts

@@ -31,7 +31,7 @@ declare class ReflectorBaseNode extends Node {
     bounces: boolean;
 
     virtualCameras: WeakMap<Camera, Camera>;
-    renderTargets: WeakMap<Camera, RenderTarget>;
+    renderTargets: Map<Camera, RenderTarget>;
     forceUpdate: boolean;
 
     constructor(textureNode: TextureNode, parameters?: ReflectorNodeParameters);

three/src/nodes/utils/SpriteSheetUVNode.d.ts

@@ -11,6 +11,6 @@ export default class SpriteSheetUVNode extends Node {
 
 export const spritesheetUV: (
     countNode: NodeRepresentation,
-    uvNode?: NodeRepresentation,
-    frameNode?: NodeRepresentation,
+    uvNode: NodeRepresentation | null,
+    frameNode: NodeRepresentation | null,
 ) => ShaderNodeObject<SpriteSheetUVNode>;

three/src/renderers/common/Animation.d.ts

@@ -12,7 +12,7 @@ export interface AnimationContext {
 declare class Animation {
     nodes: Nodes;
     info: Info;
-    _context: AnimationContext;
+    _context: AnimationContext | null;
     _animationLoop: ((time: DOMHighResTimeStamp, xrFrame?: XRFrame) => void) | null;
     _requestId: number | null;
     /**
@@ -33,13 +33,13 @@ declare class Animation {
     /**
      * Returns the user-level animation loop.
      *
-     * @return {Function} The animation loop.
+     * @return {?Function} The animation loop.
      */
     getAnimationLoop(): ((time: DOMHighResTimeStamp, xrFrame?: XRFrame) => void) | null;
     /**
      * Defines the user-level animation loop.
      *
-     * @param {Function} callback - The animation loop.
+     * @param {?Function} callback - The animation loop.
      */
     setAnimationLoop(callback: ((time: DOMHighResTimeStamp, xrFrame?: XRFrame) => void) | null): void;
     /**
@@ -47,7 +47,7 @@ declare class Animation {
      *
      * @return {Window|XRSession} The animation context.
      */
-    getContext(): AnimationContext;
+    getContext(): AnimationContext | null;
     /**
      * Defines the context in which `requestAnimationFrame()` is executed.
      *

three/src/renderers/common/Attributes.d.ts

@@ -30,7 +30,7 @@ declare class Attributes extends DataMap<{
      * Deletes the data for the given attribute.
      *
      * @param {BufferAttribute} attribute - The attribute.
-     * @return {Object} The deleted attribute data.
+     * @return {Object|null} The deleted attribute data.
      */
     delete(attribute: BufferAttribute | InterleavedBufferAttribute): Data;
     /**

three/src/renderers/common/Color4.d.ts

@@ -26,7 +26,7 @@ declare class Color4 extends Color {
      * You can also pass a single THREE.Color, hex or
      * string argument to this method.
      *
-     * @param {number|string} r - The red value.
+     * @param {number|string|Color} r - The red value.
      * @param {number} g - The green value.
      * @param {number} b - The blue value.
      * @param {number} [a=1] - The alpha value.

three/src/renderers/common/CubeRenderTarget.d.ts

@@ -10,6 +10,12 @@ import { WebGLRenderer } from "../WebGLRenderer.js";
  */
 declare class CubeRenderTarget extends WebGLCubeRenderTarget {
     readonly isCubeRenderTarget: true;
+    /**
+     * Constructs a new cube render target.
+     *
+     * @param {number} [size=1] - The size of the render target.
+     * @param {RenderTarget~Options} [options] - The configuration object.
+     */
     constructor(size?: number, options?: RenderTargetOptions);
     /**
      * Converts the given equirectangular texture to a cube map.

three/src/renderers/common/RenderList.d.ts

@@ -144,8 +144,8 @@ declare class RenderList {
     /**
      * Sorts the internal render lists.
      *
-     * @param {function(any, any): number} customOpaqueSort - A custom sort function for opaque objects.
-     * @param {function(any, any): number} customTransparentSort -  A custom sort function for transparent objects.
+     * @param {?function(any, any): number} customOpaqueSort - A custom sort function for opaque objects.
+     * @param {?function(any, any): number} customTransparentSort -  A custom sort function for transparent objects.
      */
     sort(
         customOpaqueSort: ((a: RenderItem, b: RenderItem) => number) | null,

three/src/renderers/common/RenderObject.d.ts

@@ -189,7 +189,7 @@ declare class RenderObject {
     /**
      * Returns the draw parameters for the render object.
      *
-     * @return {{vertexCount: number, firstVertex: number, instanceCount: number, firstInstance: number}} The draw parameters.
+     * @return {?{vertexCount: number, firstVertex: number, instanceCount: number, firstInstance: number}} The draw parameters.
      */
     getDrawParameters(): {
         vertexCount: number;

three/src/renderers/common/RenderObjects.d.ts

@@ -56,7 +56,7 @@ declare class RenderObjects {
      * @param {LightsNode} lightsNode - The lights node.
      * @param {RenderContext} renderContext - The render context.
      * @param {ClippingContext} clippingContext - The clipping context.
-     * @param {?string} passId - An optional ID for identifying the pass.
+     * @param {string} [passId] - An optional ID for identifying the pass.
      * @return {RenderObject} The render object.
      */
     get(
@@ -98,7 +98,7 @@ declare class RenderObjects {
      * @param {LightsNode} lightsNode - The lights node.
      * @param {RenderContext} renderContext - The render context.
      * @param {ClippingContext} clippingContext - The clipping context.
-     * @param {?string} passId - An optional ID for identifying the pass.
+     * @param {string} [passId] - An optional ID for identifying the pass.
      * @return {RenderObject} The render object.
      */
     createRenderObject(

three/src/renderers/common/Renderer.d.ts

@@ -6,8 +6,10 @@ import { Object3D } from "../../core/Object3D.js";
 import { RenderTarget } from "../../core/RenderTarget.js";
 import { Material } from "../../materials/Material.js";
 import { Box2 } from "../../math/Box2.js";
+import { Box3 } from "../../math/Box3.js";
 import { ColorRepresentation } from "../../math/Color.js";
 import { Vector2 } from "../../math/Vector2.js";
+import { Vector3 } from "../../math/Vector3.js";
 import { Vector4 } from "../../math/Vector4.js";
 import MRTNode from "../../nodes/core/MRTNode.js";
 import ComputeNode from "../../nodes/gpgpu/ComputeNode.js";
@@ -60,6 +62,7 @@ export interface RendererParameters {
     samples?: number | undefined;
     getFallback?: ((error: unknown) => Backend) | null | undefined;
     colorBufferType?: TextureDataType | undefined;
+    multiview?: boolean | undefined;
 }
 /**
  * Base class for renderers.
@@ -183,20 +186,26 @@ declare class Renderer {
     };
     localClippingEnabled?: boolean | undefined;
     /**
-     * Constructs a new renderer.
+     * Renderer options.
      *
-     * @param {Backend} backend - The backend the renderer is targeting (e.g. WebGPU or WebGL 2).
-     * @param {Object} parameters - The configuration parameter.
-     * @param {boolean} [parameters.logarithmicDepthBuffer=false] - Whether logarithmic depth buffer is enabled or not.
-     * @param {boolean} [parameters.alpha=true] - Whether the default framebuffer (which represents the final contents of the canvas) should be transparent or opaque.
-     * @param {boolean} [parameters.depth=true] - Whether the default framebuffer should have a depth buffer or not.
-     * @param {boolean} [parameters.stencil=false] - Whether the default framebuffer should have a stencil buffer or not.
-     * @param {boolean} [parameters.antialias=false] - Whether MSAA as the default anti-aliasing should be enabled or not.
-     * @param {number} [parameters.samples=0] - When `antialias` is `true`, `4` samples are used by default. This parameter can set to any other integer value than 0
+     * @typedef {Object} Renderer~Options
+     * @property {boolean} [logarithmicDepthBuffer=false] - Whether logarithmic depth buffer is enabled or not.
+     * @property {boolean} [alpha=true] - Whether the default framebuffer (which represents the final contents of the canvas) should be transparent or opaque.
+     * @property {boolean} [depth=true] - Whether the default framebuffer should have a depth buffer or not.
+     * @property {boolean} [stencil=false] - Whether the default framebuffer should have a stencil buffer or not.
+     * @property {boolean} [antialias=false] - Whether MSAA as the default anti-aliasing should be enabled or not.
+     * @property {number} [samples=0] - When `antialias` is `true`, `4` samples are used by default. This parameter can set to any other integer value than 0
      * to overwrite the default.
-     * @param {?Function} [parameters.getFallback=null] - This callback function can be used to provide a fallback backend, if the primary backend can't be targeted.
-     * @param {number} [parameters.colorBufferType=HalfFloatType] - Defines the type of color buffers. The default `HalfFloatType` is recommend for best
+     * @property {?Function} [getFallback=null] - This callback function can be used to provide a fallback backend, if the primary backend can't be targeted.
+     * @property {number} [colorBufferType=HalfFloatType] - Defines the type of color buffers. The default `HalfFloatType` is recommend for best
      * quality. To save memory and bandwidth, `UnsignedByteType` might be used. This will reduce rendering quality though.
+     * @property {boolean} [multiview=false] - If set to `true`, the renderer will use multiview during WebXR rendering if supported.
+     */
+    /**
+     * Constructs a new renderer.
+     *
+     * @param {Backend} backend - The backend the renderer is targeting (e.g. WebGPU or WebGL 2).
+     * @param {Renderer~Options} [parameters] - The configuration parameter.
      */
     constructor(backend: Backend, parameters?: RendererParameters);
     /**
@@ -227,8 +236,8 @@ declare class Renderer {
      * @async
      * @param {Object3D} scene - The scene or 3D object to precompile.
      * @param {Camera} camera - The camera that is used to render the scene.
-     * @param {Scene} targetScene - If the first argument is a 3D object, this parameter must represent the scene the 3D object is going to be added.
-     * @return {Promise<Array>} A Promise that resolves when the compile has been finished.
+     * @param {?Scene} targetScene - If the first argument is a 3D object, this parameter must represent the scene the 3D object is going to be added.
+     * @return {Promise<Array|undefined>} A Promise that resolves when the compile has been finished.
      */
     compileAsync(scene: Object3D, camera: Camera, targetScene?: Object3D | null): Promise<void>;
     /**
@@ -248,6 +257,23 @@ declare class Renderer {
      * @return {Promise} A Promise that resolves when synchronization has been finished.
      */
     waitForGPU(): Promise<void>;
+    /**
+     * Enables or disables high precision for model-view and normal-view matrices.
+     * When enabled, will use CPU 64-bit precision for higher precision instead of GPU 32-bit for higher performance.
+     *
+     * NOTE: 64-bit precision is not compatible with `InstancedMesh` and `SkinnedMesh`.
+     *
+     * @param {boolean} value - Whether to enable or disable high precision.
+     * @type {boolean}
+     */
+    set highPrecision(value: boolean);
+    /**
+     * Returns whether high precision is enabled or not.
+     *
+     * @return {boolean} Whether high precision is enabled or not.
+     * @type {boolean}
+     */
+    get highPrecision(): boolean;
     /**
      * Sets the given MRT configuration.
      *
@@ -280,7 +306,7 @@ declare class Renderer {
      * @private
      * @param {Object} bundle - Render bundle data.
      * @param {Scene} sceneRef - The scene the render bundle belongs to.
-     * @param {LightsNode} lightsNode - The current lights node.
+     * @param {LightsNode} lightsNode - The lights node.
      */
     _renderBundle(bundle: Bundle, sceneRef: Scene, lightsNode: LightsNode): void;
     /**
@@ -346,7 +372,7 @@ declare class Renderer {
      * for best compatibility.
      *
      * @async
-     * @param {Function} callback - The application's animation loop.
+     * @param {?Function} callback - The application's animation loop.
      * @return {Promise} A Promise that resolves when the set has been executed.
      */
     setAnimationLoop(callback: ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null): Promise<void>;
@@ -382,7 +408,7 @@ declare class Renderer {
      * Returns the renderer's size in logical pixels. This method does not honor the pixel ratio.
      *
      * @param {Vector2} target - The method writes the result in this target object.
-     * @return {Vector2} The drawing buffer size.
+     * @return {Vector2} The renderer's size in logical pixels.
      */
     getSize(target: Vector2): Vector2;
     /**
@@ -395,7 +421,7 @@ declare class Renderer {
      * This method allows to define the drawing buffer size by specifying
      * width, height and pixel ratio all at once. The size of the drawing
      * buffer is computed with this formula:
-     * ````
+     * ```js
      * size.x = width * pixelRatio;
      * size.y = height * pixelRatio;
      * ```
@@ -711,7 +737,7 @@ declare class Renderer {
      * if the renderer has been initialized.
      *
      * @param {Node|Array<Node>} computeNodes - The compute node(s).
-     * @return {?Promise} A Promise that resolve when the compute has finished. Only returned when the renderer has not been initialized.
+     * @return {Promise|undefined} A Promise that resolve when the compute has finished. Only returned when the renderer has not been initialized.
      */
     compute(computeNodes: ComputeNode | ComputeNode[]): Promise<void> | undefined;
     /**
@@ -755,7 +781,7 @@ declare class Renderer {
      */
     initTextureAsync(texture: Texture): Promise<void>;
     /**
-     * Initializes the given textures. Useful for preloading a texture rather than waiting until first render
+     * Initializes the given texture. Useful for preloading a texture rather than waiting until first render
      * (which can cause noticeable lags due to decode and GPU upload overhead).
      *
      * This method can only be used if the renderer has been initialized.
@@ -767,24 +793,26 @@ declare class Renderer {
      * Copies the current bound framebuffer into the given texture.
      *
      * @param {FramebufferTexture} framebufferTexture - The texture.
-     * @param {Vector2|Vector4} rectangle - A two or four dimensional vector that defines the rectangular portion of the framebuffer that should be copied.
+     * @param {?Vector2|Vector4} [rectangle=null] - A two or four dimensional vector that defines the rectangular portion of the framebuffer that should be copied.
      */
     copyFramebufferToTexture(framebufferTexture: FramebufferTexture, rectangle?: Rectangle | null): void;
     /**
-     * Copies data of source texture into a destination texture.
+     * Copies data of the given source texture into a destination texture.
      *
      * @param {Texture} srcTexture - The source texture.
      * @param {Texture} dstTexture - The destination texture.
      * @param {Box2|Box3} [srcRegion=null] - A bounding box which describes the source region. Can be two or three-dimensional.
      * @param {Vector2|Vector3} [dstPosition=null] - A vector that represents the origin of the destination region. Can be two or three-dimensional.
-     * @param {number} level - The mipmap level to copy.
+     * @param {number} [srcLevel=0] - The source mip level to copy from.
+     * @param {number} [dstLevel=0] - The destination mip level to copy to.
      */
     copyTextureToTexture(
         srcTexture: Texture,
         dstTexture: Texture,
-        srcRegion?: Box2 | null,
-        dstPosition?: Vector2 | null,
-        level?: number,
+        srcRegion?: Box2 | Box3 | null,
+        dstPosition?: Vector2 | Vector3 | null,
+        srcLevel?: number,
+        dstLevel?: number,
     ): void;
     /**
      * Reads pixel data from the given render target.
@@ -879,7 +907,7 @@ declare class Renderer {
      * @param {Material} material - The object's material.
      * @param {?Object} group - Only relevant for objects using multiple materials. This represents a group entry from the respective `BufferGeometry`.
      * @param {LightsNode} lightsNode - The current lights node.
-     * @param {ClippingContext} clippingContext - The clipping context.
+     * @param {?ClippingContext} clippingContext - The clipping context.
      * @param {?string} [passId=null] - An optional ID for identifying the pass.
      */
     renderObject(
@@ -948,7 +976,7 @@ declare class Renderer {
      * @param {Object3D} scene - The scene or 3D object to precompile.
      * @param {Camera} camera - The camera that is used to render the scene.
      * @param {Scene} targetScene - If the first argument is a 3D object, this parameter must represent the scene the 3D object is going to be added.
-     * @return {Promise} A Promise that resolves when the compile has been finished.
+     * @return {function(Object3D, Camera, ?Scene): Promise|undefined} A Promise that resolves when the compile has been finished.
      */
     get compile(): (scene: Object3D, camera: Camera, targetScene?: Object3D | null) => Promise<void>;
 }

three/src/renderers/common/Textures.d.ts

@@ -116,13 +116,6 @@ declare class Textures extends DataMap<{
      * @return {boolean} Whether mipmaps are required or not.
      */
     needsMipmaps(texture: Texture): boolean;
-    /**
-     * Returns `true` if the given texture is an environment map.
-     *
-     * @param {Texture} texture - The texture.
-     * @return {boolean} Whether the given texture is an environment map or not.
-     */
-    isEnvironmentTexture(texture: Texture): boolean;
     /**
      * Frees internal resource when the given texture isn't
      * required anymore.

three/src/renderers/common/TimestampQueryPool.d.ts

@@ -23,6 +23,7 @@ declare abstract class TimestampQueryPool {
      *
      * @abstract
      * @param {Object} renderContext - The render context to allocate queries for.
+     * @returns {?number}
      */
     abstract allocateQueriesForContext(renderContext: RenderContext): number | null;
     /**

three/src/renderers/common/XRManager.d.ts

@@ -1,7 +1,14 @@
 import { ArrayCamera } from "../../cameras/ArrayCamera.js";
 import { PerspectiveCamera } from "../../cameras/PerspectiveCamera.js";
 import { EventDispatcher } from "../../core/EventDispatcher.js";
+import { CylinderGeometry } from "../../geometries/CylinderGeometry.js";
+import { PlaneGeometry } from "../../geometries/PlaneGeometry.js";
+import { Material } from "../../materials/Material.js";
+import { MeshBasicMaterial } from "../../materials/MeshBasicMaterial.js";
+import { Quaternion } from "../../math/Quaternion.js";
 import { Vector2 } from "../../math/Vector2.js";
+import { Vector3 } from "../../math/Vector3.js";
+import { Mesh } from "../../objects/Mesh.js";
 import { WebXRController } from "../webxr/WebXRController.js";
 import { AnimationContext } from "./Animation.js";
 import Renderer from "./Renderer.js";
@@ -13,6 +20,39 @@ export interface XRManagerEventMap {
         data: XRFrame;
     };
 }
+export interface XRQuadLayerObject {
+    type: "quad";
+    width: number;
+    height: number;
+    translation: Vector3;
+    quaternion: Quaternion;
+    pixelwidth: number;
+    pixelheight: number;
+    plane: Mesh;
+    material: Material;
+    rendercall: () => void;
+    renderTarget: XRRenderTarget;
+    xrlayer?: XRLayer;
+}
+export interface XRCylinderLayerObject {
+    type: "cylinder";
+    radius: number;
+    centralAngle: number;
+    aspectratio: number;
+    translation: Vector3;
+    quaternion: Quaternion;
+    pixelwidth: number;
+    pixelheight: number;
+    plane: Mesh;
+    material: Material;
+    rendercall: () => void;
+    renderTarget: XRRenderTarget;
+    xrlayer?: XRLayer;
+}
+export type XRLayerObject = XRQuadLayerObject | XRCylinderLayerObject;
+export interface LayerAttributes {
+    stencil?: boolean | undefined;
+}
 /**
  * The XR manager is built on top of the WebXR Device API to
  * manage XR sessions with `WebGPURenderer`.
@@ -35,6 +75,10 @@ declare class XRManager extends EventDispatcher<XRManagerEventMap> {
     _controllers: WebXRController[];
     _controllerInputSources: (XRInputSource | null)[];
     _xrRenderTarget: XRRenderTarget | null;
+    _layers: XRLayerObject[];
+    _supportsLayers: boolean;
+    _createXRLayer: (layer: XRLayerObject) => XRLayer;
+    _gl: WebGL2RenderingContext | null;
     _currentAnimationContext: AnimationContext | null;
     _currentAnimationLoop: ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null;
     _currentPixelRatio: number | null;
@@ -54,12 +98,15 @@ declare class XRManager extends EventDispatcher<XRManagerEventMap> {
     _glProjLayer: XRProjectionLayer | null;
     _xrFrame: XRFrame | null;
     _useLayers: boolean;
+    _useMultiviewIfPossible: boolean;
+    _useMultiview: boolean;
     /**
      * Constructs a new XR manager.
      *
      * @param {Renderer} renderer - The renderer.
+     * @param {boolean} [multiview=false] - Enables multiview if the device supports it.
      */
-    constructor(renderer: Renderer);
+    constructor(renderer: Renderer, multiview?: boolean);
     /**
      * Returns an instance of `THREE.Group` that represents the transformation
      * of a XR controller in target ray space. The requested controller is defined
@@ -117,7 +164,7 @@ declare class XRManager extends EventDispatcher<XRManagerEventMap> {
     /**
      * Returns the reference space type.
      *
-     * @return {string} The reference space type.
+     * @return {XRReferenceSpaceType} The reference space type.
      */
     getReferenceSpaceType(): XRReferenceSpaceType;
     /**
@@ -125,7 +172,7 @@ declare class XRManager extends EventDispatcher<XRManagerEventMap> {
      *
      * This method can not be used during a XR session.
      *
-     * @param {string} type - The reference space type.
+     * @param {XRReferenceSpaceType} type - The reference space type.
      */
     setReferenceSpaceType(type: XRReferenceSpaceType): void;
     /**
@@ -149,7 +196,7 @@ declare class XRManager extends EventDispatcher<XRManagerEventMap> {
     /**
      * Returns the environment blend mode from the current XR session.
      *
-     * @return {?('opaque'|'additive'|'alpha-blend')} The environment blend mode. Returns `null` when used outside of a XR session.
+     * @return {'opaque'|'additive'|'alpha-blend'|undefined} The environment blend mode. Returns `undefined` when used outside of a XR session.
      */
     getEnvironmentBlendMode(): XREnvironmentBlendMode | undefined;
     /**
@@ -158,6 +205,34 @@ declare class XRManager extends EventDispatcher<XRManagerEventMap> {
      * @return {?XRFrame} The XR frame. Returns `null` when used outside a XR session.
      */
     getFrame(): XRFrame | null;
+    /**
+     * Returns `true` if the engine renders to a multiview target.
+     *
+     * @return {boolean} Whether the engine renders to a multiview render target or not.
+     */
+    useMultiview(): boolean;
+    createQuadLayer(
+        width: number,
+        height: number,
+        translation: Vector3,
+        quaternion: Quaternion,
+        pixelwidth: number,
+        pixelheight: number,
+        rendercall: () => void,
+        attributes?: LayerAttributes,
+    ): Mesh<PlaneGeometry, MeshBasicMaterial, import("../../core/Object3D.js").Object3DEventMap>;
+    createCylinderLayer(
+        radius: number,
+        centralAngle: number,
+        aspectratio: number,
+        translation: Vector3,
+        quaternion: Quaternion,
+        pixelwidth: number,
+        pixelheight: number,
+        rendercall: () => void,
+        attributes?: LayerAttributes,
+    ): Mesh<CylinderGeometry, MeshBasicMaterial, import("../../core/Object3D.js").Object3DEventMap>;
+    renderLayers(): void;
     /**
      * Returns the current XR session.
      *

three/src/renderers/common/nodes/NodeBuilderState.d.ts

@@ -26,9 +26,9 @@ declare class NodeBuilderState {
     /**
      * Constructs a new node builder state.
      *
-     * @param {?string} vertexShader - The native vertex shader code.
-     * @param {?string} fragmentShader - The native fragment shader code.
-     * @param {?string} computeShader - The native compute shader code.
+     * @param {string} vertexShader - The native vertex shader code.
+     * @param {string} fragmentShader - The native fragment shader code.
+     * @param {string} computeShader - The native compute shader code.
      * @param {Array<NodeAttribute>} nodeAttributes - An array of node attributes.
      * @param {Array<BindGroup>} bindings - An array of bind groups.
      * @param {Array<Node>} updateNodes - An array of nodes that implement their `update()` method.

three/src/renderers/webgpu/WebGPUBackend.d.ts

@@ -5,6 +5,7 @@ import Backend, { BackendParameters } from "../common/Backend.js";
 
 export interface WebGPUBackendParameters extends BackendParameters {
     alpha?: boolean | undefined;
+    compatibilityMode?: boolean | undefined;
     requiredLimits?: Record<string, GPUSize64> | undefined;
     trackTimestamp?: boolean | undefined;
     device?: GPUDevice | undefined;

three/src/renderers/webgpu/utils/WebGPUConstants.d.ts

@@ -112,7 +112,7 @@ export enum GPUTextureFormat {
     // Packed 32-bit formats
     RGB9E5UFloat = "rgb9e5ufloat",
     RGB10A2Unorm = "rgb10a2unorm",
-    RG11B10uFloat = "rgb10a2unorm",
+    RG11B10UFloat = "rgb10a2unorm",
 
     // 64-bit formats