@types/three 0.170.0 → 0.171.0

three/src/core/InterleavedBuffer.d.ts

@@ -85,6 +85,18 @@ export class InterleavedBuffer {
      */
     uuid: string;
 
+    /**
+     * A callback function that is executed after the Renderer has transferred the geometry data to the GPU.
+     */
+    onUploadCallback: () => void;
+
+    /**
+     * Sets the value of the {@link onUploadCallback} property.
+     * @see {@link onUploadCallback}
+     * @param callback function that is executed after the Renderer has transferred the geometry data to the GPU.
+     */
+    onUpload(callback: () => void): this;
+
     /**
      * Calls {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set | TypedArray.set}( {@link value}, {@link offset} )
      * on the {@link BufferAttribute.array | array}.

three/src/materials/Material.d.ts

@@ -234,10 +234,6 @@ export interface MaterialJSON {
  * Materials describe the appearance of objects. They are defined in a (mostly) renderer-independent way, so you don't have to rewrite materials if you decide to use a different renderer.
  */
 export class Material extends EventDispatcher<{ dispose: {} }> {
-    static get type(): string;
-
-    get type(): string;
-
     constructor();
 
     /**
@@ -247,6 +243,12 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
      */
     readonly isMaterial: true;
 
+    /**
+     * Value is the string 'Material'. This shouldn't be changed, and can be used to find all objects of this type in a
+     * scene.
+     */
+    type: string;
+
     /**
      * 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,

three/src/materials/nodes/LineDashedNodeMaterial.d.ts

@@ -3,6 +3,7 @@ import { LineDashedMaterialParameters } from "../LineDashedMaterial.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface LineDashedNodeMaterialParameters extends NodeMaterialParameters, LineDashedMaterialParameters {
+    dashOffset?: number | undefined;
     offsetNode?: Node | null | undefined;
     dashScaleNode?: Node | null | undefined;
     dashSizeNode?: Node | null | undefined;
@@ -12,6 +13,8 @@ export interface LineDashedNodeMaterialParameters extends NodeMaterialParameters
 declare class LineDashedNodeMaterial extends NodeMaterial {
     readonly isLineDashedNodeMaterial: true;
 
+    dashOffset: number;
+
     offsetNode: Node | null;
     dashScaleNode: Node | null;
     dashSizeNode: Node | null;

three/src/materials/nodes/NodeMaterial.d.ts

@@ -42,6 +42,7 @@ declare class NodeMaterial extends Material {
 
     fog: boolean;
     lights: boolean;
+    hardwareClipping: boolean;
 
     lightsNode: LightsNode | null;
     envNode: Node | null;
@@ -58,8 +59,9 @@ declare class NodeMaterial extends Material {
     geometryNode: Node | null;
 
     depthNode: Node | null;
-    shadowNode: Node | null;
     shadowPositionNode: Node | null;
+    receivedShadowNode: Node | null;
+    castShadowNode: Node | null;
 
     outputNode: Node | null;
     mrtNode: MRTNode | null;
@@ -72,6 +74,7 @@ declare class NodeMaterial extends Material {
     build(builder: NodeBuilder): void;
     setup(builder: NodeBuilder): void;
     setupClipping(builder: NodeBuilder): ClippingNode | null;
+    setupHardwareClipping(builder: NodeBuilder): void;
     setupDepth(builder: NodeBuilder): void;
     setupPosition(builder: NodeBuilder): Node;
     setupDiffuseColor(builder: NodeBuilder): void;

three/src/nodes/Nodes.d.ts

@@ -70,6 +70,7 @@ export { default as BatchNode } from "./accessors/BatchNode.js";
 export { default as BufferAttributeNode } from "./accessors/BufferAttributeNode.js";
 export { default as BufferNode } from "./accessors/BufferNode.js";
 export { default as CubeTextureNode } from "./accessors/CubeTextureNode.js";
+export { default as InstancedMeshNode } from "./accessors/InstancedMeshNode.js";
 export { default as InstanceNode } from "./accessors/InstanceNode.js";
 export { default as MaterialNode, MaterialNodeScope } from "./accessors/MaterialNode.js";
 export { default as MaterialReferenceNode } from "./accessors/MaterialReferenceNode.js";
@@ -137,7 +138,6 @@ export { default as IESSpotLightNode } from "./lighting/IESSpotLightNode.js";
 export { default as IrradianceNode } from "./lighting/IrradianceNode.js";
 export { default as LightingContextNode } from "./lighting/LightingContextNode.js";
 export { default as LightingNode } from "./lighting/LightingNode.js";
-export { default as LightNode, LightNodeScope } from "./lighting/LightNode.js";
 export { default as LightProbeNode } from "./lighting/LightProbeNode.js";
 export { default as LightsNode } from "./lighting/LightsNode.js";
 export { default as PointLightNode } from "./lighting/PointLightNode.js";

three/src/nodes/TSL.d.ts

@@ -47,12 +47,14 @@ export * from "./tsl/TSLBase.js";
 
 // accessors
 export * from "./accessors/AccessorsUtils.js";
+export * from "./accessors/Arrays.js";
 export * from "./accessors/BatchNode.js";
 export * from "./accessors/Bitangent.js";
 export * from "./accessors/BufferAttributeNode.js";
 export * from "./accessors/BufferNode.js";
 export * from "./accessors/Camera.js";
 export * from "./accessors/CubeTextureNode.js";
+export * from "./accessors/InstancedMeshNode.js";
 export * from "./accessors/InstanceNode.js";
 export * from "./accessors/MaterialNode.js";
 export * from "./accessors/MaterialProperties.js";
@@ -83,7 +85,7 @@ export * from "./accessors/VelocityNode.js";
 export * from "./accessors/VertexColorNode.js";
 
 // display
-export * from "./display/BlendMode.js";
+export * from "./display/BlendModes.js";
 export * from "./display/BumpMapNode.js";
 export * from "./display/ColorAdjustment.js";
 export * from "./display/ColorSpaceNode.js";
@@ -121,11 +123,15 @@ export * from "./fog/FogRangeNode.js";
 export * from "./geometry/RangeNode.js";
 
 // gpgpu
+export * from "./gpgpu/AtomicFunctionNode.js";
+export * from "./gpgpu/BarrierNode.js";
+export * from "./gpgpu/ComputeBuiltinNode.js";
 export * from "./gpgpu/ComputeNode.js";
+export * from "./gpgpu/WorkgroupInfoNode.js";
 
 // lighting
+export * from "./accessors/Lights.js";
 export * from "./lighting/LightingContextNode.js";
-export * from "./lighting/LightNode.js";
 export * from "./lighting/LightsNode.js";
 export * from "./lighting/PointLightNode.js";
 export * from "./lighting/ShadowNode.js";

three/src/nodes/accessors/Arrays.d.ts

@@ -0,0 +1,6 @@
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import StorageBufferNode from "./StorageBufferNode.js";
+
+export const attributeArray: (count: number, type?: string) => ShaderNodeObject<StorageBufferNode>;
+
+export const instancedArray: (count: number, type?: string) => ShaderNodeObject<StorageBufferNode>;

three/src/nodes/accessors/BuiltinNode.d.ts

@@ -0,0 +1,14 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class BuiltinNode extends Node {
+    name: string;
+
+    readonly isBuiltinNode: true;
+
+    constructor(name: string);
+}
+
+export default BuiltinNode;
+
+export const builtin: (name: string) => ShaderNodeObject<BuiltinNode>;

three/src/nodes/accessors/ClippingNode.d.ts

@@ -1,4 +1,6 @@
+import { Plane } from "../../math/Plane.js";
 import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type ClippingNodeScope = typeof ClippingNode.ALPHA_TO_COVERAGE | typeof ClippingNode.DEFAULT;
@@ -6,11 +8,15 @@ export type ClippingNodeScope = typeof ClippingNode.ALPHA_TO_COVERAGE | typeof C
 export default class ClippingNode extends Node {
     scope: ClippingNodeScope;
 
+    hardwareClipping?: boolean;
+
     constructor(scope?: ClippingNodeScope);
 
     static ALPHA_TO_COVERAGE: "alphaToCoverage";
     static DEFAULT: "default";
+    static HARDWARE: "hardware";
 }
 
 export const clipping: () => ShaderNodeObject<ClippingNode>;
 export const clippingAlpha: () => ShaderNodeObject<ClippingNode>;
+export const hardwareClipping: () => ShaderNodeObject<ClippingNode>;

three/src/nodes/accessors/InstanceNode.d.ts

@@ -1,13 +1,25 @@
+import { InstancedBufferAttribute } from "../../core/InstancedBufferAttribute.js";
 import { InstancedMesh } from "../../objects/InstancedMesh.js";
 import Node from "../core/Node.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class InstanceNode extends Node {
-    instanceMesh: InstancedMesh;
+    count: number;
+    instanceMatrix: InstancedBufferAttribute;
+    instanceColor: InstancedBufferAttribute | null;
+
     instanceMatrixNode: Node | null;
     instanceColorNode: Node | null;
 
-    constructor(instanceMesh: InstancedMesh);
+    constructor(
+        count: number,
+        instanceMatrix: InstancedBufferAttribute,
+        instanceColor: InstancedBufferAttribute | null,
+    );
 }
 
-export const instance: (instanceMesh: InstancedMesh) => ShaderNodeObject<InstanceNode>;
+export const instance: (
+    count: number,
+    instanceMatrix: InstancedBufferAttribute,
+    instanceColor: InstancedBufferAttribute | null,
+) => ShaderNodeObject<InstanceNode>;

three/src/nodes/accessors/InstancedMeshNode.d.ts

@@ -0,0 +1,11 @@
+import { InstancedMesh } from "../../objects/InstancedMesh.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import InstanceNode from "./InstanceNode.js";
+
+declare class InstancedMeshNode extends InstanceNode {
+    constructor(instanceMesh: InstancedMesh);
+}
+
+export default InstancedMeshNode;
+
+export const instancedMesh: (instancedMesh: InstancedMesh) => ShaderNodeObject<InstancedMeshNode>;

three/src/nodes/accessors/Lights.d.ts

@@ -0,0 +1,15 @@
+import { Light } from "../../lights/Light.js";
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export function lightShadowMatrix(light: Light): ShaderNodeObject<Node>;
+
+export function lightProjectionUV(light: Light): ShaderNodeObject<Node>;
+
+export function lightPosition(light: Light): ShaderNodeObject<Node>;
+
+export function lightTargetPosition(light: Light): ShaderNodeObject<Node>;
+
+export function lightViewPosition(light: Light): ShaderNodeObject<Node>;
+
+export const lightTargetDirection: (light: Light) => ShaderNodeObject<Node>;

three/src/nodes/accessors/StorageBufferNode.d.ts

@@ -1,38 +1,47 @@
 import StorageBufferAttribute from "../../renderers/common/StorageBufferAttribute.js";
 import StorageInstancedBufferAttribute from "../../renderers/common/StorageInstancedBufferAttribute.js";
-import { GPUBufferBindingType } from "../../renderers/webgpu/utils/WebGPUConstants.js";
-import { NodeOrType, NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { NodeAccess } from "../core/constants.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 import StorageArrayElementNode from "../utils/StorageArrayElementNode.js";
 import BufferNode from "./BufferNode.js";
 
 export default class StorageBufferNode extends BufferNode {
     readonly isStorageBufferNode: true;
-    bufferObject: boolean;
 
-    access: GPUBufferBindingType;
+    access: NodeAccess;
+    isAtomic: boolean;
+    isPBO: boolean;
+
+    bufferObject: boolean;
 
     constructor(
         value: StorageBufferAttribute | StorageInstancedBufferAttribute,
-        bufferType: string,
+        bufferType?: string | null,
         bufferCount?: number,
     );
 
     element(indexNode: NodeRepresentation): ShaderNodeObject<StorageArrayElementNode>;
 
-    setBufferObject(value: boolean): this;
+    setPBO(value: boolean): this;
 
-    setAccess(value: GPUBufferBindingType): this;
+    getPBO(): boolean;
+
+    setAccess(value: NodeAccess): this;
 
     toReadOnly(): this;
 }
 
 export const storage: (
     value: StorageBufferAttribute | StorageInstancedBufferAttribute,
-    nodeOrType: NodeOrType,
-    count: number,
+    type?: string | null,
+    count?: number,
 ) => ShaderNodeObject<StorageBufferNode>;
+
+/**
+ * @deprecated
+ */
 export const storageObject: (
     value: StorageBufferAttribute | StorageInstancedBufferAttribute,
-    nodeOrType: NodeOrType,
-    count: number,
+    type?: string | null,
+    count?: number,
 ) => ShaderNodeObject<StorageBufferNode>;

three/src/nodes/accessors/StorageTextureNode.d.ts

@@ -1,5 +1,5 @@
-import { GPUStorageTextureAccess } from "../../renderers/webgpu/utils/WebGPUConstants.js";
 import { Texture } from "../../textures/Texture.js";
+import { NodeAccess } from "../core/constants.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
 import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
@@ -10,7 +10,7 @@ export default class StorageTextureNode extends TextureNode {
 
     readonly isStorageTextureNode: true;
 
-    access: GPUStorageTextureAccess;
+    access: NodeAccess;
 
     constructor(
         value: Texture,
@@ -18,7 +18,9 @@ export default class StorageTextureNode extends TextureNode {
         storeNode?: Node | null,
     );
 
-    setAccess(value: GPUStorageTextureAccess): this;
+    setAccess(value: NodeAccess): this;
+
+    toReadWrite(): this;
 
     toReadOnly(): this;
 

three/src/nodes/core/IndexNode.d.ts

@@ -24,5 +24,7 @@ export default IndexNode;
 
 export const vertexIndex: ShaderNodeObject<IndexNode>;
 export const instanceIndex: ShaderNodeObject<IndexNode>;
+export const subgroupIndex: ShaderNodeObject<IndexNode>;
+export const invocationSubgroupIndex: ShaderNodeObject<IndexNode>;
 export const invocationLocalIndex: ShaderNodeObject<IndexNode>;
 export const drawIndex: ShaderNodeObject<IndexNode>;

three/src/nodes/core/NodeUtils.d.ts

@@ -17,8 +17,15 @@ export const hashArray: (array: number[]) => number;
 export const hash: (...params: number[]) => number;
 
 export function getCacheKey(object: Node, force?: boolean): number;
+
 export function getNodeChildren(object: Node): Generator<NodeChild, void>;
+
+export function getTypeFromLength(length: number): string | undefined;
+
+export function getLengthFromType(type: string): number | undefined;
+
 export function getValueType(value: unknown): string | null;
+
 export function getValueFromType(
     type: string,
     ...params: number[]

three/src/nodes/core/StackNode.d.ts

@@ -1,6 +1,7 @@
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
-export default class StackNode extends Node {
+declare class StackNode extends Node {
     isStackNode: true;
     nodes: Node[];
     outputNode: Node | null;
@@ -25,3 +26,7 @@ export default class StackNode extends Node {
      */
     else(method: () => void): this;
 }
+
+export default StackNode;
+
+export const stack: () => ShaderNodeObject<StackNode>;

three/src/nodes/core/constants.d.ts

@@ -19,8 +19,14 @@ export declare const NodeType: {
     readonly MATRIX3: "mat3";
     readonly MATRIX4: "mat4";
 };
+export declare const NodeAccess: {
+    readonly READ_ONLY: "readOnly";
+    readonly WRITE_ONLY: "writeOnly";
+    readonly READ_WRITE: "readWrite";
+};
 export type NodeShaderStage = "vertex" | "fragment" | "compute";
 export type NodeUpdateType = "none" | "frame" | "render" | "object";
+export type NodeAccess = "readOnly" | "writeOnly" | "readWrite";
 export declare const defaultShaderStages: NodeShaderStage[];
 export declare const defaultBuildStages: string[];
 export declare const shaderStages: NodeShaderStage[];

three/src/nodes/display/BlendModes.d.ts

@@ -0,0 +1,32 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const blendBurn: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const blendDodge: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const blendScreen: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const blendOverlay: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const blendColor: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+
+/**
+ * @deprecated
+ */
+export const burn: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+
+/**
+ * @deprecated
+ */
+export const dodge: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+
+/**
+ * @deprecated
+ */
+export const screen: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
+
+/**
+ * @deprecated
+ */
+export const overlay: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;

three/src/nodes/display/ScreenNode.d.ts

@@ -37,6 +37,11 @@ export const viewportUV: ShaderNodeObject<Node>;
 
 // Deprecated
 
+/**
+ * @deprecated "viewportResolution" is deprecated. Use "screenSize" instead.
+ */
+export const viewportResolution: ShaderNodeObject<ScreenNode>;
+
 /**
  * @deprecated "viewportTopLeft" is deprecated. Use "viewportUV" instead.
  */

three/src/nodes/display/ViewportDepthNode.d.ts

@@ -29,7 +29,9 @@ export const viewZToPerspectiveDepth: (viewZ: Node, near: Node, far: Node) => No
 
 export const perspectiveDepthToViewZ: (depth: Node, near: Node, far: Node) => Node;
 
-export const perspectiveDepthToLogarithmicDepth: (perspectiveW: Node, near: Node, far: Node) => Node;
+export const viewZToLogarithmicDepth: (viewZ: Node, near: Node, far: Node) => Node;
+
+export const logarithmicDepthToViewZ: (depth: Node, near: Node, far: Node) => Node;
 
 export const depth: ShaderNodeObject<ViewportDepthNode>;
 export const linearDepth: (valueNode?: Node | null) => ShaderNodeObject<ViewportDepthNode>;

three/src/nodes/gpgpu/AtomicFunctionNode.d.ts

@@ -0,0 +1,88 @@
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export type AtomicMethod =
+    | typeof AtomicFunctionNode.ATOMIC_LOAD
+    | typeof AtomicFunctionNode.ATOMIC_STORE
+    | typeof AtomicFunctionNode.ATOMIC_ADD
+    | typeof AtomicFunctionNode.ATOMIC_SUB
+    | typeof AtomicFunctionNode.ATOMIC_MAX
+    | typeof AtomicFunctionNode.ATOMIC_MIN
+    | typeof AtomicFunctionNode.ATOMIC_AND
+    | typeof AtomicFunctionNode.ATOMIC_OR
+    | typeof AtomicFunctionNode.ATOMIC_XOR;
+
+declare class AtomicFunctionNode extends TempNode {
+    method: AtomicMethod;
+    pointerNode: Node;
+    valueNode: Node;
+    storeNode: Node;
+
+    constructor(method: AtomicMethod, pointerNode: Node, valueNode: Node, storeNode?: Node | null);
+
+    static ATOMIC_LOAD: "atomicLoad";
+    static ATOMIC_STORE: "atomicStore";
+    static ATOMIC_ADD: "atomicAdd";
+    static ATOMIC_SUB: "atomicSub";
+    static ATOMIC_MAX: "atomicMax";
+    static ATOMIC_MIN: "atomicMin";
+    static ATOMIC_AND: "atomicAnd";
+    static ATOMIC_OR: "atomicOr";
+    static ATOMIC_XOR: "atomicXor";
+}
+
+export const atomicFunc: (
+    method: AtomicMethod,
+    pointerNode: NodeRepresentation,
+    valueNode: NodeRepresentation,
+    storeNode?: NodeRepresentation | null,
+) => ShaderNodeObject<AtomicFunctionNode>;
+
+export const atomicStore: (
+    pointerNode: NodeRepresentation,
+    valueNode: NodeRepresentation,
+    storeNode?: NodeRepresentation | null,
+) => ShaderNodeObject<AtomicFunctionNode>;
+
+export const atomicAdd: (
+    pointerNode: NodeRepresentation,
+    valueNode: NodeRepresentation,
+    storeNode?: NodeRepresentation | null,
+) => ShaderNodeObject<AtomicFunctionNode>;
+
+export const atomicSub: (
+    pointerNode: NodeRepresentation,
+    valueNode: NodeRepresentation,
+    storeNode?: NodeRepresentation | null,
+) => ShaderNodeObject<AtomicFunctionNode>;
+
+export const atomicMax: (
+    pointerNode: NodeRepresentation,
+    valueNode: NodeRepresentation,
+    storeNode?: NodeRepresentation | null,
+) => ShaderNodeObject<AtomicFunctionNode>;
+
+export const atomicMin: (
+    pointerNode: NodeRepresentation,
+    valueNode: NodeRepresentation,
+    storeNode?: NodeRepresentation | null,
+) => ShaderNodeObject<AtomicFunctionNode>;
+
+export const atomicAnd: (
+    pointerNode: NodeRepresentation,
+    valueNode: NodeRepresentation,
+    storeNode?: NodeRepresentation | null,
+) => ShaderNodeObject<AtomicFunctionNode>;
+
+export const atomicOr: (
+    pointerNode: NodeRepresentation,
+    valueNode: NodeRepresentation,
+    storeNode?: NodeRepresentation | null,
+) => ShaderNodeObject<AtomicFunctionNode>;
+
+export const atomicXor: (
+    pointerNode: NodeRepresentation,
+    valueNode: NodeRepresentation,
+    storeNode?: NodeRepresentation | null,
+) => ShaderNodeObject<AtomicFunctionNode>;

three/src/nodes/gpgpu/BarrierNode.d.ts

@@ -0,0 +1,12 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class BarrierNode extends Node {
+    scope: string;
+
+    constructor(scope: string);
+}
+
+export const workgroupBarrier: () => ShaderNodeObject<Node>;
+export const storageBarrier: () => ShaderNodeObject<Node>;
+export const textureBarrier: () => ShaderNodeObject<Node>;

three/src/nodes/gpgpu/ComputeBuiltinNode.d.ts

@@ -0,0 +1,13 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class ComputeBuiltinNode extends Node {
+    constructor(builtinName: string, nodeType: string);
+}
+
+export default ComputeBuiltinNode;
+
+export const numWorkgroups: ShaderNodeObject<ComputeBuiltinNode>;
+export const workgroupId: ShaderNodeObject<ComputeBuiltinNode>;
+export const localId: ShaderNodeObject<ComputeBuiltinNode>;
+export const subgroupSize: ShaderNodeObject<ComputeBuiltinNode>;

three/src/nodes/gpgpu/WorkgroupInfoNode.d.ts

@@ -0,0 +1,17 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class WorkgroupInfoNode extends Node {
+    bufferType: string;
+    bufferCount: number;
+
+    readonly isWorkgroupInfoNode: true;
+
+    scope: string;
+
+    constructor(scope: string, bufferType: string, bufferCount?: number);
+}
+
+export default WorkgroupInfoNode;
+
+export const workgroupArray: (type: string, count?: number) => ShaderNodeObject<WorkgroupInfoNode>;

three/src/nodes/lighting/AnalyticLightNode.d.ts

@@ -1,8 +1,19 @@
 import { Light } from "../../lights/Light.js";
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import LightingNode from "./LightingNode.js";
+import ShadowNode from "./ShadowNode.js";
+
+declare module "../../lights/LightShadow.js" {
+    export interface LightShadow {
+        shadowNode?: Node;
+    }
+}
 
 export default class AnalyticLightNode<T extends Light> extends LightingNode {
     light: T | null;
 
     constructor(light?: T | null);
+
+    setupShadowNode(): ShaderNodeObject<ShadowNode>;
 }

three/src/nodes/lighting/LightsNode.d.ts

@@ -2,14 +2,14 @@ import { Light } from "../../lights/Light.js";
 import Node from "../core/Node.js";
 import { NodeBuilder } from "../Nodes.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
-import LightNode from "./LightNode.js";
+import LightingNode from "./LightingNode.js";
 
 declare class LightsNode extends Node {
     constructor();
 
     setupLightsNode(builder: NodeBuilder): void;
 
-    setupLights(builder: NodeBuilder, lightNodes: LightNode[]): void;
+    setupLights(builder: NodeBuilder, lightNodes: LightingNode[]): void;
 
     setLights(lights: Light[]): this;
 

three/src/nodes/lighting/PointLightNode.d.ts

@@ -2,6 +2,7 @@ import { PointLight } from "../../lights/PointLight.js";
 import Node from "../core/Node.js";
 import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 import AnalyticLightNode from "./AnalyticLightNode.js";
+import PointShadowNode from "./PointShadowNode.js";
 
 export const directPointLight: (
     color: NodeRepresentation,
@@ -15,6 +16,8 @@ declare class PointLightNode extends AnalyticLightNode<PointLight> {
     decayExponentNode: Node;
 
     constructor(light?: PointLight | null);
+
+    setupShadowNode(): ShaderNodeObject<PointShadowNode>;
 }
 
 export default PointLightNode;