@types/three 0.180.0 → 0.182.0

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

@@ -2,10 +2,8 @@ import { ToneMapping } from "../../constants.js";
 import RendererReferenceNode from "../accessors/RendererReferenceNode.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class ToneMappingNode extends TempNode {
-    toneMapping: ToneMapping;
     exposureNode: Node;
     colorNode: Node | null;
 
@@ -18,15 +16,18 @@ export const toneMapping: (
     mapping: ToneMapping,
     exposure: Node | number,
     color?: Node,
-) => ShaderNodeObject<ToneMappingNode>;
-export const toneMappingExposure: ShaderNodeObject<RendererReferenceNode>;
+) => ToneMappingNode;
+export const toneMappingExposure: RendererReferenceNode;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
+declare module "../Nodes.js" {
+    interface Node {
         toneMapping: (
-            color: Node,
             mapping?: ToneMapping,
             exposure?: Node | number,
-        ) => ShaderNodeObject<ToneMappingNode>;
+        ) => ToneMappingNode;
+        toneMappingAssign: (
+            mapping?: ToneMapping,
+            exposure?: Node | number,
+        ) => this;
     }
 }

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

@@ -2,7 +2,6 @@ import { Camera } from "../../cameras/Camera.js";
 import { Color } from "../../math/Color.js";
 import { Scene } from "../../scenes/Scene.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import PassNode from "./PassNode.js";
 
 declare class ToonOutlinePassNode extends PassNode {
@@ -21,4 +20,4 @@ export const toonOutlinePass: (
     color?: Color,
     thickness?: number,
     alpha?: number,
-) => ShaderNodeObject<ToonOutlinePassNode>;
+) => ToonOutlinePassNode;

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

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class ViewportDepthNode extends Node {
     scope: ViewportDepthNodeScope;
@@ -33,6 +32,6 @@ export const viewZToLogarithmicDepth: (viewZ: Node, near: Node, far: Node) => No
 
 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>;
+export const depth: ViewportDepthNode;
+export const linearDepth: (valueNode?: Node | null) => ViewportDepthNode;
+export const viewportLinearDepth: ViewportDepthNode;

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

@@ -1,6 +1,5 @@
 import { DepthTexture } from "../../textures/DepthTexture.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import ViewportTextureNode from "./ViewportTextureNode.js";
 
 declare class ViewportDepthTextureNode extends ViewportTextureNode {
@@ -14,4 +13,4 @@ export default ViewportDepthTextureNode;
 export const viewportDepthTexture: (
     uvNode?: Node,
     levelNode?: Node,
-) => ShaderNodeObject<ViewportDepthTextureNode>;
+) => ViewportDepthTextureNode;

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

@@ -1,6 +1,5 @@
 import { FramebufferTexture } from "../../textures/FramebufferTexture.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import ViewportTextureNode from "./ViewportTextureNode.js";
 
 declare class ViewportSharedTextureNode extends ViewportTextureNode {
@@ -14,4 +13,4 @@ export default ViewportSharedTextureNode;
 export const viewportSharedTexture: (
     uvNode?: Node,
     levelNode?: Node | null,
-) => ShaderNodeObject<ViewportSharedTextureNode>;
+) => ViewportSharedTextureNode;

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

@@ -4,7 +4,6 @@ import { Texture } from "../../textures/Texture.js";
 import TextureNode from "../accessors/TextureNode.js";
 import { NodeUpdateType } from "../core/constants.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class ViewportTextureNode extends TextureNode {
     generateMipmaps: boolean;
@@ -24,9 +23,9 @@ export const viewportTexture: (
     uvNode?: Node,
     levelNode?: Node | null,
     framebufferTexture?: FramebufferTexture | null,
-) => ShaderNodeObject<ViewportTextureNode>;
+) => ViewportTextureNode;
 export const viewportMipTexture: (
     uvNode?: Node,
     levelNode?: Node | null,
     framebufferTexture?: FramebufferTexture | null,
-) => ShaderNodeObject<Node>;
+) => Node;

three/src/nodes/fog/Fog.d.ts

@@ -1,11 +1,10 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const rangeFogFactor: (near: Node | number, far: Node | number) => ShaderNodeObject<Node>;
+export const rangeFogFactor: (near: Node | number, far: Node | number) => Node;
 
-export const densityFogFactor: (density: Node) => ShaderNodeObject<Node>;
+export const densityFogFactor: (density: Node) => Node;
 
