@types/three 0.144.0 → 0.146.0

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

@@ -12,10 +12,12 @@ import {
 } from '../../../../src/Three';
 import LightingContextNode, { LightingModelNode } from '../lighting/LightingContextNode';
 import {
+    BlendModeNode,
     CheckerNode,
     ColorAdjustmentNode,
     ColorSpaceNode,
     CubeTextureNode,
+    EquirectUVNode,
     FogNode,
     FogRangeNode,
     InstanceNode,
@@ -24,12 +26,15 @@ import {
     MaxMipLevelNode,
     NormalMapNode,
     OscNode,
+    PosterizeNode,
+    RemapNode,
     ReflectVectorNode,
     RotateUVNode,
     SkinningNode,
     SpriteSheetUVNode,
     TimerNode,
     ToneMappingNode,
+    TriplanarTexturesNode,
 } from '../Nodes';
 
 //
@@ -69,6 +74,11 @@ export function skinning(skinnedMesh: SkinnedMesh): Swizzable<SkinningNode>;
 
 // display
 
+export function burn(baseNode: NodeRepresentation, blendNode?: NodeRepresentation): Swizzable<BlendModeNode>;
+export function dodge(baseNode: NodeRepresentation, blendNode?: NodeRepresentation): Swizzable<BlendModeNode>;
+export function overlay(baseNode: NodeRepresentation, blendNode?: NodeRepresentation): Swizzable<BlendModeNode>;
+export function screen(baseNode: NodeRepresentation, blendNode?: NodeRepresentation): Swizzable<BlendModeNode>;
+
 export function saturation(
     colorNode: NodeRepresentation,
     adjustmentNode?: NodeRepresentation,
@@ -87,6 +97,8 @@ export function toneMapping(
     color: NodeRepresentation,
 ): Swizzable<ToneMappingNode>;
 
+export function posterize(sourceNode: NodeRepresentation, stepsNode: NodeRepresentation): Swizzable<PosterizeNode>;
+
 // lighting
 
 export function lights(lights: Light[]): Swizzable<LightsNode>;
@@ -95,6 +107,8 @@ export function lightingContext(node: Node, lightingModelNode?: LightingModelNod
 // utils
 
 export const matcapUV: Swizzable<MatcapUVNode>;
+export const equirectUV: Swizzable<EquirectUVNode>;
+
 export function maxMipLevel(texture: Texture): Swizzable<MaxMipLevelNode>;
 
 export function oscSine(timeNode?: NodeRepresentation): Swizzable<OscNode>;
@@ -102,6 +116,9 @@ export function oscSquare(timeNode?: NodeRepresentation): Swizzable<OscNode>;
 export function oscTriangle(timeNode?: NodeRepresentation): Swizzable<OscNode>;
 export function oscSawtooth(timeNode?: NodeRepresentation): Swizzable<OscNode>;
 
+export function remap(node: Node, inLowNode: Node): Swizzable<RemapNode>;
+export function remapClamp(node: Node, inLowNode: Node): Swizzable<RemapNode>;
+
 export function rotateUV(uvNode: Node, rotationNode: Node, centerNode?: Node): Swizzable<RotateUVNode>;
 
 export function spritesheetUV(
@@ -113,6 +130,19 @@ export function spritesheetUV(
 export function timerLocal(timeScale: number, value?: number): Swizzable<TimerNode>;
 export function timerGlobal(timeScale: number, value?: number): Swizzable<TimerNode>;
 export function timerDelta(timeScale: number, value?: number): Swizzable<TimerNode>;
+export const frameId: Swizzable<TimerNode>;
+export function triplanarTextures(
+    textureXNode: NodeRepresentation,
+    textureYNode?: NodeRepresentation,
+    textureZNode?: NodeRepresentation,
+    scaleNode?: NodeRepresentation,
+    positionNode?: NodeRepresentation,
+    normalNode?: NodeRepresentation,
+): Swizzable<TriplanarTexturesNode>;
+export function triplanarTexture(
+    texture: NodeRepresentation,
+    ...params: NodeRepresentation[]
+): Swizzable<TriplanarTexturesNode>;
 
 // geometry
 

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

@@ -0,0 +1,6 @@
+import { PositionNode, TempNode } from '../Nodes';
+import { Swizzable } from '../shadernode/ShaderNodeElements';
+
+export default class EquirectUVNode extends TempNode {
+    constructor(dirNode?: Swizzable<PositionNode>);
+}

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

@@ -0,0 +1,13 @@
+import Node from '../core/Node';
+
+export default class RemapNode extends Node {
+    node: Node;
+    inLowNode: Node;
+    inHighNode: Node;
+    outLowNode: Node;
+    outHighNode: Node;
+
+    doClamp: boolean;
+
+    constructor(node: Node, inLowNode: Node, inHighNode: Node, outLowNode: Node, outHighNode: Node);
+}

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

@@ -1,11 +1,16 @@
 import UniformNode from '../core/UniformNode';
 
-export type TimerNodeScope = typeof TimerNode.LOCAL | typeof TimerNode.GLOBAL | typeof TimerNode.DELTA;
+export type TimerNodeScope =
+    | typeof TimerNode.LOCAL
+    | typeof TimerNode.GLOBAL
+    | typeof TimerNode.DELTA
+    | typeof TimerNode.FRAME;
 
 export default class TimerNode extends UniformNode {
     static LOCAL: 'local';
     static GLOBAL: 'global';
     static DELTA: 'delta';
+    static FRAME: 'frame';
 
     scope: TimerNodeScope;
     scale: number;

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

@@ -0,0 +1,22 @@
+import Node from '../core/Node';
+import { PositionNode, Swizzable, TextureNode } from '../Nodes';
+
+export default class TriplanarTexturesNode extends Node {
+    textureXNode: TextureNode;
+    textureYNode: TextureNode | null;
+    textureZNode: TextureNode | null;
+
+    scaleNode: Swizzable;
+
+    positionNode: Swizzable<PositionNode>;
+    normalNode: Swizzable<PositionNode>;
+
+    constructor(
+        textureXNode: Node,
+        textureYNode?: TextureNode | null,
+        textureZNode?: TextureNode | null,
+        scaleNode?: Swizzable,
+        positionNode?: Swizzable<PositionNode>,
+        normalNode?: Swizzable<PositionNode>,
+    );
+}

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

@@ -3,7 +3,7 @@ import { WebGLRenderTarget, ShaderMaterial } from '../../../src/Three';
 import { Pass } from './Pass';
 
 export class BloomPass extends Pass {
-    constructor(strength?: number, kernelSize?: number, sigma?: number, resolution?: number);
+    constructor(strength?: number, kernelSize?: number, sigma?: number);
     renderTargetX: WebGLRenderTarget;
     renderTargetY: WebGLRenderTarget;
     copyUniforms: object;

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

@@ -7,8 +7,6 @@ export interface BokehPassParamters {
     aspect?: number;
     aperture?: number;
     maxblur?: number;
-    width?: number;
-    height?: number;
 }
 
 export class BokehPass extends Pass {

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

@@ -27,4 +27,5 @@ export class EffectComposer {
     reset(renderTarget?: WebGLRenderTarget): void;
     setSize(width: number, height: number): void;
     setPixelRatio(pixelRatio: number): void;
+    dispose(): void;
 }

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

@@ -15,6 +15,8 @@ export class Pass {
         deltaTime: number,
         maskActive: boolean,
     ): void;
+
+    dispose(): void;
 }
 
 export class FullScreenQuad {

three/examples/jsm/renderers/webgl/nodes/WebGLNodeBuilder.d.ts

@@ -39,10 +39,10 @@ export class WebGLNodeBuilder extends NodeBuilder {
 
     getVarys(shaderStage: string): string;
 
-    addCodeAfterCode(shaderStage: string, snippet: string, code: string): string;
+    addCode(shaderStage: string, source: string, code: string, scope?: this): string;
     addCodeAfterInclude(shaderStage: string, snippet: string, code: string): string;
 
-    replaceCode(shaderStage: string, source: string, target: string): void;
+    replaceCode(shaderStage: string, source: string, target: string, scope?: this): void;
     parseInclude(shaderStage: string, ...includes: string[]): void;
     getTextureEncodingFromMap(map: Texture): TextureEncoding;
 

three/examples/jsm/shaders/VelocityShader.d.ts

@@ -0,0 +1,13 @@
+import { IUniform, UniformsLib } from '../../../src/Three';
+
+export const VelocityShader: {
+    uniforms: typeof UniformsLib['common'] &
+        typeof UniformsLib['displacementmap'] & {
+            modelMatrixPrev: IUniform;
+            currentProjectionViewMatrix: IUniform;
+            previousProjectionViewMatrix: IUniform;
+        };
+
+    fragmentShader: string;
+    vertexShader: string;
+};

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

@@ -8,6 +8,7 @@ import {
     Points,
 } from '../../../src/Three';
 
+export function deepCloneAttribute(attribute: BufferAttribute): BufferAttribute;
 export function mergeBufferGeometries(geometries: BufferGeometry[], useGroups?: boolean): BufferGeometry;
 export function mergeBufferAttributes(attributes: BufferAttribute[]): BufferAttribute;
 export function interleaveAttributes(attributes: BufferAttribute[]): InterleavedBufferAttribute;

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

@@ -1,4 +1,4 @@
-import { BufferGeometry, Group, InstancedMesh, Material, Object3D, Scene, Mesh } from '../../../src/Three';
+import { BufferGeometry, Group, InstancedMesh, Material, Object3D, Scene, Mesh, Vector3 } from '../../../src/Three';
 
 export function createMeshesFromInstancedMesh(instancedMesh: InstancedMesh): Group;
 export function createMultiMaterialObject(geometry: BufferGeometry, materials: Material[]): Group;
@@ -12,3 +12,11 @@ export function detach(child: Object3D, parent: Object3D, scene: Scene): void;
 export function attach(child: Object3D, scene: Scene, parent: Object3D): void;
 
 export function createMeshesFromMultiMaterialMesh(mesh: Mesh): Group;
+
+export function sortInstancedMesh(mesh: InstancedMesh, compareFn: (a: number, b: number) => number): void;
+
+export function reduceVertices<TValue>(
+    object: Object3D,
+    func: (value: TValue, vertex: Vector3) => TValue,
+    initialValue: TValue,
+): TValue;

three/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for three 0.144
+// Type definitions for three 0.146
 // Project: https://threejs.org/
 // Definitions by: Josh Ellis <https://github.com/joshuaellis>
 //                 Nathan Bierema <https://github.com/Methuselah96>

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.144.0",
+    "version": "0.146.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -27,6 +27,6 @@
     "dependencies": {
         "@types/webxr": "*"
     },
-    "typesPublisherContentHash": "fd44eeaf35ec2ad7992d39b9da4bfde0290790e3cec4fb679df94f09e35c72dd",
+    "typesPublisherContentHash": "8811cec6dcb6daed91e5163eee03aeed7a0b56ad67126ce3b6ade0354b3d8614",
     "typeScriptVersion": "4.1"
 }

three/src/Three.d.ts

@@ -158,6 +158,7 @@ export * from './math/Vector2';
 export * from './math/Quaternion';
 export * from './math/Color';
 export * from './math/SphericalHarmonics3';
+export { ColorManagement } from './math/ColorManagement';
 import * as MathUtils from './math/MathUtils';
 export { MathUtils };
 /**
@@ -223,6 +224,7 @@ export * from './scenes/Scene';
  * Textures
  */
 export * from './textures/VideoTexture';
+export * from './textures/CompressedArrayTexture';
 export * from './textures/DataTexture';
 export * from './textures/DataTexture2DArray';
 export * from './textures/DataTexture3D';

three/src/core/Object3D.d.ts

@@ -109,6 +109,13 @@ export class Object3D<E extends BaseEvent = Event> extends EventDispatcher<E> {
      */
     matrixAutoUpdate: boolean;
 
+    /**
+     * When this is set, the renderer checks every frame if the object and its children need matrix updates.
+     * Otherwise, you have to maintain all matrices in the object and its children yourself.
+     * @default THREE.Object3D.DefaultMatrixWorldAutoUpdate
+     */
+    matrixWorldAutoUpdate: boolean;
+
     /**
      * When this is set, it calculates the matrixWorld in that frame and resets this property to false.
      * @default false
@@ -210,6 +217,7 @@ export class Object3D<E extends BaseEvent = Event> extends EventDispatcher<E> {
 
     static DefaultUp: Vector3;
     static DefaultMatrixAutoUpdate: boolean;
+    static DefaultMatrixWorldAutoUpdate: boolean;
 
     /**
      * Applies the matrix transform to the object and updates the object's position, rotation and scale.
@@ -364,7 +372,7 @@ export class Object3D<E extends BaseEvent = Event> extends EventDispatcher<E> {
      */
     getObjectByName(name: string): Object3D | undefined;
 
-    getObjectByProperty(name: string, value: string): Object3D | undefined;
+    getObjectByProperty(name: string, value: any): Object3D | undefined;
 
     getWorldPosition(target: Vector3): Vector3;
     getWorldQuaternion(target: Quaternion): Quaternion;

three/src/helpers/ArrowHelper.d.ts

@@ -55,4 +55,8 @@ export class ArrowHelper extends Object3D {
      * @param color The desired color.
      */
     setColor(color: ColorRepresentation): void;
+
+    copy(source: this): this;
+
+    dispose(): void;
 }

three/src/helpers/Box3Helper.d.ts

@@ -15,4 +15,6 @@ export class Box3Helper extends LineSegments {
     type: string;
 
     box: Box3;
+
+    dispose(): void;
 }

three/src/helpers/BoxHelper.d.ts

@@ -17,4 +17,6 @@ export class BoxHelper extends LineSegments {
     update(object?: Object3D): void;
 
     setFromObject(object: Object3D): this;
+
+    dispose(): void;
 }

three/src/helpers/GridHelper.d.ts

@@ -15,8 +15,5 @@ export class GridHelper extends LineSegments {
      */
     type: string;
 
-    /**
-     * @deprecated Colors should be specified in the constructor.
-     */
-    setColors(color1?: ColorRepresentation, color2?: ColorRepresentation): void;
+    dispose(): void;
 }

three/src/helpers/PlaneHelper.d.ts

@@ -22,4 +22,6 @@ export class PlaneHelper extends LineSegments {
     size: number;
 
     updateMatrixWorld(force?: boolean): void;
+
+    dispose(): void;
 }

three/src/helpers/PolarGridHelper.d.ts

@@ -23,4 +23,6 @@ export class PolarGridHelper extends LineSegments {
      * @default 'PolarGridHelper'
      */
     type: string;
+
+    dispose(): void;
 }

three/src/helpers/SkeletonHelper.d.ts

@@ -25,4 +25,6 @@ export class SkeletonHelper extends LineSegments {
 
     getBoneList(object: Object3D): Bone[];
     update(): void;
+
+    dispose(): void;
 }

three/src/loaders/DataTextureLoader.d.ts

@@ -7,7 +7,7 @@ export class DataTextureLoader extends Loader {
 
     load(
         url: string,
-        onLoad: (dataTexture: DataTexture, texData: object) => void,
+        onLoad?: (dataTexture: DataTexture, texData: object) => void,
         onProgress?: (event: ProgressEvent) => void,
         onError?: (event: ErrorEvent) => void,
     ): DataTexture;

three/src/materials/MeshLambertMaterial.d.ts

@@ -67,7 +67,7 @@ export class MeshLambertMaterial extends Material {
     /**
      * @default 1
      */
-    dispalcementScale: number;
+    displacementScale: number;
 
     /**
      * @default 0

three/src/math/ColorManagement.d.ts

@@ -1,4 +1,4 @@
-import { LinearSRGBColorSpace, SRGBColorSpace } from '../constants';
+import { ColorSpace, LinearSRGBColorSpace, SRGBColorSpace } from '../constants';
 import { Color } from './Color';
 
 export function SRGBToLinear(c: number): number;
@@ -6,6 +6,16 @@ export function SRGBToLinear(c: number): number;
 export function LinearToSRGB(c: number): number;
 
 export namespace ColorManagement {
+    /**
+     * @default true
+     */
+    let legacyMode: boolean;
+
+    /**
+     * @default LinearSRGBColorSpace
+     */
+    let workingColorSpace: ColorSpace;
+
     function convert(
         color: Color,
         sourceColorSpace: SRGBColorSpace | LinearSRGBColorSpace,

three/src/math/Euler.d.ts

@@ -2,8 +2,10 @@ import { Matrix4 } from './Matrix4';
 import { Quaternion } from './Quaternion';
 import { Vector3 } from './Vector3';
 
+export type EulerOrder = 'XYZ' | 'YXZ' | 'ZXY' | 'ZYX' | 'YZX' | 'XZY';
+
 export class Euler {
-    constructor(x?: number, y?: number, z?: number, order?: string);
+    constructor(x?: number, y?: number, z?: number, order?: EulerOrder);
 
     /**
      * @default 0
@@ -23,25 +25,25 @@ export class Euler {
     /**
      * @default THREE.Euler.DefaultOrder
      */
-    order: string;
+    order: EulerOrder;
     readonly isEuler: true;
 
     _onChangeCallback: () => void;
 
-    set(x: number, y: number, z: number, order?: string): Euler;
+    set(x: number, y: number, z: number, order?: EulerOrder): Euler;
     clone(): this;
     copy(euler: Euler): this;
-    setFromRotationMatrix(m: Matrix4, order?: string, update?: boolean): Euler;
-    setFromQuaternion(q: Quaternion, order?: string, update?: boolean): Euler;
-    setFromVector3(v: Vector3, order?: string): Euler;
-    reorder(newOrder: string): Euler;
+    setFromRotationMatrix(m: Matrix4, order?: EulerOrder, update?: boolean): Euler;
+    setFromQuaternion(q: Quaternion, order?: EulerOrder, update?: boolean): Euler;
+    setFromVector3(v: Vector3, order?: EulerOrder): Euler;
+    reorder(newOrder: EulerOrder): Euler;
     equals(euler: Euler): boolean;
-    fromArray(xyzo: any[]): Euler;
-    toArray(array?: number[], offset?: number): number[];
+    fromArray(xyzo: [number, number, number, EulerOrder?, ...any[]]): Euler;
+    toArray(array?: Array<number | string | undefined>, offset?: number): Array<number | string | undefined>;
     _onChange(callback: () => void): this;
 
-    static RotationOrders: string[];
-    static DefaultOrder: string;
+    static RotationOrders: EulerOrder[];
+    static DefaultOrder: 'XYZ';
 
     [Symbol.iterator](): Generator<string | number, void>;
 }

three/src/math/Quaternion.d.ts

@@ -1,6 +1,8 @@
 import { Euler } from './Euler';
 import { Vector3 } from './Vector3';
 import { Matrix4 } from './Matrix4';
+import { BufferAttribute } from '../core/BufferAttribute';
+import { InterleavedBufferAttribute } from '../core/InterleavedBufferAttribute';
 
 /**
  * Implementation of a quaternion. This is used for rotating things without incurring in the dreaded gimbal lock issue, amongst other advantages.
@@ -136,6 +138,13 @@ export class Quaternion {
      */
     toArray(array: ArrayLike<number>, offset?: number): ArrayLike<number>;
 
+    /**
+     * Sets x, y, z, w properties of this quaternion from the attribute.
+     * @param attribute the source attribute.
+     * @param index index in the attribute.
+     */
+    fromBufferAttribute(attribute: BufferAttribute | InterleavedBufferAttribute, index: number): Quaternion;
+
     _onChange(callback: () => void): Quaternion;
     _onChangeCallback: () => void;
 
@@ -147,7 +156,7 @@ export class Quaternion {
         src1: number[],
         stcOffset1: number,
         t: number,
-    ): Quaternion;
+    ): void;
 
     static multiplyQuaternionsFlat(
         dst: number[],

three/src/renderers/WebGL3DRenderTarget.d.ts

@@ -12,7 +12,7 @@ export class WebGL3DRenderTarget extends WebGLRenderTarget {
      * @param height the height of the render target, in pixels.
      * @param depth the depth of the render target.
      */
-    constructor(width: number, height: number, depth: number);
+    constructor(width?: number, height?: number, depth?: number);
 
     /**
      * The depth of the render target.

three/src/renderers/WebGLArrayRenderTarget.d.ts

@@ -12,7 +12,7 @@ export class WebGLArrayRenderTarget extends WebGLRenderTarget {
      * @param height the height of the render target, in pixels.
      * @param depth the depth/layer count of the render target.
      */
-    constructor(width: number, height: number, depth: number);
+    constructor(width?: number, height?: number, depth?: number);
 
     /**
      * The depth of the render target.

three/src/renderers/WebGLCubeRenderTarget.d.ts

@@ -4,7 +4,7 @@ import { Texture } from './../textures/Texture';
 import { CubeTexture } from './../textures/CubeTexture';
 
 export class WebGLCubeRenderTarget extends WebGLRenderTarget {
-    constructor(size: number, options?: WebGLRenderTargetOptions);
+    constructor(size?: number, options?: WebGLRenderTargetOptions);
 
     texture: CubeTexture;
 

three/src/renderers/WebGLMultipleRenderTargets.d.ts

@@ -18,7 +18,7 @@ export class WebGLMultipleRenderTargets extends EventDispatcher {
      * @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?: WebGLRenderTargetOptions);
+    constructor(width?: number, height?: number, count?: number, options?: WebGLRenderTargetOptions);
 
     setSize(width: number, height: number, depth?: number): this;
     copy(source: WebGLMultipleRenderTargets): this;

three/src/renderers/WebGLRenderTarget.d.ts

@@ -26,7 +26,7 @@ export interface WebGLRenderTargetOptions {
 }
 
 export class WebGLRenderTarget extends EventDispatcher {
-    constructor(width: number, height: number, options?: WebGLRenderTargetOptions);
+    constructor(width?: number, height?: number, options?: WebGLRenderTargetOptions);
 
     width: number;
     height: number;

three/src/renderers/WebGLRenderer.d.ts

@@ -17,7 +17,7 @@ import { Material } from './../materials/Material';
 import { ToneMapping, ShadowMapType, CullFace, TextureEncoding } from '../constants';
 import { WebXRManager } from '../renderers/webxr/WebXRManager';
 import { BufferGeometry } from './../core/BufferGeometry';
-import { Texture } from '../textures/Texture';
+import { OffscreenCanvas, Texture } from '../textures/Texture';
 import { Data3DTexture } from '../textures/Data3DTexture';
 import { Vector3 } from '../math/Vector3';
 import { Box3 } from '../math/Box3';
@@ -31,10 +31,6 @@ export interface Renderer {
     setSize(width: number, height: number, updateStyle?: boolean): void;
 }
 
-/** This is only available in worker JS contexts, not the DOM. */
-// tslint:disable-next-line:no-empty-interface
-export interface OffscreenCanvas extends EventTarget {}
-
 export interface WebGLRendererParameters {
     /**
      * A Canvas where the renderer draws its output.

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

@@ -19,8 +19,9 @@ export let UniformsLib: {
         envMap: IUniform;
         flipEnvMap: IUniform;
         reflectivity: IUniform;
-        refractionRatio: IUniform;
-        maxMipLevel: IUniform;
+        ior: IUniform;
+        refractRatio: IUniform;
+        backgroundBlurriness: IUniform;
     };
     aomap: {
         aoMap: IUniform;

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

@@ -20,6 +20,7 @@ export class WebGLCapabilities {
     vertexTextures: boolean;
     floatFragmentTextures: boolean;
     floatVertexTextures: boolean;
+    maxSamples: number;
 
     getMaxAnisotropy(): number;
     getMaxPrecision(precision: string): string;

three/src/scenes/Scene.d.ts

@@ -22,17 +22,14 @@ export class Scene extends Object3D {
      */
     fog: FogBase | null;
 
+    backgroundBlurriness: number;
+
     /**
      * If not null, it will force everything in the scene to be rendered with that material. Default is null.
      * @default null
      */
     overrideMaterial: Material | null;
 
-    /**
-     * @default true
-     */
-    autoUpdate: boolean;
-
     /**
      * @default null
      */

three/src/textures/CanvasTexture.d.ts

@@ -1,4 +1,4 @@
-import { Texture } from './Texture';
+import { OffscreenCanvas, Texture } from './Texture';
 import { Mapping, Wrapping, TextureFilter, PixelFormat, TextureDataType } from '../constants';
 
 export class CanvasTexture extends Texture {
@@ -15,7 +15,7 @@ export class CanvasTexture extends Texture {
      * @param [encoding=THREE.LinearEncoding]
      */
     constructor(
-        canvas: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | ImageBitmap,
+        canvas: TexImageSource | OffscreenCanvas,
         mapping?: Mapping,
         wrapS?: Wrapping,
         wrapT?: Wrapping,

three/src/textures/CompressedArrayTexture.d.ts

@@ -0,0 +1,17 @@
+import { CompressedPixelFormat, TextureDataType, Wrapping } from '../constants';
+import { CompressedTexture } from './CompressedTexture.js';
+
+export class CompressedArrayTexture extends CompressedTexture {
+    isCompressedArrayTexture: true;
+
+    wrapR: Wrapping;
+
+    constructor(
+        mipmaps: ImageData[],
+        width: number,
+        height: number,
+        depth: number,
+        format?: CompressedPixelFormat,
+        type?: TextureDataType,
+    );
+}