glre 0.38.0 → 0.40.0

package/src/node/core.ts

@@ -1,121 +0,0 @@
-import { code } from './utils'
-import { is } from '../utils/helpers'
-import type { NodeContext, X } from './types'
-
-const GLSL_FRAGMENT_HEAD = `
-#version 300 es
-precision mediump float;
-out vec4 fragColor;
-`.trim()
-
-const topological = (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)!])
-        }
-        for (const [id] of headers) visit(id)
-        return sorted
-}
-
-const generateHead = (x: X, c: NodeContext) => {
-        const body = code(x, c)
-        let head = ''
-        if (c.isWebGL && c.code?.dependencies) {
-                const sorted = topological(c.code.headers, c.code.dependencies)
-                head = sorted.map(([, value]) => value).join('\n')
-        } else head = Array.from(c.code?.headers?.values() || []).join('\n')
-        return [head, body]
-}
-
-const generateStruct = (id: string, map: Map<string, string>) => {
-        return `struct ${id} {\n  ${Array.from(map.values()).join(',\n  ')}\n}`
-}
-
-export const fragment = (x: X, c: NodeContext) => {
-        if (is.str(x)) return x.trim()
-        c.code?.headers?.clear()
-        c.label = 'frag' // for varying inputs or outputs
-        const [head, body] = generateHead(x, c)
-        const ret = []
-        if (c.isWebGL) {
-                ret.push(GLSL_FRAGMENT_HEAD)
-                for (const code of c.code?.fragInputs?.values() || []) ret.push(`in ${code}`)
-                ret.push(head)
-                ret.push(`void main() {\n  fragColor = ${body};`)
-        } else {
-                if (c.code?.fragInputs?.size) ret.push(generateStruct('Out', c.code.fragInputs))
-                ret.push(head)
-                ret.push(`@fragment\nfn main(out: Out) -> @location(0) vec4f {`)
-                ret.push(`  return ${body};`)
-        }
-        ret.push('}')
-        const main = ret.filter(Boolean).join('\n').trim()
-        // console.log(`↓↓↓generated↓↓↓\n${main}`)
-        return main
-}
-
-export const vertex = (x: X, c: NodeContext) => {
-        if (is.str(x)) return x.trim()
-        c.code?.headers?.clear()
-        c.label = 'vert' // for varying inputs or outputs
-        const [head, body] = generateHead(x, c)
-        const ret = []
-        if (c.isWebGL) {
-                ret.push('#version 300 es')
-                for (const code of c.code?.vertInputs?.values() || []) ret.push(`in ${code}`)
-                for (const code of c.code?.vertOutputs?.values() || []) ret.push(`out ${code}`)
-                ret.push(head)
-                ret.push('void main() {')
-                ret.push(`  gl_Position = ${body};`)
-                for (const [id, code] of c.code?.vertVaryings?.entries() || []) ret.push(`  ${id} = ${code};`)
-        } else {
-                if (c.code?.vertInputs?.size) ret.push(generateStruct('In', c.code.vertInputs))
-                if (c.code?.vertOutputs?.size) ret.push(generateStruct('Out', c.code.vertOutputs))
-                ret.push(head)
-                ret.push('@vertex')
-                ret.push(`fn main(${c.code?.vertInputs?.size ? 'in: In' : ''}) -> Out {`)
-                ret.push('  var out: Out;')
-                ret.push(`  out.position = ${body};`)
-                for (const [id, code] of c.code?.vertVaryings?.entries() || []) ret.push(`  out.${id} = ${code};`)
-                ret.push('  return out;')
-        }
-        ret.push('}')
-        const main = ret.filter(Boolean).join('\n').trim()
-        // console.log(`↓↓↓generated↓↓↓\n${main}`)
-        return main
-}
-
-export const compute = (x: X, c: NodeContext) => {
-        if (is.str(x)) return x.trim()
-        c.code?.headers?.clear()
-        c.label = 'compute'
-        const [head, body] = generateHead(x, c)
-        const ret = []
-        if (c.isWebGL) {
-                ret.push('#version 300 es')
-                ret.push('precision mediump float;')
-                ret.push(head)
-                ret.push('void main() {')
-                ret.push(`  ${body};`)
-                ret.push('}')
-        } else {
-                if (c.code?.computeInputs?.size) ret.push(generateStruct('In', c.code.computeInputs))
-                ret.push(head)
-                ret.push('@compute @workgroup_size(32)')
-                ret.push(`fn main(${c.code?.computeInputs?.size ? 'in: In' : ''}) {`)
-                ret.push(`  ${body};`)
-                ret.push('}')
-        }
-        const main = ret.filter(Boolean).join('\n').trim()
-        // console.log(`↓↓↓generated↓↓↓\n${main}`)
-        return main
-}