-export const fog: (color: Node, factor: Node) => ShaderNodeObject<Node>;
+export const fog: (color: Node, factor: Node) => Node;
 
 /**
  * @deprecated
@@ -14,7 +13,7 @@ export function rangeFog(
     color: Node,
     near: Node,
     far: Node,
-): ShaderNodeObject<Node>;
+): Node;
 
 /**
  * @deprecated
@@ -23,4 +22,4 @@ export function densityFog(
     color: Node,
     near: Node,
     far: Node,
-): ShaderNodeObject<Node>;
+): Node;

three/src/nodes/functions/BSDF/BRDF_GGX.d.ts

@@ -1,15 +1,14 @@
 import Node from "../../core/Node.js";
 import OperatorNode from "../../math/OperatorNode.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
 declare const BRDF_GGX: (args: {
     lightDirection: Node;
     f0: Node;
     f90: Node;
     roughness: Node;
-    f?: Node;
-    USE_IRIDESCENCE?: Node;
-    USE_ANISOTROPY?: Node;
-}) => ShaderNodeObject<OperatorNode>;
+    f?: Node | undefined;
+    USE_IRIDESCENCE?: Node | undefined;
+    USE_ANISOTROPY?: Node | undefined;
+}) => OperatorNode;
 
 export default BRDF_GGX;

three/src/nodes/functions/BSDF/BRDF_GGX_Multiscatter.d.ts

@@ -0,0 +1,14 @@
+import Node from "../../core/Node.js";
+import OperatorNode from "../../math/OperatorNode.js";
+
+declare const BRDF_GGX_Multiscatter: (args: {
+    lightDirection: Node;
+    f0: Node;
+    f90: Node;
+    roughness: Node;
+    f?: Node | undefined;
+    USE_IRIDESCENCE?: Node | undefined;
+    USE_ANISOTROPY?: Node | undefined;
+}) => OperatorNode;
+
+export default BRDF_GGX_Multiscatter;

three/src/nodes/functions/BSDF/BRDF_Lambert.d.ts

@@ -1,7 +1,6 @@
 import Node from "../../core/Node.js";
 import OperatorNode from "../../math/OperatorNode.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
-declare const BRDF_Lambert: (args: { diffuseColor: Node }) => ShaderNodeObject<OperatorNode>;
+declare const BRDF_Lambert: (args: { diffuseColor: Node }) => OperatorNode;
 
 export default BRDF_Lambert;

three/src/nodes/functions/BSDF/BRDF_Sheen.d.ts

@@ -1,7 +1,6 @@
 import Node from "../../core/Node.js";
 import OperatorNode from "../../math/OperatorNode.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
-declare const BRDF_Sheen: (args: { lightDirection: Node }) => ShaderNodeObject<OperatorNode>;
+declare const BRDF_Sheen: (args: { lightDirection: Node }) => OperatorNode;
 
 export default BRDF_Sheen;

three/src/nodes/functions/BSDF/DFGLUT.d.ts

@@ -0,0 +1,12 @@
+import Node from "../../core/Node.js";
+import OperatorNode from "../../math/OperatorNode.js";
+
+/**
+ * Precomputed DFG LUT for Image-Based Lighting
+ * Resolution: 16x16
+ * Samples: 4096 per texel
+ * Format: RG16F (2 half floats per texel: scale, bias)
+ */
+declare const DFGLUT: (args: { roughness: Node; dotNV: Node }) => OperatorNode;
+
+export default DFGLUT;

three/src/nodes/functions/BSDF/D_GGX.d.ts

@@ -1,10 +1,9 @@
 import Node from "../../core/Node.js";
 import OperatorNode from "../../math/OperatorNode.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
 // Microfacet Models for Refraction through Rough Surfaces - equation (33)
 // http://graphicrants.blogspot.com/2013/08/specular-brdf-reference.html
 // alpha is "roughness squared" in Disney’s reparameterization
-declare const D_GGX: (args: { alpha: Node; dotNH: Node }) => ShaderNodeObject<OperatorNode>;
+declare const D_GGX: (args: { alpha: Node; dotNH: Node }) => OperatorNode;
 
 export default D_GGX;

three/src/nodes/functions/BSDF/D_GGX_Anisotropic.d.ts

