@needle-tools/three 0.169.12 → 0.169.13

package/types/src/nodes/display/BloomNode.d.ts

@@ -0,0 +1,29 @@
+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";
+
+declare class BloomNode extends TempNode {
+    inputNode: Node;
+    strength: UniformNode<number>;
+    radius: UniformNode<number>;
+    threshold: UniformNode<number>;
+
+    smoothWidth: UniformNode<number>;
+
+    constructor(inputNode: Node, strength?: number, radius?: number, threshold?: number);
+
+    getTexture(): ShaderNodeObject<TextureNode>;
+
+    setSize(width: number, height: number): void;
+}
+
+export const bloom: (
+    node: NodeRepresentation,
+    strength?: number,
+    radius?: number,
+    threshold?: number,
+) => ShaderNodeObject<BloomNode>;
+
+export default BloomNode;

package/types/src/nodes/display/BumpMapNode.d.ts

@@ -0,0 +1,16 @@
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class BumpMapNode extends TempNode {
+    textureNode: Node;
+    scaleNode: Node | null;
+
+    constructor(textureNode: Node, scaleNode?: Node | null);
+}
+
+export default BumpMapNode;
+
+export const bumpMap: (
+    textureNode: NodeRepresentation,
+    scaleNode?: NodeRepresentation | null,
+) => ShaderNodeObject<BumpMapNode>;

package/types/src/nodes/display/ColorAdjustment.d.ts

