glre 0.28.0 → 0.29.0

package/src/node/code.ts

@@ -1,67 +1,72 @@
 import { is } from '../utils/helpers'
 import { infer } from './infer'
-import { joins, getOperator, formatConversions } from './utils'
+import { joins, getOperator, formatConversions, generateDefine } from './utils'
+import { WGSL_TO_GLSL_BUILTIN } from './const'
 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)) return target.toFixed(1)
+        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
+        let head = ''
         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 === 'attribute') {
+                if (c.headers.has(id)) return id
+                head = `${infer(target, c)} ${id}`
+        }
+        if (type === 'constant') {
+                if (c.headers.has(id)) return id
+                head = `${infer(target, c)} ${id}`
+        }
+        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, props.value)
                 return id
         }
-        if (type === 'variable' || type === 'varying' || type === 'constant' || type === 'attribute') return id
-        if (type === 'vertex_stage') return code(x, c)
+        if (type === 'variable') return id
         if (type === 'swizzle') return `${code(y, c)}.${code(x, 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') {
+                // Handle special functions that need to be converted to operators
+                if (x === 'negate') return `(-${joins(children.slice(1), c)})`
+                return `${x}(${joins(children.slice(1), c)})`
+        }
+        if (type === 'conversion') return `${formatConversions(x, c)}(${joins(children.slice(1), c)})`
         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 === '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,21 +74,16 @@ 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)
@@ -94,7 +94,8 @@ export const code = (target: X, c?: NodeConfig | null): string => {
         }
         if (type === 'builtin') {
                 if (c?.isWebGL) {
-                        if (id === 'position') return 'gl_FragCoord'
+                        const glslBuiltin = WGSL_TO_GLSL_BUILTIN[id as keyof typeof WGSL_TO_GLSL_BUILTIN]
+                        if (glslBuiltin) return glslBuiltin
                         if (id === 'uv') return 'gl_FragCoord.xy'
                 }
                 return id

package/src/node/const.ts

@@ -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,14 @@ 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',
+} as const

package/src/node/index.ts

@@ -1,4 +1,4 @@
-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'
@@ -10,20 +10,33 @@ 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 position = node('variable', { id: 'gl_FragCoord' })
+export const iResolution = uniform([1280, 800], 'iResolution')
+export const iMouse = uniform([0, 0], 'iMouse')
+export const iTime = uniform(0, 'iTime')
 
-// 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 = 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' })
 
-// Buildin Variables
-export const positionLocal = node('builtin', { id: 'positionLocal' })
+// 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' })
@@ -32,26 +45,30 @@ 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)

package/src/node/infer.ts

@@ -14,11 +14,11 @@ import {
         COMPONENT_COUNT_TO_TYPE,
         BUILTIN_TYPES,
 } from './const'
-import type { Constants, NodeConfig, X } from './types'
+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.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'
 }
@@ -34,40 +34,38 @@ const inferBinaryOpType = (leftType: string, rightType: string, op: string): Con
         return (leftPriority >= rightPriority ? leftType : rightType) as Constants
 }
 
-const getHighestPriorityType = (args: X[]) => {
+const getHighestPriorityType = (args: X[], c: NodeConfig) => {
         return args.reduce((highest, current) => {
-                const currentType = infer(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')
+        }, 'float') as Constants
 }
+
 const inferSwizzleType = (count: number): Constants => {
-        return COMPONENT_COUNT_TO_TYPE[count as keyof typeof COMPONENT_COUNT_TO_TYPE] || 'vec4'
+        return COMPONENT_COUNT_TO_TYPE[count as keyof typeof COMPONENT_COUNT_TO_TYPE]!
 }
 
 const inferBuiltinType = (id: string | undefined): Constants => {
-        if (!id) return 'vec3'
         return BUILTIN_TYPES[id as keyof typeof BUILTIN_TYPES]!
 }
 
-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
+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 as Constants
+        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) as Constants
-        return firstArgType as Constants
+        if (HIGHEST_TYPE_FUNCTIONS.includes(funcName as any)) return getHighestPriorityType(args, c)
+        return firstArgType
 }
 
-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 = [], value } = props
         const [x, y, z] = children
         if (
                 type === 'uniform' ||
@@ -77,17 +75,22 @@ export const infer = (target: X, c?: NodeConfig): Constants => {
                 type === 'varying'
         )
                 return inferPrimitiveType(value)
-        if (type === 'conversions') return x as Constants
+        if (type === 'conversion') 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 === '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 === 'fn_run') return returnType!
-        if (type === 'fn_def') return returnType!
+        if (type === 'define') return y ? infer(y, c) : 'void'
         if (type === 'builtin') return inferBuiltinType(id)
         return 'float'
 }
 
-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
 }

package/src/node/node.ts

@@ -1,51 +1,42 @@
 import { code } from './code'
-import { assign, toVar, toConst } from './scope'
+import { assign, toVar } from './scope'
 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 === 'toConst') return toConst(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)
-                        if (isConversion(key)) return n(key, 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 s = (key: Swizzles, arg: X) => node('swizzle', null, key, arg)
-export const n = (key: string, ...args: X[]) => node('conversions', 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)
-
-// uniform and attribute
-export const u = (id: string, value?: number | number[] | boolean) => node('uniform', { id, value })
-
-export const select = (x: X, y: X, z: X) => node('ternary', null, x, y, z)
+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)

package/src/node/scope.ts

@@ -1,14 +1,13 @@
-import { infer } from './infer'
 import { node } from './node'
 import { getId } from './utils'
 import type { NodeProxy, X } from './types'
 
 let _scope: NodeProxy | null = null
 
-const scoped = (x: NodeProxy | null, callback = () => {}) => {
+const scoped = (x: NodeProxy | null, fun = () => {}) => {
         const prev = _scope
         _scope = x
-        callback()
+        fun()
         _scope = prev
 }
 
@@ -18,30 +17,44 @@ const addToScope = (x: NodeProxy) => {
         _scope.props.children.push(x)
 }
 
-export const If = (condition: X, callback: () => void) => {
+export const toVar = (x: X, id?: string) => {
+        if (!id) id = getId()
+        const y = node('variable', { id })
+        const z = node('declare', null, y, x)
+        addToScope(z)
+        return y
+}
+
+export const assign = (x: X, y: X) => {
+        const z = node('assign', null, x, y)
+        addToScope(z)
+        return x
+}
+
+export const If = (condition: X, fun: () => void) => {
         const scope = node('scope')
-        scoped(scope, callback)
+        scoped(scope, fun)
         const ifNode = node('if', null, condition, scope)
         addToScope(ifNode)
         const createChain = () => ({
-                ElseIf: (newCondition: X, elseIfCallback: () => void) => {
-                        const elseIfScope = node('scope')
-                        scoped(elseIfScope, elseIfCallback)
-                        ifNode.props.children!.push(newCondition, elseIfScope)
+                ElseIf: (x: X, _fun: () => void) => {
+                        const y = node('scope')
+                        scoped(y, _fun)
+                        ifNode.props.children!.push(x, y)
                         return createChain()
                 },
-                Else: (elseCallback: () => void) => {
-                        const elseScope = node('scope')
-                        scoped(elseScope, elseCallback)
-                        ifNode.props.children!.push(elseScope)
+                Else: (_fun: () => void) => {
+                        const x = node('scope')
+                        scoped(x, _fun)
+                        ifNode.props.children!.push(x)
                 },
         })
         return createChain()
 }
 
-export const Loop = (x: X, callback?: (params: { i: NodeProxy }) => void) => {
+export const Loop = (x: X, fun: (params: { i?: NodeProxy }) => void) => {
         const y = node('scope')
-        scoped(y, () => callback?.({ i: node('variable', { id: 'i' }) }))
+        scoped(y, () => fun({ i: node('variable', { id: 'i' }) }))
         const ret = node('loop', null, x, y)
         addToScope(ret)
         return ret
@@ -52,28 +65,29 @@ export const Switch = (value: X) => {
         addToScope(switchNode)
         const createChain = () => ({
                 Case: (...values: X[]) => {
-                        return (callback: () => void) => {
-                                const caseScope = node('scope')
-                                scoped(caseScope, callback)
-                                const caseNode = node('case', null, ...values, caseScope)
-                                switchNode.props.children!.push(caseNode)
+                        return (fun: () => void) => {
+                                const scope = node('scope')
+                                scoped(scope, fun)
+                                // 複数のcase値を処理
+                                for (const val of values) {
+                                        switchNode.props.children!.push(val, scope)
+                                }
                                 return createChain()
                         }
                 },
-                Default: (callback: () => void) => {
-                        const defaultScope = node('scope')
-                        scoped(defaultScope, callback)
-                        const defaultNode = node('default', null, defaultScope)
-                        switchNode.props.children!.push(defaultNode)
+                Default: (fun: () => void) => {
+                        const scope = node('scope')
+                        scoped(scope, fun)
+                        switchNode.props.children!.push(scope)
                 },
         })
 
         return createChain()
 }
 
-export const Fn = (callback: (args: NodeProxy[]) => NodeProxy) => {
+export const Fn = (fun: (paramVars: NodeProxy[]) => NodeProxy) => {
         const id = getId()
-        return (...args: NodeProxy[]) => {
+        return (...args: X[]) => {
                 const x = node('scope')
                 let y: NodeProxy | undefined
                 const paramVars: NodeProxy[] = []
@@ -82,40 +96,7 @@ export const Fn = (callback: (args: NodeProxy[]) => NodeProxy) => {
                         const paramVar = node('variable', { id: paramId })
                         paramVars.push(paramVar)
                 }
-                scoped(x, () => (y = callback(paramVars)))
-                const returnType = y ? infer(y) : 'void'
-                const paramInfo = args.map((arg, i) => ({ name: `p${i}`, type: infer(arg) }))
-                const def = node('fn_def', { id, returnType, paramInfo, args }, x, y)
-                return node('fn_run', { id, returnType }, def, ...paramVars)
+                scoped(x, () => (y = fun(paramVars)))
+                return node('define', { id }, x, y, ...args)
         }
 }
-
-export const toVar = (x: X) => (id?: string) => {
-        if (!id) id = getId()
-        const y = node('variable', { id })
-        const z = node('declare', null, y, x)
-        addToScope(z)
-        return y
-}
-
-export const toConst = (x: X) => (id?: string) => {
-        if (!id) id = getId()
-        const y = node('constant', { id })
-        const z = node('declare', null, y, x)
-        addToScope(z)
-        return y
-}
-
-export const assign = (x: X) => (y: X) => {
-        const assignNode = node('assign', null, x, y)
-        addToScope(assignNode)
-        return x
-}
-
-export const varying = (value: X, name?: string) => {
-        if (!name) name = getId()
-        const varyingVar = node('varying', { id: name })
-        const declaration = node('declare', null, varyingVar, value)
-        addToScope(declaration)
-        return varyingVar
-}