@types/three 0.180.0 → 0.182.0

three/examples/jsm/transpiler/AST.d.ts

@@ -41,6 +41,7 @@ export type Statement =
     | While
     | Switch
     | SwitchCase
+    | StructMember
     | null;
 
 export class VariableDeclaration {
@@ -273,3 +274,19 @@ export class SwitchCase {
     isDefault: boolean;
     readonly isSwitchCase: true;
 }
+
+export class StructMember {
+    type: string;
+    name: string;
+    readonly isStructMember: true;
+
+    constructor(type: string, name: string);
+}
+
+export class StructDefinition {
+    name: string;
+    members: StructMember[];
+    readonly isStructDefinition: true;
+
+    constructor(name: string, members?: StructMember[]);
+}

three/examples/jsm/transpiler/TSLEncoder.d.ts

@@ -6,6 +6,7 @@ import {
     FunctionDeclaration,
     Program,
     Statement,
+    StructDefinition,
     Switch,
     Ternary,
     Uniform,
@@ -38,6 +39,7 @@ export default class TSLEncoder {
     emitWhile(node: While): string;
     emitVariables(node: VariableDeclaration, isRoot?: boolean): string;
     emitVarying(node: Varying): string;
+    emitStructDefinition(node: StructDefinition): string;
     emitOverloadingFunction(nodes: FunctionDeclaration[]): string;
     emitFunction(node: FunctionDeclaration): string;
     setLastStatement(statement: Statement | null): void;

three/examples/jsm/tsl/display/AfterImageNode.d.ts

@@ -1,16 +1,15 @@
-import { ShaderNodeObject } from "three/tsl";
-import { Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
+import { Node, TempNode, TextureNode } from "three/webgpu";
 
 export default class AfterImageNode extends TempNode {
     textureNode: TextureNode;
     textureNodeOld: Node;
-    damp: UniformNode<number>;
+    damp: Node;
 
-    constructor(textureNode: Node, damp?: number);
+    constructor(textureNode: Node, damp?: Node);
 
     getTextureNode(): TextureNode;
 
     setSize(width: number, height: number): void;
 }
 
-export const afterImage: (node: Node, damp?: number) => ShaderNodeObject<AfterImageNode>;
+export const afterImage: (node: Node, damp?: Node | number) => AfterImageNode;

three/examples/jsm/tsl/display/AnaglyphPassNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Camera, Scene } from "three/webgpu";
 import StereoCompositePassNode from "./StereoCompositePassNode.js";
 
@@ -10,4 +9,4 @@ declare class AnaglyphPassNode extends StereoCompositePassNode {
 
 export default AnaglyphPassNode;
 
-export const anaglyphPass: (scene: Scene, camera: Camera) => ShaderNodeObject<AnaglyphPassNode>;
+export const anaglyphPass: (scene: Scene, camera: Camera) => AnaglyphPassNode;

three/examples/jsm/tsl/display/AnamorphicNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, Vector2 } from "three/webgpu";
 
 export default class AnamorphicNode extends TempNode {
@@ -29,4 +28,4 @@ export const anamorphic: (
     threshold?: Node,
     scale?: Node,
     samples?: Node | number,
-) => ShaderNodeObject<AnamorphicNode>;
+) => AnamorphicNode;

three/examples/jsm/tsl/display/BleachBypass.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node } from "three/webgpu";
 
-export const bleach: (color: Node, opacity?: number) => ShaderNodeObject<Node>;
+export const bleach: (color: Node, opacity?: Node | number) => Node;

three/examples/jsm/tsl/display/BloomNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 declare class BloomNode extends TempNode {
@@ -11,7 +10,7 @@ declare class BloomNode extends TempNode {
 
     constructor(inputNode: Node, strength?: number, radius?: number, threshold?: number);
 
-    getTexture(): ShaderNodeObject<TextureNode>;
+    getTexture(): TextureNode;
 
     setSize(width: number, height: number): void;
 }
@@ -21,6 +20,6 @@ export const bloom: (
     strength?: number,
     radius?: number,
     threshold?: number,
-) => ShaderNodeObject<BloomNode>;
+) => BloomNode;
 
 export default BloomNode;

three/examples/jsm/tsl/display/ChromaticAberrationNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, Vector2 } from "three/webgpu";
 
 declare class ChromaticAberrationNode extends TempNode {
@@ -17,4 +16,4 @@ export const chromaticAberration: (
     strength?: Node,
     center?: Node | Vector2 | null,
     scale?: Node,
-) => ShaderNodeObject<ChromaticAberrationNode>;
+) => ChromaticAberrationNode;

three/examples/jsm/tsl/display/DenoiseNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Camera, Node, TempNode, UniformNode } from "three/webgpu";
 
 declare class DenoiseNode extends TempNode {
@@ -24,4 +23,4 @@ export const denoise: (
     depthNode: Node,
     normalNode: Node,
     camera: Camera,
-) => ShaderNodeObject<DenoiseNode>;
+) => DenoiseNode;

