@types/three 0.177.0 → 0.178.1

three/src/nodes/utils/UVUtils.d.ts

@@ -1,14 +1,15 @@
+import Node from "../core/Node.js";
 import OperatorNode from "../math/OperatorNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export const rotateUV: (
-    uv: NodeRepresentation,
-    rotation: NodeRepresentation,
-    center?: NodeRepresentation,
+    uv: Node,
+    rotation: Node,
+    center?: Node,
 ) => ShaderNodeObject<OperatorNode>;
 
 export const spherizeUV: (
-    uv: NodeRepresentation,
-    strength: NodeRepresentation,
-    center?: NodeRepresentation,
+    uv: Node,
+    strength: Node | number,
+    center?: Node,
 ) => ShaderNodeObject<OperatorNode>;

three/src/nodes/utils/ViewportUtils.d.ts

@@ -1,4 +1,4 @@
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const viewportSafeUV: (uv?: NodeRepresentation | null) => ShaderNodeObject<Node>;
+export const viewportSafeUV: (uv?: Node | null) => ShaderNodeObject<Node>;

three/src/objects/LOD.d.ts

@@ -87,7 +87,7 @@ export class LOD<TEventMap extends Object3DEventMap = Object3DEventMap> extends
      * Otherwise `false`.
      * @param distance Distance of the level to delete.
      */
-    removeLabel(distance: number): boolean;
+    removeLevel(distance: number): boolean;
 
     /**
      * Get the currently active {@link LOD} level

three/src/renderers/WebGLRenderer.d.ts

@@ -463,7 +463,7 @@ export class WebGLRenderer {
      * position. The `depthTexture` and `texture` property of 3D render targets are supported as well.
      *
      * When using render target textures as `srcTexture` and `dstTexture`, you must make sure both render targets are
-     * intitialized e.g. via {@link .initRenderTarget}().
+     * initialized e.g. via {@link .initRenderTarget}().
      *
      * @param srcTexture Specifies the source texture.
      * @param dstTexture Specifies the destination texture.

three/src/renderers/common/Backend.d.ts

@@ -13,12 +13,12 @@ declare module "../../core/Object3D.js" {
 }
 
 export interface BackendParameters {
-    canvas?: HTMLCanvasElement | undefined;
+    canvas?: HTMLCanvasElement | OffscreenCanvas | undefined;
 }
 
 export default abstract class Backend {
     renderer: Renderer | null;
-    domElement: HTMLCanvasElement | null;
+    domElement: HTMLCanvasElement | OffscreenCanvas | null;
 
     constructor(parameters?: BackendParameters);
 
@@ -26,5 +26,5 @@ export default abstract class Backend {
 
     abstract get coordinateSystem(): CoordinateSystem;
 
-    getDomElement(): HTMLCanvasElement;
+    getDomElement(): HTMLCanvasElement | OffscreenCanvas;
 }

three/src/renderers/common/RenderObject.d.ts

@@ -53,7 +53,14 @@ declare class RenderObject {
         count: number;
     } | null;
     attributes: Array<BufferAttribute | InterleavedBufferAttribute> | null;
+    attributesId: {
+        [attributeName: string]: number;
+    } | null;
     pipeline: RenderPipeline | null;
+    group: {
+        start: number;
+        count: number;
+    } | null;
     vertexBuffers: Array<BufferAttribute | InterleavedBuffer> | null;
     drawParams: {
         vertexCount: number;
@@ -64,14 +71,15 @@ declare class RenderObject {
     bundle: BundleGroup | null;
     clippingContext: ClippingContext | null;
     clippingContextCacheKey: string;
-    initialNodesCacheKey: string;
-    initialCacheKey: string;
+    initialNodesCacheKey: number;
+    initialCacheKey: number;
     _nodeBuilderState: NodeBuilderState | null;
     _bindings: BindGroup[] | null;
     _monitor: NodeMaterialObserver | null;
     onDispose: (() => void) | null;
     readonly isRenderObject: true;
     onMaterialDispose: () => void;
+    onGeometryDispose: () => void;
     /**
      * Constructs a new render object.
      *

three/src/renderers/common/Renderer.d.ts

@@ -239,7 +239,7 @@ declare class Renderer {
      * @param {?Scene} targetScene - If the first argument is a 3D object, this parameter must represent the scene the 3D object is going to be added.
      * @return {Promise<Array|undefined>} A Promise that resolves when the compile has been finished.
      */
