@types/three 0.169.0 → 0.171.0

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

@@ -4,11 +4,15 @@ import UniformNode from "../core/UniformNode.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class VelocityNode extends TempNode {
+    projectionMatrix: Matrix4 | null;
+
     previousModelWorldMatrix: UniformNode<Matrix4>;
     previousProjectionMatrix: UniformNode<Matrix4>;
     previousCameraViewMatrix: UniformNode<Matrix4>;
 
     constructor();
+
+    setProjectionMatrix(projectionMatrix: Matrix4 | null): void;
 }
 
 export default VelocityNode;

three/src/nodes/code/ScriptableNode.d.ts

@@ -5,7 +5,7 @@ declare class Resources extends Map<string, unknown> {
     get<TArgs extends unknown[]>(key: string, callback?: ((...args: TArgs) => void) | null, ...params: TArgs): unknown;
 }
 
-export const global: Resources;
+export const ScriptableNodeResources: Resources;
 
 declare class ScriptableNode extends Node {
     codeNode: Node | null;

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;
@@ -11,17 +12,21 @@ export default class StackNode extends Node {
 
     If(boolNode: Node, method: () => void): this;
 
-    ElseIf(node: Node, method: () => void): this;
+    ElseIf(boolNode: Node, method: () => void): this;
 
-    Else(node: Node, method: () => void): this;
+    Else(method: () => void): this;
 
     /**
      * @deprecated Use {@link StackNode#ElseIf Else()} instead.
      */
-    elseif(node: Node, method: () => void): this;
+    elseif(boolNode: Node, method: () => void): this;
 
     /**
      * @deprecated Use {@link StackNode#Else Else()} instead.
      */
-    else(node: Node, method: () => void): this;
+    else(method: () => void): this;
 }
+
+export default StackNode;
+
+export const stack: () => ShaderNodeObject<StackNode>;

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

@@ -10,11 +10,22 @@ export default class VarNode extends Node {
     constructor(node: Node, name?: string | null);
 }
 
+declare module "../tsl/TSLCore.js" {
+    interface NodeElements {
+        toVar: (node: NodeRepresentation, name?: string | null) => ShaderNodeObject<VarNode>;
+    }
+}
+
+/**
+ * @deprecated Use ".toVar()" instead.
+ */
 export const temp: (node: NodeRepresentation, name?: string | null) => ShaderNodeObject<VarNode>;
 
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {
+        /**
+         * @deprecated Use ".toVar()" instead.
+         */
         temp: typeof temp;
-        toVar: typeof temp;
     }
 }

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/ColorAdjustment.d.ts

@@ -25,3 +25,32 @@ export const luminance: (
 ) => ShaderNodeObject<MathNode>;
 
 export const threshold: (color: NodeRepresentation, thershold: NodeRepresentation) => ShaderNodeObject<MathNode>;
+
+/**
+ * Color Decision List (CDL) v1.2
+ *
+ * Compact representation of color grading information, defined by slope, offset, power, and saturation. The CDL should
+ * be typically be given input in a log space (such as LogC, ACEScc, or AgX Log), and will return output in the same
+ * space. Output may require clamping >=0.
+ *
+ * References:
+ * - ASC CDL v1.2
+ * - https://blender.stackexchange.com/a/55239/43930
+ * - https://docs.acescentral.com/specifications/acescc/
+ *
+ * @param color Input (-Infinity < input < +Infinity)
+ * @param slope Slope (0 ≤ slope < +Infinity)
+ * @param offset Offset (-Infinity < offset < +Infinity; typically -1 < offset < 1)
+ * @param power Power (0 < power < +Infinity)
+ * @param saturation Saturation (0 ≤ saturation < +Infinity; typically 0 ≤ saturation < 4)
+ * @param luminanceCoefficients Luminance coefficients for saturation term, typically Rec. 709
+ * @return Output, -Infinity < output < +Infinity
+ */
+export const cdl: (
+    color: NodeRepresentation,
+    slope?: NodeRepresentation,
+    offset?: NodeRepresentation,
+    power?: NodeRepresentation,
+    saturation?: NodeRepresentation,
+    luminanceCoefficients?: NodeRepresentation,
+) => ShaderNodeObject<Node>;

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

@@ -1,6 +1,6 @@
 import Node from "../core/Node.js";
 import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const sRGBToLinearSRGB: (color: NodeRepresentation) => ShaderNodeObject<Node>;
+export const sRGBTransferEOTF: (color: NodeRepresentation) => ShaderNodeObject<Node>;
 
-export const linearSRGBTosRGB: (color: NodeRepresentation) => ShaderNodeObject<Node>;
+export const sRGBTransferOETF: (color: NodeRepresentation) => ShaderNodeObject<Node>;

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