@@ -1,10 +1,9 @@
 import Node from "../../core/Node.js";
 import OperatorNode from "../../math/OperatorNode.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
 // https://google.github.io/filament/Filament.md.html#materialsystem/anisotropicmodel/anisotropicspecularbrdf
 declare const D_GGX_Anisotropic: (
     args: { alphaT: Node; alphaB: Node; dotNH: Node; dotTH: Node; dotBH: Node },
-) => ShaderNodeObject<OperatorNode>;
+) => OperatorNode;
 
 export default D_GGX_Anisotropic;

three/src/nodes/functions/BSDF/F_Schlick.d.ts

@@ -1,7 +1,6 @@
 import Node from "../../core/Node.js";
 import OperatorNode from "../../math/OperatorNode.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
-declare const F_Schlick: (args: { f0: Node; f90: Node; dotVH: Node }) => ShaderNodeObject<OperatorNode>;
+declare const F_Schlick: (args: { f0: Node; f90: Node; dotVH: Node }) => OperatorNode;
 
 export default F_Schlick;

three/src/nodes/functions/BSDF/Schlick_to_F0.d.ts

@@ -1,10 +1,9 @@
 import Node from "../../core/Node.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
 declare const Schlick_to_F0: (
     f: Node,
     f90: Node,
     dotVH: Node,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 export default Schlick_to_F0;

three/src/nodes/functions/BSDF/V_GGX_SmithCorrelated.d.ts

@@ -1,11 +1,10 @@
 import Node from "../../core/Node.js";
 import OperatorNode from "../../math/OperatorNode.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
 declare const V_GGX_SmithCorrelated: (inputs: {
     alpha: Node;
     dotNL: Node;
     dotNV: Node;
-}) => ShaderNodeObject<OperatorNode>;
+}) => OperatorNode;
 
 export default V_GGX_SmithCorrelated;

three/src/nodes/functions/BSDF/V_GGX_SmithCorrelated_Anisotropic.d.ts

@@ -1,6 +1,5 @@
 import Node from "../../core/Node.js";
 import MathNode from "../../math/MathNode.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
 declare const V_GGX_SmithCorrelated: (inputs: {
     alphaT: Node;
@@ -11,6 +10,6 @@ declare const V_GGX_SmithCorrelated: (inputs: {
     dotBL: Node;
     dotNV: Node;
     dotNL: Node;
-}) => ShaderNodeObject<MathNode>;
+}) => MathNode;
 
 export default V_GGX_SmithCorrelated;

three/src/nodes/functions/PhysicalLightingModel.d.ts

@@ -16,6 +16,8 @@ export default class PhysicalLightingModel extends LightingModel {
     sheenSpecularIndirect: Node | null;
     iridescenceFresnel: Node | null;
     iridescenceF0: Node | null;
+    iridescenceF0Dielectric: Node | null;
+    iridescenceF0Metallic: Node | null;
 
     constructor(
         clearcoat?: boolean,
@@ -26,5 +28,10 @@ export default class PhysicalLightingModel extends LightingModel {
         dispersion?: boolean,
     );
 
-    computeMultiscattering(singleScatter: Node, multiScatter: Node, specularF90: Node): void;
+    computeMultiscattering(
+        singleScatter: Node,
+        multiScatter: Node,
+        specularF90: Node,
+        iridescenceF0?: Node | null,
+    ): void;
 }

three/src/nodes/functions/ShadowMaskModel.d.ts

@@ -1,9 +1,8 @@
 import LightingModel from "../core/LightingModel.js";
 import VarNode from "../core/VarNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class ShadowMaskModel extends LightingModel {
-    shadowNode: ShaderNodeObject<VarNode>;
+    shadowNode: VarNode;
 
     constructor();
 }

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

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

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

@@ -1,6 +1,5 @@
 import MathNode from "../../math/MathNode.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
-declare const getGeometryRoughness: () => ShaderNodeObject<MathNode>;
+declare const getGeometryRoughness: () => MathNode;
 
 export default getGeometryRoughness;

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

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

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

@@ -1,7 +1,6 @@
 import Node from "../../core/Node.js";
 import MathNode from "../../math/MathNode.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
-declare const getRoughness: (args: { roughness: Node }) => ShaderNodeObject<MathNode>;
+declare const getRoughness: (args: { roughness: Node }) => MathNode;
 
 export default getRoughness;

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

@@ -1,6 +1,5 @@
 import Node from "../../core/Node.js";
-import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
-declare const getShIrradianceAt: (normal: Node, shCoefficients: Node) => ShaderNodeObject<Node>;
+declare const getShIrradianceAt: (normal: Node, shCoefficients: Node) => Node;
 
 export default getShIrradianceAt;

