glre 0.28.0 → 0.29.0

package/src/node/types.ts

@@ -13,16 +13,15 @@ export interface NodeProps {
         args?: X[]
         type?: string
         children?: X[]
-        returnType?: Constants
         value?: number | number[] | boolean
-        paramInfo?: Array<{ name: string; type: string }>
 }
 
 export interface NodeConfig {
         isWebGL?: boolean
-        uniforms?: Set<string>
-        functions?: Set<string>
-        onUniform?: (name: string, value: any) => void
+        binding?: number
+        infers?: WeakMap<NodeProxy, Constants>
+        headers?: Map<string, string>
+        onMount?: (name: string, value: any) => void
 }
 
 type _Swizzles<T extends string> = T | `${T}${T}` | `${T}${T}${T}` | `${T}${T}${T}${T}`
@@ -38,24 +37,20 @@ export type NodeTypes =
         | 'variable'
         | 'swizzle'
         | 'operator'
-        | 'conversions'
-        | 'math_fun'
+        | 'conversion'
+        | 'function'
         | 'declare'
         | 'assign'
-        | 'fn_def'
-        | 'fn_run'
+        | 'define'
         | 'if'
         | 'loop'
         | 'scope'
         | 'switch'
-        | 'case'
-        | 'default'
         | 'ternary'
         | 'attribute'
         | 'varying'
         | 'builtin'
         | 'constant'
