@types/three 0.176.0 → 0.178.0

three/src/nodes/tsl/TSLCore.d.ts

@@ -1,36 +1,39 @@
-import { Color, ColorRepresentation } from "../../math/Color.js";
+import { Color } from "../../math/Color.js";
+import { Matrix2 } from "../../math/Matrix2.js";
+import { Matrix3 } from "../../math/Matrix3.js";
+import { Matrix4 } from "../../math/Matrix4.js";
+import { Vector2 } from "../../math/Vector2.js";
 import { Vector3 } from "../../math/Vector3.js";
+import { Vector4 } from "../../math/Vector4.js";
 import ConstNode from "../core/ConstNode.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
 import StackNode from "../core/StackNode.js";
-import ConvertNode from "../utils/ConvertNode.js";
+import JoinNode from "../utils/JoinNode.js";
 
 export interface NodeElements {
-    toGlobal: (node: Node) => Node;
-
     toStack: typeof Stack;
 
-    toColor: typeof color;
-    toFloat: typeof float;
-    toInt: typeof int;
-    toUint: typeof uint;
-    toBool: typeof bool;
-    toVec2: typeof vec2;
-    toIvec2: typeof ivec2;
-    toUvec2: typeof uvec2;
-    toBvec2: typeof bvec2;
-    toVec3: typeof vec3;
-    toIvec3: typeof ivec3;
-    toUvec3: typeof uvec3;
-    toBvec3: typeof bvec3;
-    toVec4: typeof vec4;
-    toIvec4: typeof ivec4;
-    toUvec4: typeof uvec4;
-    toBvec4: typeof bvec4;
-    toMat2: typeof mat2;
-    toMat3: typeof mat3;
-    toMat4: typeof mat4;
+    toColor: (node: Node) => ShaderNodeObject<Node>;
+    toFloat: (node: Node) => ShaderNodeObject<Node>;
+    toInt: (node: Node) => ShaderNodeObject<Node>;
+    toUint: (node: Node) => ShaderNodeObject<Node>;
+    toBool: (node: Node) => ShaderNodeObject<Node>;
+    toVec2: (node: Node) => ShaderNodeObject<Node>;
+    toIvec2: (node: Node) => ShaderNodeObject<Node>;
+    toUvec2: (node: Node) => ShaderNodeObject<Node>;
+    toBvec2: (node: Node) => ShaderNodeObject<Node>;
+    toVec3: (node: Node) => ShaderNodeObject<Node>;
+    toIvec3: (node: Node) => ShaderNodeObject<Node>;
+    toUvec3: (node: Node) => ShaderNodeObject<Node>;
+    toBvec3: (node: Node) => ShaderNodeObject<Node>;
+    toVec4: (node: Node) => ShaderNodeObject<Node>;
+    toIvec4: (node: Node) => ShaderNodeObject<Node>;
+    toUvec4: (node: Node) => ShaderNodeObject<Node>;
+    toBvec4: (node: Node) => ShaderNodeObject<Node>;
+    toMat2: (node: Node) => ShaderNodeObject<Node>;
+    toMat3: (node: Node) => ShaderNodeObject<Node>;
+    toMat4: (node: Node) => ShaderNodeObject<Node>;
 
     element: typeof element;
     convert: typeof convert;
@@ -91,11 +94,8 @@ export type ShaderNodeObject<T extends Node> =
     }
     & Swizzable<T>;
 
-/** anything that can be passed to {@link nodeObject} and returns a proxy */
-export type NodeRepresentation<T extends Node = Node> = number | boolean | Vector3 | Node | ShaderNodeObject<T>;
-
 /** anything that can be passed to {@link nodeObject} */
-export type NodeObjectOption = NodeRepresentation | string;
+export type NodeObjectOption = Node | number | string;
 
 // same logic as in ShaderNodeObject: number,boolean,node->ShaderNodeObject, otherwise do nothing
 export type NodeObject<T> = T extends Node ? ShaderNodeObject<T>
