@types/three 0.174.0 → 0.175.0

three/src/nodes/math/OperatorNode.d.ts

@@ -33,33 +33,51 @@ export default class OperatorNode extends TempNode {
     constructor(op: OperatorNodeOp, ...params: [Node, Node, ...Node[]]);
 }
 
-type Operator = (
+export const add: (
     a: NodeRepresentation,
     b: NodeRepresentation,
-    ...others: NodeRepresentation[]
+    ...params: NodeRepresentation[]
 ) => ShaderNodeObject<OperatorNode>;
-
-export const add: Operator;
-export const sub: Operator;
-export const mul: Operator;
-export const div: Operator;
-export const modInt: Operator;
-export const equal: Operator;
-export const notEqual: Operator;
-export const lessThan: Operator;
-export const greaterThan: Operator;
-export const lessThanEqual: Operator;
-export const greaterThanEqual: Operator;
-export const and: Operator;
-export const or: Operator;
-export const not: (a: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
-export const xor: Operator;
-export const bitAnd: Operator;
-export const bitNot: (a: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
-export const bitOr: Operator;
-export const bitXor: Operator;
-export const shiftLeft: Operator;
-export const shiftRight: Operator;
+export const sub: (
+    a: NodeRepresentation,
+    b: NodeRepresentation,
+    ...params: NodeRepresentation[]
+) => ShaderNodeObject<OperatorNode>;
+export const mul: (
+    a: NodeRepresentation,
+    b: NodeRepresentation,
+    ...params: NodeRepresentation[]
+) => ShaderNodeObject<OperatorNode>;
+export const div: (
+    a: NodeRepresentation,
+    b: NodeRepresentation,
+    ...params: NodeRepresentation[]
+) => ShaderNodeObject<OperatorNode>;
+export const mod: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const equal: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const notEqual: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const lessThan: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const greaterThan: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const lessThanEqual: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const greaterThanEqual: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const and: (
+    a: NodeRepresentation,
+    b: NodeRepresentation,
+    ...params: NodeRepresentation[]
+) => ShaderNodeObject<OperatorNode>;
+export const or: (
+    a: NodeRepresentation,
+    b: NodeRepresentation,
+    ...params: NodeRepresentation[]
+) => ShaderNodeObject<OperatorNode>;
+export const not: (value: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const xor: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const bitAnd: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const bitNot: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const bitOr: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const bitXor: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const shiftLeft: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const shiftRight: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
 
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {
@@ -67,7 +85,7 @@ declare module "../tsl/TSLCore.js" {
         sub: typeof sub;
         mul: typeof mul;
         div: typeof div;
-        modInt: typeof modInt;
+        mod: typeof mod;
         equal: typeof equal;
         notEqual: typeof notEqual;
         lessThan: typeof lessThan;
@@ -90,7 +108,16 @@ declare module "../tsl/TSLCore.js" {
 /**
  * @deprecated .remainder() has been renamed to .modInt().
  */
-export const remainder: Operator;
+export const remainder: (
+    aNode: NodeRepresentation,
+    bNode: NodeRepresentation,
+    ...params: NodeRepresentation[]
+) => ShaderNodeObject<OperatorNode>;
+
+/**
+ * @deprecated "modInt()" is deprecated. Use "mod( int( ... ) )" instead.
+ */
+export const modInt: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
 
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {
@@ -98,5 +125,9 @@ declare module "../tsl/TSLCore.js" {
          * @deprecated .remainder() has been renamed to .modInt().
          */
         remainder: typeof remainder;
+        /**
+         * @deprecated "modInt()" is deprecated. Use "mod( int( ... ) )" instead.
+         */
+        modInt: typeof modInt;
     }
 }

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

@@ -17,6 +17,7 @@ export * from "../gpgpu/ComputeNode.js";
 export * from "../math/ConditionalNode.js";
 export * from "../math/MathNode.js";
 export * from "../math/OperatorNode.js";
+export * from "../utils/DebugNode.js";
 export * from "../utils/Discard.js";
 export * from "../utils/RemapNode.js";
 export * from "./TSLCore.js";

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

@@ -0,0 +1,20 @@
+import Node from "../core/Node.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?: ((code: string) => void) | null,
+) => ShaderNodeObject<DebugNode>;
+
+declare module "../tsl/TSLCore.js" {
+    interface NodeElements {
+        debug: typeof debug;
+    }
+}

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

@@ -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;
     /**

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";
@@ -183,21 +185,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.
      */
+    /**
+     * 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);
     /**
      * Initializes the renderer so it is ready for usage.
@@ -227,8 +234,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>;
     /**
@@ -280,7 +287,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 +353,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 +389,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 +402,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 +718,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 +762,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 +774,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 +888,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 +957,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/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;
@@ -117,7 +161,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 +169,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 +193,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 +202,28 @@ declare class XRManager extends EventDispatcher<XRManagerEventMap> {
      * @return {?XRFrame} The XR frame. Returns `null` when used outside a XR session.
      */
     getFrame(): XRFrame | null;
+    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/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
 

three/src/textures/CanvasTexture.d.ts

@@ -31,7 +31,7 @@ export class CanvasTexture extends Texture {
      * @param anisotropy See {@link Texture.anisotropy | .anisotropy}. Default {@link THREE.Texture.DEFAULT_ANISOTROPY}
      */
     constructor(
-        canvas: TexImageSource | OffscreenCanvas,
+        canvas?: TexImageSource | OffscreenCanvas,
         mapping?: Mapping,
         wrapS?: Wrapping,
         wrapT?: Wrapping,

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

@@ -1,32 +0,0 @@
-import { Curve, Vector3 } from "three";
-
-import { ParametricGeometry } from "./ParametricGeometry.js";
-
-export namespace ParametricGeometries {
-    function klein(v: number, u: number, target: Vector3): Vector3;
-    function plane(width: number, height: number): (u: number, v: number, target: Vector3) => Vector3;
-    function mobius(u: number, t: number, target: Vector3): Vector3;
-    function mobius3d(u: number, t: number, target: Vector3): Vector3;
-
-    class TubeGeometry extends ParametricGeometry {
-        constructor(
-            path: Curve<Vector3>,
-            segments?: number,
-            radius?: number,
-            segmentsRadius?: number,
-            closed?: boolean,
-        );
-    }
-
-    class TorusKnotGeometry extends TubeGeometry {
-        constructor(radius?: number, tube?: number, segmentsT?: number, segmentsR?: number, p?: number, q?: number);
-    }
-
-    class SphereGeometry extends ParametricGeometry {
-        constructor(size: number, u: number, v: number);
-    }
-
-    class PlaneGeometry extends ParametricGeometry {
-        constructor(width: number, depth: number, segmentsWidth: number, segmentsDepth: number);
-    }
-}