@types/three 0.161.1 → 0.162.0

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

@@ -1,6 +1,5 @@
-import { WebGLRenderer } from "../../../src/Three.js";
+import { WebGLRenderer } from "three";
 
-// tslint:disable-next-line:no-unnecessary-class
 export class XRButton {
     static createButton(renderer: WebGLRenderer, sessionInit?: XRSessionInit): HTMLElement;
 }

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

@@ -1,12 +1,11 @@
-import { Group, Loader, Object3D, Texture } from "../../../src/Three.js";
+import { Group, Loader, Object3D, Texture } from "three";
 import { GLTF } from "../loaders/GLTFLoader.js";
 
 export class XRControllerModel extends Object3D {
-    constructor();
-
-    motionController: any;
+    motionController: unknown;
+    envMap: Texture | null;
 
-    envMap: Texture;
+    constructor();
 
     setEnvironmentMap(envMap: Texture): XRControllerModel;
 }
@@ -18,5 +17,7 @@ export class XRControllerModelFactory {
 
     constructor(gltfLoader?: Loader<GLTF> | null, onLoad?: ((scene: Group) => void) | null);
 
+    setPath(path: string): this;
+
     createControllerModel(controller: Group): XRControllerModel;
 }

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

@@ -1,4 +1,4 @@
-import { DirectionalLight, Group, LightProbe, Object3DEventMap, Texture, WebGLRenderer } from "../../../src/Three.js";
+import { DirectionalLight, Group, LightProbe, Object3DEventMap, Texture, WebGLRenderer } from "three";
 
 export class SessionLightProbe {
     xrLight: XREstimatedLight;

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

@@ -1,4 +1,4 @@
-import { Loader, Object3D } from "../../../src/Three.js";
+import { Loader, Object3D } from "three";
 import { GLTF } from "../loaders/GLTFLoader.js";
 
 export class XRHandMeshModel {

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

@@ -1,4 +1,4 @@
-import { Group, Object3D } from "../../../src/Three.js";
+import { Group, Object3D } from "three";
 
 import { XRHandMeshModel } from "./XRHandMeshModel.js";
 import { XRHandPrimitiveModel, XRHandPrimitiveModelOptions } from "./XRHandPrimitiveModel.js";
@@ -6,16 +6,17 @@ import { XRHandPrimitiveModel, XRHandPrimitiveModelOptions } from "./XRHandPrimi
 export type XRHandModelHandedness = "left" | "right";
 
 export class XRHandModel extends Object3D {
-    constructor();
-
     motionController: XRHandPrimitiveModel | XRHandMeshModel;
+
+    constructor();
 }
 
 export class XRHandModelFactory {
+    path: string | null;
+
     constructor();
-    path: string;
 
-    setPath(path: string): XRHandModelFactory;
+    setPath(path: string | null): this;
 
     createHandModel(
         controller: Group,

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

@@ -1,4 +1,4 @@
-import { Group, Texture } from "../../../src/Three.js";
+import { Group, Texture } from "three";
 
 import { XRHandModel, XRHandModelHandedness } from "./XRHandModelFactory.js";
 

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

@@ -1,5 +1,5 @@
-import { Object3D } from "../../../src/Three.js";
+import { Object3D, WebGLRenderer } from "three";
 
 export class XRPlanes extends Object3D {
-    constructor(renderer: THREE.WebGLRenderer);
+    constructor(renderer: WebGLRenderer);
 }

three/index.d.ts

@@ -4,5 +4,3 @@
 // and released in the @types/three npm package.
 
 export * from "./src/Three";
-
-export as namespace THREE;

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.161.1",
+    "version": "0.162.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -39,11 +39,12 @@
     },
     "scripts": {},
     "dependencies": {
+        "@tweenjs/tween.js": "~23.1.1",
         "@types/stats.js": "*",
         "@types/webxr": "*",
         "fflate": "~0.6.10",
         "meshoptimizer": "~0.18.1"
     },
-    "typesPublisherContentHash": "5882e0879aa203152a1b9defa5398d28aa9fb5e7a029801cf79f35a34b0ae6a7",
+    "typesPublisherContentHash": "a113c91d5796d4919f38171319b51f9ac52586ca55d8dcbb08da2d5cfeeef84d",
     "typeScriptVersion": "4.6"
 }

three/src/Three.Legacy.d.ts

@@ -1 +1,20 @@
-export {};
+import { RenderTargetOptions } from "./core/RenderTarget.js";
+import { WebGLRenderTarget } from "./renderers/WebGLRenderTarget.js";
+import { Texture } from "./textures/Texture.js";
+
+/**
+ * @deprecated THREE.WebGLMultipleRenderTargets has been deprecated and will be removed in r172. Use THREE.WebGLRenderTarget and set the "count" parameter to enable MRT.
+ */
+export class WebGLMultipleRenderTargets extends WebGLRenderTarget<Texture[]> {
+    readonly isWebGLMultipleRenderTargets: true;
+
+    /**
+     * @deprecated THREE.WebGLMultipleRenderTargets has been deprecated and will be removed in r172. Use THREE.WebGLRenderTarget and set the "count" parameter to enable MRT.
+     * @param width The width of the render target.
+     * @param height The height of the render target.
+     * @param count The number of render targets.
+     * @param options object that holds texture parameters for an auto-generated target texture and depthBuffer/stencilBuffer booleans.
+     * For an explanation of the texture parameters see {@link Texture}.
+     */
+    constructor(width?: number, height?: number, count?: number, options?: RenderTargetOptions);
+}

three/src/Three.d.ts

@@ -207,7 +207,6 @@ export * from "./renderers/WebGL1Renderer.js";
 export * from "./renderers/WebGL3DRenderTarget.js";
 export * from "./renderers/WebGLArrayRenderTarget.js";
 export * from "./renderers/WebGLCubeRenderTarget.js";
-export * from "./renderers/WebGLMultipleRenderTargets.js";
 export * from "./renderers/WebGLRenderer.js";
 export * from "./renderers/WebGLRenderTarget.js";
 export * from "./renderers/webxr/WebXRController.js";

three/src/cameras/PerspectiveCamera.d.ts

@@ -159,7 +159,7 @@ export class PerspectiveCamera extends Camera {
      * Computes the width and height of the camera's viewable rectangle at a given distance along the viewing direction.
      * Copies the result into the target Vector2, where x is width and y is height.
      */
-    getViewSize(distance: number, minTarget: Vector2, maxTarget: Vector2): void;
+    getViewSize(distance: number, target: Vector2): Vector2;
 
     /**
      * Sets an offset in a larger frustum.

three/src/constants.d.ts

@@ -140,6 +140,7 @@ export const CineonToneMapping: 3;
 export const ACESFilmicToneMapping: 4;
 export const CustomToneMapping: 5;
 export const AgXToneMapping: 6;
+export const NeutralToneMapping: 7;
 export type ToneMapping =
     | typeof NoToneMapping
     | typeof LinearToneMapping
@@ -147,7 +148,8 @@ export type ToneMapping =
     | typeof CineonToneMapping
     | typeof ACESFilmicToneMapping
     | typeof CustomToneMapping
-    | typeof AgXToneMapping;
+    | typeof AgXToneMapping
+    | typeof NeutralToneMapping;
 
 // Bind modes
 export const AttachedBindMode: "attached";
@@ -696,20 +698,6 @@ export const TriangleStripDrawMode: 1;
 export const TriangleFanDrawMode: 2;
 export type TrianglesDrawModes = typeof TrianglesDrawMode | typeof TriangleStripDrawMode | typeof TriangleFanDrawMode;
 
-///////////////////////////////////////////////////////////////////////////////
-// Texture Encodings
-
-/** @deprecated Use {@link LinearSRGBColorSpace} or {@link NoColorSpace} in three.js r152+. */
-export const LinearEncoding: 3000;
-/** @deprecated Use {@link SRGBColorSpace} in three.js r152+. */
-export const sRGBEncoding: 3001;
-/**
- * Texture Encodings.
- * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
- * @deprecated Use {@link ColorSpace} in three.js r152+.
- */
-export type TextureEncoding = typeof LinearEncoding | typeof sRGBEncoding;
-
 ///////////////////////////////////////////////////////////////////////////////
 // Depth packing strategies
 

three/src/core/BufferAttribute.d.ts

@@ -630,35 +630,3 @@ export class Float32BufferAttribute extends BufferAttribute {
         normalized?: boolean,
     );
 }
-
-/**
- * A {@link THREE.BufferAttribute | BufferAttribute} for {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array: Float64Array}
- * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#typedarray_objects | TypedArray}
- * @see {@link THREE.BufferAttribute | BufferAttribute} for details and for inherited methods and properties.
- * @see {@link https://threejs.org/docs/index.html#api/en/core/bufferAttributeTypes/BufferAttributeTypes | Official Documentation}
- * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/BufferAttribute.js | Source}
- */
-export class Float64BufferAttribute extends BufferAttribute {
-    /**
-     * This creates a new {@link THREE.Float64BufferAttribute | Float64BufferAttribute} object.
-     * @param array This can be a typed or untyped (normal) array or an integer length. An array value will be converted to `Float64Array`.
-     * If a length is given a new `TypedArray` will created, initialized with all elements set to zero.
-     * @param itemSize the number of values of the {@link array} that should be associated with a particular vertex.
-     * For instance, if this attribute is storing a 3-component vector (such as a _position_, _normal_, or _color_),
-     * then itemSize should be `3`.
-     * @param normalized Applies to integer data only.
-     * Indicates how the underlying data in the buffer maps to the values in the GLSL code.
-     * For instance, if {@link array} is an instance of `UInt16Array`, and  {@link normalized} is true,
-     * the values `0` - `+65535` in the array data will be mapped to `0.0f` - `+1.0f` in the GLSL attribute.
-     * An `Int16Array` (signed) would map from `-32768` - `+32767` to `-1.0f` - `+1.0f`.
-     * If normalized is false, the values will be converted to floats unmodified,
-     * i.e. `32767` becomes `32767.0f`.
-     * Default `false`.
-     * @see {@link THREE.BufferAttribute | BufferAttribute}
-     */
-    constructor(
-        array: Iterable<number> | ArrayLike<number> | ArrayBuffer | number,
-        itemSize: number,
-        normalized?: boolean,
-    );
-}

three/src/core/BufferGeometry.d.ts

@@ -333,14 +333,16 @@ export class BufferGeometry<
     setFromPoints(points: Vector3[] | Vector2[]): this;
 
     /**
-     * Computes bounding box of the geometry, updating {@link boundingBox | .boundingBox} attribute.
-     * @remarks Bounding boxes aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
+     * Computes the bounding box of the geometry, and updates the {@link .boundingBox} attribute. The bounding box is
+     * not computed by the engine; it must be computed by your app. You may need to recompute the bounding box if the
+     * geometry vertices are modified.
      */
     computeBoundingBox(): void;
 
     /**
-     * Computes bounding sphere of the geometry, updating {@link boundingSphere | .boundingSphere} attribute.
-     * @remarks bounding spheres aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
+     * Computes the bounding sphere of the geometry, and updates the {@link .boundingSphere} attribute. The engine
+     * automatically computes the bounding sphere when it is needed, e.g., for ray casting or view frustum culling. You
+     * may need to recompute the bounding sphere if the geometry vertices are modified.
      */
     computeBoundingSphere(): void;
 

three/src/core/InstancedBufferAttribute.d.ts

@@ -22,4 +22,11 @@ export class InstancedBufferAttribute extends BufferAttribute {
      * @defaultValue `1`
      */
     meshPerAttribute: number;
+
+    /**
+     * Read-only flag to check if a given object is of type {@link InstancedBufferAttribute}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isInstancedBufferAttribute: true;
 }

three/src/core/Object3D.d.ts

@@ -15,8 +15,25 @@ import { Layers } from "./Layers.js";
 import { Intersection, Raycaster } from "./Raycaster.js";
 
 export interface Object3DEventMap {
+    /**
+     * Fires when the object has been added to its parent object.
+     */
     added: {};
+
+    /**
+     * Fires when the object has been removed from its parent object.
+     */
     removed: {};
+
+    /**
+     * Fires when a new child object has been added.
+     */
+    childadded: { child: Object3D };
+
+    /**
+     * Fires when a new child object has been removed.
+     */
+    childremoved: { child: Object3D };
 }
 
 /**

three/src/core/Raycaster.d.ts

@@ -2,6 +2,7 @@ import { Camera } from "../cameras/Camera.js";
 import { Ray } from "../math/Ray.js";
 import { Vector2 } from "../math/Vector2.js";
 import { Vector3 } from "../math/Vector3.js";
+import { XRTargetRaySpace } from "../renderers/webxr/WebXRController.js";
 import { Layers } from "./Layers.js";
 import { Object3D } from "./Object3D.js";
 
@@ -155,6 +156,12 @@ export class Raycaster {
      */
     setFromCamera(coords: Vector2, camera: Camera): void;
 
+    /**
+     * Updates the ray with a new origin and direction.
+     * @param controller The controller to copy the position and direction from.
+     */
+    setFromXRController(controller: XRTargetRaySpace): this;
+
     /**
      * Checks all intersection between the ray and the object with or without the descendants
      * @remarks Intersections are returned sorted by distance, closest first

three/src/core/RenderTarget.d.ts

@@ -4,7 +4,6 @@ import {
     MinificationTextureFilter,
     PixelFormatGPU,
     TextureDataType,
-    TextureEncoding,
     Wrapping,
 } from "../constants.js";
 import { Vector4 } from "../math/Vector4.js";
@@ -30,14 +29,11 @@ export interface RenderTargetOptions {
      * Defines the count of MSAA samples. Can only be used with WebGL 2. Default is **0**.
      * @default 0
      */
-    samples?: number;
-    /** @deprecated Use 'colorSpace' in three.js r152+. */
-    encoding?: TextureEncoding | undefined;
+    samples?: number | undefined;
+    count?: number | undefined;
 }
 
 export class RenderTarget<TTexture extends Texture | Texture[] = Texture> extends EventDispatcher<{ dispose: {} }> {
-    constructor(width?: number, height?: number, options?: RenderTargetOptions);
-
     readonly isRenderTarget: true;
 
     width: number;
@@ -50,7 +46,7 @@ export class RenderTarget<TTexture extends Texture | Texture[] = Texture> extend
      */
     scissorTest: boolean;
     viewport: Vector4;
-    texture: TTexture;
+    textures: TTexture[];
 
     /**
      * @default true
@@ -73,6 +69,11 @@ export class RenderTarget<TTexture extends Texture | Texture[] = Texture> extend
      */
     samples: number;
 
+    constructor(width?: number, height?: number, options?: RenderTargetOptions);
+
+    get texture(): TTexture;
+    set texture(value: TTexture);
+
     setSize(width: number, height: number, depth?: number): void;
     clone(): this;
     copy(source: RenderTarget): this;

three/src/extras/PMREMGenerator.d.ts

@@ -47,14 +47,15 @@ export class PMREMGenerator {
     fromScene(scene: Scene, sigma?: number, near?: number, far?: number): WebGLRenderTarget;
 
     /**
-     * Generates a PMREM from an equirectangular texture.
-     * @param equirectangular The equirectangular texture.
+     * Generates a PMREM from an equirectangular texture, which can be either LDR or HDR. The ideal input image size is
+     * 1k (1024 x 512), as this matches best with the 256 x 256 cubemap output. The smallest supported equirectangular
+     * image size is 64 x 32.
      */
     fromEquirectangular(equirectangular: Texture, renderTarget?: WebGLRenderTarget | null): WebGLRenderTarget;
 
     /**
-     * Generates a PMREM from an cubemap texture.
-     * @param cubemap The cubemap texture.
+     * Generates a PMREM from an cubemap texture, which can be either LDR or HDR. The ideal input cube size is
+     * 256 x 256, as this matches best with the 256 x 256 cubemap output. The smallest supported cube size is 16 x 16.
      */
     fromCubemap(cubemap: CubeTexture, renderTarget?: WebGLRenderTarget | null): WebGLRenderTarget;
 

three/src/helpers/SkeletonHelper.d.ts

@@ -2,7 +2,7 @@ import { Object3D } from "../core/Object3D.js";
 import { Matrix4 } from "../math/Matrix4.js";
 import { Bone } from "../objects/Bone.js";
 import { LineSegments } from "../objects/LineSegments.js";
-import { SkinnedMesh } from "../Three.js";
+import { SkinnedMesh } from "../objects/SkinnedMesh.js";
 
 /**
  * A helper object to assist with visualizing a {@link Skeleton | Skeleton}

three/src/lights/LightShadow.d.ts

@@ -1,10 +1,10 @@
 import { Camera } from "../cameras/Camera.js";
-import { Light } from "../lights/Light.js";
+import { Frustum } from "../math/Frustum.js";
 import { Matrix4 } from "../math/Matrix4.js";
 import { Vector2 } from "../math/Vector2.js";
 import { Vector4 } from "../math/Vector4.js";
 import { WebGLRenderTarget } from "../renderers/WebGLRenderTarget.js";
-import { Frustum } from "../Three.js";
+import { Light } from "./Light.js";
 
 /**
  * Serves as a base class for the other shadow classes.

three/src/materials/MeshBasicMaterial.d.ts

@@ -1,7 +1,9 @@
 import { Combine } from "../constants.js";
 import { Color, ColorRepresentation } from "../math/Color.js";
+import { Euler } from "../math/Euler.js";
 import { Texture } from "../textures/Texture.js";
 import { Material, MaterialParameters } from "./Material.js";
+
 /**
  * parameters is an object with one or more properties defining the material's appearance.
  */
@@ -17,6 +19,7 @@ export interface MeshBasicMaterialParameters extends MaterialParameters {
     alphaMap?: Texture | null | undefined;
     fog?: boolean | undefined;
     envMap?: Texture | null | undefined;
+    envMapRotation?: Euler | undefined;
     combine?: Combine | undefined;
     reflectivity?: number | undefined;
     refractionRatio?: number | undefined;
@@ -86,6 +89,11 @@ export class MeshBasicMaterial extends Material {
      */
     envMap: Texture | null;
 
+    /**
+     * The rotation of the environment map in radians. Default is `(0,0,0)`.
+     */
+    envMapRotation: Euler;
+
     /**
      * @default THREE.MultiplyOperation
      */

three/src/materials/MeshLambertMaterial.d.ts

@@ -1,7 +1,8 @@
 import { Combine, NormalMapTypes } from "../constants.js";
 import { Color, ColorRepresentation } from "../math/Color.js";
+import { Euler } from "../math/Euler.js";
+import { Vector2 } from "../math/Vector2.js";
 import { Texture } from "../textures/Texture.js";
-import { Vector2 } from "../Three.js";
 import { Material, MaterialParameters } from "./Material.js";
 
 export interface MeshLambertMaterialParameters extends MaterialParameters {
@@ -25,6 +26,7 @@ export interface MeshLambertMaterialParameters extends MaterialParameters {
     specularMap?: Texture | null | undefined;
     alphaMap?: Texture | null | undefined;
     envMap?: Texture | null | undefined;
+    envMapRotation?: Euler | undefined;
     combine?: Combine | undefined;
     reflectivity?: number | undefined;
     refractionRatio?: number | undefined;
@@ -152,6 +154,11 @@ export class MeshLambertMaterial extends Material {
      */
     envMap: Texture | null;
 
+    /**
+     * The rotation of the environment map in radians. Default is `(0,0,0)`.
+     */
+    envMapRotation: Euler;
+
     /**
      * @default THREE.MultiplyOperation
      */

three/src/materials/MeshPhongMaterial.d.ts

@@ -1,5 +1,6 @@
 import { Combine, NormalMapTypes } from "../constants.js";
 import { Color, ColorRepresentation } from "../math/Color.js";
+import { Euler } from "../math/Euler.js";
 import { Vector2 } from "../math/Vector2.js";
 import { Texture } from "../textures/Texture.js";
 import { Material, MaterialParameters } from "./Material.js";
@@ -29,6 +30,7 @@ export interface MeshPhongMaterialParameters extends MaterialParameters {
     specularMap?: Texture | null | undefined;
     alphaMap?: Texture | null | undefined;
     envMap?: Texture | null | undefined;
+    envMapRotation?: Euler | undefined;
     combine?: Combine | undefined;
     reflectivity?: number | undefined;
     refractionRatio?: number | undefined;
@@ -165,6 +167,11 @@ export class MeshPhongMaterial extends Material {
      */
     envMap: Texture | null;
 
+    /**
+     * The rotation of the environment map in radians. Default is `(0,0,0)`.
+     */
+    envMapRotation: Euler;
+
     /**
      * @default THREE.MultiplyOperation
      */

three/src/materials/MeshStandardMaterial.d.ts

@@ -1,5 +1,6 @@
 import { NormalMapTypes } from "../constants.js";
 import { Color, ColorRepresentation } from "../math/Color.js";
+import { Euler } from "../math/Euler.js";
 import { Vector2 } from "../math/Vector2.js";
 import { Texture } from "../textures/Texture.js";
 import { Material, MaterialParameters } from "./Material.js";
@@ -28,6 +29,7 @@ export interface MeshStandardMaterialParameters extends MaterialParameters {
     metalnessMap?: Texture | null | undefined;
     alphaMap?: Texture | null | undefined;
     envMap?: Texture | null | undefined;
+    envMapRotation?: Euler | undefined;
     envMapIntensity?: number | undefined;
     wireframe?: boolean | undefined;
     wireframeLinewidth?: number | undefined;
@@ -170,6 +172,11 @@ export class MeshStandardMaterial extends Material {
      */
     envMap: Texture | null;
 
+    /**
+     * The rotation of the environment map in radians. Default is `(0,0,0)`.
+     */
+    envMapRotation: Euler;
+
     /**
      * @default 1
      */

three/src/objects/InstancedMesh.d.ts

@@ -6,6 +6,7 @@ import { Box3 } from "../math/Box3.js";
 import { Color } from "../math/Color.js";
 import { Matrix4 } from "../math/Matrix4.js";
 import { Sphere } from "../math/Sphere.js";
+import { DataTexture } from "../textures/DataTexture.js";
 import { Mesh } from "./Mesh.js";
 
 export interface InstancedMeshEventMap extends Object3DEventMap {
@@ -83,14 +84,22 @@ export class InstancedMesh<
     instanceMatrix: InstancedBufferAttribute;
 
     /**
-     * Computes bounding box of the all instances, updating {@link boundingBox | .boundingBox} attribute.
-     * @remarks Bounding boxes aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
+     * Represents the morph target weights of all instances. You have to set its {@link .needsUpdate} flag to true if
+     * you modify instanced data via {@link .setMorphAt}.
+     */
+    morphTexture: DataTexture | null;
+
+    /**
+     * Computes the bounding box of the instanced mesh, and updates the {@link .boundingBox} attribute. The bounding box
+     * is not computed by the engine; it must be computed by your app. You may need to recompute the bounding box if an
+     * instance is transformed via {@link .setMatrixAt()}.
      */
     computeBoundingBox(): void;
 
     /**
-     * Computes bounding sphere of the all instances, updating {@link boundingSphere | .boundingSphere} attribute.
-     * @remarks bounding spheres aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
+     * Computes the bounding sphere of the instanced mesh, and updates the {@link .boundingSphere} attribute. The engine
+     * automatically computes the bounding sphere when it is needed, e.g., for ray casting or view frustum culling. You
+     * may need to recompute the bounding sphere if an instance is transformed via [page:.setMatrixAt]().
      */
     computeBoundingSphere(): void;
 
@@ -117,6 +126,13 @@ export class InstancedMesh<
      */
     getMatrixAt(index: number, matrix: Matrix4): void;
 
+    /**
+     * Get the morph target weights of the defined instance.
+     * @param index The index of an instance. Values have to be in the range [0, count].
+     * @param mesh The {@link .morphTargetInfluences} property of this mesh will be filled with the morph target weights of the defined instance.
+     */
+    getMorphAt(index: number, mesh: Mesh): void;
+
     /**
      * Sets the given local transformation matrix to the defined instance.
      * @remarks
@@ -126,6 +142,14 @@ export class InstancedMesh<
      */
     setMatrixAt(index: number, matrix: Matrix4): void;
 
+    /**
+     * Sets the morph target weights to the defined instance. Make sure you set {@link .morphTexture}{@link .needsUpdate}
+     * to true after updating all the influences.
+     * @param index The index of an instance. Values have to be in the range [0, count].
+     * @param mesh A mesh with {@link .morphTargetInfluences} property containing the morph target weights of a single instance.
+     */
+    setMorphAt(index: number, mesh: Mesh): void;
+
     /**
      * No effect in {@link InstancedMesh}.
      * @ignore

three/src/objects/SkinnedMesh.d.ts

@@ -117,19 +117,16 @@ export class SkinnedMesh<
     bind(skeleton: Skeleton, bindMatrix?: Matrix4): void;
 
     /**
-     * Computes the bounding box, updating {@link boundingBox | .boundingBox} attribute.
-     * @remarks
-     * Bounding boxes aren't computed by default. They need to be explicitly computed, otherwise they are `null`. If an
-     * instance of SkinnedMesh is animated, this method should be called per frame to compute a correct bounding box.
+     * Computes the bounding box of the skinned mesh, and updates the {@link .boundingBox} attribute. The bounding box
+     * is not computed by the engine; it must be computed by your app. If the skinned mesh is animated, the bounding box
+     * should be recomputed per frame.
      */
     computeBoundingBox(): void;
 
     /**
-     * Computes the bounding sphere, updating {@link boundingSphere | .boundingSphere} attribute.
-     * @remarks
-     * Bounding spheres aren't computed by default. They need to be explicitly computed, otherwise they are `null`. If
-     * an instance of SkinnedMesh is animated, this method should be called per frame to compute a correct bounding
-     * sphere.
+     * Computes the bounding sphere of the skinned mesh, and updates the {@link .boundingSphere} attribute. The bounding
+     * sphere is automatically computed by the engine when it is needed, e.g., for ray casting and view frustum culling.
+     * If the skinned mesh is animated, the bounding sphere should be recomputed per frame.
      */
     computeBoundingSphere(): void;