@types/three 0.159.0 → 0.160.0

three/src/materials/Material.d.ts

@@ -1,7 +1,7 @@
 import { Plane } from '../math/Plane.js';
 import { EventDispatcher } from '../core/EventDispatcher.js';
+import { WebGLProgramParametersWithUniforms } from '../renderers/webgl/WebGLPrograms.js';
 import { WebGLRenderer } from '../renderers/WebGLRenderer.js';
-import { Shader } from '../renderers/shaders/ShaderLib.js';
 import {
     BlendingDstFactor,
     BlendingEquation,
@@ -69,6 +69,13 @@ export interface MaterialParameters {
 export class Material extends EventDispatcher<{ dispose: {} }> {
     constructor();
 
+    /**
+     * Read-only flag to check if a given object is of type {@link Material}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isMaterial: true;
+
     /**
      * Enables alpha hashed transparency, an alternative to {@link .transparent} or {@link .alphaTest}. The material
      * will not be rendered if opacity is lower than a random threshold. Randomization introduces some grain or noise,
@@ -256,12 +263,6 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
      */
     stencilZPass: StencilOp;
 
-    /**
-     * Used to check whether this or derived classes are materials. Default is true.
-     * You should not change this, as it used internally for optimisation.
-     */
-    readonly isMaterial: true;
-
     /**
      * Material name. Default is an empty string.
      * @default ''
@@ -338,8 +339,8 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
     shadowSide: Side | null;
 
     /**
-     * Defines whether this material is tone mapped according to the renderer's toneMapping setting.
-     * Default is true.
+     * Defines whether this material is tone mapped according to the renderer's
+     * {@link WebGLRenderer.toneMapping toneMapping} setting. It is ignored when rendering to a render target.
      * @default true
      */
     toneMapped: boolean;
@@ -347,7 +348,6 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
     /**
      * Defines whether this material is transparent. This has an effect on rendering as transparent objects need special treatment and are rendered after non-transparent objects.
      * When set to true, the extent to which the material is transparent is controlled by setting it's .opacity property.
-     * Default is false.
      * @default false
      */
     transparent: boolean;
@@ -405,12 +405,12 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
 
     /**
      * An optional callback that is executed immediately before the shader program is compiled.
-     * This function is called with the shader source code as a parameter.
+     * This function is called with the associated WebGL program parameters and renderer.
      * Useful for the modification of built-in materials.
-     * @param shader Source code of the shader
-     * @param renderer WebGLRenderer Context that is initializing the material
+     * @param parameters WebGL program parameters
+     * @param renderer WebGLRenderer context that is initializing the material
      */
-    onBeforeCompile(shader: Shader, renderer: WebGLRenderer): void;
+    onBeforeCompile(parameters: WebGLProgramParametersWithUniforms, renderer: WebGLRenderer): void;
 
     /**
      * In case onBeforeCompile is used, this callback can be used to identify values of settings used in onBeforeCompile, so three.js can reuse a cached shader or recompile the shader as needed.

three/src/materials/MeshBasicMaterial.d.ts

@@ -29,6 +29,13 @@ export interface MeshBasicMaterialParameters extends MaterialParameters {
 export class MeshBasicMaterial extends Material {
     constructor(parameters?: MeshBasicMaterialParameters);
 
+    /**
+     * Read-only flag to check if a given object is of type {@link MeshBasicMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isMeshBasicMaterial: true;
+
     /**
      * @default 'MeshBasicMaterial'
      */

three/src/materials/MeshDepthMaterial.d.ts

@@ -15,6 +15,12 @@ export interface MeshDepthMaterialParameters extends MaterialParameters {
 
 export class MeshDepthMaterial extends Material {
     constructor(parameters?: MeshDepthMaterialParameters);
+    /**
+     * Read-only flag to check if a given object is of type {@link MeshDepthMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isMeshDepthMaterial: true;
 
     /**
      * @default 'MeshDepthMaterial'

three/src/materials/MeshDistanceMaterial.d.ts

@@ -16,6 +16,13 @@ export interface MeshDistanceMaterialParameters extends MaterialParameters {
 export class MeshDistanceMaterial extends Material {
     constructor(parameters?: MeshDistanceMaterialParameters);
 
+    /**
+     * Read-only flag to check if a given object is of type {@link MeshDistanceMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isMeshDistanceMaterial: true;
+
     /**
      * @default 'MeshDistanceMaterial'
      */

three/src/materials/MeshLambertMaterial.d.ts

@@ -38,6 +38,13 @@ export interface MeshLambertMaterialParameters extends MaterialParameters {
 export class MeshLambertMaterial extends Material {
     constructor(parameters?: MeshLambertMaterialParameters);
 
+    /**
+     * Read-only flag to check if a given object is of type {@link MeshLambertMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isMeshLambertMaterial: true;
+
     /**
      * @default 'MeshLambertMaterial'
      */

three/src/materials/MeshMatcapMaterial.d.ts

@@ -24,6 +24,13 @@ export interface MeshMatcapMaterialParameters extends MaterialParameters {
 export class MeshMatcapMaterial extends Material {
     constructor(parameters?: MeshMatcapMaterialParameters);
 
+    /**
+     * Read-only flag to check if a given object is of type {@link MeshMatcapMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isMeshMatcapMaterial: true;
+
     /**
      * @default 'MeshMatcapMaterial'
      */

three/src/materials/MeshNormalMaterial.d.ts

@@ -21,6 +21,13 @@ export interface MeshNormalMaterialParameters extends MaterialParameters {
 export class MeshNormalMaterial extends Material {
     constructor(parameters?: MeshNormalMaterialParameters);
 
+    /**
+     * Read-only flag to check if a given object is of type {@link MeshNormalMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isMeshNormalMaterial: true;
+
     /**
      * @default 'MeshNormalMaterial'
      */

three/src/materials/MeshPhongMaterial.d.ts

@@ -43,6 +43,13 @@ export interface MeshPhongMaterialParameters extends MaterialParameters {
 export class MeshPhongMaterial extends Material {
     constructor(parameters?: MeshPhongMaterialParameters);
 
+    /**
+     * Read-only flag to check if a given object is of type {@link MeshPhongMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isMeshPhongMaterial: true;
+
     /**
      * @default 'MeshNormalMaterial'
      */

three/src/materials/MeshPhysicalMaterial.d.ts

@@ -48,7 +48,12 @@ export interface MeshPhysicalMaterialParameters extends MeshStandardMaterialPara
 export class MeshPhysicalMaterial extends MeshStandardMaterial {
     constructor(parameters?: MeshPhysicalMaterialParameters);
 
-    isMeshPhysicalMaterial: boolean;
+    /**
+     * Read-only flag to check if a given object is of type {@link MeshPhysicalMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isMeshPhysicalMaterial: true;
 
     /**
      * @default 'MeshPhysicalMaterial'

three/src/materials/MeshStandardMaterial.d.ts

@@ -38,6 +38,13 @@ export interface MeshStandardMaterialParameters extends MaterialParameters {
 export class MeshStandardMaterial extends Material {
     constructor(parameters?: MeshStandardMaterialParameters);
 
+    /**
+     * Read-only flag to check if a given object is of type {@link MeshStandardMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isMeshStandardMaterial: true;
+
     /**
      * @default 'MeshStandardMaterial'
      */
@@ -200,7 +207,5 @@ export class MeshStandardMaterial extends Material {
      */
     fog: boolean;
 
-    isMeshStandardMaterial: boolean;
-
     setValues(parameters: MeshStandardMaterialParameters): void;
 }

three/src/materials/MeshToonMaterial.d.ts

@@ -36,6 +36,13 @@ export interface MeshToonMaterialParameters extends MaterialParameters {
 export class MeshToonMaterial extends Material {
     constructor(parameters?: MeshToonMaterialParameters);
 
+    /**
+     * Read-only flag to check if a given object is of type {@link MeshToonMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isMeshToonMaterial: true;
+
     /**
      * @default 'MeshToonMaterial'
      */

three/src/materials/PointsMaterial.d.ts

@@ -14,6 +14,13 @@ export interface PointsMaterialParameters extends MaterialParameters {
 export class PointsMaterial extends Material {
     constructor(parameters?: PointsMaterialParameters);
 
+    /**
+     * Read-only flag to check if a given object is of type {@link PointsMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isPointsMaterial: true;
+
     /**
      * @default 'PointsMaterial'
      */

three/src/materials/RawShaderMaterial.d.ts

@@ -2,4 +2,13 @@ import { ShaderMaterialParameters, ShaderMaterial } from './ShaderMaterial.js';
 
 export class RawShaderMaterial extends ShaderMaterial {
     constructor(parameters?: ShaderMaterialParameters);
+
+    /**
+     * Read-only flag to check if a given object is of type {@link RawShaderMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isRawShaderMaterial: true;
+
+    override readonly type: 'RawShaderMaterial';
 }

three/src/materials/ShaderMaterial.d.ts

@@ -28,6 +28,13 @@ export interface ShaderMaterialParameters extends MaterialParameters {
 export class ShaderMaterial extends Material {
     constructor(parameters?: ShaderMaterialParameters);
 
+    /**
+     * Read-only flag to check if a given object is of type {@link ShaderMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isShaderMaterial: true;
+
     /**
      * @default 'ShaderMaterial'
      */
@@ -85,13 +92,14 @@ export class ShaderMaterial extends Material {
     derivatives: any;
 
     /**
-     * @default { derivatives: false, fragDepth: false, drawBuffers: false, shaderTextureLOD: false }
+     * @default { derivatives: false, fragDepth: false, drawBuffers: false, shaderTextureLOD: false, clipCullDistance: false }
      */
     extensions: {
         derivatives: boolean;
         fragDepth: boolean;
         drawBuffers: boolean;
         shaderTextureLOD: boolean;
+        clipCullDistance: boolean;
     };
 
     /**
@@ -114,8 +122,6 @@ export class ShaderMaterial extends Material {
      */
     glslVersion: GLSLVersion | null;
 
-    isShaderMaterial: boolean;
-
     setValues(parameters: ShaderMaterialParameters): void;
     toJSON(meta: any): any;
 }

three/src/materials/ShadowMaterial.d.ts

@@ -9,6 +9,13 @@ export interface ShadowMaterialParameters extends MaterialParameters {
 export class ShadowMaterial extends Material {
     constructor(parameters?: ShadowMaterialParameters);
 
+    /**
+     * Read-only flag to check if a given object is of type {@link ShadowMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isShadowMaterial: true;
+
     /**
      * @default 'ShadowMaterial'
      */

three/src/materials/SpriteMaterial.d.ts

@@ -13,6 +13,13 @@ export interface SpriteMaterialParameters extends MaterialParameters {
 
 export class SpriteMaterial extends Material {
     constructor(parameters?: SpriteMaterialParameters);
+    /**
+     * Read-only flag to check if a given object is of type {@link SpriteMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isSpriteMaterial: true;
+
     /**
      * @default 'SpriteMaterial'
      */
@@ -54,8 +61,6 @@ export class SpriteMaterial extends Material {
      */
     fog: boolean;
 
-    readonly isSpriteMaterial: true;
-
     setValues(parameters: SpriteMaterialParameters): void;
     copy(source: SpriteMaterial): this;
 }

three/src/math/Matrix4.d.ts

@@ -94,40 +94,40 @@ export class Matrix4 implements Matrix {
         n42: number,
         n43: number,
         n44: number,
-    ): Matrix4;
+    ): this;
 
     /**
      * Resets this matrix to identity.
      */
-    identity(): Matrix4;
+    identity(): this;
     clone(): Matrix4;
     copy(m: Matrix4): this;
-    copyPosition(m: Matrix4): Matrix4;
-    extractBasis(xAxis: Vector3, yAxis: Vector3, zAxis: Vector3): Matrix4;
-    makeBasis(xAxis: Vector3, yAxis: Vector3, zAxis: Vector3): Matrix4;
+    copyPosition(m: Matrix4): this;
+    extractBasis(xAxis: Vector3, yAxis: Vector3, zAxis: Vector3): this;
+    makeBasis(xAxis: Vector3, yAxis: Vector3, zAxis: Vector3): this;
 
     /**
      * Copies the rotation component of the supplied matrix m into this matrix rotation component.
      */
-    extractRotation(m: Matrix4): Matrix4;
-    makeRotationFromEuler(euler: Euler): Matrix4;
-    makeRotationFromQuaternion(q: Quaternion): Matrix4;
+    extractRotation(m: Matrix4): this;
+    makeRotationFromEuler(euler: Euler): this;
+    makeRotationFromQuaternion(q: Quaternion): this;
     /**
      * Constructs a rotation matrix, looking from eye towards center with defined up vector.
      */
-    lookAt(eye: Vector3, target: Vector3, up: Vector3): Matrix4;
+    lookAt(eye: Vector3, target: Vector3, up: Vector3): this;
 
     /**
      * Multiplies this matrix by m.
      */
-    multiply(m: Matrix4): Matrix4;
+    multiply(m: Matrix4): this;
 
-    premultiply(m: Matrix4): Matrix4;
+    premultiply(m: Matrix4): this;
 
     /**
      * Sets this matrix to a x b.
      */
-    multiplyMatrices(a: Matrix4, b: Matrix4): Matrix4;
+    multiplyMatrices(a: Matrix4, b: Matrix4): this;
 
     /**
      * Sets this matrix to a x b and stores the result into the flat array r.
@@ -140,7 +140,7 @@ export class Matrix4 implements Matrix {
     /**
      * Multiplies this matrix by s.
      */
-    multiplyScalar(s: number): Matrix4;
+    multiplyScalar(s: number): this;
 
     /**
      * Computes determinant of this matrix.
@@ -151,23 +151,23 @@ export class Matrix4 implements Matrix {
     /**
      * Transposes this matrix.
      */
-    transpose(): Matrix4;
+    transpose(): this;
 
     /**
      * Sets the position component for this matrix from vector v.
      */
-    setPosition(v: Vector3): Matrix4;
-    setPosition(x: number, y: number, z: number): Matrix4;
+    setPosition(v: Vector3): this;
+    setPosition(x: number, y: number, z: number): this;
 
     /**
      * Inverts this matrix.
      */
-    invert(): Matrix4;
+    invert(): this;
 
     /**
      * Multiplies the columns of this matrix by vector v.
      */
-    scale(v: Vector3): Matrix4;
+    scale(v: Vector3): this;
 
     getMaxScaleOnAxis(): number;
     /**
@@ -181,21 +181,21 @@ export class Matrix4 implements Matrix {
      *
      * @param theta Rotation angle in radians.
      */
-    makeRotationX(theta: number): Matrix4;
+    makeRotationX(theta: number): this;
 
     /**
      * Sets this matrix as rotation transform around y axis by theta radians.
      *
      * @param theta Rotation angle in radians.
      */
-    makeRotationY(theta: number): Matrix4;
+    makeRotationY(theta: number): this;
 
     /**
      * Sets this matrix as rotation transform around z axis by theta radians.
      *
      * @param theta Rotation angle in radians.
      */
-    makeRotationZ(theta: number): Matrix4;
+    makeRotationZ(theta: number): this;
 
     /**
      * Sets this matrix as rotation transform around axis by angle radians.
@@ -204,27 +204,27 @@ export class Matrix4 implements Matrix {
      * @param axis Rotation axis.
      * @param theta Rotation angle in radians.
      */
-    makeRotationAxis(axis: Vector3, angle: number): Matrix4;
+    makeRotationAxis(axis: Vector3, angle: number): this;
 
     /**
      * Sets this matrix as scale transform.
      */
-    makeScale(x: number, y: number, z: number): Matrix4;
+    makeScale(x: number, y: number, z: number): this;
 
     /**
      * Sets this matrix as shear transform.
      */
-    makeShear(xy: number, xz: number, yx: number, yz: number, zx: number, zy: number): Matrix4;
+    makeShear(xy: number, xz: number, yx: number, yz: number, zx: number, zy: number): this;
 
     /**
      * Sets this matrix to the transformation composed of translation, rotation and scale.
      */
-    compose(translation: Vector3, rotation: Quaternion, scale: Vector3): Matrix4;
+    compose(translation: Vector3, rotation: Quaternion, scale: Vector3): this;
 
     /**
      * Decomposes this matrix into it's position, quaternion and scale components.
      */
-    decompose(translation: Vector3, rotation: Quaternion, scale: Vector3): Matrix4;
+    decompose(translation: Vector3, rotation: Quaternion, scale: Vector3): this;
 
     /**
      * Creates a perspective projection matrix.
@@ -237,7 +237,7 @@ export class Matrix4 implements Matrix {
         near: number,
         far: number,
         coordinateSystem?: CoordinateSystem,
-    ): Matrix4;
+    ): this;
 
     /**
      * Creates an orthographic projection matrix.
@@ -250,7 +250,7 @@ export class Matrix4 implements Matrix {
         near: number,
         far: number,
         coordinateSystem?: CoordinateSystem,
-    ): Matrix4;
+    ): this;
     equals(matrix: Matrix4): boolean;
 
     /**
@@ -258,7 +258,7 @@ export class Matrix4 implements Matrix {
      * @param array the source array or array-like.
      * @param offset (optional) offset into the array-like. Default is 0.
      */
-    fromArray(array: number[] | ArrayLike<number>, offset?: number): Matrix4;
+    fromArray(array: number[] | ArrayLike<number>, offset?: number): this;
 
     /**
      * Returns an array with the values of this matrix, or copies them into the provided array.
@@ -280,7 +280,7 @@ export class Matrix4 implements Matrix {
     /**
      * Set the upper 3x3 elements of this matrix to the values of the Matrix3 m.
      */
-    setFromMatrix3(m: Matrix3): Matrix4;
+    setFromMatrix3(m: Matrix3): this;
 
     /**
      * @deprecated Use {@link Matrix4#copyPosition .copyPosition()} instead.

three/src/math/Sphere.d.ts

@@ -6,6 +6,11 @@ import { Matrix4 } from './Matrix4.js';
 export class Sphere {
     constructor(center?: Vector3, radius?: number);
 
+    /**
+     * Read-only flag to check if a given object is of type {@link Sphere}.
+     */
+    readonly isSphere: true;
+
     /**
      * @default new Vector3()
      */

three/src/math/Triangle.d.ts

@@ -39,14 +39,14 @@ export class Triangle {
     getMidpoint(target: Vector3): Vector3;
     getNormal(target: Vector3): Vector3;
     getPlane(target: Plane): Plane;
-    getBarycoord(point: Vector3, target: Vector3): Vector3;
+    getBarycoord(point: Vector3, target: Vector3): Vector3 | null;
     /**
      * @deprecated Triangle.getUV() has been renamed to Triangle.getInterpolation().
      */
     getUV(point: Vector3, uv1: Vector2, uv2: Vector2, uv3: Vector2, target: Vector2): Vector2;
-    getInterpolation(point: Vector3, v1: Vector2, v2: Vector2, v3: Vector2, target: Vector2): Vector2;
-    getInterpolation(point: Vector3, v1: Vector3, v2: Vector3, v3: Vector3, target: Vector3): Vector3;
-    getInterpolation(point: Vector3, v1: Vector4, v2: Vector4, v3: Vector4, target: Vector4): Vector4;
+    getInterpolation(point: Vector3, v1: Vector2, v2: Vector2, v3: Vector2, target: Vector2): Vector2 | null;
+    getInterpolation(point: Vector3, v1: Vector3, v2: Vector3, v3: Vector3, target: Vector3): Vector3 | null;
+    getInterpolation(point: Vector3, v1: Vector4, v2: Vector4, v3: Vector4, target: Vector4): Vector4 | null;
     containsPoint(point: Vector3): boolean;
     intersectsBox(box: Box3): boolean;
     isFrontFacing(direction: Vector3): boolean;
@@ -54,7 +54,7 @@ export class Triangle {
     equals(triangle: Triangle): boolean;
 
     static getNormal(a: Vector3, b: Vector3, c: Vector3, target: Vector3): Vector3;
-    static getBarycoord(point: Vector3, a: Vector3, b: Vector3, c: Vector3, target: Vector3): Vector3;
+    static getBarycoord(point: Vector3, a: Vector3, b: Vector3, c: Vector3, target: Vector3): Vector3 | null;
     static containsPoint(point: Vector3, a: Vector3, b: Vector3, c: Vector3): boolean;
     /**
      * @deprecated THREE.Triangle.getUV() has been renamed to THREE.Triangle.getInterpolation().
@@ -78,7 +78,7 @@ export class Triangle {
         v2: Vector2,
         v3: Vector2,
         target: Vector2,
-    ): Vector2;
+    ): Vector2 | null;
     static getInterpolation(
         point: Vector3,
         p1: Vector3,
@@ -88,7 +88,7 @@ export class Triangle {
         v2: Vector3,
         v3: Vector3,
         target: Vector3,
-    ): Vector3;
+    ): Vector3 | null;
     static getInterpolation(
         point: Vector3,
         p1: Vector3,
@@ -98,6 +98,6 @@ export class Triangle {
         v2: Vector4,
         v3: Vector4,
         target: Vector4,
-    ): Vector4;
+    ): Vector4 | null;
     static isFrontFacing(a: Vector3, b: Vector3, c: Vector3, direction: Vector3): boolean;
 }

three/src/objects/SkinnedMesh.d.ts

@@ -11,8 +11,7 @@ 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);

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[];