@types/three 0.159.0 → 0.160.0

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

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class FogNode extends Node {
     isFogNode: true;
@@ -8,3 +9,5 @@ export default class FogNode extends Node {
     constructor(colorNode: Node, factorNode: Node);
     mixAssign(outputNode: Node): Node;
 }
+
+export const fog: (colorNode: NodeRepresentation, factorNode: NodeRepresentation) => ShaderNodeObject<FogNode>;

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

@@ -1,5 +1,6 @@
 import FogNode from './FogNode.js';
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class FogRangeNode extends FogNode {
     isFogRangeNode: true;
@@ -8,3 +9,5 @@ export default class FogRangeNode extends FogNode {
 
     constructor(colorNode: Node, nearNode: Node, farNode: Node);
 }
+
+export const rangeFog: (colorNode: Node, nearNode: Node, farNode: Node) => ShaderNodeObject<FogRangeNode>;

three/examples/jsm/nodes/functions/BSDF/BRDF_GGX.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.js';
 import Node from '../../core/Node.js';
 
 declare const BRDF_GGX: ShaderNode<{ lightDirection: Node; f0: Node; f90: Node; roughness: Node }>;

three/examples/jsm/nodes/functions/BSDF/BRDF_Lambert.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.js';
 import Node from '../../core/Node.js';
 
 declare const BRDF_Lambert: ShaderNode<{ diffuseColor: Node }>;

three/examples/jsm/nodes/functions/BSDF/DFGApprox.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeElements.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.js';
 import Node from '../../core/Node.js';
 
 // Analytical approximation of the DFG LUT, one half of the

three/examples/jsm/nodes/functions/BSDF/D_GGX.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.js';
 import Node from '../../core/Node.js';
 
 // Microfacet Models for Refraction through Rough Surfaces - equation (33)

three/examples/jsm/nodes/functions/BSDF/F_Schlick.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.js';
 import Node from '../../core/Node.js';
 
 declare const F_Schlick: ShaderNode<{ f0: Node; f90: Node; dotVH: Node }>;

three/examples/jsm/nodes/functions/BSDF/V_GGX_SmithCorrelated.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.js';
 import Node from '../../core/Node.js';
 
 declare const V_GGX_SmithCorrelated: ShaderNode<{ alpha: Node; dotNL: Node; dotNV: Node }>;

three/examples/jsm/nodes/functions/PhysicalLightingModel.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNode } from '../shadernode/ShaderNodeElements.js';
+import { ShaderNode } from '../shadernode/ShaderNode.js';
 import Node from '../core/Node.js';
 
 declare const PhysicalLightingModel: {

three/examples/jsm/nodes/functions/material/getGeometryRoughness.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.js';
 
 declare const getGeometryRoughness: ShaderNode;
 

three/examples/jsm/nodes/functions/material/getRoughness.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeElements.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.js';
 import Node from '../../core/Node.js';
 
 declare const getRoughness: ShaderNode<{ roughness: Node }>;

three/examples/jsm/nodes/geometry/RangeNode.d.ts

@@ -1,6 +1,7 @@
 import { Color, Vector2, Vector3, Vector4 } from '../../../../src/Three.js';
 import Node from '../core/Node.js';
 import NodeBuilder from '../core/NodeBuilder.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type RangeModeBound = number | Color | Vector2 | Vector3 | Vector4;
 
@@ -11,3 +12,5 @@ export default class RangeNode extends Node {
     constructor(min: RangeModeBound, max: RangeModeBound);
     getVectorLength(builder: NodeBuilder): number;
 }
+
+export const range: (min: RangeModeBound, max: RangeModeBound) => ShaderNodeObject<RangeNode>;

three/examples/jsm/nodes/gpgpu/ComputeNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class ComputeNode extends Node {
     isComputeNode: true;
@@ -9,3 +10,9 @@ export default class ComputeNode extends Node {
 
     constructor(computeNode: Node, count: number, workgroupSize?: number[]);
 }
+
+export const compute: (
+    node: NodeRepresentation,
+    count: number,
+    workgroupSize: number[],
+) => ShaderNodeObject<ComputeNode>;

three/examples/jsm/nodes/lighting/LightingContextNode.d.ts

@@ -1,6 +1,6 @@
 import ContextNode from '../core/ContextNode.js';
 import Node from '../core/Node.js';
-import { ShaderNode } from '../Nodes.js';
+import { ShaderNode, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export interface LightingModelNode {
     indirectDiffuse?: ShaderNode;
@@ -13,3 +13,8 @@ export default class LightingContextNode extends ContextNode {
 
     constructor(node: Node, lightingModelNode?: LightingModelNode | null);
 }
+
+export const lightingContext: (
+    node: Node,
+    lightingModelNode?: LightingModelNode,
+) => ShaderNodeObject<LightingContextNode>;

three/examples/jsm/nodes/lighting/LightsNode.d.ts

@@ -1,6 +1,7 @@
 import { Light } from '../../../../src/Three.js';
 import Node from '../core/Node.js';
 import LightingNode from './LightingNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class LightsNode extends Node {
     lightNodes: LightingNode[];
@@ -17,3 +18,5 @@ export default class LightsNode extends Node {
         lightNodeClass: { new (light: T): LightingNode },
     ): void;
 }
+
+export const lights: (lights: Light[]) => ShaderNodeObject<LightsNode>;

three/examples/jsm/nodes/materials/MeshPhysicalNodeMaterial.d.ts

@@ -1,12 +1,25 @@
 import { ShaderMaterialParameters } from '../../../../src/Three.js';
-import { Swizzable, CheckerNode, Node } from '../Nodes.js';
 
 import MeshStandardNodeMaterial from './MeshStandardNodeMaterial.js';
+import Node from '../core/Node.js';
+import CheckerNode from '../procedural/CheckerNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
-    iridescenceNode: null | Swizzable<CheckerNode>;
-    iridescenceIORNode: null | Swizzable;
-    iridescenceThicknessNode: null | Swizzable;
+    readonly isMeshPhysicalNodeMaterial: true;
+
+    clearcoatNode: Node | null;
+    clearcoatRoughnessNode: Node | null;
+    clearcoatNormalNode: Node | null;
+
+    sheenNode: Node | null;
+    sheenRoughnessNode: Node | null;
+
+    iridescenceNode: null | ShaderNodeObject<CheckerNode>;
+    iridescenceIORNode: null | ShaderNodeObject<Node>;
+    iridescenceThicknessNode: null | ShaderNodeObject<Node>;
+
+    iorNode?: Node | null;
 
     specularIntensityNode: Node | null;
     specularColorNode: Node | null;
@@ -16,7 +29,7 @@ export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
     attenuationDistanceNode: Node | null;
     attenuationColorNode: Node | null;
 
-    constructor(parameters: ShaderMaterialParameters);
+    constructor(parameters?: ShaderMaterialParameters);
 
     copy(source: MeshPhysicalNodeMaterial): this;
 }

three/examples/jsm/nodes/materials/MeshStandardNodeMaterial.d.ts

@@ -10,9 +10,6 @@ export default class MeshStandardNodeMaterial extends NodeMaterial {
     metalnessNode: Node | null;
     roughnessNode: Node | null;
 
-    clearcoatNode: Node | null;
-    clearcoatRoughnessNode: Node | null;
-
     constructor(paramters?: ShaderMaterialParameters);
     copy(source: MeshStandardNodeMaterial): this;
 }

three/examples/jsm/nodes/materials/NodeMaterial.d.ts

@@ -1,7 +1,22 @@
-import { Material, ShaderMaterial } from '../../../../src/Three.js';
+import {
+    LineBasicMaterial,
+    Material,
+    MeshBasicMaterial,
+    MeshPhysicalMaterial,
+    MeshStandardMaterial,
+    PointsMaterial,
+    ShaderMaterial,
+    SpriteMaterial,
+} from '../../../../src/Three.js';
 import NodeBuilder from '../core/NodeBuilder.js';
 import Node from '../core/Node.js';
 import { LightingModelNode } from '../lighting/LightingContextNode.js';
+import LineBasicNodeMaterial from './LineBasicNodeMaterial.js';
+import MeshBasicNodeMaterial from './MeshBasicNodeMaterial.js';
+import MeshPhysicalNodeMaterial from './MeshPhysicalNodeMaterial.js';
+import MeshStandardNodeMaterial from './MeshStandardNodeMaterial.js';
+import PointsNodeMaterial from './PointsNodeMaterial.js';
+import SpriteNodeMaterial from './SpriteNodeMaterial.js';
 
 export default class NodeMaterial extends ShaderMaterial {
     isNodeMaterial: true;
@@ -34,5 +49,13 @@ export default class NodeMaterial extends ShaderMaterial {
         lights: { diffuseColorNode: Node; lightingModelNode: LightingModelNode; lightsNode?: Node },
     ): void;
     generateOutput(builder: NodeBuilder, lights: { diffuseColorNode: Node; outgoingLightNode: Node }): void;
-    static fromMaterial(m: Material): NodeMaterial;
+
+    static fromMaterial(material: LineBasicMaterial): LineBasicNodeMaterial;
+    static fromMaterial(material: MeshBasicMaterial): MeshBasicNodeMaterial;
+    static fromMaterial(material: MeshPhysicalMaterial): MeshPhysicalNodeMaterial;
+    static fromMaterial(material: MeshStandardMaterial): MeshStandardNodeMaterial;
+    static fromMaterial(material: PointsMaterial): PointsNodeMaterial;
+    static fromMaterial(material: SpriteMaterial): SpriteNodeMaterial;
+    static fromMaterial(material: NodeMaterial): NodeMaterial;
+    static fromMaterial(material: Material): NodeMaterial;
 }

three/examples/jsm/nodes/materialx/MaterialXNodes.d.ts

@@ -1,94 +1,103 @@
 import { mx_hsvtorgb, mx_rgbtohsv } from './lib/mx_hsv.js';
-import { Swizzable } from '../shadernode/ShaderNodeElements.js';
-import { UVNode, MathNode } from '../Nodes.js';
-import { NodeRepresentation } from '../shadernode/ShaderNode.js';
+import Node from '../core/Node.js';
+import MathNode from '../math/MathNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
-export function mx_aastep(threshold?: NodeRepresentation, value?: NodeRepresentation): Swizzable<MathNode>;
+export function mx_aastep(threshold?: NodeRepresentation, value?: NodeRepresentation): ShaderNodeObject<MathNode>;
 
 export function mx_ramplr(
     valuel?: NodeRepresentation,
     valuer?: NodeRepresentation,
-    texcoord?: Swizzable<UVNode>,
-): Swizzable<MathNode>;
+    texcoord?: ShaderNodeObject<Node>,
+): ShaderNodeObject<MathNode>;
 export function mx_ramptb(
     valuet?: NodeRepresentation,
     valueb?: NodeRepresentation,
-    texcoord?: Swizzable<UVNode>,
-): Swizzable<MathNode>;
+    texcoord?: ShaderNodeObject<Node>,
+): ShaderNodeObject<MathNode>;
 
 export function mx_splitlr(
     valuel?: NodeRepresentation,
     valuer?: NodeRepresentation,
     center?: NodeRepresentation,
-    texcoord?: Swizzable<UVNode>,
-): Swizzable<MathNode>;
+    texcoord?: ShaderNodeObject<Node>,
+): ShaderNodeObject<MathNode>;
 export function mx_splittb(
     valuet?: NodeRepresentation,
     valueb?: NodeRepresentation,
     center?: NodeRepresentation,
-    texcoord?: Swizzable<UVNode>,
-): Swizzable<MathNode>;
+    texcoord?: ShaderNodeObject<Node>,
+): ShaderNodeObject<MathNode>;
 
 export function mx_transform_uv(
     uv_scale?: NodeRepresentation,
     uv_offset?: NodeRepresentation,
-    uv_geo?: Swizzable<UVNode>,
-): Swizzable;
+    uv_geo?: ShaderNodeObject<Node>,
+): ShaderNodeObject<Node>;
 
 export function mx_noise_float(
-    texcoord?: Swizzable<UVNode>,
+    texcoord?: ShaderNodeObject<Node>,
     amplitude?: NodeRepresentation,
     pivot?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 export function mx_noise_vec2(
-    texcoord?: Swizzable<UVNode>,
+    texcoord?: ShaderNodeObject<Node>,
     amplitude?: NodeRepresentation,
     pivot?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 export function mx_noise_vec3(
-    texcoord?: Swizzable<UVNode>,
+    texcoord?: ShaderNodeObject<Node>,
     amplitude?: NodeRepresentation,
     pivot?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 export function mx_noise_vec4(
-    texcoord?: Swizzable<UVNode>,
+    texcoord?: ShaderNodeObject<Node>,
     amplitude?: NodeRepresentation,
     pivot?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 
-export function mx_worley_noise_float(texcoord?: Swizzable<UVNode>, jitter?: NodeRepresentation): Swizzable;
-export function mx_worley_noise_vec2(texcoord?: Swizzable<UVNode>, jitter?: NodeRepresentation): Swizzable;
-export function mx_worley_noise_vec3(texcoord?: Swizzable<UVNode>, jitter?: NodeRepresentation): Swizzable;
+export function mx_worley_noise_float(
+    texcoord?: ShaderNodeObject<Node>,
+    jitter?: NodeRepresentation,
+): ShaderNodeObject<Node>;
+export function mx_worley_noise_vec2(
+    texcoord?: ShaderNodeObject<Node>,
+    jitter?: NodeRepresentation,
+): ShaderNodeObject<Node>;
+export function mx_worley_noise_vec3(
+    texcoord?: ShaderNodeObject<Node>,
+    jitter?: NodeRepresentation,
+): ShaderNodeObject<Node>;
 
-export function mx_cell_noise_float(texcoord?: Swizzable<UVNode>): Swizzable;
+export function mx_cell_noise_float(texcoord?: ShaderNodeObject<Node>): ShaderNodeObject<Node>;
 
 export function mx_fractal_noise_float(
-    position?: Swizzable<UVNode>,
+    position?: ShaderNodeObject<Node>,
     octaves?: NodeRepresentation,
     lacunarity?: NodeRepresentation,
     diminish?: NodeRepresentation,
     amplitude?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 export function mx_fractal_noise_vec2(
-    position?: Swizzable<UVNode>,
+    position?: ShaderNodeObject<Node>,
     octaves?: NodeRepresentation,
     lacunarity?: NodeRepresentation,
     diminish?: NodeRepresentation,
     amplitude?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 export function mx_fractal_noise_vec3(
-    position?: Swizzable<UVNode>,
+    position?: ShaderNodeObject<Node>,
     octaves?: NodeRepresentation,
     lacunarity?: NodeRepresentation,
     diminish?: NodeRepresentation,
     amplitude?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 export function mx_fractal_noise_vec4(
-    position?: Swizzable<UVNode>,
+    position?: ShaderNodeObject<Node>,
     octaves?: NodeRepresentation,
     lacunarity?: NodeRepresentation,
     diminish?: NodeRepresentation,
     amplitude?: NodeRepresentation,
-): Swizzable;
+): ShaderNodeObject<Node>;
 
 export { mx_hsvtorgb, mx_rgbtohsv };

three/examples/jsm/nodes/materialx/lib/mx_hsv.d.ts

@@ -1,4 +1,6 @@
-import { Fn, Node, Swizzable } from '../../Nodes.js';
+import Node from '../../core/Node.js';
+import { Fn } from '../../code/FunctionNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
 
-export function mx_hsvtorgb(...params: Fn<[Node]>): Swizzable;
-export function mx_rgbtohsv(...params: Fn<[Node]>): Swizzable;
+export function mx_hsvtorgb(...params: Fn<[Node]>): ShaderNodeObject<Node>;
+export function mx_rgbtohsv(...params: Fn<[Node]>): ShaderNodeObject<Node>;

three/examples/jsm/nodes/materialx/lib/mx_noise.d.ts

@@ -1,6 +1,8 @@
-import { Fn, Node, Swizzable } from '../../Nodes.js';
+import Node from '../../core/Node.js';
+import { Fn } from '../../code/FunctionNode.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
 
-export function mx_perlin_noise_float(...params: Fn<[Node]>): Swizzable;
-export function mx_cell_noise_float(...params: Fn<[Node]>): Swizzable;
-export function mx_worley_noise_float(...params: Fn<[Node]>): Swizzable;
-export function mx_fractal_noise_float(...params: Fn<[Node, Node, Node, Node]>): Swizzable;
+export function mx_perlin_noise_float(...params: Fn<[Node]>): ShaderNodeObject<Node>;
+export function mx_cell_noise_float(...params: Fn<[Node]>): ShaderNodeObject<Node>;
+export function mx_worley_noise_float(...params: Fn<[Node]>): ShaderNodeObject<Node>;
+export function mx_fractal_noise_float(...params: Fn<[Node, Node, Node, Node]>): ShaderNodeObject<Node>;

three/examples/jsm/nodes/math/CondNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class CondNode extends Node {
     condNode: Node;
@@ -7,3 +8,9 @@ export default class CondNode extends Node {
 
     constructor(condNode: Node, ifNode: Node, elseNode: Node);
 }
+
+export function cond(
+    condNode: NodeRepresentation,
+    ifNode: NodeRepresentation,
+    elseNode: NodeRepresentation,
+): ShaderNodeObject<Node>;

three/examples/jsm/nodes/math/MathNode.d.ts

@@ -1,5 +1,6 @@
 import Node from '../core/Node.js';
 import TempNode from '../core/TempNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type MathNodeMethod1 =
     | typeof MathNode.RADIANS
@@ -27,7 +28,11 @@ export type MathNodeMethod1 =
     | typeof MathNode.ONE_MINUS
     | typeof MathNode.DFDX
     | typeof MathNode.DFDY
-    | typeof MathNode.ROUND;
+    | typeof MathNode.ROUND
+    | typeof MathNode.RECIPROCAL
+    | typeof MathNode.TRUNC
+    | typeof MathNode.FWIDTH
+    | typeof MathNode.BITCAST;
 
 export type MathNodeMethod2 =
     | typeof MathNode.ATAN2
@@ -81,6 +86,9 @@ export default class MathNode extends TempNode {
     static DFDY: 'dFdy';
     static ROUND: 'round';
     static RECIPROCAL: 'reciprocal';
+    static TRUNC: 'trunc';
+    static FWIDTH: 'fwidth';
+    static BITCAST: 'bitcast';
 
     // 2 inputs
 
@@ -113,3 +121,128 @@ export default class MathNode extends TempNode {
     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 type Unary = (a: NodeRepresentation) => ShaderNodeObject<MathNode>;
+
+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 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;
+
+export type Ternary = (
+    a: NodeRepresentation,
+    b: NodeRepresentation,
+    c: NodeRepresentation,
+) => ShaderNodeObject<MathNode>;
+
+export const mix: Ternary;
+export const clamp: Ternary;
+export const saturate: Ternary;
+export const refract: Ternary;
+export const smoothstep: Ternary;
+export const faceForward: Ternary;
+
+export const mixElement: Ternary;
+export const smoothstepElement: Ternary;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        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;
+        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;
+    }
+}

three/examples/jsm/nodes/math/OperatorNode.d.ts

@@ -1,5 +1,6 @@
 import TempNode from '../core/TempNode.js';
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type OperatorNodeOp =
     | '='
@@ -29,3 +30,53 @@ export default class OperatorNode extends TempNode {
 
     constructor(op: OperatorNodeOp, ...params: [Node, Node, ...Node[]]);
 }
+
+export 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 assign: 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 xor: Operator;
+export const bitAnd: Operator;
+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;
+        assign: typeof assign;
+        lessThan: typeof lessThan;
+        greaterThan: typeof greaterThan;
+        lessThanEqual: typeof lessThanEqual;
+        greaterThanEqual: typeof greaterThanEqual;
+        and: typeof and;
+        or: typeof or;
+        xor: typeof xor;
+        bitAnd: typeof bitAnd;
+        bitOr: typeof bitOr;
+        bitXor: typeof bitXor;
+        shiftLeft: typeof shiftLeft;
+        shiftRight: typeof shiftRight;
+    }
+}

three/examples/jsm/nodes/procedural/CheckerNode.d.ts

@@ -1,6 +1,9 @@
 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>;