@types/three 0.184.0 → 0.185.0

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

@@ -1,4 +1,4 @@
-import { BufferGeometry, ColorRepresentation, Mesh, WebGLRenderTarget } from "three";
+import { BufferGeometry, Camera, ColorRepresentation, Mesh, WebGLRenderTarget } from "three";
 
 export interface ReflectorOptions {
     color?: ColorRepresentation | undefined;
@@ -10,12 +10,45 @@ export interface ReflectorOptions {
 }
 
 export class Reflector extends Mesh {
-    type: "Reflector";
+    /**
+     * This flag can be used for type testing.
+     *
+     * @type {boolean}
+     * @readonly
+     * @default true
+     */
+    readonly isReflector: boolean;
+
+    /**
+     * Whether to force an update, no matter if the reflector
+     * is in view or not.
+     *
+     * @type {boolean}
+     * @default false
+     */
     forceUpdate: boolean;
 
-    constructor(geometry?: BufferGeometry, options?: ReflectorOptions);
+    /**
+     * Returns the reflector's internal render target.
+     *
+     * @return {WebGLRenderTarget} The internal render target
+     */
+    getRenderTarget: () => WebGLRenderTarget;
+
+    /**
+     * Frees the GPU-related resources allocated by this instance. Call this
+     * method whenever this instance is no longer used in your app.
+     */
+    dispose: () => void;
 
-    getRenderTarget(): WebGLRenderTarget;
+    /**
+     * Returns a reflection camera for the given camera. The reflection camera is used to
+     * render the scene from the reflector's view so correct reflections can be produced.
+     *
+     * @param {Camera} camera - The scene's camera.
+     * @return {Camera} The corresponding reflection camera.
+     */
+    getReflectionCamera: (camera: Camera) => Camera;
 
-    dispose(): void;
+    constructor(geometry: BufferGeometry, options?: ReflectorOptions);
 }

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

@@ -12,7 +12,7 @@ declare class SkyMesh extends Mesh<BoxGeometry, NodeMaterial> {
     cloudCoverage: UniformNode<"float", number>;
     cloudDensity: UniformNode<"float", number>;
     cloudElevation: UniformNode<"float", number>;
-    showSunDisc: UniformNode<"float", number>;
+    showSunDisc: UniformNode<"float", number | boolean>;
 
     /**
      * @deprecated

three/examples/jsm/physics/RapierPhysics.d.ts

@@ -18,6 +18,7 @@ export interface RapierPhysicsObject {
         heights: Float32Array,
         scale: Vector,
     ) => RAPIER.RigidBody;
+    applyImpulse: (mesh: Mesh, impulse: Vector, index?: number) => void;
 }
 
 export function RapierPhysics(): Promise<RapierPhysicsObject>;

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

@@ -1,25 +1,42 @@
 import { Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 declare class BloomNode extends TempNode<"vec4"> {
-    inputNode: Node;
+    inputNode: Node<"vec4">;
     strength: UniformNode<"float", number>;
     radius: UniformNode<"float", number>;
     threshold: UniformNode<"float", number>;
 
     smoothWidth: UniformNode<"float", number>;
 
-    constructor(inputNode: Node, strength?: number, radius?: number, threshold?: number);
+    highPassFn: (
+        params: {
+            input: Node<"vec4">;
+            threshold: UniformNode<"float", number>;
+            smoothWidth: UniformNode<"float", number>;
+        },
+    ) => void;
+
+    constructor(
+        inputNode: Node,
+        strength?: UniformNode<"float", number> | number,
+        radius?: UniformNode<"float", number> | number,
+        threshold?: UniformNode<"float", number> | number,
+    );
 
     getTexture(): TextureNode;
 
+    setResolutionScale(resolutionScale: number): this;
+
+    getResolutionScale(): number;
+
     setSize(width: number, height: number): void;
 }
 
 export const bloom: (
-    node: Node,
-    strength?: number,
-    radius?: number,
-    threshold?: number,
+    node: Node<"vec4">,
+    strength?: UniformNode<"float", number> | number,
+    radius?: UniformNode<"float", number> | number,
+    threshold?: UniformNode<"float", number> | number,
 ) => BloomNode;
 
 export default BloomNode;

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

@@ -0,0 +1,84 @@
+import { Matrix4, Node, Texture, UniformNode } from "three/webgpu";
+
+/**
+ * Manages a preprocessed HDR environment map (CDF textures, uniforms) and exposes
+ * TSL helpers for BRDF-direction lookups and MIS importance sampling.
+ *
+ * @see {@link https://github.com/gkjohnson/three-gpu-pathtracer}
+ */
+declare class ImportanceSampledEnvironment {
+    /**
+     * @param {boolean} [importanceSampling=false] - When `true`, builds luminance CDF tables and enables MIS env sampling.
+     */
+    constructor(importanceSampling?: boolean);
+    intensity: UniformNode<"float", number>;
+    /**
+     * @param {Texture} hdr - Equirectangular HDR environment map.
+     */
+    updateFrom(hdr: Texture): void;
+    clear(): void;
+    /**
+     * Simple environment lookup along the reflected direction (no MIS).
+     *
+     * @param {Object} params
+     * @param {UniformNode<Matrix4>} params.cameraWorldMatrix
+     * @param {Node<vec3>} params.viewReflectDir
+     * @param {Node<float>} [params.sampleWeight] - Optional radiance scale (defaults to 1).
+     * @return {Node<vec3>}
+     */
+    sampleReflect(params: {
+        cameraWorldMatrix: UniformNode<"mat4", Matrix4>;
+        viewReflectDir: Node<"vec3">;
+        sampleWeight?: Node<"float">;
+    }): Node<"vec3">;
+    /**
+     * Environment reflection for a screen-space miss using only the BRDF / reflected-ray direction.
+     *
+     * @param {Object} params
+     * @param {UniformNode<Matrix4>} params.cameraWorldMatrix
+     * @param {Node<vec3>} params.viewReflectDir - View-space GGX-sampled reflected ray.
+     * @param {Node<vec3>} params.N - View-space shading normal.
+     * @param {Node<vec3>} params.V - View-space direction to camera.
+     * @param {Node<float>} params.alpha - GGX roughness (alpha).
+     * @param {Node<vec3>} params.f0
+     * @return {Node<vec3>}
+     */
+    sampleEnvironmentBRDF(params: {
+        cameraWorldMatrix: UniformNode<"mat4", Matrix4>;
+        viewReflectDir: Node<"vec3">;
+        N: Node<"vec3">;
+        V: Node<"vec3">;
+        alpha: Node<"float">;
+        f0: Node<"vec3">;
+    }): Node<"vec3">;
+    /**
+     * Environment reflection for a screen-space miss, estimated with multiple importance
+     * sampling (MIS) between the BRDF / reflected-ray direction and the env-luminance CDF
+     * direction. Both techniques use consistent solid-angle PDFs (`D·G1(N·V)/(4·N·V)`), so
+     * the power heuristic is unbiased. Adapted from three-gpu-pathtracer.
+     *
+     * @see {@link https://github.com/gkjohnson/three-gpu-pathtracer}
+     *
+     * @param {Object} params
+     * @param {UniformNode<Matrix4>} params.cameraWorldMatrix
+     * @param {Node<vec3>} params.viewReflectDir - View-space GGX-sampled reflected ray.
+     * @param {Node<vec3>} params.N - View-space shading normal.
+     * @param {Node<vec3>} params.V - View-space direction to camera.
+     * @param {Node<float>} params.alpha - GGX roughness (alpha).
+     * @param {Node<vec3>} params.f0
+     * @param {Node<vec4>} params.Xi2 - Second blue-noise sample (zw used for the CDF).
+     * @return {Node<vec3>}
+     */
+    sampleEnvironmentMIS(params: {
+        cameraWorldMatrix: UniformNode<"mat4", Matrix4>;
+        viewReflectDir: Node<"vec3">;
+        N: Node<"vec3">;
+        V: Node<"vec3">;
+        alpha: Node<"float">;
+        f0: Node<"vec3">;
+        Xi2: Node<"vec4">;
+    }): Node<"vec3">;
+    dispose(): void;
+}
+
+export default ImportanceSampledEnvironment;

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

@@ -0,0 +1,89 @@
+import { Camera, Node, RenderTarget, TempNode, TextureNode, UniformNode } from "three/webgpu";
+
+export type DenoiseMode = "diffuse" | "specular";
+
+export type DenoiseAlphaSource = "raylength" | "ao" | "none";
+
+export interface RecurrentDenoiseNodeOptions {
+    depth?: Node<"float"> | Node<"vec4"> | null | undefined;
+    normal?: Node<"vec3"> | Node<"vec4"> | null | undefined;
+    metalRoughness?: Node<"vec2"> | null | undefined;
+    diffuse?: Node<"vec4"> | null | undefined;
+    raw?: Node<"vec4"> | null | undefined;
+    mode?: DenoiseMode | undefined;
+    accumulate?: boolean | undefined;
+}
+
+/**
+ * Post processing node for denoising temporally-accumulated screen-space effects
+ * such as SSGI (ambient occlusion / indirect diffuse) and SSR (specular reflections).
+ *
+ * The denoising kernel is selected at construction time via `mode`:
+ * `'diffuse'` (SSGI) or `'specular'` (SSR). The kernel uses a fixed 8-sample Vogel disk.
+ *
+ * @augments TempNode
+ * @three_import import { recurrentDenoise } from 'three/addons/tsl/display/RecurrentDenoiseNode.js';
+ */
+declare class RecurrentDenoiseNode extends TempNode<"vec4"> {
+    readonly isRecurrentDenoiseNode: boolean;
+    camera: Camera;
+
+    /**
+     * Denoising kernel type.
+     *
+     * @type {DenoiseMode}
+     */
+    mode: DenoiseMode;
+
+    /**
+     * When `true`, apply temporal blending after spatial denoising. When `false`, output spatially
+     * filtered colour only (alpha is passed through from the input temporal pass).
+     *
+     * @type {boolean}
+     */
+    accumulate: boolean;
+
+    textureNode: Node<"vec4">;
+    depthNode: Node<"float"> | Node<"vec4"> | null;
+    normalNode: Node<"vec3"> | Node<"vec4"> | null;
+    rawNode: TextureNode | null;
+    roughnessMetalnessNode: Node<"vec2"> | null;
+    diffuseNode: Node<"vec4"> | null;
+
+    lumaPhi: UniformNode<"float", number>;
+    depthPhi: UniformNode<"float", number>;
+    normalPhi: UniformNode<"float", number>;
+    radius: UniformNode<"float", number>;
+    alphaPhi: UniformNode<"float", number>;
+    roughnessPhi: UniformNode<"float", number>;
+    diffusePhi: UniformNode<"float", number>;
+    adapt: UniformNode<"float", number>;
+    smoothDisocclusions: UniformNode<"bool", boolean>;
+    strength: UniformNode<"float", number>;
+    maxFrames: UniformNode<"float", number>;
+
+    /**
+     * Which channel of the raw texture drives alpha-based edge stopping.
+     * `'raylength'` — alpha encodes SSR ray length; `'ao'` — alpha encodes AO factor;
+     * `'none'` — skip alpha-based edge stopping.
+     *
+     * @type {DenoiseAlphaSource}
+     * @default 'raylength'
+     */
+    alphaSource: DenoiseAlphaSource;
+
+    flickerSuppression: UniformNode<"float", number>;
+    adaptiveTrust: UniformNode<"float", number>;
+
+    constructor(inputTexture: Node<"vec4">, camera: Camera, options?: RecurrentDenoiseNodeOptions);
+
+    getRenderTarget(): RenderTarget;
+}
+
+export default RecurrentDenoiseNode;
+
+export const recurrentDenoise: (
+    inputTexture: Node<"vec4">,
+    camera: Camera,
+    options?: RecurrentDenoiseNodeOptions,
+) => RecurrentDenoiseNode;

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

@@ -5,8 +5,6 @@ declare class SSAAPassNode extends PassNode {
 
     sampleLevel: number;
     unbiased: boolean;
-    clearColor: Color;
-    clearAlpha: number;
 
     sampleWeight: UniformNode<"float", number>;
 

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

@@ -1,4 +1,4 @@
-import { Node, PerspectiveCamera, TempNode, UniformNode } from "three/webgpu";
+import { Node, PerspectiveCamera, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 declare class SSGINode extends TempNode<"vec4"> {
     beautyNode: Node;
@@ -18,6 +18,9 @@ declare class SSGINode extends TempNode<"vec4"> {
     useTemporalFiltering: boolean;
 
     constructor(beautyNode: Node, depthNode: Node, normalNode: Node, camera: PerspectiveCamera);
+
+    getAONode(): TextureNode;
+    getGINode(): TextureNode;
 }
 
 export default SSGINode;

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

@@ -1,42 +1,315 @@
-import { Camera, Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
+import { Camera, Node, RenderTarget, TempNode, Texture, TextureNode, UniformNode } from "three/webgpu";
 
-declare class SSRNode extends TempNode<"vec4"> {
-    colorNode: Node;
-    depthNode: Node;
-    normalNode: Node;
-    metalnessNode: Node;
-    roughnessNode: Node | null;
-    camera: Camera | null;
+export interface SSRNodeOptions {
+    /**
+     * - When `false`, traces a single mirror reflection and softens roughness with a blur pass (first-generation SSR). When `true`, varies the reflection direction per pixel with stochastic GGX rays (second-generation SSR); higher quality on rough/glossy surfaces but noisier, so it expects a temporal/spatial denoiser downstream.
+     */
+    stochastic?: boolean | undefined;
+    /**
+     * - Per-pixel metalness. Drives GGX reflection sampling and, with `reflectNonMetals=false`, the non-metal early-out.
+     */
+    metalnessNode?: Node<"float"> | undefined;
+    /**
+     * - Per-pixel roughness. Drives GGX sampling and the blur mip selection.
+     */
+    roughnessNode?: Node<"float"> | undefined;
+    /**
+     * - Only used when `stochastic=false`. When `false`, non-metallic surfaces are discarded for a noticeable performance gain; set `true` to also reflect dielectrics (e.g. marble, polished wood, plastic).
+     */
+    reflectNonMetals?: boolean | undefined;
+    /**
+     * - Equirectangular HDR environment map with CPU-side `image.data` (e.g. from RGBELoader). Not compatible with PMREM / `scene.environment` cubemaps.
+     */
+    environmentNode?: Texture | undefined;
+    /**
+     * - When `true`, precomputes env-luminance CDF tables and uses MIS for environment misses. Build-time only.
+     */
+    envImportanceSampling?: boolean | undefined;
+    /**
+     * - Scene diffuse / base color. Defaults to `vec3(1)` in the shader when omitted.
+     */
+    diffuseNode?: Node<"vec4"> | undefined;
+    /**
+     * - Sub-step binary-search refinement of detected hits. Compile-time constant (baked into the shader at construction).
+     */
+    binaryRefine?: boolean | undefined;
+    /**
+     * - Camera the scene is rendered with. Inferred from the color pass when omitted.
+     */
+    camera?: Camera | undefined;
+}
 
+/**
+ * Post processing node for computing screen space reflections (SSR).
+ *
+ * Reference: {@link https://lettier.github.io/3d-game-shaders-for-beginners/screen-space-reflection.html}
+ *
+ * @augments TempNode
+ * @three_import import { ssr } from 'three/addons/tsl/display/SSRNode.js';
+ */
+declare class SSRNode extends TempNode<"vec4"> {
+    /**
+     * Constructs a new SSR node.
+     *
+     * @param {Node<vec4>} colorNode - The node that represents the beauty pass.
+     * @param {Node<float>} depthNode - A node that represents the beauty pass's depth.
+     * @param {Node<vec3>} normalNode - A node that represents the beauty pass's normals.
+     * @param {SSRNodeOptions} [options] - Optional inputs for material and environment data.
+     */
+    constructor(
+        colorNode: Node<"vec4">,
+        depthNode: Node<"float"> | Node<"vec4">,
+        normalNode: Node<"vec3">,
+        options?: SSRNodeOptions,
+    );
+    /**
+     * When `true`, the reflection direction is varied per pixel with stochastic GGX rays
+     * (second-generation SSR). When `false`, a single mirror reflection is traced and
+     * roughness is softened with a blur pass (first-generation SSR).
+     *
+     * @type {boolean}
+     */
+    stochastic: boolean;
+    /**
+     * When `true`, env-luminance CDF tables are built and MIS is used for environment misses.
+     * Fixed at construction time.
+     *
+     * @type {boolean}
+     */
+    envImportanceSampling: boolean;
+    /**
+     * The node that represents the beauty pass.
+     *
+     * @type {Node<vec4>}
+     */
+    colorNode: Node<"vec4">;
+    /**
+     * A node that represents the scene's diffuse color (typically the MRT `diffuseColor` attachment).
+     * When `null`, the shader uses `vec3(1)`.
+     *
+     * @type {?Node<vec4>}
+     */
+    diffuseNode: Node<"vec4"> | null;
+    /**
+     * A node that represents the beauty pass's depth.
+     *
+     * @type {Node<float>}
+     */
+    depthNode: Node<"float"> | Node<"vec4">;
+    /**
+     * A node that represents the beauty pass's normals.
+     *
+     * @type {Node<vec3>}
+     */
+    normalNode: Node<"vec3">;
+    /**
+     * Per-pixel metalness, used to drive the GGX reflection sampling and the non-metal
+     * early-out. When `null`, the shader treats surfaces as non-metallic.
+     *
+     * @type {?Node<float>}
+     */
+    metalnessNode: Node<"float"> | null;
+    /**
+     * Per-pixel roughness, used to drive the GGX reflection sampling and the blur mip
+     * selection. When `null`, the shader treats surfaces as fully smooth.
+     *
+     * @type {?Node<float>}
+     */
+    roughnessNode: Node<"float"> | null;
+    /**
+     * The resolution scale. Valid values are in the range
+     * `[0,1]`. `1` means best quality but also results in
+     * more computational overhead. Setting to `0.5` means
+     * the effect is computed in half-resolution.
+     *
+     * @type {number}
+     * @default 1
+     */
     resolutionScale: number;
-
+    /**
+     * Controls how far a fragment can reflect. Increasing this value result in more
+     * computational overhead but also increases the reflection distance.
+     *
+     * @type {UniformNode<float>}
+     */
     maxDistance: UniformNode<"float", number>;
+    /**
+     * Controls the cutoff between what counts as a possible reflection hit and what does not.
+     *
+     * @type {UniformNode<float>}
+     */
     thickness: UniformNode<"float", number>;
-    opacity: UniformNode<"float", number>;
+    /**
+     * A multiplier for the overall reflection intensity. `1` leaves the
+     * reflections unchanged, lower values dim them and higher values boost them.
+     *
+     * @type {UniformNode<float>}
+     * @default 1
+     */
+    intensity: UniformNode<"float", number>;
+    /**
+     * Screen-edge fade width, in UV units. As a screen-space hit approaches a screen
+     * border, the reflection is faded over this distance — either toward the environment
+     * reflection ({@link SSRNode#screenEdgeFadeBlack} `false`) or to zero intensity
+     * (`true`). `0` disables it.
+     *
+     * @type {UniformNode<float>}
+     * @default 0.2
+     */
+    screenEdgeFade: UniformNode<"float", number>;
+    /**
+     * Absolute env luminance cap. HDR env samples above this are scaled down (hue preserved).
+     *
+     * @type {UniformNode<float>}
+     * @default 10
+     */
+    maxLuminance: UniformNode<"float", number>;
+    /**
+     * This parameter controls how detailed the raymarching process works.
+     * The value ranges is `[0,1]` where `1` means best quality (the maximum number
+     * of raymarching iterations/samples) and `0` means no samples at all.
+     *
+     * A quality of `0.5` is usually sufficient for most use cases. Try to keep
+     * this parameter as low as possible. Larger values result in noticeable more
+     * overhead.
+     *
+     * @type {UniformNode<float>}
+     */
     quality: UniformNode<"float", number>;
-    blurQuality: UniformNode<"float", number>;
-
-    constructor(
-        colorNode: Node,
-        depthNode: Node,
-        normalNode: Node,
-        metalnessNode: Node,
-        roughnessNode?: Node | null,
-        camera?: Camera | null,
-    );
-
+    /**
+     * Mirror bias for the stochastic GGX sampling. Concentrates the reflected rays toward
+     * the lobe's narrow (near-mirror) core, trading a small amount of bias for less noise.
+     * `0` samples the full VNDF lobe; values toward `1` tighten the cone. Range `[0,1]`.
+     *
+     * @type {UniformNode<float>}
+     * @default 0.5
+     */
+    mirrorBias: UniformNode<"float", number>;
+    /**
+     * HDR environment map for screen-space misses.
+     *
+     * @type {?Texture}
+     */
+    environmentNode: Texture | null;
+    /**
+     * A node that represents the history texture for multi-bounce reflections.
+     *
+     * @type {?Texture}
+     */
+    historyTexture: Texture | null;
+    /**
+     * A node that represents the velocity texture for reprojection.
+     *
+     * @type {?Node<vec2>}
+     */
+    velocityTexture: Node<"vec2"> | Node<"vec4"> | null;
+    /**
+     * The camera the scene is rendered with.
+     *
+     * @type {Camera}
+     */
+    camera: Camera;
+    /**
+     * Intensity multiplier applied to environment-map reflections on screen-space
+     * misses and at screen edges. Defaults to π to match the former hardcoded multiplier.
+     *
+     * @type {UniformNode<float>}
+     * @default Math.PI
+     */
+    environmentIntensity: UniformNode<"float", number>;
+    /**
+     * Non-linear step distribution exponent (compile-time constant). See the backing
+     * field for details. Assigning a new value recompiles the SSR material.
+     *
+     * @type {number}
+     */
+    get stepExponent(): number;
+    set stepExponent(value: number);
+    /**
+     * Blur kernel size (compile-time constant). Assigning a new value recompiles the
+     * blur material.
+     *
+     * @type {number}
+     */
+    get blurQuality(): number;
+    set blurQuality(value: number);
+    /**
+     * Whether SSR fades to black near screen borders (compile-time constant). Assigning
+     * a new value recompiles the SSR material.
+     *
+     * @type {boolean}
+     */
+    get screenEdgeFadeBlack(): boolean;
+    set screenEdgeFadeBlack(value: boolean);
+    /**
+     * Whether sub-step binary-search hit refinement is enabled (compile-time constant).
+     * Assigning a new value rebuilds the SSR material.
+     *
+     * @type {boolean}
+     */
+    get binaryRefine(): boolean;
+    set binaryRefine(value: boolean);
+    /**
+     * Whether dielectrics are reflected in the non-stochastic path (compile-time constant).
+     * Assigning a new value rebuilds the SSR material.
+     *
+     * @type {boolean}
+     */
+    get reflectNonMetals(): boolean;
+    set reflectNonMetals(value: boolean);
+    /**
+     * Returns the result of the effect as a texture node.
+     *
+     * @return {PassTextureNode} A texture node that represents the result of the effect.
+     */
     getTextureNode(): TextureNode;
-
+    /**
+     * Sets the size of the effect.
+     *
+     * @param {number} width - The width of the effect.
+     * @param {number} height - The height of the effect.
+     */
     setSize(width: number, height: number): void;
+    /**
+     * Wires the feedback inputs for multi-bounce reflections: the previous frame's
+     * denoised result (`history`) and the velocity buffer used to reproject it
+     * (`velocity`). `history` accepts the producing node (e.g. a
+     * {@link RecurrentDenoiseNode}) — its output render target is used — or a raw
+     * texture. Pass `null` for both to disable multi-bounce.
+     *
+     * @param {Texture} history
+     * @param {Node<vec2>} velocity
+     */
+    setHistory(
+        history: Texture | { getRenderTarget(): { texture: Texture } },
+        velocity: Node<"vec2"> | Node<"vec4">,
+    ): void;
+    /**
+     * Sets the environment map for importance-sampled env lighting when
+     * screen-space rays miss. Call this whenever the scene's env map changes.
+     *
+     * Uses {@link ImportanceSampledEnvironment} (CDF + MIS adapted from
+     * [three-gpu-pathtracer](https://github.com/gkjohnson/three-gpu-pathtracer)).
+     *
+     * @param {Texture|null} hdr - The equirectangular HDR environment map, or null to disable.
+     * @see {@link https://github.com/gkjohnson/three-gpu-pathtracer}
+     */
+    setEnvMap(hdr: Texture | null): void;
+    /**
+     * Intensity multiplier for the importance-sampled env contribution.
+     * Only available after {@link setEnvMap} has been called.
+     *
+     * @type {?UniformNode<float>}
+     */
+    get envMapIntensity(): UniformNode<"float", number> | null;
+    getRenderTarget(): RenderTarget;
 }
 
 export default SSRNode;
 
-export const ssr: (
-    colorNode: Node,
-    depthNode: Node,
-    normalNode: Node,
-    metalnessNode: Node,
-    roughnessNode?: Node | null,
-    camera?: Camera | null,
-) => SSRNode;
+export function ssr(
+    colorNode: Node<"vec4">,
+    depthNode: Node<"float"> | Node<"vec4">,
+    normalNode: Node<"vec3">,
+    options?: SSRNodeOptions,
+): SSRNode;

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

@@ -1,6 +1,6 @@
 import { Camera, Node, TempNode, TextureNode } from "three/webgpu";
 
-declare class TRAANode extends TempNode {
+declare class TRAANode extends TempNode<"vec4"> {
     readonly isTRAANode: true;
 
     beautyNode: TextureNode;