@@ -0,0 +1,27 @@
+import Node from "../core/Node.js";
+import MathNode from "../math/MathNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const grayscale: (color: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const saturation: (
+    color: NodeRepresentation,
+    adjustment?: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const vibrance: (
+    color: NodeRepresentation,
+    adjustment?: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const hue: (
+    color: NodeRepresentation,
+    adjustment?: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const luminance: (
+    color: NodeRepresentation,
+    luminanceCoefficients?: NodeRepresentation,
+) => ShaderNodeObject<MathNode>;
+
+export const threshold: (color: NodeRepresentation, thershold: NodeRepresentation) => ShaderNodeObject<MathNode>;

package/types/src/nodes/display/ColorSpaceFunctions.d.ts

@@ -0,0 +1,6 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const sRGBToLinearSRGB: (color: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const linearSRGBTosRGB: (color: NodeRepresentation) => ShaderNodeObject<Node>;

package/types/src/nodes/display/ColorSpaceNode.d.ts

@@ -0,0 +1,54 @@
+import { ColorSpace, LinearSRGBColorSpace, SRGBColorSpace } from "../../constants.js";
+import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export type WorkingOrOutputColorSpace = "WorkingColorSpace" | "OutputColorSpace";
+
+export type ColorSpaceMethod = "LinearTosRGB" | "sRGBToLinear" | "LinearToLinear" | "sRGBTosRGB";
+
+export function getColorSpaceMethod(
+    source: typeof LinearSRGBColorSpace | typeof SRGBColorSpace,
+    target: typeof LinearSRGBColorSpace | typeof SRGBColorSpace,
+): ColorSpaceMethod;
+
+export default class ColorSpaceNode extends TempNode {
+    colorNode: Node;
+    source: WorkingOrOutputColorSpace | ColorSpace;
+    target: WorkingOrOutputColorSpace | ColorSpace;
+
+    constructor(
+        colorNode: Node,
+        source: WorkingOrOutputColorSpace | ColorSpace,
+        target: WorkingOrOutputColorSpace | ColorSpace,
+    );
+
+    getColorSpace(nodeBuilder: NodeBuilder, colorSpace: WorkingOrOutputColorSpace): ColorSpace;
+}
+
+export const toOutputColorSpace: (
+    node: NodeRepresentation,
+) => ShaderNodeObject<ColorSpaceNode>;
+export const toWorkingColorSpace: (
+    node: NodeRepresentation,
+) => ShaderNodeObject<ColorSpaceNode>;
+
+export const workingToColorSpace: (
+    node: NodeRepresentation,
+    colorSpace: ColorSpace,
+) => ShaderNodeObject<ColorSpaceNode>;
+export const colorSpaceToWorking: (
+    node: NodeRepresentation,
+    colorSpace: ColorSpace,
+) => ShaderNodeObject<ColorSpaceNode>;
+
+declare module "../tsl/TSLCore.js" {
+    interface NodeElements {
+        toOutputColorSpace: typeof toOutputColorSpace;
+        toWorkingColorSpace: typeof toWorkingColorSpace;
+
+        workingToColorSpace: typeof workingToColorSpace;
+        colorSpaceToWorking: typeof colorSpaceToWorking;
+    }
+}

package/types/src/nodes/display/DenoiseNode.d.ts

@@ -0,0 +1,32 @@
+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";
+
+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>;
+    radius: UniformNode<number>;
+    index: UniformNode<number>;
+
+    constructor(textureNode: Node, depthNode: Node, normalNode: Node, noiseNode: Node, camera: Camera);
+}
+
+export default DenoiseNode;
+
+export const denoise: (
+    node: NodeRepresentation,
+    depthNode: NodeRepresentation,
+    normalNode: NodeRepresentation,
+    noiseNode: NodeRepresentation,
+    camera: Camera,
+) => ShaderNodeObject<DenoiseNode>;

package/types/src/nodes/display/DepthOfFieldNode.d.ts

@@ -0,0 +1,26 @@
+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";
+
+declare class DepthOfFieldNode extends TempNode {
+    textureNode: TextureNode;
+    viewZNode: Node;
+
+    focus: UniformNode<number>;
+    aperture: UniformNode<number>;
+    maxblur: UniformNode<number>;
+
+    constructor(textureNode: TextureNode, viewZNode: Node, focusNode: Node, apertureNode: Node, maxblurNode: Node);
+}
+
+export default DepthOfFieldNode;
+
+export const dof: (
+    node: NodeRepresentation,
+    viewZNode: NodeRepresentation,
+    focus?: NodeRepresentation,
+    aperture?: NodeRepresentation,
+    maxblur?: NodeRepresentation,
+) => ShaderNodeObject<DepthOfFieldNode>;

package/types/src/nodes/display/DotScreenNode.d.ts

@@ -0,0 +1,23 @@
+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";
+
+declare class DotScreenNode extends TempNode {
+    inputNode: Node;
+    center: UniformNode<Vector2>;
+    angle: UniformNode<number>;
+    scale: UniformNode<number>;
+
+    constructor(inputNode: Node, center?: Vector2, angle?: number, scale?: number);
+}
+
+export default DotScreenNode;
+
+export const dotScreen: (
+    node: NodeRepresentation,
+    center?: Vector2,
+    angle?: number,
+    scale?: number,
+) => ShaderNodeObject<DotScreenNode>;

package/types/src/nodes/display/FXAANode.d.ts

@@ -0,0 +1,13 @@
+import TextureNode from "../accessors/TextureNode.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class FXAANode extends TempNode {
+    textureNode: TextureNode;
+
+    constructor(textureNode: TextureNode);
+}
+
+export default FXAANode;
+
+export const fxaa: (node: NodeRepresentation) => ShaderNodeObject<FXAANode>;

package/types/src/nodes/display/FilmNode.d.ts

@@ -0,0 +1,19 @@
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class FilmNode extends TempNode {
+    inputNode: Node;
+    intensityNode: Node | null;
+    uvNode: Node | null;
+
+    constructor(inputNode: Node, intensityNode?: Node | null, uvNode?: Node | null);
+}
+
+export default FilmNode;
+
+export const film: (
+    inputNode: NodeRepresentation,
+    intensityNode?: NodeRepresentation | null,
+    uvNode?: NodeRepresentation | null,
+) => ShaderNodeObject<FilmNode>;

package/types/src/nodes/display/FrontFacingNode.d.ts

@@ -0,0 +1,12 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class FrontFacingNode extends Node {
+    isFrontFacingNode: true;
+    constructor();
+}
+
+export default FrontFacingNode;
+
+export const frontFacing: ShaderNodeObject<FrontFacingNode>;
+export const faceDirection: ShaderNodeObject<Node>;

package/types/src/nodes/display/GTAONode.d.ts

@@ -0,0 +1,40 @@
+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";
+
+declare class GTAONode extends TempNode {
+    depthNode: Node;
+    normalNode: Node;
+
+    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>>;
+
+    constructor(depthNode: Node, normalNode: Node, camera: Camera);
+
+    getTextureNode(): ShaderNodeObject<TextureNode>;
+
+    setSize(width: number, height: number): void;
+}
+
+export default GTAONode;
+
+export const ao: (
+    depthNode: NodeRepresentation,
+    normalNode: NodeRepresentation,
+    camera: Camera,
+) => ShaderNodeObject<GTAONode>;

package/types/src/nodes/display/GaussianBlurNode.d.ts

@@ -0,0 +1,27 @@
+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";
+
+declare class GaussianBlurNode extends TempNode {
+    textureNode: TextureNode;
+    directionNode: Node | null;
+    sigma: number;
+
+    resolution: Vector2;
+
+    constructor(textureNode: TextureNode, directionNode?: Node | null, sigma?: number);
+
+    setSize(width: number, height: number): void;
+
+    getTextureNode(): TextureNode;
+}
+
+export default GaussianBlurNode;
+
+export const gaussianBlur: (
+    node: NodeRepresentation,
+    directionNode?: NodeRepresentation | null,
+    sigma?: number,
+) => ShaderNodeObject<GaussianBlurNode>;

package/types/src/nodes/display/Lut3DNode.d.ts

@@ -0,0 +1,24 @@
+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";
+
+declare class Lut3DNode extends TempNode {
+    inputNode: Node;
+    lutNode: Texture3DNode;
+    size: ShaderNodeObject<UniformNode<number>>;
+    intensityNode: UniformNode<number>;
+
+    constructor(inputNode: Node, lutNode: UniformNode<Data3DTexture>, size: number, intensityNode: UniformNode<number>);
+}
+
+export default Lut3DNode;
+
+export const lut3D: (
+    node: NodeRepresentation,
+    lut: NodeRepresentation,
+    size: number,
+    intensity: NodeRepresentation,
+) => ShaderNodeObject<Lut3DNode>;

package/types/src/nodes/display/MotionBlur.d.ts

@@ -0,0 +1,8 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const motionBlur: (
+    inputNode: NodeRepresentation,
+    velocity: NodeRepresentation,
+    numSamples?: NodeRepresentation,
+) => ShaderNodeObject<Node>;

package/types/src/nodes/display/NormalMapNode.d.ts

@@ -0,0 +1,17 @@
+import { NormalMapTypes } from "../../constants.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class NormalMapNode extends TempNode {
+    node: Node;
+    scaleNode: Node | null;
+
+    normalMapType: NormalMapTypes;
+
+    constructor(node: Node, scaleNode?: Node | null);
+}
+
+export default NormalMapNode;
+
+export const normalMap: (node: Node, scaleNode?: Node) => ShaderNodeObject<NormalMapNode>;

