@types/three 0.163.0 → 0.164.0

three/examples/jsm/nodes/materials/NodeMaterial.d.ts

@@ -9,6 +9,7 @@ import {
     PointsMaterial,
     ShaderMaterial,
     ShaderMaterialParameters,
+    ShadowMaterial,
     SpriteMaterial,
 } from "three";
 import ClippingNode from "../accessors/ClippingNode.js";
@@ -24,6 +25,7 @@ import MeshPhongNodeMaterial from "./MeshPhongNodeMaterial.js";
 import MeshPhysicalNodeMaterial from "./MeshPhysicalNodeMaterial.js";
 import MeshStandardNodeMaterial from "./MeshStandardNodeMaterial.js";
 import PointsNodeMaterial from "./PointsNodeMaterial.js";
+import ShadowNodeMaterial from "./ShadowNodeMaterial.js";
 import SpriteNodeMaterial from "./SpriteNodeMaterial.js";
 
 export interface NodeMaterialParameters extends ShaderMaterialParameters {
@@ -33,6 +35,7 @@ export interface NodeMaterialParameters extends ShaderMaterialParameters {
 
     lightsNode?: ShaderNodeObject<LightsNode> | null | undefined;
     envNode?: ShaderNodeObject<Node> | null | undefined;
+    aoNode?: ShaderNodeObject<Node> | null | undefined;
 
     colorNode?: ShaderNodeObject<Node> | null | undefined;
     normalNode?: ShaderNodeObject<Node> | null | undefined;
@@ -57,10 +60,9 @@ export default class NodeMaterial extends ShaderMaterial {
 
     normals: boolean;
 
-    colorSpaced: boolean;
-
     lightsNode: ShaderNodeObject<LightsNode> | null;
     envNode: ShaderNodeObject<Node> | null;
+    aoNode: ShaderNodeObject<Node> | null;
 
     colorNode: ShaderNodeObject<Node> | null;
     normalNode: ShaderNodeObject<Node> | null;
@@ -73,6 +75,7 @@ export default class NodeMaterial extends ShaderMaterial {
 
     depthNode: ShaderNodeObject<Node> | null;
     shadowNode: ShaderNodeObject<Node> | null;
+    shadowPositionNode: ShaderNodeObject<Node> | null;
 
     outputNode: ShaderNodeObject<Node> | null;
 
@@ -104,6 +107,7 @@ export default class NodeMaterial extends ShaderMaterial {
     static fromMaterial(material: MeshPhysicalMaterial): MeshPhysicalNodeMaterial;
     static fromMaterial(material: MeshStandardMaterial): MeshStandardNodeMaterial;
     static fromMaterial(material: PointsMaterial): PointsNodeMaterial;
+    static fromMaterial(material: ShadowMaterial): ShadowNodeMaterial;
     static fromMaterial(material: SpriteMaterial): SpriteNodeMaterial;
     static fromMaterial(material: NodeMaterial): NodeMaterial;
     static fromMaterial(material: Material): NodeMaterial;

three/examples/jsm/nodes/materials/ShadowNodeMaterial.d.ts

@@ -0,0 +1,15 @@
+import { Color, ShadowMaterialParameters } from "three";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface ShadowNodeMaterialParameters extends NodeMaterialParameters, ShadowMaterialParameters {
+}
+
+export default class ShadowNodeMaterial extends NodeMaterial {
+    readonly isShadowNodeMaterial: true;
+
+    // Properties from ShadowMaterial
+    readonly isShadowMaterial: true;
+    color: Color;
+
+    constructor(parameters?: ShadowNodeMaterialParameters);
+}

three/examples/jsm/nodes/materialx/MaterialXNodes.d.ts

@@ -2,102 +2,106 @@ import Node from "../core/Node.js";
 import MathNode from "../math/MathNode.js";
 import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import { mx_hsvtorgb, mx_rgbtohsv } from "./lib/mx_hsv.js";
+import { mx_srgb_texture_to_lin_rec709 } from "./lib/mx_transform_color.js";
 
-export function mx_aastep(threshold?: NodeRepresentation, value?: NodeRepresentation): ShaderNodeObject<MathNode>;
+export function mx_aastep(threshold: NodeRepresentation, value: NodeRepresentation): ShaderNodeObject<MathNode>;
 
 export function mx_ramplr(
-    valuel?: NodeRepresentation,
-    valuer?: NodeRepresentation,
-    texcoord?: ShaderNodeObject<Node>,
+    valuel: NodeRepresentation,
+    valuer: NodeRepresentation,
+    texcoord?: NodeRepresentation,
 ): ShaderNodeObject<MathNode>;
 export function mx_ramptb(
-    valuet?: NodeRepresentation,
-    valueb?: NodeRepresentation,
-    texcoord?: ShaderNodeObject<Node>,
+    valuet: NodeRepresentation,
+    valueb: NodeRepresentation,
+    texcoord?: NodeRepresentation,
 ): ShaderNodeObject<MathNode>;
 
 export function mx_splitlr(
-    valuel?: NodeRepresentation,
-    valuer?: NodeRepresentation,
-    center?: NodeRepresentation,
-    texcoord?: ShaderNodeObject<Node>,
+    valuel: NodeRepresentation,
+    valuer: NodeRepresentation,
+    center: NodeRepresentation,
+    texcoord?: NodeRepresentation,
 ): ShaderNodeObject<MathNode>;
 export function mx_splittb(
-    valuet?: NodeRepresentation,
-    valueb?: NodeRepresentation,
-    center?: NodeRepresentation,
-    texcoord?: ShaderNodeObject<Node>,
+    valuet: NodeRepresentation,
+    valueb: NodeRepresentation,
+    center: NodeRepresentation,
+    texcoord?: NodeRepresentation,
 ): ShaderNodeObject<MathNode>;
 
 export function mx_transform_uv(
     uv_scale?: NodeRepresentation,
     uv_offset?: NodeRepresentation,
-    uv_geo?: ShaderNodeObject<Node>,
+    uv_geo?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
 
-export function mx_noise_float(
-    texcoord?: ShaderNodeObject<Node>,
-    amplitude?: NodeRepresentation,
+export function mx_safepower(in1: NodeRepresentation, in2?: NodeRepresentation): ShaderNodeObject<Node>;
+
+export function mx_contrast(
+    input: NodeRepresentation,
+    amount?: NodeRepresentation,
     pivot?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
-export function mx_noise_vec2(
-    texcoord?: ShaderNodeObject<Node>,
+
+export function mx_noise_float(
+    texcoord?: NodeRepresentation,
     amplitude?: NodeRepresentation,
     pivot?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
 export function mx_noise_vec3(
-    texcoord?: ShaderNodeObject<Node>,
+    texcoord?: NodeRepresentation,
     amplitude?: NodeRepresentation,
     pivot?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
 export function mx_noise_vec4(
-    texcoord?: ShaderNodeObject<Node>,
+    texcoord?: NodeRepresentation,
     amplitude?: NodeRepresentation,
     pivot?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
 
 export function mx_worley_noise_float(
-    texcoord?: ShaderNodeObject<Node>,
+    texcoord?: NodeRepresentation,
     jitter?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
 export function mx_worley_noise_vec2(
-    texcoord?: ShaderNodeObject<Node>,
+    texcoord?: NodeRepresentation,
     jitter?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
 export function mx_worley_noise_vec3(
-    texcoord?: ShaderNodeObject<Node>,
+    texcoord?: NodeRepresentation,
     jitter?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
 
-export function mx_cell_noise_float(texcoord?: ShaderNodeObject<Node>): ShaderNodeObject<Node>;
+export function mx_cell_noise_float(texcoord?: NodeRepresentation): ShaderNodeObject<Node>;
 
 export function mx_fractal_noise_float(
-    position?: ShaderNodeObject<Node>,
+    position?: NodeRepresentation,
     octaves?: NodeRepresentation,
     lacunarity?: NodeRepresentation,
     diminish?: NodeRepresentation,
     amplitude?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
 export function mx_fractal_noise_vec2(
-    position?: ShaderNodeObject<Node>,
+    position?: NodeRepresentation,
     octaves?: NodeRepresentation,
     lacunarity?: NodeRepresentation,
     diminish?: NodeRepresentation,
     amplitude?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
 export function mx_fractal_noise_vec3(
-    position?: ShaderNodeObject<Node>,
+    position?: NodeRepresentation,
     octaves?: NodeRepresentation,
     lacunarity?: NodeRepresentation,
     diminish?: NodeRepresentation,
     amplitude?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
 export function mx_fractal_noise_vec4(
-    position?: ShaderNodeObject<Node>,
+    position?: NodeRepresentation,
     octaves?: NodeRepresentation,
     lacunarity?: NodeRepresentation,
     diminish?: NodeRepresentation,
     amplitude?: NodeRepresentation,
 ): ShaderNodeObject<Node>;
 
-export { mx_hsvtorgb, mx_rgbtohsv };
+export { mx_hsvtorgb, mx_rgbtohsv, mx_srgb_texture_to_lin_rec709 };

three/examples/jsm/nodes/materialx/lib/mx_hsv.d.ts

@@ -1,6 +1,5 @@
-import { Fn } from "../../code/FunctionNode.js";
 import Node from "../../core/Node.js";
-import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../../shadernode/ShaderNode.js";
 
-export function mx_hsvtorgb(...params: Fn<[Node]>): ShaderNodeObject<Node>;
-export function mx_rgbtohsv(...params: Fn<[Node]>): ShaderNodeObject<Node>;
+export const mx_hsvtorgb: (hsv_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+export const mx_rgbtohsv: (c_immutable: NodeRepresentation) => ShaderNodeObject<Node>;

three/examples/jsm/nodes/materialx/lib/mx_noise.d.ts

@@ -1,8 +1,129 @@
-import { Fn } from "../../code/FunctionNode.js";
 import Node from "../../core/Node.js";
-import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
+import VarNode from "../../core/VarNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../../shadernode/ShaderNode.js";
 
-export function mx_perlin_noise_float(...params: Fn<[Node]>): ShaderNodeObject<Node>;
-export function mx_cell_noise_float(...params: Fn<[Node]>): ShaderNodeObject<Node>;
-export function mx_worley_noise_float(...params: Fn<[Node]>): ShaderNodeObject<Node>;
-export function mx_fractal_noise_float(...params: Fn<[Node, Node, Node, Node]>): ShaderNodeObject<Node>;
+export const mx_select: (
+    b_immutable: NodeRepresentation,
+    t_immutable: NodeRepresentation,
+    f_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+export const mx_negate_if: (
+    val_immutable: NodeRepresentation,
+    b_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+export const mx_floor: (x_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+export const mx_floorfrac: (x_immutable: NodeRepresentation, i: ShaderNodeObject<VarNode>) => ShaderNodeObject<Node>;
+export const mx_bilerp: (
+    v0_immutable: NodeRepresentation,
+    v1_immutable: NodeRepresentation,
+    v2_immutable: NodeRepresentation,
+    v3_immutable: NodeRepresentation,
+    s_immutable: NodeRepresentation,
+    t_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+export const mx_trilerp: (
+    v0_immutable: NodeRepresentation,
+    v1_immutable: NodeRepresentation,
+    v2_immutable: NodeRepresentation,
+    v3_immutable: NodeRepresentation,
+    v4_immutable: NodeRepresentation,
+    v5_immutable: NodeRepresentation,
+    v6_immutable: NodeRepresentation,
+    v7_immutable: NodeRepresentation,
+    s_immutable: NodeRepresentation,
+    t_immutable: NodeRepresentation,
+    r_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+export const mx_gradient_float: (
+    hash_immutable: NodeRepresentation,
+    x_immutable: NodeRepresentation,
+    y_immutable: NodeRepresentation,
+    z_immutable?: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+export const mx_gradient_vec3: (
+    hash_immutable: NodeRepresentation,
+    x_immutable: NodeRepresentation,
+    y_immutable: NodeRepresentation,
+    z_immutable?: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+export const mx_gradient_scale2d: (v_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+export const mx_gradient_scale3d: (v_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+export const mx_rotl32: (x_immutable: NodeRepresentation, k_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+export const mx_bjmix: (
+    a: ShaderNodeObject<VarNode>,
+    b: ShaderNodeObject<VarNode>,
+    c: ShaderNodeObject<VarNode>,
+) => ShaderNodeObject<Node>;
+export const mx_bjfinal: (
+    a_immutable: NodeRepresentation,
+    b_immutable: NodeRepresentation,
+    c_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+export const mx_bits_to_01: (bits_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+export const mx_fade: (t_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+export const mx_hash_int: (
+    x_immutable: NodeRepresentation,
+    y_immutable?: NodeRepresentation,
+    z_immutable?: NodeRepresentation,
+    xx_immutable?: NodeRepresentation,
+    yy_immutable?: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+export const mx_hash_vec3: (
+    x_immutable: NodeRepresentation,
+    y_immutable: NodeRepresentation,
+    z_immutable?: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+export const mx_perlin_noise_float: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+export const mx_perlin_noise_vec3: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+export const mx_cell_noise_float: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+export const mx_cell_noise_vec3: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+export const mx_fractal_noise_float: (
+    p_immutable: NodeRepresentation,
+    octaves_immutable: NodeRepresentation,
+    lacunarity_immutable: NodeRepresentation,
+    diminish_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+export const mx_fractal_noise_vec3: (
+    p_immutable: NodeRepresentation,
+    octaves_immutable: NodeRepresentation,
+    lacunarity_immutable: NodeRepresentation,
+    diminish_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+export const mx_fractal_noise_vec2: (
+    p_immutable: NodeRepresentation,
+    octaves_immutable: NodeRepresentation,
+    lacunarity_immutable: NodeRepresentation,
+    diminish_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+export const mx_fractal_noise_vec4: (
+    p_immutable: NodeRepresentation,
+    octaves_immutable: NodeRepresentation,
+    lacunarity_immutable: NodeRepresentation,
+    diminish_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+export const mx_worley_distance: (
+    p_immutable: NodeRepresentation,
+    x_immutable: NodeRepresentation,
+    y_immutable: NodeRepresentation,
+    z_immutable: NodeRepresentation,
+    xoff_immutable: NodeRepresentation,
+    yoff_immutable: NodeRepresentation,
+    zoff_immutable: NodeRepresentation,
+    jitter_immutable: NodeRepresentation,
+    metric_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+export const mx_worley_noise_float: (
+    p_immutable: NodeRepresentation,
+    jitter_immutable: NodeRepresentation,
+    metric_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+export const mx_worley_noise_vec2: (
+    p_immutable: NodeRepresentation,
+    jitter_immutable: NodeRepresentation,
+    metric_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+export const mx_worley_noise_vec3: (
+    p_immutable: NodeRepresentation,
+    jitter_immutable: NodeRepresentation,
+    metric_immutable: NodeRepresentation,
+) => ShaderNodeObject<Node>;

three/examples/jsm/nodes/materialx/lib/mx_transform_color.d.ts

@@ -0,0 +1,4 @@
+import Node from "../../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../../shadernode/ShaderNode.js";
+
+export const mx_srgb_texture_to_lin_rec709: (color_immutable: NodeRepresentation) => ShaderNodeObject<Node>;

three/examples/jsm/nodes/shadernode/ShaderNode.d.ts

@@ -53,8 +53,8 @@ export type Swizzable<T extends Node = Node> =
 export type ShaderNodeObject<T extends Node> =
     & T
     & {
-        [Key in keyof NodeElements]: NodeElements[Key] extends (node: T, ...args: infer Args) => infer R
-            ? (...args: Args) => R
+        [Key in keyof NodeElements]: T extends { [K in Key]: infer M } ? M
+            : NodeElements[Key] extends (node: T, ...args: infer Args) => infer R ? (...args: Args) => R
             : never;
     }
     & Swizzable<T>;
@@ -198,9 +198,12 @@ export function nodeImmutable<T>(
 ): ShaderNodeObject<ConstructedNode<T>>;
 
 export function tslFn<R extends Node = ShaderNodeObject<Node>>(jsFunc: () => R): () => R;
+export function tslFn<T extends any[], R extends Node = ShaderNodeObject<Node>>(
+    jsFunc: (args: T) => R,
+): (...args: ProxiedTuple<T>) => R;
 export function tslFn<T extends AnyObject, R extends Node = ShaderNodeObject<Node>>(
     jsFunc: (args: T) => R,
-): (args: T) => R;
+): (args: ProxiedObject<T>) => R;
 
 export function append(node: Node): Node;
 

three/examples/jsm/physics/JoltPhysics.d.ts

@@ -0,0 +1,10 @@
+import { Mesh, Object3D, Vector3Like } from "three";
+
+export interface JoltPhysicsObject {
+    addScene: (scene: Object3D) => void;
+    addMesh: (mesh: Mesh, mass?: number, restitution?: number) => void;
+    setMeshPosition: (mesh: Mesh, position: Vector3Like, index?: number) => void;
+    setMeshVelocity: (mesh: Mesh, velocity: Vector3Like, index?: number) => void;
+}
+
+export function JoltPhysics(): Promise<JoltPhysicsObject>;

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

@@ -0,0 +1,33 @@
+import { Camera, Object3D, ShaderMaterial, Texture, WebGLRenderer, WebGLRenderTarget } from "three";
+import { FullScreenQuad, Pass } from "./Pass.js";
+
+export class RenderTransitionPass extends Pass {
+    material: ShaderMaterial;
+    fsQuad: FullScreenQuad;
+
+    sceneA: Object3D;
+    cameraA: Camera;
+    sceneB: Object3D;
+    cameraB: Camera;
+
+    renderTargetA: WebGLRenderTarget;
+    renderTargetB: WebGLRenderTarget;
+
+    constructor(sceneA: Object3D, cameraA: Camera, sceneB: Object3D, cameraB: Camera);
+
+    setTransition(value: number): void;
+
+    useTexture(value: boolean): void;
+
+    setTexture(value: Texture | null): void;
+
+    setTextureThreshold(value: number): void;
+
+    setSize(width: number, height: number): void;
+
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget): void;
+
+    dispose(): void;
+
+    createMaterial(): ShaderMaterial;
+}

three/examples/jsm/renderers/common/Renderer.d.ts

@@ -97,14 +97,14 @@ export default class Renderer {
 
     clippingPlanes: readonly Plane[];
 
+    toneMappingNode: Node | null;
+
     info: Info;
 
     shadowMap: { enabled: boolean; type: ShadowMapType };
 
     xr: { enabled: boolean };
 
-    toneMappingNode?: Node;
-
     localClippingEnabled?: boolean;
 
     constructor(backend: Backend, parameters?: RendererParameters);
@@ -252,9 +252,9 @@ export default class Renderer {
 
     dispose(): void;
 
-    setRenderTarget(renderTarget: RenderTarget, activeCubeFace?: number, activeMipmapLevel?: number): void;
+    setRenderTarget(renderTarget: RenderTarget | null, activeCubeFace?: number, activeMipmapLevel?: number): void;
 
-    getRenderTarget(): RenderTarget;
+    getRenderTarget(): RenderTarget | null;
 
     setRenderObjectFunction(renderObjectFunction: () => {}): void;
 
@@ -265,6 +265,8 @@ export default class Renderer {
      */
     computeAsync(computeNodes: ComputeNode | ComputeNode[]): Promise<void>;
 
+    hasFeatureAsync(name: string): Promise<boolean>;
+
     hasFeature(name: string): boolean;
 
     copyFramebufferToTexture(framebufferTexture: FramebufferTexture): void;
@@ -277,6 +279,7 @@ export default class Renderer {
         y: number,
         width: number,
         height: number,
+        index?: number,
     ): Promise<Float32Array | Uint16Array | Uint8Array | Int8Array | Int16Array | Uint32Array | Int32Array>;
 
     renderObject(

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

@@ -31,3 +31,21 @@ export function reduceVertices<TValue>(
     func: (value: TValue, vertex: Vector3) => TValue,
     initialValue: TValue,
 ): TValue;
+
+/**
+ * @param object Object to traverse.
+ * @yields Objects that passed the filter condition.
+ */
+export function traverseGenerator(object: Object3D): Generator<Object3D, void, unknown>;
+
+/**
+ * @param object Object to traverse.
+ * @yields Objects that passed the filter condition.
+ */
+export function traverseVisibleGenerator(object: Object3D): Generator<Object3D, void, unknown>;
+
+/**
+ * @param object Object to traverse.
+ * @yields Objects that passed the filter condition.
+ */
+export function traverseAncestorsGenerator(object: Object3D): Generator<Object3D, void, unknown>;

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

@@ -1,14 +1,17 @@
-import { Mesh, Object3D, Texture, Vector3 } from "three";
+import { Loader, Mesh, Object3D, Texture, Vector3 } from "three";
+import { GLTF } from "../loaders/GLTFLoader.js";
 import { XRHandMeshModel } from "./XRHandMeshModel.js";
 
 export class OculusHandModel extends Object3D {
     controller: Object3D;
     motionController: XRHandMeshModel | null;
     envMap: Texture | null;
+    loader: Loader<GLTF> | null;
+    onLoad?: ((object: Object3D) => void) | null;
 
     mesh: Mesh | null;
 
-    constructor(controller: Object3D);
+    constructor(controller: Object3D, loader?: Loader<GLTF> | null, onLoad?: ((object: Object3D) => void) | null);
 
     updateMatrixWorld(force?: boolean): void;
 

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

@@ -1,5 +1,6 @@
-import { Group, Object3D } from "three";
+import { Group, Loader, Object3D } from "three";
 
+import { GLTF } from "../loaders/GLTFLoader.js";
 import { XRHandMeshModel } from "./XRHandMeshModel.js";
 import { XRHandPrimitiveModel, XRHandPrimitiveModelOptions } from "./XRHandPrimitiveModel.js";
 
@@ -12,9 +13,14 @@ export class XRHandModel extends Object3D {
 }
 
 export class XRHandModelFactory {
+    gltfLoader: Loader<GLTF> | null;
     path: string | null;
+    onLoad?: ((object: Object3D) => void) | null;
 
-    constructor();
+    constructor(
+        gltfLoader?: Loader<GLTF> | null,
+        onLoad?: ((object: Object3D) => void) | null,
+    );
 
     setPath(path: string | null): this;
 

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.163.0",
+    "version": "0.164.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -45,6 +45,6 @@
         "fflate": "~0.8.2",
         "meshoptimizer": "~0.18.1"
     },
-    "typesPublisherContentHash": "9f0e97bd23c86f0c0c2d025de530532214c74995254c55868863ffb17e00963a",
+    "typesPublisherContentHash": "58c6d9927d6ac01a5c65fdd023a998d808d352da3e1d79f7bb0b3b290f2d5443",
     "typeScriptVersion": "4.7"
 }

three/src/core/Object3D.d.ts

@@ -617,10 +617,11 @@ export class Object3D<TEventMap extends Object3DEventMap = Object3DEventMap> ext
     clone(recursive?: boolean): this;
 
     /**
-     * Copy the given object into this object
-     * @remarks Note: event listeners and user-defined callbacks ({@link onAfterRender | .onAfterRender} and {@link onBeforeRender | .onBeforeRender}) are not copied.
-     * @param source
-     * @param recursive If true, descendants of the object are also copied. Default `true`
+     * Copies the given object into this object.
+     * @remarks Event listeners and user-defined callbacks ({@link .onAfterRender} and {@link .onBeforeRender}) are not copied.
+     * @param object
+     * @param recursive If set to `true`, descendants of the object are copied next to the existing ones. If set to
+     * `false`, descendants are left unchanged. Default is `true`.
      */
-    copy(source: this, recursive?: boolean): this;
+    copy(object: Object3D, recursive?: boolean): this;
 }

three/src/core/RenderTarget.d.ts

@@ -16,15 +16,17 @@ export interface RenderTargetOptions {
     wrapT?: Wrapping | undefined;
     magFilter?: MagnificationTextureFilter | undefined;
     minFilter?: MinificationTextureFilter | undefined;
-    generateMipmaps?: boolean | undefined; // true;
-    format?: number | undefined; // RGBAFormat;
-    type?: TextureDataType | undefined; // UnsignedByteType;
-    anisotropy?: number | undefined; // 1;
+    generateMipmaps?: boolean | undefined; // true
+    format?: number | undefined; // RGBAFormat
+    type?: TextureDataType | undefined; // UnsignedByteType
+    anisotropy?: number | undefined; // 1
     colorSpace?: ColorSpace | undefined;
-    internalFormat?: PixelFormatGPU | null | undefined;
-    depthBuffer?: boolean | undefined; // true;
-    stencilBuffer?: boolean | undefined; // false;
-    depthTexture?: DepthTexture | undefined;
+    internalFormat?: PixelFormatGPU | null | undefined; // null
+    depthBuffer?: boolean | undefined; // true
+    stencilBuffer?: boolean | undefined; // false
+    resolveDepthBuffer?: boolean | undefined; // true
+    resolveStencilBuffer?: boolean | undefined; // true
+    depthTexture?: DepthTexture | null | undefined; // null
     /**
      * Defines the count of MSAA samples. Can only be used with WebGL 2. Default is **0**.
      * @default 0
@@ -54,14 +56,27 @@ export class RenderTarget<TTexture extends Texture | Texture[] = Texture> extend
     depthBuffer: boolean;
 
     /**
-     * @default true
+     * @default false
      */
     stencilBuffer: boolean;
 
+    /**
+     * Defines whether the depth buffer should be resolved when rendering into a multisampled render target.
+     * @default true
+     */
+    resolveDepthBuffer: boolean;
+
+    /**
+     * Defines whether the stencil buffer should be resolved when rendering into a multisampled render target.
+     * This property has no effect when {@link .resolveDepthBuffer} is set to `false`.
+     * @default true
+     */
+    resolveStencilBuffer: boolean;
+
     /**
      * @default null
      */
-    depthTexture: DepthTexture;
+    depthTexture: DepthTexture | null;
 
     /**
      * Defines the count of MSAA samples. Can only be used with WebGL 2. Default is **0**.