@types/three 0.161.2 → 0.163.0

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
@@ -138,5 +162,5 @@ export class InstancedMesh<
      * @remarks
      * Call this method whenever this instance is no longer used in your app.
      */
-    dispose(): void;
+    dispose(): this;
 }

three/src/objects/SkinnedMesh.d.ts

@@ -11,8 +11,6 @@ import { Skeleton } from "./Skeleton.js";
 
 /**
  * A mesh that has a {@link THREE.Skeleton | Skeleton} with {@link Bone | bones} that can then be used to animate the vertices of the geometry.
- * @remarks
- * {@link SkinnedMesh} can only be used with WebGL 2.
  * @example
  * ```typescript
  * const geometry = new THREE.CylinderGeometry(5, 5, 5, 5, 15, 5, 30);
@@ -117,19 +115,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;
 

three/src/renderers/WebGL3DRenderTarget.d.ts

@@ -1,5 +1,6 @@
+import { RenderTargetOptions } from "../core/RenderTarget.js";
 import { Data3DTexture } from "../textures/Data3DTexture.js";
-import { WebGLRenderTarget, WebGLRenderTargetOptions } from "./WebGLRenderTarget.js";
+import { WebGLRenderTarget } from "./WebGLRenderTarget.js";
 
 /**
  * Represents a three-dimensional render target.
@@ -14,17 +15,15 @@ export class WebGL3DRenderTarget extends WebGLRenderTarget {
      * @param options optional object that holds texture parameters for an auto-generated target texture and
      * depthBuffer/stencilBuffer booleans. See {@link WebGLRenderTarget} for details.
      */
-    constructor(width?: number, height?: number, depth?: number, options?: WebGLRenderTargetOptions);
+    constructor(width?: number, height?: number, depth?: number, options?: RenderTargetOptions);
 
-    /**
-     * The depth of the render target.
-     */
-    depth: number;
+    textures: Data3DTexture[];
 
     /**
      * The texture property is overwritten with an instance of {@link Data3DTexture}.
      */
-    texture: Data3DTexture;
+    get texture(): Data3DTexture;
+    set texture(value: Data3DTexture);
 
     readonly isWebGL3DRenderTarget: true;
 }

three/src/renderers/WebGLArrayRenderTarget.d.ts

@@ -1,5 +1,6 @@
+import { RenderTargetOptions } from "../core/RenderTarget.js";
 import { DataArrayTexture } from "../textures/DataArrayTexture.js";
-import { WebGLRenderTarget, WebGLRenderTargetOptions } from "./WebGLRenderTarget.js";
+import { WebGLRenderTarget } from "./WebGLRenderTarget.js";
 
 /**
  * This type of render target represents an array of textures.
@@ -14,17 +15,15 @@ export class WebGLArrayRenderTarget extends WebGLRenderTarget {
      * @param options optional object that holds texture parameters for an auto-generated target texture and
      * depthBuffer/stencilBuffer booleans. See {@link WebGLRenderTarget} for details.
      */
-    constructor(width?: number, height?: number, depth?: number, options?: WebGLRenderTargetOptions);
+    constructor(width?: number, height?: number, depth?: number, options?: RenderTargetOptions);
 
-    /**
-     * The depth of the render target.
-     */
-    depth: number;
+    textures: DataArrayTexture[];
 
     /**
      * The texture property is overwritten with an instance of {@link DataArrayTexture}.
      */
-    texture: DataArrayTexture;
+    get texture(): DataArrayTexture;
+    set texture(value: DataArrayTexture);
 
     readonly isWebGLArrayRenderTarget: true;
 }

three/src/renderers/WebGLCubeRenderTarget.d.ts

@@ -1,12 +1,16 @@
+import { RenderTargetOptions } from "../core/RenderTarget.js";
 import { CubeTexture } from "../textures/CubeTexture.js";
 import { Texture } from "../textures/Texture.js";
 import { WebGLRenderer } from "./WebGLRenderer.js";