package/types/src/nodes/display/ParallaxBarrierPassNode.d.ts

@@ -0,0 +1,14 @@
+import { Camera } from "../../cameras/Camera.js";
+import { Scene } from "../../scenes/Scene.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import StereoCompositePassNode from "./StereoCompositePassNode.js";
+
+declare class ParallaxBarrierPassNode extends StereoCompositePassNode {
+    readonly isParallaxBarrierPassNode: true;
+
+    constructor(scene: Scene, camera: Camera);
+}
+
+export default ParallaxBarrierPassNode;
+
+export const parallaxBarrierPass: (scene: Scene, camera: Camera) => ShaderNodeObject<ParallaxBarrierPassNode>;

package/types/src/nodes/display/PassNode.d.ts

@@ -0,0 +1,71 @@
+import { Camera } from "../../cameras/Camera.js";
+import { RenderTarget, RenderTargetOptions } from "../../core/RenderTarget.js";
+import { Scene } from "../../scenes/Scene.js";
+import { Texture } from "../../textures/Texture.js";
+import TextureNode from "../accessors/TextureNode.js";
+import MRTNode from "../core/MRTNode.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class PassTextureNode extends TextureNode {
+    passNode: PassNode;
+
+    constructor(passNode: PassNode, texture: Texture);
+}
+
+declare class PassMultipleTextureNode extends PassTextureNode {
+    textureName: string;
+    previousTexture: boolean;
+
+    constructor(passNode: PassNode, textureName: string, previousTexture?: boolean);
+
+    updateTexture(): void;
+}
+
+declare class PassNode extends TempNode {
+    scope: PassNodeScope;
+    scene: Scene;
+    camera: Camera;
+
+    renderTarget: RenderTarget;
+
+    readonly isPassNode: true;
+
+    constructor(scope: PassNodeScope, scene: Scene, camera: Camera, options?: RenderTargetOptions);
+
+    setMRT(mrt: MRTNode | null): this;
+
+    getMRT(): MRTNode | null;
+
+    getTexture(name: string): Texture;
+
+    getPreviousTexture(name: string): Texture;
+
+    toggleTexture(name: string): void;
+
+    getTextureNode(name?: string): ShaderNodeObject<Node>;
+
+    getPreviousTextureNode(name?: string): ShaderNodeObject<Node>;
+
+    getViewZNode(name?: string): ShaderNodeObject<Node>;
+
+    getLinearDepthNode(name?: string): ShaderNodeObject<Node>;
+
+    setSize(width: number, height: number): void;
+
+    setPixelRatio(pixelRatio: number): void;
+
+    dispose(): void;
+
+    static COLOR: "color";
+    static DEPTH: "depth";
+}
+
+export type PassNodeScope = typeof PassNode.COLOR | typeof PassNode.DEPTH;
+
+export default PassNode;
+
+export const pass: (scene: Scene, camera: Camera, options?: RenderTargetOptions) => ShaderNodeObject<PassNode>;
+export const passTexture: (pass: PassNode, texture: Texture) => ShaderNodeObject<PassTextureNode>;
+export const depthPass: (scene: Scene, camera: Camera) => ShaderNodeObject<PassNode>;

