@types/three 0.159.0 → 0.161.0

three/src/objects/Bone.d.ts

@@ -1,4 +1,4 @@
-import { Object3D } from '../core/Object3D.js';
+import { Object3D, Object3DEventMap } from '../core/Object3D.js';
 
 /**
  * A {@link Bone} which is part of a {@link THREE.Skeleton | Skeleton}
@@ -15,7 +15,7 @@ import { Object3D } from '../core/Object3D.js';
  * @see {@link https://threejs.org/docs/index.html#api/en/objects/Bone | Official Documentation}
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/objects/Bone.js | Source}
  */
-export class Bone extends Object3D {
+export class Bone<TEventMap extends Object3DEventMap = Object3DEventMap> extends Object3D<TEventMap> {
     /**
      * Creates a new {@link Bone}.
      */

three/src/objects/InstancedMesh.d.ts

@@ -28,7 +28,8 @@ export interface InstancedMeshEventMap extends Object3DEventMap {
 export class InstancedMesh<
     TGeometry extends BufferGeometry = BufferGeometry,
     TMaterial extends Material | Material[] = Material | Material[],
-> extends Mesh<TGeometry, TMaterial, InstancedMeshEventMap> {
+    TEventMap extends InstancedMeshEventMap = InstancedMeshEventMap,
+> extends Mesh<TGeometry, TMaterial, TEventMap> {
     /**
      * Create a new instance of {@link InstancedMesh}
      * @param geometry An instance of {@link THREE.BufferGeometry | BufferGeometry}.

three/src/objects/LOD.d.ts

@@ -1,4 +1,4 @@
-import { Object3D } from '../core/Object3D.js';
+import { Object3D, Object3DEventMap } from '../core/Object3D.js';
 import { Camera } from '../cameras/Camera.js';
 
 /**
@@ -20,7 +20,7 @@ import { Camera } from '../cameras/Camera.js';
  * @see {@link https://threejs.org/docs/index.html#api/en/objects/LOD | Official Documentation}
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/objects/LOD.js | Source}
  */
-export class LOD extends Object3D {
+export class LOD<TEventMap extends Object3DEventMap = Object3DEventMap> extends Object3D<TEventMap> {
     /**
      * Creates a new {@link LOD}.
      */

three/src/objects/Line.d.ts

@@ -1,5 +1,5 @@
 import { Material } from '../materials/Material.js';
-import { Object3D } from '../core/Object3D.js';
+import { Object3D, Object3DEventMap } from '../core/Object3D.js';
 import { BufferGeometry } from '../core/BufferGeometry.js';
 
 /**
@@ -27,7 +27,8 @@ import { BufferGeometry } from '../core/BufferGeometry.js';
 export class Line<
     TGeometry extends BufferGeometry = BufferGeometry,
     TMaterial extends Material | Material[] = Material | Material[],
-> extends Object3D {
+    TEventMap extends Object3DEventMap = Object3DEventMap,
+> extends Object3D<TEventMap> {
     /**
      * Create a new instance of {@link Line}
      * @param geometry Vertices representing the {@link Line} segment(s). Default {@link THREE.BufferGeometry | `new THREE.BufferGeometry()`}.

three/src/objects/LineLoop.d.ts

@@ -1,6 +1,7 @@
 import { Line } from './Line.js';
 import { Material } from '../materials/Material.js';
 import { BufferGeometry } from '../core/BufferGeometry.js';
+import { Object3DEventMap } from '../core/Object3D.js';
 
 /**
  * A continuous line that connects back to the start.
@@ -15,7 +16,8 @@ import { BufferGeometry } from '../core/BufferGeometry.js';
 export class LineLoop<
     TGeometry extends BufferGeometry = BufferGeometry,
     TMaterial extends Material | Material[] = Material | Material[],
-> extends Line<TGeometry, TMaterial> {
+    TEventMap extends Object3DEventMap = Object3DEventMap,
+> extends Line<TGeometry, TMaterial, TEventMap> {
     /**
      * Create a new instance of {@link LineLoop}
      * @param geometry  List of vertices representing points on the line loop. Default {@link THREE.BufferGeometry | `new THREE.BufferGeometry()`}.

three/src/objects/LineSegments.d.ts

@@ -1,6 +1,7 @@
 import { Material } from '../materials/Material.js';
 import { Line } from './Line.js';
 import { BufferGeometry } from '../core/BufferGeometry.js';
+import { Object3DEventMap } from '../core/Object3D.js';
 
 /**
  * A series of lines drawn between pairs of vertices.
@@ -14,7 +15,8 @@ import { BufferGeometry } from '../core/BufferGeometry.js';
 export class LineSegments<
     TGeometry extends BufferGeometry = BufferGeometry,
     TMaterial extends Material | Material[] = Material | Material[],
-> extends Line<TGeometry, TMaterial> {
+    TEventMap extends Object3DEventMap = Object3DEventMap,
+> extends Line<TGeometry, TMaterial, TEventMap> {
     /**
      * Create a new instance of {@link LineSegments}
      * @param geometry Pair(s) of vertices representing each line segment(s). Default {@link THREE.BufferGeometry | `new THREE.BufferGeometry()`}.

three/src/objects/Points.d.ts

@@ -1,5 +1,5 @@
 import { Material } from '../materials/Material.js';
-import { Object3D } from '../core/Object3D.js';
+import { Object3D, Object3DEventMap } from '../core/Object3D.js';
 import { BufferGeometry, NormalOrGLBufferAttributes } from '../core/BufferGeometry.js';
 import { BufferAttribute } from '../core/BufferAttribute.js';
 import { InterleavedBufferAttribute } from '../core/InterleavedBufferAttribute.js';
@@ -15,7 +15,8 @@ import { GLBufferAttribute } from '../core/GLBufferAttribute.js';
 export class Points<
     TGeometry extends BufferGeometry<NormalOrGLBufferAttributes> = BufferGeometry,
     TMaterial extends Material | Material[] = Material | Material[],
-> extends Object3D {
+    TEventMap extends Object3DEventMap = Object3DEventMap,
+> extends Object3D<TEventMap> {
     /**
      * Create a new instance of {@link Points}
      * @param geometry An instance of {@link THREE.BufferGeometry | BufferGeometry}. Default {@link THREE.BufferGeometry | `new THREE.BufferGeometry()`}.

three/src/objects/SkinnedMesh.d.ts

@@ -5,14 +5,14 @@ import { Vector3 } from '../math/Vector3.js';
 import { Skeleton } from './Skeleton.js';
 import { Mesh } from './Mesh.js';
 import { BufferGeometry } from '../core/BufferGeometry.js';
+import { Object3DEventMap } from '../core/Object3D.js';
 import { Sphere } from '../math/Sphere.js';
 import { BindMode } from '../constants.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 or
- * With WebGL 1 `OES_texture_float` and vertex textures support is required.
+ * {@link SkinnedMesh} can only be used with WebGL 2.
  * @example
  * ```typescript
  * const geometry = new THREE.CylinderGeometry(5, 5, 5, 5, 15, 5, 30);
@@ -51,7 +51,8 @@ import { BindMode } from '../constants.js';
 export class SkinnedMesh<
     TGeometry extends BufferGeometry = BufferGeometry,
     TMaterial extends Material | Material[] = Material | Material[],
-> extends Mesh<TGeometry, TMaterial> {
+    TEventMap extends Object3DEventMap = Object3DEventMap,
+> extends Mesh<TGeometry, TMaterial, TEventMap> {
     /**
      * Create a new instance of {@link SkinnedMesh}
      * @param geometry An instance of {@link THREE.BufferGeometry | BufferGeometry}. Default {@link THREE.BufferGeometry | `new THREE.BufferGeometry()`}.
@@ -149,9 +150,4 @@ export class SkinnedMesh<
      * @param vector
      */
     applyBoneTransform(index: number, vector: Vector3): Vector3;
-
-    /**
-     * @deprecated {@link THREE.SkinnedMesh}: {@link boneTransform | .boneTransform()} was renamed to {@link applyBoneTransform | .applyBoneTransform()} in **r151**.
-     */
-    boneTransform(index: number, target: Vector3): Vector3;
 }

three/src/objects/Sprite.d.ts

@@ -1,5 +1,5 @@
 import { Vector2 } from '../math/Vector2.js';
-import { Object3D } from '../core/Object3D.js';
+import { Object3D, Object3DEventMap } from '../core/Object3D.js';
 import { SpriteMaterial } from '../materials/Materials.js';
 import { BufferGeometry } from '../core/BufferGeometry.js';
 
@@ -18,7 +18,7 @@ import { BufferGeometry } from '../core/BufferGeometry.js';
  * @see {@link https://threejs.org/docs/index.html#api/en/objects/Sprite | Official Documentation}
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/objects/Sprite.js | Source}
  */
-export class Sprite extends Object3D {
+export class Sprite<TEventMap extends Object3DEventMap = Object3DEventMap> extends Object3D<TEventMap> {
     /**
      * Creates a new Sprite.
      * @param material An instance of {@link THREE.SpriteMaterial | SpriteMaterial}. Default {@link THREE.SpriteMaterial | `new SpriteMaterial()`}, _with white color_.

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

@@ -1,27 +1,27 @@
 import { IUniform } from './UniformsLib.js';
 
-export interface Shader {
+export interface ShaderLibShader {
     uniforms: { [uniform: string]: IUniform };
     vertexShader: string;
     fragmentShader: string;
 }
 
 export let ShaderLib: {
-    [name: string]: Shader;
-    basic: Shader;
-    lambert: Shader;
-    phong: Shader;
-    standard: Shader;
-    matcap: Shader;
-    points: Shader;
-    dashed: Shader;
-    depth: Shader;
-    normal: Shader;
-    sprite: Shader;
-    background: Shader;
-    cube: Shader;
-    equirect: Shader;
-    distanceRGBA: Shader;
-    shadow: Shader;
-    physical: Shader;
+    [name: string]: ShaderLibShader;
+    basic: ShaderLibShader;
+    lambert: ShaderLibShader;
+    phong: ShaderLibShader;
+    standard: ShaderLibShader;
+    matcap: ShaderLibShader;
+    points: ShaderLibShader;
+    dashed: ShaderLibShader;
+    depth: ShaderLibShader;
+    normal: ShaderLibShader;
+    sprite: ShaderLibShader;
+    background: ShaderLibShader;
+    cube: ShaderLibShader;
+    equirect: ShaderLibShader;
+    distanceRGBA: ShaderLibShader;
+    shadow: ShaderLibShader;
+    physical: ShaderLibShader;
 };

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

@@ -1,7 +1,8 @@
 import { UniformsGroup } from '../../core/UniformsGroup.js';
+import { IUniform } from './UniformsLib.js';
 
-export function cloneUniforms(uniforms_src: any): any;
-export function mergeUniforms(uniforms: any): any;
+export function cloneUniforms<T extends { [uniform: string]: IUniform }>(uniformsSrc: T): T;
+export function mergeUniforms(uniforms: Array<{ [uniform: string]: IUniform }>): { [uniform: string]: IUniform };
 
 export function cloneUniformsGroups(src: UniformsGroup[]): UniformsGroup[];
 

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

@@ -1,47 +1,49 @@
 import { WebGLExtensions } from './WebGLExtensions.js';
 import { WebGLCapabilities } from './WebGLCapabilities.js';
 
-export class WebGLLights {
-    constructor(extensions: WebGLExtensions, capabilities: WebGLCapabilities);
+export interface WebGLLightsState {
+    version: number;
+
+    hash: {
+        directionalLength: number;
+        pointLength: number;
+        spotLength: number;
+        rectAreaLength: number;
+        hemiLength: number;
+
+        numDirectionalShadows: number;
+        numPointShadows: number;
+        numSpotShadows: number;
+        numSpotMaps: number;
 
-    state: {
-        version: number;
-
-        hash: {
-            directionalLength: number;
-            pointLength: number;
-            spotLength: number;
-            rectAreaLength: number;
-            hemiLength: number;
-
-            numDirectionalShadows: number;
-            numPointShadows: number;
-            numSpotShadows: number;
-            numSpotMaps: number;
-
-            numLightProbes: number;
-        };
-
-        ambient: number[];
-        probe: any[];
-        directional: any[];
-        directionalShadow: any[];
-        directionalShadowMap: any[];
-        directionalShadowMatrix: any[];
-        spot: any[];
-        spotShadow: any[];
-        spotShadowMap: any[];
-        spotShadowMatrix: any[];
-        rectArea: any[];
-        point: any[];
-        pointShadow: any[];
-        pointShadowMap: any[];
-        pointShadowMatrix: any[];
-        hemi: any[];
-        numSpotLightShadowsWithMaps: number;
         numLightProbes: number;
     };
 
+    ambient: number[];
+    probe: any[];
+    directional: any[];
+    directionalShadow: any[];
+    directionalShadowMap: any[];
+    directionalShadowMatrix: any[];
+    spot: any[];
+    spotShadow: any[];
+    spotShadowMap: any[];
+    spotShadowMatrix: any[];
+    rectArea: any[];
+    point: any[];
+    pointShadow: any[];
+    pointShadowMap: any[];
+    pointShadowMatrix: any[];
+    hemi: any[];
+    numSpotLightShadowsWithMaps: number;
+    numLightProbes: number;
+}
+
+export class WebGLLights {
+    constructor(extensions: WebGLExtensions, capabilities: WebGLCapabilities);
+
+    state: WebGLLightsState;
+
     get(light: any): any;
     setup(lights: any): void;
     setupView(lights: any, camera: any): void;

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

@@ -1,5 +1,4 @@
 import { WebGLRenderer } from '../WebGLRenderer.js';
-import { WebGLShader } from './WebGLShader.js';
 import { WebGLUniforms } from './WebGLUniforms.js';
 
 export class WebGLProgram {

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

@@ -1,12 +1,222 @@
+import { Material } from '../../materials/Material.js';
+import { Object3D } from '../../core/Object3D.js';
+import { Light } from '../../lights/Light.js';
+import { Scene } from '../../scenes/Scene.js';
+import { IUniform } from '../shaders/UniformsLib.js';
 import { WebGLRenderer } from '../WebGLRenderer.js';
-import { WebGLProgram } from './WebGLProgram.js';
+import { WebGLBindingStates } from './WebGLBindingStates.js';
 import { WebGLCapabilities } from './WebGLCapabilities.js';
+import { WebGLClipping } from './WebGLClipping.js';
 import { WebGLCubeMaps } from './WebGLCubeMaps.js';
 import { WebGLExtensions } from './WebGLExtensions.js';
-import { WebGLClipping } from './WebGLClipping.js';
-import { WebGLBindingStates } from './WebGLBindingStates.js';
-import { Material } from '../../materials/Material.js';
-import { Scene } from '../../scenes/Scene.js';
+import { WebGLLightsState } from './WebGLLights.js';
+import { WebGLProgram } from './WebGLProgram.js';
+import {
+    ColorSpace,
+    Combine,
+    DepthPackingStrategies,
+    GLSLVersion,
+    Mapping,
+    ShadowMapType,
+    ToneMapping,
+} from '../../constants.js';
+
+export interface WebGLProgramParameters {
+    isWebGL2: boolean;
+
+    shaderID: string;
+    shaderType: string;
+    shaderName: string;
+
+    vertexShader: string;
+    fragmentShader: string;
+    defines: { [define: string]: string | number | boolean } | undefined;
+
+    customVertexShaderID: string | undefined;
+    customFragmentShaderID: string | undefined;
+
+    isRawShaderMaterial: boolean;
+    glslVersion: GLSLVersion | null | undefined;
+
+    precision: 'lowp' | 'mediump' | 'highp';
+
+    batching: boolean;
+    instancing: boolean;
+    instancingColor: boolean;
+
+    supportsVertexTextures: boolean;
+    outputColorSpace: ColorSpace;
+    alphaToCoverage: boolean;
+
+    map: boolean;
+    matcap: boolean;
+    envMap: boolean;
+    envMapMode: Mapping | false;
+    envMapCubeUVHeight: number | null;
+    aoMap: boolean;
+    lightMap: boolean;
+    bumpMap: boolean;
+    normalMap: boolean;
+    displacementMap: boolean;
+    emissiveMap: boolean;
+
+    normalMapObjectSpace: boolean;
+    normalMapTangentSpace: boolean;
+
+    metalnessMap: boolean;
+    roughnessMap: boolean;
+
+    anisotropy: boolean;
+    anisotropyMap: boolean;
+
+    clearcoat: boolean;
+    clearcoatMap: boolean;
+    clearcoatNormalMap: boolean;
+    clearcoatRoughnessMap: boolean;
+
+    iridescence: boolean;
+    iridescenceMap: boolean;
+    iridescenceThicknessMap: boolean;
+
+    sheen: boolean;
+    sheenColorMap: boolean;
+    sheenRoughnessMap: boolean;
+
+    specularMap: boolean;
+    specularColorMap: boolean;
+    specularIntensityMap: boolean;
+
+    transmission: boolean;
+    transmissionMap: boolean;
+    thicknessMap: boolean;
+
+    gradientMap: boolean;
+
+    opaque: boolean;
+
+    alphaMap: boolean;
+    alphaTest: boolean;
+    alphaHash: boolean;
+
+    combine: Combine | undefined;
+
+    //
+
+    mapUv: string | false;
+    aoMapUv: string | false;
+    lightMapUv: string | false;
+    bumpMapUv: string | false;
+    normalMapUv: string | false;
+    displacementMapUv: string | false;
+    emissiveMapUv: string | false;
+
+    metalnessMapUv: string | false;
+    roughnessMapUv: string | false;
+
+    anisotropyMapUv: string | false;
+
+    clearcoatMapUv: string | false;
+    clearcoatNormalMapUv: string | false;
+    clearcoatRoughnessMapUv: string | false;
+
+    iridescenceMapUv: string | false;
+    iridescenceThicknessMapUv: string | false;
+
+    sheenColorMapUv: string | false;
+    sheenRoughnessMapUv: string | false;
+
+    specularMapUv: string | false;
+    specularColorMapUv: string | false;
+    specularIntensityMapUv: string | false;
+
+    transmissionMapUv: string | false;
+    thicknessMapUv: string | false;
+
+    alphaMapUv: string | false;
+
+    //
+
+    vertexTangents: boolean;
+    vertexColors: boolean;
+    vertexAlphas: boolean;
+    vertexUv1s: boolean;
+    vertexUv2s: boolean;
+    vertexUv3s: boolean;
+
+    pointsUvs: boolean;
+
+    fog: boolean;
+    useFog: boolean;
+    fogExp2: boolean;
+
+    flatShading: boolean;
+
+    sizeAttenuation: boolean;
+    logarithmicDepthBuffer: boolean;
+
+    skinning: boolean;
+
+    morphTargets: boolean;
+    morphNormals: boolean;
+    morphColors: boolean;
+    morphTargetsCount: number;
+    morphTextureStride: number;
+
+    numDirLights: number;
+    numPointLights: number;
+    numSpotLights: number;
+    numSpotLightMaps: number;
+    numRectAreaLights: number;
+    numHemiLights: number;
+
+    numDirLightShadows: number;
+    numPointLightShadows: number;
+    numSpotLightShadows: number;
+    numSpotLightShadowsWithMaps: number;
+
+    numLightProbes: number;
+
+    numClippingPlanes: number;
+    numClipIntersection: number;
+
+    dithering: boolean;
+
+    shadowMapEnabled: boolean;
+    shadowMapType: ShadowMapType;
+
+    toneMapping: ToneMapping;
+    useLegacyLights: boolean;
+
+    decodeVideoTexture: boolean;
+
+    premultipliedAlpha: boolean;
+
+    doubleSided: boolean;
+    flipSided: boolean;
+
+    useDepthPacking: boolean;
+    depthPacking: DepthPackingStrategies | 0;
+
+    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;
+}
+
+export interface WebGLProgramParametersWithUniforms extends WebGLProgramParameters {
+    uniforms: { [uniform: string]: IUniform };
+}
 
 export class WebGLPrograms {
     constructor(
@@ -20,9 +230,16 @@ export class WebGLPrograms {
 
     programs: WebGLProgram[];
 
-    getParameters(material: Material, lights: any, shadows: object[], scene: Scene, object: any): any;
-    getProgramCacheKey(parameters: any): string;
-    getUniforms(material: Material): object;
-    acquireProgram(parameters: any, cacheKey: string): WebGLProgram;
+    getParameters(
+        material: Material,
+        lights: WebGLLightsState,
+        shadows: Light[],
+        scene: Scene,
+        object: Object3D,
+    ): WebGLProgramParameters;
+
+    getProgramCacheKey(parameters: WebGLProgramParameters): string;
+    getUniforms(material: Material): { [uniform: string]: IUniform };
+    acquireProgram(parameters: WebGLProgramParametersWithUniforms, cacheKey: string): WebGLProgram;
     releaseProgram(program: WebGLProgram): void;
 }

three/src/renderers/webxr/WebXRDepthSensing.d.ts

@@ -0,0 +1,27 @@
+import { Texture } from '../../textures/Texture.js';
+import { Mesh } from '../../objects/Mesh.js';
+import { WebGLRenderer } from '../WebGLRenderer.js';
+import { WebXRArrayCamera } from './WebXRManager.js';
+
+// FIXME Replace by XRWebGLDepthInformation when typed in @types/webxr
+interface XRWebGLDepthInformation {
+    readonly texture: WebGLTexture;
+    readonly depthNear: number;
+    readonly depthFar: number;
+}
+
+export class WebXRDepthSensing {
+    texture: Texture | null;
+    mesh: Mesh | null;
+
+    depthNear: number;
+    depthFar: number;
+
+    constructor();
+
+    init(renderer: WebGLRenderer, depthData: XRWebGLDepthInformation, renderState: XRRenderState): void;
+
+    render(renderer: WebGLRenderer, cameraXR: WebXRArrayCamera): void;
+
+    reset(): void;
+}

three/src/renderers/webxr/WebXRManager.d.ts

@@ -7,6 +7,7 @@ import { ArrayCamera } from '../../cameras/ArrayCamera.js';
 import { PerspectiveCamera } from '../../cameras/PerspectiveCamera.js';
 import { EventDispatcher } from '../../core/EventDispatcher.js';
 import { XRTargetRaySpace, XRGripSpace, XRHandSpace } from './WebXRController.js';
+import { WebGLRenderer } from '../WebGLRenderer.js';
 
 export type WebXRCamera = PerspectiveCamera & { viewport: Vector4 };
 export type WebXRArrayCamera = Omit<ArrayCamera, 'cameras'> & { cameras: [WebXRCamera, WebXRCamera] };
@@ -21,7 +22,7 @@ export interface WebXRManagerEventMap {
 }
 
 export class WebXRManager extends EventDispatcher<WebXRManagerEventMap> {
-    constructor(renderer: any, gl: WebGLRenderingContext);
+    constructor(renderer: WebGLRenderer, gl: WebGLRenderingContext);
 
     /**
      * @default false

three/src/textures/CompressedCubeTexture.d.ts

@@ -0,0 +1,13 @@
+import { CompressedTexture } from './CompressedTexture.js';
+import { CompressedPixelFormat, TextureDataType } from '../constants.js';
+
+export class CompressedCubeTexture extends CompressedTexture {
+    readonly isCompressedCubeTexture: true;
+    readonly isCubeTexture: true;
+
+    constructor(
+        images: Array<{ width: number; height: number }>,
+        format?: CompressedPixelFormat,
+        type?: TextureDataType,
+    );
+}

three/src/textures/DataArrayTexture.d.ts

@@ -53,7 +53,7 @@ export class DataArrayTexture extends Texture {
      * @param height Height of the texture. Default `1`.
      * @param depth Depth of the texture. Default `1`.
      */
-    constructor(data?: BufferSource, width?: number, height?: number, depth?: number);
+    constructor(data?: BufferSource | null, width?: number, height?: number, depth?: number);
 
     /**
      * Read-only flag to check if a given object is of type {@link DataArrayTexture}.

three/src/textures/Source.d.ts

@@ -26,7 +26,17 @@ export class Source {
     data: any;
 
     /**
-     * Set this to `true` to trigger a data upload to the GPU next time the {@link Source} is used.
+     * This property is only relevant when {@link .needsUpdate} is set to `true` and provides more control on how
+     * texture data should be processed.
+     * When `dataReady` is set to `false`, the engine performs the memory allocation (if necessary) but does not
+     * transfer the data into the GPU memory.
+     * @default true
+     */
+    dataReady: boolean;
+
+    /**
+     * When the property is set to `true`, the engine allocates the memory for the texture (if necessary) and triggers
+     * the actual texture upload to the GPU next time the source is used.
      */
     set needsUpdate(value: boolean);
 

three/build/three.d.ts

@@ -1,2 +0,0 @@
-export * from '../src/Three.js';
-export as namespace THREE;

three/build/three.min.d.ts

@@ -1,2 +0,0 @@
-export * from '../src/Three.js';
-export as namespace THREE;