glre 0.31.0 → 0.33.0

package/src/node/parse.ts

@@ -0,0 +1,160 @@
+import { is } from '../utils/helpers'
+import { code } from './code'
+import { infer } from './infer'
+import { formatConversions, isConstants, addDependency } from './utils'
+import type { Constants, NodeContext, NodeProps, NodeProxy, X } from './types'
+
+export const parseArray = (children: X[], c: NodeContext) => {
+        return children
+                .filter((x) => !is.und(x) && !is.nul(x))
+                .map((x) => code(x, c))
+                .join(', ')
+}
+
+export const parseTexture = (c: NodeContext, y: X, z: X, w: X) => {
+        if (c.isWebGL) {
+                const args = w ? [y, z, w] : [y, z]
+                return `texture(${parseArray(args, c)})`
+        }
+        const _y = code(y, c)
+        const args = [_y, _y + 'Sampler', code(z, c)]
+        if (!w) return `textureSample(${args})`
+        args.push(code(w, c))
+        return `textureSampleLevel(${args})`
+}
+
+/**
+ * scopes
+ */
+export const parseIf = (c: NodeContext, x: X, y: X, children: X[]) => {
+        let ret = `if (${code(x, c)}) {\n${code(y, c)}\n}`
+        for (let i = 2; i < children.length; i += 2) {
+                const isElse = i >= children.length - 1
+                ret += !isElse
+                        ? ` else if (${code(children[i], c)}) {\n${code(children[i + 1], c)}\n}`
+                        : ` else {\n${code(children[i], c)}\n}`
+        }
+        return ret
+}
+
+export const parseSwitch = (c: NodeContext, x: X, children: X[]) => {
+        let ret = `switch (${code(x, 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 += '}'
+        return ret
+}
+
+export const parseDeclare = (c: NodeContext, x: X, y: X) => {
+        const type = infer(x, c)
+        const varName = (y as any)?.props?.id
+        if (c.isWebGL) return `${type} ${varName} = ${code(x, c)};`
+        const wgslType = formatConversions(type)
+        return `var ${varName}: ${wgslType} = ${code(x, c)};`
+}
+
+export const parseDefine = (c: NodeContext, props: NodeProps, returnType: Constants | string) => {
+        const { id, children = [], layout } = props
+        const [x, ...args] = children
+        const argParams: [name: string, type: string][] = []
+        const params: string[] = []
+        if (layout?.inputs)
+                for (const input of layout.inputs) {
+                        argParams.push([input.name, input.type])
+                }
+        else
+                for (let i = 0; i < args.length; i++) {
+                        argParams.push([`p${i}`, infer(args[i], c)])
+                }
+        const ret = []
+        if (c?.isWebGL) {
+                for (const [paramId, type] of argParams) {
+                        addDependency(c, id!, type)
+                        params.push(`${type} ${paramId}`)
+                }
+                addDependency(c, id!, returnType)
+                ret.push(`${returnType} ${id}(${params}) {`)
+        } else {
+                for (const [paramId, type] of argParams) params.push(`${paramId}: ${formatConversions(type, c)}`)
+                ret.push(`fn ${id}(${params}) -> ${formatConversions(returnType, c)} {`)
+        }
+        const scopeCode = code(x, c)
+        if (scopeCode) ret.push(scopeCode)
+        ret.push('}')
+        return ret.join('\n')
+}
+
+export const parseStructHead = (c: NodeContext, id: string, fields: Record<string, NodeProxy> = {}) => {
+        const lines: string[] = []
+        for (const key in fields) {
+                const fieldType = fields[key]
+                const type = infer(fieldType, c)
+                if (c.isWebGL) addDependency(c, id, type)
+                lines.push(c.isWebGL ? `${type} ${key};` : `${key}: ${formatConversions(type, c)},`)
+        }
+        const ret = lines.join('\n  ')
+        return `struct ${id} {\n  ${ret}\n};`
+}
+
+export const parseStruct = (
+        c: NodeContext,
+        id: string,
+        instanceId = '',
+        fields?: Record<string, NodeProxy>,
+        initialValues?: Record<string, NodeProxy>
+) => {
+        if (c.isWebGL) {
+                if (initialValues) {
+                        const ordered = []
+                        for (const key in fields) ordered.push(initialValues[key])
+                        return `${id} ${instanceId} = ${id}(${parseArray(ordered, c)});`
+                } else return `${id} ${instanceId};`
+        } else {
+                if (initialValues) {
+                        const ordered = []
+                        for (const key in fields) ordered.push(initialValues[key])
+                        return `var ${instanceId}: ${id} = ${id}(${parseArray(ordered, c)});`
+                } else return `var ${instanceId}: ${id};`
+        }
+}
+
+/**
+ * headers
+ */
+export const parseVaryingHead = (c: NodeContext, id: string, type: string) => {
+        return c.isWebGL ? `${type} ${id};` : `@location(${c.code?.vertVaryings?.size || 0}) ${id}: ${formatConversions(type, c)}`
+}
+
+export const parseUniformHead = (c: NodeContext, id: string, type: Constants) => {
+        const isTexture = type === 'sampler2D' || type === 'texture'
+        if (c.isWebGL)
+                return isTexture //
+                        ? `uniform sampler2D ${id};`
+                        : `uniform ${type} ${id};`
+        if (isTexture) {
+                const { group = 1, binding = 0 } = c.gl?.webgpu?.textures.map.get(id) || {}
+                return (
+                        `@group(${group}) @binding(${binding}) var ${id}Sampler: sampler;\n` +
+                        `@group(${group}) @binding(${binding + 1}) var ${id}: texture_2d<f32>;`
+                )
+        }
+        const { group = 0, binding = 0 } = c.gl?.webgpu?.uniforms.map.get(id) || {}
+        const wgslType = formatConversions(type, c)
+        return `@group(${group}) @binding(${binding}) var<uniform> ${id}: ${wgslType};`
+}
+
+export const parseAttribHead = (c: NodeContext, id: string, type: Constants) => {
+        if (c.isWebGL) return `${type} ${id};`
+        const { location = 0 } = c.gl?.webgpu?.attribs.map.get(id) || {}
+        const wgslType = formatConversions(type, c)
+        return `@location(${location}) ${id}: ${wgslType}`
+}
+
+export const parseConstantHead = (c: NodeContext, id: string, type: Constants, value: string) => {
+        return c.isWebGL ? `const ${type} ${id} = ${value};` : `const ${id}: ${formatConversions(type, c)} = ${value};`
+}

package/src/node/scope.ts

@@ -3,24 +3,22 @@ import { conversion, node } from './node'
 import { getId } from './utils'
 import type { FnLayout, NodeProps, NodeProxy, X } from './types'
 
-let _scope: NodeProxy | null = null
-
-const scoped = (x: NodeProxy | null, fun = () => {}) => {
-        const prev = _scope
-        _scope = x
-        fun()
-        _scope = prev
-}
+let scope: NodeProxy | null = null
+let define: NodeProxy | null = null
 
 const addToScope = (x: NodeProxy) => {
-        if (!_scope) return // ignore
-        if (!_scope.props.children) _scope.props.children = []
-        _scope.props.children.push(x)
+        if (!scope) return
+        if (!scope.props.children) scope.props.children = []
+        scope.props.children.push(x)
+        if (x.type !== 'return' || !define) return
+        const { props } = define
+        if (!props.inferFrom) props.inferFrom = []
+        props.inferFrom.push(x)
 }
 
 export const toVar = (x: X, id?: string) => {
         if (!id) id = getId()
-        const y = node('variable', { id, inferFrom: x })
+        const y = node('variable', { id, inferFrom: [x] })
         const z = node('declare', null, x, y)
         addToScope(z)
         return y
@@ -32,6 +30,37 @@ export const assign = (x: X, y: X) => {
         return x
 }
 
+export const Return = (x: X) => {
+        const y = node('return', { inferFrom: [x] }, x)
+        addToScope(y)
+        return y
+}
+
+// Struct functions
+export const struct = (fields: Record<string, NodeProxy>, id = getId()) => {
+        return (initialValues: Record<string, NodeProxy> = {}, instanceId = getId()) => {
+                const x = node('variable', { id: instanceId, inferFrom: [id] })
+                const y = node('struct', { id, fields, initialValues }, x)
+                addToScope(y)
+                return x
+        }
+}
+
+const scoped = (x: NodeProxy, fun: () => NodeProxy | void, y = define) => {
+        // cache to revert
+        const _scope = scope
+        const _define = define
+        // update
+        scope = x
+        define = y
+        if (_scope) x.props.parent = _scope
+        const z = fun()
+        if (z) Return(z)
+        // revert
+        scope = _scope
+        define = _define
+}
+
 export const If = (x: X, fun: () => void) => {
         const y = node('scope')
         scoped(y, fun)
@@ -55,7 +84,7 @@ export const If = (x: X, fun: () => void) => {
 
 export const Loop = (x: X, fun: (params: { i: NodeProxy }) => void) => {
         const y = node('scope')
-        scoped(y, () => fun({ i: node('variable', { id: 'i', inferFrom: int(0) }) }))
+        scoped(y, () => fun({ i: node('variable', { id: 'i', inferFrom: [int(0)] }) }))
         const ret = node('loop', null, x, y)
         addToScope(ret)
         return ret
@@ -79,7 +108,6 @@ export const Switch = (x: X) => {
                         switchNode.props.children!.push(scope)
                 },
         })
-
         return ret()
 }
 
@@ -88,24 +116,21 @@ export const Fn = (fun: (paramVars: NodeProxy[]) => NodeProxy) => {
         const ret = (...args: X[]) => {
                 const id = layout?.name || getId()
                 const x = node('scope')
-                let y: NodeProxy | undefined
                 const paramVars: NodeProxy[] = []
                 const paramDefs: NodeProps[] = []
                 if (layout?.inputs)
                         for (const input of layout.inputs) {
-                                paramDefs.push({ id: input.name, inferFrom: conversion(input.type) })
+                                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] })
+                                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, layout }, x, y, ...args)
-        }
-        ret.setLayout = (newLayout: FnLayout) => {
-                layout = newLayout
-                return ret
+                const y = node('define', { id, layout }, x, ...args)
+                scoped(x, () => fun(paramVars), y)
+                return y
         }
+        ret.setLayout = (_layout: FnLayout) => void (layout = _layout)
         return ret
 }

package/src/node/types.ts

@@ -1,3 +1,4 @@
+import { GL } from '../types'
 import { CONSTANTS, CONVERSIONS, FUNCTIONS, OPERATOR_KEYS } from './const'
 
 export type Constants = (typeof CONSTANTS)[number] | 'void'
@@ -17,23 +18,68 @@ export interface FnLayout {
         }>
 }
 
+/**
+ * Node
+ */
+export type NodeTypes =
+        // headers
+        | 'attribute'
+        | 'uniform'
+        | 'constant'
+        // variables
+        | 'variable'
+        | 'varying'
+        | 'ternary'
+        | 'builtin'
+        | 'conversion'
+        | 'operator'
+        | 'function'
+        // struct
+        | 'struct'
+        | 'member'
+        // scopes
+        | 'scope'
+        | 'assign'
+        | 'loop'
+        | 'define'
+        | 'if'
+        | 'switch'
+        | 'declare'
+        | 'return'
+
 export interface NodeProps {
         id?: string
         args?: X[]
         type?: string
         children?: X[]
-        inferFrom?: X
+        inferFrom?: X[]
         layout?: FnLayout
+        parent?: NodeProxy
+        // for struct
+        fields?: Record<string, NodeProxy>
+        initialValues?: Record<string, NodeProxy>
 }
 
-export interface NodeConfig {
+export interface NodeContext {
+        gl?: Partial<GL>
+        isFrag?: boolean
         isWebGL?: boolean
         binding?: number
         infers?: WeakMap<NodeProxy, Constants>
-        headers?: Map<string, string>
         onMount?: (name: string) => void
+        code?: {
+                headers: Map<string, string>
+                fragInputs: Map<string, string>
+                vertInputs: Map<string, string>
+                vertOutputs: Map<string, string>
+                vertVaryings: Map<string, string>
+                dependencies: Map<string, Set<string>>
+        }
 }
 
+/**
+ * NodeProxy
+ */
 type _Swizzles<T extends string> = T | `${T}${T}` | `${T}${T}${T}` | `${T}${T}${T}${T}`
 
 export type Swizzles =
@@ -42,31 +88,34 @@ export type Swizzles =
         | _Swizzles<'p' | 'q'>
         | _Swizzles<'s' | 't'>
 
-export type NodeTypes =
-        // headers
-        | 'attribute'
-        | 'uniform'
-        | 'varying'
-        | 'constant'
-        // variables
-        | 'variable'
-        | 'swizzle'
-        | 'ternary'
-        | 'builtin'
-        | 'conversion'
-        | 'operator'
-        | 'function'
-        // scopes
-        | 'scope'
+type NodeProxyMethods =
+        | Functions
+        | Operators
+        | Conversions
+        | Swizzles
+        // system property
+        | 'type'
+        | 'props'
+        | 'isProxy'
         | 'assign'
-        | 'loop'
-        | 'define'
-        | 'if'
-        | 'switch'
-        | 'declare'
+        | 'toVar'
+        | 'toString'
+
+export type ReadNodeProxy = {
+        [K in string as K extends NodeProxyMethods ? never : K]: X
+}
 
-export interface NodeProxy extends Record<Swizzles, NodeProxy> {
-        // Operators
+export interface BaseNodeProxy extends Record<Swizzles, NodeProxy> {
+        // System properties
+        assign(n: X): NodeProxy
+        toVar(name?: string): NodeProxy
+        toString(c?: NodeContext): string
+        type: NodeTypes
+        props: NodeProps
+        isProxy: true
+        listeners: Set<(value: any) => void>
+
+        // Operators methods
         add(n: X): NodeProxy
         sub(n: X): NodeProxy
         mul(n: X): NodeProxy
@@ -82,11 +131,29 @@ export interface NodeProxy extends Record<Swizzles, NodeProxy> {
         or(n: X): NodeProxy
         not(): NodeProxy
 
-        // Variable manipulation
-        assign(n: X): NodeProxy
-        toVar(name?: string): NodeProxy
+        // Conversations methods
+        toBool(): NodeProxy
+        toUint(): NodeProxy
+        toInt(): NodeProxy
+        toFloat(): NodeProxy
+        toBvec2(): NodeProxy
+        toIvec2(): NodeProxy
+        toUvec2(): NodeProxy
+        toVec2(): NodeProxy
+        toBvec3(): NodeProxy
+        toIvec3(): NodeProxy
+        toUvec3(): NodeProxy
+        toVec3(): NodeProxy
+        toBvec4(): NodeProxy
+        toIvec4(): NodeProxy
+        toUvec4(): NodeProxy
+        toVec4(): NodeProxy
+        toColor(): NodeProxy
+        toMat2(): NodeProxy
+        toMat3(): NodeProxy
+        toMat4(): NodeProxy
 
-        // Math function methods
+        // Function methods
         abs(): NodeProxy
         sin(): NodeProxy
         cos(): NodeProxy
@@ -131,32 +198,8 @@ export interface NodeProxy extends Record<Swizzles, NodeProxy> {
         dFdx(): NodeProxy
         dFdy(): NodeProxy
         fwidth(): NodeProxy
-
-        // System properties
-        toBool(): NodeProxy
-        toUint(): NodeProxy
-        toInt(): NodeProxy
-        toFloat(): NodeProxy
-        toBvec2(): NodeProxy
-        toIvec2(): NodeProxy
-        toUvec2(): NodeProxy
-        toVec2(): NodeProxy
-        toBvec3(): NodeProxy
-        toIvec3(): NodeProxy
-        toUvec3(): NodeProxy
-        toVec3(): NodeProxy
-        toBvec4(): NodeProxy
-        toIvec4(): NodeProxy
-        toUvec4(): NodeProxy
-        toVec4(): NodeProxy
-        toColor(): NodeProxy
-        toMat2(): NodeProxy
-        toMat3(): NodeProxy
-        toMat4(): NodeProxy
-        toString(c?: NodeConfig): string
-        type: NodeTypes
-        props: NodeProps
-        isProxy: true
 }
 
-export type X = NodeProxy | number | string | boolean | undefined
+export type NodeProxy = BaseNodeProxy & ReadNodeProxy
+
+export type X = X[] | (NodeProxy | number | string | boolean | undefined)

package/src/node/utils.ts

@@ -1,6 +1,4 @@
 import { is } from '../utils/helpers'
-import { code } from './code'
-import { infer } from './infer'
 import {
         CONSTANTS,
         CONVERSIONS,
@@ -10,17 +8,7 @@ import {
         TYPE_MAPPING,
         WGSL_TO_GLSL_BUILTIN,
 } from './const'
-import type {
-        Constants,
-        Conversions,
-        Functions,
-        NodeConfig,
-        NodeProps,
-        NodeProxy,
-        Operators,
-        Swizzles,
-        X,
-} from './types'
+import type { Constants, Conversions, Functions, NodeContext, NodeProxy, Operators, Swizzles, X } from './types'
 
 export const isSwizzle = (key: unknown): key is Swizzles => {
         return is.str(key) && /^[xyzwrgbastpq]{1,4}$/.test(key)
@@ -44,6 +32,11 @@ export const isNodeProxy = (x: unknown): x is NodeProxy => {
         return x.isProxy
 }
 
+export const isConstants = (type?: unknown): type is Constants => {
+        if (!is.str(type)) return false
+        return CONSTANTS.includes(type)
+}
+
 export const hex2rgb = (hex: number) => {
         const r = ((hex >> 16) & 0xff) / 255
         const g = ((hex >> 8) & 0xff) / 255
@@ -55,17 +48,10 @@ let count = 0
 
 export const getId = () => `i${count++}`
 
-export const joins = (children: X[], c: NodeConfig) => {
-        return children
-                .filter((x) => !is.und(x) && !is.nul(x))
-                .map((x) => code(x, c))
-                .join(', ')
-}
-
-export const formatConversions = (x: X, c?: NodeConfig) => {
+export const formatConversions = (x: X, c?: NodeContext) => {
         if (!is.str(x)) return ''
         if (c?.isWebGL) return x
-        return TYPE_MAPPING[x as keyof typeof TYPE_MAPPING]
+        return TYPE_MAPPING[x as keyof typeof TYPE_MAPPING] || x // for struct type
 }
 
 export const getOperator = (op: X) => {
@@ -81,80 +67,63 @@ export const conversionToConstant = (conversionKey: string): Constants => {
         return index !== -1 ? CONSTANTS[index] : 'float'
 }
 
-const generateHead = (c: NodeConfig) => {
-        return Array.from(c.headers!)
-                .map(([, v]) => v)
-                .join('\n')
-}
-
-export const generateDefine = (props: NodeProps, c: NodeConfig) => {
-        const { id, children = [], layout } = props
-        const [x, y, ...args] = children
-        const returnType = layout?.type && layout?.type !== 'auto' ? layout?.type : y ? infer(y, c) : 'void'
-        const argParams: [name: string, type: string][] = []
-        const params: string[] = []
-        if (layout?.inputs)
-                for (const input of layout.inputs) {
-                        argParams.push([input.name, input.type])
+export const getEventFun = (c: NodeContext, id: string, isAttribute = false, isTexture = false) => {
+        if (c.isWebGL) {
+                if (isAttribute) return (value: any) => c.gl?.attribute?.(id, value)
+                if (isTexture) return (value: any) => c.gl?.texture?.(id, value)
+                return (value: any) => c.gl?.uniform?.(id, value)
+        }
+        if (isAttribute) return (value: any) => c.gl?._attribute?.(id, value)
+        if (isTexture) return (value: any) => c.gl?._texture?.(id, value)
+        return (value: any) => c.gl?._uniform?.(id, value)
+}
+
+export const safeEventCall = (x: X, fun: (value: unknown) => void) => {
+        if (!x) return
+        if (!isNodeProxy(x)) return fun(x) // for uniform(1)
+        if (x.type !== 'conversion') return
+        const value = x.props.children?.slice(1).filter(Boolean)
+        if (!value?.length) return // for uniform(vec2())
+        fun(value)
+}
+
+export const initNodeContext = (c: NodeContext) => {
+        if (!c.code) {
+                c.code = {
+                        headers: new Map(),
+                        fragInputs: new Map(),
+                        vertInputs: new Map(),
+                        vertOutputs: new Map(),
+                        vertVaryings: new Map(),
+                        dependencies: new Map(),
                 }
-        else
-                for (let i = 0; i < args.length; i++) {
-                        argParams.push([`p${i}`, infer(args[i], c)])
+                if (!c.isWebGL) {
+                        c.code.fragInputs.set('position', '@builtin(position) position: vec4f')
+                        c.code.vertOutputs.set('position', '@builtin(position) position: vec4f')
                 }
-        let ret = ''
-        if (c?.isWebGL) {
-                for (const [id, type] of argParams) params.push(`${type} ${id}`)
-                ret += `${returnType} ${id}(${params}) {\n`
-        } else {
-                for (const [id, type] of argParams) params.push(`${id}: ${formatConversions(type, c)}`)
-                ret += `fn ${id}(${params}) -> ${formatConversions(returnType, c)} {\n`
         }
-        const scopeCode = code(x, c)
-        if (scopeCode) ret += scopeCode + '\n'
-        if (y) ret += `return ${code(y, c)};`
-        ret += '\n}'
-        return ret
-}
-
-const GLSL_FRAGMENT_HEAD = `
-#version 300 es
-precision mediump float;
-out vec4 fragColor;
-`.trim()
-
-const WGSL_FRAGMENT_HEAD = `
-@fragment
-fn main(@builtin(position) position: vec4f) -> @location(0) vec4f {
-`.trim()
-
-const generateFragmentMain = (body: string, head: string, isWebGL = true) => {
-        let ret = ''
-        if (isWebGL) ret += GLSL_FRAGMENT_HEAD
-        if (head) ret += '\n' + head + '\n'
-        if (isWebGL) ret += `void main() {\n  fragColor = ${body};`
-        else {
-                ret += WGSL_FRAGMENT_HEAD + '\n'
-                ret += `  return ${body};`
+        return c
+}
+
+export const addDependency = (c: NodeContext, id = '', type: string) => {
+        if (!c.code?.dependencies?.has(id)) c.code!.dependencies.set(id, new Set())
+        if (!isConstants(type)) c.code!.dependencies.get(id)!.add(type)
+}
+
+export const sortHeadersByDependencies = (headers: Map<string, string>, dependencies: Map<string, Set<string>>) => {
+        const sorted: [string, string][] = []
+        const visited = new Set<string>()
+        const visiting = new Set<string>()
+        const visit = (id: string) => {
+                if (visiting.has(id)) return
+                if (visited.has(id)) return
+                visiting.add(id)
+                const deps = dependencies.get(id) || new Set()
+                for (const dep of deps) if (headers.has(dep)) visit(dep)
+                visiting.delete(id)
+                visited.add(id)
+                if (headers.has(id)) sorted.push([id, headers.get(id)!])
         }
-        ret += '\n}'
-        return ret
-}
-
-const generateVertexMain = (_body: string, _head: string, isWebGL = true) => {
-        if (isWebGL) return ``
-        return ``
-}
-
-export const fragment = (x: X, c: NodeConfig = {}) => {
-        const body = code(x, c)
-        const head = generateHead(c)
-        const main = generateFragmentMain(body, head, c.isWebGL)
-        console.log(`// ↓↓↓ generated ↓↓↓\n\n${main}\n\n`)
-        return main
-}
-
-export const vertex = (x: X, c: NodeConfig) => {
-        const body = code(x, c)
-        const head = generateHead(c)
-        return generateVertexMain(body, head, c.isWebGL)
+        for (const [id] of headers) visit(id)
+        return sorted
 }