@nativescript/canvas-three 2.0.0-webgpu.3 → 2.0.0-webgpu.30

package/three/src/nodes/materials/VolumeNodeMaterial.d.ts

@@ -0,0 +1,10 @@
+import Node from '../core/Node.js';
+import NodeMaterial, { NodeMaterialParameters } from './NodeMaterial.js';
+
+export default class VolumeNodeMaterial extends NodeMaterial {
+	lights: boolean;
+	readonly isVolumeNodeMaterial: true;
+	testNode: Node | null;
+
+	constructor(parameters?: NodeMaterialParameters);
+}

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

@@ -0,0 +1,36 @@
+import Node from '../core/Node.js';
+import MathNode from '../math/MathNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.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: NodeRepresentation, value: NodeRepresentation): ShaderNodeObject<MathNode>;
+
+export function mx_ramplr(valuel: NodeRepresentation, valuer: NodeRepresentation, texcoord?: NodeRepresentation): ShaderNodeObject<MathNode>;
+export function mx_ramptb(valuet: NodeRepresentation, valueb: NodeRepresentation, texcoord?: NodeRepresentation): ShaderNodeObject<MathNode>;
+
+export function mx_splitlr(valuel: NodeRepresentation, valuer: NodeRepresentation, center: NodeRepresentation, texcoord?: NodeRepresentation): ShaderNodeObject<MathNode>;
+export function mx_splittb(valuet: NodeRepresentation, valueb: NodeRepresentation, center: NodeRepresentation, texcoord?: NodeRepresentation): ShaderNodeObject<MathNode>;
+
+export function mx_transform_uv(uv_scale?: NodeRepresentation, uv_offset?: NodeRepresentation, uv_geo?: NodeRepresentation): ShaderNodeObject<Node>;
+
+export function mx_safepower(in1: NodeRepresentation, in2?: NodeRepresentation): ShaderNodeObject<Node>;
+
+export function mx_contrast(input: NodeRepresentation, amount?: NodeRepresentation, pivot?: NodeRepresentation): ShaderNodeObject<Node>;
+
+export function mx_noise_float(texcoord?: NodeRepresentation, amplitude?: NodeRepresentation, pivot?: NodeRepresentation): ShaderNodeObject<Node>;
+export function mx_noise_vec3(texcoord?: NodeRepresentation, amplitude?: NodeRepresentation, pivot?: NodeRepresentation): ShaderNodeObject<Node>;
+export function mx_noise_vec4(texcoord?: NodeRepresentation, amplitude?: NodeRepresentation, pivot?: NodeRepresentation): ShaderNodeObject<Node>;
+
+export function mx_worley_noise_float(texcoord?: NodeRepresentation, jitter?: NodeRepresentation): ShaderNodeObject<Node>;
+export function mx_worley_noise_vec2(texcoord?: NodeRepresentation, jitter?: NodeRepresentation): ShaderNodeObject<Node>;
+export function mx_worley_noise_vec3(texcoord?: NodeRepresentation, jitter?: NodeRepresentation): ShaderNodeObject<Node>;
+
+export function mx_cell_noise_float(texcoord?: NodeRepresentation): ShaderNodeObject<Node>;
+
+export function mx_fractal_noise_float(position?: NodeRepresentation, octaves?: NodeRepresentation, lacunarity?: NodeRepresentation, diminish?: NodeRepresentation, amplitude?: NodeRepresentation): ShaderNodeObject<Node>;
+export function mx_fractal_noise_vec2(position?: NodeRepresentation, octaves?: NodeRepresentation, lacunarity?: NodeRepresentation, diminish?: NodeRepresentation, amplitude?: NodeRepresentation): ShaderNodeObject<Node>;
+export function mx_fractal_noise_vec3(position?: NodeRepresentation, octaves?: NodeRepresentation, lacunarity?: NodeRepresentation, diminish?: NodeRepresentation, amplitude?: NodeRepresentation): ShaderNodeObject<Node>;
+export function mx_fractal_noise_vec4(position?: NodeRepresentation, octaves?: NodeRepresentation, lacunarity?: NodeRepresentation, diminish?: NodeRepresentation, amplitude?: NodeRepresentation): ShaderNodeObject<Node>;
+
+export { mx_hsvtorgb, mx_rgbtohsv, mx_srgb_texture_to_lin_rec709 };