-    compileAsync(scene: Object3D, camera: Camera, targetScene?: Object3D | null): Promise<void>;
+    compileAsync(scene: Object3D, camera: Camera, targetScene?: Scene | null): Promise<void>;
     /**
      * Renders the scene in an async fashion.
      *
@@ -248,7 +248,7 @@ declare class Renderer {
      * @param {Camera} camera - The camera.
      * @return {Promise} A Promise that resolves when the render has been finished.
      */
-    renderAsync(scene: Scene, camera: Camera): Promise<void>;
+    renderAsync(scene: Object3D, camera: Camera): Promise<void>;
     /**
      * Can be used to synchronize CPU operations with GPU tasks. So when this method is called,
      * the CPU waits for the GPU to complete its operation (e.g. a compute task).
@@ -321,7 +321,7 @@ declare class Renderer {
      * @return {?Promise} A Promise that resolve when the scene has been rendered.
      * Only returned when the renderer has not been initialized.
      */
-    render(scene: Scene, camera: Camera): Promise<void> | undefined;
+    render(scene: Object3D, camera: Camera): Promise<void> | undefined;
     /**
      * Returns an internal render target which is used when computing the output tone mapping
      * and color space conversion. Unlike in `WebGLRenderer`, this is done in a separate render
@@ -340,7 +340,7 @@ declare class Renderer {
      * @param {boolean} [useFrameBufferTarget=true] - Whether to use a framebuffer target or not.
      * @return {RenderContext} The current render context.
      */
-    _renderScene(scene: Scene, camera: Camera, useFrameBufferTarget?: boolean): RenderContext | undefined;
+    _renderScene(scene: Object3D, camera: Camera, useFrameBufferTarget?: boolean): RenderContext | undefined;
     _setXRLayerSize(width: number, height: number): void;
     /**
      * The output pass performs tone mapping and color space conversion.
@@ -983,6 +983,6 @@ declare class Renderer {
      * @param {Scene} targetScene - If the first argument is a 3D object, this parameter must represent the scene the 3D object is going to be added.
      * @return {function(Object3D, Camera, ?Scene): Promise|undefined} A Promise that resolves when the compile has been finished.
      */
-    get compile(): (scene: Object3D, camera: Camera, targetScene?: Object3D | null) => Promise<void>;
+    get compile(): (scene: Object3D, camera: Camera, targetScene?: Scene | null) => Promise<void>;
 }
 export default Renderer;

three/src/renderers/common/Storage3DTexture.d.ts

@@ -0,0 +1,40 @@
+import { Wrapping } from "../../constants.js";
+import { Texture } from "../../textures/Texture.js";
+
+/**
+ * This special type of texture is intended for compute shaders.
+ * It can be used to compute the data of a texture with a compute shader.
+ *
+ * Note: This type of texture can only be used with `WebGPURenderer`
+ * and a WebGPU backend.
+ */
+declare class Storage3DTexture extends Texture {
+    /**
+     * This defines how the texture is wrapped in the depth direction and corresponds to
+     * *W* in UVW mapping.
+     */
+    wrapR: Wrapping;
+
+    /**
+     * This flag can be used for type testing.
+     *
+     * @default true
+     */
+    readonly isStorageTexture: true;
+
+    /**
+     * Indicates whether this texture is a 3D texture.
+     */
+    is3DTexture: boolean;
+
+    /**
+     * Constructs a new storage texture.
+     *
+     * @param {number} [width=1] - The storage texture's width.
+     * @param {number} [height=1] - The storage texture's height.
+     * @param {number} [depth=1] - The storage texture's depth.
+     */
+    constructor(width?: number, height?: number, depth?: number);
+}
+
+export default Storage3DTexture;

