@types/three 0.182.0 → 0.183.1

three/src/nodes/core/NodeUniform.d.ts

@@ -1,16 +1,13 @@
+import UniformGroupNode from "./UniformGroupNode.js";
 import UniformNode from "./UniformNode.js";
+
 /**
  * {@link NodeBuilder} is going to create instances of this class during the build process
  * of nodes. They represent the final shader uniforms that are going to be generated
  * by the builder. A dictionary of node uniforms is maintained in {@link NodeBuilder#uniforms}
  * for this purpose.
  */
-declare class NodeUniform<TValue> {
-    readonly isNodeUniform: true;
-    name: string;
-    type: string | null;
-    node: UniformNode<TValue>;
-    needsUpdate: boolean | undefined;
+declare class NodeUniform<TNodeType, TValue> {
     /**
      * Constructs a new node uniform.
      *
@@ -18,14 +15,40 @@ declare class NodeUniform<TValue> {
      * @param {string} type - The type of the uniform.
      * @param {UniformNode} node - An reference to the node.
      */
-    constructor(name: string, type: string | null, node: UniformNode<TValue>);
+    constructor(name: string, type: string, node: UniformNode<TNodeType, TValue>);
+    /**
+     * This flag can be used for type testing.
+     *
+     * @type {boolean}
+     * @readonly
+     * @default true
+     */
+    readonly isNodeUniform: boolean;
+    /**
+     * The name of the uniform.
+     *
+     * @type {string}
+     */
+    name: string;
+    /**
+     * The type of the uniform.
+     *
+     * @type {string}
+     */
+    type: string;
+    /**
+     * An reference to the node.
+     *
+     * @type {UniformNode}
+     */
+    node: UniformNode<TNodeType, TValue>;
+    set value(val: TValue);
     /**
      * The value of the uniform node.
      *
      * @type {any}
      */
     get value(): TValue;
-    set value(val: TValue);
     /**
      * The id of the uniform node.
      *
@@ -37,6 +60,7 @@ declare class NodeUniform<TValue> {
      *
      * @type {UniformGroupNode}
      */
-    get groupNode(): import("./UniformGroupNode.js").default;
+    get groupNode(): UniformGroupNode;
 }
+
 export default NodeUniform;

three/src/nodes/core/NodeVar.d.ts

@@ -5,11 +5,6 @@
  * this purpose.
  */
 declare class NodeVar {
-    readonly isNodeVar: true;
-    name: string;
-    type: string;
-    readOnly: boolean;
-    count: number | null;
     /**
      * Constructs a new node variable.
      *
@@ -19,5 +14,38 @@ declare class NodeVar {
      * @param {?number} [count=null] - The size.
      */
     constructor(name: string, type: string, readOnly?: boolean, count?: number | null);
+    /**
+     * This flag can be used for type testing.
+     *
+     * @type {boolean}
+     * @readonly
+     * @default true
+     */
+    readonly isNodeVar: boolean;
+    /**
+     * The name of the variable.
+     *
+     * @type {string}
+     */
+    name: string;
+    /**
+     * The type of the variable.
+     *
+     * @type {string}
+     */
+    type: string;
+    /**
+     *  The read-only flag.
+     *
+     * @type {boolean}
+     */
+    readOnly: boolean;
+    /**
+     * The size.
+     *
+     * @type {?number}
+     */
+    count: number | null;
 }
+
 export default NodeVar;

three/src/nodes/core/NodeVarying.d.ts

@@ -1,5 +1,6 @@
 import { InterpolationSamplingMode, InterpolationSamplingType } from "../../constants.js";
 import NodeVar from "./NodeVar.js";
+
 /**
  * {@link NodeBuilder} is going to create instances of this class during the build process
  * of nodes. They represent the final shader varyings that are going to be generated
@@ -9,10 +10,6 @@ import NodeVar from "./NodeVar.js";
  * @augments NodeVar
  */
 declare class NodeVarying extends NodeVar {
-    needsInterpolation: boolean;
-    readonly isNodeVarying: true;
-    interpolationType: InterpolationSamplingType | null;
-    interpolationSampling: InterpolationSamplingMode | null;
     /**
      * Constructs a new node varying.
      *
@@ -27,5 +24,36 @@ declare class NodeVarying extends NodeVar {
         interpolationType?: InterpolationSamplingType | null,
         interpolationSampling?: InterpolationSamplingMode | null,
     );
+    /**
+     * Whether this varying requires interpolation or not. This property can be used
+     * to check if the varying can be optimized for a variable.
+     *
+     * @type {boolean}
+     * @default false
+     */
+    needsInterpolation: boolean;
+    /**
+     * This flag can be used for type testing.
+     *
+     * @type {boolean}
+     * @readonly
+     * @default true
+     */
+    readonly isNodeVarying: boolean;
+    /**
+     * The interpolation type of the varying data.
+     *
+     * @type {?string}
+     * @default null
+     */
+    interpolationType: InterpolationSamplingType | null;
+    /**
+     * The interpolation sampling type of varying data.
+     *
+     * @type {?string}
+     * @default null
+     */
+    interpolationSampling: InterpolationSamplingMode | null;
 }
+
 export default NodeVarying;

three/src/nodes/core/ParameterNode.d.ts

@@ -1,11 +1,18 @@
 import PropertyNode from "./PropertyNode.js";
 
-declare class ParameterNode extends PropertyNode {
+interface ParameterNodeInterface {
     readonly isParameterNode: true;
-
-    constructor(nodeType: string, name?: string | null);
 }
 
+declare const ParameterNode: {
+    new<TNodeType>(
+        nodeType: TNodeType,
+        name?: string | null,
+    ): ParameterNode<TNodeType>;
+};
+
+type ParameterNode<TNodeType> = PropertyNode<TNodeType> & ParameterNodeInterface;
+
 export default ParameterNode;
 
-export const parameter: (type: string, name?: string | null) => ParameterNode;
+export const parameter: <TNodeType>(type: TNodeType, name?: string | null) => ParameterNode<TNodeType>;

three/src/nodes/core/PropertyNode.d.ts

@@ -1,44 +1,54 @@
 import Node from "./Node.js";
 
-export default class PropertyNode extends Node {
+interface PropertyNodeInterface {
     name: string | null;
     varying: boolean;
 
     readonly isPropertyNode: true;
-
-    constructor(nodeType?: string | null, name?: string | null, varying?: boolean);
 }
 
-export const property: (type?: string | null, name?: string | null) => PropertyNode;
-export const varyingProperty: (type?: string | null, name?: string | null) => PropertyNode;
+declare const PropertyNode: {
+    new<TNodeType>(
+        nodeType: TNodeType,
+        name?: string | null,
+        varying?: boolean,
+    ): PropertyNode<TNodeType>;
+};
+
+type PropertyNode<TNodeType> = Node<TNodeType> & PropertyNodeInterface;
+
+export default PropertyNode;
+
+export const property: <const TNodeType>(type: TNodeType, name?: string | null) => PropertyNode<TNodeType>;
+export const varyingProperty: <const TNodeType>(type: TNodeType, name?: string | null) => PropertyNode<TNodeType>;
 
-export const diffuseColor: PropertyNode;
-export const diffuseContribution: PropertyNode;
-export const emissive: PropertyNode;
-export const roughness: PropertyNode;
-export const metalness: PropertyNode;
-export const clearcoat: PropertyNode;
-export const clearcoatRoughness: PropertyNode;
-export const sheen: PropertyNode;
-export const sheenRoughness: PropertyNode;
-export const iridescence: PropertyNode;
-export const iridescenceIOR: PropertyNode;
-export const iridescenceThickness: PropertyNode;
-export const alphaT: PropertyNode;
-export const anisotropy: PropertyNode;
-export const anisotropyT: PropertyNode;
-export const anisotropyB: PropertyNode;
-export const specularColor: PropertyNode;
-export const specularColorBlended: PropertyNode;
-export const specularF90: PropertyNode;
-export const shininess: PropertyNode;
-export const output: PropertyNode;
-export const dashSize: PropertyNode;
-export const gapSize: PropertyNode;
-export const pointWidth: PropertyNode;
-export const ior: PropertyNode;
-export const transmission: PropertyNode;
-export const thickness: PropertyNode;
-export const attenuationDistance: PropertyNode;
-export const attenuationColor: PropertyNode;
-export const dispersion: PropertyNode;
+export const diffuseColor: PropertyNode<"vec4">;
+export const diffuseContribution: PropertyNode<"vec3">;
+export const emissive: PropertyNode<"vec3">;
+export const roughness: PropertyNode<"float">;
+export const metalness: PropertyNode<"float">;
+export const clearcoat: PropertyNode<"float">;
+export const clearcoatRoughness: PropertyNode<"float">;
+export const sheen: PropertyNode<"vec3">;
+export const sheenRoughness: PropertyNode<"float">;
+export const iridescence: PropertyNode<"float">;
+export const iridescenceIOR: PropertyNode<"float">;
+export const iridescenceThickness: PropertyNode<"float">;
+export const alphaT: PropertyNode<"float">;
+export const anisotropy: PropertyNode<"float">;
+export const anisotropyT: PropertyNode<"vec3">;
+export const anisotropyB: PropertyNode<"vec3">;
+export const specularColor: PropertyNode<"color">;
+export const specularColorBlended: PropertyNode<"color">;
+export const specularF90: PropertyNode<"float">;
+export const shininess: PropertyNode<"float">;
+export const output: PropertyNode<"vec4">;
+export const dashSize: PropertyNode<"float">;
+export const gapSize: PropertyNode<"float">;
+export const pointWidth: PropertyNode<"float">;
+export const ior: PropertyNode<"float">;
+export const transmission: PropertyNode<"float">;
+export const thickness: PropertyNode<"float">;
+export const attenuationDistance: PropertyNode<"float">;
+export const attenuationColor: PropertyNode<"color">;
+export const dispersion: PropertyNode<"float">;

three/src/nodes/core/StackTrace.d.ts

@@ -0,0 +1,9 @@
+declare class StackTrace {
+    readonly isStackTrace: true;
+
+    stack: Array<{ fn: string; file: string; line: number; column: number }>;
+
+    constructor(stackMessage?: Error | string | null);
+}
+
+export default StackTrace;

three/src/nodes/core/StructType.d.ts

@@ -1,8 +1,10 @@
 import { MemberLayout } from "./StructTypeNode.js";
+
 declare class StructType {
+    constructor(name: string, members: MemberLayout[]);
     name: string;
     members: MemberLayout[];
     output: boolean;
-    constructor(name: string, members: MemberLayout[]);
 }
+
 export default StructType;

three/src/nodes/core/StructTypeNode.d.ts

@@ -1,16 +1,19 @@
 import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
+
 export interface MembersLayout {
     [name: string]: string | {
         type: string;
         atomic?: boolean;
     };
 }
+
 export interface MemberLayout {
     name: string;
     type: string;
     atomic: boolean;
 }
+
 /**
  * Represents a struct type node in the node-based system.
  * This class is used to define and manage the layout and types of struct members.
@@ -20,10 +23,6 @@ export interface MemberLayout {
  * @augments Node
  */
 declare class StructTypeNode extends Node {
-    static get type(): string;
-    membersLayout: MemberLayout[];
-    name: string | null;
-    readonly isStructLayoutNode: true;
     /**
      * Creates an instance of StructTypeNode.
      *
@@ -31,6 +30,20 @@ declare class StructTypeNode extends Node {
      * @param {?string} [name=null] - The optional name of the struct.
      */
     constructor(membersLayout: MembersLayout, name?: string | null);
+    /**
+     * The layout of the members for the struct
+     *
+     * @type {Array.<{name: string, type: string, atomic: boolean}>}
+     */
+    membersLayout: Array<MemberLayout>;
+    /**
+     * This flag can be used for type testing.
+     *
+     * @type {boolean}
+     * @readonly
+     * @default true
+     */
+    readonly isStructLayoutNode: boolean;
     /**
      * Returns the length of the struct.
      * The length is calculated by summing the lengths of the struct's members.
@@ -40,7 +53,8 @@ declare class StructTypeNode extends Node {
     getLength(): number;
     getMemberType(builder: NodeBuilder, name: string): string;
     getNodeType(builder: NodeBuilder): string;
-    setup(builder: NodeBuilder): void;
+    setup(builder: NodeBuilder): undefined;
     generate(builder: NodeBuilder): string;
 }
+
 export default StructTypeNode;

three/src/nodes/core/TempNode.d.ts

@@ -1,10 +1,16 @@
 import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
 
-export default class TempNode extends Node {
+interface TempNodeInterface {
     isTempNode: true;
 
-    constructor(type: string | null);
-
     hasDependencies(builder: NodeBuilder): boolean;
 }
+
+declare const TempNode: {
+    new<TNodeType = unknown>(type?: TNodeType | null): TempNode<TNodeType>;
+};
+
+type TempNode<TNodeType> = Node<TNodeType> & TempNodeInterface;
+
+export default TempNode;

three/src/nodes/core/UniformNode.d.ts

@@ -1,33 +1,45 @@
+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 { NodeUpdateType } from "./constants.js";
 import InputNode from "./InputNode.js";
-import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
 import NodeFrame from "./NodeFrame.js";
 import UniformGroupNode from "./UniformGroupNode.js";
+
 /**
  * Class for representing a uniform.
  *
  * @augments InputNode
  */
-declare class UniformNode<TValue> extends InputNode<TValue> {
-    static get type(): string;
-    readonly isUniformNode: true;
-    name: string;
-    groupNode: UniformGroupNode;
+declare class UniformNodeClass<TValue> extends InputNode<unknown, TValue> {
     /**
-     * Constructs a new uniform node.
+     * This flag can be used for type testing.
      *
-     * @param {any} value - The value of this node. Usually a JS primitive or three.js object (vector, matrix, color, texture).
-     * @param {?string} nodeType - The node type. If no explicit type is defined, the node tries to derive the type from its value.
+     * @type {boolean}
+     * @readonly
+     * @default true
      */
-    constructor(value: TValue, nodeType?: string | null);
+    readonly isUniformNode: boolean;
+    /**
+     * The uniform group of this uniform. By default, uniforms are
+     * managed per object but they might belong to a shared group
+     * which is updated per frame or render call.
+     *
+     * @type {UniformGroupNode}
+     */
+    groupNode: UniformGroupNode;
     /**
      * Sets the {@link UniformNode#name} property.
      *
      * @param {string} name - The name of the uniform.
      * @return {UniformNode} A reference to this node.
      */
-    setName: (name: string) => this;
+    setName(name: string): this;
     /**
      * Sets the {@link UniformNode#name} property.
      *
@@ -35,7 +47,7 @@ declare class UniformNode<TValue> extends InputNode<TValue> {
      * @param {string} name - The name of the uniform.
      * @return {UniformNode} A reference to this node.
      */
-    label: (name: string) => this;
+    label(name: string): this;
     /**
      * Sets the {@link UniformNode#groupNode} property.
      *
@@ -58,17 +70,43 @@ declare class UniformNode<TValue> extends InputNode<TValue> {
      */
     getUniformHash(builder: NodeBuilder): string;
     onUpdate(callback: (frame: NodeFrame, self: this) => TValue | undefined, updateType: NodeUpdateType): this;
-    getInputType(builder: NodeBuilder): string | null;
+    getInputType(builder: NodeBuilder): string;
     generate(builder: NodeBuilder, output: string | null): string;
 }
+
+declare const UniformNode: {
+    /**
+     * Constructs a new uniform node.
+     *
+     * @param {any} value - The value of this node. Usually a JS primitive or three.js object (vector, matrix, color, texture).
+     * @param {?string} nodeType - The node type. If no explicit type is defined, the node tries to derive the type from its value.
+     */
+    new<TNodeType, TValue>(value: TValue, nodeType?: string | null): UniformNode<TNodeType, TValue>;
+};
+
+type UniformNode<TNodeType, TValue> = UniformNodeClass<TValue> & InputNode<TNodeType, TValue>;
+
 export default UniformNode;
+
+interface Uniform {
+    (value: number, type?: "float"): UniformNode<"float", number>;
+    (value: boolean): UniformNode<"bool", boolean>;
+    (value: Vector2): UniformNode<"vec2", Vector2>;
+    (value: Vector3): UniformNode<"vec3", Vector3>;
+    (value: Vector4): UniformNode<"vec4", Vector4>;
+    (value: Matrix2): UniformNode<"mat2", Matrix2>;
+    (value: Matrix3): UniformNode<"mat3", Matrix3>;
+    (value: Matrix4): UniformNode<"mat4", Matrix4>;
+    (value: Color): UniformNode<"color", Color>;
+    <TNodeType, TValue>(value: InputNode<TNodeType, TValue>): UniformNode<TNodeType, TValue>;
+}
+
 /**
  * TSL function for creating a uniform node.
  *
- * @tsl
  * @function
  * @param {any|string} value - The value of this uniform or your type. Usually a JS primitive or three.js object (vector, matrix, color, texture).
  * @param {string} [type] - The node type. If no explicit type is defined, the node tries to derive the type from its value.
  * @returns {UniformNode}
  */
-export declare const uniform: <TValue>(value: InputNode<TValue> | TValue, type?: Node | string) => UniformNode<TValue>;
+export declare const uniform: Uniform;

three/src/nodes/core/VarNode.d.ts

@@ -1,6 +1,6 @@
 import Node from "./Node.js";
 
-declare class VarNode extends Node {
+interface VarNodeInterface {
     node: Node;
     name: string | null;
 
@@ -10,29 +10,30 @@ declare class VarNode extends Node {
 
     intent: boolean;
 
-    constructor(node: Node, name?: string | null, readOnly?: boolean);
-
     setIntent(value: boolean): this;
     getIntent(): boolean;
 }
 
+declare const VarNode: {
+    new<TNodeType>(node: Node<TNodeType>, name?: string | null, readOnly?: boolean): VarNode<TNodeType>;
+};
+
+type VarNode<TNodeType = unknown> = Node<TNodeType> & VarNodeInterface;
+
 export default VarNode;
 
-export const Var: (node: Node, name?: string | null) => VarNode;
+export const Var: <TNodeType>(node: Node<TNodeType>, name?: string | null) => VarNode<TNodeType>;
 
-export const Const: (node: Node, name?: string | null) => VarNode;
+export const Const: <TNodeType>(node: Node<TNodeType>, name?: string | null) => VarNode<TNodeType>;
 
-export const VarIntent: (node: Node) => Node;
+export const VarIntent: <TNodeType>(node: Node<TNodeType>) => Node<TNodeType>;
 
-declare module "../Nodes.js" {
-    interface Node {
-        toVar: (name?: string | null) => VarNode;
-        toVarAssign: (name?: string | null) => this;
+declare module "./Node.js" {
+    interface NodeExtensions<TNodeType> {
+        toVar: (name?: string | null) => VarNode<TNodeType>;
 
-        toConst: (name?: string | null) => VarNode;
-        toConstAssign: (name?: string | null) => this;
+        toConst: (name?: string | null) => VarNode<TNodeType>;
 
-        toVarIntent: () => Node;
-        toVarIntentAssign: () => this;
+        toVarIntent: () => Node<TNodeType>;
     }
 }

three/src/nodes/core/VaryingNode.d.ts

@@ -3,39 +3,34 @@ import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
 import NodeVarying from "./NodeVarying.js";
 
-export default class VaryingNode extends Node {
+interface VaryingNodeInterface {
     node: Node;
     name: string | null;
     readonly isVaryingNode: true;
     interpolationType: InterpolationSamplingType | null;
     interpolationSampling: InterpolationSamplingMode | null;
 
-    constructor(node: Node, name?: string | null);
-
     setInterpolation(type: InterpolationSamplingType | null, sampling?: InterpolationSamplingMode | null): this;
 
     setupVarying(builder: NodeBuilder): NodeVarying;
 }
 
-export const varying: (node: Node, name?: string) => VaryingNode;
+declare const VaryingNode: {
+    new<TNodeType>(node: Node<TNodeType>, name?: string | null): VaryingNode<TNodeType>;
+};
+
+type VaryingNode<TNodeType> = VaryingNodeInterface & Node<TNodeType>;
+
+export default VaryingNode;
 
-export const vertexStage: (node: Node) => VaryingNode;
+export const varying: <TNodeType>(node: Node<TNodeType>, name?: string) => VaryingNode<TNodeType>;
 
-declare module "../Nodes.js" {
-    interface Node {
-        toVarying: (name?: string) => VaryingNode;
-        toVaryingAssign: (name?: string) => this;
+export const vertexStage: <TNodeType>(node: Node<TNodeType>) => VaryingNode<TNodeType>;
 
-        toVertexStage: () => VaryingNode;
-        toVertexStageAssign: () => this;
+declare module "./Node.js" {
+    interface NodeExtensions<TNodeType> {
+        toVarying: (name?: string) => VaryingNode<TNodeType>;
 
-        /**
-         * @deprecated .vertexStage() has been renamed to .toVertexStage().
-         */
-        vertexStage: () => VaryingNode;
-        /**
-         * @deprecated .vertexStage() has been renamed to .toVertexStage().
-         */
-        vertexStageAssign: () => this;
+        toVertexStage: () => VaryingNode<TNodeType>;
     }
 }

three/src/nodes/core/constants.d.ts

@@ -4,10 +4,11 @@
  * @property {string} VERTEX The vertex shader stage.
  * @property {string} FRAGMENT The fragment shader stage.
  */
-export declare const NodeShaderStage: {
+export const NodeShaderStage: {
     readonly VERTEX: "vertex";
     readonly FRAGMENT: "fragment";
 };
+
 /**
  * Update types of a node.
  *
@@ -16,12 +17,13 @@ export declare const NodeShaderStage: {
  * @property {string} RENDER The update method is executed per render. A frame might be produced by multiple render calls so this value allows more detailed updates than FRAME.
  * @property {string} OBJECT The update method is executed per {@link Object3D} that uses the node for rendering.
  */
-export declare const NodeUpdateType: {
+export const NodeUpdateType: {
     readonly NONE: "none";
     readonly FRAME: "frame";
     readonly RENDER: "render";
     readonly OBJECT: "object";
 };
+
 /**
  * Data types of a node.
  *
@@ -35,7 +37,7 @@ export declare const NodeUpdateType: {
  * @property {string} MATRIX3 3x3 matrix type.
  * @property {string} MATRIX4 4x4 matrix type.
  */
-export declare const NodeType: {
+export const NodeType: {
     readonly BOOLEAN: "bool";
     readonly INTEGER: "int";
     readonly FLOAT: "float";
@@ -46,6 +48,7 @@ export declare const NodeType: {
     readonly MATRIX3: "mat3";
     readonly MATRIX4: "mat4";
 };
+
 /**
  * Access types of a node. These are relevant for compute and storage usage.
  *
@@ -53,14 +56,16 @@ export declare const NodeType: {
  * @property {string} WRITE_ONLY Write-only access.
  * @property {string} READ_WRITE Read and write access.
  */
-export declare const NodeAccess: {
+export const NodeAccess: {
     readonly READ_ONLY: "readOnly";
     readonly WRITE_ONLY: "writeOnly";
     readonly READ_WRITE: "readWrite";
 };
+
 export type NodeShaderStage = "vertex" | "fragment" | "compute";
 export type NodeUpdateType = "none" | "frame" | "render" | "object";
 export type NodeAccess = "readOnly" | "writeOnly" | "readWrite";
+
 export declare const defaultShaderStages: NodeShaderStage[];
 export declare const defaultBuildStages: string[];
 export declare const shaderStages: NodeShaderStage[];