-import { WebGLRenderTarget, WebGLRenderTargetOptions } from "./WebGLRenderTarget.js";
+import { WebGLRenderTarget } from "./WebGLRenderTarget.js";
 
 export class WebGLCubeRenderTarget extends WebGLRenderTarget {
-    constructor(size?: number, options?: WebGLRenderTargetOptions);
+    constructor(size?: number, options?: RenderTargetOptions);
 
-    texture: CubeTexture;
+    textures: CubeTexture[];
+
+    get texture(): CubeTexture;
+    set texture(value: CubeTexture);
 
     fromEquirectangularTexture(renderer: WebGLRenderer, texture: Texture): this;
 

three/src/renderers/WebGLRenderTarget.d.ts

@@ -1,11 +1,8 @@
 import { RenderTarget, RenderTargetOptions } from "../core/RenderTarget.js";
 import { Texture } from "../textures/Texture.js";
 
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface WebGLRenderTargetOptions extends RenderTargetOptions {}
-
 export class WebGLRenderTarget<TTexture extends Texture | Texture[] = Texture> extends RenderTarget<TTexture> {
-    constructor(width?: number, height?: number, options?: WebGLRenderTargetOptions);
+    constructor(width?: number, height?: number, options?: RenderTargetOptions);
 
     readonly isWebGLRenderTarget: true;
 }

three/src/renderers/WebGLRenderer.d.ts

@@ -1,12 +1,5 @@
 import { Camera } from "../cameras/Camera.js";
-import {
-    ColorSpace,
-    CullFace,
-    ShadowMapType,
-    TextureEncoding,
-    ToneMapping,
-    WebGLCoordinateSystem,
-} from "../constants.js";
+import { ColorSpace, CullFace, ShadowMapType, ToneMapping, WebGLCoordinateSystem } from "../constants.js";
 import { BufferGeometry } from "../core/BufferGeometry.js";
 import { Object3D } from "../core/Object3D.js";
 import { Material } from "../materials/Material.js";
@@ -28,7 +21,6 @@ import { WebGLProperties } from "./webgl/WebGLProperties.js";
 import { WebGLRenderLists } from "./webgl/WebGLRenderLists.js";
 import { WebGLShadowMap } from "./webgl/WebGLShadowMap.js";
 import { WebGLState } from "./webgl/WebGLState.js";
-import { WebGLMultipleRenderTargets } from "./WebGLMultipleRenderTargets.js";
 import { WebGLRenderTarget } from "./WebGLRenderTarget.js";
 import { WebXRManager } from "./webxr/WebXRManager.js";
 
@@ -73,7 +65,7 @@ export interface WebGLRendererParameters {
     antialias?: boolean | undefined;
 
     /**
-     * default is true.
+     * default is false.
      */
     stencil?: boolean | undefined;
 
@@ -185,7 +177,7 @@ export class WebGLRenderer implements Renderer {
     /**
      * @default []
      */
-    clippingPlanes: readonly Plane[];
+    clippingPlanes: Plane[];
 
     /**
      * @default false
@@ -194,13 +186,6 @@ export class WebGLRenderer implements Renderer {
 
     extensions: WebGLExtensions;
 
-    /**
-     * Default is LinearEncoding.
-     * @default THREE.LinearEncoding
-     * @deprecated Use {@link WebGLRenderer.outputColorSpace .outputColorSpace} in three.js r152+.
-     */
-    outputEncoding: TextureEncoding;
-
     /**
      * Color space used for output to HTMLCanvasElement. Supported values are
      * {@link SRGBColorSpace} and {@link LinearSRGBColorSpace}.
@@ -425,13 +410,13 @@ export class WebGLRenderer implements Renderer {
      * @param activeMipmapLevel Specifies the active mipmap level.
      */
     setRenderTarget(
-        renderTarget: WebGLRenderTarget | WebGLMultipleRenderTargets | null,
+        renderTarget: WebGLRenderTarget | WebGLRenderTarget<Texture[]> | null,
         activeCubeFace?: number,
         activeMipmapLevel?: number,
     ): void;
 
     readRenderTargetPixels(
-        renderTarget: WebGLRenderTarget | WebGLMultipleRenderTargets,
+        renderTarget: WebGLRenderTarget | WebGLRenderTarget<Texture[]>,
         x: number,
         y: number,
         width: number,

three/src/renderers/shaders/UniformsLib.d.ts

@@ -23,6 +23,7 @@ export const UniformsLib: {
     };
     envmap: {
         envMap: IUniform<unknown>;
+        envMapRotation: IUniform<Matrix3>;
         flipEnvMap: IUniform<number>;
         reflectivity: IUniform<number>;
         ior: IUniform<number>;

three/src/renderers/webgl/WebGLAttributes.d.ts

@@ -1,10 +1,9 @@
 import { BufferAttribute } from "../../core/BufferAttribute.js";
 import { GLBufferAttribute } from "../../core/GLBufferAttribute.js";
 import { InterleavedBufferAttribute } from "../../core/InterleavedBufferAttribute.js";
-import { WebGLCapabilities } from "./WebGLCapabilities.js";
 
 export class WebGLAttributes {
-    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, capabilities: WebGLCapabilities);
+    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext);
 
     get(attribute: BufferAttribute | InterleavedBufferAttribute | GLBufferAttribute):
         | {

three/src/renderers/webgl/WebGLBindingStates.d.ts

@@ -3,17 +3,10 @@ import { BufferGeometry } from "../../core/BufferGeometry.js";
 import { Object3D } from "../../core/Object3D.js";
 import { Material } from "../../materials/Material.js";
 import { WebGLAttributes } from "./WebGLAttributes.js";
-import { WebGLCapabilities } from "./WebGLCapabilities.js";
-import { WebGLExtensions } from "./WebGLExtensions.js";
 import { WebGLProgram } from "./WebGLProgram.js";
 
 export class WebGLBindingStates {
-    constructor(
-        gl: WebGLRenderingContext,
-        extensions: WebGLExtensions,
-        attributes: WebGLAttributes,
-        capabilities: WebGLCapabilities,
-    );
+    constructor(gl: WebGLRenderingContext, attributes: WebGLAttributes);
 
     setup(
         object: Object3D,

three/src/renderers/webgl/WebGLBufferRenderer.d.ts

@@ -1,5 +1,3 @@
-// Renderers / WebGL /////////////////////////////////////////////////////////////////////
-import { WebGLCapabilities } from "./WebGLCapabilities.js";
 import { WebGLExtensions } from "./WebGLExtensions.js";
 import { WebGLInfo } from "./WebGLInfo.js";
 
@@ -8,7 +6,6 @@ export class WebGLBufferRenderer {
         gl: WebGLRenderingContext,
         extensions: WebGLExtensions,
         info: WebGLInfo,
-        capabilities: WebGLCapabilities,
     );
 
     setMode: (value: any) => void;

three/src/renderers/webgl/WebGLCapabilities.d.ts

@@ -7,22 +7,24 @@ export class WebGLCapabilities {
     constructor(gl: WebGLRenderingContext, extensions: any, parameters: WebGLCapabilitiesParameters);
 
     readonly isWebGL2: boolean;
-    readonly drawBuffers: boolean;
+
+    getMaxAnisotropy: () => number;
+    getMaxPrecision: (precision: string) => string;
+
     precision: string;
     logarithmicDepthBuffer: boolean;
+
     maxTextures: number;
     maxVertexTextures: number;
     maxTextureSize: number;
     maxCubemapSize: number;
+
     maxAttributes: number;
     maxVertexUniforms: number;
     maxVaryings: number;
     maxFragmentUniforms: number;
+
     vertexTextures: boolean;
-    floatFragmentTextures: boolean;
-    floatVertexTextures: boolean;
-    maxSamples: number;
 
-    getMaxAnisotropy(): number;
-    getMaxPrecision(precision: string): string;
+    maxSamples: number;
 }

three/src/renderers/webgl/WebGLCubeUVMaps.d.ts

@@ -1,4 +1,5 @@
-import { Texture, WebGLRenderer } from "../../Three.js";
+import { Texture } from "../../textures/Texture.js";
+import { WebGLRenderer } from "../WebGLRenderer.js";
 
 export class WebGLCubeUVMaps {
     constructor(renderer: WebGLRenderer);

three/src/renderers/webgl/WebGLExtensions.d.ts

@@ -1,9 +1,7 @@
-import { WebGLCapabilities } from "./WebGLCapabilities.js";
-
 export class WebGLExtensions {
     constructor(gl: WebGLRenderingContext);
 
     has(name: string): boolean;
-    init(capabilities: WebGLCapabilities): void;
+    init(): void;
     get(name: string): any;
 }

three/src/renderers/webgl/WebGLIndexedBufferRenderer.d.ts

@@ -1,5 +1,5 @@
 export class WebGLIndexedBufferRenderer {
-    constructor(gl: WebGLRenderingContext, extensions: any, info: any, capabilities: any);
+    constructor(gl: WebGLRenderingContext, extensions: any, info: any);
 
     setMode: (value: any) => void;
     setIndex: (index: any) => void;

three/src/renderers/webgl/WebGLLights.d.ts

@@ -1,4 +1,3 @@
-import { WebGLCapabilities } from "./WebGLCapabilities.js";
 import { WebGLExtensions } from "./WebGLExtensions.js";
 
 export interface WebGLLightsState {
@@ -40,7 +39,7 @@ export interface WebGLLightsState {
 }
 
 export class WebGLLights {
-    constructor(extensions: WebGLExtensions, capabilities: WebGLCapabilities);
+    constructor(extensions: WebGLExtensions);
 
     state: WebGLLightsState;
 

three/src/renderers/webgl/WebGLPrograms.d.ts

@@ -22,8 +22,6 @@ import { WebGLLightsState } from "./WebGLLights.js";
 import { WebGLProgram } from "./WebGLProgram.js";
 
 export interface WebGLProgramParameters {
-    isWebGL2: boolean;
-
     shaderID: string;
     shaderType: string;
     shaderName: string;
@@ -43,6 +41,7 @@ export interface WebGLProgramParameters {
     batching: boolean;
     instancing: boolean;
     instancingColor: boolean;
+    instancingMorph: boolean;
 
     supportsVertexTextures: boolean;
     outputColorSpace: ColorSpace;
@@ -199,16 +198,9 @@ export interface WebGLProgramParameters {
 
     index0AttributeName: string | undefined;
 
-    extensionDerivatives: boolean;
-    extensionFragDepth: boolean;
-    extensionDrawBuffers: boolean;
-    extensionShaderTextureLOD: boolean;
     extensionClipCullDistance: boolean;
     extensionMultiDraw: boolean;
 
-    rendererExtensionFragDepth: boolean;
-    rendererExtensionDrawBuffers: boolean;
-    rendererExtensionShaderTextureLod: boolean;
     rendererExtensionParallelShaderCompile: boolean;
 
     customProgramCacheKey: string;

three/src/renderers/webgl/WebGLState.d.ts

@@ -9,8 +9,6 @@ import {
 import { Material } from "../../materials/Material.js";
 import { Vector4 } from "../../math/Vector4.js";
 import { WebGLRenderTarget } from "../WebGLRenderTarget.js";
-import { WebGLCapabilities } from "./WebGLCapabilities.js";
-import { WebGLExtensions } from "./WebGLExtensions.js";
 
 export class WebGLColorBuffer {
     constructor();
@@ -45,7 +43,7 @@ export class WebGLStencilBuffer {
 }
 
 export class WebGLState {
-    constructor(gl: WebGLRenderingContext, extensions: WebGLExtensions, capabilities: WebGLCapabilities);
+    constructor(gl: WebGLRenderingContext);
 
     buffers: {
         color: WebGLColorBuffer;

three/src/renderers/webgl/WebGLUtils.d.ts

@@ -1,7 +1,11 @@
-import { CompressedPixelFormat, PixelFormat, TextureDataType, TextureEncoding } from "../../constants.js";
+import { ColorSpace, CompressedPixelFormat, PixelFormat, TextureDataType } from "../../constants.js";
+import { WebGLExtensions } from "./WebGLExtensions.js";
 
 export class WebGLUtils {
-    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, extensions: any, capabilities: any);
+    constructor(
+        gl: WebGLRenderingContext | WebGL2RenderingContext,
+        extensions: WebGLExtensions,
+    );
 
-    convert(p: PixelFormat | CompressedPixelFormat | TextureDataType, encoding?: TextureEncoding | null): number | null;
+    convert(p: PixelFormat | CompressedPixelFormat | TextureDataType, colorSpace?: ColorSpace): number | null;
 }

three/src/scenes/Scene.d.ts

@@ -1,8 +1,9 @@
 import { Object3D } from "../core/Object3D.js";
 import { Material } from "../materials/Material.js";
 import { Color } from "../math/Color.js";
+import { Euler } from "../math/Euler.js";
+import { CubeTexture } from "../textures/CubeTexture.js";
 import { Texture } from "../textures/Texture.js";
-import { CubeTexture } from "../Three.js";
 import { FogBase } from "./Fog.js";
 
 /**
@@ -68,6 +69,12 @@ export class Scene extends Object3D {
      */
     background: Color | Texture | CubeTexture | null;
 
+    /**
+     * The rotation of the background in radians. Only influences environment maps assigned to {@link .background}.
+     * Default is `(0,0,0)`.
+     */
+    backgroundRotation: Euler;
+
     /**
      * Sets the environment map for all physical materials in the scene.
      * However, it's not possible to overwrite an existing texture assigned to {@link THREE.MeshStandardMaterial.envMap | MeshStandardMaterial.envMap}.
@@ -75,6 +82,18 @@ export class Scene extends Object3D {
      */
     environment: Texture | null;
 
+    /**
+     * Attenuates the color of the environment. Only influences environment maps assigned to {@link Scene.environment}.
+     * @default 1
+     */
+    environmentIntensity: number;
+
+    /**
+     * The rotation of the environment map in radians. Only influences physical materials in the scene when
+     * {@link .environment} is used. Default is `(0,0,0)`.
+     */
+    environmentRotation: Euler;
+
     /**
      * Convert the {@link Scene} to three.js {@link https://github.com/mrdoob/three.js/wiki/JSON-Object-Scene-format-4 | JSON Object/Scene format}.
      * @param meta Object containing metadata such as textures or images for the scene.

three/src/textures/Data3DTexture.d.ts

@@ -4,7 +4,6 @@ import { Texture3DImageData } from "./types.js";
 
 /**
  * Creates a three-dimensional texture from raw data, with parameters to divide it into width, height, and depth
- * @remarks Compatible only with {@link WebGL2RenderingContext | WebGL 2 Rendering Context}.
  * @example
  * ```typescript
  * This creates a[name] with repeating data, 0 to 255

three/src/textures/DataArrayTexture.d.ts

@@ -4,7 +4,6 @@ import { Texture3DImageData } from "./types.js";
 
 /**
  * Creates an array of textures directly from raw data, width and height and depth
- * @remarks Compatible only with {@link WebGL2RenderingContext | WebGL 2 Rendering Context}.
  * @example
  * ```typescript
  * This creates a[name] where each texture has a different color.

three/src/textures/DepthTexture.d.ts

@@ -11,9 +11,6 @@ import { Texture } from "./Texture.js";
 
 /**
  * This class can be used to automatically save the depth information of a rendering into a texture
- * @remarks
- * When using a **WebGL1** rendering context, {@link DepthTexture} requires support for the
- * {@link https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/ | WEBGL_depth_texture} extension.
  * @see Example: {@link https://threejs.org/examples/#webgl_depth_texture | depth / texture}
  * @see {@link https://threejs.org/docs/index.html#api/en/textures/DepthTexture | Official Documentation}
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/textures/DepthTexture.js | Source}

three/src/textures/Texture.d.ts

@@ -8,7 +8,6 @@ import {
     PixelFormat,
     PixelFormatGPU,
     TextureDataType,
-    TextureEncoding,
     Wrapping,
 } from "../constants.js";
 import { EventDispatcher } from "../core/EventDispatcher.js";
@@ -78,7 +77,6 @@ export class Texture extends EventDispatcher<{ dispose: {} }> {
         format: PixelFormat,
         type: TextureDataType,
         anisotropy: number,
-        encoding: TextureEncoding,
     );
 
     /**
@@ -324,19 +322,6 @@ export class Texture extends EventDispatcher<{ dispose: {} }> {
      */
     unpackAlignment: number; // TODO Fix typing to only allow the expected values.
 
-    /**
-     * The {@link Textures | {@link Texture} constants} page for details of other formats.
-     * @remarks
-     * Values of {@link encoding} !== {@link THREE.LinearEncoding} are only supported on _map_, _envMap_ and _emissiveMap_.
-     * @remarks
-     * Note that if this value is changed on a texture after the material has been used, it is necessary to trigger a {@link THREE.Material.needsUpdate} for this value to be realized in the shader.
-     * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
-     * @see {@link THREE.TextureDataType}
-     * @defaultValue {@link THREE.LinearEncoding}
-     * @deprecated Use {@link Texture.colorSpace .colorSpace} in three.js r152+.
-     */
-    encoding: TextureEncoding;
-
     /**
      * The {@link Textures | {@link Texture} constants} page for details of other color spaces.
      * @remarks
@@ -354,13 +339,6 @@ export class Texture extends EventDispatcher<{ dispose: {} }> {
      */
     isRenderTargetTexture: boolean;
 
-    /**
-     * Indicates whether this texture should be processed by {@link THREE.PMREMGenerator} or not.
-     * @remarks Only relevant for render target textures.
-     * @defaultValue `false`
-     */
-    needsPMREMUpdate: boolean;
-
     /**
      * An object that can be used to store custom data about the texture.
      * @remarks It should not hold references to functions as these will not be cloned.
@@ -375,11 +353,24 @@ export class Texture extends EventDispatcher<{ dispose: {} }> {
      */
     version: number;
 
+    /**
+     * Indicates whether this texture should be processed by PMREMGenerator or not (only relevant for render target
+     * textures)
+     */
+    pmremVersion: number;
+
     /**
      * Set this to `true` to trigger an update next time the texture is used. Particularly important for setting the wrap mode.
      */
     set needsUpdate(value: boolean);
 
+    /**
+     * Indicates whether this texture should be processed by {@link THREE.PMREMGenerator} or not.
+     * @remarks Only relevant for render target textures.
+     * @defaultValue `false`
+     */
+    set needsPMREMUpdate(value: boolean);
+
     /**
      * The Global default value for {@link anisotropy | .anisotropy}.
      * @defaultValue `1`.

three/examples/jsm/nodes/core/ArrayUniformNode.d.ts

@@ -1,8 +0,0 @@
-import Node from "./Node.js";
-import UniformNode from "./UniformNode.js";
-
-export default class ArrayUniformNode extends UniformNode<undefined> {
-    isArrayUniformNode: true;
-    nodes: Node[];
-    constructor(nodes?: Node[]);
-}

three/examples/jsm/nodes/utils/SpecularMIPLevelNode.d.ts

@@ -1,12 +0,0 @@
-import TextureNode from "../accessors/TextureNode.js";
-import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
-
-export default class SpecularMIPLevelNode extends Node {
-    textureNode: TextureNode;
-    roughnessNode: Node | null;
-
-    constructor(textureNode: TextureNode, roughnessNode?: Node | null);
-}
-
-export const specularMIPLevel: () => ShaderNodeObject<SpecularMIPLevelNode>;

three/src/renderers/WebGL1Renderer.d.ts

@@ -1,6 +0,0 @@
-import { WebGLRenderer, WebGLRendererParameters } from "./WebGLRenderer.js";
-
-export class WebGL1Renderer extends WebGLRenderer {
-    constructor(parameters?: WebGLRendererParameters);
-    readonly isWebGL1Renderer: true;
-}