glre 0.29.0 → 0.31.0

package/src/node/code.ts

@@ -1,20 +1,30 @@
 import { is } from '../utils/helpers'
 import { infer } from './infer'
-import { joins, getOperator, formatConversions, generateDefine } from './utils'
-import { WGSL_TO_GLSL_BUILTIN } from './const'
+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.headers) c.headers = new Map()
         if (is.str(target)) return target
-        if (is.num(target)) return target.toFixed(1)
+        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
@@ -23,13 +33,13 @@ export const code = (target: X, c?: NodeConfig | null): string => {
                         ? `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}`
+                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
@@ -37,23 +47,34 @@ export const code = (target: X, c?: NodeConfig | null): string => {
         }
         if (head) {
                 c.headers.set(id, head)
-                c.onMount?.(id, props.value)
+                c.onMount?.(id)
                 return id
         }
+        /**
+         * 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 === '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)})`
+        /**
+         * 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 === '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))})`
@@ -61,7 +82,6 @@ export const code = (target: X, c?: NodeConfig | null): string => {
                 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) {
@@ -84,21 +104,12 @@ export const code = (target: X, c?: NodeConfig | null): string => {
                 ret += '}'
                 return ret
         }
-        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) {
-                        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
+                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 = {
@@ -226,4 +226,5 @@ export const WGSL_TO_GLSL_BUILTIN = {
         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 { conversion as c, function_ as f, node } 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,44 +10,25 @@ 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 = 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' })
+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')
 
 // 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
+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) => c('float', x)
@@ -74,6 +55,11 @@ export const color = (r?: X, g?: X, b?: X) => {
         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,39 +1,21 @@
 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 { 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 '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)
@@ -43,15 +25,11 @@ const getHighestPriorityType = (args: X[], c: NodeConfig) => {
         }, '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 => {
+const inferBuiltin = (id: string | undefined): Constants => {
         return BUILTIN_TYPES[id as keyof typeof BUILTIN_TYPES]!
 }
 
-const inferMathType = (funcName: string, args: X[], c: NodeConfig): Constants => {
+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'
@@ -63,29 +41,47 @@ const inferMathType = (funcName: string, args: X[], c: NodeConfig): Constants =>
         return firstArgType
 }
 
+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
+        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 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 inferSwizzle = (count: number): Constants => {
+        return COMPONENT_COUNT_TO_TYPE[count as keyof typeof COMPONENT_COUNT_TO_TYPE]!
+}
+
 export const inferImpl = (target: NodeProxy, c: NodeConfig): Constants => {
         const { type, props } = target
-        const { id, children = [], value } = 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 (inferFrom) return infer(inferFrom, c)
         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'
+        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 infer = (target: X, c: NodeConfig | null): Constants => {
+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>()

package/src/node/node.ts

@@ -1,6 +1,6 @@
 import { code } from './code'
 import { assign, toVar } from './scope'
-import { getId, isConversion, isFunction, isOperator, isSwizzle } from './utils'
+import { conversionToConstant, isConversion, isFunction, isOperator, isSwizzle } from './utils'
 import type { Functions, NodeProps, NodeProxy, NodeTypes, Operators, Swizzles, X } from './types'
 
 const toPrimitive = (x: X, hint: string) => {
@@ -21,11 +21,11 @@ export const node = (type: NodeTypes, props?: NodeProps | null, ...args: 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)
+                if (isConversion(key)) return () => conversion(conversionToConstant(key), x)
         }
-        const set = (_: unknown, key: string, value: X) => {
+        const set = (_: unknown, key: string, y: X) => {
                 if (isSwizzle(key)) {
-                        swizzle(key, x).assign(value)
+                        swizzle(key, x).assign(y)
                         return true
                 }
                 return false
@@ -34,9 +34,19 @@ export const node = (type: NodeTypes, props?: NodeProps | null, ...args: X[]) =>
         return x
 }
 
+// headers
+export const attribute = (x: X, id?: string) => node('varying', { id }, x)
+export const uniform = (x: X, id?: string) => node('uniform', { id }, x)
+export const varying = (x: X, id?: string) => node('varying', { id }, x)
+export const constant = (x: X, id?: string) => node('constant', { id }, x)
+export const variable = (id: string) => node('variable', { id })
+export const builtin = (id: string) => node('builtin', { id })
+
 // Node shorthands
-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)
+
+// x ? y : z
+export const select = (x: X, y: X, z: X) => node('ternary', null, x, y, z)

package/src/node/scope.ts

@@ -1,6 +1,7 @@
-import { node } from './node'
+import { int } from '.'
+import { conversion, node } from './node'
 import { getId } from './utils'
-import type { NodeProxy, X } from './types'
+import type { FnLayout, NodeProps, NodeProxy, X } from './types'
 
 let _scope: NodeProxy | null = null
 
@@ -19,8 +20,8 @@ const addToScope = (x: NodeProxy) => {
 
 export const toVar = (x: X, id?: string) => {
         if (!id) id = getId()
-        const y = node('variable', { id })
-        const z = node('declare', null, y, x)
+        const y = node('variable', { id, inferFrom: x })
+        const z = node('declare', null, x, y)
         addToScope(z)
         return y
 }
@@ -31,48 +32,45 @@ export const assign = (x: X, y: X) => {
         return x
 }
 
-export const If = (condition: X, fun: () => void) => {
-        const scope = node('scope')
-        scoped(scope, fun)
-        const ifNode = node('if', null, condition, scope)
+export const If = (x: X, fun: () => void) => {
+        const y = node('scope')
+        scoped(y, fun)
+        const ifNode = node('if', null, x, y)
         addToScope(ifNode)
-        const createChain = () => ({
-                ElseIf: (x: X, _fun: () => void) => {
-                        const y = node('scope')
-                        scoped(y, _fun)
-                        ifNode.props.children!.push(x, y)
-                        return createChain()
+        const ret = () => ({
+                ElseIf: (_x: X, _fun: () => void) => {
+                        const _y = node('scope')
+                        scoped(_y, _fun)
+                        ifNode.props.children!.push(_x, _y)
+                        return ret()
                 },
                 Else: (_fun: () => void) => {
-                        const x = node('scope')
-                        scoped(x, _fun)
-                        ifNode.props.children!.push(x)
+                        const _x = node('scope')
+                        scoped(_x, _fun)
+                        ifNode.props.children!.push(_x)
                 },
         })
-        return createChain()
+        return ret()
 }
 
-export const Loop = (x: X, fun: (params: { i?: NodeProxy }) => void) => {
+export const Loop = (x: X, fun: (params: { i: NodeProxy }) => void) => {
         const y = node('scope')
-        scoped(y, () => fun({ i: node('variable', { id: 'i' }) }))
+        scoped(y, () => fun({ i: node('variable', { id: 'i', inferFrom: int(0) }) }))
         const ret = node('loop', null, x, y)
         addToScope(ret)
         return ret
 }
 
-export const Switch = (value: X) => {
-        const switchNode = node('switch', null, value)
+export const Switch = (x: X) => {
+        const switchNode = node('switch', null, x)
         addToScope(switchNode)
-        const createChain = () => ({
+        const ret = () => ({
                 Case: (...values: X[]) => {
                         return (fun: () => void) => {
-                                const scope = node('scope')
-                                scoped(scope, fun)
-                                // 複数のcase値を処理
-                                for (const val of values) {
-                                        switchNode.props.children!.push(val, scope)
-                                }
-                                return createChain()
+                                const y = node('scope')
+                                scoped(y, fun)
+                                for (const _x of values) switchNode.props.children!.push(_x, y)
+                                return ret()
                         }
                 },
                 Default: (fun: () => void) => {
@@ -82,21 +80,32 @@ export const Switch = (value: X) => {
                 },
         })
 
-        return createChain()
+        return ret()
 }
 
 export const Fn = (fun: (paramVars: NodeProxy[]) => NodeProxy) => {
-        const id = getId()
-        return (...args: X[]) => {
+        let layout: FnLayout
+        const ret = (...args: X[]) => {
+                const id = layout?.name || getId()
                 const x = node('scope')
                 let y: NodeProxy | undefined
                 const paramVars: NodeProxy[] = []
-                for (let i = 0; i < args.length; i++) {
-                        const paramId = `p${i}`
-                        const paramVar = node('variable', { id: paramId })
-                        paramVars.push(paramVar)
-                }
+                const paramDefs: NodeProps[] = []
+                if (layout?.inputs)
+                        for (const input of layout.inputs) {
+                                paramDefs.push({ id: input.name, inferFrom: conversion(input.type) })
+                        }
+                else
+                        for (let i = 0; i < args.length; i++) {
+                                paramDefs.push({ id: `p${i}`, inferFrom: args[i] })
+                        }
+                for (const props of paramDefs) paramVars.push(node('variable', props))
                 scoped(x, () => (y = fun(paramVars)))
-                return node('define', { id }, x, y, ...args)
+                return node('define', { id, layout }, x, y, ...args)
         }
+        ret.setLayout = (newLayout: FnLayout) => {
+                layout = newLayout
+                return ret
+        }
+        return ret
 }