glre 0.28.0 → 0.30.0

package/src/node/code.ts

@@ -1,67 +1,92 @@
 import { is } from '../utils/helpers'
 import { infer } from './infer'
-import { joins, getOperator, formatConversions } from './utils'
+import { getBluiltin, getOperator, generateDefine, formatConversions, joins } from './utils'
 import type { NodeConfig, X } from './types'
 
 export const code = (target: X, c?: NodeConfig | null): string => {
         if (!c) c = {}
-        if (!c.uniforms) c.uniforms = new Set()
-        if (!c.functions) c.functions = new Set()
-        if (is.num(target)) return target.toFixed(1)
+        if (!c.headers) c.headers = new Map()
         if (is.str(target)) return target
-        if (is.bol(target)) return target.toString()
+        if (is.num(target)) {
+                const ret = `${target}`
+                if (ret.includes('.')) return ret
+                return ret + '.0'
+        }
+        if (is.bol(target)) return target ? 'true' : 'false'
         if (!target) return '' // ignore if no target
         const { type, props } = target
         const { id = '', children = [] } = props
         const [x, y, z] = children
+        /**
+         * headers
+         */
+        let head = ''
+        if (type === 'attribute') {
+                if (c.headers.has(id)) return id
+                head = `${infer(target, c)} ${id}`
+        }
         if (type === 'uniform') {
+                if (c.headers.has(id)) return id
+                if (!c.binding) c.binding = 0
                 const varType = infer(target, c)
-                c.uniforms.add(`${varType} ${id}`)
-                c.onUniform?.(id, props.value)
+                head = c.isWebGL
+                        ? `uniform ${varType} ${id};`
+                        : `@group(0) @binding(${c.binding++}) var<uniform> ${id}: ${formatConversions(varType, c)};`
+        }
+        if (type === 'constant') {
+                if (c.headers.has(id)) return id
+                const varType = infer(target, c)
+                const value = code(x, c)
+                head = c.isWebGL
+                        ? `const ${varType} ${id} = ${value};`
+                        : `const ${id}: ${formatConversions(varType, c)} = ${value};`
+        }
+        if (type === 'varying') {
+                if (c.headers.has(id)) return id
+                head = `${infer(target, c)} ${id}`
+        }
+        if (head) {
+                c.headers.set(id, head)
+                c.onMount?.(id)
                 return id
         }
-        if (type === 'variable' || type === 'varying' || type === 'constant' || type === 'attribute') return id
-        if (type === 'vertex_stage') return code(x, c)
+        /**
+         * variables
+         */
+        if (type === 'variable') return id
         if (type === 'swizzle') return `${code(y, c)}.${code(x, c)}`
+        if (type === 'ternary') return `(${code(x, c)} ? ${code(y, c)} : ${code(z, c)})`
+        if (type === 'builtin') return c?.isWebGL ? getBluiltin(id) : id
+        if (type === 'conversion') return `${formatConversions(x, c)}(${joins(children.slice(1), c)})`
         if (type === 'operator') {
                 if (x === 'not' || x === 'bitNot') return `!${code(y, c)}`
                 return `(${code(y, c)} ${getOperator(x)} ${code(z, c)})`
         }
-        if (type === 'math_fun') return `${x}(${joins(children.slice(1), c)})`
-        if (type === 'conversions') return `${formatConversions(x, c)}(${joins(children.slice(1), c)})`
+        if (type === 'function') {
+                if (x === 'negate') return `(-${joins(children.slice(1), c)})`
+                return `${x}(${joins(children.slice(1), c)})`
+        }
+        /**
+         * scopes
+         */
         if (type === 'scope') return children.map((child: any) => code(child, c)).join('\n')
         if (type === 'assign') return `${code(x, c)} = ${code(y, c)};`
-        if (type === 'fn_run') {
-                c.functions.add(code(x, c))
-                return `${id}(${children
-                        .slice(1)
-                        .map((child) => code(child, c))
-                        .join(', ')})`
-        }
-        if (type === 'fn_def') {
-                const { paramInfo = [], returnType } = props
-                const scopeCode = code(x, c)
-                const returnCode = y ? `return ${code(y, c)};` : ''
-                if (c?.isWebGL) {
-                        const params = paramInfo.map(({ name, type }) => `${type} ${name}`).join(', ')
-                        return `${returnType} ${id}(${params}) {\n${scopeCode}\n${returnCode}\n}`
-                } else {
-                        const wgslReturnType = formatConversions(returnType, c)
-                        const wgslParams = paramInfo
-                                .map(({ name, type }) => {
-                                        const wgslParamType = formatConversions(type, c)
-                                        return `${name}: ${wgslParamType}`
-                                })
-                                .join(', ')
-                        return `fn ${id}(${wgslParams}) -> ${wgslReturnType} {\n${scopeCode}\n${returnCode}\n}`
-                }
+        if (type === 'loop')
+                return c.isWebGL
+                        ? `for (int i = 0; i < ${x}; i += 1) {\n${code(y, c)}\n}`
+                        : `for (var i: i32 = 0; i < ${x}; i++) {\n${code(y, c)}\n}`
+        if (type === 'define') {
+                const args = children.slice(2)
+                const ret = `${id}(${args.map((arg) => code(arg, c))})`
+                if (c.headers.has(id)) return ret
+                c.headers.set(id, generateDefine(props, c))
+                return ret
         }
-        if (type === 'loop') return `for (int i = 0; i < ${x}; i++) {\n${code(y, c)}\n}`
         if (type === 'if') {
                 let ret = `if (${code(x, c)}) {\n${code(y, c)}\n}`
                 for (let i = 2; i < children.length; i += 2) {
-                        const isLast = i >= children.length - 1
-                        ret += !isLast
+                        const isElseIf = i >= children.length - 1
+                        ret += !isElseIf
                                 ? ` else if (${code(children[i], c)}) {\n${code(children[i + 1], c)}\n}`
                                 : ` else {\n${code(children[i], c)}\n}`
                 }
@@ -69,35 +94,22 @@ export const code = (target: X, c?: NodeConfig | null): string => {
         }
         if (type === 'switch') {
                 let ret = `switch (${code(x, c)}) {\n`
-                for (const child of children.slice(1)) ret += code(child, c) + '\n'
-                ret += '}'
-                return ret
-        }
-        if (type === 'case') {
-                const values = children.slice(0, -1)
-                const scope = children[children.length - 1]
-                let ret = ''
-                for (const value of values) {
-                        ret += `case ${code(value, c)}:\n`
+                for (let i = 1; i < children.length; i += 2) {
+                        const isDefault = i >= children.length - 1
+                        if (isDefault && children.length % 2 === 0) {
+                                ret += `default:\n${code(children[i], c)}\nbreak;\n`
+                        } else if (i + 1 < children.length)
+                                ret += `case ${code(children[i], c)}:\n${code(children[i + 1], c)}\nbreak;\n`
                 }
-                ret += `${code(scope, c)}\nbreak;\n`
+                ret += '}'
                 return ret
         }
-        if (type === 'default') `default:\n${code(x, c)}\nbreak;\n`
-        if (type === 'ternary') return `(${code(x, c)} ? ${code(y, c)} : ${code(z, c)})`
         if (type === 'declare') {
-                const varType = infer(y, c)
-                const varName = (x as any)?.props?.id
-                if (c.isWebGL) return `${varType} ${varName} = ${code(y, c)};`
+                const varType = infer(x, c)
+                const varName = (y as any)?.props?.id
+                if (c.isWebGL) return `${varType} ${varName} = ${code(x, c)};`
                 const wgslType = formatConversions(varType)
-                return `var ${varName}: ${wgslType} = ${code(y, c)};`
-        }
-        if (type === 'builtin') {
-                if (c?.isWebGL) {
-                        if (id === 'position') return 'gl_FragCoord'
-                        if (id === 'uv') return 'gl_FragCoord.xy'
-                }
-                return id
+                return `var ${varName}: ${wgslType} = ${code(x, c)};`
         }
         return code(x, c)
 }

package/src/node/const.ts

@@ -6,16 +6,16 @@ export const CONSTANTS = [
         'int',
         'float',
         'bvec2',
-        'bvec3',
-        'bvec4',
         'ivec2',
-        'ivec3',
-        'ivec4',
         'uvec2',
-        'uvec3',
-        'uvec4',
         'vec2',
+        'bvec3',
+        'ivec3',
+        'uvec3',
         'vec3',
+        'bvec4',
+        'ivec4',
+        'uvec4',
         'vec4',
         'color',
         'mat2',
@@ -24,26 +24,26 @@ export const CONSTANTS = [
 ] as const
 
 export const CONVERSIONS = [
-        'toFloat',
-        'toInt',
-        'toUint',
         'toBool',
-        'toVec2',
-        'toVec3',
-        'toVec4',
+        'toUint',
+        'toInt',
+        'toFloat',
+        'toBvec2',
         'toIvec2',
-        'toIvec3',
-        'toIvec4',
         'toUvec2',
-        'toUvec3',
-        'toUvec4',
-        'toBvec2',
+        'toVec2',
         'toBvec3',
+        'toIvec3',
+        'toUvec3',
+        'toVec3',
         'toBvec4',
+        'toIvec4',
+        'toUvec4',
+        'toVec4',
+        'toColor',
         'toMat2',
         'toMat3',
         'toMat4',
-        'toColor',
 ] as const
 
 export const OPERATORS = {
@@ -69,7 +69,6 @@ export const OPERATORS = {
 
 export const OPERATOR_KEYS = Object.keys(OPERATORS) as (keyof typeof OPERATORS)[]
 
-// Function return type classification
 export const SCALAR_RETURN_FUNCTIONS = ['dot', 'distance', 'length', 'lengthSq', 'determinant', 'luminance'] as const
 
 export const BOOL_RETURN_FUNCTIONS = ['all', 'any'] as const
@@ -171,8 +170,37 @@ export const COMPONENT_COUNT_TO_TYPE = {
 } 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',
-        position: 'vec3',
+        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',
@@ -188,3 +216,15 @@ export const COMPARISON_OPERATORS = [
 ] 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',
+        uv: 'gl_FragCoord.xy',
+} as const

package/src/node/index.ts

@@ -1,4 +1,4 @@
-import { f, n, node, u } from './node'
+import { builtin, conversion as c, function_ as f, uniform } from './node'
 import { hex2rgb } from './utils'
 import { is } from '../utils/helpers'
 import type { X } from './types'
@@ -10,53 +10,56 @@ export * from './scope'
 export * from './types'
 export * from './utils'
 
-// Default uniforms
-export const iResolution = u('iResolution', [1280, 800])
-export const iMouse = u('iMouse', [0, 0])
-export const iTime = u('iTime', 0)
-export const position = node('variable', { id: 'gl_FragCoord' })
-
-// Default attributes
-export const uv = (index = 0) => node('attribute', { id: `uv${index || ''}` })
-export const vertexColor = (index = 0) => node('attribute', { id: `color${index || ''}` })
-export const attribute = (id: string, type?: string) => node('attribute', { id, type })
-export const vertexStage = (value: X) => node('vertex_stage', null, value)
+// Builtin Variables
+export const position = builtin('position')
+export const vertexIndex = builtin('vertex_index')
+export const instanceIndex = builtin('instance_index')
+export const frontFacing = builtin('front_facing')
+export const fragDepth = builtin('frag_depth')
+export const sampleIndex = builtin('sample_index')
+export const sampleMask = builtin('sample_mask')
+export const pointCoord = builtin('point_coord')
 
-// Buildin Variables
-export const positionLocal = node('builtin', { id: 'positionLocal' })
-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' })
+// TSL Compatible Builtin Variables
+export const normalLocal = builtin('normalLocal')
+export const normalWorld = builtin('normalWorld')
+export const normalView = builtin('normalView')
+export const positionLocal = builtin('position')
+export const positionWorld = builtin('positionWorld')
+export const positionView = builtin('positionView')
+export const screenCoordinate = builtin('screenCoordinate')
+export const screenUV = builtin('screenUV')
 
 // 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)
 }
 
+// Default uniforms
+export const iResolution = uniform(vec2(1280, 800), 'iResolution')
+export const iMouse = uniform(vec2(0, 0), 'iMouse')
+export const iTime = uniform(float(0), 'iTime')
+
 // 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)

package/src/node/infer.ts

@@ -1,29 +1,47 @@
 import { is } from '../utils/helpers'
-import { isNodeProxy } from './utils'
 import {
-        CONSTANTS,
-        SCALAR_RETURN_FUNCTIONS,
         BOOL_RETURN_FUNCTIONS,
-        PRESERVE_TYPE_FUNCTIONS,
-        VEC3_RETURN_FUNCTIONS,
+        BUILTIN_TYPES,
+        COMPARISON_OPERATORS,
+        COMPONENT_COUNT_TO_TYPE,
+        CONSTANTS,
         FIRST_ARG_TYPE_FUNCTIONS,
         HIGHEST_TYPE_FUNCTIONS,
-        VEC4_RETURN_FUNCTIONS,
-        COMPARISON_OPERATORS,
         LOGICAL_OPERATORS,
-        COMPONENT_COUNT_TO_TYPE,
-        BUILTIN_TYPES,
+        PRESERVE_TYPE_FUNCTIONS,
+        SCALAR_RETURN_FUNCTIONS,
+        VEC3_RETURN_FUNCTIONS,
+        VEC4_RETURN_FUNCTIONS,
 } from './const'
-import type { Constants, NodeConfig, X } from './types'
+import { isNodeProxy } from './utils'
+import type { Constants, NodeConfig, NodeProxy, X } from './types'
 
-const inferPrimitiveType = (x: any): Constants => {
-        if (is.bol(x)) return 'bool'
-        if (is.num(x)) return Number.isInteger(x) ? 'int' : 'float'
-        if (is.arr(x)) return COMPONENT_COUNT_TO_TYPE[x.length as keyof typeof COMPONENT_COUNT_TO_TYPE] || 'float'
-        return 'float'
+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 inferBuiltin = (id: string | undefined): Constants => {
+        return BUILTIN_TYPES[id as keyof typeof BUILTIN_TYPES]!
+}
+
+const inferFunction = (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
 }
 
-const inferBinaryOpType = (leftType: string, rightType: string, op: string): Constants => {
+const inferOperator = (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
@@ -34,60 +52,41 @@ const inferBinaryOpType = (leftType: string, rightType: string, op: string): Con
         return (leftPriority >= rightPriority ? leftType : rightType) as Constants
 }
 
-const getHighestPriorityType = (args: X[]) => {
-        return args.reduce((highest, current) => {
-                const currentType = infer(current)
-                const highestPriority = CONSTANTS.indexOf(highest as any)
-                const currentPriority = CONSTANTS.indexOf(currentType as any)
-                return currentPriority > highestPriority ? currentType : highest
-        }, 'float')
-}
-const inferSwizzleType = (count: number): Constants => {
-        return COMPONENT_COUNT_TO_TYPE[count as keyof typeof COMPONENT_COUNT_TO_TYPE] || 'vec4'
-}
-
-const inferBuiltinType = (id: string | undefined): Constants => {
-        if (!id) return 'vec3'
-        return BUILTIN_TYPES[id as keyof typeof BUILTIN_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 inferMathType = (funcName: string, args: X[]): Constants => {
-        const firstArgType = args.length > 0 ? infer(args[0]) : 'float'
-        if (FIRST_ARG_TYPE_FUNCTIONS.includes(funcName as any)) return firstArgType as Constants
-        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 as Constants
-        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) as Constants
-        return firstArgType as Constants
+const inferSwizzle = (count: number): Constants => {
+        return COMPONENT_COUNT_TO_TYPE[count as keyof typeof COMPONENT_COUNT_TO_TYPE]!
 }
 
-export const infer = (target: X, c?: NodeConfig): Constants => {
-        if (!target) throw ``
-        if (!isNodeProxy(target)) return inferPrimitiveType(target)
+export const inferImpl = (target: NodeProxy, c: NodeConfig): Constants => {
         const { type, props } = target
-        const { id, children = [], value, returnType } = props
+        const { id, children = [], inferFrom } = props
         const [x, y, z] = children
-        if (
-                type === 'uniform' ||
-                type === 'variable' ||
-                type === 'constant' ||
-                type === 'attribute' ||
-                type === 'varying'
-        )
-                return inferPrimitiveType(value)
-        if (type === 'conversions') return x as Constants
-        if (type === 'operator') return inferBinaryOpType(infer(y, c), infer(z, c), x as string)
-        if (type === 'math_fun') return inferMathType(x as string, children.slice(1))
-        if (type === 'swizzle') return inferSwizzleType((x as string).length)
-        if (type === 'ternary') return inferBinaryOpType(infer(y, c), infer(z, c), 'add')
-        if (type === 'fn_run') return returnType!
-        if (type === 'fn_def') return returnType!
-        if (type === 'builtin') return inferBuiltinType(id)
-        return 'float'
+        if (inferFrom) return infer(inferFrom, c)
+        if (type === 'conversion') return x as Constants
+        if (type === 'operator') return inferOperator(infer(y, c), infer(z, c), x as string)
+        if (type === 'function') return inferFunction(x as string, children.slice(1), c)
+        if (type === 'swizzle') return inferSwizzle((x as string).length)
+        if (type === 'ternary') return inferOperator(infer(y, c), infer(z, c), 'add')
+        if (type === 'builtin') return inferBuiltin(id)
+        if (type === 'define') {
+                if (props.layout?.type && props.layout?.type !== 'auto') return props.layout.type as Constants
+                return y ? infer(y, c) : 'void'
+        }
+        return infer(x, c)
 }
 
-export const inferParameterTypes = (args: X[], c?: NodeConfig): Constants[] => {
-        return args.map((arg) => infer(arg, c))
+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
 }