@@ -1,4 +1,4 @@
-import { ColorSpace, LinearSRGBColorSpace, SRGBColorSpace } from "../../constants.js";
+import { LinearSRGBColorSpace, SRGBColorSpace } from "../../constants.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
 import TempNode from "../core/TempNode.js";
@@ -15,16 +15,16 @@ export function getColorSpaceMethod(
 
 export default class ColorSpaceNode extends TempNode {
     colorNode: Node;
-    source: WorkingOrOutputColorSpace | ColorSpace;
-    target: WorkingOrOutputColorSpace | ColorSpace;
+    source: string;
+    target: string;
 
     constructor(
         colorNode: Node,
-        source: WorkingOrOutputColorSpace | ColorSpace,
-        target: WorkingOrOutputColorSpace | ColorSpace,
+        source: string,
+        target: string,
     );
 
-    getColorSpace(nodeBuilder: NodeBuilder, colorSpace: WorkingOrOutputColorSpace): ColorSpace;
+    resolveColorSpace(nodeBuilder: NodeBuilder, colorSpace: WorkingOrOutputColorSpace): string;
 }
 
 export const toOutputColorSpace: (
@@ -36,11 +36,17 @@ export const toWorkingColorSpace: (
 
 export const workingToColorSpace: (
     node: NodeRepresentation,
-    colorSpace: ColorSpace,
+    colorSpace: string,
 ) => ShaderNodeObject<ColorSpaceNode>;
 export const colorSpaceToWorking: (
     node: NodeRepresentation,
-    colorSpace: ColorSpace,
+    colorSpace: string,
+) => ShaderNodeObject<ColorSpaceNode>;
+
+export const convertColorSpace: (
+    node: NodeRepresentation,
+    sourceColorSpace: string,
+    targetColorSpace: string,
 ) => ShaderNodeObject<ColorSpaceNode>;
 
 declare module "../tsl/TSLCore.js" {

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

@@ -1,4 +1,4 @@
-import { ColorSpace, ToneMapping } from "../../constants.js";
+import { ToneMapping } from "../../constants.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
 import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
@@ -6,11 +6,11 @@ import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 declare class RenderOutputNode extends TempNode {
     colorNode: Node;
     toneMapping: ToneMapping | null;
-    outputColorSpace: ColorSpace | null;
+    outputColorSpace: string | null;
 
     readonly isRenderOutput: true;
 
-    constructor(colorNode: Node, toneMapping?: ToneMapping | null, outputColorSpace?: ColorSpace | null);
+    constructor(colorNode: Node, toneMapping?: ToneMapping | null, outputColorSpace?: string | null);
 }
 
 export default RenderOutputNode;
@@ -18,7 +18,7 @@ export default RenderOutputNode;
 export const renderOutput: (
     color: NodeRepresentation,
     toneMapping?: ToneMapping | null,
-    outputColorSpace?: ColorSpace | null,
+    outputColorSpace?: string | null,
 ) => ShaderNodeObject<RenderOutputNode>;
 
 declare module "../tsl/TSLCore.js" {

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,6 +29,10 @@ export const viewZToPerspectiveDepth: (viewZ: Node, near: Node, far: Node) => No
 
 export const perspectiveDepthToViewZ: (depth: 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>;
 export const viewportLinearDepth: ShaderNodeObject<ViewportDepthNode>;

three/src/nodes/functions/material/getAlphaHashThreshold.d.ts

@@ -0,0 +1,6 @@
+import Node from "../../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../../tsl/TSLCore.js";
+
+declare const getAlphaHashThreshold: (position: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export default getAlphaHashThreshold;

three/src/nodes/functions/material/getParallaxCorrectNormal.d.ts

@@ -0,0 +1,10 @@
+import Node from "../../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../../tsl/TSLCore.js";
+
+declare const getParallaxCorrectNormal: (
+    normal: NodeRepresentation,
+    cubeSize: NodeRepresentation,
+    cubePos: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export default getParallaxCorrectNormal;

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/ComputeNode.d.ts

@@ -1,3 +1,4 @@
+import Renderer from "../../renderers/common/Renderer.js";
 import Node from "../core/Node.js";
 import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
@@ -8,7 +9,11 @@ export default class ComputeNode extends Node {
     workgroupSize: number[];
     dispatchCount: number;
 
+    onInitFunction: ((args: { renderer: Renderer }) => void) | null;
+
     constructor(computeNode: Node, count: number, workgroupSize?: number[]);
+
+    onInit(callback: ((args: { renderer: Renderer }) => void) | null): void;
 }
 
 export const compute: (

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,17 +2,22 @@ import { Light } from "../../lights/Light.js";
 import Node from "../core/Node.js";
 import { NodeBuilder } from "../Nodes.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import LightingNode from "./LightingNode.js";
 
 declare class LightsNode extends Node {
-    constructor(lights?: Light[]);
+    constructor();
 
     setupLightsNode(builder: NodeBuilder): void;
 
+    setupLights(builder: NodeBuilder, lightNodes: LightingNode[]): void;
+
     setLights(lights: Light[]): this;
 
     getLights(): Light[];
+
+    get hasLights(): boolean;
 }
 
 export default LightsNode;
 
-export const lights: (lights: Light[]) => ShaderNodeObject<LightsNode>;
+export const lights: (lights?: Light[]) => ShaderNodeObject<LightsNode>;

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

@@ -1,10 +1,23 @@
 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 default class PointLightNode extends AnalyticLightNode<PointLight> {
+export const directPointLight: (
+    color: NodeRepresentation,
+    lightViewPosition: NodeRepresentation,
+    cutoffDistance: NodeRepresentation,
+    decayExponent: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+declare class PointLightNode extends AnalyticLightNode<PointLight> {
     cutoffDistanceNode: Node;
     decayExponentNode: Node;
 
     constructor(light?: PointLight | null);
+
+    setupShadowNode(): ShaderNodeObject<PointShadowNode>;
 }
+
+export default PointLightNode;

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

@@ -0,0 +1,30 @@
+import { Light } from "../../lights/Light.js";
+import { LightShadow } from "../../lights/LightShadow.js";
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import ShadowNode from "./ShadowNode.js";
+
+export const cubeToUV: (pos: NodeRepresentation, texelSizeY: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const BasicPointShadowFilter: (
+    depthTexture: NodeRepresentation,
+    bd3D: NodeRepresentation,
+    dp: NodeRepresentation,
+    texelSize: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const PointShadowFilter: (
+    depthTexture: NodeRepresentation,
+    bd3D: NodeRepresentation,
+    dp: NodeRepresentation,
+    texelSize: NodeRepresentation,
+    shadow: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+declare class PointShadowNode extends ShadowNode {
+    constructor(light: Light, shadow: LightShadow | null);
+}
+
+export default PointShadowNode;
+
+export const pointShadow: (light: Light, shadow?: LightShadow | null) => ShaderNodeObject<PointShadowNode>;

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

@@ -0,0 +1,35 @@
+import { Light } from "../../lights/Light.js";
+import { LightShadow } from "../../lights/LightShadow.js";
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const BasicShadowFilter: (
+    depthTexture: NodeRepresentation,
+    shadowCoord: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const PCFShadowFilter: (
+    depthTexture: NodeRepresentation,
+    shadowCoord: NodeRepresentation,
+    shadow: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const PCFSoftShadowFilter: (
+    depthTexture: NodeRepresentation,
+    shadowCoord: NodeRepresentation,
+    shadow: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const VSMShadowFilter: (
+    depthTexture: NodeRepresentation,
+    shadowCoord: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+declare class ShadowNode extends Node {
+    constructor(light: Light, shadow: LightShadow | null);
+}
+
+export default ShadowNode;
+
+export const shadow: (light: Light, shadow?: LightShadow) => ShaderNodeObject<ShadowNode>;
+export const shadows: ShaderNodeObject<Node>;

three/src/nodes/math/OperatorNode.d.ts

@@ -10,6 +10,7 @@ export type OperatorNodeOp =
     | ">>"
     | "<<"
     | "=="
+    | "!="
     | "&&"
     | "||"
     | "^^"
@@ -42,6 +43,7 @@ export const mul: Operator;
 export const div: Operator;
 export const modInt: Operator;
 export const equal: Operator;
+export const notEqual: Operator;
 export const lessThan: Operator;
 export const greaterThan: Operator;
 export const lessThanEqual: Operator;
@@ -65,6 +67,7 @@ declare module "../tsl/TSLCore.js" {
         div: typeof div;
         modInt: typeof modInt;
         equal: typeof equal;
+        notEqual: typeof notEqual;
         lessThan: typeof lessThan;
         greaterThan: typeof greaterThan;
         lessThanEqual: typeof lessThanEqual;

three/src/nodes/tsl/TSLBase.d.ts

@@ -19,3 +19,8 @@ export * from "../math/OperatorNode.js";
 export * from "../utils/Discard.js";
 export * from "../utils/RemapNode.js";
 export * from "./TSLCore.js";
+
+/**
+ * @deprecated
+ */
+export function addNodeElement(name: string): void;