@types/three 0.178.1 → 0.180.0

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

@@ -139,13 +139,6 @@ declare class Node extends EventDispatcher<{
      * @return {Node} A reference to this node.
      */
     onReference(callback: (this: this, frame: NodeBuilder | NodeFrame) => unknown): this;
-    /**
-     * The `this` reference might point to a Proxy so this method can be used
-     * to get the reference to the actual node instance.
-     *
-     * @return {Node} A reference to the node.
-     */
-    getSelf(): this;
     /**
      * Nodes might refer to other objects like materials. This method allows to dynamically update the reference
      * to such objects based on a given state (e.g. the current node frame or builder).
@@ -267,10 +260,17 @@ declare class Node extends EventDispatcher<{
      * @return {Node} The shared node if possible. Otherwise `this` is returned.
      */
     getShared(builder: NodeBuilder): Node;
+    /**
+     * Returns the number of elements in the node array.
+     *
+     * @param {NodeBuilder} builder - The current node builder.
+     * @return {?number} The number of elements in the node array.
+     */
+    getArrayCount(builder: NodeBuilder): number | null;
     /**
      * Represents the setup stage which is the first step of the build process, see {@link Node#build} method.
-     * This method is often overwritten in derived modules to prepare the node which is used as the output/result.
-     * The output node must be returned in the `return` statement.
+     * This method is often overwritten in derived modules to prepare the node which is used as a node's output/result.
+     * If an output node is prepared, then it must be returned in the `return` statement of the derived module's setup function.
      *
      * @param {NodeBuilder} builder - The current node builder.
      * @return {?Node} The output node.
@@ -289,7 +289,7 @@ declare class Node extends EventDispatcher<{
      * This state builds the output node and returns the resulting shader string.
      *
      * @param {NodeBuilder} builder - The current node builder.
-     * @param {?string} output - Can be used to define the output type.
+     * @param {?string} [output] - Can be used to define the output type.
      * @return {?string} The generated shader string.
      */
     generate(builder: NodeBuilder, output?: string | null): string | null | undefined;
@@ -327,14 +327,14 @@ declare class Node extends EventDispatcher<{
      * - **generate**: Generates the shader code for the node. Returns the generated shader string.
      *
      * @param {NodeBuilder} builder - The current node builder.
-     * @param {string|Node|null} [output=null] - Can be used to define the output type.
-     * @return {Node|string|null} The result of the build process, depending on the build stage.
+     * @param {?(string|Node)} [output=null] - Can be used to define the output type.
+     * @return {?(Node|string)} The result of the build process, depending on the build stage.
      */
     build(builder: NodeBuilder, output?: string | Node | null): Node | string | null;
     /**
      * Returns the child nodes as a JSON object.
      *
-     * @return {Array<Object>} An iterable list of serialized child objects as JSON.
+     * @return {Generator<Object>} An iterable list of serialized child objects as JSON.
      */
     getSerializeChildren(): Generator<import("./NodeUtils.js").NodeChild, void, unknown>;
     /**

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

@@ -27,6 +27,14 @@ declare class UniformNode<TValue> extends InputNode<TValue> {
      * @param {string} name - The name of the uniform.
      * @return {UniformNode} A reference to this node.
      */
+    setName(name: string): this;
+    /**
+     * Sets the {@link UniformNode#name} property.
+     *
+     * @deprecated
+     * @param {string} name - The name of the uniform.
+     * @return {UniformNode} A reference to this node.
+     */
     label(name: string): this;
     /**
      * Sets the {@link UniformNode#groupNode} property.
@@ -50,6 +58,7 @@ 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;
     generate(builder: NodeBuilder, output: string | null): string;
 }
 export default UniformNode;
@@ -58,11 +67,11 @@ export default UniformNode;
  *
  * @tsl
  * @function
- * @param {any} arg1 - The value of this node. Usually a JS primitive or three.js object (vector, matrix, color, texture).
- * @param {string} [arg2] - The node type. If no explicit type is defined, the node tries to derive the type from its value.
+ * @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>(
-    arg1: InputNode<TValue> | TValue,
-    arg2?: Node | string,
+    value: InputNode<TValue> | TValue,
+    type?: Node | string,
 ) => import("../tsl/TSLCore.js").ShaderNodeObject<UniformNode<TValue>>;

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

@@ -1,7 +1,7 @@
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
-export default class VarNode extends Node {
+declare class VarNode extends Node {
     node: Node;
     name: string | null;
 
@@ -9,30 +9,26 @@ export default class VarNode extends Node {
 
     readOnly: boolean;
 
+    intent: boolean;
+
     constructor(node: Node, name?: string | null, readOnly?: boolean);
+
+    setIntent(value: boolean): this;
+    getIntent(): boolean;
 }
 
+export default VarNode;
+
 export const Var: (node: Node, name?: string | null) => ShaderNodeObject<VarNode>;
 
 export const Const: (node: Node, name?: string | null) => ShaderNodeObject<VarNode>;
 
+export const VarIntent: (node: Node) => Node;
+
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {
         toVar: (node: Node, name?: string | null) => ShaderNodeObject<VarNode>;
         toConst: (node: Node, name?: string | null) => ShaderNodeObject<VarNode>;
-    }
-}
-
-/**
- * @deprecated Use ".toVar()" instead.
- */
-export const temp: (node: Node, name?: string | null) => ShaderNodeObject<VarNode>;
-
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        /**
-         * @deprecated Use ".toVar()" instead.
-         */
-        temp: typeof temp;
+        toVarIntent: (node: Node) => Node;
     }
 }

