@types/three 0.183.0 → 0.184.0

three/src/nodes/functions/ShadowMaskModel.d.ts

@@ -1,8 +1,8 @@
 import LightingModel from "../core/LightingModel.js";
-import VarNode from "../core/VarNode.js";
+import Node from "../core/Node.js";
 
 export default class ShadowMaskModel extends LightingModel {
-    shadowNode: VarNode;
+    shadowNode: Node;
 
     constructor();
 }

three/src/nodes/gpgpu/BarrierNode.d.ts

@@ -3,6 +3,8 @@ import Node from "../core/Node.js";
 declare class BarrierNode extends Node {
     scope: string;
 
+    readonly isBarrierNode: boolean;
+
     constructor(scope: string);
 }
 

three/src/nodes/gpgpu/ComputeBuiltinNode.d.ts

@@ -1,13 +1,22 @@
 import Node from "../core/Node.js";
+import { NodeBuilder } from "../Nodes.js";
 
-declare class ComputeBuiltinNode extends Node {
-    constructor(builtinName: string, nodeType: string);
+interface ComputeBuiltinNodeInterface {
+    setBuiltinName(builtinName: string): this;
+    getBuiltinName(builder: NodeBuilder): string;
+    hasBuiltin(builder: NodeBuilder): boolean;
 }
 
+declare const ComputeBuiltinNode: {
+    new<TNodeType>(builtinName: string, nodeType: TNodeType): ComputeBuiltinNode<TNodeType>;
+};
+
+type ComputeBuiltinNode<TNodeType = unknown> = Node<TNodeType> & ComputeBuiltinNodeInterface;
+
 export default ComputeBuiltinNode;
 
-export const numWorkgroups: ComputeBuiltinNode;
-export const workgroupId: ComputeBuiltinNode;
-export const globalId: ComputeBuiltinNode;
-export const localId: ComputeBuiltinNode;
-export const subgroupSize: ComputeBuiltinNode;
+export const numWorkgroups: ComputeBuiltinNode<"uvec3">;
+export const workgroupId: ComputeBuiltinNode<"uvec3">;
+export const globalId: ComputeBuiltinNode<"uvec3">;
+export const localId: ComputeBuiltinNode<"uvec3">;
+export const subgroupSize: ComputeBuiltinNode<"uint">;

three/src/nodes/gpgpu/ComputeNode.d.ts

@@ -1,16 +1,20 @@
 import Renderer from "../../renderers/common/Renderer.js";
 import Node from "../core/Node.js";
+import UniformNode from "../core/UniformNode.js";
 
 export default class ComputeNode extends Node {
-    readonly isComputeNode: true;
+    readonly isComputeNode: boolean;
 
     computeNode: Node;
     workgroupSize: number[];
     count: number | number[] | null;
+    dispatchSize: number | number[] | null;
     name: string;
 
     onInitFunction: ((args: { renderer: Renderer }) => void) | null;
 
+    countNode: UniformNode<"uint", number> | null;
+
     constructor(computeNode: Node, workgroupSize: number[]);
 
     setCount(count: number | number[]): this;
@@ -23,7 +27,7 @@ export default class ComputeNode extends Node {
      */
     label: (name: string) => this;
 
-    onInit(callback: ((args: { renderer: Renderer }) => void) | null): void;
+    onInit(callback: ((args: { renderer: Renderer }) => void) | null): this;
 }
 
 export const computeKernel: (node: Node, workgroupSize?: number[]) => ComputeNode;

three/src/nodes/materialx/lib/mx_noise.d.ts

@@ -1,5 +1,4 @@
 import Node from "../../core/Node.js";
-import VarNode from "../../core/VarNode.js";
 
 export const mx_select: (
     b_immutable: Node | boolean,
@@ -14,7 +13,7 @@ export const mx_negate_if: (
 
 export const mx_floor: (x_immutable: Node | number) => Node;
 
-export const mx_floorfrac: (x_immutable: Node | number, i: VarNode) => Node;
+export const mx_floorfrac: (x_immutable: Node | number, i: Node) => Node;
 
 export const mx_bilerp_0: (
     v0_immutable: Node | number,
@@ -140,9 +139,9 @@ export const mx_gradient_scale3d: (v_immutable: Node | number) => Node;
 export const mx_rotl32: (x_immutable: Node | number, k_immutable: Node | number) => Node;
 
 export const mx_bjmix: (
-    a: VarNode,
-    b: VarNode,
-    c: VarNode,
+    a: Node,
+    b: Node,
+    c: Node,
 ) => Node;
 
 export const mx_bjfinal: (

three/src/nodes/math/MathNode.d.ts

@@ -18,11 +18,17 @@ export type MathNodeMethod1 =
     | typeof MathNode.NORMALIZE
     | typeof MathNode.FRACT
     | typeof MathNode.SIN
+    | typeof MathNode.SINH
     | typeof MathNode.COS
+    | typeof MathNode.COSH
     | typeof MathNode.TAN
+    | typeof MathNode.TANH
     | typeof MathNode.ASIN
+    | typeof MathNode.ASINH
     | typeof MathNode.ACOS
+    | typeof MathNode.ACOSH
     | typeof MathNode.ATAN
+    | typeof MathNode.ATANH
     | typeof MathNode.ABS
     | typeof MathNode.SIGN
     | typeof MathNode.LENGTH
@@ -77,11 +83,17 @@ export default class MathNode extends TempNode {
     static NORMALIZE: "normalize";
     static FRACT: "fract";
     static SIN: "sin";
+    static SINH: "sinh";
     static COS: "cos";
+    static COSH: "cosh";
     static TAN: "tan";
+    static TANH: "tanh";
     static ASIN: "asin";
+    static ASINH: "asinh";
     static ACOS: "acos";
+    static ACOSH: "acosh";
     static ATAN: "atan";
+    static ATANH: "atanh";
     static ABS: "abs";
     static SIGN: "sign";
     static LENGTH: "length";
@@ -236,20 +248,66 @@ declare module "../core/Node.js" {
     }
 }
 
-export const sin: (x: FloatOrNumber) => Node<"float">;
-export const cos: (x: FloatOrNumber) => Node<"float">;
-export const tan: (x: FloatOrNumber) => Node<"float">;
-export const asin: (x: FloatOrNumber) => Node<"float">;
-export const acos: (x: FloatOrNumber) => Node<"float">;
-export const atan: (y: FloatOrNumber, x?: FloatOrNumber) => Node<"float">;
+interface TrigonometricFunction {
+    (x: FloatOrNumber): Node<"float">;
+    (x: Node<"vec2">): Node<"vec2">;
+    (x: Node<"vec3">): Node<"vec3">;
+    (x: Node<"vec4">): Node<"vec4">;
+}
+interface ArcTanFunction {
+    (y: FloatOrNumber, x?: FloatOrNumber): Node<"float">;
+    (y: Node<"vec2">, x?: Vec2OrLessOrFloat): Node<"vec2">;
+    (y: Node<"vec3">, x?: Vec3OrLessOrFloat): Node<"vec3">;
+    (y: Node<"vec4">, x?: Vec4OrLessOrFloat): Node<"vec4">;
+}
+export const sin: TrigonometricFunction;
+export const sinh: TrigonometricFunction;
+export const cos: TrigonometricFunction;
+export const cosh: TrigonometricFunction;
+export const tan: TrigonometricFunction;
+export const tanh: TrigonometricFunction;
+export const asin: TrigonometricFunction;
+export const asinh: TrigonometricFunction;
+export const acos: TrigonometricFunction;
+export const acosh: TrigonometricFunction;
+export const atan: ArcTanFunction;
+export const atanh: TrigonometricFunction;
 declare module "../core/Node.js" {
     interface FloatExtensions {
         sin: () => Node<"float">;
+        sinh: () => Node<"float">;
         cos: () => Node<"float">;
+        cosh: () => Node<"float">;
         tan: () => Node<"float">;
+        tanh: () => Node<"float">;
         asin: () => Node<"float">;
+        asinh: () => Node<"float">;
         acos: () => Node<"float">;
+        acosh: () => Node<"float">;
         atan: (x?: FloatOrNumber) => Node<"float">;
+        atanh: () => Node<"float">;
+    }
+    interface FloatVecExtensions<TVec extends FloatVecType> {
+        sin: () => Node<TVec>;
+        sinh: () => Node<TVec>;
+        cos: () => Node<TVec>;
+        cosh: () => Node<TVec>;
+        tan: () => Node<TVec>;
+        tanh: () => Node<TVec>;
+        asin: () => Node<TVec>;
+        asinh: () => Node<TVec>;
+        acos: () => Node<TVec>;
+        acosh: () => Node<TVec>;
+        atanh: () => Node<TVec>;
+    }
+    interface Vec2Extensions {
+        atan: (x?: Vec2OrLessOrFloat) => Node<"vec2">;
+    }
+    interface Vec3Extensions {
+        atan: (x?: Vec3OrLessOrFloat) => Node<"vec3">;
+    }
+    interface Vec4Extensions {
+        atan: (x?: Vec4OrLessOrFloat) => Node<"vec4">;
     }
 }
 

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

@@ -21,7 +21,7 @@ export * from "../math/MathNode.js";
 export * from "../math/OperatorNode.js";
 export * from "../utils/DebugNode.js";
 export * from "../utils/Discard.js";
-export * from "../utils/RemapNode.js";
+export * from "../utils/Remap.js";
 export * from "./TSLCore.js";
 
 /**