@types/three 0.182.0 → 0.183.0

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

@@ -56,7 +56,7 @@ declare class WebGLState {
     disable(id: number): void;
     bindFramebuffer(target: number, framebuffer: WebGLFramebuffer | null): void;
     drawBuffers(renderTarget: WebGLRenderTarget | null, framebuffer: WebGLFramebuffer | null): void;
-    useProgram(program: any): boolean;
+    useProgram(program: WebGLProgram): boolean;
     setBlending(
         blending: Blending,
         blendEquation?: BlendingEquation,
@@ -74,43 +74,320 @@ declare class WebGLState {
     setPolygonOffset(polygonoffset: boolean, factor?: number, units?: number): void;
     setScissorTest(scissorTest: boolean): void;
     activeTexture(webglSlot: number): void;
-    bindTexture(webglType: number, webglTexture: any): void;
+    bindTexture(webglType: number, webglTexture: WebGLTexture, webglSlot?: number): void;
     unbindTexture(): void;
+
     // Same interface as https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/compressedTexImage2D
     compressedTexImage2D(
-        target: number,
-        level: number,
-        internalformat: number,
-        width: number,
-        height: number,
-        border: number,
-        data: ArrayBufferView,
+        target: GLenum,
+        level: GLint,
+        internalformat: GLenum,
+        width: GLsizei,
+        height: GLsizei,
+        border: GLint,
+        imageSize: GLsizei,
+        offset: GLintptr,
+    ): void;
+    compressedTexImage2D(
+        target: GLenum,
+        level: GLint,
+        internalformat: GLenum,
+        width: GLsizei,
+        height: GLsizei,
+        border: GLint,
+        srcData: ArrayBufferView,
+        srcOffset?: number,
+        srcLengthOverride?: GLuint,
+    ): void;
+
+    compressedTexImage3D(
+        target: GLenum,
+        level: GLint,
+        internalformat: GLenum,
+        width: GLsizei,
+        height: GLsizei,
+        depth: GLsizei,
+        border: GLint,
+        imageSize: GLsizei,
+        offset: GLintptr,
+    ): void;
+    compressedTexImage3D(
+        target: GLenum,
+        level: GLint,
+        internalformat: GLenum,
+        width: GLsizei,
+        height: GLsizei,
+        depth: GLsizei,
+        border: GLint,
+        srcData: ArrayBufferView,
+        srcOffset?: number,
+        srcLengthOverride?: GLuint,
+    ): void;
+
+    texSubImage2D(
+        target: GLenum,
+        level: GLint,
+        xoffset: GLint,
+        yoffset: GLint,
+        width: GLsizei,
+        height: GLsizei,
+        format: GLenum,
+        type: GLenum,
+        pixels: ArrayBufferView | null,
+    ): void;
+    texSubImage2D(
+        target: GLenum,
+        level: GLint,
+        xoffset: GLint,
+        yoffset: GLint,
+        format: GLenum,
+        type: GLenum,
+        source: TexImageSource,
+    ): void;
+    texSubImage2D(
+        target: GLenum,
+        level: GLint,
+        xoffset: GLint,
+        yoffset: GLint,
+        width: GLsizei,
+        height: GLsizei,
+        format: GLenum,
+        type: GLenum,
+        pboOffset: GLintptr,
+    ): void;
+    texSubImage2D(
+        target: GLenum,
+        level: GLint,
+        xoffset: GLint,
+        yoffset: GLint,
+        width: GLsizei,
+        height: GLsizei,
+        format: GLenum,
+        type: GLenum,
+        source: TexImageSource,
+    ): void;
+    texSubImage2D(
+        target: GLenum,
+        level: GLint,
+        xoffset: GLint,
+        yoffset: GLint,
+        width: GLsizei,
+        height: GLsizei,
+        format: GLenum,
+        type: GLenum,
+        srcData: ArrayBufferView,
+        srcOffset: number,
+    ): void;
+
+    texSubImage3D(
+        target: GLenum,
+        level: GLint,
+        xoffset: GLint,
+        yoffset: GLint,
+        zoffset: GLint,
+        width: GLsizei,
+        height: GLsizei,
+        depth: GLsizei,
+        format: GLenum,
+        type: GLenum,
+        pboOffset: GLintptr,
+    ): void;
+    texSubImage3D(
+        target: GLenum,
+        level: GLint,
+        xoffset: GLint,
+        yoffset: GLint,
+        zoffset: GLint,
+        width: GLsizei,
+        height: GLsizei,
+        depth: GLsizei,
+        format: GLenum,
+        type: GLenum,
+        source: TexImageSource,
+    ): void;
+    texSubImage3D(
+        target: GLenum,
+        level: GLint,
+        xoffset: GLint,
+        yoffset: GLint,
+        zoffset: GLint,
+        width: GLsizei,
+        height: GLsizei,
+        depth: GLsizei,
+        format: GLenum,
+        type: GLenum,
+        srcData: ArrayBufferView | null,
+        srcOffset?: number,
+    ): void;
+
+    compressedTexSubImage2D(
+        target: GLenum,
+        level: GLint,
+        xoffset: GLint,
+        yoffset: GLint,
+        width: GLsizei,
+        height: GLsizei,
+        format: GLenum,
+        imageSize: GLsizei,
+        offset: GLintptr,
+    ): void;
+    compressedTexSubImage2D(
+        target: GLenum,
+        level: GLint,
+        xoffset: GLint,
+        yoffset: GLint,
+        width: GLsizei,
+        height: GLsizei,
+        format: GLenum,
+        srcData: ArrayBufferView,
+        srcOffset?: number,
+        srcLengthOverride?: GLuint,
+    ): void;
+
+    compressedTexSubImage3D(
+        target: GLenum,
+        level: GLint,
+        xoffset: GLint,
+        yoffset: GLint,
+        zoffset: GLint,
+        width: GLsizei,
+        height: GLsizei,
+        depth: GLsizei,
+        format: GLenum,
+        imageSize: GLsizei,
+        offset: GLintptr,
     ): void;
+    compressedTexSubImage3D(
+        target: GLenum,
+        level: GLint,
+        xoffset: GLint,
+        yoffset: GLint,
+        zoffset: GLint,
+        width: GLsizei,
+        height: GLsizei,
+        depth: GLsizei,
+        format: GLenum,
+        srcData: ArrayBufferView,
+        srcOffset?: number,
+        srcLengthOverride?: GLuint,
+    ): void;
+
+    texStorage2D(target: GLenum, levels: GLsizei, internalformat: GLenum, width: GLsizei, height: GLsizei): void;
+
+    texStorage3D(
+        target: GLenum,
+        levels: GLsizei,
+        internalformat: GLenum,
+        width: GLsizei,
+        height: GLsizei,
+        depth: GLsizei,
+    ): void;
+
     // Same interface as https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/texImage2D
     texImage2D(
-        target: number,
-        level: number,
-        internalformat: number,
-        width: number,
-        height: number,
-        border: number,
-        format: number,
-        type: number,
+        target: GLenum,
+        level: GLint,
+        internalformat: GLint,
+        width: GLsizei,
+        height: GLsizei,
+        border: GLint,
+        format: GLenum,
+        type: GLenum,
         pixels: ArrayBufferView | null,
     ): void;
-    texImage2D(target: number, level: number, internalformat: number, format: number, type: number, source: any): void;
+    texImage2D(
+        target: GLenum,
+        level: GLint,
+        internalformat: GLint,
+        format: GLenum,
+        type: GLenum,
+        source: TexImageSource,
+    ): void;
+    texImage2D(
+        target: GLenum,
+        level: GLint,
+        internalformat: GLint,
+        width: GLsizei,
+        height: GLsizei,
+        border: GLint,
+        format: GLenum,
+        type: GLenum,
+        pboOffset: GLintptr,
+    ): void;
+    texImage2D(
+        target: GLenum,
+        level: GLint,
+        internalformat: GLint,
+        width: GLsizei,
+        height: GLsizei,
+        border: GLint,
+        format: GLenum,
+        type: GLenum,
+        source: TexImageSource,
+    ): void;
+    texImage2D(
+        target: GLenum,
+        level: GLint,
+        internalformat: GLint,
+        width: GLsizei,
+        height: GLsizei,
+        border: GLint,
+        format: GLenum,
+        type: GLenum,
+        srcData: ArrayBufferView,
+        srcOffset: number,
+    ): void;
+
+    texImage3D(
+        target: GLenum,
+        level: GLint,
+        internalformat: GLint,
+        width: GLsizei,
+        height: GLsizei,
+        depth: GLsizei,
+        border: GLint,
+        format: GLenum,
+        type: GLenum,
+        pboOffset: GLintptr,
+    ): void;
     texImage3D(
-        target: number,
-        level: number,
-        internalformat: number,
-        width: number,
-        height: number,
-        depth: number,
-        border: number,
-        format: number,
-        type: number,
-        pixels: any,
+        target: GLenum,
+        level: GLint,
+        internalformat: GLint,
+        width: GLsizei,
+        height: GLsizei,
+        depth: GLsizei,
+        border: GLint,
+        format: GLenum,
+        type: GLenum,
+        source: TexImageSource,
     ): void;
+    texImage3D(
+        target: GLenum,
+        level: GLint,
+        internalformat: GLint,
+        width: GLsizei,
+        height: GLsizei,
+        depth: GLsizei,
+        border: GLint,
+        format: GLenum,
+        type: GLenum,
+        srcData: ArrayBufferView | null,
+    ): void;
+    texImage3D(
+        target: GLenum,
+        level: GLint,
+        internalformat: GLint,
+        width: GLsizei,
+        height: GLsizei,
+        depth: GLsizei,
+        border: GLint,
+        format: GLenum,
+        type: GLenum,
+        srcData: ArrayBufferView,
+        srcOffset: number,
+    ): void;
+
     scissor(scissor: Vector4): void;
     viewport(viewport: Vector4): void;
     reset(): void;

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

@@ -1,3 +1,5 @@
+import { RenderTarget } from "../../core/RenderTarget.js";
+import { Texture } from "../../textures/Texture.js";
 import { WebGLCapabilities } from "./WebGLCapabilities.js";
 import { WebGLExtensions } from "./WebGLExtensions.js";
 import { WebGLInfo } from "./WebGLInfo.js";
@@ -18,13 +20,12 @@ export class WebGLTextures {
 
     allocateTextureUnit(): void;
     resetTextureUnits(): void;
-    setTexture2D(texture: any, slot: number): void;
-    setTexture2DArray(texture: any, slot: number): void;
-    setTexture3D(texture: any, slot: number): void;
-    setTextureCube(texture: any, slot: number): void;
-    setupRenderTarget(renderTarget: any): void;
-    updateRenderTargetMipmap(renderTarget: any): void;
-    updateMultisampleRenderTarget(renderTarget: any): void;
-    safeSetTexture2D(texture: any, slot: number): void;
-    safeSetTextureCube(texture: any, slot: number): void;
+
+    setTexture2D(texture: Texture, slot: number): void;
+    setTexture2DArray(texture: Texture, slot: number): void;
+    setTexture3D(texture: Texture, slot: number): void;
+    setTextureCube(texture: Texture, slot: number): void;
+    setupRenderTarget(renderTarget: RenderTarget): void;
+    updateRenderTargetMipmap(renderTarget: RenderTarget): void;
+    updateMultisampleRenderTarget(renderTarget: RenderTarget): void;
 }

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

@@ -1,12 +1,5 @@
 import { WebGLProgram } from "./WebGLProgram.js";
-import { WebGLTextures } from "./WebGLTextures.js";
 
 export class WebGLUniforms {
     constructor(gl: WebGLRenderingContext, program: WebGLProgram);
-
-    setValue(gl: WebGLRenderingContext, name: string, value: any, textures: WebGLTextures): void;
-    setOptional(gl: WebGLRenderingContext, object: any, name: string): void;
-
-    static upload(gl: WebGLRenderingContext, seq: any, values: any[], textures: WebGLTextures): void;
-    static seqWithValue(seq: any, values: any[]): any[];
 }

three/src/renderers/webgpu/WebGPUBackend.d.ts

@@ -5,7 +5,6 @@ import Backend, { BackendParameters } from "../common/Backend.js";
 
 export interface WebGPUBackendParameters extends BackendParameters {
     alpha?: boolean | undefined;
-    compatibilityMode?: boolean | undefined;
     requiredLimits?: Record<string, GPUSize64> | undefined;
     trackTimestamp?: boolean | undefined;
     device?: GPUDevice | undefined;

three/src/renderers/webgpu/nodes/BasicNodeLibrary.d.ts

@@ -1,4 +1,5 @@
 import NodeLibrary from "../../common/nodes/NodeLibrary.js";
+
 /**
  * This version of a node library represents a basic version
  * just focusing on lights and tone mapping techniques.
@@ -7,9 +8,6 @@ import NodeLibrary from "../../common/nodes/NodeLibrary.js";
  * @augments NodeLibrary
  */
 declare class BasicNodeLibrary extends NodeLibrary {
-    /**
-     * Constructs a new basic node library.
-     */
-    constructor();
 }
+
 export default BasicNodeLibrary;

three/src/renderers/webgpu/nodes/StandardNodeLibrary.d.ts

@@ -12,6 +12,7 @@ import { PointsNodeMaterialNodeProperties } from "../../../materials/nodes/Point
 import { ShadowNodeMaterialNodeProperties } from "../../../materials/nodes/ShadowNodeMaterial.js";
 import { SpriteNodeMaterialNodeProperties } from "../../../materials/nodes/SpriteNodeMaterial.js";
 import NodeLibrary from "../../common/nodes/NodeLibrary.js";
+
 /**
  * This version of a node library represents the standard version
  * used in {@link WebGPURenderer}. It maps lights, tone mapping
@@ -21,61 +22,71 @@ import NodeLibrary from "../../common/nodes/NodeLibrary.js";
  * @augments NodeLibrary
  */
 declare class StandardNodeLibrary extends NodeLibrary {
-    /**
-     * Constructs a new standard node library.
-     */
-    constructor();
 }
+
 declare module "../../../materials/MeshPhongMaterial.js" {
     interface MeshPhongMaterialProperties extends MeshPhongNodeMaterialNodeProperties {
     }
 }
+
 declare module "../../../materials/MeshStandardMaterial.js" {
     interface MeshStandardMaterialProperties extends MeshStandardNodeMaterialNodeProperties {
     }
 }
+
 declare module "../../../materials/MeshPhysicalMaterial.js" {
     interface MeshPhysicalMaterialProperties extends MeshPhysicalNodeMaterialNodeProperties {
     }
 }
+
 declare module "../../../materials/MeshToonMaterial.js" {
     interface MeshToonMaterialProperties extends MeshToonNodeMaterialNodeProperties {
     }
 }
+
 declare module "../../../materials/MeshBasicMaterial.js" {
     interface MeshBasicMaterialProperties extends MeshBasicNodeMaterialNodeProperties {
     }
 }
+
 declare module "../../../materials/MeshLambertMaterial.js" {
     interface MeshLambertMaterialProperties extends MeshLambertNodeMaterialNodeProperties {
     }
 }
+
 declare module "../../../materials/MeshNormalMaterial.js" {
     interface MeshNormalMaterialProperties extends MeshNormalNodeMaterialNodeProperties {
     }
 }
+
 declare module "../../../materials/MeshMatcapMaterial.js" {
     interface MeshMatcapMaterialProperties extends MeshMatcapNodeMaterialNodeProperties {
     }
 }
+
 declare module "../../../materials/LineBasicMaterial.js" {
     interface LineBasicMaterialProperties extends LineBasicNodeMaterialNodeProperties {
     }
 }
+
 declare module "../../../materials/LineDashedMaterial.js" {
     interface LineDashedMaterialProperties extends LineDashedNodeMaterialNodeProperties {
     }
 }
+
 declare module "../../../materials/PointsMaterial.js" {
     interface PointsMaterialProperties extends PointsNodeMaterialNodeProperties {
     }
 }
+
 declare module "../../../materials/SpriteMaterial.js" {
     interface SpriteMaterialProperties extends SpriteNodeMaterialNodeProperties {
     }
 }
+
 declare module "../../../materials/ShadowMaterial.js" {
     interface ShadowMaterialProperties extends ShadowNodeMaterialNodeProperties {
     }
 }
+
 export default StandardNodeLibrary;

three/src/renderers/webgpu/nodes/WGSLNodeBuilder.d.ts

@@ -82,7 +82,7 @@ export default class WGSLNodeBuilder extends NodeBuilder {
         shaderStage: NodeShaderStage,
     ): string;
 
-    getPropertyName<TValue>(node: NodeVar | NodeUniform<TValue>, shaderStage: NodeShaderStage): string;
+    getPropertyName(node: NodeVar | NodeUniform<unknown, unknown>, shaderStage: NodeShaderStage): string;
 
     getOutputStructName(): string;
 

three/src/scenes/Fog.d.ts

@@ -9,69 +9,63 @@ export interface FogJSON {
 }
 
 /**
- * This class contains the parameters that define linear fog, i.e., that grows linearly denser with the distance.
- *  @example
- * ```typescript
+ * This class can be used to define a linear fog that grows linearly denser
+ * with the distance.
+ *
+ * ```js
  * const scene = new THREE.Scene();
- * scene.fog = new THREE.Fog(0xcccccc, 10, 15);
+ * scene.fog = new THREE.Fog( 0xcccccc, 10, 15 );
  * ```
- * @see {@link https://threejs.org/docs/index.html#api/en/scenes/Fog | Official Documentation}
- * @see {@link https://github.com/mrdoob/three.js/blob/master/src/scenes/Fog.js | Source}
  */
 export class Fog {
     /**
-     * The color parameter is passed to the {@link THREE.Color | Color} constructor to set the color property
-     * @remarks
-     * Color can be a hexadecimal integer or a CSS-style string.
-     * @param color
-     * @param near Expects a `Float`
-     * @param far Expects a `Float`
+     * Constructs a new fog.
+     *
+     * @param {number|Color} color - The fog's color.
+     * @param {number} [near=1] - The minimum distance to start applying fog.
+     * @param {number} [far=1000] - The maximum distance at which fog stops being calculated and applied.
      */
     constructor(color: ColorRepresentation, near?: number, far?: number);
-
     /**
-     * Read-only flag to check if a given object is of type {@link Fog}.
-     * @remarks This is a _constant_ value
-     * @defaultValue `true`
+     * This flag can be used for type testing.
+     *
+     * @default true
      */
-    readonly isFog: true;
-
+    readonly isFog: boolean;
     /**
-     * Optional name of the object
-     * @remarks _(doesn't need to be unique)_.
-     * @defaultValue `""`
+     * The name of the fog.
      */
     name: string;
-
     /**
-     * Fog color.
-     * @remarks If set to black, far away objects will be rendered black.
+     * The fog's color.
      */
     color: Color;
-
     /**
-     * The minimum distance to start applying fog.
-     * @remarks Objects that are less than **near** units from the active camera won't be affected by fog.
-     * @defaultValue `1`
-     * @remarks Expects a `Float`
+     * The minimum distance to start applying fog. Objects that are less than
+     * `near` units from the active camera won't be affected by fog.
+     *
+     * @default 1
      */
     near: number;
-
     /**
      * The maximum distance at which fog stops being calculated and applied.
-     * @remarks Objects that are more than **far** units away from the active camera won't be affected by fog.
-     * @defaultValue `1000`
-     * @remarks Expects a `Float`
+     * Objects that are more than `far` units away from the active camera won't
+     * be affected by fog.
+     *
+     * @default 1000
      */
     far: number;
-
     /**
-     * Returns a new {@link Fog} instance with the same parameters as this one.
+     * Returns a new fog with copied values from this instance.
+     *
+     * @return {Fog} A clone of this instance.
      */
     clone(): Fog;
-
     /**
-     * Return {@link Fog} data in JSON format.
+     * Serializes the fog into JSON.
+     *
+     * @param {?(Object|string)} meta - An optional value holding meta information about the serialization.
+     * @return {Object} A JSON object representing the serialized fog
      */
     toJSON(): FogJSON;
 }