three/src/nodes/display/PassNode.d.ts

@@ -1,6 +1,8 @@
 import { Camera } from "../../cameras/Camera.js";
 import { Layers } from "../../core/Layers.js";
 import { RenderTarget, RenderTargetOptions } from "../../core/RenderTarget.js";
+import { Vector4 } from "../../math/Vector4.js";
+import Renderer from "../../renderers/common/Renderer.js";
 import { Scene } from "../../scenes/Scene.js";
 import { Texture } from "../../textures/Texture.js";
 import TextureNode from "../accessors/TextureNode.js";
@@ -61,8 +63,16 @@ declare class PassNode extends TempNode {
 
     getLinearDepthNode(name?: string): ShaderNodeObject<Node>;
 
+    compileAsync(renderer: Renderer): Promise<void>;
+
     setSize(width: number, height: number): void;
 
+    setScissor(x: number, y: number, width: number, height: number): void;
+    setScissor(x: Vector4): void;
+
+    setViewport(x: number, y: number, width: number, height: number): void;
+    setViewport(x: Vector4): void;
+
     setPixelRatio(pixelRatio: number): void;
 
     dispose(): void;

three/src/nodes/display/ScreenNode.d.ts

@@ -5,7 +5,8 @@ export type ScreenNodeScope =
     | typeof ScreenNode.COORDINATE
     | typeof ScreenNode.VIEWPORT
     | typeof ScreenNode.SIZE
-    | typeof ScreenNode.UV;
+    | typeof ScreenNode.UV
+    | typeof ScreenNode.DPR;
 
 declare class ScreenNode extends Node {
     scope: ScreenNodeScope;
@@ -18,12 +19,14 @@ declare class ScreenNode extends Node {
     static VIEWPORT: "viewport";
     static SIZE: "size";
     static UV: "uv";
+    static DPR: "dpr";
 }
 
 export default ScreenNode;
 
 // Screen
 
+export const screenDPR: ShaderNodeObject<ScreenNode>;
 export const screenUV: ShaderNodeObject<ScreenNode>;
 export const screenSize: ShaderNodeObject<ScreenNode>;
 export const screenCoordinate: ShaderNodeObject<ScreenNode>;

three/src/nodes/display/ToneMappingNode.d.ts

@@ -16,7 +16,7 @@ export default ToneMappingNode;
 
 export const toneMapping: (
     mapping: ToneMapping,
-    exposure: Node,
+    exposure: Node | number,
     color?: Node,
 ) => ShaderNodeObject<ToneMappingNode>;
 export const toneMappingExposure: ShaderNodeObject<RendererReferenceNode>;
@@ -26,7 +26,7 @@ declare module "../tsl/TSLCore.js" {
         toneMapping: (
             color: Node,
             mapping?: ToneMapping,
-            exposure?: Node,
+            exposure?: Node | number,
         ) => ShaderNodeObject<ToneMappingNode>;
     }
 }

three/src/nodes/display/ViewportDepthTextureNode.d.ts

@@ -1,9 +1,12 @@
+import { DepthTexture } from "../../textures/DepthTexture.js";
 import Node from "../core/Node.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import ViewportTextureNode from "./ViewportTextureNode.js";
 
 declare class ViewportDepthTextureNode extends ViewportTextureNode {
     constructor(uvNode?: Node, levelNode?: Node | null);
+
+    getTextureForReference(): DepthTexture;
 }
 
 export default ViewportDepthTextureNode;

three/src/nodes/display/ViewportSharedTextureNode.d.ts

@@ -1,9 +1,12 @@
+import { FramebufferTexture } from "../../textures/FramebufferTexture.js";
 import Node from "../core/Node.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import ViewportTextureNode from "./ViewportTextureNode.js";
 
 declare class ViewportSharedTextureNode extends ViewportTextureNode {
     constructor(uvNode?: Node, levelNode?: Node | null);
+
+    getTextureForReference(): FramebufferTexture;
 }
 
 export default ViewportSharedTextureNode;

three/src/nodes/display/ViewportTextureNode.d.ts

@@ -1,4 +1,6 @@
+import { RenderTarget } from "../../core/RenderTarget.js";
 import { FramebufferTexture } from "../../textures/FramebufferTexture.js";
+import { Texture } from "../../textures/Texture.js";
 import TextureNode from "../accessors/TextureNode.js";
 import { NodeUpdateType } from "../core/constants.js";
 import Node from "../core/Node.js";
@@ -12,6 +14,8 @@ declare class ViewportTextureNode extends TextureNode {
     updateBeforeType: NodeUpdateType;
 
     constructor(uvNode?: Node, levelNode?: Node | null, framebufferTexture?: FramebufferTexture | null);
+
+    getTextureForReference(reference?: RenderTarget | null): Texture;
 }
 
 export default ViewportTextureNode;

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

@@ -3,24 +3,32 @@ import Node from "../core/Node.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class ComputeNode extends Node {
-    isComputeNode: true;
+    readonly isComputeNode: true;
 
-    count: number;
+    computeNode: Node;
     workgroupSize: number[];
-    dispatchCount: number;
+    count: number | null;
     name: string;
 
     onInitFunction: ((args: { renderer: Renderer }) => void) | null;
 
-    constructor(computeNode: Node, count: number, workgroupSize?: number[]);
+    constructor(computeNode: Node, workgroupSize: number[]);
 
-    label(name: string): void;
+    setCount(count: number): this;
+    getCount(): number | null;
 
-    updateDispatchCount(): void;
+    setName(name: string): this;
+
+    /**
+     * @deprecated "label()" has been deprecated. Use "setName()" instead.
+     */
+    label(name: string): this;
 
     onInit(callback: ((args: { renderer: Renderer }) => void) | null): void;
 }
 