package/types/src/nodes/display/PixelationPassNode.d.ts

@@ -0,0 +1,31 @@
+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";
+
+declare class PixelationPassNode extends PassNode {
+    pixelSize: UniformNode<number>;
+    normalEdgeStrength: UniformNode<number>;
+    depthEdgeStrength: UniformNode<number>;
+
+    readonly isPixelationPassNode: true;
+
+    constructor(
+        scene: Scene,
+        camera: Camera,
+        pixelSize: number,
+        normalEdgeStrength: number,
+        depthEdgeStrength: number,
+    );
+}
+
+export const pixelationPass: (
+    scene: Scene,
+    camera: Camera,
+    pixelSize: UniformNode<number>,
+    normalEdgeStrength: UniformNode<number>,
+    depthEdgeStrength: UniformNode<number>,
+) => ShaderNodeObject<PixelationPassNode>;
+
+export default PixelationPassNode;

package/types/src/nodes/display/PosterizeNode.d.ts

@@ -0,0 +1,14 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export default class PosterizeNode extends Node {
+    sourceNode: Node;
+    stepsNode: Node;
+
+    constructor(sourceNode: Node, stepsNode: Node);
+}
+
+export const posterize: (
+    sourceNode: NodeRepresentation,
+    stepsNode: NodeRepresentation,
+) => ShaderNodeObject<PosterizeNode>;

