diff --git a/examples-testing/changes.patch b/examples-testing/changes.patch index cd2a8b25c..a6f7de9f4 100644 --- a/examples-testing/changes.patch +++ b/examples-testing/changes.patch @@ -14204,7 +14204,7 @@ index 384311dd4..8d39e8acc 100644 }); } diff --git a/examples-testing/examples/webgpu_backdrop_water.ts b/examples-testing/examples/webgpu_backdrop_water.ts -index a8538cf94..53b975193 100644 +index a8538cf94..ac7a9b71f 100644 --- a/examples-testing/examples/webgpu_backdrop_water.ts +++ b/examples-testing/examples/webgpu_backdrop_water.ts @@ -24,11 +24,13 @@ import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js'; @@ -14226,16 +14226,19 @@ index a8538cf94..53b975193 100644 init(); -@@ -157,7 +159,7 @@ function init() { +@@ -157,7 +159,10 @@ function init() { let transition = waterPosY.add(0.1).saturate().oneMinus(); transition = waterPosY.lessThan(0).select(transition, normalWorld.y.mix(transition, 0)).toVar(); - const colorNode = transition.mix(material.colorNode, material.colorNode.add(waterLayer0)); -+ const colorNode = transition.mix(material.colorNode!, material.colorNode!.add(waterLayer0)); ++ const colorNode = transition.mix( ++ material.colorNode as THREE.Node<'vec4'>, ++ (material.colorNode as THREE.Node<'vec4'>).add(waterLayer0), ++ ); //material.colorNode = colorNode; floor.material.colorNode = colorNode; -@@ -182,7 +184,7 @@ function init() { +@@ -182,7 +187,7 @@ function init() { // gui diff --git a/jsdoc-testing/changes.patch b/jsdoc-testing/changes.patch index a77a31b03..51a8cdc4a 100644 --- a/jsdoc-testing/changes.patch +++ b/jsdoc-testing/changes.patch @@ -10296,7 +10296,7 @@ index 60775a2a1..2ed041bfc 100644 -import { InterleavedBuffer } from '../../core/InterleavedBuffer.js'; -import InputNode from '../core/InputNode.js'; diff --git a/jsdoc-testing/jsdoc/nodes/core/Node.d.ts b/jsdoc-testing/jsdoc/nodes/core/Node.d.ts -index 8299d6c54..1764023d1 100644 +index 8299d6c54..74b76b2cb 100644 --- a/jsdoc-testing/jsdoc/nodes/core/Node.d.ts +++ b/jsdoc-testing/jsdoc/nodes/core/Node.d.ts @@ -1,10 +1,85 @@ @@ -10636,7 +10636,7 @@ index 8299d6c54..1764023d1 100644 /** * This method performs the build of a node. The behavior and return value depend on the current build stage: * - **setup**: Prepares the node and its children for the build process. This process can also create new nodes. Returns the node itself or a variant. -@@ -410,28 +463,161 @@ declare class Node extends EventDispatcher { +@@ -410,28 +463,176 @@ declare class Node extends EventDispatcher { * * @return {Generator} An iterable list of serialized child objects as JSON. */ @@ -10664,7 +10664,9 @@ index 8299d6c54..1764023d1 100644 */ - toJSON(meta: Object | null): Object; + toJSON(meta?: NodeJSONMeta | string): NodeJSONOutputData; -+} + } +-declare namespace Node { +- let captureStackTrace: boolean; + +declare const Node: { + new(nodeType?: TNodeType | null): Node; @@ -10680,12 +10682,10 @@ index 8299d6c54..1764023d1 100644 + +export interface NodeElements { } --declare namespace Node { -- let captureStackTrace: boolean; +-import { EventDispatcher } from '../../core/EventDispatcher.js'; + +export interface NodeExtensions { - } --import { EventDispatcher } from '../../core/EventDispatcher.js'; ++} + +export type NumType = "float" | "int" | "uint"; +export type IntegerType = "int" | "uint"; @@ -10747,6 +10747,18 @@ index 8299d6c54..1764023d1 100644 +export interface FloatVecExtensions { +} + ++export interface FloatOrVecExtensions { ++} ++ ++export interface IntOrVecExtensions { ++} ++ ++export interface UintOrVecExtensions { ++} ++ ++export interface BoolOrVecExtensions { ++} ++ +export interface Mat2Extensions { +} + @@ -10763,36 +10775,39 @@ index 8299d6c54..1764023d1 100644 + & NodeClass + & NodeElements + & (unknown extends TNodeType ? {} : NodeExtensions) -+ & (TNodeType extends "float" ? NumOrBoolExtensions<"float"> & FloatExtensions & NumExtensions<"float"> ++ & (TNodeType extends "float" ? NumOrBoolExtensions<"float"> & FloatExtensions & NumExtensions<"float"> & FloatOrVecExtensions<"float"> + : TNodeType extends "int" -+ ? NumOrBoolExtensions<"int"> & IntExtensions & NumExtensions<"int"> & IntegerExtensions<"int"> ++ ? NumOrBoolExtensions<"int"> & IntExtensions & NumExtensions<"int"> & IntegerExtensions<"int"> & IntOrVecExtensions<"int"> + : TNodeType extends "uint" -+ ? NumOrBoolExtensions<"uint"> & UintExtensions & NumExtensions<"uint"> & IntegerExtensions<"uint"> -+ : TNodeType extends "bool" ? NumOrBoolExtensions<"bool"> & BoolExtensions ++ ? NumOrBoolExtensions<"uint"> & UintExtensions & NumExtensions<"uint"> & IntegerExtensions<"uint"> & IntOrVecExtensions<"uint"> ++ : TNodeType extends "bool" ? NumOrBoolExtensions<"bool"> & BoolExtensions & BoolOrVecExtensions + : TNodeType extends "vec2" ? + & NumOrBoolVec2Extensions<"float"> + & Vec2Extensions + & NumVec2Extensions<"float"> + & FloatVecExtensions<"vec2"> -+ : TNodeType extends "ivec2" ? NumOrBoolVec2Extensions<"int"> & NumVec2Extensions<"int"> -+ : TNodeType extends "uvec2" ? NumOrBoolVec2Extensions<"uint"> & NumVec2Extensions<"uint"> -+ : TNodeType extends "bvec2" ? NumOrBoolVec2Extensions<"bool"> ++ & FloatOrVecExtensions<"vec2"> ++ : TNodeType extends "ivec2" ? NumOrBoolVec2Extensions<"int"> & NumVec2Extensions<"int"> & IntOrVecExtensions<"ivec2"> ++ : TNodeType extends "uvec2" ? NumOrBoolVec2Extensions<"uint"> & NumVec2Extensions<"uint"> & IntOrVecExtensions<"uvec2"> ++ : TNodeType extends "bvec2" ? NumOrBoolVec2Extensions<"bool"> & BoolOrVecExtensions + : TNodeType extends "vec3" ? + & NumOrBoolVec3Extensions<"float"> + & Vec3Extensions + & NumVec3Extensions<"float"> + & FloatVecExtensions<"vec3"> -+ : TNodeType extends "ivec3" ? NumOrBoolVec3Extensions<"int"> & NumVec3Extensions<"int"> -+ : TNodeType extends "uvec3" ? NumOrBoolVec3Extensions<"uint"> & NumVec3Extensions<"uint"> -+ : TNodeType extends "bvec3" ? NumOrBoolVec3Extensions<"bool"> ++ & FloatOrVecExtensions<"vec3"> ++ : TNodeType extends "ivec3" ? NumOrBoolVec3Extensions<"int"> & NumVec3Extensions<"int"> & IntOrVecExtensions<"ivec3"> ++ : TNodeType extends "uvec3" ? NumOrBoolVec3Extensions<"uint"> & NumVec3Extensions<"uint"> & IntOrVecExtensions<"uvec3"> ++ : TNodeType extends "bvec3" ? NumOrBoolVec3Extensions<"bool"> & BoolOrVecExtensions + : TNodeType extends "vec4" ? + & NumOrBoolVec4Extensions<"float"> + & Vec4Extensions + & NumVec4Extensions<"float"> + & FloatVecExtensions<"vec4"> -+ : TNodeType extends "ivec4" ? NumOrBoolVec4Extensions<"int"> & NumVec4Extensions<"int"> -+ : TNodeType extends "uvec4" ? NumOrBoolVec4Extensions<"uint"> & NumVec4Extensions<"uint"> -+ : TNodeType extends "bvec4" ? NumOrBoolVec4Extensions<"bool"> ++ & FloatOrVecExtensions<"vec4"> ++ : TNodeType extends "ivec4" ? NumOrBoolVec4Extensions<"int"> & NumVec4Extensions<"int"> & IntOrVecExtensions<"ivec4"> ++ : TNodeType extends "uvec4" ? NumOrBoolVec4Extensions<"uint"> & NumVec4Extensions<"uint"> & IntOrVecExtensions<"uvec4"> ++ : TNodeType extends "bvec4" ? NumOrBoolVec4Extensions<"bool"> & BoolOrVecExtensions + : TNodeType extends "color" ? ColorExtensions + : TNodeType extends "mat2" ? Mat2Extensions & MatExtensions<"mat2"> + : TNodeType extends "mat3" ? Mat3Extensions & MatExtensions<"mat3"> diff --git a/tsl-testing/MathNode.test.ts b/tsl-testing/MathNode.test.ts new file mode 100644 index 000000000..893cefa7b --- /dev/null +++ b/tsl-testing/MathNode.test.ts @@ -0,0 +1,127 @@ +import { beforeAll, expect, test } from 'vitest'; +import { all, any, atan, bvec2, bvec3, int, normalize, radians, sign, uvec3, vec2, vec3 } from 'three/tsl'; +import * as THREE from 'three/webgpu'; + +const renderer = new THREE.WebGPURenderer(); +const nodeBuilder: THREE.NodeBuilder = renderer.backend.createNodeBuilder(null!, renderer); + +const scene = new THREE.Scene(); +const camera = new THREE.PerspectiveCamera(); + +beforeAll(async () => { + await renderer.init(); +}); + +function assertNode(node: THREE.Node, nodeType: string) { + expect(node).toBeInstanceOf(THREE.Node); + expect(node.getNodeType(nodeBuilder)).toBe(nodeType); + + scene.backgroundNode = node.debug(); + renderer.render(scene, camera); +} + +test('all(boolean)', () => { + const result: THREE.Node<'bool'> = all(true); + assertNode(result, 'bool'); +}); + +test('all(Node<"bvec2">)', () => { + const vec = bvec2(true, false); + const result: THREE.Node<'bool'> = all(vec); + assertNode(result, 'bool'); +}); + +test('bvec3.all()', () => { + const vec = bvec3(true, false, true); + const result: THREE.Node<'bool'> = vec.all(); + assertNode(result, 'bool'); +}); + +test('any(boolean)', () => { + const result: THREE.Node<'bool'> = any(true); + assertNode(result, 'bool'); +}); + +test('any(Node<"bvec2">)', () => { + const vec = bvec2(true, false); + const result: THREE.Node<'bool'> = any(vec); + assertNode(result, 'bool'); +}); + +test('bvec3.any()', () => { + const vec = bvec3(true, false, true); + const result: THREE.Node<'bool'> = vec.any(); + assertNode(result, 'bool'); +}); + +test('radians(number)', () => { + const result: THREE.Node<'float'> = radians(3); + assertNode(result, 'float'); +}); + +test('radians(int)', () => { + const intNode = int(3); + // This is likely to be a mistake because it returns an integer + // @ts-expect-error + radians(intNode); +}); + +test('radians(vec2)', () => { + const vec = vec2(3, 1); + const result: THREE.Node<'vec2'> = radians(vec); + assertNode(result, 'vec2'); +}); + +test('vec3.radians()', () => { + const vec = vec3(3, 1); + const result: THREE.Node<'vec3'> = vec.radians(); + assertNode(result, 'vec3'); +}); + +test('radians(Vector4)', () => { + const vector = new THREE.Vector4(1, 2, 3, 4); + const result: THREE.Node<'vec4'> = radians(vector); + assertNode(result, 'vec4'); +}); + +test('normalize(vec2)', () => { + const vec = vec2(3, 1); + const result: THREE.Node<'vec2'> = normalize(vec); + assertNode(result, 'vec2'); +}); + +test('vec3.normalize()', () => { + const vec = vec3(3, 1); + const result: THREE.Node<'vec3'> = normalize(vec); + assertNode(result, 'vec3'); +}); + +test('vec2.atan(number)', () => { + const vec = vec2(3, 1); + const result: THREE.Node<'vec2'> = vec.atan(5); + assertNode(result, 'vec2'); +}); + +test('atan(number, Vector3)', () => { + const vector = new THREE.Vector3(5, 3, 1); + const result: THREE.Node<'vec3'> = atan(5, vector); + assertNode(result, 'vec3'); +}); + +test('vec2.abs()', () => { + const vec = vec2(5, 3); + const result: THREE.Node<'vec2'> = vec.abs(); + assertNode(result, 'vec2'); +}); + +test('abs(uvec3)', () => { + const vec = uvec3(5, 3, 1); + const result: THREE.Node<'uvec3'> = vec.abs(); + assertNode(result, 'uvec3'); +}); + +test('sign(Vector4)', () => { + const vector = new THREE.Vector4(1, 2, 3, 4); + const result: THREE.Node<'vec4'> = sign(vector); + assertNode(result, 'vec4'); +}); diff --git a/types/three/src/nodes/core/Node.d.ts b/types/three/src/nodes/core/Node.d.ts index 19b6434ef..1ab85044b 100644 --- a/types/three/src/nodes/core/Node.d.ts +++ b/types/three/src/nodes/core/Node.d.ts @@ -563,6 +563,18 @@ export interface ColorExtensions { export interface FloatVecExtensions { } +export interface FloatOrVecExtensions { +} + +export interface IntOrVecExtensions { +} + +export interface UintOrVecExtensions { +} + +export interface BoolOrVecExtensions { +} + export interface Mat2Extensions { } @@ -579,36 +591,54 @@ type Node = & NodeClass & NodeElements & (unknown extends TNodeType ? {} : NodeExtensions) - & (TNodeType extends "float" ? NumOrBoolExtensions<"float"> & FloatExtensions & NumExtensions<"float"> - : TNodeType extends "int" - ? NumOrBoolExtensions<"int"> & IntExtensions & NumExtensions<"int"> & IntegerExtensions<"int"> - : TNodeType extends "uint" - ? NumOrBoolExtensions<"uint"> & UintExtensions & NumExtensions<"uint"> & IntegerExtensions<"uint"> - : TNodeType extends "bool" ? NumOrBoolExtensions<"bool"> & BoolExtensions + & (TNodeType extends "float" + ? NumOrBoolExtensions<"float"> & FloatExtensions & NumExtensions<"float"> & FloatOrVecExtensions<"float"> + : TNodeType extends "int" ? + & NumOrBoolExtensions<"int"> + & IntExtensions + & NumExtensions<"int"> + & IntegerExtensions<"int"> + & IntOrVecExtensions<"int"> + : TNodeType extends "uint" ? + & NumOrBoolExtensions<"uint"> + & UintExtensions + & NumExtensions<"uint"> + & IntegerExtensions<"uint"> + & IntOrVecExtensions<"uint"> + : TNodeType extends "bool" ? NumOrBoolExtensions<"bool"> & BoolExtensions & BoolOrVecExtensions : TNodeType extends "vec2" ? & NumOrBoolVec2Extensions<"float"> & Vec2Extensions & NumVec2Extensions<"float"> & FloatVecExtensions<"vec2"> - : TNodeType extends "ivec2" ? NumOrBoolVec2Extensions<"int"> & NumVec2Extensions<"int"> - : TNodeType extends "uvec2" ? NumOrBoolVec2Extensions<"uint"> & NumVec2Extensions<"uint"> - : TNodeType extends "bvec2" ? NumOrBoolVec2Extensions<"bool"> + & FloatOrVecExtensions<"vec2"> + : TNodeType extends "ivec2" + ? NumOrBoolVec2Extensions<"int"> & NumVec2Extensions<"int"> & IntOrVecExtensions<"ivec2"> + : TNodeType extends "uvec2" + ? NumOrBoolVec2Extensions<"uint"> & NumVec2Extensions<"uint"> & IntOrVecExtensions<"uvec2"> + : TNodeType extends "bvec2" ? NumOrBoolVec2Extensions<"bool"> & BoolOrVecExtensions : TNodeType extends "vec3" ? & NumOrBoolVec3Extensions<"float"> & Vec3Extensions & NumVec3Extensions<"float"> & FloatVecExtensions<"vec3"> - : TNodeType extends "ivec3" ? NumOrBoolVec3Extensions<"int"> & NumVec3Extensions<"int"> - : TNodeType extends "uvec3" ? NumOrBoolVec3Extensions<"uint"> & NumVec3Extensions<"uint"> - : TNodeType extends "bvec3" ? NumOrBoolVec3Extensions<"bool"> + & FloatOrVecExtensions<"vec3"> + : TNodeType extends "ivec3" + ? NumOrBoolVec3Extensions<"int"> & NumVec3Extensions<"int"> & IntOrVecExtensions<"ivec3"> + : TNodeType extends "uvec3" + ? NumOrBoolVec3Extensions<"uint"> & NumVec3Extensions<"uint"> & IntOrVecExtensions<"uvec3"> + : TNodeType extends "bvec3" ? NumOrBoolVec3Extensions<"bool"> & BoolOrVecExtensions : TNodeType extends "vec4" ? & NumOrBoolVec4Extensions<"float"> & Vec4Extensions & NumVec4Extensions<"float"> & FloatVecExtensions<"vec4"> - : TNodeType extends "ivec4" ? NumOrBoolVec4Extensions<"int"> & NumVec4Extensions<"int"> - : TNodeType extends "uvec4" ? NumOrBoolVec4Extensions<"uint"> & NumVec4Extensions<"uint"> - : TNodeType extends "bvec4" ? NumOrBoolVec4Extensions<"bool"> + & FloatOrVecExtensions<"vec4"> + : TNodeType extends "ivec4" + ? NumOrBoolVec4Extensions<"int"> & NumVec4Extensions<"int"> & IntOrVecExtensions<"ivec4"> + : TNodeType extends "uvec4" + ? NumOrBoolVec4Extensions<"uint"> & NumVec4Extensions<"uint"> & IntOrVecExtensions<"uvec4"> + : TNodeType extends "bvec4" ? NumOrBoolVec4Extensions<"bool"> & BoolOrVecExtensions : TNodeType extends "color" ? ColorExtensions : TNodeType extends "mat2" ? Mat2Extensions & MatExtensions<"mat2"> : TNodeType extends "mat3" ? Mat3Extensions & MatExtensions<"mat3"> diff --git a/types/three/src/nodes/math/MathNode.d.ts b/types/three/src/nodes/math/MathNode.d.ts index 420ebf8f6..c2860f7a3 100644 --- a/types/three/src/nodes/math/MathNode.d.ts +++ b/types/three/src/nodes/math/MathNode.d.ts @@ -1,3 +1,4 @@ +import { Color } from "../../math/Color.js"; import { Vector2 } from "../../math/Vector2.js"; import { Vector3 } from "../../math/Vector3.js"; import { Vector4 } from "../../math/Vector4.js"; @@ -143,17 +144,18 @@ export default class MathNode extends TempNode { } type FloatOrNumber = Node<"float"> | number; -type IntOrNumber = Node<"int"> | number; type FloatVector = Node<"vec2"> | Node<"vec3"> | Node<"vec4">; type FloatVectorOrNumber = FloatOrNumber | Node<"vec2"> | Node<"vec3"> | Node<"vec4">; -type BoolVector = Node<"bvec2"> | Node<"bvec3"> | Node<"bvec4">; +type Vec2 = Node<"vec2"> | Vector2; +type Vec3 = Node<"vec3"> | Vector3 | Node<"color"> | Color; +type Vec4 = Node<"vec4"> | Vector4; -type Matrix = Node<"mat2"> | Node<"mat3"> | Node<"mat4">; +type Vec2OrFloat = Vec2 | FloatOrNumber; +type Vec3OrFloat = Vec3 | FloatOrNumber; +type Vec4OrFloat = Vec4 | FloatOrNumber; -type Vec2OrLessOrFloat = FloatOrNumber | Node<"vec2">; -type Vec3OrLessOrFloat = Vec2OrLessOrFloat | Node<"vec3">; -type Vec4OrLessOrFloat = Vec3OrLessOrFloat | Node<"vec4">; +type Matrix = Node<"mat2"> | Node<"mat3"> | Node<"mat4">; export const EPSILON: Node<"float">; export const INFINITY: Node<"float">; @@ -168,62 +170,52 @@ export const TWO_PI: Node<"float">; export const HALF_PI: Node<"float">; -export const all: (x: BoolVector) => Node<"bool">; -export const any: (x: BoolVector) => Node<"bool">; +type BoolOrVector = Node<"bool"> | boolean | Node<"bvec2"> | Node<"bvec3"> | Node<"bvec4">; + +export const all: (x: BoolOrVector) => Node<"bool">; +export const any: (x: BoolOrVector) => Node<"bool">; declare module "../core/Node.js" { - interface BvecExtensions { + interface BoolOrVecExtensions { all: () => Node<"bool">; any: () => Node<"bool">; } } -interface UnaryFunction { +interface UnaryFloatVecFunction { (x: FloatOrNumber): Node<"float">; -} -export const radians: UnaryFunction; -export const degrees: UnaryFunction; -export const exp: UnaryFunction; -export const exp2: UnaryFunction; -export const log: UnaryFunction; -export const log2: UnaryFunction; -export const sqrt: UnaryFunction; -export const inverseSqrt: UnaryFunction; -declare module "../core/Node.js" { - interface FloatExtensions { - radians: () => Node<"float">; - degrees: () => Node<"float">; - exp: () => Node<"float">; - exp2: () => Node<"float">; - log: () => Node<"float">; - log2: () => Node<"float">; - sqrt: () => Node<"float">; - inverseSqrt: () => Node<"float">; - } -} - -interface FloorCeil { - (x: FloatOrNumber): Node<"float">; - (x: Node<"vec2">): Node<"vec2">; - (x: Node<"vec3">): Node<"vec3">; - (x: Node<"vec4">): Node<"vec4">; -} -export const floor: FloorCeil; -export const ceil: FloorCeil; -declare module "../core/Node.js" { - interface FloatExtensions { - floor: () => Node<"float">; - ceil: () => Node<"float">; - } - interface FloatVecExtensions { - floor: () => Node; - ceil: () => Node; + (x: Vec2): Node<"vec2">; + (x: Vec3): Node<"vec3">; + (x: Vec4): Node<"vec4">; +} +export const radians: UnaryFloatVecFunction; +export const degrees: UnaryFloatVecFunction; +export const exp: UnaryFloatVecFunction; +export const exp2: UnaryFloatVecFunction; +export const log: UnaryFloatVecFunction; +export const log2: UnaryFloatVecFunction; +export const sqrt: UnaryFloatVecFunction; +export const inverseSqrt: UnaryFloatVecFunction; +export const floor: UnaryFloatVecFunction; +export const ceil: UnaryFloatVecFunction; +declare module "../core/Node.js" { + interface FloatOrVecExtensions { + radians: () => Node; + degrees: () => Node; + exp: () => Node; + exp2: () => Node; + log: () => Node; + log2: () => Node; + sqrt: () => Node; + inverseSqrt: () => Node; + floor: () => Node; + ceil: () => Node; } } interface Normalize { - (x: Node<"vec2"> | Vector2): Node<"vec2">; - (x: Node<"vec3"> | Vector3): Node<"vec3">; - (x: Node<"vec4"> | Vector4): Node<"vec4">; + (x: Vec2): Node<"vec2">; + (x: Vec3): Node<"vec3">; + (x: Vec4): Node<"vec4">; } export const normalize: Normalize; declare module "../core/Node.js" { @@ -232,118 +224,103 @@ declare module "../core/Node.js" { } } -interface Fract { - (x: FloatOrNumber): Node<"float">; - (x: Node<"vec2">): Node<"vec2">; - (x: Node<"vec3">): Node<"vec3">; - (x: Node<"vec4">): Node<"vec4">; -} -export const fract: Fract; +interface ArcTanFunction { + (y: FloatOrNumber, x?: FloatOrNumber): Node<"float">; + (y: Vec2OrFloat, x?: Vec2OrFloat): Node<"vec2">; + (y: Vec3OrFloat, x?: Vec3OrFloat): Node<"vec3">; + (y: Vec4OrFloat, x?: Vec4OrFloat): Node<"vec4">; +} + +export const fract: UnaryFloatVecFunction; +export const sin: UnaryFloatVecFunction; +export const sinh: UnaryFloatVecFunction; +export const cos: UnaryFloatVecFunction; +export const cosh: UnaryFloatVecFunction; +export const tan: UnaryFloatVecFunction; +export const tanh: UnaryFloatVecFunction; +export const asin: UnaryFloatVecFunction; +export const asinh: UnaryFloatVecFunction; +export const acos: UnaryFloatVecFunction; +export const acosh: UnaryFloatVecFunction; +export const atan: ArcTanFunction; +export const atanh: UnaryFloatVecFunction; + declare module "../core/Node.js" { - interface FloatExtensions { - fract: () => Node<"float">; - } - interface FloatVecExtensions { - fract: () => Node; + interface FloatOrVecExtensions { + fract: () => Node; + sin: () => Node; + sinh: () => Node; + cos: () => Node; + cosh: () => Node; + tan: () => Node; + tanh: () => Node; + asin: () => Node; + asinh: () => Node; + acos: () => Node; + acosh: () => Node; + atanh: () => Node; } } -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 { - sin: () => Node; - sinh: () => Node; - cos: () => Node; - cosh: () => Node; - tan: () => Node; - tanh: () => Node; - asin: () => Node; - asinh: () => Node; - acos: () => Node; - acosh: () => Node; - atanh: () => Node; } interface Vec2Extensions { - atan: (x?: Vec2OrLessOrFloat) => Node<"vec2">; + atan: (x?: Vec2OrFloat) => Node<"vec2">; } interface Vec3Extensions { - atan: (x?: Vec3OrLessOrFloat) => Node<"vec3">; + atan: (x?: Vec3OrFloat) => Node<"vec3">; } interface Vec4Extensions { - atan: (x?: Vec4OrLessOrFloat) => Node<"vec4">; + atan: (x?: Vec4OrFloat) => Node<"vec4">; } } -interface Abs { +interface AbsFunction { (x: FloatOrNumber): Node<"float">; - (x: Node<"vec2">): Node<"vec2">; - (x: Node<"vec3">): Node<"vec3">; - (x: Node<"vec4">): Node<"vec4">; - (x: IntOrNumber): Node<"int">; + (x: Node<"int">): Node<"int">; + (x: Node<"uint">): Node<"uint">; + (x: Vec2): Node<"vec2">; + (x: Node<"ivec2">): Node<"ivec2">; + (x: Node<"uvec2">): Node<"uvec2">; + (x: Vec3): Node<"vec3">; + (x: Node<"ivec3">): Node<"ivec3">; + (x: Node<"uvec3">): Node<"uvec3">; + (x: Vec4): Node<"vec4">; + (x: Node<"ivec4">): Node<"ivec4">; + (x: Node<"uvec4">): Node<"uvec4">; } -export const abs: Abs; +export const abs: AbsFunction; declare module "../core/Node.js" { - interface FloatExtensions { - abs: () => Node<"float">; + interface FloatOrVecExtensions { + abs: () => Node; } - interface IntExtensions { - abs: () => Node<"int">; + interface IntOrVecExtensions { + abs: () => Node; } - interface FloatVecExtensions { - abs: () => Node; + interface UintOrVecExtensions { + abs: () => Node; } } -interface Sign { +interface SignFunction { (x: FloatOrNumber): Node<"float">; - (x: Node<"vec2">): Node<"vec2">; - (x: Node<"vec3">): Node<"vec3">; - (x: Node<"vec4">): Node<"vec4">; + (x: Node<"int">): Node<"int">; + (x: Vec2): Node<"vec2">; + (x: Node<"ivec2">): Node<"ivec2">; + (x: Vec3): Node<"vec3">; + (x: Node<"ivec3">): Node<"ivec3">; + (x: Vec4): Node<"vec4">; + (x: Node<"ivec4">): Node<"ivec4">; } -export const sign: Sign; +export const sign: SignFunction; declare module "../core/Node.js" { - interface FloatExtensions { - sign: () => Node<"float">; + interface FloatOrVecExtensions { + sign: () => Node; } - interface FloatVecExtensions { - sign: () => Node; + interface IntOrVecExtensions { + sign: () => Node; } } @@ -460,29 +437,29 @@ declare module "../core/Node.js" { interface MinMax { (x: FloatOrNumber, y: FloatOrNumber, ...params: FloatOrNumber[]): Node<"float">; - (x: Vec2OrLessOrFloat, y: Vec2OrLessOrFloat, ...params: Vec2OrLessOrFloat[]): Node<"vec2">; - (x: Vec3OrLessOrFloat, y: Vec3OrLessOrFloat, ...params: Vec3OrLessOrFloat[]): Node<"vec3">; - (x: Vec4OrLessOrFloat, y: Vec4OrLessOrFloat, ...params: Vec4OrLessOrFloat[]): Node<"vec4">; + (x: Vec2OrFloat, y: Vec2OrFloat, ...params: Vec2OrFloat[]): Node<"vec2">; + (x: Vec3OrFloat, y: Vec3OrFloat, ...params: Vec3OrFloat[]): Node<"vec3">; + (x: Vec4OrFloat, y: Vec4OrFloat, ...params: Vec4OrFloat[]): Node<"vec4">; } export const min: MinMax; export const max: MinMax; interface MinMaxFloatExtension { (y: FloatOrNumber, ...params: FloatOrNumber[]): Node<"float">; - (y: Vec2OrLessOrFloat, ...params: Vec2OrLessOrFloat[]): Node<"vec2">; - (y: Vec3OrLessOrFloat, ...params: Vec3OrLessOrFloat[]): Node<"vec3">; - (y: Vec4OrLessOrFloat, ...params: Vec4OrLessOrFloat[]): Node<"vec4">; + (y: Vec2OrFloat, ...params: Vec2OrFloat[]): Node<"vec2">; + (y: Vec3OrFloat, ...params: Vec3OrFloat[]): Node<"vec3">; + (y: Vec4OrFloat, ...params: Vec4OrFloat[]): Node<"vec4">; } interface MinMaxVec2Extension { - (y: Vec2OrLessOrFloat, ...params: Vec2OrLessOrFloat[]): Node<"vec2">; - (y: Vec3OrLessOrFloat, ...params: Vec3OrLessOrFloat[]): Node<"vec3">; - (y: Vec4OrLessOrFloat, ...params: Vec4OrLessOrFloat[]): Node<"vec4">; + (y: Vec2OrFloat, ...params: Vec2OrFloat[]): Node<"vec2">; + (y: Vec3OrFloat, ...params: Vec3OrFloat[]): Node<"vec3">; + (y: Vec4OrFloat, ...params: Vec4OrFloat[]): Node<"vec4">; } interface MinMaxVec3Extension { - (y: Vec3OrLessOrFloat, ...params: Vec3OrLessOrFloat[]): Node<"vec3">; - (y: Vec4OrLessOrFloat, ...params: Vec4OrLessOrFloat[]): Node<"vec4">; + (y: Vec3OrFloat, ...params: Vec3OrFloat[]): Node<"vec3">; + (y: Vec4OrFloat, ...params: Vec4OrFloat[]): Node<"vec4">; } interface MinMaxVec4Extension { - (y: Vec4OrLessOrFloat, ...params: Vec4OrLessOrFloat[]): Node<"vec4">; + (y: Vec4OrFloat, ...params: Vec4OrFloat[]): Node<"vec4">; } declare module "../core/Node.js" { interface FloatExtensions { @@ -505,29 +482,29 @@ declare module "../core/Node.js" { interface Step { (x: FloatOrNumber, y: FloatOrNumber): Node<"float">; - (x: Vec2OrLessOrFloat, y: Vec2OrLessOrFloat): Node<"vec2">; - (x: Vec3OrLessOrFloat, y: Vec3OrLessOrFloat): Node<"vec3">; - (x: Vec4OrLessOrFloat, y: Vec4OrLessOrFloat): Node<"vec4">; + (x: Vec2OrFloat, y: Vec2OrFloat): Node<"vec2">; + (x: Vec3OrFloat, y: Vec3OrFloat): Node<"vec3">; + (x: Vec4OrFloat, y: Vec4OrFloat): Node<"vec4">; } export const step: Step; interface Reflect { - (I: Vec2OrLessOrFloat, N: Vec2OrLessOrFloat): Node<"vec2">; - (I: Vec3OrLessOrFloat, N: Vec3OrLessOrFloat): Node<"vec3">; - (I: Vec4OrLessOrFloat, N: Vec4OrLessOrFloat): Node<"vec4">; + (I: Vec2OrFloat, N: Vec2OrFloat): Node<"vec2">; + (I: Vec3OrFloat, N: Vec3OrFloat): Node<"vec3">; + (I: Vec4OrFloat, N: Vec4OrFloat): Node<"vec4">; } export const reflect: Reflect; interface ReflectVec2Extension { - (N: Vec2OrLessOrFloat): Node<"vec2">; - (N: Vec3OrLessOrFloat): Node<"vec3">; - (N: Vec4OrLessOrFloat): Node<"vec4">; + (N: Vec2OrFloat): Node<"vec2">; + (N: Vec3OrFloat): Node<"vec3">; + (N: Vec4OrFloat): Node<"vec4">; } interface ReflectVec3Extension { - (N: Vec3OrLessOrFloat): Node<"vec3">; - (N: Vec4OrLessOrFloat): Node<"vec4">; + (N: Vec3OrFloat): Node<"vec3">; + (N: Vec4OrFloat): Node<"vec4">; } interface ReflectVec4Extension { - (N: Vec4OrLessOrFloat): Node<"vec4">; + (N: Vec4OrFloat): Node<"vec4">; } declare module "../core/Node.js" { interface Vec2Extensions { @@ -553,28 +530,28 @@ declare module "../core/Node.js" { interface Difference { (x: FloatOrNumber, y: FloatOrNumber): Node<"float">; - (x: Vec2OrLessOrFloat, y: Vec2OrLessOrFloat): Node<"vec2">; - (x: Vec3OrLessOrFloat, y: Vec3OrLessOrFloat): Node<"vec3">; - (x: Vec4OrLessOrFloat, y: Vec4OrLessOrFloat): Node<"vec4">; + (x: Vec2OrFloat, y: Vec2OrFloat): Node<"vec2">; + (x: Vec3OrFloat, y: Vec3OrFloat): Node<"vec3">; + (x: Vec4OrFloat, y: Vec4OrFloat): Node<"vec4">; } export const difference: Difference; interface DifferenceFloatExtension { (y: FloatOrNumber): Node<"float">; - (y: Vec2OrLessOrFloat): Node<"vec2">; - (y: Vec3OrLessOrFloat): Node<"vec3">; - (y: Vec4OrLessOrFloat): Node<"vec4">; + (y: Vec2OrFloat): Node<"vec2">; + (y: Vec3OrFloat): Node<"vec3">; + (y: Vec4OrFloat): Node<"vec4">; } interface DifferenceVec2Extension { - (y: Vec2OrLessOrFloat): Node<"vec2">; - (y: Vec3OrLessOrFloat): Node<"vec3">; - (y: Vec4OrLessOrFloat): Node<"vec4">; + (y: Vec2OrFloat): Node<"vec2">; + (y: Vec3OrFloat): Node<"vec3">; + (y: Vec4OrFloat): Node<"vec4">; } interface DifferenceVec3Extension { - (y: Vec3OrLessOrFloat): Node<"vec3">; - (y: Vec4OrLessOrFloat): Node<"vec4">; + (y: Vec3OrFloat): Node<"vec3">; + (y: Vec4OrFloat): Node<"vec4">; } interface DifferenceVec4Extension { - (y: Vec4OrLessOrFloat): Node<"vec4">; + (y: Vec4OrFloat): Node<"vec4">; } declare module "../core/Node.js" { interface FloatExtensions { @@ -666,36 +643,36 @@ declare module "../core/Node.js" { interface Mix { (a: FloatOrNumber, b: FloatOrNumber, t: FloatOrNumber): Node<"float">; - (a: Vec2OrLessOrFloat, b: Vec2OrLessOrFloat, t: FloatOrNumber): Node<"vec2">; - (a: Vec3OrLessOrFloat | Node<"color">, b: Vec3OrLessOrFloat | Node<"color">, t: FloatOrNumber): Node<"vec3">; - (a: Vec4OrLessOrFloat, b: Vec4OrLessOrFloat, t: FloatOrNumber): Node<"vec4">; + (a: Vec2OrFloat, b: Vec2OrFloat, t: FloatOrNumber): Node<"vec2">; + (a: Vec3OrFloat, b: Vec3OrFloat, t: FloatOrNumber): Node<"vec3">; + (a: Vec4OrFloat | Vec3, b: Vec4OrFloat | Vec3, t: FloatOrNumber): Node<"vec4">; } export const mix: Mix; interface Clamp { (value: FloatOrNumber, low?: FloatOrNumber, high?: FloatOrNumber): Node<"float">; - (value: Vec2OrLessOrFloat, low?: Vec2OrLessOrFloat, high?: Vec2OrLessOrFloat): Node<"vec2">; - (value: Vec3OrLessOrFloat, low?: Vec3OrLessOrFloat, high?: Vec3OrLessOrFloat): Node<"vec3">; - (value: Vec4OrLessOrFloat, low?: Vec4OrLessOrFloat, high?: Vec4OrLessOrFloat): Node<"vec4">; + (value: Vec2OrFloat, low?: Vec2OrFloat, high?: Vec2OrFloat): Node<"vec2">; + (value: Vec3OrFloat, low?: Vec3OrFloat, high?: Vec3OrFloat): Node<"vec3">; + (value: Vec4OrFloat, low?: Vec4OrFloat, high?: Vec4OrFloat): Node<"vec4">; } export const clamp: Clamp; interface ClampFloatExtension { (low?: FloatOrNumber, high?: FloatOrNumber): Node<"float">; - (low?: Vec2OrLessOrFloat, high?: Vec2OrLessOrFloat): Node<"vec2">; - (low?: Vec3OrLessOrFloat, high?: Vec3OrLessOrFloat): Node<"vec3">; - (low?: Vec4OrLessOrFloat, high?: Vec4OrLessOrFloat): Node<"vec4">; + (low?: Vec2OrFloat, high?: Vec2OrFloat): Node<"vec2">; + (low?: Vec3OrFloat, high?: Vec3OrFloat): Node<"vec3">; + (low?: Vec4OrFloat, high?: Vec4OrFloat): Node<"vec4">; } interface ClampVec2Extension { - (low?: Vec2OrLessOrFloat, high?: Vec2OrLessOrFloat): Node<"vec2">; - (low?: Vec3OrLessOrFloat, high?: Vec3OrLessOrFloat): Node<"vec3">; - (low?: Vec4OrLessOrFloat, high?: Vec4OrLessOrFloat): Node<"vec4">; + (low?: Vec2OrFloat, high?: Vec2OrFloat): Node<"vec2">; + (low?: Vec3OrFloat, high?: Vec3OrFloat): Node<"vec3">; + (low?: Vec4OrFloat, high?: Vec4OrFloat): Node<"vec4">; } interface ClampVec3Extension { - (low?: Vec3OrLessOrFloat, high?: Vec3OrLessOrFloat): Node<"vec3">; - (low?: Vec4OrLessOrFloat, high?: Vec4OrLessOrFloat): Node<"vec4">; + (low?: Vec3OrFloat, high?: Vec3OrFloat): Node<"vec3">; + (low?: Vec4OrFloat, high?: Vec4OrFloat): Node<"vec4">; } interface ClampVec4Extension { - (low?: Vec4OrLessOrFloat, high?: Vec4OrLessOrFloat): Node<"vec4">; + (low?: Vec4OrFloat, high?: Vec4OrFloat): Node<"vec4">; } declare module "../core/Node.js" { interface FloatExtensions { @@ -729,22 +706,22 @@ declare module "../core/Node.js" { } interface Refract { - (I: Vec2OrLessOrFloat, N: Vec2OrLessOrFloat, ratio: FloatOrNumber): Node<"vec2">; - (I: Vec3OrLessOrFloat, N: Vec3OrLessOrFloat, ratio: FloatOrNumber): Node<"vec3">; - (I: Vec4OrLessOrFloat, N: Vec4OrLessOrFloat, ratio: FloatOrNumber): Node<"vec4">; + (I: Vec2OrFloat, N: Vec2OrFloat, ratio: FloatOrNumber): Node<"vec2">; + (I: Vec3OrFloat, N: Vec3OrFloat, ratio: FloatOrNumber): Node<"vec3">; + (I: Vec4OrFloat, N: Vec4OrFloat, ratio: FloatOrNumber): Node<"vec4">; } export const refract: Refract; interface RefractVec2Extension { - (N: Vec2OrLessOrFloat, ratio: FloatOrNumber): Node<"vec2">; - (N: Vec3OrLessOrFloat, ratio: FloatOrNumber): Node<"vec3">; - (N: Vec4OrLessOrFloat, ratio: FloatOrNumber): Node<"vec4">; + (N: Vec2OrFloat, ratio: FloatOrNumber): Node<"vec2">; + (N: Vec3OrFloat, ratio: FloatOrNumber): Node<"vec3">; + (N: Vec4OrFloat, ratio: FloatOrNumber): Node<"vec4">; } interface RefractVec3Extension { - (N: Vec3OrLessOrFloat, ratio: FloatOrNumber): Node<"vec3">; - (N: Vec4OrLessOrFloat, ratio: FloatOrNumber): Node<"vec4">; + (N: Vec3OrFloat, ratio: FloatOrNumber): Node<"vec3">; + (N: Vec4OrFloat, ratio: FloatOrNumber): Node<"vec4">; } interface RefractVec4Extension { - (N: Vec4OrLessOrFloat, ratio: FloatOrNumber): Node<"vec4">; + (N: Vec4OrFloat, ratio: FloatOrNumber): Node<"vec4">; } declare module "../core/Node.js" { interface Vec2Extensions { @@ -760,29 +737,29 @@ declare module "../core/Node.js" { interface Smoothstep { (low: FloatOrNumber, high: FloatOrNumber, x: FloatOrNumber): Node<"float">; - (low: Vec2OrLessOrFloat, high: Vec2OrLessOrFloat, x: Vec2OrLessOrFloat): Node<"vec2">; - (low: Vec3OrLessOrFloat, high: Vec3OrLessOrFloat, x: Vec3OrLessOrFloat): Node<"vec3">; - (low: Vec4OrLessOrFloat, high: Vec4OrLessOrFloat, x: Vec4OrLessOrFloat): Node<"vec4">; + (low: Vec2OrFloat, high: Vec2OrFloat, x: Vec2OrFloat): Node<"vec2">; + (low: Vec3OrFloat, high: Vec3OrFloat, x: Vec3OrFloat): Node<"vec3">; + (low: Vec4OrFloat, high: Vec4OrFloat, x: Vec4OrFloat): Node<"vec4">; } export const smoothstep: Smoothstep; interface FaceForward { - (N: Vec2OrLessOrFloat, I: Vec2OrLessOrFloat, Nref: Vec2OrLessOrFloat): Node<"vec2">; - (N: Vec3OrLessOrFloat, I: Vec3OrLessOrFloat, Nref: Vec3OrLessOrFloat): Node<"vec3">; - (N: Vec4OrLessOrFloat, I: Vec4OrLessOrFloat, Nref: Vec4OrLessOrFloat): Node<"vec4">; + (N: Vec2OrFloat, I: Vec2OrFloat, Nref: Vec2OrFloat): Node<"vec2">; + (N: Vec3OrFloat, I: Vec3OrFloat, Nref: Vec3OrFloat): Node<"vec3">; + (N: Vec4OrFloat, I: Vec4OrFloat, Nref: Vec4OrFloat): Node<"vec4">; } export const faceForward: FaceForward; interface FaceForwardVec2Extension { - (I: Vec2OrLessOrFloat, Nref: Vec2OrLessOrFloat): Node<"vec2">; - (I: Vec3OrLessOrFloat, Nref: Vec3OrLessOrFloat): Node<"vec3">; - (I: Vec4OrLessOrFloat, Nref: Vec4OrLessOrFloat): Node<"vec4">; + (I: Vec2OrFloat, Nref: Vec2OrFloat): Node<"vec2">; + (I: Vec3OrFloat, Nref: Vec3OrFloat): Node<"vec3">; + (I: Vec4OrFloat, Nref: Vec4OrFloat): Node<"vec4">; } interface FaceForwardVec3Extension { - (N: Vec3OrLessOrFloat, ratio: Vec3OrLessOrFloat): Node<"vec3">; - (N: Vec4OrLessOrFloat, ratio: Vec4OrLessOrFloat): Node<"vec4">; + (N: Vec3OrFloat, ratio: Vec3OrFloat): Node<"vec3">; + (N: Vec4OrFloat, ratio: Vec4OrFloat): Node<"vec4">; } interface FaceForwardVec4Extension { - (N: Vec4OrLessOrFloat, ratio: Vec4OrLessOrFloat): Node<"vec4">; + (N: Vec4OrFloat, ratio: Vec4OrFloat): Node<"vec4">; } declare module "../core/Node.js" { interface Vec2Extensions { @@ -805,16 +782,16 @@ declare module "../core/Node.js" { interface MixElement { (t: FloatOrNumber, e1: FloatOrNumber, e2: FloatOrNumber): Node<"float">; - (t: FloatOrNumber, e1: Vec2OrLessOrFloat, e2: Vec2OrLessOrFloat): Node<"vec2">; - (t: FloatOrNumber, e1: Vec3OrLessOrFloat | Node<"color">, e2: Vec3OrLessOrFloat | Node<"color">): Node<"vec3">; - (t: FloatOrNumber, e1: Vec4OrLessOrFloat, e2: Vec4OrLessOrFloat): Node<"vec4">; + (t: FloatOrNumber, e1: Vec2OrFloat, e2: Vec2OrFloat): Node<"vec2">; + (t: FloatOrNumber, e1: Vec3OrFloat, e2: Vec3OrFloat): Node<"vec3">; + (t: FloatOrNumber, e1: Vec4OrFloat | Vec3, e2: Vec4OrFloat | Vec3): Node<"vec4">; } export const mixElement: MixElement; interface MixExtension { (e1: FloatOrNumber, e2: FloatOrNumber): Node<"float">; - (e1: Vec2OrLessOrFloat, e2: Vec2OrLessOrFloat): Node<"vec2">; - (e1: Vec3OrLessOrFloat | Node<"color">, e2: Vec3OrLessOrFloat | Node<"color">): Node<"vec3">; - (e1: Vec4OrLessOrFloat | Node<"color">, e2: Vec4OrLessOrFloat | Node<"color">): Node<"vec4">; + (e1: Vec2OrFloat, e2: Vec2OrFloat): Node<"vec2">; + (e1: Vec3OrFloat, e2: Vec3OrFloat): Node<"vec3">; + (e1: Vec4OrFloat | Vec3, e2: Vec4OrFloat | Vec3): Node<"vec4">; } declare module "../core/Node.js" { interface FloatExtensions { @@ -824,22 +801,22 @@ declare module "../core/Node.js" { interface SmoothstepElement { (x: FloatOrNumber, low: FloatOrNumber, high: FloatOrNumber): Node<"float">; - (x: Vec2OrLessOrFloat, low: Vec2OrLessOrFloat, high: Vec2OrLessOrFloat): Node<"vec2">; - (x: Vec3OrLessOrFloat, low: Vec3OrLessOrFloat, high: Vec3OrLessOrFloat): Node<"vec3">; - (x: Vec4OrLessOrFloat, low: Vec4OrLessOrFloat, high: Vec4OrLessOrFloat): Node<"vec4">; + (x: Vec2OrFloat, low: Vec2OrFloat, high: Vec2OrFloat): Node<"vec2">; + (x: Vec3OrFloat, low: Vec3OrFloat, high: Vec3OrFloat): Node<"vec3">; + (x: Vec4OrFloat, low: Vec4OrFloat, high: Vec4OrFloat): Node<"vec4">; } export const smoothstepElement: SmoothstepElement; interface SmoothstepFloatExtension { (low: FloatOrNumber, high: FloatOrNumber): Node<"float">; } interface SmoothstepVec2Extension { - (low: Vec2OrLessOrFloat, high: Vec2OrLessOrFloat): Node<"vec2">; + (low: Vec2OrFloat, high: Vec2OrFloat): Node<"vec2">; } interface SmoothstepVec3Extension { - (low: Vec3OrLessOrFloat, high: Vec3OrLessOrFloat): Node<"vec3">; + (low: Vec3OrFloat, high: Vec3OrFloat): Node<"vec3">; } interface SmoothstepVec4Extension { - (low: Vec4OrLessOrFloat, high: Vec4OrLessOrFloat): Node<"vec4">; + (low: Vec4OrFloat, high: Vec4OrFloat): Node<"vec4">; } declare module "../core/Node.js" { interface FloatExtensions { @@ -858,9 +835,9 @@ declare module "../core/Node.js" { interface StepElement { (x: FloatOrNumber, edge: FloatOrNumber): Node<"float">; - (x: Vec2OrLessOrFloat, edge: Vec2OrLessOrFloat): Node<"vec2">; - (x: Vec3OrLessOrFloat, edge: Vec3OrLessOrFloat): Node<"vec3">; - (x: Vec4OrLessOrFloat, edge: Vec4OrLessOrFloat): Node<"vec4">; + (x: Vec2OrFloat, edge: Vec2OrFloat): Node<"vec2">; + (x: Vec3OrFloat, edge: Vec3OrFloat): Node<"vec3">; + (x: Vec4OrFloat, edge: Vec4OrFloat): Node<"vec4">; } export const stepElement: StepElement; declare module "../core/Node.js" { @@ -868,13 +845,13 @@ declare module "../core/Node.js" { step: (edge: FloatOrNumber) => Node<"float">; } interface Vec2Extensions { - step: (edge: Vec2OrLessOrFloat) => Node<"vec2">; + step: (edge: Vec2OrFloat) => Node<"vec2">; } interface Vec3Extensions { - step: (edge: Vec3OrLessOrFloat) => Node<"vec3">; + step: (edge: Vec3OrFloat) => Node<"vec3">; } interface Vec4Extensions { - step: (edge: Vec4OrLessOrFloat) => Node<"vec4">; + step: (edge: Vec4OrFloat) => Node<"vec4">; } }