three/src/nodes/geometry/RangeNode.d.ts

@@ -4,7 +4,6 @@ import { Vector3 } from "../../math/Vector3.js";
 import { Vector4 } from "../../math/Vector4.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class RangeNode extends Node {
     minNode: Node;
@@ -18,4 +17,4 @@ export default class RangeNode extends Node {
 export const range: (
     minNode: Node | number | Color | Vector2 | Vector3 | Vector4,
     maxNode: Node | number | Color | Vector2 | Vector3 | Vector4,
-) => ShaderNodeObject<RangeNode>;
+) => RangeNode;

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

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type AtomicMethod =
     | typeof AtomicFunctionNode.ATOMIC_LOAD
@@ -35,48 +34,48 @@ export const atomicFunc: (
     method: AtomicMethod,
     pointerNode: Node,
     valueNode: Node,
-) => ShaderNodeObject<AtomicFunctionNode>;
+) => AtomicFunctionNode;
 
 export const atomicLoad: (
     pointerNode: Node,
-) => ShaderNodeObject<AtomicFunctionNode>;
+) => AtomicFunctionNode;
 
 export const atomicStore: (
     pointerNode: Node,
     valueNode: Node | number,
-) => ShaderNodeObject<AtomicFunctionNode>;
+) => AtomicFunctionNode;
 
 export const atomicAdd: (
     pointerNode: Node,
     valueNode: Node | number,
-) => ShaderNodeObject<AtomicFunctionNode>;
+) => AtomicFunctionNode;
 
 export const atomicSub: (
     pointerNode: Node,
     valueNode: Node | number,
-) => ShaderNodeObject<AtomicFunctionNode>;
+) => AtomicFunctionNode;
 
 export const atomicMax: (
     pointerNode: Node,
     valueNode: Node,
-) => ShaderNodeObject<AtomicFunctionNode>;
+) => AtomicFunctionNode;
 
 export const atomicMin: (
     pointerNode: Node,
     valueNode: Node,
-) => ShaderNodeObject<AtomicFunctionNode>;
+) => AtomicFunctionNode;
 
 export const atomicAnd: (
     pointerNode: Node,
     valueNode: Node,
-) => ShaderNodeObject<AtomicFunctionNode>;
+) => AtomicFunctionNode;
 
 export const atomicOr: (
     pointerNode: Node,
     valueNode: Node,
-) => ShaderNodeObject<AtomicFunctionNode>;
+) => AtomicFunctionNode;
 
 export const atomicXor: (
     pointerNode: Node,
     valueNode: Node,
-) => ShaderNodeObject<AtomicFunctionNode>;
+) => AtomicFunctionNode;

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

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

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

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

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

@@ -1,43 +1,51 @@
 import Renderer from "../../renderers/common/Renderer.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class ComputeNode extends Node {
     readonly isComputeNode: true;
 
     computeNode: Node;
     workgroupSize: number[];
-    count: number | null;
+    count: number | number[] | null;
     name: string;
 
     onInitFunction: ((args: { renderer: Renderer }) => void) | null;
 
     constructor(computeNode: Node, workgroupSize: number[]);
 
-    setCount(count: number): this;
-    getCount(): number | null;
+    setCount(count: number | number[]): this;
+    getCount(): number | number[] | null;
 
-    setName(name: string): this;
+    setName: (name: string) => this;
 
     /**
      * @deprecated "label()" has been deprecated. Use "setName()" instead.
      */
-    label(name: string): this;
+    label: (name: string) => this;
 
     onInit(callback: ((args: { renderer: Renderer }) => void) | null): void;
 }
 
-export const computeKernel: (node: Node, workgroupSize?: number[]) => ShaderNodeObject<ComputeNode>;
+export const computeKernel: (node: Node, workgroupSize?: number[]) => ComputeNode;
 
 export const compute: (
     node: Node,
     count: number,
     workgroupSize?: number[],
-) => ShaderNodeObject<ComputeNode>;
-
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        compute: typeof compute;
-        computeKernel: typeof computeKernel;
+) => ComputeNode;
+
+declare module "../Nodes.js" {
+    interface Node {
+        compute: (
+            count: number,
+            workgroupSize?: number[],
+        ) => ComputeNode;
+        computeAssign: (
+            count: number,
+            workgroupSize?: number[],
+        ) => this;
+
+        computeKernel: (workgroupSize?: number[]) => ComputeNode;
+        computeKernelAssign: (workgroupSize?: number[]) => this;
     }
 }

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

