@types/three 0.159.0 → 0.160.0

three/examples/jsm/nodes/accessors/PositionNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type PositionNodeScope =
     | typeof PositionNode.GEOMETRY
@@ -19,3 +20,10 @@ export default class PositionNode extends Node {
 
     constructor(scope?: PositionNodeScope);
 }
+
+export const positionGeometry: ShaderNodeObject<PositionNode>;
+export const positionLocal: ShaderNodeObject<PositionNode>;
+export const positionWorld: ShaderNodeObject<PositionNode>;
+export const positionWorldDirection: ShaderNodeObject<PositionNode>;
+export const positionView: ShaderNodeObject<PositionNode>;
+export const positionViewDirection: ShaderNodeObject<PositionNode>;

three/examples/jsm/nodes/accessors/ReferenceNode.d.ts

@@ -1,5 +1,6 @@
 import Node from '../core/Node.js';
-import { NodeTypeOption } from '../Nodes.js';
+import { NodeTypeOption } from '../core/constants.js';
+import { NodeOrType, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class ReferenceNode<T> extends Node {
     object: T;
@@ -11,3 +12,5 @@ export default class ReferenceNode<T> extends Node {
 
     setNodeType(uniformType: NodeTypeOption): void;
 }
+
+export const reference: <T>(name: string, nodeOrType: NodeOrType, object: T) => ShaderNodeObject<ReferenceNode<T>>;

three/examples/jsm/nodes/accessors/ReflectVectorNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class ReflectVectorNode extends Node {
     constructor();
@@ -6,3 +7,5 @@ export default class ReflectVectorNode extends Node {
     getHash(): 'reflectVector';
     setup(): Node;
 }
+
+export const reflectVector: ShaderNodeObject<ReflectVectorNode>;

three/examples/jsm/nodes/accessors/SkinningNode.d.ts

@@ -1,5 +1,6 @@
 import { SkinnedMesh } from '../../../../src/Three.js';
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class SkinningNode extends Node {
     skinIndexNode: Node;
@@ -11,3 +12,5 @@ export default class SkinningNode extends Node {
 
     constructor(skinnedMesh: SkinnedMesh);
 }
+
+export function skinning(skinnedMesh: SkinnedMesh): ShaderNodeObject<SkinningNode>;

three/examples/jsm/nodes/accessors/StorageBufferNode.d.ts

@@ -1,6 +1,13 @@
-import { NodeTypeOption } from '../Nodes.js';
 import BufferNode from './BufferNode.js';
+import { NodeTypeOption } from '../core/constants.js';
+import { NodeOrType, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class StorageBufferNode extends BufferNode {
     constructor(value: ArrayLike<number>, bufferType: NodeTypeOption, bufferCount?: number);
 }
+
+export const storage: (
+    value: ArrayLike<number>,
+    nodeOrType: NodeOrType,
+    count: number,
+) => ShaderNodeObject<StorageBufferNode>;

three/examples/jsm/nodes/accessors/TangentNode.d.ts

@@ -1,4 +1,6 @@
 import Node from '../core/Node.js';
+import MathNode from '../math/MathNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type TangentNodeScope =
     | typeof TangentNode.LOCAL
@@ -16,3 +18,10 @@ export default class TangentNode extends Node {
 
     constructor(scope?: TangentNodeScope);
 }
+
+export const tangentGeometry: ShaderNodeObject<TangentNode>;
+export const tangentLocal: ShaderNodeObject<TangentNode>;
+export const tangentView: ShaderNodeObject<TangentNode>;
+export const tangentWorld: ShaderNodeObject<TangentNode>;
+export const transformedTangentView: ShaderNodeObject<MathNode>;
+export const transformedTangentWorld: ShaderNodeObject<MathNode>;

three/examples/jsm/nodes/accessors/TextureNode.d.ts

@@ -1,8 +1,9 @@
 import { Texture } from '../../../../src/Three.js';
 import UniformNode from '../core/UniformNode.js';
-import { Node } from '../Nodes.js';
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
-export default class TextureNode extends UniformNode {
+export default class TextureNode extends UniformNode<Texture> {
     isTextureNode: true;
 
     uvNode: Node | null;
@@ -12,3 +13,10 @@ export default class TextureNode extends UniformNode {
 
     getDefaultUV(): Node;
 }
+
+export const texture: (
+    value: Texture,
+    uvNode?: NodeRepresentation,
+    levelNode?: NodeRepresentation,
+) => ShaderNodeObject<TextureNode>;
+export const sampler: (aTexture: Texture | TextureNode) => ShaderNodeObject<Node>;

three/examples/jsm/nodes/accessors/UVNode.d.ts

@@ -1,4 +1,5 @@
 import AttributeNode from '../core/AttributeNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class UVNode extends AttributeNode {
     isUVNode: true;
@@ -6,3 +7,5 @@ export default class UVNode extends AttributeNode {
 
     constructor(index?: number);
 }
+
+export const uv: (index?: number) => ShaderNodeObject<UVNode>;

three/examples/jsm/nodes/accessors/UserDataNode.d.ts

@@ -1,7 +1,14 @@
 import { NodeTypeOption, NodeUserData } from '../core/constants.js';
 import ReferenceNode from './ReferenceNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class UserDataNode extends ReferenceNode<NodeUserData> {
     userData: NodeUserData | null;
     constructor(property: string, inputType: NodeTypeOption, userData?: NodeUserData | null);
 }
+
+export const userData: (
+    name: string,
+    inputType: NodeTypeOption,
+    userData?: NodeUserData,
+) => ShaderNodeObject<UserDataNode>;

three/examples/jsm/nodes/code/CodeNode.d.ts

@@ -1,5 +1,7 @@
 import Node from '../core/Node.js';
 import NodeBuilder from '../core/NodeBuilder.js';
+import { NodeTypeOption } from '../core/constants.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export interface CodeNodeInclude {
     build(builder: NodeBuilder): void;
@@ -13,3 +15,5 @@ export default class CodeNode extends Node {
     setIncludes(includes: CodeNodeInclude[]): this;
     getIncludes(builder: NodeBuilder): CodeNodeInclude[];
 }
+
+export const code: (code: string, nodeType?: NodeTypeOption) => ShaderNodeObject<CodeNode>;

three/examples/jsm/nodes/code/ExpressionNode.d.ts

@@ -1,7 +1,10 @@
 import { NodeTypeOption } from '../core/constants.js';
 import TempNode from '../core/TempNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class ExpressionNode extends TempNode {
     snipped: string; /* sic */
     constructor(snipped?: string, nodeType?: NodeTypeOption);
 }
+
+export const expression: (snipped?: string, nodeType?: NodeTypeOption) => ShaderNodeObject<ExpressionNode>;

three/examples/jsm/nodes/code/FunctionCallNode.d.ts

@@ -1,6 +1,7 @@
-import FunctionNode from './FunctionNode.js';
+import FunctionNode, { FunctionNodeArguments } from './FunctionNode.js';
 import TempNode from '../core/TempNode.js';
 import Node from '../core/Node.js';
+import { ProxiedObject, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class FunctionCallNode<P extends Node[] | { [name: string]: Node }> extends TempNode {
     functionNode: FunctionNode<P>;
@@ -11,3 +12,8 @@ export default class FunctionCallNode<P extends Node[] | { [name: string]: Node
     setParameters(parameters: P): this;
     getParameters(): P;
 }
+
+export const call: <P extends FunctionNodeArguments>(
+    functionNode?: FunctionNode<P>,
+    parameters?: ProxiedObject<P>,
+) => ShaderNodeObject<FunctionCallNode<P>>;

three/examples/jsm/nodes/code/FunctionNode.d.ts

@@ -4,6 +4,7 @@ import NodeBuilder from '../core/NodeBuilder.js';
 import NodeFunction from '../core/NodeFunction.js';
 import NodeFunctionInput from '../core/NodeFunctionInput.js';
 import Node from '../core/Node.js';
+import { ProxiedObject, ProxiedTuple, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type FunctionNodeArguments = Node[] | { [name: string]: Node };
 
@@ -15,3 +16,19 @@ export default class FunctionNode<P extends Node[] | { [name: string]: Node }> e
     getNodeFunction(builder: NodeBuilder): NodeFunction;
     call(parameters: P): FunctionCallNode<P>;
 }
+
+export type Fn<P extends FunctionNodeArguments> = P extends readonly [...unknown[]]
+    ? ProxiedTuple<P>
+    : readonly [ProxiedObject<P>];
+
+export const func: <P extends FunctionNodeArguments>(
+    code: string,
+    includes?: CodeNodeInclude[],
+    // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+) => { call: (...params: Fn<P>) => ShaderNodeObject<Node> };
+
+export const fn: <P extends FunctionNodeArguments>(
+    code: string,
+    includes?: CodeNodeInclude[],
+    // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+) => (...params: Fn<P>) => ShaderNodeObject<Node>;

three/examples/jsm/nodes/core/ArrayUniformNode.d.ts

@@ -1,7 +1,7 @@
 import UniformNode from './UniformNode.js';
 import Node from './Node.js';
 
-export default class ArrayUniformNode extends UniformNode {
+export default class ArrayUniformNode extends UniformNode<undefined> {
     isArrayUniformNode: true;
     nodes: Node[];
     constructor(nodes?: Node[]);

three/examples/jsm/nodes/core/AttributeNode.d.ts

@@ -1,9 +1,12 @@
 import { NodeTypeOption } from './constants.js';
 import Node from './Node.js';
 import NodeBuilder from './NodeBuilder.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class AttributeNode extends Node {
     constructor(attributeName: string, nodeType?: NodeTypeOption | null);
     setAttributeName(attributeName: string): this;
     getAttributeName(builder: NodeBuilder): string;
 }
+
+export const attribute: (name: string, nodeType: NodeTypeOption) => ShaderNodeObject<Node>;

three/examples/jsm/nodes/core/BypassNode.d.ts

@@ -1,4 +1,5 @@
 import Node from './Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class BypassNode extends Node {
     isBypassNode: true;
@@ -7,3 +8,5 @@ export default class BypassNode extends Node {
 
     constructor(returnNode: Node, callNode: Node);
 }
+
+export const bypass: (returnNode: NodeRepresentation, callNode: NodeRepresentation) => ShaderNodeObject<BypassNode>;

three/examples/jsm/nodes/core/CacheNode.d.ts

@@ -1,5 +1,6 @@
 import Node from './Node.js';
 import NodeCache from './NodeCache.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class CacheNode extends Node {
     isCacheNode: true;
@@ -8,3 +9,5 @@ export default class CacheNode extends Node {
 
     constructor(node: Node, cache?: NodeCache);
 }
+
+export const cache: (node: Node, cache?: NodeCache) => ShaderNodeObject<CacheNode>;

three/examples/jsm/nodes/core/ConstNode.d.ts

@@ -1,10 +1,10 @@
-import { NodeTypeOption, NodeValueOption } from './constants.js';
+import { NodeTypeOption } from './constants.js';
 import InputNode from './InputNode.js';
 import NodeBuilder from './NodeBuilder.js';
 
-export default class ConstNode extends InputNode {
+export default class ConstNode<Value> extends InputNode<Value> {
     isConstNode: true;
-    constructor(value: NodeValueOption, nodeType?: NodeTypeOption | null);
+    constructor(value: Value, nodeType?: NodeTypeOption | null);
 
     generateConst(builder: NodeBuilder): string;
 }

three/examples/jsm/nodes/core/ContextNode.d.ts

@@ -1,5 +1,6 @@
 import Node from './Node.js';
 import { NodeBuilderContext } from './NodeBuilder.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class ContextNode extends Node {
     isContextNode: true;
@@ -8,3 +9,5 @@ export default class ContextNode extends Node {
 
     constructor(node: Node, context: NodeBuilderContext);
 }
+
+export const context: (node: NodeRepresentation, context: NodeBuilderContext) => ShaderNodeObject<ContextNode>;

three/examples/jsm/nodes/core/InputNode.d.ts

@@ -1,15 +1,15 @@
-import { NodeTypeOption, NodeValueOption } from './constants.js';
+import { NodeTypeOption } from './constants.js';
 import Node from './Node.js';
 import NodeBuilder from './NodeBuilder.js';
 
 export type Precision = 'low' | 'medium' | 'high';
 
-export default abstract class InputNode extends Node {
+export default abstract class InputNode<Value> extends Node {
     isInputNode: true;
-    value: NodeValueOption;
+    value: Value;
     precision: Precision | null;
 
-    constructor(value: NodeValueOption, nodeType?: NodeTypeOption | null);
+    constructor(value: Value, nodeType?: NodeTypeOption | null);
 
     getInputType(builder: NodeBuilder): string | null;
     setPrecision(precision: Precision): this;

three/examples/jsm/nodes/core/NodeBuilder.d.ts

@@ -3,14 +3,12 @@ import {
     Material,
     Object3D,
     Renderer,
-    Scene,
     Texture,
     TextureEncoding,
     WebGLRenderTarget,
 } from '../../../../src/Three.js';
 import FogNode from '../fog/FogNode.js';
 import LightsNode from '../lighting/LightsNode.js';
-import { nodeObject } from '../Nodes.js';
 import { AnyObject, NodeShaderStageOption, NodeTypeOption } from './constants.js';
 import Node from './Node.js';
 import NodeAttribute from './NodeAttribute.js';
@@ -106,7 +104,12 @@ export default abstract class NodeBuilder {
     getVectorFromMatrix(type: NodeTypeOption): NodeTypeOption;
     getDataFromNode(node: Node, shaderStage?: NodeShaderStageOption): NodeData;
     getNodeProperties(node: Node, shaderStage?: NodeShaderStageOption): AnyObject;
-    getUniformFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): NodeUniform;
+    getUniformFromNode(
+        node: Node,
+        type: NodeTypeOption,
+        shaderStage?: NodeShaderStageOption,
+        name?: string | null,
+    ): NodeUniform<string>;
     getVarFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): NodeVar;
     getVaryFromNode(node: Node, type: NodeTypeOption): NodeVarying;
     getCodeFromNode(node: Node, type: NodeTypeOption, shaderStage?: NodeShaderStageOption): string;

three/examples/jsm/nodes/core/NodeUniform.d.ts

@@ -1,13 +1,17 @@
-import { NodeValueOption } from './constants.js';
-import InputNode from './InputNode.js';
+import UniformNode from './UniformNode.js';
+
+export default class NodeUniform<Value> {
+    readonly isNodeUniform: true;
 
-export default class NodeUniform {
-    isNodeUniform: true;
     name: string;
     type: string;
-    node: InputNode;
-    needsUpdate: boolean;
-    value: NodeValueOption;
+    node: UniformNode<Value>;
+    needsUpdate: boolean | undefined;
+
+    constructor(name: string, type: string, node: UniformNode<Value>, needsUpdate?: boolean);
+
+    get(): Value;
+    set value(val: Value);
 
-    constructor(name: string, type: string, node: InputNode, needsUpdate?: boolean);
+    get id(): number;
 }

three/examples/jsm/nodes/core/NodeUtils.d.ts

@@ -1,4 +1,4 @@
-import { NodeValueOption } from './constants.js';
+import { Color, Vector2, Vector3, Vector4, Matrix3, Matrix4 } from '../../../../src/Three.js';
 import Node from './Node.js';
 
 export interface NodeChild {
@@ -9,5 +9,8 @@ export interface NodeChild {
 
 export function getCacheKey(object: Node): string;
 export function getNodeChildren(object: Node): Generator<NodeChild, void>;
-export function getValueType(value: NodeValueOption): string | null;
-export function getValueFromType(type: string, ...params: number[]): NodeValueOption | null;
+export function getValueType(value: unknown): string | null;
+export function getValueFromType(
+    type: string,
+    ...params: number[]
+): Color | Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4 | boolean | number | string | ArrayBufferLike | null;

three/examples/jsm/nodes/core/PropertyNode.d.ts

@@ -1,6 +1,15 @@
 import { NodeTypeOption } from './constants.js';
 import Node from './Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class PropertyNode extends Node {
     constructor(name?: string, nodeType?: NodeTypeOption);
 }
+
+export const property: (name: string, nodeOrType: Node | NodeTypeOption) => ShaderNodeObject<Node>;
+
+export const diffuseColor: ShaderNodeObject<PropertyNode>;
+export const roughness: ShaderNodeObject<PropertyNode>;
+export const metalness: ShaderNodeObject<PropertyNode>;
+export const specularColor: ShaderNodeObject<PropertyNode>;
+export const shininess: ShaderNodeObject<PropertyNode>;

three/examples/jsm/nodes/core/UniformNode.d.ts

@@ -1,10 +1,18 @@
-import { NodeTypeOption, NodeValueOption } from './constants.js';
+import { NodeTypeOption } from './constants.js';
 import InputNode from './InputNode.js';
 import NodeBuilder from './NodeBuilder.js';
+import Node from './Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
-export default class UniformNode extends InputNode {
-    isUniformNode: true;
+export default class UniformNode<Value> extends InputNode<Value> {
+    readonly isUniformNode: true;
+
+    constructor(value: Value, nodeType?: NodeTypeOption | null);
 
-    constructor(value: NodeValueOption, nodeType?: NodeTypeOption | null);
     getUniformHash(builder: NodeBuilder): string;
 }
+
+export const uniform: <Value>(
+    arg1: InputNode<Value> | Value,
+    arg2?: Node | string,
+) => ShaderNodeObject<UniformNode<Value>>;

three/examples/jsm/nodes/core/VarNode.d.ts

@@ -1,5 +1,6 @@
 import { OperatorNodeOp } from '../math/OperatorNode.js';
 import Node from './Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class VarNode extends Node {
     node: Node;
@@ -14,3 +15,6 @@ export default class VarNode extends Node {
     mul(...params: Node[]): this;
     div(...params: Node[]): this;
 }
+
+export const label: (node: NodeRepresentation, name?: string) => ShaderNodeObject<VarNode>;
+export const temp: (node: NodeRepresentation, name?: string) => ShaderNodeObject<VarNode>;

three/examples/jsm/nodes/core/VaryingNode.d.ts

@@ -1,4 +1,5 @@
 import Node from './Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class VaryingNode extends Node {
     node: Node;
@@ -6,3 +7,5 @@ export default class VaryingNode extends Node {
 
     constructor(node: Node, name?: string | null);
 }
+
+export const varying: (node: NodeRepresentation, name?: string) => ShaderNodeObject<VaryingNode>;

three/examples/jsm/nodes/core/constants.d.ts

@@ -1,5 +1,3 @@
-import { Color, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from '../../../../src/Three.js';
-
 // disable automatic export, we have some private declarations
 export const NodeShaderStage: {
     VERTEX: 'vertex';
@@ -13,7 +11,6 @@ export const NodeUpdateType: {
     OBJECT: 'object';
 };
 
-export type NodeValueOption = Color | Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4 | boolean | number;
 export type NodeUpdateTypeOption = 'none' | 'frame' | 'object';
 export type NodeShaderStageOption = 'vertex' | 'fragment' | 'compute';
 export type NodeTypeOption =
@@ -50,8 +47,15 @@ export type NodeTypeOption =
     | 'umat4'
     | 'bmat4';
 
-// can be defined with string template type in Typescript 4.1
-export type SwizzleOption = string;
+export type SwizzleCharacter = 'x' | 'y' | 'z' | 'w' | 'r' | 'g' | 'b' | 'a' | 's' | 't' | 'p' | 'q';
+
+export type SwizzleOption = Exclude<
+    | `${SwizzleCharacter}`
+    | `${SwizzleCharacter}${SwizzleCharacter}`
+    | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}`
+    | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}`,
+    'abs' | 'sqrt'
+>;
 
 /** Should be the same type as Object3D.userData */
 export type NodeUserData = Record<string, any>;

three/examples/jsm/nodes/display/BlendModeNode.d.ts

@@ -1,6 +1,6 @@
 import TempNode from '../core/TempNode.js';
-import { ShaderNode } from '../shadernode/ShaderNodeBaseElements.js';
-import { Node } from '../Nodes.js';
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNode, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export const BurnNode: ShaderNode<{ base: Node; blendNode: Node }>;
 
@@ -30,3 +30,8 @@ export default class BlendModeNode extends TempNode {
 
     setup(): Node;
 }
+
+export const burn: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
+export const dodge: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
+export const overlay: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
+export const screen: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;

three/examples/jsm/nodes/display/ColorAdjustmentNode.d.ts

@@ -1,5 +1,6 @@
 import TempNode from '../core/TempNode.js';
-import { Node } from '../Nodes.js';
+import MathNode from '../math/MathNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type ColorAdjustmentMethod =
     | typeof ColorAdjustmentNode.SATURATION
@@ -18,3 +19,19 @@ export default class ColorAdjustmentNode extends TempNode {
 
     constructor(method: ColorAdjustmentMethod, colorNode: Node, adjustmentNode?: Node);
 }
+
+export const saturation: (
+    colorNode: NodeRepresentation,
+    adjustmentNode?: NodeRepresentation,
+) => ShaderNodeObject<ColorAdjustmentNode>;
+export const vibrance: (
+    colorNode: NodeRepresentation,
+    adjustmentNode?: NodeRepresentation,
+) => ShaderNodeObject<ColorAdjustmentNode>;
+export const hue: (
+    colorNode: NodeRepresentation,
+    adjustmentNode?: NodeRepresentation,
+) => ShaderNodeObject<ColorAdjustmentNode>;
+
+export const lumaCoeffs: ShaderNodeObject<MathNode>;
+export const luminance: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<MathNode>;

three/examples/jsm/nodes/display/ColorSpaceNode.d.ts

@@ -1,5 +1,7 @@
+import { TextureEncoding } from '../../../../src/Three.js';
 import TempNode from '../core/TempNode.js';
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type ColorSpaceNodeMethod =
     | typeof ColorSpaceNode.LINEAR_TO_LINEAR
@@ -16,3 +18,5 @@ export default class ColorSpaceNode extends TempNode {
 
     constructor(method: ColorSpaceNodeMethod | null, node: Node);
 }
+
+export const colorSpace: (node: NodeRepresentation, encoding: TextureEncoding) => ShaderNodeObject<ColorSpaceNode>;

three/examples/jsm/nodes/display/FrontFacingNode.d.ts

@@ -1,6 +1,10 @@
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class FrontFacingNode extends Node {
     isFrontFacingNode: true;
     constructor();
 }
+
+export const frontFacing: ShaderNodeObject<FrontFacingNode>;
+export const faceDirection: ShaderNodeObject<Node>;

three/examples/jsm/nodes/display/NormalMapNode.d.ts

@@ -1,6 +1,8 @@
-import TempNode from '../core/TempNode.js';
 import { NormalMapTypes } from '../../../../src/Three.js';
+import TempNode from '../core/TempNode.js';
 import Node from '../core/Node.js';
+import MathNode from '../math/MathNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class NormalMapNode extends TempNode {
     node: Node;
@@ -10,3 +12,7 @@ export default class NormalMapNode extends TempNode {
 
     constructor(node: Node, scaleNode?: Node | null);
 }
+
+export const normalMap: (node: Node, scaleNode?: Node) => ShaderNodeObject<NormalMapNode>;
+
+export const TBNViewMatrix: ShaderNodeObject<MathNode>;

three/examples/jsm/nodes/display/PosterizeNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class PosterizeNode extends Node {
     sourceNode: Node;
@@ -6,3 +7,8 @@ export default class PosterizeNode extends Node {
 
     constructor(sourceNode: Node, stepsNode: Node);
 }
+
+export const posterize: (
+    sourceNode: NodeRepresentation,
+    stepsNode: NodeRepresentation,
+) => ShaderNodeObject<PosterizeNode>;

three/examples/jsm/nodes/display/ToneMappingNode.d.ts

@@ -1,6 +1,7 @@
+import { ToneMapping } from '../../../../src/Three.js';
 import TempNode from '../core/TempNode.js';
 import Node from '../core/Node.js';
-import { ToneMapping } from '../../../../src/Three.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 // exposure only
 export const LinearToneMappingNode: Node;
@@ -12,3 +13,9 @@ export default class ToneMappingNode extends TempNode {
 
     constructor(toneMapping: ToneMapping, exposureNode?: Node, colorNode?: Node | null);
 }
+
+export const toneMapping: (
+    mapping: ToneMapping,
+    exposure: NodeRepresentation,
+    color?: NodeRepresentation,
+) => ShaderNodeObject<ToneMappingNode>;

three/examples/jsm/nodes/display/ViewportNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type ViewportNodeScope =
     | typeof ViewportNode.COORDINATE
@@ -21,3 +22,10 @@ export default class ViewportNode extends Node {
 
     constructor(scope: ViewportNodeScope);
 }
+
+export const viewportCoordinate: ShaderNodeObject<ViewportNode>;
+export const viewportResolution: ShaderNodeObject<ViewportNode>;
+export const viewportTopLeft: ShaderNodeObject<ViewportNode>;
+export const viewportBottomLeft: ShaderNodeObject<ViewportNode>;
+export const viewportTopRight: ShaderNodeObject<ViewportNode>;
+export const viewportBottomRight: ShaderNodeObject<ViewportNode>;

three/examples/jsm/nodes/fog/FogExp2Node.d.ts

@@ -1,5 +1,6 @@
 import Node from '../core/Node.js';
 import FogNode from './FogNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class FogExp2Node extends FogNode {
     isFogExp2Node: true;
@@ -7,3 +8,5 @@ export default class FogExp2Node extends FogNode {
 
     constructor(colorNode: Node, densityNode: Node);
 }
+
+export const densityFog: (colorNode: Node, densityNode: Node) => ShaderNodeObject<FogExp2Node>;