three/src/renderers/common/StorageArrayTexture.d.ts

@@ -0,0 +1,29 @@
+import { Wrapping } from "../../constants.js";
+import { Texture } from "../../textures/Texture.js";
+
+/**
+ * This special type of texture is intended for compute shaders.
+ * It can be used to compute the data of a texture with a compute shader.
+ *
+ * Note: This type of texture can only be used with `WebGPURenderer`
+ * and a WebGPU backend.
+ */
+declare class Storage3DTexture extends Texture {
+    /**
+     * This flag can be used for type testing.
+     *
+     * @default true
+     */
+    readonly isStorageTexture: true;
+
+    /**
+     * Constructs a new storage texture.
+     *
+     * @param {number} [width=1] - The storage texture's width.
+     * @param {number} [height=1] - The storage texture's height.
+     * @param {number} [depth=1] - The storage texture's depth.
+     */
+    constructor(width?: number, height?: number, depth?: number);
+}
+
+export default Storage3DTexture;

three/src/renderers/common/Textures.d.ts

@@ -6,7 +6,7 @@ import Backend from "./Backend.js";
 import DataMap from "./DataMap.js";
 import Info from "./Info.js";
 import Renderer from "./Renderer.js";
-type SizeVector3Unitialized = Vector3 & {
+type SizeVector3Uninitialized = Vector3 & {
     width?: number;
     height?: number;
     depth?: number;
@@ -99,7 +99,7 @@ declare class Textures extends DataMap<{
      * @param {Vector3} target - The target vector.
      * @return {Vector3} The target vector.
      */
-    getSize(texture: Texture, target?: SizeVector3Unitialized): SizeVector3;
+    getSize(texture: Texture, target?: SizeVector3Uninitialized): SizeVector3;
     /**
      * Computes the number of mipmap levels for the given texture.
      *

three/src/renderers/common/XRRenderTarget.d.ts

@@ -8,8 +8,9 @@ import { RenderTarget, RenderTargetOptions } from "../../core/RenderTarget.js";
  */
 declare class XRRenderTarget extends RenderTarget {
     readonly isXRRenderTarget: true;
-    hasExternalTextures: boolean;
-    autoAllocateDepthBuffer: boolean;
+    _hasExternalTextures: boolean;
+    _autoAllocateDepthBuffer: boolean;
+    _isOpaqueFramebuffer: boolean;
     /**
      * Constructs a new XR render target.
      *

three/src/renderers/common/nodes/NodeLibrary.d.ts

@@ -4,7 +4,7 @@ import { Material } from "../../../materials/Material.js";
 import NodeMaterial from "../../../materials/nodes/NodeMaterial.js";
 import Node from "../../../nodes/core/Node.js";
 import AnalyticLightNode from "../../../nodes/lighting/AnalyticLightNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../../../nodes/tsl/TSLCore.js";
+import { ShaderNodeObject } from "../../../nodes/tsl/TSLCore.js";
 /**
  * The purpose of a node library is to assign node implementations
  * to existing library features. In `WebGPURenderer` lights, materials
@@ -22,10 +22,7 @@ declare class NodeLibrary {
     materialNodes: Map<string, {
         new(): NodeMaterial;
     }>;
-    toneMappingNodes: Map<
-        ToneMapping,
-        (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>
-    >;
+    toneMappingNodes: Map<ToneMapping, (color: Node, exposure: Node) => ShaderNodeObject<Node>>;
     /**
      * Constructs a new node library.
      */
@@ -48,7 +45,7 @@ declare class NodeLibrary {
      * @param {number} toneMapping - The tone mapping.
      */
     addToneMapping(
-        toneMappingNode: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>,
+        toneMappingNode: (color: Node, exposure: Node) => ShaderNodeObject<Node>,
         toneMapping: ToneMapping,
     ): void;
     /**
@@ -57,9 +54,7 @@ declare class NodeLibrary {
      * @param {number} toneMapping - The tone mapping.
      * @return {?Function} The tone mapping node function. Returns `null` if no node function is found.
      */
-    getToneMappingFunction(
-        toneMapping: ToneMapping,
-    ): ((color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>) | null;
+    getToneMappingFunction(toneMapping: ToneMapping): ((color: Node, exposure: Node) => ShaderNodeObject<Node>) | null;
     /**
      * Returns a node material class definition for a material type.
      *

three/src/renderers/common/nodes/NodeSampledTexture.d.ts

@@ -23,7 +23,7 @@ declare class NodeSampledCubeTexture extends NodeSampledTexture {
 }
 
 declare class NodeSampledTexture3D extends NodeSampledTexture {
-    readonly isSampledTexture3D = true;
+    readonly isSampledTexture3D: true;
 }
 
 export { NodeSampledCubeTexture, NodeSampledTexture, NodeSampledTexture3D };

three/src/renderers/common/nodes/Nodes.d.ts

@@ -106,7 +106,7 @@ declare class Nodes extends DataMap<{
      * @param {RenderObject} renderObject - The render object.
      * @return {number} The cache key.
      */
-    getForRenderCacheKey(renderObject: RenderObject): string;
+    getForRenderCacheKey(renderObject: RenderObject): number;
     /**
      * Returns a node builder state for the given render object.
      *

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

@@ -1,4 +1,5 @@
 import Renderer, { RendererParameters } from "../common/Renderer.js";
+import StandardNodeLibrary from "./nodes/StandardNodeLibrary.js";
 import { WebGPUBackendParameters } from "./WebGPUBackend.js";
 
 export interface WebGPURendererParameters extends RendererParameters, WebGPUBackendParameters {
@@ -6,6 +7,8 @@ export interface WebGPURendererParameters extends RendererParameters, WebGPUBack
 }
 
 declare class WebGPURenderer extends Renderer {
+    library: StandardNodeLibrary;
+
     readonly isWebGPURenderer: true;
 
     constructor(parameters?: WebGPURendererParameters);

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

@@ -1,3 +1,16 @@
+import { LineBasicNodeMaterialNodeProperties } from "../../../materials/nodes/LineBasicNodeMaterial.js";
+import { LineDashedNodeMaterialNodeProperties } from "../../../materials/nodes/LineDashedNodeMaterial.js";
+import { MeshBasicNodeMaterialNodeProperties } from "../../../materials/nodes/MeshBasicNodeMaterial.js";
+import { MeshLambertNodeMaterialNodeProperties } from "../../../materials/nodes/MeshLambertNodeMaterial.js";
+import { MeshMatcapNodeMaterialNodeProperties } from "../../../materials/nodes/MeshMatcapNodeMaterial.js";
+import { MeshNormalNodeMaterialNodeProperties } from "../../../materials/nodes/MeshNormalNodeMaterial.js";
+import { MeshPhongNodeMaterialNodeProperties } from "../../../materials/nodes/MeshPhongNodeMaterial.js";
+import { MeshPhysicalNodeMaterialNodeProperties } from "../../../materials/nodes/MeshPhysicalNodeMaterial.js";
+import { MeshStandardNodeMaterialNodeProperties } from "../../../materials/nodes/MeshStandardNodeMaterial.js";
+import { MeshToonNodeMaterialNodeProperties } from "../../../materials/nodes/MeshToonNodeMaterial.js";
+import { PointsNodeMaterialNodeProperties } from "../../../materials/nodes/PointsNodeMaterial.js";
+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
@@ -13,4 +26,56 @@ declare class StandardNodeLibrary extends NodeLibrary {
      */
     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/utils/WebGPUConstants.d.ts

@@ -314,15 +314,24 @@ export enum GPUInputStepMode {
 }
 
 export enum GPUFeatureName {
+    CoreFeaturesAndLimits = "core-features-and-limits",
     DepthClipControl = "depth-clip-control",
     Depth32FloatStencil8 = "depth32float-stencil8",
     TextureCompressionBC = "texture-compression-bc",
+    TextureCompressionBCSliced3D = "texture-compression-bc-sliced-3d",
     TextureCompressionETC2 = "texture-compression-etc2",
     TextureCompressionASTC = "texture-compression-astc",
+    TextureCompressionASTCSliced3D = "texture-compression-astc-sliced-3d",
     TimestampQuery = "timestamp-query",
     IndirectFirstInstance = "indirect-first-instance",
     ShaderF16 = "shader-f16",
     RG11B10UFloat = "rg11b10ufloat-renderable",
     BGRA8UNormStorage = "bgra8unorm-storage",
     Float32Filterable = "float32-filterable",
+    Float32Blendable = "float32-blendable",
+    ClipDistances = "clip-distances",
+    DualSourceBlending = "dual-source-blending",
+    Subgroups = "subgroups",
+    TextureFormatsTier1 = "texture-formats-tier1",
+    TextureFormatsTier2 = "texture-formats-tier2",
 }

three/src/nodes/utils/EquirectUVNode.d.ts

@@ -1,8 +0,0 @@
-import { Node, TempNode } from "../Nodes.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
-
-export default class EquirectUVNode extends TempNode {
-    constructor(dirNode?: ShaderNodeObject<Node>);
-}
-
-export const equirectUV: (dirNode?: NodeRepresentation) => ShaderNodeObject<EquirectUVNode>;

three/src/nodes/utils/MatcapUVNode.d.ts

@@ -1,8 +0,0 @@
-import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
-
-export default class MatcapUVNode extends TempNode {
-    constructor();
-}
-
-export const matcapUV: ShaderNodeObject<MatcapUVNode>;

three/src/nodes/utils/TriplanarTexturesNode.d.ts

@@ -1,36 +0,0 @@
-import TextureNode from "../accessors/TextureNode.js";
-import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
-
-export default class TriplanarTexturesNode extends Node {
-    textureXNode: TextureNode;
-    textureYNode: TextureNode | null;
-    textureZNode: TextureNode | null;
-
-    scaleNode: ShaderNodeObject<Node>;
-
-    positionNode: ShaderNodeObject<Node>;
-    normalNode: ShaderNodeObject<Node>;
-
-    constructor(
-        textureXNode: Node,
-        textureYNode?: TextureNode | null,
-        textureZNode?: TextureNode | null,
-        scaleNode?: ShaderNodeObject<Node>,
-        positionNode?: ShaderNodeObject<Node>,
-        normalNode?: ShaderNodeObject<Node>,
-    );
-}
-
-export const triplanarTextures: (
-    textureXNode: NodeRepresentation,
-    textureYNode?: NodeRepresentation,
-    textureZNode?: NodeRepresentation,
-    scaleNode?: NodeRepresentation,
-    positionNode?: NodeRepresentation,
-    normalNode?: NodeRepresentation,
-) => ShaderNodeObject<TriplanarTexturesNode>;
-export const triplanarTexture: (
-    texture: NodeRepresentation,
-    ...params: NodeRepresentation[]
-) => ShaderNodeObject<TriplanarTexturesNode>;

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

@@ -1,5 +0,0 @@
-import NodeLibrary from "./NodeLibrary.js";
-declare class StandardNodeLibrary extends NodeLibrary {
-    constructor();
-}
-export default StandardNodeLibrary;