-        | 'vertex_stage'
 
 export interface NodeProxy extends Record<Swizzles | Conversions, NodeProxy> {
         // Operators
@@ -132,4 +127,4 @@ export interface NodeProxy extends Record<Swizzles | Conversions, NodeProxy> {
         isProxy: true
 }
 
-export type X = NodeProxy | number | string | boolean | null | undefined
+export type X = NodeProxy | number | string | boolean | undefined

package/src/node/utils.ts

@@ -1,7 +1,9 @@
+import { NodeProps } from './../../../../node_modules/glre/src/node/types'
 import { is } from '../utils/helpers'
 import { code } from './code'
 import { CONVERSIONS, FUNCTIONS, OPERATOR_KEYS, OPERATORS, TYPE_MAPPING } from './const'
 import type { Conversions, Functions, NodeConfig, NodeProxy, Operators, Swizzles, X } from './types'
+import { infer } from './infer'
 
 export const isSwizzle = (key: unknown): key is Swizzles => {
         return is.str(key) && /^[xyzwrgbastpq]{1,4}$/.test(key)
@@ -21,7 +23,7 @@ export const isConversion = (key: unknown): key is Conversions => {
 
 export const isNodeProxy = (x: unknown): x is NodeProxy => {
         if (!x) return false
-        if (!is.fun(x)) return false // @ts-ignore
+        if (typeof x !== 'object') return false // @ts-ignore
         return x.isProxy
 }
 
@@ -54,14 +56,25 @@ export const getOperator = (op: X) => {
 }
 
 const generateHead = (c: NodeConfig) => {
-        const uniforms = Array.from(c.uniforms!)
-                .map((uniform, i) => {
-                        if (c.isWebGL) return `uniform ${uniform};`
-                        else return `@group(0) @binding(${i}) var<uniform> ${uniform};`
-                })
+        return Array.from(c.headers!)
+                .map(([, v]) => v)
                 .join('\n')
-        const functions = Array.from(c.functions!).join('\n')
-        return `${uniforms}\n${functions}`
+}
+
+export const generateDefine = (props: NodeProps, c: NodeConfig) => {
+        const { id, children = [] } = props
+        const [x, y, ...args] = children
+        const returnType = y ? infer(y, c) : 'void'
+        const params = args.map((arg, i) => [`p${i}`, infer(arg, c)])
+        const lines = [code(x, c)]
+        if (y) lines.push(`return ${code(y, c)};`)
+        if (c?.isWebGL) {
+                const paramList = params.map(([name, type]) => `${type} ${name}`)
+                return `${returnType} ${id}(${paramList}) {\n${lines.join('\n')}\n}`
+        }
+        const wgslReturnType = formatConversions(returnType, c)
+        const wgslParams = params.map(([name, type]) => `${name}: ${formatConversions(type, c)}`)
+        return `fn ${id}(${wgslParams}) -> ${wgslReturnType} {\n${lines.join('\n')}\n}`
 }
 
 const generateFragmentMain = (body: string, head: string, isWebGL = true) => {
@@ -82,10 +95,12 @@ return ${body};
 }`.trim()
 }
 
-export const fragment = (x: X, c: NodeConfig) => {
+export const fragment = (x: X, c: NodeConfig = {}) => {
         const body = code(x, c)
         const head = generateHead(c)
-        return generateFragmentMain(body, head, c.isWebGL)
+        const main = generateFragmentMain(body, head, c.isWebGL)
+        console.log(`// ↓↓↓ generated ↓↓↓\n\n${main}\n\n`)
+        return main
 }
 
 export const vertex = (x: X, c: NodeConfig) => {

package/src/types.ts

@@ -1,6 +1,6 @@
 import { EventState } from 'reev'
 import type { Fun, Queue, Frame } from 'refr'
-import type { X } from './node'
+import type { NodeProxy } from './node'
 export type { Fun, Queue, Frame }
 export type GPUContext = any // GPUCanvasContext https://developer.mozilla.org/en-US/docs/Web/API/GPUCanvasContext
 export type GPUDevice = any //
@@ -52,12 +52,12 @@ export type GL = EventState<{
         mouse: [number, number]
         count: number
         el: HTMLCanvasElement
-        vs: string | X
-        fs: string | X
-        vert: string | X
-        frag: string | X
-        vertex: string | X
-        fragment: string | X
+        vs: string | NodeProxy
+        fs: string | NodeProxy
+        vert: string | NodeProxy
+        frag: string | NodeProxy
+        vertex: string | NodeProxy
+        fragment: string | NodeProxy
 
         /**
          * core state

package/src/utils/pipeline.ts

@@ -1,5 +1,5 @@
-import { fragment, vertex, X } from '../node'
-import { is } from './helpers'
+import { fragment, isNodeProxy, vertex } from '../node'
+import type { NodeProxy } from '../node'
 import type { GPUContext, GPUDevice, GPUPipeline } from '../types'
 
 const defaultVertexWGSL = `
@@ -34,11 +34,11 @@ export const createPipeline = (
         format: string,
         bufferLayouts: any[],
         bindGroupLayouts: any[],
-        vs: string | X = defaultVertexWGSL,
-        fs: string | X = defaultFragmentWGSL
+        vs: string | NodeProxy = defaultVertexWGSL,
+        fs: string | NodeProxy = defaultFragmentWGSL
 ) => {
-        if (!is.str(fs)) fs = fragment(fs, { isWebGL: false })
-        if (!is.str(vs)) vs = vertex(vs, { isWebGL: false })
+        if (isNodeProxy(vs)) vs = vertex(vs, { isWebGL: false })
+        if (isNodeProxy(fs)) fs = fragment(fs, { isWebGL: false })
         const layout = device.createPipelineLayout({ bindGroupLayouts })
         return device.createRenderPipeline({
                 vertex: {

package/src/utils/program.ts

@@ -1,5 +1,5 @@
-import { fragment, vertex, X } from '../node'
-import { is } from './helpers'
+import { fragment, isNodeProxy, vertex } from '../node'
+import type { NodeProxy } from '../node'
 
 export const defaultVertexGLSL = /* cpp */ `
 #version 300 es
@@ -33,12 +33,12 @@ const createShader = (c: WebGLRenderingContext, source: string, type: number) =>
 
 export const createProgram = (
         c: WebGLRenderingContext,
-        vs: string | X = defaultVertexGLSL,
-        fs: string | X = defaultFragmentGLSL,
+        vs: string | NodeProxy = defaultVertexGLSL,
+        fs: string | NodeProxy = defaultFragmentGLSL,
         onError = () => {}
 ) => {
-        if (!is.str(fs)) fs = fragment(fs, { isWebGL: true })
-        if (!is.str(vs)) vs = vertex(fs, { isWebGL: true })
+        if (isNodeProxy(fs)) fs = fragment(fs, { isWebGL: true })
+        if (isNodeProxy(vs)) vs = vertex(fs, { isWebGL: true })
         const pg = c.createProgram()
         const _vs = createShader(c, vs, c.VERTEX_SHADER)
         const _fs = createShader(c, fs, c.FRAGMENT_SHADER)

package/src/webgl.ts

@@ -6,13 +6,12 @@ import type { GL, WebGLState } from './types'
 export const webgl = async (gl: Partial<GL>) => {
         const c = gl.el!.getContext('webgl2')!
         const pg = createProgram(c, gl.vs, gl.fs, () => void (gl.isLoop = false))!
-        const state = { context: c, program: pg } as WebGLState
         c.useProgram(pg)
-
         let _activeUnit = 0
         const uniforms = cached((key) => c.getUniformLocation(pg, key))
         const attribs = cached((key) => c.getAttribLocation(pg, key))
         const units = cached(() => _activeUnit++)
+        const state = { context: c, program: pg } as WebGLState
 
         const clean = () => c.deleteProgram(pg)