@@ -1,6 +1,5 @@
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type SubgroupFunctionNodeMethod0 = typeof SubgroupFunctionNode.SUBGROUP_ELECT;
 
@@ -71,30 +70,30 @@ declare class SubgroupFunctionNode extends TempNode {
 
 export default SubgroupFunctionNode;
 
-export const subgroupElect: () => ShaderNodeObject<Node>;
+export const subgroupElect: () => Node;
 
-export const subgroupBallot: (pred: Node) => ShaderNodeObject<Node>;
-export const subgroupAdd: (e: Node) => ShaderNodeObject<Node>;
-export const subgroupInclusiveAdd: (e: Node) => ShaderNodeObject<Node>;
-export const subgroupExclusiveAdd: (e: Node) => ShaderNodeObject<Node>;
-export const subgroupMul: (e: Node) => ShaderNodeObject<Node>;
-export const subgroupInclusiveMul: (e: Node) => ShaderNodeObject<Node>;
-export const subgroupExclusiveMul: (e: Node) => ShaderNodeObject<Node>;
-export const subgroupAnd: (e: Node) => ShaderNodeObject<Node>;
-export const subgroupOr: (e: Node) => ShaderNodeObject<Node>;
-export const subgroupXor: (e: Node) => ShaderNodeObject<Node>;
-export const subgroupMin: (e: Node) => ShaderNodeObject<Node>;
-export const subgroupMax: (e: Node) => ShaderNodeObject<Node>;
-export const subgroupAll: () => ShaderNodeObject<Node>;
-export const subgroupAny: () => ShaderNodeObject<Node>;
-export const subgroupBroadcastFirst: (e: Node, id: Node) => ShaderNodeObject<Node>;
-export const quadSwapX: (e: Node) => ShaderNodeObject<Node>;
-export const quadSwapY: (e: Node) => ShaderNodeObject<Node>;
-export const quadSwapDiagonal: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupBallot: (pred: Node) => Node;
+export const subgroupAdd: (e: Node) => Node;
+export const subgroupInclusiveAdd: (e: Node) => Node;
+export const subgroupExclusiveAdd: (e: Node) => Node;
+export const subgroupMul: (e: Node) => Node;
+export const subgroupInclusiveMul: (e: Node) => Node;
+export const subgroupExclusiveMul: (e: Node) => Node;
+export const subgroupAnd: (e: Node) => Node;
+export const subgroupOr: (e: Node) => Node;
+export const subgroupXor: (e: Node) => Node;
+export const subgroupMin: (e: Node) => Node;
+export const subgroupMax: (e: Node) => Node;
+export const subgroupAll: () => Node;
+export const subgroupAny: () => Node;
+export const subgroupBroadcastFirst: (e: Node, id: Node) => Node;
+export const quadSwapX: (e: Node) => Node;
+export const quadSwapY: (e: Node) => Node;
+export const quadSwapDiagonal: (e: Node) => Node;
 
-export const subgroupBroadcast: (e: Node, id: Node) => ShaderNodeObject<Node>;
-export const subgroupShuffle: (v: Node, id: Node) => ShaderNodeObject<Node>;
-export const subgroupShuffleXor: (v: Node, mask: Node) => ShaderNodeObject<Node>;
-export const subgroupShuffleUp: (v: Node, delta: Node) => ShaderNodeObject<Node>;
-export const subgroupShuffleDown: (v: Node, delta: Node) => ShaderNodeObject<Node>;
-export const quadBroadcast: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupBroadcast: (e: Node, id: Node) => Node;
+export const subgroupShuffle: (v: Node, id: Node) => Node;
+export const subgroupShuffleXor: (v: Node, mask: Node) => Node;
+export const subgroupShuffleUp: (v: Node, delta: Node) => Node;
+export const subgroupShuffleDown: (v: Node, delta: Node) => Node;
+export const quadBroadcast: (e: Node) => Node;

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

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class WorkgroupInfoNode extends Node {
     bufferType: string;
@@ -16,4 +15,4 @@ declare class WorkgroupInfoNode extends Node {
 
 export default WorkgroupInfoNode;
 
-export const workgroupArray: (type: string, count?: number) => ShaderNodeObject<WorkgroupInfoNode>;
+export const workgroupArray: (type: string, count?: number) => WorkgroupInfoNode;