@types/three 0.182.0 → 0.183.1

three/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for three (https://threejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three.
 
 ### Additional Details
- * Last updated: Wed, 10 Dec 2025 22:36:27 GMT
+ * Last updated: Fri, 20 Feb 2026 17:44:37 GMT
  * Dependencies: [@dimforge/rapier3d-compat](https://npmjs.com/package/@dimforge/rapier3d-compat), [@tweenjs/tween.js](https://npmjs.com/package/@tweenjs/tween.js), [@types/stats.js](https://npmjs.com/package/@types/stats.js), [@types/webxr](https://npmjs.com/package/@types/webxr), [@webgpu/types](https://npmjs.com/package/@webgpu/types), [fflate](https://npmjs.com/package/fflate), [meshoptimizer](https://npmjs.com/package/meshoptimizer)
 
 # Credits

three/examples/jsm/Addons.d.ts

@@ -123,8 +123,6 @@ export * from "./loaders/VTKLoader.js";
 export * from "./loaders/XYZLoader.js";
 
 export * from "./materials/LDrawConditionalLineMaterial.js";
-export * from "./materials/MeshGouraudMaterial.js";
-export * from "./materials/MeshPostProcessingMaterial.js";
 
 export * from "./math/Capsule.js";
 export * from "./math/ColorConverter.js";
@@ -225,7 +223,6 @@ export * from "./shaders/FocusShader.js";
 export * from "./shaders/FreiChenShader.js";
 export * from "./shaders/FXAAShader.js";
 export * from "./shaders/GammaCorrectionShader.js";
-export * from "./shaders/GodRaysShader.js";
 export * from "./shaders/GTAOShader.js";
 export * from "./shaders/HalftoneShader.js";
 export * from "./shaders/HorizontalBlurShader.js";

three/examples/jsm/controls/OrbitControls.d.ts

@@ -208,6 +208,9 @@ declare class OrbitControls extends Controls<OrbitControlsEventMap> {
      */
     constructor(object: Camera, domElement?: HTMLElement | SVGElement | null);
 
+    set cursorStyle(type: "auto" | "grab");
+    get cursorStyle(): "auto" | "grab";
+
     /**
      * Get the current vertical rotation, in radians.
      */
@@ -245,6 +248,42 @@ declare class OrbitControls extends Controls<OrbitControlsEventMap> {
      */
     reset(): void;
 
+    /**
+     * Programmatically pan the camera.
+     *
+     * @param {number} deltaX - The horizontal pan amount in pixels.
+     * @param {number} deltaY - The vertical pan amount in pixels.
+     */
+    pan(deltaX: number, deltaY: number): void;
+
+    /**
+     * Programmatically dolly in (zoom in for perspective camera).
+     *
+     * @param {number} dollyScale - The dolly scale factor.
+     */
+    dollyIn(dollyScale: number): void;
+
+    /**
+     * Programmatically dolly out (zoom out for perspective camera).
+     *
+     * @param {number} dollyScale - The dolly scale factor.
+     */
+    dollyOut(dollyScale: number): void;
+
+    /**
+     * Programmatically rotate the camera left (around the vertical axis).
+     *
+     * @param {number} angle - The rotation angle in radians.
+     */
+    rotateLeft(angle: number): void;
+
+    /**
+     * Programmatically rotate the camera up (around the horizontal axis).
+     *
+     * @param {number} angle - The rotation angle in radians.
+     */
+    rotateUp(angle: number): void;
+
     /**
      * Update the controls. Must be called after any manual changes to the camera's transform, or in the update loop if
      * {@link .autoRotate} or {@link .enableDamping} are set. `deltaTime`, in seconds, is optional, and is only required

three/examples/jsm/effects/AnaglyphEffect.d.ts

@@ -5,6 +5,10 @@ declare class AnaglyphEffect {
 
     colorMatrixRight: Matrix3;
 
+    eyeSep: number;
+
+    planeDistance: number;
+
     setSize: (width: number, height: number) => void;
 
     render: (scene: Scene, camera: Camera) => void;

three/examples/jsm/environments/ColorEnvironment.d.ts

@@ -0,0 +1,9 @@
+import { ColorRepresentation, Scene } from "three";
+
+declare class ColorEnvironment extends Scene {
+    constructor(color?: ColorRepresentation);
+
+    dispose(): void;
+}
+
+export { ColorEnvironment };

three/examples/jsm/gpgpu/BitonicSort.d.ts

@@ -1,20 +1,20 @@
 import { Node, Renderer, StorageBufferNode } from "three/webgpu";
 
-export const getBitonicFlipIndices: (index: Node, blockHeight: Node) => Node;
+export const getBitonicFlipIndices: (index: Node, blockHeight: Node) => Node<"uvec2">;
 
-export const getBitonicDisperseIndices: (index: Node, swapSpan: Node) => Node;
+export const getBitonicDisperseIndices: (index: Node, swapSpan: Node) => Node<"uvec2">;
 
 export interface BitonicSortOptions {
     workgroupSize?: number | undefined;
 }
 
-export class BitonicSort {
-    infoStorage: StorageBufferNode;
+export class BitonicSort<TNodeType> {
+    infoStorage: StorageBufferNode<TNodeType>;
 
     swapOpCount: number;
     stepCount: number;
 
-    constructor(renderer: Renderer, dataBuffer: StorageBufferNode, options?: BitonicSortOptions);
+    constructor(renderer: Renderer, dataBuffer: StorageBufferNode<TNodeType>, options?: BitonicSortOptions);
 
     computeStep(renderer: Renderer): Promise<void>;
     compute(renderer: Renderer): Promise<void>;

three/examples/jsm/helpers/AnimationPathHelper.d.ts

@@ -0,0 +1,38 @@
+import {
+    AnimationClip,
+    BufferGeometry,
+    ColorRepresentation,
+    Line,
+    LineBasicMaterial,
+    Object3D,
+    Points,
+    PointsMaterial,
+} from "three";
+
+export interface AnimationPathHelperOptions {
+    color?: ColorRepresentation | undefined;
+    markerColor?: ColorRepresentation | undefined;
+    divisions?: number | undefined;
+    showMarkers?: boolean | undefined;
+    markerSize?: number | undefined;
+}
+
+declare class AnimationPathHelper extends Object3D {
+    readonly isAnimationPathHelper: boolean;
+
+    root: Object3D;
+    clip: AnimationClip;
+    object: Object3D;
+    divisions: number;
+
+    line: Line<BufferGeometry, LineBasicMaterial>;
+    points: Points<BufferGeometry, PointsMaterial> | null;
+
+    constructor(root: Object3D, clip: AnimationClip, object: Object3D, options?: AnimationPathHelperOptions);
+
+    setColor(color: ColorRepresentation): void;
+    setMarkerColor(color: ColorRepresentation): void;
+    dispose(): void;
+}
+
+export { AnimationPathHelper };

three/examples/jsm/helpers/ViewHelper.d.ts

@@ -1,10 +1,11 @@
 import { Camera, Object3D, Vector3, WebGLRenderer } from "three";
 
-export class ViewHelper extends Object3D {
+declare class ViewHelper extends Object3D {
     readonly isViewHelper: true;
 
     animating: boolean;
     center: Vector3;
+    location: { top: number | null; right: number; bottom: number; left: number | null };
 
     render: (renderer: WebGLRenderer) => void;
     handleClick: (event: MouseEvent) => boolean;
@@ -15,3 +16,5 @@ export class ViewHelper extends Object3D {
 
     constructor(camera: Camera, domElement: HTMLElement);
 }
+
+export { ViewHelper };

three/examples/jsm/inspector/tabs/Parameters.d.ts

@@ -1,3 +1,4 @@
+import { Item } from "../ui/Item.js";
 import { Tab } from "../ui/Tab.js";
 import { ValueButton, ValueCheckbox, ValueColor, ValueNumber, ValueSelect, ValueSlider } from "../ui/Values.js";
 
@@ -52,6 +53,8 @@ interface ValueColorWithParameters<
 declare class ParametersGroup {
     name: string;
 
+    paramList: Item;
+
     constructor(parameters: never, name: string);
 
     add<T, K extends keyof T>(

three/examples/jsm/inspector/ui/Item.d.ts

@@ -0,0 +1,5 @@
+export class Item {
+    domElement: HTMLDivElement;
+
+    constructor(...data: readonly unknown[]);
+}

three/examples/jsm/libs/meshopt_decoder.module.d.ts

@@ -1 +1 @@
-export * from "meshoptimizer/meshopt_decoder.module.js";
+export * from "meshoptimizer/decoder";

three/examples/jsm/lights/LightProbeGenerator.d.ts

@@ -1,10 +1,16 @@
 import { CubeTexture, LightProbe, WebGLCubeRenderTarget, WebGLRenderer } from "three";
-import { WebGPURenderer } from "three/webgpu";
+import { CubeRenderTarget, WebGPURenderer } from "three/webgpu";
 
-export namespace LightProbeGenerator {
-    function fromCubeTexture(cubeTexture: CubeTexture): LightProbe;
-    function fromCubeRenderTarget(
-        renderer: WebGLRenderer | WebGPURenderer,
+declare class LightProbeGenerator {
+    static fromCubeTexture(cubeTexture: CubeTexture): LightProbe;
+    static fromCubeRenderTarget(
+        renderer: WebGLRenderer,
         cubeRenderTarget: WebGLCubeRenderTarget,
     ): Promise<LightProbe>;
+    static fromCubeRenderTarget(
+        renderer: WebGPURenderer,
+        cubeRenderTarget: CubeRenderTarget,
+    ): Promise<LightProbe>;
 }
+
+export { LightProbeGenerator };

three/examples/jsm/loaders/ColladaLoader.d.ts

@@ -1,11 +1,34 @@
 import { Loader, Scene } from "three";
 
+export interface ColladaKinematics {
+    joints: unknown;
+    getJointValue: unknown;
+    setJointValue: unknown;
+}
+
+export interface ColladaLibrary {
+    animations: Record<string, unknown>;
+    clips: Record<string, unknown>;
+    controllers: Record<string, unknown>;
+    images: Record<string, unknown>;
+    effects: Record<string, unknown>;
+    materials: Record<string, unknown>;
+    cameras: Record<string, unknown>;
+    lights: Record<string, unknown>;
+    geometries: Record<string, unknown>;
+    nodes: Record<string, unknown>;
+    visualScenes: Record<string, unknown>;
+    kinematicsModels: Record<string, unknown>;
+    physicsModels: Record<string, unknown>;
+    kinematicsScenes: Record<string, unknown>;
+}
+
 export interface Collada {
-    kinematics: object;
-    library: object;
+    kinematics?: ColladaKinematics;
+    library?: ColladaLibrary;
     scene: Scene;
 }
 
-export class ColladaLoader extends Loader<Collada> {
-    parse(text: string, path: string): Collada;
+export class ColladaLoader extends Loader<Collada | null> {
+    parse(text: string, path: string): Collada | null;
 }

three/examples/jsm/objects/SkyMesh.d.ts

@@ -1,12 +1,17 @@
 import { BoxGeometry, Mesh, NodeMaterial, UniformNode, Vector3 } from "three/webgpu";
 
 declare class SkyMesh extends Mesh<BoxGeometry, NodeMaterial> {
-    turbidity: UniformNode<number>;
-    rayleigh: UniformNode<number>;
-    mieCoefficient: UniformNode<number>;
-    mieDirectionalG: UniformNode<number>;
-    sunPosition: UniformNode<Vector3>;
-    upUniform: UniformNode<Vector3>;
+    turbidity: UniformNode<"float", number>;
+    rayleigh: UniformNode<"float", number>;
+    mieCoefficient: UniformNode<"float", number>;
+    mieDirectionalG: UniformNode<"float", number>;
+    sunPosition: UniformNode<"vec3", Vector3>;
+    upUniform: UniformNode<"vec3", Vector3>;
+    cloudScale: UniformNode<"float", number>;
+    cloudSpeed: UniformNode<"float", number>;
+    cloudCoverage: UniformNode<"float", number>;
+    cloudDensity: UniformNode<"float", number>;
+    cloudElevation: UniformNode<"float", number>;
 
     /**
      * @deprecated

three/examples/jsm/objects/Water2Mesh.d.ts

@@ -30,19 +30,19 @@ declare class WaterMesh extends Mesh<BufferGeometry, NodeMaterial> {
     constructor(geometry: BufferGeometry, options: WaterMeshOptions);
 }
 
-declare class WaterNode extends TempNode {
+declare class WaterNode extends TempNode<"vec4"> {
     waterBody: WaterMesh;
 
     normalMap0: TextureNode;
     normalMap1: TextureNode;
     flowMap: TextureNode;
 
-    color: UniformNode<Color>;
-    flowDirection: UniformNode<Vector2>;
-    flowSpeed: UniformNode<number>;
-    reflectivity: UniformNode<number>;
-    scale: UniformNode<number>;
-    flowConfig: UniformNode<Vector3>;
+    color: UniformNode<"color", Color>;
+    flowDirection: UniformNode<"vec2", Vector2>;
+    flowSpeed: UniformNode<"float", number>;
+    reflectivity: UniformNode<"float", number>;
+    scale: UniformNode<"float", number>;
+    flowConfig: UniformNode<"vec3", Vector3>;
 
     constructor(options: WaterMeshOptions, waterBody: WaterMesh);
 

three/examples/jsm/objects/WaterMesh.d.ts

@@ -27,12 +27,12 @@ declare class WaterMesh extends Mesh<BufferGeometry, NodeMaterial> {
     resolutionScale: number;
 
     waterNormals: TextureNode;
-    alpha: UniformNode<number>;
-    size: UniformNode<number>;
-    sunColor: UniformNode<Color>;
-    sunDirection: UniformNode<Vector3>;
-    waterColor: UniformNode<Color>;
-    distortionScale: UniformNode<number>;
+    alpha: UniformNode<"float", number>;
+    size: UniformNode<"float", number>;
+    sunColor: UniformNode<"color", Color>;
+    sunDirection: UniformNode<"vec3", Vector3>;
+    waterColor: UniformNode<"color", Color>;
+    distortionScale: UniformNode<"float", number>;
 
     constructor(geometry: BufferGeometry, options: WaterMeshOptions);
 }

three/examples/jsm/postprocessing/EffectComposer.d.ts

@@ -1,22 +1,19 @@
-import { Clock, WebGLRenderer, WebGLRenderTarget } from "three";
-
-import { FullScreenQuad, Pass } from "./Pass.js";
+import { Timer, WebGLRenderer, WebGLRenderTarget } from "three";
+import { Pass } from "./Pass.js";
 import { ShaderPass } from "./ShaderPass.js";
 
-export { FullScreenQuad } from "./Pass.js";
-export { Pass };
-
-export class EffectComposer {
-    constructor(renderer: WebGLRenderer, renderTarget?: WebGLRenderTarget);
+declare class EffectComposer {
     renderer: WebGLRenderer;
     renderTarget1: WebGLRenderTarget;
     renderTarget2: WebGLRenderTarget;
     writeBuffer: WebGLRenderTarget;
     readBuffer: WebGLRenderTarget;
+    renderToScreen: boolean;
     passes: Pass[];
     copyPass: ShaderPass;
-    clock: Clock;
-    renderToScreen: boolean;
+    timer: Timer;
+
+    constructor(renderer: WebGLRenderer, renderTarget?: WebGLRenderTarget);
 
     swapBuffers(): void;
     addPass(pass: Pass): void;
@@ -29,3 +26,5 @@ export class EffectComposer {
     setPixelRatio(pixelRatio: number): void;
     dispose(): void;
 }
+
+export { EffectComposer };

three/examples/jsm/postprocessing/UnrealBloomPass.d.ts

@@ -3,12 +3,13 @@ import { Color, MeshBasicMaterial, ShaderMaterial, Vector2, Vector3, WebGLRender
 import { FullScreenQuad, Pass } from "./Pass.js";
 
 export class UnrealBloomPass extends Pass {
-    constructor(resolution: Vector2, strength: number, radius: number, threshold: number);
-    resolution: Vector2;
     strength: number;
     radius: number;
     threshold: number;
+    resolution: Vector2;
     clearColor: Color;
+    needsUpdate: boolean;
+
     renderTargetsHorizontal: WebGLRenderTarget[];
     renderTargetsVertical: WebGLRenderTarget[];
     nMips: number;
@@ -20,12 +21,6 @@ export class UnrealBloomPass extends Pass {
     bloomTintColors: Vector3[];
     copyUniforms: object;
     blendMaterial: ShaderMaterial;
-    oldClearColor: Color;
-    oldClearAlpha: number;
-    basic: MeshBasicMaterial;
-    fsQuad: FullScreenQuad;
 
-    dispose(): void;
-    getSeparableBlurMaterial(): ShaderMaterial;
-    getCompositeMaterial(): ShaderMaterial;
+    constructor(resolution: Vector2, strength: number, radius: number, threshold: number);
 }

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

@@ -1,12 +1,42 @@
 import { Camera, Scene } from "three/webgpu";
 import StereoCompositePassNode from "./StereoCompositePassNode.js";
 
+declare const AnaglyphAlgorithm: {
+    TRUE: "true";
+    GREY: "grey";
+    COLOUR: "colour";
+    HALF_COLOUR: "halfColour";
+    DUBOIS: "dubois";
+    OPTIMISED: "optimised";
+    COMPROMISE: "compromise";
+};
+type AnaglyphAlgorithm = (typeof AnaglyphAlgorithm)[keyof typeof AnaglyphAlgorithm];
+
+declare const AnaglyphColorMode: {
+    RED_CYAN: "redCyan";
+    MAGENTA_CYAN: "magentaCyan";
+    MAGENTA_GREEN: "magentaGreen";
+};
+type AnaglyphColorMode = (typeof AnaglyphColorMode)[keyof typeof AnaglyphColorMode];
+
 declare class AnaglyphPassNode extends StereoCompositePassNode {
     readonly isAnaglyphPassNode: true;
 
+    eyeSep: number;
+
+    planeDistance: number;
+
     constructor(scene: Scene, camera: Camera);
+
+    get algorithm(): AnaglyphAlgorithm;
+    set algorithm(algorithm: AnaglyphAlgorithm);
+
+    get colorMode(): AnaglyphColorMode;
+    set colorMode(color: AnaglyphColorMode);
 }
 
 export default AnaglyphPassNode;
 
+export { AnaglyphAlgorithm, AnaglyphColorMode };
+
 export const anaglyphPass: (scene: Scene, camera: Camera) => AnaglyphPassNode;

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

@@ -1,6 +1,6 @@
 import { Node, TempNode, Vector2 } from "three/webgpu";
 
-export default class AnamorphicNode extends TempNode {
+export default class AnamorphicNode extends TempNode<"vec4"> {
     textureNode: Node;
     thresholdNode: Node;
     scaleNode: Node;

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

@@ -0,0 +1,27 @@
+import { Node, TempNode, TextureNode } from "three/webgpu";
+
+declare class BilateralBlurNode extends TempNode<"vec4"> {
+    textureNode: TextureNode;
+    directionNode: Node<"vec2"> | Node<"float"> | null;
+    sigma: number;
+    sigmaColor: number;
+
+    constructor(
+        textureNode: TextureNode,
+        directionNode?: Node<"vec2"> | Node<"float"> | null,
+        sigma?: number,
+        sigmaColor?: number,
+    );
+
+    setSize(width: number, height: number): void;
+    getTextureNode(): TextureNode;
+}
+
+export default BilateralBlurNode;
+
+export const bilateralBlur: (
+    node: Node<"vec4">,
+    directionNode?: Node<"vec2"> | Node<"float">,
+    sigma?: number,
+    sigmaColor?: number,
+) => BilateralBlurNode;

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

@@ -1,12 +1,12 @@
 import { Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
-declare class BloomNode extends TempNode {
+declare class BloomNode extends TempNode<"vec4"> {
     inputNode: Node;
-    strength: UniformNode<number>;
-    radius: UniformNode<number>;
-    threshold: UniformNode<number>;
+    strength: UniformNode<"float", number>;
+    radius: UniformNode<"float", number>;
+    threshold: UniformNode<"float", number>;
 
-    smoothWidth: UniformNode<number>;
+    smoothWidth: UniformNode<"float", number>;
 
     constructor(inputNode: Node, strength?: number, radius?: number, threshold?: number);
 

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

@@ -0,0 +1,22 @@
+import { Node } from "three/webgpu";
+
+export const barrelUV: (curvature?: Node<"float">, coord?: Node<"vec2">) => Node<"vec2">;
+
+export const barrelMast: (coord: Node<"vec2">) => Node<"float">;
+
+export const colorBleeding: (color: Node, amount?: Node<"float">) => Node<"vec3">;
+
+export const scanlines: (
+    color: Node<"vec3">,
+    intensity?: Node<"float">,
+    count?: Node<"float">,
+    speed?: Node<"float">,
+    coord?: Node<"vec2">,
+) => Node<"vec3">;
+
+export const vignette: (
+    color: Node<"vec3">,
+    intensity?: Node<"float">,
+    smoothness?: Node<"float"> | number,
+    coord?: Node<"vec2">,
+) => Node<"vec3">;

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

@@ -7,11 +7,11 @@ declare class DenoiseNode extends TempNode {
 
     noiseNode: Node;
 
-    lumaPhi: UniformNode<number>;
-    depthPhi: UniformNode<number>;
-    normalPhi: UniformNode<number>;
-    radius: UniformNode<number>;
-    index: UniformNode<number>;
+    lumaPhi: UniformNode<"float", number>;
+    depthPhi: UniformNode<"float", number>;
+    normalPhi: UniformNode<"float", number>;
+    radius: UniformNode<"float", number>;
+    index: UniformNode<"float", number>;
 
     constructor(textureNode: Node, depthNode: Node, normalNode: Node, noiseNode: Node, camera: Camera);
 }

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

@@ -1,19 +1,17 @@
-import { Node, TempNode, UniformNode, Vector2 } from "three/webgpu";
+import { Node, TempNode, UniformNode } from "three/webgpu";
 
 declare class DotScreenNode extends TempNode {
     inputNode: Node;
-    center: UniformNode<Vector2>;
-    angle: UniformNode<number>;
-    scale: UniformNode<number>;
+    angle: UniformNode<"float", number>;
+    scale: UniformNode<"float", number>;
 
-    constructor(inputNode: Node, center?: Vector2, angle?: number, scale?: number);
+    constructor(inputNode: Node, angle?: number, scale?: number);
 }
 
 export default DotScreenNode;
 
 export const dotScreen: (
     node: Node,
-    center?: Vector2,
     angle?: number,
     scale?: number,
 ) => DotScreenNode;

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

@@ -1,18 +1,18 @@
 import { Camera, Node, TempNode, TextureNode, UniformNode, Vector2 } from "three/webgpu";
 
-declare class GTAONode extends TempNode {
+declare class GTAONode extends TempNode<"float"> {
     depthNode: Node;
     normalNode: Node;
 
     resolutionScale: number;
 
-    radius: UniformNode<number>;
-    resolution: UniformNode<Vector2>;
-    thickness: UniformNode<number>;
-    distanceExponent: UniformNode<number>;
-    distanceFallOff: UniformNode<number>;
-    scale: UniformNode<number>;
-    samples: UniformNode<number>;
+    radius: UniformNode<"float", number>;
+    resolution: UniformNode<"vec2", Vector2>;
+    thickness: UniformNode<"float", number>;
+    distanceExponent: UniformNode<"float", number>;
+    distanceFallOff: UniformNode<"float", number>;
+    scale: UniformNode<"float", number>;
+    samples: UniformNode<"float", number>;
 
     useTemporalFiltering: boolean;
 

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

@@ -2,10 +2,10 @@ import { Node, TempNode, TextureNode, Vector2 } from "three/webgpu";
 
 export interface GaussianBlurNodeOptions {
     premultipliedAlpha?: boolean | undefined;
-    resolution?: Vector2 | undefined;
+    resolutionScale?: number | undefined;
 }
 
-declare class GaussianBlurNode extends TempNode {
+declare class GaussianBlurNode extends TempNode<"vec4"> {
     textureNode: TextureNode;
     directionNode: Node | null;
     sigma: number;
@@ -14,6 +14,8 @@ declare class GaussianBlurNode extends TempNode {
 
     premultipliedAlpha: boolean;
 
+    readonly isGaussianBlurNode: boolean;
+
     constructor(
         textureNode: TextureNode,
         directionNode?: Node | null,

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

@@ -0,0 +1,20 @@
+import { Camera, DirectionalLight, PointLight, TempNode, TextureNode, UniformNode } from "three/webgpu";
+
+declare class GodraysNode extends TempNode<"vec4"> {
+    depthNode: TextureNode;
+
+    raymarchSteps: UniformNode<"uint", number>;
+    density: UniformNode<"float", number>;
+    maxDensity: UniformNode<"float", number>;
+    distanceAttenuation: UniformNode<"float", number>;
+    resolutionScale: number;
+
+    constructor(depthNode: TextureNode, camera: Camera, light: DirectionalLight | PointLight);
+
+    getTextureNode(): TextureNode;
+    setSize(width: number, height: number): void;
+}
+
+export default GodraysNode;
+
+export const godrays: (depthNode: TextureNode, camera: Camera, light: DirectionalLight | PointLight) => GodraysNode;