glre 0.27.0 → 0.29.0

package/src/node/const.ts

@@ -1,26 +1,49 @@
 export const SWIZZLES = ['x', 'y', 'z', 'w', 'r', 'g', 'b', 'a', 's', 't', 'p', 'q'] as const
 
-export const NODE_TYPES = [
-        'float',
-        'int',
-        'uint',
+export const CONSTANTS = [
         'bool',
-        'color',
-        'vec2',
-        'vec3',
-        'vec4',
-        'mat2',
-        'mat3',
-        'mat4',
+        'uint',
+        'int',
+        'float',
+        'bvec2',
+        'bvec3',
+        'bvec4',
         'ivec2',
         'ivec3',
         'ivec4',
         'uvec2',
         'uvec3',
         'uvec4',
-        'bvec2',
-        'bvec3',
-        'bvec4',
+        'vec2',
+        'vec3',
+        'vec4',
+        'color',
+        'mat2',
+        'mat3',
+        'mat4',
+] as const
+
+export const CONVERSIONS = [
+        'toFloat',
+        'toInt',
+        'toUint',
+        'toBool',
+        'toVec2',
+        'toVec3',
+        'toVec4',
+        'toIvec2',
+        'toIvec3',
+        'toIvec4',
+        'toUvec2',
+        'toUvec3',
+        'toUvec4',
+        'toBvec2',
+        'toBvec3',
+        'toBvec4',
+        'toMat2',
+        'toMat3',
+        'toMat4',
+        'toColor',
 ] as const
 
 export const OPERATORS = {
@@ -46,62 +69,73 @@ export const OPERATORS = {
 
 export const OPERATOR_KEYS = Object.keys(OPERATORS) as (keyof typeof OPERATORS)[]
 
-export const FUNCTIONS = [
+export const SCALAR_RETURN_FUNCTIONS = ['dot', 'distance', 'length', 'lengthSq', 'determinant', 'luminance'] as const
+
+export const BOOL_RETURN_FUNCTIONS = ['all', 'any'] as const
+
+export const PRESERVE_TYPE_FUNCTIONS = [
         'abs',
-        'acos',
-        'asin',
-        'atan',
-        'atan2',
+        'sign',
+        'floor',
         'ceil',
-        'clamp',
+        'round',
+        'fract',
+        'trunc',
+        'sin',
         'cos',
-        'cross',
-        'degrees',
-        'distance',
-        'dot',
+        'tan',
+        'asin',
+        'acos',
+        'atan',
         'exp',
         'exp2',
+        'log',
+        'log2',
+        'sqrt',
+        'inverseSqrt',
+        'normalize',
+        'oneMinus',
+        'saturate',
+        'negate',
+        'reciprocal',
+        'dFdx',
+        'dFdy',
+        'fwidth',
+] as const
+
+export const VEC3_RETURN_FUNCTIONS = ['cross'] as const
+
+export const FIRST_ARG_TYPE_FUNCTIONS = ['reflect', 'refract'] as const
+
+export const HIGHEST_TYPE_FUNCTIONS = ['min', 'max', 'mix', 'clamp', 'step', 'smoothstep'] as const
+
+export const VEC4_RETURN_FUNCTIONS = ['texture', 'textureLod', 'textureSize', 'cubeTexture'] as const
+
+export const ADDITIONAL_FUNCTIONS = [
+        'atan2',
+        'degrees',
         'faceforward',
-        'floor',
-        'fract',
-        'length',
-        'all',
-        'any',
         'bitcast',
         'cbrt',
-        'dFdx',
-        'dFdy',
         'difference',
         'equals',
-        'fwidth',
-        'inverseSqrt',
-        'lengthSq',
-        'log',
-        'log2',
-        'max',
-        'min',
-        'mix',
-        'negate',
-        'normalize',
-        'oneMinus',
         'pow',
         'pow2',
         'pow3',
         'pow4',
         'radians',
-        'reciprocal',
-        'reflect',
-        'refract',
-        'round',
-        'saturate',
-        'sign',
-        'sin',
-        'smoothstep',
-        'sqrt',
-        'step',
-        'tan',
         'transformDirection',
-        'trunc',
+] as const
+
+export const FUNCTIONS = [
+        ...SCALAR_RETURN_FUNCTIONS,
+        ...BOOL_RETURN_FUNCTIONS,
+        ...PRESERVE_TYPE_FUNCTIONS,
+        ...VEC3_RETURN_FUNCTIONS,
+        ...FIRST_ARG_TYPE_FUNCTIONS,
+        ...HIGHEST_TYPE_FUNCTIONS,
+        ...VEC4_RETURN_FUNCTIONS,
+        ...ADDITIONAL_FUNCTIONS,
 ] as const
 
 export const TYPE_MAPPING = {
@@ -125,3 +159,71 @@ export const TYPE_MAPPING = {
         bvec3: 'vec3<bool>',
         bvec4: 'vec4<bool>',
 } as const
+
+export const COMPONENT_COUNT_TO_TYPE = {
+        1: 'float',
+        2: 'vec2',
+        3: 'vec3',
+        4: 'vec4',
+        9: 'mat3',
+        16: 'mat4',
+} as const
+
+export const BUILTIN_TYPES = {
+        // WGSL builtin variables
+        position: 'vec4',
+        vertex_index: 'uint',
+        instance_index: 'uint',
+        front_facing: 'bool',
+        frag_depth: 'float',
+        sample_index: 'uint',
+        sample_mask: 'uint',
+        point_coord: 'vec2',
+
+        // TSL compatible variables
+        positionLocal: 'vec3',
+        positionWorld: 'vec3',
+        positionView: 'vec3',
+        normalLocal: 'vec3',
+        normalWorld: 'vec3',
+        normalView: 'vec3',
+        screenCoordinate: 'vec2',
+        screenUV: 'vec2',
+
+        // Legacy GLSL variables (for backward compatibility)
+        gl_FragCoord: 'vec4',
+        gl_VertexID: 'uint',
+        gl_InstanceID: 'uint',
+        gl_FrontFacing: 'bool',
+        gl_FragDepth: 'float',
+        gl_SampleID: 'uint',
+        gl_SampleMask: 'uint',
+        gl_PointCoord: 'vec2',
+
+        // Common variables
+        normal: 'vec3',
+        uv: 'vec2',
+        color: 'vec4',
+} as const
+
+export const COMPARISON_OPERATORS = [
+        'equal',
+        'notEqual',
+        'lessThan',
+        'lessThanEqual',
+        'greaterThan',
+        'greaterThanEqual',
+] as const
+
+export const LOGICAL_OPERATORS = ['and', 'or'] as const
+
+export const WGSL_TO_GLSL_BUILTIN = {
+        position: 'gl_FragCoord',
+        vertex_index: 'gl_VertexID',
+        instance_index: 'gl_InstanceID',
+        front_facing: 'gl_FrontFacing',
+        frag_depth: 'gl_FragDepth',
+        sample_index: 'gl_SampleID',
+        sample_mask: 'gl_SampleMask',
+        point_coord: 'gl_PointCoord',
+} as const

package/src/node/index.ts

@@ -1,91 +1,137 @@
-import { f, n, node, u } from './node'
+import { conversion as c, function_ as f, node } from './node'
+import { hex2rgb } from './utils'
+import { is } from '../utils/helpers'
 import type { X } from './types'
 export * from './code'
 export * from './const'
+export * from './infer'
 export * from './node'
 export * from './scope'
 export * from './types'
 export * from './utils'
 
+// x ? y : z
+export const select = (x: X, y: X, z: X) => node('ternary', null, x, y, z)
+
+// uniform and attribute
+export const uniform = (value: number | number[], id?: string) => node('uniform', { id, value })
+export const varying = (value: number | number[], id?: string) => node('varying', { id, value })
+export const attribute = (value: number | number[], id?: string) => node('varying', { id, value })
+export const variable = (id: string) => node('variable', { id })
+export const builtin = (id: string) => node('builtin', { id })
+
 // Default uniforms
-export const iResolution = u('iResolution', [1280, 800])
-export const iMouse = u('iMouse', [0, 0])
-export const iTime = u('iTime', 0)
-export const fragCoord = node('variable', { id: 'fragCoord' })
+export const iResolution = uniform([1280, 800], 'iResolution')
+export const iMouse = uniform([0, 0], 'iMouse')
+export const iTime = uniform(0, 'iTime')
+
+// Builtin Variables
+export const position = node('builtin', { id: 'position' })
+export const vertexIndex = node('builtin', { id: 'vertex_index' })
+export const instanceIndex = node('builtin', { id: 'instance_index' })
+export const frontFacing = node('builtin', { id: 'front_facing' })
+export const fragDepth = node('builtin', { id: 'frag_depth' })
+export const sampleIndex = node('builtin', { id: 'sample_index' })
+export const sampleMask = node('builtin', { id: 'sample_mask' })
+export const pointCoord = node('builtin', { id: 'point_coord' })
+
+// TSL Compatible Builtin Variables
+export const positionLocal = node('builtin', { id: 'position' })
+export const positionWorld = node('builtin', { id: 'positionWorld' })
+export const positionView = node('builtin', { id: 'positionView' })
+export const normalLocal = node('builtin', { id: 'normalLocal' })
+export const normalWorld = node('builtin', { id: 'normalWorld' })
+export const normalView = node('builtin', { id: 'normalView' })
+export const screenCoordinate = node('builtin', { id: 'screenCoordinate' })
+export const screenUV = node('builtin', { id: 'screenUV' })
+
+// Legacy aliases for backward compatibility
+export const fragCoord = position
+export const vertexId = vertexIndex
 
 // Type constructors
-export const float = (x: X) => n('float', x)
-export const int = (x: X) => n('int', x)
-export const uint = (x: X) => n('uint', x)
-export const bool = (x: X) => n('bool', x)
-export const vec2 = (x?: X, y?: X) => n('vec2', x, y)
-export const vec3 = (x?: X, y?: X, z?: X) => n('vec3', x, y, z)
-export const vec4 = (x?: X, y?: X, z?: X, w?: X) => n('vec4', x, y, z, w)
-export const mat2 = (...args: X[]) => n('mat2', ...args)
-export const mat3 = (...args: X[]) => n('mat3', ...args)
-export const mat4 = (...args: X[]) => n('mat4', ...args)
-export const ivec2 = (x?: X, y?: X) => n('ivec2', x, y)
-export const ivec3 = (x?: X, y?: X, z?: X) => n('ivec3', x, y, z)
-export const ivec4 = (x?: X, y?: X, z?: X, w?: X) => n('ivec4', x, y, z, w)
-export const uvec2 = (x?: X, y?: X) => n('uvec2', x, y)
-export const uvec3 = (x?: X, y?: X, z?: X) => n('uvec3', x, y, z)
-export const uvec4 = (x?: X, y?: X, z?: X, w?: X) => n('uvec4', x, y, z, w)
-export const bvec2 = (x?: X, y?: X) => n('bvec2', x, y)
-export const bvec3 = (x?: X, y?: X, z?: X) => n('bvec3', x, y, z)
-export const bvec4 = (x?: X, y?: X, z?: X, w?: X) => n('bvec4', x, y, z, w)
+export const float = (x: X) => c('float', x)
+export const int = (x: X) => c('int', x)
+export const uint = (x: X) => c('uint', x)
+export const bool = (x: X) => c('bool', x)
+export const vec2 = (x?: X, y?: X) => c('vec2', x, y)
+export const vec3 = (x?: X, y?: X, z?: X) => c('vec3', x, y, z)
+export const vec4 = (x?: X, y?: X, z?: X, w?: X) => c('vec4', x, y, z, w)
+export const mat2 = (...args: X[]) => c('mat2', ...args)
+export const mat3 = (...args: X[]) => c('mat3', ...args)
+export const mat4 = (...args: X[]) => c('mat4', ...args)
+export const ivec2 = (x?: X, y?: X) => c('ivec2', x, y)
+export const ivec3 = (x?: X, y?: X, z?: X) => c('ivec3', x, y, z)
+export const ivec4 = (x?: X, y?: X, z?: X, w?: X) => c('ivec4', x, y, z, w)
+export const uvec2 = (x?: X, y?: X) => c('uvec2', x, y)
+export const uvec3 = (x?: X, y?: X, z?: X) => c('uvec3', x, y, z)
+export const uvec4 = (x?: X, y?: X, z?: X, w?: X) => c('uvec4', x, y, z, w)
+export const bvec2 = (x?: X, y?: X) => c('bvec2', x, y)
+export const bvec3 = (x?: X, y?: X, z?: X) => c('bvec3', x, y, z)
+export const bvec4 = (x?: X, y?: X, z?: X, w?: X) => c('bvec4', x, y, z, w)
+export const color = (r?: X, g?: X, b?: X) => {
+        if (is.num(r) && is.und(g) && is.und(b)) return vec3(...hex2rgb(r))
+        return vec3(r, g, b)
+}
+
+// Texture Functions
+export const texture = (x: X, y: X, z?: X) => f('texture', x, y, z)
+export const cubeTexture = (x: X, y: X, z?: X) => f('cubeTexture', x, y, z)
+export const textureSize = (x: X, y?: X) => f('textureSize', x, y)
 
 // Math Functions
-export const abs = (x: X) => f('abs', x) // Return the absolute value of the parameter.
-export const acos = (x: X) => f('acos', x) // Return the arccosine of the parameter.
-export const all = (x: X) => f('all', x) // Return true if all components of x are true.
-export const any = (x: X) => f('any', x) // Return true if any component of x is true.
-export const asin = (x: X) => f('asin', x) // Return the arcsine of the parameter.
-export const atan = (y: X, x: X) => f('atan', y, x) // Return the arc-tangent of the parameters.
-export const bitcast = (x: X, y: X) => f('bitcast', x, y) // Reinterpret the bits of a value as a different type.
-export const cbrt = (x: X) => f('cbrt', x) // Return the cube root of the parameter.
-export const ceil = (x: X) => f('ceil', x) // Find the nearest integer that is greater than or equal to the parameter.
-export const clamp = (x: X, min: X, max: X) => f('clamp', x, min, max) // Constrain a value to lie between two further values.
-export const cos = (x: X) => f('cos', x) // Return the cosine of the parameter.
-export const cross = (x: X, y: X) => f('cross', x, y) // Calculate the cross product of two vectors.
-export const dFdx = (p: X) => f('dFdx', p) // Return the partial derivative of an argument with respect to x.
-export const dFdy = (p: X) => f('dFdy', p) // Return the partial derivative of an argument with respect to y.
-export const degrees = (radians: X) => f('degrees', radians) // Convert a quantity in radians to degrees.
-export const difference = (x: X, y: X) => f('difference', x, y) // Calculate the absolute difference between two values.
-export const distance = (x: X, y: X) => f('distance', x, y) // Calculate the distance between two points.
-export const dot = (x: X, y: X) => f('dot', x, y) // Calculate the dot product of two vectors.
-export const equals = (x: X, y: X) => f('equals', x, y) // Return true if x equals y.
-export const exp = (x: X) => f('exp', x) // Return the natural exponentiation of the parameter.
-export const exp2 = (x: X) => f('exp2', x) // Return 2 raised to the power of the parameter.
-export const faceforward = (N: X, I: X, Nref: X) => f('faceforward', N, I, Nref) // Return a vector pointing in the same direction as another.
-export const floor = (x: X) => f('floor', x) // Find the nearest integer less than or equal to the parameter.
-export const fract = (x: X) => f('fract', x) // Compute the fractional part of the argument.
-export const fwidth = (x: X) => f('fwidth', x) // Return the sum of the absolute derivatives in x and y.
-export const inverseSqrt = (x: X) => f('inverseSqrt', x) // Return the inverse of the square root of the parameter.
-export const length = (x: X) => f('length', x) // Calculate the length of a vector.
-export const lengthSq = (x: X) => f('lengthSq', x) // Calculate the squared length of a vector.
-export const log = (x: X) => f('log', x) // Return the natural logarithm of the parameter.
-export const log2 = (x: X) => f('log2', x) // Return the base 2 logarithm of the parameter.
-export const max = (x: X, y: X) => f('max', x, y) // Return the greater of two values.
-export const min = (x: X, y: X) => f('min', x, y) // Return the lesser of two values.
-export const mix = (x: X, y: X, a: X) => f('mix', x, y, a) // Linearly interpolate between two values.
-export const negate = (x: X) => f('negate', x) // Negate the value of the parameter ( -x ).
-export const normalize = (x: X) => f('normalize', x) // Calculate the unit vector in the same direction as the original vector.
-export const oneMinus = (x: X) => f('oneMinus', x) // Return 1 minus the parameter.
-export const pow = (x: X, y: X) => f('pow', x, y) // Return the value of the first parameter raised to the power of the second.
-export const pow2 = (x: X) => f('pow2', x) // Return the square of the parameter.
-export const pow3 = (x: X) => f('pow3', x) // Return the cube of the parameter.
-export const pow4 = (x: X) => f('pow4', x) // Return the fourth power of the parameter.
-export const radians = (degrees: X) => f('radians', degrees) // Convert a quantity in degrees to radians.
-export const reciprocal = (x: X) => f('reciprocal', x) // Return the reciprocal of the parameter (1/x).
-export const reflect = (I: X, N: X) => f('reflect', I, N) // Calculate the reflection direction for an incident vector.
-export const refract = (I: X, N: X, eta: X) => f('refract', I, N, eta) // Calculate the refraction direction for an incident vector.
-export const round = (x: X) => f('round', x) // Round the parameter to the nearest integer.
-export const saturate = (x: X) => f('saturate', x) // Constrain a value between 0 and 1.
-export const sign = (x: X) => f('sign', x) // Extract the sign of the parameter.
-export const sin = (x: X) => f('sin', x) // Return the sine of the parameter.
-export const smoothstep = (e0: X, e1: X, x: X) => f('smoothstep', e0, e1, x) // Perform Hermite interpolation between two values.
-export const sqrt = (x: X) => f('sqrt', x) // Return the square root of the parameter.
-export const step = (edge: X, x: X) => f('step', edge, x) // Generate a step function by comparing two values.
-export const tan = (x: X) => f('tan', x) // Return the tangent of the parameter.
-export const transformDirection = (dir: X, matrix: X) => f('transformDirection', dir, matrix) // Transform the direction of a vector by a matrix and then normalize the result.
-export const trunc = (x: X) => f('trunc', x) // Truncate the parameter, removing the fractional part.
+export const abs = (x: X) => f('abs', x)
+export const acos = (x: X) => f('acos', x)
+export const all = (x: X) => f('all', x)
+export const any = (x: X) => f('any', x)
+export const asin = (x: X) => f('asin', x)
+export const atan = (y: X, x?: X) => (x !== undefined ? f('atan', y, x) : f('atan', y))
+export const atan2 = (y: X, x: X) => f('atan', y, x)
+export const bitcast = (x: X, y: X) => f('bitcast', x, y)
+export const cbrt = (x: X) => f('cbrt', x)
+export const ceil = (x: X) => f('ceil', x)
+export const clamp = (x: X, min: X, max: X) => f('clamp', x, min, max)
+export const cos = (x: X) => f('cos', x)
+export const cross = (x: X, y: X) => f('cross', x, y)
+export const dFdx = (p: X) => f('dFdx', p)
+export const dFdy = (p: X) => f('dFdy', p)
+export const degrees = (radians: X) => f('degrees', radians)
+export const difference = (x: X, y: X) => f('difference', x, y)
+export const distance = (x: X, y: X) => f('distance', x, y)
+export const dot = (x: X, y: X) => f('dot', x, y)
+export const equals = (x: X, y: X) => f('equals', x, y)
+export const exp = (x: X) => f('exp', x)
+export const exp2 = (x: X) => f('exp2', x)
+export const faceforward = (N: X, I: X, Nref: X) => f('faceforward', N, I, Nref)
+export const floor = (x: X) => f('floor', x)
+export const fract = (x: X) => f('fract', x)
+export const fwidth = (x: X) => f('fwidth', x)
+export const inverseSqrt = (x: X) => f('inverseSqrt', x)
+export const length = (x: X) => f('length', x)
+export const lengthSq = (x: X) => f('lengthSq', x)
+export const log = (x: X) => f('log', x)
+export const log2 = (x: X) => f('log2', x)
+export const max = (x: X, y: X) => f('max', x, y)
+export const min = (x: X, y: X) => f('min', x, y)
+export const mix = (x: X, y: X, a: X) => f('mix', x, y, a)
+export const negate = (x: X) => f('negate', x)
+export const normalize = (x: X) => f('normalize', x)
+export const oneMinus = (x: X) => f('oneMinus', x)
+export const pow = (x: X, y: X) => f('pow', x, y)
+export const pow2 = (x: X) => f('pow2', x)
+export const pow3 = (x: X) => f('pow3', x)
+export const pow4 = (x: X) => f('pow4', x)
+export const radians = (degrees: X) => f('radians', degrees)
+export const reciprocal = (x: X) => f('reciprocal', x)
+export const reflect = (I: X, N: X) => f('reflect', I, N)
+export const refract = (I: X, N: X, eta: X) => f('refract', I, N, eta)
+export const round = (x: X) => f('round', x)
+export const saturate = (x: X) => f('saturate', x)
+export const sign = (x: X) => f('sign', x)
+export const sin = (x: X) => f('sin', x)
+export const smoothstep = (e0: X, e1: X, x: X) => f('smoothstep', e0, e1, x)
+export const sqrt = (x: X) => f('sqrt', x)
+export const step = (edge: X, x: X) => f('step', edge, x)
+export const tan = (x: X) => f('tan', x)
+export const transformDirection = (dir: X, matrix: X) => f('transformDirection', dir, matrix)
+export const trunc = (x: X) => f('trunc', x)

package/src/node/infer.ts

@@ -0,0 +1,96 @@
+import { is } from '../utils/helpers'
+import { isNodeProxy } from './utils'
+import {
+        CONSTANTS,
+        SCALAR_RETURN_FUNCTIONS,
+        BOOL_RETURN_FUNCTIONS,
+        PRESERVE_TYPE_FUNCTIONS,
+        VEC3_RETURN_FUNCTIONS,
+        FIRST_ARG_TYPE_FUNCTIONS,
+        HIGHEST_TYPE_FUNCTIONS,
+        VEC4_RETURN_FUNCTIONS,
+        COMPARISON_OPERATORS,
+        LOGICAL_OPERATORS,
+        COMPONENT_COUNT_TO_TYPE,
+        BUILTIN_TYPES,
+} from './const'
+import type { Constants, NodeConfig, NodeProxy, X } from './types'
+
+const inferPrimitiveType = (x: any): Constants => {
+        if (is.bol(x)) return 'bool'
+        if (is.num(x)) return 'float' // Number.isInteger(x) ? 'int' : 'float' // @TODO FIX
+        if (is.arr(x)) return COMPONENT_COUNT_TO_TYPE[x.length as keyof typeof COMPONENT_COUNT_TO_TYPE] || 'float'
+        return 'float'
+}
+
+const inferBinaryOpType = (leftType: string, rightType: string, op: string): Constants => {
+        if (COMPARISON_OPERATORS.includes(op as any)) return 'bool'
+        if (LOGICAL_OPERATORS.includes(op as any)) return 'bool'
+        if (leftType === rightType) return leftType as Constants
+        if (leftType.includes('vec') && !rightType.includes('vec')) return leftType as Constants
+        if (rightType.includes('vec') && !leftType.includes('vec')) return rightType as Constants
+        const leftPriority = CONSTANTS.indexOf(leftType as any)
+        const rightPriority = CONSTANTS.indexOf(rightType as any)
+        return (leftPriority >= rightPriority ? leftType : rightType) as Constants
+}
+
+const getHighestPriorityType = (args: X[], c: NodeConfig) => {
+        return args.reduce((highest, current) => {
+                const currentType = infer(current, c)
+                const highestPriority = CONSTANTS.indexOf(highest as any)
+                const currentPriority = CONSTANTS.indexOf(currentType as any)
+                return currentPriority > highestPriority ? currentType : highest
+        }, 'float') as Constants
+}
+
+const inferSwizzleType = (count: number): Constants => {
+        return COMPONENT_COUNT_TO_TYPE[count as keyof typeof COMPONENT_COUNT_TO_TYPE]!
+}
+
+const inferBuiltinType = (id: string | undefined): Constants => {
+        return BUILTIN_TYPES[id as keyof typeof BUILTIN_TYPES]!
+}
+
+const inferMathType = (funcName: string, args: X[], c: NodeConfig): Constants => {
+        const firstArgType = args.length > 0 ? infer(args[0], c) : 'float'
+        if (FIRST_ARG_TYPE_FUNCTIONS.includes(funcName as any)) return firstArgType
+        if (SCALAR_RETURN_FUNCTIONS.includes(funcName as any)) return 'float'
+        if (BOOL_RETURN_FUNCTIONS.includes(funcName as any)) return 'bool'
+        if (PRESERVE_TYPE_FUNCTIONS.includes(funcName as any)) return firstArgType
+        if (VEC3_RETURN_FUNCTIONS.includes(funcName as any)) return 'vec3'
+        if (VEC4_RETURN_FUNCTIONS.includes(funcName as any)) return 'vec4'
+        if (HIGHEST_TYPE_FUNCTIONS.includes(funcName as any)) return getHighestPriorityType(args, c)
+        return firstArgType
+}
+
+export const inferImpl = (target: NodeProxy, c: NodeConfig): Constants => {
+        const { type, props } = target
+        const { id, children = [], value } = props
+        const [x, y, z] = children
+        if (
+                type === 'uniform' ||
+                type === 'variable' ||
+                type === 'constant' ||
+                type === 'attribute' ||
+                type === 'varying'
+        )
+                return inferPrimitiveType(value)
+        if (type === 'conversion') return x as Constants
+        if (type === 'operator') return inferBinaryOpType(infer(y, c), infer(z, c), x as string)
+        if (type === 'function') return inferMathType(x as string, children.slice(1), c)
+        if (type === 'swizzle') return inferSwizzleType((x as string).length)
+        if (type === 'ternary') return inferBinaryOpType(infer(y, c), infer(z, c), 'add')
+        if (type === 'define') return y ? infer(y, c) : 'void'
+        if (type === 'builtin') return inferBuiltinType(id)
+        return 'float'
+}
+
+export const infer = (target: X, c: NodeConfig | null): Constants => {
+        if (!c) c = {}
+        if (!isNodeProxy(target)) return inferPrimitiveType(target)
+        if (!c.infers) c.infers = new WeakMap<NodeProxy, Constants>()
+        if (c.infers.has(target)) return c.infers.get(target)!
+        const ret = inferImpl(target, c)
+        c.infers.set(target, ret)
+        return ret
+}

package/src/node/node.ts

@@ -1,46 +1,42 @@
 import { code } from './code'
 import { assign, toVar } from './scope'
-import { getId, isFunction, isOperator, isSwizzle } from './utils'
+import { getId, isConversion, isFunction, isOperator, isSwizzle } from './utils'
 import type { Functions, NodeProps, NodeProxy, NodeTypes, Operators, Swizzles, X } from './types'
 
-const toPrimitive = (x: X) => {
-        return (hint: string) => {
-                if (hint === 'string') return code(x)
-        }
+const toPrimitive = (x: X, hint: string) => {
+        if (hint === 'string') return code(x)
 }
 
 export const node = (type: NodeTypes, props?: NodeProps | null, ...args: X[]) => {
         if (!props) props = {}
         if (args.length) props.children = args
-        const x = new Proxy(() => {}, {
-                get(_, key) {
-                        if (key === 'type') return type
-                        if (key === 'props') return props
-                        if (key === 'toVar') return toVar(x)
-                        if (key === 'assign') return assign(x)
-                        if (key === 'isProxy') return true
-                        if (key === 'toString') return code.bind(null, x)
-                        if (key === Symbol.toPrimitive) return toPrimitive(x)
-                        if (isSwizzle(key)) return s(key, x)
-                        if (isOperator(key)) return (...y: X[]) => o(key, x, ...y)
-                        if (isFunction(key)) return (...y: X[]) => f(key, x, ...y)
-                        return toVar(x)('')
-                },
-                set(_, key, value) {
-                        if (isSwizzle(key)) {
-                                s(key, x).assign(value)
-                                return true
-                        }
-                        return false
-                },
-        }) as unknown as NodeProxy
+        const get = (_: unknown, key: string | Symbol) => {
+                if (key === 'type') return type
+                if (key === 'props') return props
+                if (key === 'toVar') return toVar.bind(null, x)
+                if (key === 'assign') return assign.bind(null, x)
+                if (key === 'isProxy') return true
+                if (key === 'toString') return code.bind(null, x)
+                if (key === Symbol.toPrimitive) return toPrimitive.bind(null, x)
+                if (isSwizzle(key)) return swizzle(key, x)
+                if (isOperator(key)) return (...y: X[]) => operator(key, x, ...y)
+                if (isFunction(key)) return (...y: X[]) => function_(key, x, ...y)
+                if (isConversion(key)) return conversion(key, x)
+        }
+        const set = (_: unknown, key: string, value: X) => {
+                if (isSwizzle(key)) {
+                        swizzle(key, x).assign(value)
+                        return true
+                }
+                return false
+        }
+        const x = new Proxy({}, { get, set }) as unknown as NodeProxy
         return x
 }
 
 // Node shorthands
-export const v = (...args: X[]) => node('variable', { id: getId() }, ...args)
-export const u = (key: string, defaultValue?: number | number[]) => node('uniform', { defaultValue }, key)
-export const s = (key: Swizzles, arg: X) => node('swizzle', null, key, arg)
-export const n = (key: string, ...args: X[]) => node('node_type', null, key, ...args)
-export const o = (key: Operators, ...args: X[]) => node('operator', null, key, ...args)
-export const f = (key: Functions, ...args: X[]) => node('math_fun', null, key, ...args)
+export const variable = (...args: X[]) => node('variable', { id: getId() }, ...args)
+export const swizzle = (key: Swizzles, arg: X) => node('swizzle', null, key, arg)
+export const operator = (key: Operators, ...args: X[]) => node('operator', null, key, ...args)
+export const function_ = (key: Functions, ...args: X[]) => node('function', null, key, ...args)
+export const conversion = (key: string, ...args: X[]) => node('conversion', null, key, ...args)