package/types/src/nodes/display/RGBShiftNode.d.ts

@@ -0,0 +1,18 @@
+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";
+
+export default class RGBShiftNode extends TempNode {
+    textureNode: TextureNode;
+    amount: UniformNode<number>;
+    angle: UniformNode<number>;
+
+    constructor(textureNode: TextureNode, amount?: number, angle?: number);
+
+    getTextureNode(): TextureNode;
+
+    setSize(width: number, height: number): void;
+}
+
+export const rgbShift: (node: NodeRepresentation, amount?: number, angle?: number) => ShaderNodeObject<RGBShiftNode>;

package/types/src/nodes/display/RenderOutputNode.d.ts

@@ -0,0 +1,28 @@
+import { ColorSpace, ToneMapping } from "../../constants.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class RenderOutputNode extends TempNode {
+    colorNode: Node;
+    toneMapping: ToneMapping | null;
+    outputColorSpace: ColorSpace | null;
+
+    readonly isRenderOutput: true;
+
+    constructor(colorNode: Node, toneMapping?: ToneMapping | null, outputColorSpace?: ColorSpace | null);
+}
+
+export default RenderOutputNode;
+
+export const renderOutput: (
+    color: NodeRepresentation,
+    toneMapping?: ToneMapping | null,
+    outputColorSpace?: ColorSpace | null,
+) => ShaderNodeObject<RenderOutputNode>;
+
+declare module "../tsl/TSLCore.js" {
+    interface NodeElements {
+        renderOutput: typeof renderOutput;
+    }
+}

package/types/src/nodes/display/SSAAPassNode.d.ts

@@ -0,0 +1,26 @@
+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";
+
+declare class SSAAPassNode extends PassNode {
+    readonly isSSAAPassNode: boolean;
+
+    sampleLevel: number;
+    unbiased: boolean;
+    clearColor: Color;
+    clearAlpha: number;
+
+    sampleWeight: UniformNode<number>;
+
+    sampleRenderTarget: RenderTarget | null;
+
+    constructor(scene: Scene, camera: Camera);
+}
+
+export default SSAAPassNode;
+
+export const ssaaPass: (scene: Scene, camera: Camera) => ShaderNodeObject<SSAAPassNode>;

package/types/src/nodes/display/ScreenNode.d.ts

@@ -0,0 +1,48 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export type ScreenNodeScope =
+    | typeof ScreenNode.COORDINATE
+    | typeof ScreenNode.VIEWPORT
+    | typeof ScreenNode.SIZE
+    | typeof ScreenNode.UV;
+
+declare class ScreenNode extends Node {
+    scope: ScreenNodeScope;
+
+    readonly isViewportNode: true;
+
+    constructor(scope: ScreenNodeScope);
+
+    static COORDINATE: "coordinate";
+    static VIEWPORT: "viewport";
+    static SIZE: "size";
+    static UV: "uv";
+}
+
+export default ScreenNode;
+
+// Screen
+
+export const screenUV: ShaderNodeObject<ScreenNode>;
+export const screenSize: ShaderNodeObject<ScreenNode>;
+export const screenCoordinate: ShaderNodeObject<ScreenNode>;
+
+// Viewport
+
+export const viewport: ShaderNodeObject<ScreenNode>;
+export const viewportSize: ShaderNodeObject<Node>;
+export const viewportCoordinate: ShaderNodeObject<Node>;
+export const viewportUV: ShaderNodeObject<Node>;
+
+// Deprecated
+
+/**
+ * @deprecated "viewportTopLeft" is deprecated. Use "viewportUV" instead.
+ */
+export const viewportTopLeft: ShaderNodeObject<ScreenNode>;
+
+/**
+ * @deprecated "viewportBottomLeft" is deprecated. Use "viewportUV.flipY()" instead.
+ */
+export const viewportBottomLeft: ShaderNodeObject<ScreenNode>;

package/types/src/nodes/display/Sepia.d.ts

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