@types/three 0.165.0 → 0.166.0

three/examples/jsm/renderers/common/Bindings.d.ts

@@ -1,24 +1,20 @@
 import ComputeNode from "../../nodes/gpgpu/ComputeNode.js";
 import Attributes from "./Attributes.js";
 import Backend from "./Backend.js";
-import Binding from "./Binding.js";
+import BindGroup from "./BindGroup.js";
 import DataMap from "./DataMap.js";
 import Info from "./Info.js";
 import Nodes from "./nodes/Nodes.js";
 import Pipelines from "./Pipelines.js";
 import RenderObject from "./RenderObject.js";
 import Textures from "./Textures.js";
-interface Data {
-    bindings?: Binding[] | undefined;
+interface BindGroupData {
+    bindGroup?: BindGroup | undefined;
 }
 declare class Bindings extends DataMap<{
-    renderObject: {
-        key: RenderObject;
-        value: Data;
-    };
-    computeNode: {
-        key: ComputeNode;
-        value: Data;
+    bindGroup: {
+        key: BindGroup;
+        value: BindGroupData;
     };
 }> {
     backend: Backend;
@@ -35,11 +31,12 @@ declare class Bindings extends DataMap<{
         pipelines: Pipelines,
         info: Info,
     );
-    getForRender(renderObject: RenderObject): Binding[];
-    getForCompute(computeNode: ComputeNode): Binding[];
+    getForRender(renderObject: RenderObject): BindGroup[];
+    getForCompute(computeNode: ComputeNode): BindGroup[];
     updateForCompute(computeNode: ComputeNode): void;
     updateForRender(renderObject: RenderObject): void;
-    _init(bindings: Binding[]): void;
-    _update(object: ComputeNode | RenderObject, bindings: Binding[]): void;
+    _updateBindings(object: ComputeNode | RenderObject, bindings: BindGroup[]): void;
+    _init(bindGroup: BindGroup): void;
+    _update(object: ComputeNode | RenderObject, bindGroup: BindGroup, bindings: BindGroup[]): void;
 }
 export default Bindings;

three/examples/jsm/renderers/common/Geometries.d.ts

@@ -1,4 +1,4 @@
-import { BufferAttribute, BufferGeometry } from "three";
+import { BufferAttribute, BufferGeometry, InterleavedBuffer, InterleavedBufferAttribute } from "three";
 import Attributes from "./Attributes.js";
 import { AttributeType } from "./Constants.js";
 import DataMap from "./DataMap.js";
@@ -16,13 +16,13 @@ declare class Geometries extends DataMap<{
     attributes: Attributes;
     info: Info;
     wireframes: WeakMap<BufferGeometry, BufferAttribute>;
-    attributeCall: WeakMap<BufferAttribute, number>;
+    attributeCall: WeakMap<BufferAttribute | InterleavedBufferAttribute | InterleavedBuffer, number>;
     constructor(attributes: Attributes, info: Info);
     has(renderObject: RenderObject | BufferGeometry): boolean;
     updateForRender(renderObject: RenderObject): void;
     initGeometry(renderObject: RenderObject): void;
     updateAttributes(renderObject: RenderObject): void;
-    updateAttribute(attribute: BufferAttribute, type: AttributeType): void;
+    updateAttribute(attribute: BufferAttribute | InterleavedBufferAttribute, type: AttributeType): void;
     getIndex(renderObject: RenderObject): BufferAttribute | null;
 }
 export default Geometries;

three/examples/jsm/renderers/common/Info.d.ts

@@ -5,16 +5,21 @@ declare class Info {
     calls: number;
     render: {
         calls: number;
+        frameCalls: number;
         drawCalls: number;
         triangles: number;
         points: number;
         lines: number;
         timestamp: number;
+        previousFrameCalls: number;
+        timestampCalls: number;
     };
     compute: {
         calls: number;
-        computeCalls: number;
+        frameCalls: number;
         timestamp: number;
+        previousFrameCalls: number;
+        timestampCalls: number;
     };
     memory: {
         geometries: number;

three/examples/jsm/renderers/common/PostProcessing.d.ts

@@ -10,4 +10,6 @@ export default class PostProcessing {
     render(): void;
 
     renderAsync(): Promise<void>;
+
+    set needsUpdate(value: boolean);
 }

three/examples/jsm/renderers/common/RenderObject.d.ts

@@ -9,7 +9,7 @@ import {
     Scene,
 } from "three";
 import LightsNode from "../../nodes/lighting/LightsNode.js";
-import Binding from "./Binding.js";
+import BindGroup from "./BindGroup.js";
 import ClippingContext from "./ClippingContext.js";
 import Geometries from "./Geometries.js";
 import NodeBuilderState from "./nodes/NodeBuilderState.js";
@@ -42,7 +42,7 @@ export default class RenderObject {
     initialNodesCacheKey: string;
     initialCacheKey: string;
     _nodeBuilderState: NodeBuilderState | null;
-    _bindings: Binding[] | null;
+    _bindings: BindGroup[] | null;
     onDispose: (() => void) | null;
     readonly isRenderObject: true;
     onMaterialDispose: () => void;
@@ -60,7 +60,7 @@ export default class RenderObject {
     updateClipping(parent: ClippingContext): void;
     get clippingNeedsUpdate(): boolean;
     getNodeBuilderState(): NodeBuilderState;
-    getBindings(): Binding[];
+    getBindings(): BindGroup[];
     getIndex(): BufferAttribute | null;
     getChainArray(): readonly [Object3D<import("three").Object3DEventMap>, Material, RenderContext, LightsNode];
     getAttributes(): (InterleavedBufferAttribute | BufferAttribute)[];

three/examples/jsm/renderers/common/Renderer.d.ts

@@ -133,6 +133,17 @@ declare class Renderer {
     xr: {
         enabled: boolean;
     };
+    debug: {
+        checkShaderErrors: boolean;
+        onShaderError:
+            | ((
+                gl: WebGL2RenderingContext,
+                programGPU: WebGLProgram,
+                glVertexShader: WebGLShader,
+                glFragmentShader: WebGLShader,
+            ) => void)
+            | null;
+    };
     localClippingEnabled?: boolean | undefined;
     constructor(backend: Backend, parameters?: RendererParameters);
     init(): Promise<void>;

three/examples/jsm/renderers/common/SampledTexture.d.ts

@@ -0,0 +1,27 @@
+import { Texture } from "three";
+import Binding from "./Binding.js";
+
+declare class SampledTexture extends Binding {
+    id: number;
+    texture: Texture | null;
+    version: number;
+    store: boolean;
+    readonly isSampledTexture: true;
+    constructor(name: string, texture: Texture | null);
+    get needsBindingsUpdate(): boolean;
+    update(): boolean;
+}
+
+declare class SampledArrayTexture extends SampledTexture {
+    readonly isSampledArrayTexture: true;
+}
+
+declare class Sampled3DTexture extends SampledTexture {
+    readonly isSampled3DTexture: true;
+}
+
+declare class SampledCubeTexture extends SampledTexture {
+    readonly isSampledCubeTexture: true;
+}
+
+export { Sampled3DTexture, SampledArrayTexture, SampledCubeTexture, SampledTexture };

three/examples/jsm/renderers/common/Sampler.d.ts

@@ -0,0 +1,11 @@
+import TextureNode from "../../nodes/accessors/TextureNode.js";
+import Binding from "./Binding.js";
+
+declare class Sampler extends Binding {
+    texture: TextureNode | null;
+    version: number;
+    readonly isSampler: true;
+    constructor(name: string, texture: TextureNode | null);
+}
+
+export default Sampler;

three/examples/jsm/renderers/common/Uniform.d.ts

@@ -9,8 +9,8 @@ declare class Uniform<TValue> {
     setValue(value: TValue): void;
     getValue(): TValue;
 }
-declare class FloatUniform extends Uniform<number> {
-    readonly isFloatUniform: true;
+declare class NumberUniform extends Uniform<number> {
+    readonly isNumberUniform: true;
     constructor(name: string, value?: number);
 }
 declare class Vector2Uniform extends Uniform<Vector2> {
@@ -37,4 +37,4 @@ declare class Matrix4Uniform extends Uniform<Matrix4> {
     readonly isMatrix4Uniform: true;
     constructor(name: string, value?: Matrix4);
 }
-export { ColorUniform, FloatUniform, Matrix3Uniform, Matrix4Uniform, Vector2Uniform, Vector3Uniform, Vector4Uniform };
+export { ColorUniform, Matrix3Uniform, Matrix4Uniform, NumberUniform, Vector2Uniform, Vector3Uniform, Vector4Uniform };

three/examples/jsm/renderers/common/UniformsGroup.d.ts

@@ -1,9 +1,9 @@
 import {
     ColorNodeUniform,
-    FloatNodeUniform,
     Matrix3NodeUniform,
     Matrix4NodeUniform,
     NodeUniformGPU,
+    NumberNodeUniform,
     Vector2NodeUniform,
     Vector3NodeUniform,
     Vector4NodeUniform,
@@ -11,15 +11,17 @@ import {
 import UniformBuffer from "./UniformBuffer.js";
 declare class UniformsGroup extends UniformBuffer {
     readonly isUniformsGroup: true;
+    _values: number[] | null;
     uniforms: NodeUniformGPU[];
     constructor(name?: string);
     addUniform(uniform: NodeUniformGPU): this;
     removeUniform(uniform: NodeUniformGPU): this;
+    get values(): number[];
     get buffer(): Float32Array;
     get byteLength(): number;
     update(): boolean;
     updateByType(uniform: NodeUniformGPU): boolean | undefined;
-    updateNumber(uniform: FloatNodeUniform): boolean;
+    updateNumber(uniform: NumberNodeUniform): boolean;
     updateVector2(uniform: Vector2NodeUniform): boolean;
     updateVector3(uniform: Vector3NodeUniform): boolean;
     updateVector4(uniform: Vector4NodeUniform): boolean;

three/examples/jsm/renderers/common/nodes/NodeBuilderState.d.ts

@@ -1,26 +1,30 @@
 import Node from "../../../nodes/core/Node.js";
 import NodeAttribute from "../../../nodes/core/NodeAttribute.js";
-import Binding from "../Binding.js";
+import BindGroup from "../BindGroup.js";
 declare class NodeBuilderState {
     vertexShader: string | null;
     fragmentShader: string | null;
     computeShader: string | null;
     transforms: never[];
     nodeAttributes: NodeAttribute[];
-    bindings: Binding[];
+    bindings: BindGroup[];
     updateNodes: Node[];
     updateBeforeNodes: Node[];
+    updateAfterNodes: Node[];
+    instanceBindGroups: boolean;
     usedTimes: number;
     constructor(
         vertexShader: string | null,
         fragmentShader: string | null,
         computeShader: string | null,
         nodeAttributes: NodeAttribute[],
-        bindings: Binding[],
+        bindings: BindGroup[],
         updateNodes: Node[],
         updateBeforeNodes: Node[],
+        updateAfterNodes: Node[],
+        instanceBindGroups?: boolean,
         transforms?: never[],
     );
-    createBindings(): Binding[];
+    createBindings(): BindGroup[];
 }
 export default NodeBuilderState;

three/examples/jsm/renderers/common/nodes/NodeSampledTexture.d.ts

@@ -0,0 +1,29 @@
+import TextureNode from "../../../nodes/accessors/TextureNode.js";
+import UniformGroupNode from "../../../nodes/core/UniformGroupNode.js";
+import { SampledTexture } from "../SampledTexture.js";
+
+type GPUStorageTextureAccess = "read-only" | "read-write" | "write-only";
+
+declare class NodeSampledTexture extends SampledTexture {
+    textureNode: TextureNode | undefined;
+    groupNode: UniformGroupNode;
+    access: "read-write" | "read-only" | "write-only";
+    constructor(
+        name: string,
+        textureNode: TextureNode | undefined,
+        groupNode: UniformGroupNode,
+        access: GPUStorageTextureAccess | null,
+    );
+    get needsBindingsUpdate(): boolean;
+    update(): boolean;
+}
+
+declare class NodeSampledCubeTexture extends NodeSampledTexture {
+    readonly isSampledCubeTexture: true;
+}
+
+declare class NodeSampledTexture3D extends NodeSampledTexture {
+    readonly isSampledTexture3D = true;
+}
+
+export { NodeSampledCubeTexture, NodeSampledTexture, NodeSampledTexture3D };

three/examples/jsm/renderers/common/nodes/NodeSampler.d.ts

@@ -0,0 +1,12 @@
+import TextureNode from "../../../nodes/accessors/TextureNode.js";
+import UniformGroupNode from "../../../nodes/core/UniformGroupNode.js";
+import Sampler from "../Sampler.js";
+
+declare class NodeSampler extends Sampler {
+    textureNode: TextureNode | undefined;
+    groupNode: UniformGroupNode;
+    constructor(name: string, textureNode: TextureNode | undefined, groupNode: UniformGroupNode);
+    update(): void;
+}
+
+export default NodeSampler;

three/examples/jsm/renderers/common/nodes/NodeUniform.d.ts

@@ -2,14 +2,14 @@ import { Color, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from "three";
 import NodeUniform from "../../../nodes/core/NodeUniform.js";
 import {
     ColorUniform,
-    FloatUniform,
     Matrix3Uniform,
     Matrix4Uniform,
+    NumberUniform,
     Vector2Uniform,
     Vector3Uniform,
     Vector4Uniform,
 } from "../Uniform.js";
-declare class FloatNodeUniform extends FloatUniform {
+declare class NumberNodeUniform extends NumberUniform {
     nodeUniform: NodeUniform<number>;
     constructor(nodeUniform: NodeUniform<number>);
     getValue(): number;
@@ -46,15 +46,15 @@ declare class Matrix4NodeUniform extends Matrix4Uniform {
 }
 export {
     ColorNodeUniform,
-    FloatNodeUniform,
     Matrix3NodeUniform,
     Matrix4NodeUniform,
+    NumberNodeUniform,
     Vector2NodeUniform,
     Vector3NodeUniform,
     Vector4NodeUniform,
 };
 export type NodeUniformGPU =
-    | FloatNodeUniform
+    | NumberNodeUniform
     | Vector2NodeUniform
     | Vector3NodeUniform
     | Vector4NodeUniform

three/examples/jsm/renderers/common/nodes/NodeUniformsGroup.d.ts

@@ -6,7 +6,6 @@ declare class NodeUniformsGroup extends UniformsGroup {
     groupNode: UniformGroupNode;
     readonly isNodeUniformsGroup: true;
     constructor(name: string, groupNode: UniformGroupNode);
-    get shared(): boolean;
     getNodes(): UniformNode<unknown>[];
 }
 export default NodeUniformsGroup;

three/examples/jsm/renderers/common/nodes/Nodes.d.ts

@@ -87,6 +87,7 @@ declare class Nodes extends DataMap<{
     getNodeFrameForRender(renderObject: RenderObject): NodeFrame;
     getOutputNode(outputTexture: Texture): ShaderNodeObject<Node>;
     updateBefore(renderObject: RenderObject): void;
+    updateAfter(renderObject: RenderObject): void;
     updateForCompute(computeNode: ComputeNode): void;
     updateForRender(renderObject: RenderObject): void;
     dispose(): void;

three/examples/jsm/renderers/webgpu/nodes/WGSLNodeBuilder.d.ts

@@ -0,0 +1,123 @@
+import { Texture } from "three";
+import { NodeShaderStage } from "../../../nodes/core/constants.js";
+import NodeBuilder from "../../../nodes/core/NodeBuilder.js";
+import NodeUniform from "../../../nodes/core/NodeUniform.js";
+import NodeVar from "../../../nodes/core/NodeVar.js";
+import StructTypeNode from "../../../nodes/core/StructTypeNode.js";
+import { ShaderNode } from "../../../nodes/shadernode/ShaderNode.js";
+import NodeUniformsGroup from "../../common/nodes/NodeUniformsGroup.js";
+
+type BuiltinStage = NodeShaderStage | "attribute" | "output";
+interface BuiltinType {
+    name: string;
+    property: string;
+    type: string;
+}
+
+export default class WGSLNodeBuilder extends NodeBuilder {
+    builtins: { [key in BuiltinStage]: Map<string, BuiltinType> };
+    uniformGroups: { [key in NodeShaderStage]: NodeUniformsGroup };
+
+    needsColorSpaceToLinear(texture: Texture);
+    _generateTextureSample(
+        texture: Texture,
+        textureProperty: string,
+        uvSnippet: string,
+        depthSnippet: string | null,
+        shaderStage: NodeShaderStage,
+    ): string;
+    _generateVideoSample(textureProperty: string, uvSnippet: string, shaderStage: NodeShaderStage): string;
+    _generateTextureSampleLevel(
+        texture: Texture,
+        textureProperty: string,
+        uvSnippet: string,
+        levelSnippet: string,
+        depthSnippet: string | null,
+        shaderStage: NodeShaderStage,
+    ): string;
+    generateTextureLod(texture: Texture, textureProperty: string, uvSnippet: string, levelSnippet: string): string;
+    generateTextureLoad(
+        texture: Texture,
+        textureProperty: string,
+        uvIndexSnippet: string,
+        depthSnippet: string | null,
+        shaderStage: NodeShaderStage,
+    ): string;
+    generateTextureStore(
+        texture: Texture,
+        textureProperty: string,
+        uvIndexSnippet: string,
+        valueSnippet: string,
+    ): string;
+    isUnfilterable(texture: Texture): boolean;
+    generateTexture(
+        texture: Texture,
+        textureProperty: string,
+        uvSnippet: string,
+        depthSnippet: string | null,
+        shaderStage: NodeShaderStage,
+    ): string;
+    generateTextureGrad(
+        texture: Texture,
+        textureProperty: string,
+        uvSnippet: string,
+        gradSnippet: string[],
+        depthSnippet: string | null,
+        shaderStage: NodeShaderStage,
+    ): string;
+    generateTextureCompare(
+        texture: Texture,
+        textureProperty: string,
+        uvSnippet: string,
+        compareSnippet: String,
+        shaderStage: NodeShaderStage,
+    ): string;
+    generateTextureLevel(
+        texture: Texture,
+        textureProperty: string,
+        uvSnippet: string,
+        levelSnippet: string,
+        depthSnippet: string | null,
+        shaderStage: NodeShaderStage,
+    ): string;
+
+    getPropertyName<TValue>(node: NodeVar | NodeUniform<TValue>, shaderStage: NodeShaderStage): string;
+
+    getOutputStructName(): string;
+
+    _getUniformGroupCount(shaderStage: NodeShaderStage): number;
+
+    getFunctionOperator(op: string): string | null;
+    // getStorageAccess(node: StorageTextureNode | StorageBufferNode): string;
+
+    getBuiltin(name: string, property: string, type: string, shaderStage: BuiltinStage): string;
+    getVertexIndex(): string;
+    getInstanceIndex(): string;
+
+    buildFunctionCode(shaderNode: ShaderNode): string;
+
+    getFragDepth(): string;
+    getFragCoord(): string;
+    getFrontFacing(): string;
+
+    getBuiltins(shaderStage: BuiltinStage): string;
+    getAttributes(shaderStage: NodeShaderStage): string;
+
+    getStructMembers(struct: StructTypeNode): string;
+    getStructs(shaderStage: NodeShaderStage): string;
+
+    getVar(type: string, name: string): string;
+    getVars(shaderStage: NodeShaderStage): string;
+    getVaryings(shaderStage: NodeShaderStage): string;
+    getUniforms(shaderStage: NodeShaderStage): string;
+    buildCode(): void;
+    getMethod(method: string, output?: string | null): string;
+
+    _getWGSLMethod(method: string);
+    // _include(name: string): CodeNode
+    _getWGSLVertexCode(shaderData: { [key: string]: string }): string;
+    _getWGSLFragmentCode(shaderData: { [key: string]: string }): string;
+    _getWGSLComputeCode(shaderData: { [key: string]: string }, workgroupSize: string): string;
+    _getWGSLStruct(name: string, vars: string): string;
+    _getWGSLStructBinding(name: string, vars: string, access: string, binding: number, group: number): string;
+}

three/examples/jsm/renderers/webgpu/nodes/WGSLNodeFunction.d.ts

@@ -0,0 +1,6 @@
+import NodeFunction from "../../../nodes/core/NodeFunction.js";
+
+export default class WGSLNodeFunction extends NodeFunction {
+    constructor(source: string);
+    getCode(name?: string): string;
+}

three/examples/jsm/renderers/webgpu/nodes/WGSLNodeParser.d.ts

@@ -0,0 +1,6 @@
+import NodeParser from "../../../nodes/core/NodeParser.js";
+import WGSLNodeFunction from "./WGSLNodeFunction.js";
+
+export default class WGSLNodeParser extends NodeParser {
+    parseFunction(source: string): WGSLNodeFunction;
+}