@types/three 0.164.1 → 0.166.0

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

@@ -0,0 +1,30 @@
+import Node from "../../../nodes/core/Node.js";
+import NodeAttribute from "../../../nodes/core/NodeAttribute.js";
+import BindGroup from "../BindGroup.js";
+declare class NodeBuilderState {
+    vertexShader: string | null;
+    fragmentShader: string | null;
+    computeShader: string | null;
+    transforms: never[];
+    nodeAttributes: NodeAttribute[];
+    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: BindGroup[],
+        updateNodes: Node[],
+        updateBeforeNodes: Node[],
+        updateAfterNodes: Node[],
+        instanceBindGroups?: boolean,
+        transforms?: never[],
+    );
+    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

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

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

@@ -0,0 +1,11 @@
+import UniformGroupNode from "../../../nodes/core/UniformGroupNode.js";
+import UniformNode from "../../../nodes/core/UniformNode.js";
+import UniformsGroup from "../UniformsGroup.js";
+declare class NodeUniformsGroup extends UniformsGroup {
+    id: number;
+    groupNode: UniformGroupNode;
+    readonly isNodeUniformsGroup: true;
+    constructor(name: string, groupNode: UniformGroupNode);
+    getNodes(): UniformNode<unknown>[];
+}
+export default NodeUniformsGroup;

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

@@ -0,0 +1,95 @@
+import { Camera, Color, CubeTexture, FogBase, Material, Object3D, Scene, Texture } from "three";
+import Node from "../../../nodes/core/Node.js";
+import NodeBuilder from "../../../nodes/core/NodeBuilder.js";
+import UniformGroupNode from "../../../nodes/core/UniformGroupNode.js";
+import ComputeNode from "../../../nodes/gpgpu/ComputeNode.js";
+import LightsNode from "../../../nodes/lighting/LightsNode.js";
+import { NodeFrame, ShaderNodeObject } from "../../../nodes/Nodes.js";
+import Backend from "../Backend.js";
+import ChainMap from "../ChainMap.js";
+import DataMap from "../DataMap.js";
+import Renderer from "../Renderer.js";
+import RenderObject from "../RenderObject.js";
+import NodeBuilderState from "./NodeBuilderState.js";
+import NodeUniformsGroup from "./NodeUniformsGroup.js";
+interface NodeUniformsGroupData {
+    renderId?: number | undefined;
+    frameId?: number | undefined;
+}
+interface RenderObjectData {
+    nodeBuilderState?: NodeBuilderState | undefined;
+}
+interface ComputeNodeData {
+    nodeBuilderState?: NodeBuilderState | undefined;
+}
+interface SceneData {
+    background?: Color | Texture | CubeTexture | undefined;
+    backgroundNode?: Node | undefined;
+    fog?: FogBase | undefined;
+    fogNode?: Node | undefined;
+    environment?: Texture | undefined;
+    environmentNode?: Node | undefined;
+}
+declare class Nodes extends DataMap<{
+    nodeUniformsGroup: {
+        key: NodeUniformsGroup;
+        value: NodeUniformsGroupData;
+    };
+    renderObject: {
+        key: RenderObject;
+        value: RenderObjectData;
+    };
+    computeNode: {
+        key: ComputeNode;
+        value: ComputeNodeData;
+    };
+    scene: {
+        key: Scene;
+        value: SceneData;
+    };
+}> {
+    renderer: Renderer;
+    backend: Backend;
+    nodeFrame: NodeFrame;
+    nodeBuilderCache: Map<string, NodeBuilderState>;
+    callHashCache: ChainMap<readonly [Scene, LightsNode], {
+        callId: number;
+        cacheKey: string;
+    }>;
+    groupsData: ChainMap<readonly [UniformGroupNode, NodeUniformsGroup], {
+        version?: number;
+    }>;
+    constructor(renderer: Renderer, backend: Backend);
+    updateGroup(nodeUniformsGroup: NodeUniformsGroup): boolean;
+    getForRenderCacheKey(renderObject: RenderObject): string;
+    getForRender(renderObject: RenderObject): NodeBuilderState;
+    delete(
+        object: NodeUniformsGroup | RenderObject | ComputeNode | Scene,
+    ): SceneData | RenderObjectData | NodeUniformsGroupData | ComputeNodeData;
+    getForCompute(computeNode: ComputeNode): NodeBuilderState;
+    _createNodeBuilderState(nodeBuilder: NodeBuilder): NodeBuilderState;
+    getEnvironmentNode(scene: Scene): Node | null;
+    getBackgroundNode(scene: Scene): Node | null;
+    getFogNode(scene: Scene): Node | null;
+    getCacheKey(scene: Scene, lightsNode: LightsNode): string;
+    updateScene(scene: Scene): void;
+    get isToneMappingState(): boolean;
+    updateBackground(scene: Scene): void;
+    updateFog(scene: Scene): void;
+    updateEnvironment(scene: Scene): void;
+    getNodeFrame(
+        renderer?: Renderer,
+        scene?: Scene | null,
+        object?: Object3D | null,
+        camera?: Camera | null,
+        material?: Material | null,
+    ): NodeFrame;
+    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;
+}
+export default Nodes;

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;
+}