package/src/node/node.ts

@@ -1,65 +0,0 @@
-import { code, getConstant, isConversion, isFunction, isOperator, getId, isArrayAccess } from './utils'
-import { assign, toVar } from './scope'
-import { is } from '../utils/helpers'
-import type { Functions, NodeProps, NodeProxy, NodeTypes, Operators, X, Constants as C } from './types'
-
-const toPrimitive = (x: X, hint: string) => {
-        if (hint === 'string') return code(x, null)
-}
-
-export const node = <T extends C>(type: NodeTypes, props?: NodeProps | null, ...args: X[]) => {
-        if (!props) props = {}
-        if (args.length) props.children = args
-        const listeners = new Set<(value: any) => void>()
-        const get = (_: unknown, y: string | Symbol) => {
-                if (y === 'type') return type
-                if (y === 'props') return props
-                if (y === '__nodeType') return undefined // Will be inferred by TypeScript
-                if (y === 'toVar') return toVar.bind(null, x as any)
-                if (y === 'isProxy') return true
-                if (y === 'toString') return code.bind(null, x)
-                if (y === Symbol.toPrimitive) return toPrimitive.bind(null, x)
-                if (y === 'listeners') return listeners
-                if (y === 'attribute') return (id = getId()) => attribute(x, id)
-                if (y === 'constant') return (id = getId()) => constant(x, id)
-                if (y === 'uniform') return (id = getId()) => uniform(x, id)
-                if (y === 'variable') return (id = getId()) => variable(id)
-                if (y === 'builtin') return (id = getId()) => builtin(id)
-                if (y === 'vertexStage') return (id = getId()) => vertexStage(x, id)
-                if (y === 'element') return (z: X) => (type === 'storage' ? gather(x, z) : element(x, z))
-                if (y === 'member') return (z: X) => member(x, z)
-                if (y === 'assign') return assign.bind(null, x, x.type === 'gather')
-                if (isOperator(y)) return (...z: X[]) => operator(y, x, ...z)
-                if (isFunction(y)) return (...z: X[]) => function_(y, x, ...z)
-                if (isConversion(y)) return () => conversion(getConstant(y), x)
-                if (is.str(y)) return isArrayAccess(y) ? element(x, y) : member(x, y)
-        }
-        const set = (_: unknown, y: string, z: X) => {
-                if (y === 'value') listeners.forEach((fun) => fun(z))
-                if (is.str(y)) member(x, y).assign(z)
-                return true
-        }
-        const x = new Proxy({}, { get, set }) as unknown as NodeProxy<T>
-        return x
-}
-
-// headers with proper type inference
-export const attribute = <T extends C>(x: X<T>, id = getId()) => node<T>('attribute', { id }, x)
-export const constant = <T extends C>(x: X<T>, id = getId()) => node<T>('constant', { id }, x)
-export const uniform = <T extends C>(x: X<T>, id = getId()) => node<T>('uniform', { id }, x)
-export const storage = <T extends C>(x: X<T>, id = getId()) => node<T>('storage', { id }, x)
-export const variable = <T extends C>(id = getId()) => node<T>('variable', { id })
-export const builtin = <T extends C>(id = getId()) => node<T>('builtin', { id })
-export const vertexStage = <T extends C>(x: X<T>, id = getId()) => {
-        return node<T>('varying', { id, inferFrom: [x] }, x)
-}
-
-// Node shorthands with proper typing
-export const member = <T extends C>(x: X, index: X) => node<T>('member', null, x, index)
-export const element = <T extends C>(x: X, index: X) => node<T>('element', null, x, index)
-export const gather = <T extends C>(x: X, index: X) => node<T>('gather', null, x, index)
-export const scatter = <T extends C>(x: X, index: X) => node<T>('scatter', null, x, index)
-export const select = <T extends C>(x: X<T>, y: X<T>, z: X) => node<T>('ternary', null, x, y, z) // z ? x : y @TODO REMOVE
-export const operator = <T extends C>(key: Operators, ...x: X[]) => node<T>('operator', null, key, ...x)
-export const function_ = <T extends C>(key: Functions, ...x: X[]) => node<T>('function', null, key, ...x)
-export const conversion = <T extends C>(key: T, ...x: X[]) => node<T>('conversion', null, key, ...x)