@types/three 0.162.0 → 0.164.0

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/pmrem/PMREMNode.d.ts

@@ -0,0 +1,20 @@
+import { Texture } from "three";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class PMREMNode extends TempNode {
+    uvNode: Node | null;
+    levelNode: Node | null;
+
+    constructor(value: Texture, uvNode?: Node | null, levelNode?: Node | null);
+
+    set value(value: Texture);
+    get value(): Texture;
+}
+
+export const pmremTexture: (
+    value: Texture,
+    uvNode?: NodeRepresentation,
+    levelNode?: NodeRepresentation,
+) => ShaderNodeObject<PMREMNode>;

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/objects/QuadMesh.d.ts

@@ -1,15 +1,12 @@
-import { Material } from "three";
+import { Material, Mesh, OrthographicCamera } from "three";
 import Renderer from "../renderers/common/Renderer.js";
 
-export default class QuadMesh {
-    constructor(material?: Material | null);
+export default class QuadMesh extends Mesh {
+    camera: OrthographicCamera;
 
-    dispose(): void;
+    constructor(material?: Material | null);
 
     renderAsync(renderer: Renderer): Promise<void>;
 
-    get material(): Material;
-    set material(value: Material);
-
-    get render(): (renderer: Renderer) => Promise<void>;
+    render(renderer: Renderer): void;
 }

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

@@ -6,19 +6,15 @@ export default class Info {
     frame: number;
     calls: number;
 
-    render: { calls: number; drawCalls: number; triangles: number; points: number; lines: number };
+    render: { calls: number; drawCalls: number; triangles: number; points: number; lines: number; timestamp: number };
 
-    compute: { calls: number; computeCalls: number };
+    compute: { calls: number; computeCalls: number; timestamp: number };
 
     memory: { geometries: number; textures: number };
 
-    timestamp: { compute: number; render: number };
-
     update(object: Object3D, count: number, instanceCount: number): void;
 
-    updateTimestamp(type: keyof typeof this.timestamp, time: number): void;
-
-    resetCompute(): void;
+    updateTimestamp(type: "render" | "compute", time: number): void;
 
     reset(): void;
 

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

@@ -7,5 +7,7 @@ export default class PostProcessing {
 
     constructor(renderer: Renderer, outputNode?: Node);
 
-    render(): Promise<void>;
+    render(): void;
+
+    renderAsync(): Promise<void>;
 }

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

@@ -12,6 +12,7 @@ import {
     RenderTarget,
     Scene,
     ShadowMapType,
+    Texture,
     ToneMapping,
     Vector2,
     Vector4,
@@ -90,20 +91,20 @@ export default class Renderer {
     depth: boolean;
 
     /**
-     * @default true
+     * @default false
      */
     stencil: boolean;
 
     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);
@@ -251,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;
 
@@ -264,16 +265,21 @@ export default class Renderer {
      */
     computeAsync(computeNodes: ComputeNode | ComputeNode[]): Promise<void>;
 
+    hasFeatureAsync(name: string): Promise<boolean>;
+
     hasFeature(name: string): boolean;
 
     copyFramebufferToTexture(framebufferTexture: FramebufferTexture): void;
 
+    copyTextureToTexture(position: Vector2, srcTexture: Texture, dstTexture: Texture, level?: number): void;
+
     readRenderTargetPixelsAsync(
         renderTarget: RenderTarget,
         x: number,
         y: number,
         width: number,
         height: number,
+        index?: number,
     ): Promise<Float32Array | Uint16Array | Uint8Array | Int8Array | Int16Array | Uint32Array | Int32Array>;
 
     renderObject(

three/examples/jsm/renderers/common/extras/PMREMGenerator.d.ts

@@ -0,0 +1,8 @@
+import { RenderTarget, Scene } from "three";
+import Renderer from "../Renderer.js";
+
+export default class PMREMGenerator {
+    constructor(renderer: Renderer);
+
+    fromScene(scene: Scene, sigma?: number, near?: number, far?: number): RenderTarget;
+}

three/examples/jsm/renderers/webgl/WebGLBackend.d.ts

@@ -1,6 +1,10 @@
 import { CoordinateSystem } from "three";
 import Backend, { BackendParameters } from "../common/Backend.js";
 
+export interface WebGLBackendParameters extends BackendParameters {
+    trackTimestamp?: boolean | undefined;
+}
+
 export default class WebGLBackend extends Backend {
     constructor(parameters?: BackendParameters);
 

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

@@ -3,4 +3,4 @@
 // Periodically, the updates from the repository are pushed to DefinitelyTyped
 // and released in the @types/three npm package.
 
-export * from "./src/Three";
+export * from "./src/Three.js";

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.162.0",
+    "version": "0.164.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -42,9 +42,9 @@
         "@tweenjs/tween.js": "~23.1.1",
         "@types/stats.js": "*",
         "@types/webxr": "*",
-        "fflate": "~0.6.10",
+        "fflate": "~0.8.2",
         "meshoptimizer": "~0.18.1"
     },
-    "typesPublisherContentHash": "a113c91d5796d4919f38171319b51f9ac52586ca55d8dcbb08da2d5cfeeef84d",
-    "typeScriptVersion": "4.6"
+    "typesPublisherContentHash": "58c6d9927d6ac01a5c65fdd023a998d808d352da3e1d79f7bb0b3b290f2d5443",
+    "typeScriptVersion": "4.7"
 }

three/src/Three.d.ts

@@ -203,7 +203,6 @@ export * from "./renderers/webgl/WebGLTextures.js";
 export * from "./renderers/webgl/WebGLUniforms.js";
 export * from "./renderers/webgl/WebGLUniformsGroups.js";
 export { WebGLUtils } from "./renderers/webgl/WebGLUtils.js";
-export * from "./renderers/WebGL1Renderer.js";
 export * from "./renderers/WebGL3DRenderTarget.js";
 export * from "./renderers/WebGLArrayRenderTarget.js";
 export * from "./renderers/WebGLCubeRenderTarget.js";

three/src/cameras/Camera.d.ts

@@ -3,6 +3,7 @@ import { Layers } from "../core/Layers.js";
 import { Object3D } from "../core/Object3D.js";
 import { Matrix4 } from "../math/Matrix4.js";
 import { Vector3 } from "../math/Vector3.js";
+import { Vector4 } from "../math/Vector4.js";
 
 /**
  * Abstract base class for cameras
@@ -62,6 +63,8 @@ export class Camera extends Object3D {
 
     coordinateSystem: CoordinateSystem;
 
+    viewport?: Vector4;
+
     /**
      * Returns a {@link THREE.Vector3 | Vector3} representing the world space direction in which the {@link Camera} is looking.
      * @remarks Note: A {@link Camera} looks down its local, negative z-axis.

three/src/constants.d.ts

@@ -336,6 +336,7 @@ export const HalfFloatType: 1016;
 export const UnsignedShort4444Type: 1017;
 export const UnsignedShort5551Type: 1018;
 export const UnsignedInt248Type: 1020;
+export const UnsignedInt5999Type: 35902;
 
 export type AttributeGPUType = typeof FloatType | typeof IntType;
 
@@ -356,7 +357,8 @@ export type TextureDataType =
     | typeof HalfFloatType
     | typeof UnsignedShort4444Type
     | typeof UnsignedShort5551Type
-    | typeof UnsignedInt248Type;
+    | typeof UnsignedInt248Type
+    | typeof UnsignedInt5999Type;
 
 ///////////////////////////////////////////////////////////////////////////////
 // Pixel formats
@@ -364,7 +366,9 @@ export type TextureDataType =
 /** {@link AlphaFormat} discards the red, green and blue components and reads just the alpha component. */
 export const AlphaFormat: 1021;
 
-/** {@link RGBAFormat} discards the green and blue components and reads just the red component. (Can only be used with a WebGL 2 rendering context). */
+export const RGBFormat: 1022;
+
+/** {@link RGBAFormat} is the default and reads the red, green, blue and alpha components. */
 export const RGBAFormat: 1023;
 
 /**
@@ -395,27 +399,23 @@ export const DepthStencilFormat: 1027;
 
 /**
  * {@link RedFormat} discards the green and blue components and reads just the red component.
- * @remarks Can only be used with a WebGL 2 rendering context.
  */
 export const RedFormat: 1028;
 
 /**
  * {@link RedIntegerFormat} discards the green and blue components and reads just the red component.
  * The texels are read as integers instead of floating point.
- * @remarks Can only be used with a WebGL 2 rendering context.
  */
 export const RedIntegerFormat: 1029;
 
 /**
  * {@link RGFormat} discards the alpha, and blue components and reads the red, and green components.
- * @remarks Can only be used with a WebGL 2 rendering context.
  */
 export const RGFormat: 1030;
 
 /**
  * {@link RGIntegerFormat} discards the alpha, and blue components and reads the red, and green components.
  * The texels are read as integers instead of floating point.
- * @remarks Can only be used with a WebGL 2 rendering context.
  */
 export const RGIntegerFormat: 1031;
 
@@ -425,35 +425,15 @@ export const RGIntegerFormat: 1031;
  */
 export const RGBAIntegerFormat: 1033;
 
-export const _SRGBAFormat: 1035; // fallback for WebGL 1
-
-/**
- * Texture Pixel Formats Modes. Compatible only with {@link WebGLRenderingContext | WebGL 1 Rendering Context}.
- * @remarks Note that the texture must have the correct {@link THREE.Texture.type} set, as described in  {@link TextureDataType}.
- * @see {@link WebGLRenderingContext.texImage2D} for details.
- * @see {@link WebGL2PixelFormat} and {@link PixelFormat}
- * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
- */
-export type WebGL1PixelFormat =
-    | typeof AlphaFormat
-    | typeof LuminanceFormat
-    | typeof LuminanceAlphaFormat
-    | typeof DepthFormat
-    | typeof DepthStencilFormat
-    | typeof RedFormat
-    | typeof RedIntegerFormat
-    | typeof RGFormat
-    | typeof _SRGBAFormat;
-
 /**
- * Texture Pixel Formats Modes. Compatible only with {@link WebGL2RenderingContext | WebGL 2 Rendering Context}.
+ * All Texture Pixel Formats Modes.
  * @remarks Note that the texture must have the correct {@link THREE.Texture.type} set, as described in  {@link TextureDataType}.
  * @see {@link WebGLRenderingContext.texImage2D} for details.
- * @see {@link WebGL2PixelFormat} and {@link PixelFormat}
  * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
  */
-export type WebGL2PixelFormat =
+export type PixelFormat =
     | typeof AlphaFormat
+    | typeof RGBFormat
     | typeof RGBAFormat
     | typeof LuminanceFormat
     | typeof LuminanceAlphaFormat
@@ -463,17 +443,7 @@ export type WebGL2PixelFormat =
     | typeof RedIntegerFormat
     | typeof RGFormat
     | typeof RGIntegerFormat
-    | typeof RGBAIntegerFormat
-    | typeof _SRGBAFormat;
-
-/**
- * All Texture Pixel Formats Modes.
- * @remarks Note that the texture must have the correct {@link THREE.Texture.type} set, as described in  {@link TextureDataType}.
- * @see {@link WebGLRenderingContext.texImage2D} for details.
- * @see {@link WebGL1PixelFormat} and {@link WebGL2PixelFormat}
- * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
- */
-export type PixelFormat = WebGL1PixelFormat | WebGL2PixelFormat;
+    | typeof RGBAIntegerFormat;
 
 /**
  * All Texture Pixel Formats Modes for {@link THREE.DepthTexture}.

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;
 }