@@ -103,7 +103,7 @@ export type NodeObject<T> = T extends Node ? ShaderNodeObject<T>
     : T;
 
 // opposite of NodeObject: node -> node|ShaderNodeObject|boolean|number, otherwise do nothing
-type Proxied<T> = T extends Node ? NodeRepresentation<T> : T;
+type Proxied<T> = T extends Node | number ? Node | number : T;
 // https://github.com/microsoft/TypeScript/issues/42435#issuecomment-765557874
 export type ProxiedTuple<T extends readonly [...unknown[]]> = [...{ [index in keyof T]: Proxied<T[index]> }];
 export type ProxiedObject<T> = { [index in keyof T]: Proxied<T[index]> };
@@ -154,7 +154,7 @@ type OverloadedConstructorsOf<T> = T extends {
 type AnyConstructors = Constructors<any, any, any, any>;
 
 /**
- * Returns all constructors where the first paramter is assignable to given "scope"
+ * Returns all constructors where the first parameter is assignable to given "scope"
  */
 // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
 type FilterConstructorsByScope<T extends AnyConstructors, S> = {
@@ -173,7 +173,7 @@ type ConstructorUnion<T extends AnyConstructors> =
     | Exclude<T["d"], undefined>;
 
 /**
- * Extract list of possible scopes - union of the first paramter
+ * Extract list of possible scopes - union of the first parameter
  * of all constructors, should it be string
  */
 type ExtractScopes<T extends AnyConstructors> =
@@ -186,8 +186,6 @@ type GetConstructorsByScope<T, S> = ConstructorUnion<FilterConstructorsByScope<O
 type GetConstructors<T> = ConstructorUnion<OverloadedConstructorsOf<T>>;
 type GetPossibleScopes<T> = ExtractScopes<OverloadedConstructorsOf<T>>;
 
-export type ConvertType = (...params: unknown[]) => ShaderNodeObject<Node>;
-
 type NodeArray<T extends NodeObjectOption[]> = { [index in keyof T]: NodeObject<T[index]> };
 type NodeObjects<T> = { [key in keyof T]: T[key] extends NodeObjectOption ? NodeObject<T[key]> : T[key] };
 type ConstructedNode<T> = T extends new(...args: any[]) => infer R ? (R extends Node ? R : never) : never;
@@ -204,9 +202,9 @@ export const defined: (v: unknown) => unknown;
 export const getConstNodeType: (value: NodeOrType) => string | null;
 
 export class ShaderNode<T = {}, R extends Node = Node> {
-    constructor(jsFunc: (inputs: NodeObjects<T>, builder: NodeBuilder) => NodeRepresentation);
+    constructor(jsFunc: (inputs: NodeObjects<T>, builder: NodeBuilder) => Node);
     call: (
-        inputs: { [key in keyof T]: T[key] extends NodeRepresentation ? ShaderNodeObject<Node> | Node : T[key] },
+        inputs: { [key in keyof T]: T[key] extends Node ? ShaderNodeObject<Node> | Node : T[key] },
         builder?: NodeBuilder,
     ) => ShaderNodeObject<R>;
 }
@@ -248,17 +246,24 @@ interface Layout {
 
 interface ShaderNodeFn<Args extends readonly unknown[]> {
     (...args: Args): ShaderNodeObject<ShaderCallNodeInternal>;
+
     shaderNode: ShaderNodeObject<ShaderNodeInternal>;
+    id: number;
+
+    getNodeType: (builder: NodeBuilder) => string | null;
+    getCacheKey: (force?: boolean) => number;
+
     setLayout: (layout: Layout) => this;
-    once: () => this;
+
+    once: (subBuilds?: string[] | null) => this;
 }
 
-export function Fn(jsFunc: () => void): ShaderNodeFn<[]>;
+export function Fn(jsFunc: (builder: NodeBuilder) => void): ShaderNodeFn<[]>;
 export function Fn<T extends readonly unknown[]>(
-    jsFunc: (args: T) => void,
+    jsFunc: (args: T, builder: NodeBuilder) => void,
 ): ShaderNodeFn<ProxiedTuple<T>>;
 export function Fn<T extends { readonly [key: string]: unknown }>(
-    jsFunc: (args: T) => void,
+    jsFunc: (args: T, builder: NodeBuilder) => void,
 ): ShaderNodeFn<[ProxiedObject<T>]>;
 
 export const setCurrentStack: (stack: StackNode | null) => void;
@@ -266,67 +271,167 @@ export const setCurrentStack: (stack: StackNode | null) => void;
 export const getCurrentStack: () => StackNode | null;
 
 export const If: (boolNode: Node, method: () => void) => StackNode;
-export const Switch: (expression: NodeRepresentation) => StackNode;
+export const Switch: (expression: Node) => StackNode;
 
 export function Stack(node: Node): Node;
 
 interface ColorFunction {
-    (color?: ColorRepresentation): ShaderNodeObject<ConstNode<Color>>;
+    // The first branch in `ConvertType` will forward the parameters to the `Color` constructor if there are no
+    //   parameters or all the parameters are non-objects
+    (color?: string | number): ShaderNodeObject<ConstNode<Color>>;
     (r: number, g: number, b: number): ShaderNodeObject<ConstNode<Color>>;
-    (node: Node): ShaderNodeObject<ConvertNode>;
+
+    // The second branch does not apply because `cacheMap` is `null`
+
+    // The third branch will be triggered if there is a single parameter.
+    (color: Color): ShaderNodeObject<ConstNode<Color>>;
+    (node: Node): ShaderNodeObject<Node>;
+
+    // The fall-through branch will be triggered if there is more than one parameter, or one of the parameters is an
+    // object. Not sure which cases are worth considering here.
 }
 
 export const color: ColorFunction;
 
-export const float: ConvertType;
-export const int: ConvertType;
-export const uint: ConvertType;
-export const bool: ConvertType;
+interface NumberFunction {
+    (value?: number): ShaderNodeObject<ConstNode<number>>;
+    (node: Node): ShaderNodeObject<Node>;
+}
+
+export const float: NumberFunction;
+export const int: NumberFunction;
+export const uint: NumberFunction;
+
+interface BooleanFunction {
+    (value?: boolean): ShaderNodeObject<ConstNode<boolean>>;
+    (node: Node): ShaderNodeObject<Node>;
+}
+
+export const bool: BooleanFunction;
+
+interface Vector2Function {
+    // The first branch in `ConvertType` will forward the parameters to the `Vector2` constructor if there are no
+    //   parameters or all the parameters are non-objects
+    (x?: number, y?: number): ShaderNodeObject<ConstNode<Vector2>>;
 
-export const vec2: ConvertType;
-export const ivec2: ConvertType;
-export const uvec2: ConvertType;
-export const bvec2: ConvertType;
+    // The second branch does not apply because `cacheMap` is `null`
 
-export const vec3: ConvertType;
-export const ivec3: ConvertType;
-export const uvec3: ConvertType;
-export const bvec3: ConvertType;
+    // The third branch will be triggered if there is a single parameter.
+    (value: Vector2): ShaderNodeObject<ConstNode<Vector2>>;
+    (node: Node): ShaderNodeObject<Node>;
 
-export const vec4: ConvertType;
-export const ivec4: ConvertType;
-export const uvec4: ConvertType;
-export const bvec4: ConvertType;
+    // The fall-through branch will be triggered if there is more than one parameter, or one of the parameters is an
+    // object.
+    (x: Node | number, y: Node | number): ShaderNodeObject<JoinNode>;
+}
 
-export const mat2: ConvertType;
-export const mat3: ConvertType;
-export const mat4: ConvertType;
+export const vec2: Vector2Function;
+export const ivec2: Vector2Function;
+export const uvec2: Vector2Function;
+export const bvec2: (node: Node) => ShaderNodeObject<Node>;
+
+interface Vector3Function {
+    // The first branch in `ConvertType` will forward the parameters to the `Vector3` constructor if there are no
+    //   parameters or all the parameters are non-objects
+    (x?: number, y?: number, z?: number): ShaderNodeObject<ConstNode<Vector3>>;
+
+    // The second branch does not apply because `cacheMap` is `null`
+
+    // The third branch will be triggered if there is a single parameter.
+    (value: Vector3): ShaderNodeObject<ConstNode<Vector3>>;
+    (node: Node): ShaderNodeObject<Node>;
+
+    // The fall-through branch will be triggered if there is more than one parameter, or one of the parameters is an
+    // object.
+    (x: Node | number, y: Node | number, z?: Node | number): ShaderNodeObject<JoinNode>;
+}
+
+export const vec3: Vector3Function;
+export const ivec3: Vector3Function;
+export const uvec3: Vector3Function;
+export const bvec3: (node: Node) => ShaderNodeObject<Node>;
+
+interface Vector4Function {
+    // The first branch in `ConvertType` will forward the parameters to the `Vector4` constructor if there are no
+    //   parameters or all the parameters are non-objects
+    (x?: number, y?: number, z?: number, w?: number): ShaderNodeObject<ConstNode<Vector4>>;
+
+    // The second branch does not apply because `cacheMap` is `null`
+
+    // The third branch will be triggered if there is a single parameter.
+    (value: Vector4): ShaderNodeObject<ConstNode<Vector4>>;
+    (node: Node): ShaderNodeObject<Node>;
+
+    // The fall-through branch will be triggered if there is more than one parameter, or one of the parameters is an
+    // object.
+    (x: Node | number, y: Node | number, z?: Node | number, w?: Node | number): ShaderNodeObject<JoinNode>;
+}
+
+export const vec4: Vector4Function;
+export const ivec4: Vector4Function;
+export const uvec4: Vector4Function;
+export const bvec4: (node: Node) => ShaderNodeObject<Node>;
+
+interface Matrix2Function {
+    (value: Matrix2): ShaderNodeObject<ConstNode<Matrix2>>;
+    (node: Node): ShaderNodeObject<Node>;
+}
+
+export const mat2: Matrix2Function;
+
+interface Matrix3Function {
+    (value: Matrix3): ShaderNodeObject<ConstNode<Matrix3>>;
+    (
+        n11: number,
+        n12: number,
+        n13: number,
+        n21: number,
+        n22: number,
+        n23: number,
+        n31: number,
+        n32: number,
+        n33: number,
+    ): ShaderNodeObject<ConstNode<Matrix3>>;
+    (): ShaderNodeObject<ConstNode<Matrix3>>;
+    (node: Node): ShaderNodeObject<Node>;
+}
+
+export const mat3: Matrix3Function;
+
+interface Matrix4Function {
+    (value: Matrix4): ShaderNodeObject<ConstNode<Matrix4>>;
+    (
+        n11: number,
+        n12: number,
+        n13: number,
+        n14: number,
+        n21: number,
+        n22: number,
+        n23: number,
+        n24: number,
+        n31: number,
+        n32: number,
+        n33: number,
+        n34: number,
+        n41: number,
+        n42: number,
+        n43: number,
+        n44: number,
+    ): ShaderNodeObject<ConstNode<Matrix4>>;
+    (): ShaderNodeObject<ConstNode<Matrix4>>;
+    (node: Node): ShaderNodeObject<Node>;
+}
+
+export const mat4: Matrix4Function;
 
 export const string: (value?: string) => ShaderNodeObject<ConstNode<string>>;
 export const arrayBuffer: (value: ArrayBuffer) => ShaderNodeObject<ConstNode<ArrayBuffer>>;
 
-export const element: (node: NodeRepresentation, indexNode: NodeRepresentation) => ShaderNodeObject<Node>;
-export const convert: (node: NodeRepresentation, types: string) => ShaderNodeObject<Node>;
-export const split: (node: NodeRepresentation, channels?: string) => ShaderNodeObject<Node>;
+export const element: (node: Node, indexNode: Node) => ShaderNodeObject<Node>;
+export const convert: (node: Node, types: string) => ShaderNodeObject<Node>;
+export const split: (node: Node, channels?: string) => ShaderNodeObject<Node>;
 
 /**
  * @deprecated append() has been renamed to Stack().
  */
 export const append: (node: Node) => Node;
-
-/**
- * @deprecated tslFn() has been renamed to Fn()
- */
-export function tslFn<R extends Node = ShaderNodeObject<Node>>(jsFunc: () => R): () => R;
-/**
- * @deprecated tslFn() has been renamed to Fn()
- */
-export function tslFn<T extends any[], R extends Node = ShaderNodeObject<Node>>(
-    jsFunc: (args: T) => R,
-): (...args: ProxiedTuple<T>) => R;
-/**
- * @deprecated tslFn() has been renamed to Fn()
- */
-export function tslFn<T extends { [key: string]: unknown }, R extends Node = ShaderNodeObject<Node>>(
-    jsFunc: (args: T) => R,
-): (args: ProxiedObject<T>) => R;

three/src/nodes/utils/CubeMapNode.d.ts

@@ -1,6 +1,6 @@
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class CubeMapNode extends TempNode {
     envNode: Node;
@@ -10,4 +10,4 @@ declare class CubeMapNode extends TempNode {
 
 export default CubeMapNode;
 
-export const cubeMapNode: (envNode: NodeRepresentation) => ShaderNodeObject<CubeMapNode>;
+export const cubeMapNode: (envNode: Node) => ShaderNodeObject<CubeMapNode>;

three/src/nodes/utils/DebugNode.d.ts

@@ -1,7 +1,7 @@
 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";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class DebugNode extends TempNode {
     constructor(node: Node, callback?: ((code: string) => void) | null);
@@ -10,7 +10,7 @@ declare class DebugNode extends TempNode {
 export default DebugNode;
 
 export const debug: (
-    node: NodeRepresentation,
+    node: Node,
     callback?: ((node: NodeBuilder, code: string) => void) | null,
 ) => ShaderNodeObject<DebugNode>;
 

three/src/nodes/utils/Discard.d.ts

@@ -1,7 +1,7 @@
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const Discard: (conditional?: NodeRepresentation) => ShaderNodeObject<Node>;
+export const Discard: (conditional?: Node) => ShaderNodeObject<Node>;
 export const Return: () => ShaderNodeObject<Node>;
 
 declare module "../tsl/TSLCore.js" {

three/src/nodes/utils/EquirectUV.d.ts

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

three/src/nodes/utils/LoopNode.d.ts

@@ -4,12 +4,12 @@ import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 interface LoopNodeObjectParameter {
     // TODO Expand to other types and update loop function types appropriately
-    type?: "int" | "uint";
+    type?: "int" | "uint" | "float";
     // TODO The variable name should affect the type of the loop function
     // name?: string;
     start: number | Node;
     end: number | Node;
-    condition: string;
+    condition?: string;
 }
 
 type LoopNodeParameter = Node | number | LoopNodeObjectParameter;
@@ -36,8 +36,3 @@ interface Loop {
 export const Loop: Loop;
 export const Continue: () => ShaderNodeObject<Node>;
 export const Break: () => ShaderNodeObject<Node>;
-
-/**
- * @deprecated loop() has been renamed to Loop()
- */
-export const loop: (...params: unknown[]) => ShaderNodeObject<Node>;

three/src/nodes/utils/MatcapUV.d.ts

@@ -0,0 +1,4 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const matcapUV: ShaderNodeObject<Node>;

three/src/nodes/utils/Oscillators.d.ts

@@ -1,7 +1,7 @@
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const oscSine: (timeNode?: NodeRepresentation) => ShaderNodeObject<Node>;
-export const oscSquare: (timeNode?: NodeRepresentation) => ShaderNodeObject<Node>;
-export const oscTriangle: (timeNode?: NodeRepresentation) => ShaderNodeObject<Node>;
-export const oscSawtooth: (timeNode?: NodeRepresentation) => ShaderNodeObject<Node>;
+export const oscSine: (timeNode?: Node) => ShaderNodeObject<Node>;
+export const oscSquare: (timeNode?: Node) => ShaderNodeObject<Node>;
+export const oscTriangle: (timeNode?: Node) => ShaderNodeObject<Node>;
+export const oscSawtooth: (timeNode?: Node) => ShaderNodeObject<Node>;

three/src/nodes/utils/Packing.d.ts

@@ -1,5 +1,5 @@
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const directionToColor: (node: NodeRepresentation) => ShaderNodeObject<Node>;
-export const colorToDirection: (node: NodeRepresentation) => ShaderNodeObject<Node>;
+export const directionToColor: (node: Node) => ShaderNodeObject<Node>;
+export const colorToDirection: (node: Node) => ShaderNodeObject<Node>;

three/src/nodes/utils/PostProcessingUtils.d.ts

@@ -1,5 +1,5 @@
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 /**
  * Computes a position in view space based on a fragment's screen position expressed as uv coordinates, the fragments
@@ -11,9 +11,9 @@ import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
  * @return {vec3} The fragments position in view space.
  */
 export const getViewPosition: (
-    screenPosition: NodeRepresentation,
-    depth: NodeRepresentation,
-    projectionMatrixInverse: NodeRepresentation,
+    screenPosition: Node,
+    depth: Node,
+    projectionMatrixInverse: Node,
 ) => ShaderNodeObject<Node>;
 
 /**
@@ -25,8 +25,8 @@ export const getViewPosition: (
  * @return {vec2} The fragment's screen position expressed as uv coordinates.
  */
 export const getScreenPosition: (
-    viewPosition: NodeRepresentation,
-    projectionMatrix: NodeRepresentation,
+    viewPosition: Node,
+    projectionMatrix: Node,
 ) => ShaderNodeObject<Node>;
 
 /**
@@ -39,7 +39,7 @@ export const getScreenPosition: (
  * @return {vec3} The computed normal vector.
  */
 export const getNormalFromDepth: (
-    uv: NodeRepresentation,
-    depthTexture: NodeRepresentation,
-    projectionMatrixInverse: NodeRepresentation,
+    uv: Node,
+    depthTexture: Node,
+    projectionMatrixInverse: Node,
 ) => ShaderNodeObject<Node>;

three/src/nodes/utils/RTTNode.d.ts

@@ -2,7 +2,7 @@ import { TextureDataType } from "../../constants.js";
 import { RenderTarget } from "../../core/RenderTarget.js";
 import TextureNode from "../accessors/TextureNode.js";
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export interface RTTNodeOptions {
     type: TextureDataType;
@@ -22,7 +22,7 @@ declare class RTTNode extends TextureNode {
 
     constructor(node: Node, width?: number | null, height?: number | null, options?: RTTNodeOptions);
 
-    get autoSize(): boolean;
+    get autoResize(): boolean;
 
     setSize(width: number | null, height: number | null): void;
 
@@ -32,7 +32,7 @@ declare class RTTNode extends TextureNode {
 export default RTTNode;
 
 export const rtt: (
-    node: NodeRepresentation,
+    node: Node,
     width?: number | null,
     height?: number | null,
     options?: RTTNodeOptions,

three/src/nodes/utils/ReflectorNode.d.ts

@@ -33,6 +33,7 @@ declare class ReflectorBaseNode extends Node {
     virtualCameras: WeakMap<Camera, Camera>;
     renderTargets: Map<Camera, RenderTarget>;
     forceUpdate: boolean;
+    hasOutput: boolean;
 
     constructor(textureNode: TextureNode, parameters?: ReflectorNodeParameters);
 

three/src/nodes/utils/RemapNode.d.ts

@@ -1,5 +1,5 @@
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class RemapNode extends Node {
     node: Node;
@@ -15,17 +15,17 @@ export default class RemapNode extends Node {
 
 export const remap: (
     node: Node,
-    inLowNode: NodeRepresentation,
-    inHighNode: NodeRepresentation,
-    outLowNode?: NodeRepresentation,
-    outHighNode?: NodeRepresentation,
+    inLowNode: Node | number,
+    inHighNode: Node | number,
+    outLowNode?: Node | number,
+    outHighNode?: Node | number,
 ) => ShaderNodeObject<RemapNode>;
 export const remapClamp: (
     node: Node,
-    inLowNode: NodeRepresentation,
-    inHighNode: NodeRepresentation,
-    outLowNode?: NodeRepresentation,
-    outHighNode?: NodeRepresentation,
+    inLowNode: Node | number,
+    inHighNode: Node | number,
+    outLowNode?: Node | number,
+    outHighNode?: Node | number,
 ) => ShaderNodeObject<RemapNode>;
 
 declare module "../tsl/TSLCore.js" {

three/src/nodes/utils/RotateNode.d.ts

@@ -1,6 +1,6 @@
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class RotateNode extends TempNode {
     positionNode: Node;
@@ -10,6 +10,6 @@ export default class RotateNode extends TempNode {
 }
 
 export const rotate: (
-    positionNode: NodeRepresentation,
-    rotationNode: NodeRepresentation,
+    positionNode: Node,
+    rotationNode: Node | number,
 ) => ShaderNodeObject<RotateNode>;

three/src/nodes/utils/SampleNode.d.ts

@@ -0,0 +1,16 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class SampleNode extends Node {
+    callback: (uv: Node) => Node;
+
+    readonly isSampleNode: true;
+
+    constructor(callback: (uv: Node) => Node);
+
+    sample(uv: Node): Node;
+}
+
+export default SampleNode;
+
+export const sample: (callback: (uv: Node) => Node) => ShaderNodeObject<SampleNode>;

three/src/nodes/utils/SpriteSheetUVNode.d.ts

@@ -1,5 +1,5 @@
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class SpriteSheetUVNode extends Node {
     countNode: Node;
@@ -10,7 +10,7 @@ export default class SpriteSheetUVNode extends Node {
 }
 
 export const spritesheetUV: (
-    countNode: NodeRepresentation,
-    uvNode: NodeRepresentation | null,
-    frameNode: NodeRepresentation | null,
+    countNode: Node,
+    uvNode: Node | null,
+    frameNode: Node | null,
 ) => ShaderNodeObject<SpriteSheetUVNode>;

three/src/nodes/utils/SpriteUtils.d.ts

@@ -1,6 +1,6 @@
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export const billboarding: (
-    args?: { position?: NodeRepresentation | null; horizontal?: boolean; vertical?: boolean },
+    args?: { position?: Node | null; horizontal?: boolean; vertical?: boolean },
 ) => ShaderNodeObject<Node>;

three/src/nodes/utils/StorageArrayElementNode.d.ts

@@ -1,5 +1,6 @@
 import StorageBufferNode from "../accessors/StorageBufferNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import ArrayElementNode from "./ArrayElementNode.js";
 
 export default class StorageArrayElementNode extends ArrayElementNode {
@@ -14,6 +15,6 @@ export default class StorageArrayElementNode extends ArrayElementNode {
 }
 
 export const storageElement: (
-    storageBufferNode: NodeRepresentation,
-    indexNode: NodeRepresentation,
+    storageBufferNode: Node,
+    indexNode: Node,
 ) => ShaderNodeObject<StorageArrayElementNode>;