three/examples/jsm/tsl/display/DepthOfFieldNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, TextureNode } from "three/webgpu";
 
 declare class DepthOfFieldNode extends TempNode {
@@ -26,4 +25,4 @@ export const dof: (
     focusDistance?: Node | number,
     focalLength?: Node | number,
     bokehScale?: Node | number,
-) => ShaderNodeObject<DepthOfFieldNode>;
+) => DepthOfFieldNode;

three/examples/jsm/tsl/display/DotScreenNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, UniformNode, Vector2 } from "three/webgpu";
 
 declare class DotScreenNode extends TempNode {
@@ -17,4 +16,4 @@ export const dotScreen: (
     center?: Vector2,
     angle?: number,
     scale?: number,
-) => ShaderNodeObject<DotScreenNode>;
+) => DotScreenNode;

three/examples/jsm/tsl/display/FXAANode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, TextureNode } from "three/webgpu";
 
 declare class FXAANode extends TempNode {
@@ -9,4 +8,4 @@ declare class FXAANode extends TempNode {
 
 export default FXAANode;
 
-export const fxaa: (node: Node) => ShaderNodeObject<FXAANode>;
+export const fxaa: (node: Node) => FXAANode;

three/examples/jsm/tsl/display/FilmNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode } from "three/webgpu";
 
 declare class FilmNode extends TempNode {
@@ -15,4 +14,4 @@ export const film: (
     inputNode: Node,
     intensityNode?: Node | null,
     uvNode?: Node | null,
-) => ShaderNodeObject<FilmNode>;
+) => FilmNode;

three/examples/jsm/tsl/display/GTAONode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Camera, Node, TempNode, TextureNode, UniformNode, Vector2 } from "three/webgpu";
 
 declare class GTAONode extends TempNode {
@@ -7,17 +6,19 @@ declare class GTAONode extends TempNode {
 
     resolutionScale: number;
 
-    radius: ShaderNodeObject<UniformNode<number>>;
-    resolution: ShaderNodeObject<UniformNode<Vector2>>;
-    thickness: ShaderNodeObject<UniformNode<number>>;
-    distanceExponent: ShaderNodeObject<UniformNode<number>>;
-    distanceFallOff: ShaderNodeObject<UniformNode<number>>;
-    scale: ShaderNodeObject<UniformNode<number>>;
-    samples: ShaderNodeObject<UniformNode<number>>;
+    radius: UniformNode<number>;
+    resolution: UniformNode<Vector2>;
+    thickness: UniformNode<number>;
+    distanceExponent: UniformNode<number>;
+    distanceFallOff: UniformNode<number>;
+    scale: UniformNode<number>;
+    samples: UniformNode<number>;
+
+    useTemporalFiltering: boolean;
 
     constructor(depthNode: Node, normalNode: Node, camera: Camera);
 
-    getTextureNode(): ShaderNodeObject<TextureNode>;
+    getTextureNode(): TextureNode;
 
     setSize(width: number, height: number): void;
 }
@@ -28,4 +29,4 @@ export const ao: (
     depthNode: Node,
     normalNode: Node,
     camera: Camera,
-) => ShaderNodeObject<GTAONode>;
+) => GTAONode;

