@types/three 0.169.0 → 0.171.0

three/examples/jsm/misc/ProgressiveLightMap.d.ts

@@ -24,29 +24,23 @@ export interface LightMapContainers {
     object: Object3D;
 }
 
-export class ProgressiveLightMap {
+declare class ProgressiveLightMap {
     renderer: WebGLRenderer;
     res: number;
     lightMapContainers: LightMapContainers[];
-    compiled: boolean;
     scene: Scene;
-    tinyTarget: WebGLRenderTarget;
     buffer1Active: boolean;
     firstUpdate: boolean;
     warned: boolean;
+    labelMesh: Mesh<PlaneGeometry, MeshBasicMaterial> | null;
+    blurringPlane: Mesh<PlaneGeometry, MeshBasicMaterial> | null;
 
     progressiveLightMap1: WebGLRenderTarget;
     progressiveLightMap2: WebGLRenderTarget;
 
     uvMat: MeshPhongMaterial;
 
-    uv_boxes: UVBoxes[];
-
-    blurringPlane: Mesh<PlaneGeometry, MeshBasicMaterial>;
-
-    labelMaterial: MeshBasicMaterial;
-    labelPlane: PlaneGeometry;
-    labelMesh: Mesh<PlaneGeometry, MeshBasicMaterial>;
+    uv_boxes?: UVBoxes[];
 
     constructor(renderer: WebGLRenderer, res?: number);
 
@@ -57,4 +51,8 @@ export class ProgressiveLightMap {
     showDebugLightmap(visible: boolean, position?: Vector3): void;
 
     private _initializeBlurPlane(res: number, lightMap?: Texture | null): void;
+
+    dispose(): void;
 }
+
+export { ProgressiveLightMap };

three/examples/jsm/misc/ProgressiveLightMapGPU.d.ts

@@ -0,0 +1,27 @@
+import { Camera, Material, Object3D, Vector3, WebGPURenderer } from "three/webgpu";
+
+export interface UVBoxes {
+    w: number;
+    h: number;
+    index: number;
+}
+
+export interface LightMapContainers {
+    basicMat: Material | Material[];
+    object: Object3D;
+}
+
+declare class ProgressiveLightMap {
+    renderer: WebGPURenderer;
+    resolution: number;
+
+    constructor(renderer: WebGPURenderer, resolution?: number);
+
+    addObjectsToLightMap(objects: Object3D[]): void;
+
+    update(camera: Camera, blendWindow?: number, blurEdges?: boolean): void;
+
+    showDebugLightmap(visible: boolean, position?: Vector3 | null): void;
+}
+
+export { ProgressiveLightMap };

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

@@ -1,5 +1,5 @@
-import { ShaderNodeObject, UniformNode } from "three/tsl";
-import { BoxGeometry, Mesh, NodeMaterial, Vector3 } from "three/webgpu";
+import { ShaderNodeObject } from "three/tsl";
+import { BoxGeometry, Mesh, NodeMaterial, UniformNode, Vector3 } from "three/webgpu";
 
 declare class SkyMesh extends Mesh<BoxGeometry, NodeMaterial> {
     turbidity: ShaderNodeObject<UniformNode<number>>;

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

@@ -1,5 +1,16 @@
-import { TempNode, TextureNode, UniformNode, Vector2, Vector3 } from "three/tsl";
-import { BufferGeometry, Color, ColorRepresentation, Mesh, NodeMaterial, Texture } from "three/webgpu";
+import {
+    BufferGeometry,
+    Color,
+    ColorRepresentation,
+    Mesh,
+    NodeMaterial,
+    TempNode,
+    Texture,
+    TextureNode,
+    UniformNode,
+    Vector2,
+    Vector3,
+} from "three/webgpu";
 
 export interface WaterMeshOptions {
     normalMap0: Texture;

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

@@ -1,5 +1,14 @@
-import { TextureNode, UniformNode } from "three/tsl";
-import { BufferGeometry, Color, ColorRepresentation, Mesh, NodeMaterial, Texture, Vector3 } from "three/webgpu";
+import {
+    BufferGeometry,
+    Color,
+    ColorRepresentation,
+    Mesh,
+    NodeMaterial,
+    Texture,
+    TextureNode,
+    UniformNode,
+    Vector3,
+} from "three/webgpu";
 
 export interface WaterMeshOptions {
     resolution?: number | undefined;

three/examples/jsm/renderers/SVGRenderer.d.ts

@@ -1,4 +1,4 @@
-import { Camera, Color, ColorSpace, Object3D, Scene } from "three";
+import { Camera, Color, Object3D, Scene } from "three";
 
 export class SVGObject extends Object3D {
     constructor(node: SVGElement);
@@ -12,7 +12,7 @@ export class SVGRenderer {
     sortObjects: boolean;
     sortElements: boolean;
     overdraw: number;
-    outputColorSpace: ColorSpace;
+    outputColorSpace: string;
     info: { render: { vertices: number; faces: number } };
 
     getSize(): { width: number; height: number };

three/{src/nodes → examples/jsm/tsl}/display/AfterImageNode.d.ts

@@ -1,8 +1,5 @@
-import TextureNode from "../accessors/TextureNode.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import UniformNode from "../core/UniformNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "three/tsl";
+import { Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 export default class AfterImageNode extends TempNode {
     textureNode: TextureNode;

three/{src/nodes → examples/jsm/tsl}/display/AnaglyphPassNode.d.ts

@@ -1,6 +1,5 @@
-import { Camera } from "../../cameras/Camera.js";
-import { Scene } from "../../scenes/Scene.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "three/tsl";
+import { Camera, Scene } from "three/webgpu";
 import StereoCompositePassNode from "./StereoCompositePassNode.js";
 
 declare class AnaglyphPassNode extends StereoCompositePassNode {

three/{src/nodes → examples/jsm/tsl}/display/AnamorphicNode.d.ts

@@ -1,7 +1,5 @@
-import { Vector2 } from "../../math/Vector2.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
+import { Node, TempNode, Vector2 } from "three/webgpu";
 
 export default class AnamorphicNode extends TempNode {
     textureNode: Node;

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

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

three/{src/nodes → examples/jsm/tsl}/display/BloomNode.d.ts

@@ -1,8 +1,5 @@
-import TextureNode from "../accessors/TextureNode.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
+import { Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 declare class BloomNode extends TempNode {
     inputNode: Node;

three/{src/nodes → examples/jsm/tsl}/display/DenoiseNode.d.ts

@@ -1,17 +1,13 @@
-import { Camera } from "../../cameras/Camera.js";
-import { Matrix4 } from "../../math/Matrix4.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
+import { Camera, Node, TempNode, UniformNode } from "three/webgpu";
 
 declare class DenoiseNode extends TempNode {
     textureNode: Node;
     depthNode: Node;
     normalNode: Node;
+
     noiseNode: Node;
 
-    cameraProjectionMatrixInversion: UniformNode<Matrix4>;
     lumaPhi: UniformNode<number>;
     depthPhi: UniformNode<number>;
     normalPhi: UniformNode<number>;
@@ -27,6 +23,5 @@ export const denoise: (
     node: NodeRepresentation,
     depthNode: NodeRepresentation,
     normalNode: NodeRepresentation,
-    noiseNode: NodeRepresentation,
     camera: Camera,
 ) => ShaderNodeObject<DenoiseNode>;

three/{src/nodes → examples/jsm/tsl}/display/DepthOfFieldNode.d.ts

@@ -1,8 +1,5 @@
-import TextureNode from "../accessors/TextureNode.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
+import { Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 declare class DepthOfFieldNode extends TempNode {
     textureNode: TextureNode;

three/{src/nodes → examples/jsm/tsl}/display/DotScreenNode.d.ts

@@ -1,8 +1,5 @@
-import { Vector2 } from "../../math/Vector2.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
+import { Node, TempNode, UniformNode, Vector2 } from "three/webgpu";
 
 declare class DotScreenNode extends TempNode {
     inputNode: Node;

three/{src/nodes → examples/jsm/tsl}/display/FXAANode.d.ts

@@ -1,6 +1,5 @@
-import TextureNode from "../accessors/TextureNode.js";
-import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
+import { TempNode, TextureNode } from "three/webgpu";
 
 declare class FXAANode extends TempNode {
     textureNode: TextureNode;

three/{src/nodes → examples/jsm/tsl}/display/FilmNode.d.ts

@@ -1,6 +1,5 @@
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
+import { Node, TempNode } from "three/webgpu";
 
 declare class FilmNode extends TempNode {
     inputNode: Node;

three/{src/nodes → examples/jsm/tsl}/display/GTAONode.d.ts

@@ -1,28 +1,19 @@
-import { Camera } from "../../cameras/Camera.js";
-import { Matrix4 } from "../../math/Matrix4.js";
-import { Vector2 } from "../../math/Vector2.js";
-import TextureNode from "../accessors/TextureNode.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
+import { Camera, Node, TempNode, TextureNode, UniformNode, Vector2 } from "three/webgpu";
 
 declare class GTAONode extends TempNode {
     depthNode: Node;
     normalNode: Node;
 
+    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>>;
-    noiseNode: ShaderNodeObject<TextureNode>;
-
-    cameraProjectionMatrix: ShaderNodeObject<UniformNode<Matrix4>>;
-    cameraProjectionMatrixInverse: ShaderNodeObject<UniformNode<Matrix4>>;
-
-    SAMPLES: ShaderNodeObject<UniformNode<number>>;
+    samples: ShaderNodeObject<UniformNode<number>>;
 
     constructor(depthNode: Node, normalNode: Node, camera: Camera);
 

three/{src/nodes → examples/jsm/tsl}/display/GaussianBlurNode.d.ts

@@ -1,8 +1,5 @@
-import { Vector2 } from "../../math/Vector2.js";
-import TextureNode from "../accessors/TextureNode.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
+import { Node, TempNode, TextureNode, Vector2 } from "three/webgpu";
 
 declare class GaussianBlurNode extends TempNode {
     textureNode: TextureNode;
@@ -11,8 +8,14 @@ declare class GaussianBlurNode extends TempNode {
 
     resolution: Vector2;
 
+    premultipliedAlpha: boolean;
+
     constructor(textureNode: TextureNode, directionNode?: Node | null, sigma?: number);
 
+    setPremultipliedAlpha(value: boolean): this;
+
+    getPremultipliedAlpha(): boolean;
+
     setSize(width: number, height: number): void;
 
     getTextureNode(): TextureNode;
@@ -25,3 +28,8 @@ export const gaussianBlur: (
     directionNode?: NodeRepresentation | null,
     sigma?: number,
 ) => ShaderNodeObject<GaussianBlurNode>;
+export const premultipliedGaussianBlur: (
+    node: NodeRepresentation,
+    directionNode?: NodeRepresentation | null,
+    sigma?: number,
+) => ShaderNodeObject<GaussianBlurNode>;

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

@@ -0,0 +1,35 @@
+import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
+import { TempNode, TextureNode, UniformNode, Vector3 } from "three/webgpu";
+
+interface LensflareNodeParams {
+    ghostTint?: NodeRepresentation | undefined;
+    threshold?: NodeRepresentation | undefined;
+    ghostSamples?: NodeRepresentation | undefined;
+    ghostSpacing?: NodeRepresentation | undefined;
+    ghostAttenuationFactor?: NodeRepresentation | undefined;
+    downSampleRatio?: number | undefined;
+}
+
+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>>;
+    downSampleRatio: number;
+
+    constructor(textureNode: TextureNode, params?: LensflareNodeParams);
+
+    getTextureNode(): TextureNode;
+
+    setSize(width: number, height: number): void;
+}
+
+export default LensflareNode;
+
+export const lensflare: (
+    inputNode: NodeRepresentation,
+    params?: LensflareNodeParams,
+) => ShaderNodeObject<LensflareNode>;

three/{src/nodes → examples/jsm/tsl}/display/Lut3DNode.d.ts

@@ -1,9 +1,5 @@
-import { Data3DTexture } from "../../textures/Data3DTexture.js";
-import Texture3DNode from "../accessors/Texture3DNode.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
+import { Data3DTexture, Node, TempNode, Texture3DNode, UniformNode } from "three/webgpu";
 
 declare class Lut3DNode extends TempNode {
     inputNode: Node;

three/{src/nodes → examples/jsm/tsl}/display/MotionBlur.d.ts

@@ -1,5 +1,5 @@
-import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
+import { Node } from "three/webgpu";
 
 export const motionBlur: (
     inputNode: NodeRepresentation,

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

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

three/{src/nodes → examples/jsm/tsl}/display/ParallaxBarrierPassNode.d.ts

@@ -1,6 +1,5 @@
-import { Camera } from "../../cameras/Camera.js";
-import { Scene } from "../../scenes/Scene.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "three/tsl";
+import { Camera, Scene } from "three/webgpu";
 import StereoCompositePassNode from "./StereoCompositePassNode.js";
 
 declare class ParallaxBarrierPassNode extends StereoCompositePassNode {

three/{src/nodes → examples/jsm/tsl}/display/PixelationPassNode.d.ts

@@ -1,8 +1,5 @@
-import { Camera } from "../../cameras/Camera.js";
-import { Scene } from "../../scenes/Scene.js";
-import UniformNode from "../core/UniformNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
-import PassNode from "./PassNode.js";
+import { ShaderNodeObject } from "three/tsl";
+import { Camera, PassNode, Scene, UniformNode } from "three/webgpu";
 
 declare class PixelationPassNode extends PassNode {
     pixelSize: UniformNode<number>;

three/{src/nodes → examples/jsm/tsl}/display/RGBShiftNode.d.ts

@@ -1,7 +1,5 @@
-import TextureNode from "../accessors/TextureNode.js";
-import TempNode from "../core/TempNode.js";
-import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
+import { TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 export default class RGBShiftNode extends TempNode {
     textureNode: TextureNode;

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

@@ -0,0 +1,18 @@
+import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
+import { TempNode, TextureNode } from "three/webgpu";
+
+declare class SMAANode extends TempNode {
+    textureNode: TextureNode;
+
+    constructor(textureNode: TextureNode);
+
+    getTextureNode(): TextureNode;
+
+    setSize(width: number, height: number): void;
+
+    getAreaTexture(): string;
+
+    getSearchTexture(): string;
+}
+
+export const smaa: (node: NodeRepresentation) => ShaderNodeObject<SMAANode>;

three/{src/nodes → examples/jsm/tsl}/display/SSAAPassNode.d.ts

@@ -1,10 +1,5 @@
-import { Camera } from "../../cameras/Camera.js";
-import { RenderTarget } from "../../core/RenderTarget.js";
-import { Color } from "../../math/Color.js";
-import { Scene } from "../../scenes/Scene.js";
-import UniformNode from "../core/UniformNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
-import PassNode from "./PassNode.js";
+import { ShaderNodeObject } from "three/tsl";
+import { Camera, Color, PassNode, RenderTarget, Scene, UniformNode } from "three/webgpu";
 
 declare class SSAAPassNode extends PassNode {
     readonly isSSAAPassNode: boolean;

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

@@ -0,0 +1,38 @@
+import { NodeRepresentation, 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>;
+    camera: Camera;
+
+    resolutionScale: number;
+
+    maxDistance: UniformNode<number>;
+    thickness: UniformNode<number>;
+    opacity: UniformNode<number>;
+
+    constructor(
+        colorNode: ShaderNodeObject<Node>,
+        depthNode: ShaderNodeObject<Node>,
+        normalNode: ShaderNodeObject<Node>,
+        metalnessNode: ShaderNodeObject<Node>,
+        camera: Camera,
+    );
+
+    getTextureNode(): ShaderNodeObject<TextureNode>;
+
+    setSize(width: number, height: number): void;
+}
+
+export default SSRNode;
+
+export const ssr: (
+    colorNode: NodeRepresentation,
+    depthNode: NodeRepresentation,
+    normalNode: NodeRepresentation,
+    metalnessNode: NodeRepresentation,
+    camera: Camera,
+) => ShaderNodeObject<SSRNode>;

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

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

three/{src/nodes → examples/jsm/tsl}/display/SobelOperatorNode.d.ts

@@ -1,6 +1,5 @@
-import TextureNode from "../accessors/TextureNode.js";
-import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
+import { TempNode, TextureNode } from "three/webgpu";
 
 declare class SobelOperatorNode extends TempNode {
     textureNode: TextureNode;

three/{src/nodes → examples/jsm/tsl}/display/StereoCompositePassNode.d.ts

@@ -1,8 +1,4 @@
-import { Camera } from "../../cameras/Camera.js";
-import { StereoCamera } from "../../cameras/StereoCamera.js";
-import { CoordinateSystem } from "../../constants.js";
-import { Scene } from "../../scenes/Scene.js";
-import PassNode from "./PassNode.js";
+import { Camera, CoordinateSystem, PassNode, Scene, StereoCamera } from "three/webgpu";
 
 declare class StereoCompositePassNode extends PassNode {
     readonly isStereoCompositePassNode: true;

three/{src/nodes → examples/jsm/tsl}/display/StereoPassNode.d.ts

@@ -1,8 +1,5 @@
-import { Camera } from "../../cameras/Camera.js";
-import { StereoCamera } from "../../cameras/StereoCamera.js";
-import { Scene } from "../../scenes/Scene.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
-import PassNode from "./PassNode.js";
+import { ShaderNodeObject } from "three/tsl";
+import { Camera, PassNode, Scene, StereoCamera } from "three/webgpu";
 
 declare class StereoPassNode extends PassNode {
     readonly isStereoPassNode: true;

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

@@ -0,0 +1,15 @@
+import { ShaderNodeObject } from "three/tsl";
+import { Camera, ColorRepresentation, PassNode, Scene } from "three/webgpu";
+
+declare class TRAAPassNode extends PassNode {
+    readonly isTRAAPassNode: true;
+
+    clearColor: ColorRepresentation;
+    clearAlpha: number;
+
+    constructor(scene: Scene, camera: Camera);
+}
+
+export default TRAAPassNode;
+
+export const traaPass: (scene: Scene, camera: Camera) => ShaderNodeObject<TRAAPassNode>;

three/{src/nodes → examples/jsm/tsl}/display/TransitionNode.d.ts

@@ -1,8 +1,5 @@
-import TextureNode from "../accessors/TextureNode.js";
-import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
-import UniformNode from "../core/UniformNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
+import { Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 declare class TransitionNode extends TempNode {
     textureNodeA: TextureNode;

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

@@ -0,0 +1,8 @@
+import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
+import { Node } from "three/webgpu";
+
+export const hashBlur: (
+    textureNode: NodeRepresentation,
+    bluramount?: NodeRepresentation,
+    repeats?: NodeRepresentation,
+) => ShaderNodeObject<Node>;

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

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