+export const computeKernel: (node: Node, workgroupSize?: number[]) => ShaderNodeObject<ComputeNode>;
+
 export const compute: (
     node: Node,
     count: number,
@@ -30,5 +38,6 @@ export const compute: (
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {
         compute: typeof compute;
+        computeKernel: typeof computeKernel;
     }
 }

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

@@ -0,0 +1,100 @@
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export type SubgroupFunctionNodeMethod0 = typeof SubgroupFunctionNode.SUBGROUP_ELECT;
+
+export type SubgroupFunctionNodeMethod1 =
+    | typeof SubgroupFunctionNode.SUBGROUP_BALLOT
+    | typeof SubgroupFunctionNode.SUBGROUP_ADD
+    | typeof SubgroupFunctionNode.SUBGROUP_INCLUSIVE_ADD
+    | typeof SubgroupFunctionNode.SUBGROUP_EXCLUSIVE_AND
+    | typeof SubgroupFunctionNode.SUBGROUP_MUL
+    | typeof SubgroupFunctionNode.SUBGROUP_INCLUSIVE_MUL
+    | typeof SubgroupFunctionNode.SUBGROUP_EXCLUSIVE_MUL
+    | typeof SubgroupFunctionNode.SUBGROUP_AND
+    | typeof SubgroupFunctionNode.SUBGROUP_OR
+    | typeof SubgroupFunctionNode.SUBGROUP_XOR
+    | typeof SubgroupFunctionNode.SUBGROUP_MIN
+    | typeof SubgroupFunctionNode.SUBGROUP_MAX
+    | typeof SubgroupFunctionNode.SUBGROUP_ALL
+    | typeof SubgroupFunctionNode.SUBGROUP_ANY
+    | typeof SubgroupFunctionNode.SUBGROUP_BROADCAST_FIRST
+    | typeof SubgroupFunctionNode.QUAD_SWAP_X
+    | typeof SubgroupFunctionNode.QUAD_SWAP_Y
+    | typeof SubgroupFunctionNode.QUAD_SWAP_DIAGONAL;
+
+export type SubgroupFunctionNodeMethod2 =
+    | typeof SubgroupFunctionNode.SUBGROUP_BROADCAST
+    | typeof SubgroupFunctionNode.SUBGROUP_SHUFFLE
+    | typeof SubgroupFunctionNode.SUBGROUP_SHUFFLE_XOR
+    | typeof SubgroupFunctionNode.SUBGROUP_SHUFFLE_UP
+    | typeof SubgroupFunctionNode.SUBGROUP_SHUFFLE_DOWN
+    | typeof SubgroupFunctionNode.QUAD_BROADCAST;
+
+declare class SubgroupFunctionNode extends TempNode {
+    constructor(method: SubgroupFunctionNodeMethod0);
+    constructor(method: SubgroupFunctionNodeMethod1, aNode: Node);
+    constructor(method: SubgroupFunctionNodeMethod2, aNode: Node, bNode: Node);
+
+    // 0 inputs
+    static SUBGROUP_ELECT: "subgroupElect";
+
+    // 1 input
+    static SUBGROUP_BALLOT: "subgroupBallot";
+    static SUBGROUP_ADD: "subgroupAdd";
+    static SUBGROUP_INCLUSIVE_ADD: "subgroupInclusiveAdd";
+    static SUBGROUP_EXCLUSIVE_AND: "subgroupExclusiveAdd";
+    static SUBGROUP_MUL: "subgroupMul";
+    static SUBGROUP_INCLUSIVE_MUL: "subgroupInclusiveMul";
+    static SUBGROUP_EXCLUSIVE_MUL: "subgroupExclusiveMul";
+    static SUBGROUP_AND: "subgroupAnd";
+    static SUBGROUP_OR: "subgroupOr";
+    static SUBGROUP_XOR: "subgroupXor";
+    static SUBGROUP_MIN: "subgroupMin";
+    static SUBGROUP_MAX: "subgroupMax";
+    static SUBGROUP_ALL: "subgroupAll";
+    static SUBGROUP_ANY: "subgroupAny";
+    static SUBGROUP_BROADCAST_FIRST: "subgroupBroadcastFirst";
+    static QUAD_SWAP_X: "quadSwapX";
+    static QUAD_SWAP_Y: "quadSwapY";
+    static QUAD_SWAP_DIAGONAL: "quadSwapDiagonal";
+
+    // 2 inputs
+    static SUBGROUP_BROADCAST: "subgroupBroadcast";
+    static SUBGROUP_SHUFFLE: "subgroupShuffle";
+    static SUBGROUP_SHUFFLE_XOR: "subgroupShuffleXor";
+    static SUBGROUP_SHUFFLE_UP: "subgroupShuffleUp";
+    static SUBGROUP_SHUFFLE_DOWN: "subgroupShuffleDown";
+    static QUAD_BROADCAST: "quadBroadcast";
+}
+
+export default SubgroupFunctionNode;
+
+export const subgroupElect: () => ShaderNodeObject<Node>;
+
+export const subgroupBallot: (pred: Node) => ShaderNodeObject<Node>;
+export const subgroupAdd: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupInclusiveAdd: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupExclusiveAdd: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupMul: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupInclusiveMul: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupExclusiveMul: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupAnd: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupOr: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupXor: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupMin: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupMax: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupAll: () => ShaderNodeObject<Node>;
+export const subgroupAny: () => ShaderNodeObject<Node>;
+export const subgroupBroadcastFirst: (e: Node, id: Node) => ShaderNodeObject<Node>;
+export const quadSwapX: (e: Node) => ShaderNodeObject<Node>;
+export const quadSwapY: (e: Node) => ShaderNodeObject<Node>;
+export const quadSwapDiagonal: (e: Node) => ShaderNodeObject<Node>;
+
+export const subgroupBroadcast: (e: Node, id: Node) => ShaderNodeObject<Node>;
+export const subgroupShuffle: (v: Node, id: Node) => ShaderNodeObject<Node>;
+export const subgroupShuffleXor: (v: Node, mask: Node) => ShaderNodeObject<Node>;
+export const subgroupShuffleUp: (v: Node, delta: Node) => ShaderNodeObject<Node>;
+export const subgroupShuffleDown: (v: Node, delta: Node) => ShaderNodeObject<Node>;
+export const quadBroadcast: (e: Node) => ShaderNodeObject<Node>;

three/src/nodes/materialx/MaterialXNodes.d.ts

@@ -4,61 +4,96 @@ import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import { mx_hsvtorgb, mx_rgbtohsv } from "./lib/mx_hsv.js";
 import { mx_srgb_texture_to_lin_rec709 } from "./lib/mx_transform_color.js";
 
-export function mx_aastep(threshold: Node | number, value: Node | number): ShaderNodeObject<MathNode>;
+export const mx_aastep: (threshold: Node | number, value: Node | number) => ShaderNodeObject<MathNode>;
 
-export function mx_ramplr(
+export const mx_ramplr: (
     valuel: Node | number,
     valuer: Node | number,
     texcoord?: Node,
-): ShaderNodeObject<MathNode>;
-export function mx_ramptb(
+) => ShaderNodeObject<MathNode>;
+export const mx_ramptb: (
     valuet: Node | number,
     valueb: Node | number,
     texcoord?: Node,
-): ShaderNodeObject<MathNode>;
+) => ShaderNodeObject<MathNode>;
 
-export function mx_splitlr(
+export const mx_ramp4: (
+    valuetl: Node | number,
+    valuetr: Node | number,
+    valuebl: Node | number,
+    valuebr: Node | number,
+    texcoord?: Node,
+) => ShaderNodeObject<MathNode>;
+
+export const mx_splitlr: (
     valuel: Node | number,
     valuer: Node | number,
     center: Node | number,
     texcoord?: Node,
-): ShaderNodeObject<MathNode>;
-export function mx_splittb(
+) => ShaderNodeObject<MathNode>;
+export const mx_splittb: (
     valuet: Node | number,
     valueb: Node | number,
     center: Node | number,
     texcoord?: Node,
-): ShaderNodeObject<MathNode>;
+) => ShaderNodeObject<MathNode>;
 
-export function mx_transform_uv(
+export const mx_transform_uv: (
     uv_scale?: Node | number,
     uv_offset?: Node | number,
     uv_geo?: Node,
-): ShaderNodeObject<Node>;
+) => ShaderNodeObject<Node>;
 
-export function mx_safepower(in1: Node | number, in2?: Node | number): ShaderNodeObject<Node>;
+export const mx_safepower: (in1: Node | number, in2?: Node | number) => ShaderNodeObject<Node>;
 
-export function mx_contrast(
+export const mx_contrast: (
     input: Node | number,
     amount?: Node | number,
     pivot?: Node | number,
-): ShaderNodeObject<Node>;
+) => ShaderNodeObject<Node>;
 
-export function mx_noise_float(
+export const mx_noise_float: (
     texcoord?: Node,
     amplitude?: Node | number,
     pivot?: Node | number,
-): ShaderNodeObject<Node>;
-export function mx_noise_vec3(
+) => ShaderNodeObject<Node>;
+export const mx_noise_vec3: (
     texcoord?: Node,
     amplitude?: Node | number,
     pivot?: Node | number,
-): ShaderNodeObject<Node>;
-export function mx_noise_vec4(
+) => ShaderNodeObject<Node>;
+export const mx_noise_vec4: (
     texcoord?: Node,
     amplitude?: Node | number,
     pivot?: Node | number,
-): ShaderNodeObject<Node>;
+) => ShaderNodeObject<Node>;
+
+export const mx_unifiednoise2d: (
+    noiseType: Node,
+    texcoord?: Node,
+    freq?: Node,
+    offset?: Node,
+    jitter?: Node | number,
+    outmin?: Node | number,
+    outmax?: Node | number,
+    clampoutput?: Node | boolean,
+    octaves?: Node | number,
+    lacunarity?: Node | number,
+    diminish?: Node | number,
+) => ShaderNodeObject<Node>;
+export const mx_unifiednoise3d: (
+    noiseType: Node,
+    texcoord?: Node,
+    freq?: Node,
+    offset?: Node,
+    jitter?: Node | number,
+    outmin?: Node | number,
+    outmax?: Node | number,
+    clampoutput?: Node | boolean,
+    octaves?: Node | number,
+    lacunarity?: Node | number,
+    diminish?: Node | number,
+) => ShaderNodeObject<Node>;
 
 export function mx_worley_noise_float(
     texcoord?: Node,
@@ -105,3 +140,33 @@ export function mx_fractal_noise_vec4(
 ): ShaderNodeObject<Node>;
 
 export { mx_hsvtorgb, mx_rgbtohsv, mx_srgb_texture_to_lin_rec709 };
+
+export const mx_add: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
+export const mx_subtract: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
+export const mx_multiply: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
+export const mx_divide: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
+export const mx_modulo: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
+export const mx_power: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
+export const mx_atan2: (in1?: Node, in2?: Node) => ShaderNodeObject<Node>;
+export const mx_timer: () => ShaderNodeObject<Node>;
+export const mx_frame: () => ShaderNodeObject<Node>;
+export const mx_invert: (in1: Node, amount?: Node) => ShaderNodeObject<Node>;
+export const mx_ifgreater: (value1: Node, value2: Node, in1: Node, in2: Node) => ShaderNodeObject<Node>;
+export const mx_ifgreatereq: (value1: Node, value2: Node, in1: Node, in2: Node) => ShaderNodeObject<Node>;
+export const mx_ifequal: (value1: Node, value2: Node, in1: Node, in2: Node) => ShaderNodeObject<Node>;
+
+export const mx_separate: (in1: Node, channelOrOut?: string | number) => ShaderNodeObject<Node>;
+
+export const mx_place2d: (
+    texcoord: Node,
+    pivot?: Node,
+    scale?: Node,
+    rotate?: Node,
+    offset?: Node,
+) => ShaderNodeObject<Node>;
+
+export const mx_rotate2d: (input: Node, amount: Node) => ShaderNodeObject<Node>;
+
+export const mx_rotate3d: (input: Node, amount: Node, axis: Node) => ShaderNodeObject<Node>;
+
+export const mx_heighttonormal: (input: Node, scale: Node) => ShaderNodeObject<Node>;

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

@@ -357,3 +357,31 @@ export const mx_worley_noise_vec3: (
     jitter_immutable: Node | number,
     metric_immutable: Node | number,
 ) => ShaderNodeObject<Node>;
+
+export const mx_unifiednoise2d: (
+    noiseType_immutable: Node,
+    texcoord_immutable: Node,
+    freq_immutable: Node,
+    offset_immutable: Node,
+    jitter_immutable: Node,
+    outmin_immutable: Node,
+    outmax_immutable: Node,
+    clampoutput_immutable: Node,
+    octaves_immutable: Node,
+    lacunarity_immutable: Node,
+    diminish_immutable: Node,
+) => ShaderNodeObject<Node>;
+
+export const mx_unifiednoise3d: (
+    noiseType_immutable: Node,
+    position_immutable: Node,
+    freq_immutable: Node,
+    offset_immutable: Node,
+    jitter_immutable: Node,
+    outmin_immutable: Node,
+    outmax_immutable: Node,
+    clampoutput_immutable: Node,
+    octaves_immutable: Node,
+    lacunarity_immutable: Node,
+    diminish_immutable: Node,
+) => ShaderNodeObject<Node>;

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

@@ -0,0 +1,25 @@
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class BitcastNode extends TempNode {
+    valueNode: Node;
+    conversionType: string;
+    inputType: string | null;
+
+    readonly isBitcastNode: true;
+
+    constructor(valueNode: Node, conversionType: string, inputType: string | null);
+}
+
+export default BitcastNode;
+
+export const bitcast: (x: Node | number, y: string) => ShaderNodeObject<BitcastNode>;
+
+export const floatBitsToInt: (value: Node) => ShaderNodeObject<BitcastNode>;
+
+export const floatBitsToUint: (value: Node) => ShaderNodeObject<BitcastNode>;
+
+export const intBitsToFloat: (value: Node) => ShaderNodeObject<BitcastNode>;
+
+export const uintBitsToFloat: (value: Node) => ShaderNodeObject<BitcastNode>;

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

@@ -34,8 +34,9 @@ export type MathNodeMethod1 =
     | typeof MathNode.RECIPROCAL
     | typeof MathNode.TRUNC
     | typeof MathNode.FWIDTH
-    | typeof MathNode.BITCAST
-    | typeof MathNode.TRANSPOSE;
+    | typeof MathNode.TRANSPOSE
+    | typeof MathNode.DETERMINANT
+    | typeof MathNode.INVERSE;
 
 export type MathNodeMethod2 =
     | typeof MathNode.MIN
@@ -93,8 +94,9 @@ export default class MathNode extends TempNode {
     static RECIPROCAL: "reciprocal";
     static TRUNC: "trunc";
     static FWIDTH: "fwidth";
-    static BITCAST: "bitcast";
     static TRANSPOSE: "transpose";
+    static DETERMINANT: "determinant";
+    static INVERSE: "inverse";
 
     // 2 inputs
 
@@ -175,10 +177,11 @@ export const reciprocal: Unary;
 export const trunc: Unary;
 export const fwidth: Unary;
 export const transpose: Unary;
+export const determinant: (x: Node) => ShaderNodeObject<MathNode>;
+export const inverse: (x: Node) => ShaderNodeObject<MathNode>;
 
 type Binary = (a: MathNodeParameter, b: MathNodeParameter) => ShaderNodeObject<MathNode>;
 
-export const bitcast: Binary;
 export const min: (
     x: MathNodeParameter,
     y: MathNodeParameter,
@@ -194,7 +197,7 @@ export const reflect: Binary;
 export const distance: Binary;
 export const difference: Binary;
 export const dot: Binary;
-export const cross: Binary;
+export const cross: (x: Node, y: Node) => ShaderNodeObject<MathNode>;
 export const pow: Binary;
 export const pow2: Unary;
 export const pow3: Unary;
@@ -291,6 +294,8 @@ declare module "../tsl/TSLCore.js" {
         saturate: typeof saturate;
         cbrt: typeof cbrt;
         transpose: typeof transpose;
+        determinant: typeof determinant;
+        inverse: typeof inverse;
         rand: typeof rand;
     }
 }