three/examples/jsm/tsl/display/GaussianBlurNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, TextureNode, Vector2 } from "three/webgpu";
 
 export interface GaussianBlurNodeOptions {
@@ -43,7 +42,7 @@ export const gaussianBlur: (
     directionNode?: Node | number | null,
     sigma?: number,
     options?: GaussianBlurNodeOptions,
-) => ShaderNodeObject<GaussianBlurNode>;
+) => GaussianBlurNode;
 
 /**
  * @deprecated "premultipliedGaussianBlur()" is deprecated. Use "gaussianBlur()" with "premultipliedAlpha: true" option instead.
@@ -52,4 +51,4 @@ export const premultipliedGaussianBlur: (
     node: Node,
     directionNode?: Node | number | null,
     sigma?: number,
-) => ShaderNodeObject<GaussianBlurNode>;
+) => GaussianBlurNode;

three/examples/jsm/tsl/display/LensflareNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, TextureNode, UniformNode, Vector3 } from "three/webgpu";
 
 interface LensflareNodeParams {
@@ -13,11 +12,11 @@ interface LensflareNodeParams {
 declare class LensflareNode extends TempNode {
     textureNode: TextureNode;
 
-    ghostTintNode: ShaderNodeObject<UniformNode<Vector3>>;
-    thresholdNode: ShaderNodeObject<UniformNode<number>>;
-    ghostSamplesNode: ShaderNodeObject<UniformNode<number>>;
-    ghostSpacingNode: ShaderNodeObject<UniformNode<number>>;
-    ghostAttenuationFactorNode: ShaderNodeObject<UniformNode<number>>;
+    ghostTintNode: UniformNode<Vector3>;
+    thresholdNode: UniformNode<number>;
+    ghostSamplesNode: UniformNode<number>;
+    ghostSpacingNode: UniformNode<number>;
+    ghostAttenuationFactorNode: UniformNode<number>;
     downSampleRatio: number;
 
     constructor(textureNode: TextureNode, params?: LensflareNodeParams);
@@ -32,4 +31,4 @@ export default LensflareNode;
 export const lensflare: (
     inputNode: Node,
     params?: LensflareNodeParams,
-) => ShaderNodeObject<LensflareNode>;
+) => LensflareNode;

three/examples/jsm/tsl/display/Lut3DNode.d.ts

@@ -1,10 +1,9 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Data3DTexture, Node, TempNode, Texture3DNode, UniformNode } from "three/webgpu";
 
 declare class Lut3DNode extends TempNode {
     inputNode: Node;
     lutNode: Texture3DNode;
-    size: ShaderNodeObject<UniformNode<number>>;
+    size: UniformNode<number>;
     intensityNode: UniformNode<number>;
 
     constructor(inputNode: Node, lutNode: UniformNode<Data3DTexture>, size: number, intensityNode: UniformNode<number>);
@@ -17,4 +16,4 @@ export const lut3D: (
     lut: Node,
     size: number,
     intensity: Node,
-) => ShaderNodeObject<Lut3DNode>;
+) => Lut3DNode;

three/examples/jsm/tsl/display/MotionBlur.d.ts

@@ -1,8 +1,7 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node } from "three/webgpu";
 
 export const motionBlur: (
     inputNode: Node,
     velocity: Node,
     numSamples?: Node,
-) => ShaderNodeObject<Node>;
+) => Node;

three/examples/jsm/tsl/display/OutlineNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Camera, Node, Object3D, Scene, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 export interface OutlineNodeParams {
@@ -12,21 +11,21 @@ declare class OutlineNode extends TempNode {
     scene: Scene;
     camera: Camera;
     selectedObjects: Object3D[];
-    edgeThicknessNode: ShaderNodeObject<UniformNode<number>>;
-    edgeGlowNode: ShaderNodeObject<UniformNode<number>>;
+    edgeThicknessNode: UniformNode<number>;
+    edgeGlowNode: UniformNode<number>;
     downSampleRatio: number;
 
     constructor(scene: Scene, camera: Camera, params?: OutlineNodeParams);
 
-    get visibleEdge(): ShaderNodeObject<Node>;
+    get visibleEdge(): Node;
 
-    get hiddenEdge(): ShaderNodeObject<Node>;
+    get hiddenEdge(): Node;
 
-    getTextureNode(): ShaderNodeObject<TextureNode>;
+    getTextureNode(): TextureNode;
 
     setSize(width: number, height: number): void;
 }
 
 export default OutlineNode;
 
-export const outline: (scene: Scene, camera: Camera, params?: OutlineNodeParams) => ShaderNodeObject<OutlineNode>;
+export const outline: (scene: Scene, camera: Camera, params?: OutlineNodeParams) => OutlineNode;

three/examples/jsm/tsl/display/ParallaxBarrierPassNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Camera, Scene } from "three/webgpu";
 import StereoCompositePassNode from "./StereoCompositePassNode.js";
 
@@ -10,4 +9,4 @@ declare class ParallaxBarrierPassNode extends StereoCompositePassNode {
 
 export default ParallaxBarrierPassNode;
 
-export const parallaxBarrierPass: (scene: Scene, camera: Camera) => ShaderNodeObject<ParallaxBarrierPassNode>;
+export const parallaxBarrierPass: (scene: Scene, camera: Camera) => ParallaxBarrierPassNode;

three/examples/jsm/tsl/display/PixelationPassNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Camera, PassNode, Scene, UniformNode } from "three/webgpu";
 
 declare class PixelationPassNode extends PassNode {
@@ -23,6 +22,6 @@ export const pixelationPass: (
     pixelSize: UniformNode<number>,
     normalEdgeStrength: UniformNode<number>,
     depthEdgeStrength: UniformNode<number>,
-) => ShaderNodeObject<PixelationPassNode>;
+) => PixelationPassNode;
 
 export default PixelationPassNode;

three/examples/jsm/tsl/display/RGBShiftNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 export default class RGBShiftNode extends TempNode {
@@ -13,4 +12,4 @@ export default class RGBShiftNode extends TempNode {
     setSize(width: number, height: number): void;
 }
 
-export const rgbShift: (node: Node, amount?: number, angle?: number) => ShaderNodeObject<RGBShiftNode>;
+export const rgbShift: (node: Node, amount?: number, angle?: number) => RGBShiftNode;

three/examples/jsm/tsl/display/SMAANode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, TextureNode } from "three/webgpu";
 
 declare class SMAANode extends TempNode {
@@ -15,4 +14,4 @@ declare class SMAANode extends TempNode {
     getSearchTexture(): string;
 }
 
-export const smaa: (node: Node) => ShaderNodeObject<SMAANode>;
+export const smaa: (node: Node) => SMAANode;

three/examples/jsm/tsl/display/SSAAPassNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Camera, Color, PassNode, RenderTarget, Scene, UniformNode } from "three/webgpu";
 
 declare class SSAAPassNode extends PassNode {
@@ -18,4 +17,4 @@ declare class SSAAPassNode extends PassNode {
 
 export default SSAAPassNode;
 
-export const ssaaPass: (scene: Scene, camera: Camera) => ShaderNodeObject<SSAAPassNode>;
+export const ssaaPass: (scene: Scene, camera: Camera) => SSAAPassNode;

three/examples/jsm/tsl/display/SSGINode.d.ts

@@ -0,0 +1,30 @@
+import { Node, PerspectiveCamera, TempNode, UniformNode } from "three/webgpu";
+
+declare class SSGINode extends TempNode {
+    beautyNode: Node;
+    depthNode: Node;
+    normalNode: Node;
+
+    sliceCount: UniformNode<number>;
+    stepCount: UniformNode<number>;
+    aoIntensity: UniformNode<number>;
+    giIntensity: UniformNode<number>;
+    radius: UniformNode<number>;
+    useScreenSpaceSampling: UniformNode<boolean>;
+    expFactor: UniformNode<number>;
+    thickness: UniformNode<number>;
+    useLinearThickness: UniformNode<boolean>;
+    backfaceLighting: UniformNode<number>;
+    useTemporalFiltering: boolean;
+
+    constructor(beautyNode: Node, depthNode: Node, normalNode: Node, camera: PerspectiveCamera);
+}
+
+export default SSGINode;
+
+export const ssgi: (
+    beautyNode: Node,
+    depthNode: Node,
+    normalNode: Node,
+    camera: PerspectiveCamera,
+) => SSGINode;

three/examples/jsm/tsl/display/SSRNode.d.ts

@@ -1,12 +1,11 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Camera, Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 declare class SSRNode extends TempNode {
-    colorNode: ShaderNodeObject<Node>;
-    depthNode: ShaderNodeObject<Node>;
-    normalNode: ShaderNodeObject<Node>;
-    metalnessNode: ShaderNodeObject<Node>;
-    roughnessNode: ShaderNodeObject<Node> | null;
+    colorNode: Node;
+    depthNode: Node;
+    normalNode: Node;
+    metalnessNode: Node;
+    roughnessNode: Node | null;
     camera: Camera | null;
 
     resolutionScale: number;
@@ -18,15 +17,15 @@ declare class SSRNode extends TempNode {
     blurQuality: UniformNode<number>;
 
     constructor(
-        colorNode: ShaderNodeObject<Node>,
-        depthNode: ShaderNodeObject<Node>,
-        normalNode: ShaderNodeObject<Node>,
-        metalnessNode: ShaderNodeObject<Node>,
-        roughnessNode?: ShaderNodeObject<Node> | null,
+        colorNode: Node,
+        depthNode: Node,
+        normalNode: Node,
+        metalnessNode: Node,
+        roughnessNode?: Node | null,
         camera?: Camera | null,
     );
 
-    getTextureNode(): ShaderNodeObject<TextureNode>;
+    getTextureNode(): TextureNode;
 
     setSize(width: number, height: number): void;
 }
@@ -40,4 +39,4 @@ export const ssr: (
     metalnessNode: Node,
     roughnessNode?: Node | null,
     camera?: Camera | null,
-) => ShaderNodeObject<SSRNode>;
+) => SSRNode;

three/examples/jsm/tsl/display/SSSNode.d.ts

@@ -0,0 +1,20 @@
+import { Camera, DirectionalLight, TempNode, TextureNode, UniformNode } from "three/webgpu";
+
+declare class SSSNode extends TempNode {
+    depthNode: TextureNode;
+
+    maxDistance: UniformNode<number>;
+    thickness: UniformNode<number>;
+    shadowIntensity: UniformNode<number>;
+    quality: UniformNode<number>;
+    resolutionScale: number;
+    useTemporalFiltering: boolean;
+
+    constructor(depthNode: TextureNode, camera: Camera, mainLight: DirectionalLight);
+
+    getTextureNode(): TextureNode;
+}
+
+export default SSSNode;
+
+export const sss: (depthNode: TextureNode, camera: Camera, mainLight: DirectionalLight) => SSSNode;

three/examples/jsm/tsl/display/Sepia.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node } from "three/webgpu";
 
-export const sepia: (color: Node) => ShaderNodeObject<Node>;
+export const sepia: (color: Node) => Node;

three/examples/jsm/tsl/display/SobelOperatorNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, TextureNode } from "three/webgpu";
 
 declare class SobelOperatorNode extends TempNode {
@@ -9,4 +8,4 @@ declare class SobelOperatorNode extends TempNode {
 
 export default SobelOperatorNode;
 
-export const sobel: (node: Node) => ShaderNodeObject<SobelOperatorNode>;
+export const sobel: (node: Node) => SobelOperatorNode;

three/examples/jsm/tsl/display/StereoPassNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Camera, PassNode, Scene, StereoCamera } from "three/webgpu";
 
 declare class StereoPassNode extends PassNode {
@@ -11,4 +10,4 @@ declare class StereoPassNode extends PassNode {
 
 export default StereoPassNode;
 
-export const stereoPass: (scene: Scene, camera: Camera) => ShaderNodeObject<StereoPassNode>;
+export const stereoPass: (scene: Scene, camera: Camera) => StereoPassNode;

three/examples/jsm/tsl/display/TRAANode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Camera, Node, TempNode, TextureNode } from "three/webgpu";
 
 declare class TRAANode extends TempNode {
@@ -9,6 +8,11 @@ declare class TRAANode extends TempNode {
     velocityNode: TextureNode;
     camera: Camera;
 
+    depthThreshold: number;
+    edgeDepthDiff: number;
+    maxVelocityLength: number;
+    useSubpixelCorrection: boolean;
+
     constructor(beautyNode: TextureNode, depthNode: TextureNode, velocityNode: TextureNode, camera: Camera);
 }
 
@@ -19,4 +23,4 @@ export const traa: (
     depthNode: TextureNode,
     velocityNode: TextureNode,
     camera: Camera,
-) => ShaderNodeObject<TRAANode>;
+) => TRAANode;

three/examples/jsm/tsl/display/TransitionNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 declare class TransitionNode extends TempNode {
@@ -29,4 +28,4 @@ export const transition: (
     mixRatio: UniformNode<number>,
     threshold: UniformNode<number>,
     useTexture: UniformNode<number>,
-) => ShaderNodeObject<TransitionNode>;
+) => TransitionNode;

three/examples/jsm/tsl/display/boxBlur.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node } from "three/webgpu";
 
 export interface BoxBlurOptions {
@@ -8,4 +7,4 @@ export interface BoxBlurOptions {
     premultipliedAlpha?: boolean | undefined;
 }
 
-export const boxBlur: (textureNode: Node, options?: BoxBlurOptions) => ShaderNodeObject<Node>;
+export const boxBlur: (textureNode: Node, options?: BoxBlurOptions) => Node;

three/examples/jsm/tsl/display/hashBlur.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node } from "three/webgpu";
 
 interface HashBlurOptions {
@@ -11,4 +10,4 @@ export const hashBlur: (
     textureNode: Node,
     bluramount?: Node | number,
     options?: HashBlurOptions,
-) => ShaderNodeObject<Node>;
+) => Node;

three/examples/jsm/tsl/display/radialBlur.d.ts

@@ -0,0 +1,12 @@
+import { Node } from "three/webgpu";
+
+export interface RadialBlurOptions {
+    center?: Node | undefined;
+    weight?: Node | undefined;
+    decay?: Node | undefined;
+    count?: Node | undefined;
+    exposure?: Node | undefined;
+    premultipliedAlpha?: boolean | undefined;
+}
+
+export const radialBlur: (textureNode: Node, options?: RadialBlurOptions) => Node;

three/examples/jsm/tsl/lighting/TiledLightsNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { LightsNode, Node } from "three/webgpu";
 
 export const circleIntersectsAABB: (
@@ -6,18 +5,18 @@ export const circleIntersectsAABB: (
     radius: Node,
     minBounds: Node,
     maxBounds: Node,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 declare class TiledLightsNode extends LightsNode {
     constructor(maxLights?: number, tileSize?: number);
 
     updateLightsTexture(): void;
 
-    getBlock(block?: number): ShaderNodeObject<Node>;
+    getBlock(block?: number): Node;
 
     setSize(width: number, height: number): this;
 }
 
 export default TiledLightsNode;
 
-export const tiledLights: (maxLights?: number, tileSize?: number) => ShaderNodeObject<TiledLightsNode>;
+export const tiledLights: (maxLights?: number, tileSize?: number) => TiledLightsNode;

three/examples/jsm/tsl/math/Bayer.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node } from "three/webgpu";
 
-export const bayer16: (uv: Node) => ShaderNodeObject<Node>;
+export const bayer16: (uv: Node) => Node;

three/examples/jsm/tsl/utils/Raymarching.d.ts

@@ -1,9 +1,8 @@
-import { ShaderNodeObject } from "three/tsl";
 import { FunctionNode, Node } from "three/webgpu";
 
 export const RaymarchingBox: (
     steps: number | Node,
     callback:
-        | ((params: { positionRay: ShaderNodeObject<Node> }) => void)
-        | FunctionNode<{ positionRay: ShaderNodeObject<Node> }>,
+        | ((params: { positionRay: Node }) => void)
+        | FunctionNode<{ positionRay: Node }>,
 ) => void;