package/three/src/nodes/materialx/lib/mx_hsv.d.ts

@@ -0,0 +1,6 @@
+import Node from '../../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../../shadernode/ShaderNode.js';
+
+export const mx_hsvtorgb: (hsv_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_rgbtohsv: (c_immutable: NodeRepresentation) => ShaderNodeObject<Node>;

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

@@ -0,0 +1,139 @@
+import Node from '../../core/Node.js';
+import VarNode from '../../core/VarNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../../shadernode/ShaderNode.js';
+
+export const mx_select: (b_immutable: NodeRepresentation, t_immutable: NodeRepresentation, f_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_negate_if: (val_immutable: NodeRepresentation, b_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_floor: (x_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_floorfrac: (x_immutable: NodeRepresentation, i: ShaderNodeObject<VarNode>) => ShaderNodeObject<Node>;
+
+export const mx_bilerp_0: (v0_immutable: NodeRepresentation, v1_immutable: NodeRepresentation, v2_immutable: NodeRepresentation, v3_immutable: NodeRepresentation, s_immutable: NodeRepresentation, t_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_bilerp_1: (v0_immutable: NodeRepresentation, v1_immutable: NodeRepresentation, v2_immutable: NodeRepresentation, v3_immutable: NodeRepresentation, s_immutable: NodeRepresentation, t_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_bilerp: (v0_immutable: NodeRepresentation, v1_immutable: NodeRepresentation, v2_immutable: NodeRepresentation, v3_immutable: NodeRepresentation, s_immutable: NodeRepresentation, t_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_trilerp_0: (v0_immutable: NodeRepresentation, v1_immutable: NodeRepresentation, v2_immutable: NodeRepresentation, v3_immutable: NodeRepresentation, v4_immutable: NodeRepresentation, v5_immutable: NodeRepresentation, v6_immutable: NodeRepresentation, v7_immutable: NodeRepresentation, s_immutable: NodeRepresentation, t_immutable: NodeRepresentation, r_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_trilerp_1: (v0_immutable: NodeRepresentation, v1_immutable: NodeRepresentation, v2_immutable: NodeRepresentation, v3_immutable: NodeRepresentation, v4_immutable: NodeRepresentation, v5_immutable: NodeRepresentation, v6_immutable: NodeRepresentation, v7_immutable: NodeRepresentation, s_immutable: NodeRepresentation, t_immutable: NodeRepresentation, r_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_trilerp: (v0_immutable: NodeRepresentation, v1_immutable: NodeRepresentation, v2_immutable: NodeRepresentation, v3_immutable: NodeRepresentation, v4_immutable: NodeRepresentation, v5_immutable: NodeRepresentation, v6_immutable: NodeRepresentation, v7_immutable: NodeRepresentation, s_immutable: NodeRepresentation, t_immutable: NodeRepresentation, r_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_gradient_float_0: (hash_immutable: NodeRepresentation, x_immutable: NodeRepresentation, y_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_gradient_float_1: (hash_immutable: NodeRepresentation, x_immutable: NodeRepresentation, y_immutable: NodeRepresentation, z_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_gradient_float: (hash_immutable: NodeRepresentation, x_immutable: NodeRepresentation, y_immutable: NodeRepresentation, z_immutable?: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_gradient_vec3_0: (hash_immutable: NodeRepresentation, x_immutable: NodeRepresentation, y_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_gradient_vec3_1: (hash_immutable: NodeRepresentation, x_immutable: NodeRepresentation, y_immutable: NodeRepresentation, z_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_gradient_vec3: (hash_immutable: NodeRepresentation, x_immutable: NodeRepresentation, y_immutable: NodeRepresentation, z_immutable?: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_gradient_scale2d_0: (v_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_gradient_scale3d_0: (v_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_gradient_scale2d_1: (v_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_gradient_scale2d: (v_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_gradient_scale3d_1: (v_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_gradient_scale3d: (v_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_rotl32: (x_immutable: NodeRepresentation, k_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_bjmix: (a: ShaderNodeObject<VarNode>, b: ShaderNodeObject<VarNode>, c: ShaderNodeObject<VarNode>) => ShaderNodeObject<Node>;
+
+export const mx_bjfinal: (a_immutable: NodeRepresentation, b_immutable: NodeRepresentation, c_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_bits_to_01: (bits_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_fade: (t_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_hash_int_0: (x_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_hash_int_1: (x_immutable: NodeRepresentation, y_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_hash_int_2: (x_immutable: NodeRepresentation, y_immutable: NodeRepresentation, z_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_hash_int_3: (x_immutable: NodeRepresentation, y_immutable: NodeRepresentation, z_immutable: NodeRepresentation, xx_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_hash_int_4: (x_immutable: NodeRepresentation, y_immutable: NodeRepresentation, z_immutable: NodeRepresentation, xx_immutable: NodeRepresentation, yy_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_hash_int: (x_immutable: NodeRepresentation, y_immutable?: NodeRepresentation, z_immutable?: NodeRepresentation, xx_immutable?: NodeRepresentation, yy_immutable?: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_hash_vec3_0: (x_immutable: NodeRepresentation, y_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_hash_vec3_1: (x_immutable: NodeRepresentation, y_immutable: NodeRepresentation, z_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_hash_vec3: (x_immutable: NodeRepresentation, y_immutable: NodeRepresentation, z_immutable?: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_perlin_noise_float_0: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_perlin_noise_float_1: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_perlin_noise_float: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_perlin_noise_vec3_0: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_perlin_noise_vec3_1: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_perlin_noise_vec3: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_cell_noise_float_0: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_cell_noise_float_1: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_cell_noise_float_2: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_cell_noise_float_3: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_cell_noise_float: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_cell_noise_vec3_0: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_cell_noise_vec3_1: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_cell_noise_vec3_2: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_cell_noise_vec3_3: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_cell_noise_vec3: (p_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_fractal_noise_float: (p_immutable: NodeRepresentation, octaves_immutable: NodeRepresentation, lacunarity_immutable: NodeRepresentation, diminish_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_fractal_noise_vec3: (p_immutable: NodeRepresentation, octaves_immutable: NodeRepresentation, lacunarity_immutable: NodeRepresentation, diminish_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_fractal_noise_vec2: (p_immutable: NodeRepresentation, octaves_immutable: NodeRepresentation, lacunarity_immutable: NodeRepresentation, diminish_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_fractal_noise_vec4: (p_immutable: NodeRepresentation, octaves_immutable: NodeRepresentation, lacunarity_immutable: NodeRepresentation, diminish_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_worley_distance_0: (p_immutable: NodeRepresentation, x_immutable: NodeRepresentation, y_immutable: NodeRepresentation, z_immutable: NodeRepresentation, xoff_immutable: NodeRepresentation, yoff_immutable: NodeRepresentation, jitter_immutable: NodeRepresentation, metric_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_worley_distance_1: (p_immutable: NodeRepresentation, x_immutable: NodeRepresentation, y_immutable: NodeRepresentation, z_immutable: NodeRepresentation, xoff_immutable: NodeRepresentation, yoff_immutable: NodeRepresentation, zoff_immutable: NodeRepresentation, jitter_immutable: NodeRepresentation, metric_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_worley_distance: (p_immutable: NodeRepresentation, x_immutable: NodeRepresentation, y_immutable: NodeRepresentation, z_immutable: NodeRepresentation, xoff_immutable: NodeRepresentation, yoff_immutable: NodeRepresentation, zoff_immutable: NodeRepresentation, jitter_immutable: NodeRepresentation, metric_immutable?: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_worley_noise_float_0: (p_immutable: NodeRepresentation, jitter_immutable: NodeRepresentation, metric_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_worley_noise_vec2_0: (p_immutable: NodeRepresentation, jitter_immutable: NodeRepresentation, metric_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_worley_noise_vec3_0: (p_immutable: NodeRepresentation, jitter_immutable: NodeRepresentation, metric_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_worley_noise_float_1: (p_immutable: NodeRepresentation, jitter_immutable: NodeRepresentation, metric_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_worley_noise_float: (p_immutable: NodeRepresentation, jitter_immutable: NodeRepresentation, metric_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_worley_noise_vec2_1: (p_immutable: NodeRepresentation, jitter_immutable: NodeRepresentation, metric_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_worley_noise_vec2: (p_immutable: NodeRepresentation, jitter_immutable: NodeRepresentation, metric_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_worley_noise_vec3_1: (p_immutable: NodeRepresentation, jitter_immutable: NodeRepresentation, metric_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const mx_worley_noise_vec3: (p_immutable: NodeRepresentation, jitter_immutable: NodeRepresentation, metric_immutable: NodeRepresentation) => ShaderNodeObject<Node>;

package/three/src/nodes/materialx/lib/mx_transform_color.d.ts

@@ -0,0 +1,4 @@
+import Node from '../../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../../shadernode/ShaderNode.js';
+
+export const mx_srgb_texture_to_lin_rec709: (color_immutable: NodeRepresentation) => ShaderNodeObject<Node>;

package/three/src/nodes/math/CondNode.d.ts

@@ -0,0 +1,18 @@
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class CondNode extends Node {
+	condNode: Node;
+	ifNode: Node;
+	elseNode: Node;
+
+	constructor(condNode: Node, ifNode: Node, elseNode: Node);
+}
+
+export function cond(condNode: NodeRepresentation, ifNode: NodeRepresentation, elseNode: NodeRepresentation): ShaderNodeObject<Node>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		cond: typeof cond;
+	}
+}

package/three/src/nodes/math/HashNode.d.ts

@@ -0,0 +1,16 @@
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class HashNode extends Node {
+	seedNode: Node;
+
+	constructor(seedNode: Node);
+}
+
+export const hash: (seedNode: NodeRepresentation) => ShaderNodeObject<HashNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		hash: typeof hash;
+	}
+}

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

@@ -0,0 +1,253 @@
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import OperatorNode from './OperatorNode.js';
+
+export type MathNodeMethod1 =
+	| typeof MathNode.RADIANS
+	| typeof MathNode.DEGREES
+	| typeof MathNode.EXP
+	| typeof MathNode.EXP2
+	| typeof MathNode.LOG
+	| typeof MathNode.LOG2
+	| typeof MathNode.SQRT
+	| typeof MathNode.INVERSE_SQRT
+	| typeof MathNode.FLOOR
+	| typeof MathNode.CEIL
+	| typeof MathNode.NORMALIZE
+	| typeof MathNode.FRACT
+	| typeof MathNode.SIN
+	| typeof MathNode.COS
+	| typeof MathNode.TAN
+	| typeof MathNode.ASIN
+	| typeof MathNode.ACOS
+	| typeof MathNode.ATAN
+	| typeof MathNode.ABS
+	| typeof MathNode.SIGN
+	| typeof MathNode.LENGTH
+	| typeof MathNode.NEGATE
+	| typeof MathNode.ONE_MINUS
+	| typeof MathNode.DFDX
+	| typeof MathNode.DFDY
+	| typeof MathNode.ROUND
+	| typeof MathNode.RECIPROCAL
+	| typeof MathNode.TRUNC
+	| typeof MathNode.FWIDTH
+	| typeof MathNode.BITCAST
+	| typeof MathNode.TRANSPOSE;
+
+export type MathNodeMethod2 = typeof MathNode.ATAN2 | typeof MathNode.MIN | typeof MathNode.MAX | typeof MathNode.MOD | typeof MathNode.STEP | typeof MathNode.REFLECT | typeof MathNode.DISTANCE | typeof MathNode.DOT | typeof MathNode.CROSS | typeof MathNode.POW | typeof MathNode.TRANSFORM_DIRECTION;
+
+export type MathNodeMethod3 = typeof MathNode.MIX | typeof MathNode.CLAMP | typeof MathNode.REFRACT | typeof MathNode.SMOOTHSTEP | typeof MathNode.FACEFORWARD;
+
+export type MathNodeMethod = MathNodeMethod1 | MathNodeMethod2 | MathNodeMethod3;
+
+export default class MathNode extends TempNode {
+	// 1 input
+
+	static ALL: 'all';
+	static ANY: 'any';
+	static EQUALS: 'equals';
+
+	static RADIANS: 'radians';
+	static DEGREES: 'degrees';
+	static EXP: 'exp';
+	static EXP2: 'exp2';
+	static LOG: 'log';
+	static LOG2: 'log2';
+	static SQRT: 'sqrt';
+	static INVERSE_SQRT: 'inversesqrt';
+	static FLOOR: 'floor';
+	static CEIL: 'ceil';
+	static NORMALIZE: 'normalize';
+	static FRACT: 'fract';
+	static SIN: 'sin';
+	static COS: 'cos';
+	static TAN: 'tan';
+	static ASIN: 'asin';
+	static ACOS: 'acos';
+	static ATAN: 'atan';
+	static ABS: 'abs';
+	static SIGN: 'sign';
+	static LENGTH: 'length';
+	static NEGATE: 'negate';
+	static ONE_MINUS: 'oneMinus';
+	static DFDX: 'dFdx';
+	static DFDY: 'dFdy';
+	static ROUND: 'round';
+	static RECIPROCAL: 'reciprocal';
+	static TRUNC: 'trunc';
+	static FWIDTH: 'fwidth';
+	static BITCAST: 'bitcast';
+	static TRANSPOSE: 'transpose';
+
+	// 2 inputs
+
+	static ATAN2: 'atan2';
+	static MIN: 'min';
+	static MAX: 'max';
+	static MOD: 'mod';
+	static STEP: 'step';
+	static REFLECT: 'reflect';
+	static DISTANCE: 'distance';
+	static DOT: 'dot';
+	static CROSS: 'cross';
+	static POW: 'pow';
+	static TRANSFORM_DIRECTION: 'transformDirection';
+
+	// 3 inputs
+
+	static MIX: 'mix';
+	static CLAMP: 'clamp';
+	static REFRACT: 'refract';
+	static SMOOTHSTEP: 'smoothstep';
+	static FACEFORWARD: 'faceforward';
+
+	method: MathNodeMethod;
+	aNode: Node;
+	bNode: Node | null;
+	cNode: Node | null;
+
+	constructor(method: MathNodeMethod1, aNode: Node);
+	constructor(method: MathNodeMethod2, aNode: Node, bNode: Node);
+	constructor(method: MathNodeMethod3, aNode: Node, bNode: Node, cNode: Node);
+}
+
+export const EPSILON: ShaderNodeObject<Node>;
+export const INFINITY: ShaderNodeObject<Node>;
+export const PI: ShaderNodeObject<Node>;
+export const PI2: ShaderNodeObject<Node>;
+
+type Unary = (a: NodeRepresentation) => ShaderNodeObject<MathNode>;
+
+export const all: Unary;
+export const any: Unary;
+export const equals: Unary;
+
+export const radians: Unary;
+export const degrees: Unary;
+export const exp: Unary;
+export const exp2: Unary;
+export const log: Unary;
+export const log2: Unary;
+export const sqrt: Unary;
+export const inverseSqrt: Unary;
+export const floor: Unary;
+export const ceil: Unary;
+export const normalize: Unary;
+export const fract: Unary;
+export const sin: Unary;
+export const cos: Unary;
+export const tan: Unary;
+export const asin: Unary;
+export const acos: Unary;
+export const atan: Unary;
+export const abs: Unary;
+export const sign: Unary;
+export const length: Unary;
+export const negate: Unary;
+export const oneMinus: Unary;
+export const dFdx: Unary;
+export const dFdy: Unary;
+export const round: Unary;
+export const reciprocal: Unary;
+export const trunc: Unary;
+export const fwidth: Unary;
+export const bitcast: Unary;
+export const transpose: Unary;
+
+type Binary = (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<MathNode>;
+
+export const atan2: Binary;
+export const min: Binary;
+export const max: Binary;
+export const mod: Binary;
+export const step: Binary;
+export const reflect: Binary;
+export const distance: Binary;
+export const difference: Binary;
+export const dot: Binary;
+export const cross: Binary;
+export const pow: Binary;
+export const pow2: Binary;
+export const pow3: Binary;
+export const pow4: Binary;
+export const transformDirection: Binary;
+
+type Ternary = (a: NodeRepresentation, b: NodeRepresentation, c: NodeRepresentation) => ShaderNodeObject<MathNode>;
+
+export const cbrt: Unary;
+export const lengthSq: Unary;
+export const mix: Ternary;
+export const clamp: (a: NodeRepresentation, b?: NodeRepresentation, c?: NodeRepresentation) => ShaderNodeObject<MathNode>;
+export const saturate: Unary;
+export const refract: Ternary;
+export const smoothstep: Ternary;
+export const faceForward: Ternary;
+
+export const rand: (uv: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+
+export const mixElement: Ternary;
+export const smoothstepElement: Ternary;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		all: typeof all;
+		any: typeof any;
+		equals: typeof equals;
+		radians: typeof radians;
+		degrees: typeof degrees;
+		exp: typeof exp;
+		exp2: typeof exp2;
+		log: typeof log;
+		log2: typeof log2;
+		sqrt: typeof sqrt;
+		inverseSqrt: typeof inverseSqrt;
+		floor: typeof floor;
+		ceil: typeof ceil;
+		normalize: typeof normalize;
+		fract: typeof fract;
+		sin: typeof sin;
+		cos: typeof cos;
+		tan: typeof tan;
+		asin: typeof asin;
+		acos: typeof acos;
+		atan: typeof atan;
+		abs: typeof abs;
+		sign: typeof sign;
+		length: typeof length;
+		lengthSq: typeof lengthSq;
+		negate: typeof negate;
+		oneMinus: typeof oneMinus;
+		dFdx: typeof dFdx;
+		dFdy: typeof dFdy;
+		round: typeof round;
+		reciprocal: typeof reciprocal;
+		trunc: typeof trunc;
+		fwidth: typeof fwidth;
+		atan2: typeof atan2;
+		min: typeof min;
+		max: typeof max;
+		mod: typeof mod;
+		step: typeof step;
+		reflect: typeof reflect;
+		distance: typeof distance;
+		dot: typeof dot;
+		cross: typeof cross;
+		pow: typeof pow;
+		pow2: typeof pow2;
+		pow3: typeof pow3;
+		pow4: typeof pow4;
+		transformDirection: typeof transformDirection;
+		mix: typeof mixElement;
+		clamp: typeof clamp;
+		refract: typeof refract;
+		smoothstep: typeof smoothstepElement;
+		faceForward: typeof faceForward;
+		difference: typeof difference;
+		saturate: typeof saturate;
+		cbrt: typeof cbrt;
+		transpose: typeof transpose;
+		rand: typeof rand;
+	}
+}

package/three/src/nodes/math/MathUtils.d.ts

@@ -0,0 +1,16 @@
+import { Binary, Ternary } from './MathNode.js';
+
+// remapping functions
+export const parabola: Binary;
+export const gain: Binary;
+export const pcurve: Ternary;
+export const sinc: Binary;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		parabola: typeof parabola;
+		gain: typeof gain;
+		pcurve: typeof pcurve;
+		sinc: typeof sinc;
+	}
+}

package/three/src/nodes/math/OperatorNode.d.ts

@@ -0,0 +1,61 @@
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export type OperatorNodeOp = '%' | '&' | '|' | '^' | '>>' | '<<' | '==' | '&&' | '||' | '^^' | '<' | '>' | '<=' | '>=' | '+' | '-' | '*' | '/';
+
+export default class OperatorNode extends TempNode {
+	aNode: Node;
+	bNode: Node;
+	op: OperatorNodeOp;
+
+	constructor(op: OperatorNodeOp, ...params: [Node, Node, ...Node[]]);
+}
+
+type Operator = (a: NodeRepresentation, b: NodeRepresentation, ...others: NodeRepresentation[]) => ShaderNodeObject<OperatorNode>;
+
+export const add: Operator;
+export const sub: Operator;
+export const mul: Operator;
+export const div: Operator;
+export const remainder: Operator;
+export const equal: Operator;
+export const lessThan: Operator;
+export const greaterThan: Operator;
+export const lessThanEqual: Operator;
+export const greaterThanEqual: Operator;
+export const and: Operator;
+export const or: Operator;
+export const not: (a: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const xor: Operator;
+export const bitAnd: Operator;
+export const bitNot: (a: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
+export const bitOr: Operator;
+export const bitXor: Operator;
+export const shiftLeft: Operator;
+export const shiftRight: Operator;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		add: typeof add;
+		sub: typeof sub;
+		mul: typeof mul;
+		div: typeof div;
+		remainder: typeof remainder;
+		equal: typeof equal;
+		lessThan: typeof lessThan;
+		greaterThan: typeof greaterThan;
+		lessThanEqual: typeof lessThanEqual;
+		greaterThanEqual: typeof greaterThanEqual;
+		and: typeof and;
+		or: typeof or;
+		not: typeof not;
+		xor: typeof xor;
+		bitAnd: typeof bitAnd;
+		bitNot: typeof bitNot;
+		bitOr: typeof bitOr;
+		bitXor: typeof bitXor;
+		shiftLeft: typeof shiftLeft;
+		shiftRight: typeof shiftRight;
+	}
+}

package/three/src/nodes/math/TriNoise3D.d.ts

@@ -0,0 +1,8 @@
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export const tri: (x: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const tri3: (p: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const triNoise3D: (p_immutable: NodeRepresentation, spd: NodeRepresentation, time: NodeRepresentation) => ShaderNodeObject<Node>;

package/three/src/nodes/pmrem/PMREMNode.d.ts

@@ -0,0 +1,16 @@
+import { Texture } from '../../textures/Texture.js';
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class PMREMNode extends TempNode {
+	uvNode: Node | null;
+	levelNode: Node | null;
+
+	constructor(value: Texture, uvNode?: Node | null, levelNode?: Node | null);
+
+	set value(value: Texture);
+	get value(): Texture;
+}
+
+export const pmremTexture: (value: Texture, uvNode?: NodeRepresentation, levelNode?: NodeRepresentation) => ShaderNodeObject<PMREMNode>;

package/three/src/nodes/procedural/CheckerNode.d.ts

@@ -0,0 +1,15 @@
+import TempNode from '../core/TempNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class CheckerNode extends TempNode {
+	uvNode: Node;
+	constructor(uvNode?: Node);
+}
+
+export const checker: (uvNode?: NodeRepresentation) => ShaderNodeObject<CheckerNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+	interface NodeElements {
+		checker: typeof checker;
+	}
+}