glre 0.27.0 → 0.29.0

package/src/node/scope.ts

@@ -4,10 +4,10 @@ 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
 }
 
@@ -17,52 +17,86 @@ const addToScope = (x: NodeProxy) => {
         _scope.props.children.push(x)
 }
 
-export const If = (x: X, callback: () => void) => {
-        const y = node('scope')
-        scoped(y, callback)
-        const ifNode = node('if', null, x, y)
+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, fun)
+        const ifNode = node('if', null, condition, scope)
         addToScope(ifNode)
-        return {
-                ElseIf: (y: X, elseCallback: () => void) => {
-                        const z = node('scope')
-                        scoped(z, elseCallback)
-                        ifNode.props.children!.push(y, z)
+        const createChain = () => ({
+                ElseIf: (x: X, _fun: () => void) => {
+                        const y = node('scope')
+                        scoped(y, _fun)
+                        ifNode.props.children!.push(x, y)
+                        return createChain()
                 },
-                Else: (elseCallback: () => void) => {
-                        const z = node('scope')
-                        scoped(z, elseCallback)
-                        ifNode.props.children!.push(z)
+                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
 }
 
-export const Fn = (callback: (args: X[]) => NodeProxy) => {
-        return (...args: X[]) => {
-                let result
-                const fnScope = node('scope')
-                scoped(fnScope, () => (result = callback(args)))
-                return node('fn', null, fnScope, result)
-        }
-}
+export const Switch = (value: X) => {
+        const switchNode = node('switch', null, value)
+        addToScope(switchNode)
+        const createChain = () => ({
+                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()
+                        }
+                },
+                Default: (fun: () => void) => {
+                        const scope = node('scope')
+                        scoped(scope, fun)
+                        switchNode.props.children!.push(scope)
+                },
+        })
 
-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
+        return createChain()
 }
 
-export const assign = (x: X) => (y: X) => {
-        const assignNode = node('assign', null, x, y)
-        addToScope(assignNode)
-        return x
+export const Fn = (fun: (paramVars: NodeProxy[]) => NodeProxy) => {
+        const id = getId()
+        return (...args: X[]) => {
+                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)
+                }
+                scoped(x, () => (y = fun(paramVars)))
+                return node('define', { id }, x, y, ...args)
+        }
 }

package/src/node/types.ts

@@ -1,6 +1,8 @@
-import { FUNCTIONS, NODE_TYPES, OPERATOR_KEYS } from './const'
+import { CONSTANTS, CONVERSIONS, FUNCTIONS, OPERATOR_KEYS } from './const'
 
-export type NodeType = (typeof NODE_TYPES)[number]
+export type Constants = (typeof CONSTANTS)[number] | 'void'
+
+export type Conversions = (typeof CONVERSIONS)[number]
 
 export type Functions = (typeof FUNCTIONS)[number]
 
@@ -8,14 +10,18 @@ export type Operators = (typeof OPERATOR_KEYS)[number]
 
 export interface NodeProps {
         id?: string
+        args?: X[]
+        type?: string
         children?: X[]
-        defaultValue?: number | number[]
+        value?: number | number[] | boolean
 }
 
 export interface NodeConfig {
         isWebGL?: boolean
-        uniforms?: 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}`
@@ -31,16 +37,23 @@ export type NodeTypes =
         | 'variable'
         | 'swizzle'
         | 'operator'
-        | 'node_type'
-        | 'math_fun'
+        | 'conversion'
+        | 'function'
         | 'declare'
         | 'assign'
-        | 'fn'
+        | 'define'
         | 'if'
         | 'loop'
         | 'scope'
+        | 'switch'
+        | 'ternary'
+        | 'attribute'
+        | 'varying'
+        | 'builtin'
+        | 'constant'
 
-export interface NodeProxy extends Record<Swizzles, NodeProxy> {
+export interface NodeProxy extends Record<Swizzles | Conversions, NodeProxy> {
+        // Operators
         add(n: X): NodeProxy
         sub(n: X): NodeProxy
         mul(n: X): NodeProxy
@@ -55,12 +68,63 @@ export interface NodeProxy extends Record<Swizzles, NodeProxy> {
         and(n: X): NodeProxy
         or(n: X): NodeProxy
         not(): NodeProxy
+
+        // Variable manipulation
         assign(n: X): NodeProxy
         toVar(name?: string): NodeProxy
+        toConst(name?: string): NodeProxy
+
+        // Math function methods
+        abs(): NodeProxy
+        sin(): NodeProxy
+        cos(): NodeProxy
+        tan(): NodeProxy
+        asin(): NodeProxy
+        acos(): NodeProxy
+        atan(): NodeProxy
+        atan2(x: X): NodeProxy
+        pow(y: X): NodeProxy
+        pow2(): NodeProxy
+        pow3(): NodeProxy
+        pow4(): NodeProxy
+        sqrt(): NodeProxy
+        inverseSqrt(): NodeProxy
+        exp(): NodeProxy
+        exp2(): NodeProxy
+        log(): NodeProxy
+        log2(): NodeProxy
+        floor(): NodeProxy
+        ceil(): NodeProxy
+        round(): NodeProxy
+        fract(): NodeProxy
+        trunc(): NodeProxy
+        min(y: X): NodeProxy
+        max(y: X): NodeProxy
+        clamp(min: X, max: X): NodeProxy
+        saturate(): NodeProxy
+        mix(y: X, a: X): NodeProxy
+        step(edge: X): NodeProxy
+        smoothstep(edge0: X, edge1: X): NodeProxy
+        length(): NodeProxy
+        distance(y: X): NodeProxy
+        dot(y: X): NodeProxy
+        cross(y: X): NodeProxy
+        normalize(): NodeProxy
+        reflect(N: X): NodeProxy
+        refract(N: X, eta: X): NodeProxy
+        sign(): NodeProxy
+        oneMinus(): NodeProxy
+        reciprocal(): NodeProxy
+        negate(): NodeProxy
+        dFdx(): NodeProxy
+        dFdy(): NodeProxy
+        fwidth(): NodeProxy
+
+        // System properties
         toString(c?: NodeConfig): string
         type: NodeTypes
         props: NodeProps
         isProxy: true
 }
 
-export type X = NodeProxy | number | string | 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 { FUNCTIONS, NODE_TYPES, OPERATOR_KEYS } from './const'
-import type { Functions, NodeConfig, NodeType, Operators, Swizzles, X } from './types'
+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)
@@ -11,16 +13,29 @@ export const isOperator = (key: unknown): key is Operators => {
         return OPERATOR_KEYS.includes(key as Operators)
 }
 
-export const isNodeType = (key: unknown): key is NodeType => {
-        return NODE_TYPES.includes(key as NodeType)
-}
-
 export const isFunction = (key: unknown): key is Functions => {
         return FUNCTIONS.includes(key as Functions)
 }
 
+export const isConversion = (key: unknown): key is Conversions => {
+        return CONVERSIONS.includes(key as Conversions)
+}
+
+export const isNodeProxy = (x: unknown): x is NodeProxy => {
+        if (!x) return false
+        if (typeof x !== 'object') return false // @ts-ignore
+        return x.isProxy
+}
+
 let count = 0
 
+export const hex2rgb = (hex: number) => {
+        const r = ((hex >> 16) & 0xff) / 255
+        const g = ((hex >> 8) & 0xff) / 255
+        const b = (hex & 0xff) / 255
+        return [r, g, b]
+}
+
 export const getId = () => `i${count++}`
 
 export const joins = (children: X[], c: NodeConfig) => {
@@ -30,73 +45,66 @@ export const joins = (children: X[], c: NodeConfig) => {
                 .join(', ')
 }
 
-export const inferType = (target: X, c: NodeConfig): string => {
-        if (!target || typeof target !== 'object') return 'float'
-        const { type, props } = target
-        const { children = [] } = props
-        const [x, y, z] = children
-        if (type === 'node_type') return x as string
-        if (type === 'operator') {
-                const left = inferType(y, c)
-                const right = inferType(z, c)
-                if (left === right) return left
-                if (left.includes('vec')) return left
-                if (right.includes('vec')) return right
-                return 'float'
-        }
-        if (type === 'math_fun') {
-                if (['normalize', 'cross', 'reflect'].includes(x as string)) return inferType(children[1], c)
-                if (['dot', 'distance', 'length'].includes(x as string)) return 'float'
-                return 'float'
-        }
-        return 'float'
+export const formatConversions = (x: X, c?: NodeConfig) => {
+        if (!is.str(x)) return ''
+        if (c?.isWebGL) return x
+        return TYPE_MAPPING[x as keyof typeof TYPE_MAPPING]
+}
+
+export const getOperator = (op: X) => {
+        return OPERATORS[op as keyof typeof OPERATORS] || op
 }
 
-const generateUniforms = (c: NodeConfig): string => {
-        if (!c.uniforms || c.uniforms.size === 0) return ''
-        const uniformList = Array.from(c.uniforms)
-        return (
-                uniformList
-                        .map((name, i) => {
-                                if (c.isWebGL) return `uniform vec2 ${name};`
-                                else return `@group(0) @binding(${i}) var<uniform> ${name}: vec2f;`
-                        })
-                        .join('\n') + '\n'
-        )
+const generateHead = (c: NodeConfig) => {
+        return Array.from(c.headers!)
+                .map(([, v]) => v)
+                .join('\n')
+}
+
+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, uniforms: string, isWebGL = true) => {
+const generateFragmentMain = (body: string, head: string, isWebGL = true) => {
         if (isWebGL)
                 return `
-${uniforms}
 #version 300 es
 precision mediump float;
-uniform vec2 iResolution;
-uniform vec2 iMouse;
-uniform float iTime;
 out vec4 fragColor;
+${head}
 void main() {
-${body}
+fragColor = ${body};
 }`.trim()
         return `
-@group(0) @binding(0) var<uniform> iResolution: vec2f;
-@group(0) @binding(1) var<uniform> iMouse: vec2f;
-@group(0) @binding(2) var<uniform> iTime: f32;
-${uniforms}
+${head}
 @fragment
 fn main(@builtin(position) position: vec4f) -> @location(0) vec4f {
-${body}
+return ${body};
 }`.trim()
 }
 
-export const fragment = (x: X, c: NodeConfig) => {
+export const fragment = (x: X, c: NodeConfig = {}) => {
         const body = code(x, c)
-        const uniforms = generateUniforms(c)
-        return generateFragmentMain(body, uniforms, c.isWebGL)
+        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 uniforms = generateUniforms(c)
-        return generateFragmentMain(body, uniforms, c.isWebGL)
+        const head = generateHead(c)
+        return generateFragmentMain(body, head, c.isWebGL)
 }

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,21 +33,23 @@ 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)
-        if (!_vs || !_fs) return
+        if (!_vs || !_fs) return onError()
         c.attachShader(pg, _vs)
         c.attachShader(pg, _fs)
         c.linkProgram(pg)
         if (c.getProgramParameter(pg, c.LINK_STATUS)) return pg
         const error = c.getProgramInfoLog(pg)
         c.deleteProgram(pg)
+        onError()
         console.warn(`Could not link pg: ${error}`)
 }
 

package/src/webgl.ts

@@ -5,14 +5,13 @@ 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)!
-        const state = { context: c, program: pg } as WebGLState
+        const pg = createProgram(c, gl.vs, gl.fs, () => void (gl.isLoop = false))!
         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)
 

package/dist/index.mjs

@@ -1,61 +0,0 @@
-import{durable as M,event as Pe}from"reev";import{createFrame as Ge,createQueue as Se}from"refr";import{nested as I}from"reev";var d={arr:Array.isArray,bol:e=>typeof e=="boolean",str:e=>typeof e=="string",num:e=>typeof e=="number",int:e=>Number.isInteger(e),fun:e=>typeof e=="function",und:e=>typeof e>"u",nul:e=>e===null,set:e=>e instanceof Set,map:e=>e instanceof Map,obj:e=>!!e&&e.constructor.name==="Object",nan:e=>typeof e=="number"&&Number.isNaN(e)},be=(e,t)=>e.forEach(t),Ne=(e,...t)=>{be(e,r=>r(...t))},ze=(e="",t="_",r="/")=>e.split(t).join(r),Be=(e=".pdf")=>e.split(".").pop()?.toLowerCase()??"",$e=(e=0)=>`${e}`.split(".")[1]?.length??0,Ie=(e=0)=>`${e}`.split(".")[0]?.length-(e<0?1:0),Ce=(e=0,t=-2)=>(t*=-1,t=Math.pow(10,t),e*=t,e=Math.round(e),e/=t,e);var Oe=["x","y","z","w","r","g","b","a","s","t","p","q"],D=["float","int","uint","bool","color","vec2","vec3","vec4","mat2","mat3","mat4","ivec2","ivec3","ivec4","uvec2","uvec3","uvec4","bvec2","bvec3","bvec4"],N={add:"+",sub:"-",mul:"*",div:"/",mod:"%",equal:"==",notEqual:"!=",lessThan:"<",lessThanEqual:"<=",greaterThan:">",greaterThanEqual:">=",and:"&&",or:"||",bitAnd:"&",bitOr:"|",bitXor:"^",shiftLeft:"<<",shiftRight:">>"},W=Object.keys(N),q=["abs","acos","asin","atan","atan2","ceil","clamp","cos","cross","degrees","distance","dot","exp","exp2","faceforward","floor","fract","length","all","any","bitcast","cbrt","dFdx","dFdy","difference","equals","fwidth","inverseSqrt","lengthSq","log","log2","max","min","mix","negate","normalize","oneMinus","pow","pow2","pow3","pow4","radians","reciprocal","reflect","refract","round","saturate","sign","sin","smoothstep","sqrt","step","tan","transformDirection","trunc"],V={float:"f32",int:"i32",uint:"u32",bool:"bool",vec2:"vec2f",vec3:"vec3f",vec4:"vec4f",mat2:"mat2x2f",mat3:"mat3x3f",mat4:"mat4x4f",ivec2:"vec2i",ivec3:"vec3i",ivec4:"vec4i",uvec2:"vec2u",uvec3:"vec3u",uvec4:"vec4u",bvec2:"vec2<bool>",bvec3:"vec3<bool>",bvec4:"vec4<bool>"};var z=e=>d.str(e)&&/^[xyzwrgbastpq]{1,4}$/.test(e),Y=e=>W.includes(e),Ye=e=>D.includes(e),k=e=>q.includes(e),Xe=0,P=()=>`i${Xe++}`,B=(e,t)=>e.filter(r=>!d.und(r)&&!d.nul(r)).map(r=>f(r,t)).join(", "),_=(e,t)=>{if(!e||typeof e!="object")return"float";let{type:r,props:o}=e,{children:n=[]}=o,[i,a,c]=n;if(r==="node_type")return i;if(r==="operator"){let v=_(a,t),m=_(c,t);return v===m||v.includes("vec")?v:m.includes("vec")?m:"float"}return r==="math_fun"?["normalize","cross","reflect"].includes(i)?_(n[1],t):(["dot","distance","length"].includes(i),"float"):"float"},j=e=>!e.uniforms||e.uniforms.size===0?"":Array.from(e.uniforms).map((r,o)=>e.isWebGL?`uniform vec2 ${r};`:`@group(0) @binding(${o}) var<uniform> ${r}: vec2f;`).join(`
-`)+`
-`,K=(e,t,r=!0)=>r?`
-${t}
-#version 300 es
-precision mediump float;
-uniform vec2 iResolution;
-uniform vec2 iMouse;
-uniform float iTime;
-out vec4 fragColor;
-void main() {
-${e}
-}`.trim():`
-@group(0) @binding(0) var<uniform> iResolution: vec2f;
-@group(0) @binding(1) var<uniform> iMouse: vec2f;
-@group(0) @binding(2) var<uniform> iTime: f32;
-${t}
-@fragment
-fn main(@builtin(position) position: vec4f) -> @location(0) vec4f {
-${e}
-}`.trim(),G=(e,t)=>{let r=f(e,t),o=j(t);return K(r,o,t.isWebGL)},S=(e,t)=>{let r=f(e,t),o=j(t);return K(r,o,t.isWebGL)};var f=(e,t)=>{if(t||(t={}),t.uniforms||(t.uniforms=new Set),d.num(e))return e.toFixed(1);if(d.str(e))return e;if(!e)return"";let{type:r,props:o}=e,{id:n="",children:i=[]}=o,[a,c,v]=i;if(r==="uniform")return t.uniforms.add(n),t.onUniform?.(n,o.defaultValue),n;if(r==="variable")return n;if(r==="swizzle")return`${f(c,t)}.${f(a,t)}`;if(r==="node_type"){if(!d.str(a))return n;let m=!t.isWebGL&&a.startsWith("vec")?`${a}f`:a,X=B(i.slice(1),t);return`${m}(${X})`}if(r==="operator"){if(a==="not"||a==="bitNot")return`!${f(c,t)}`;let m=N[a];return`(${f(c,t)} ${m} ${f(v,t)})`}if(r==="math_fun")return`${a}(${B(i.slice(1),t)})`;if(r==="assign")return`${f(a,t)} = ${f(c,t)};`;if(r==="scope")return i.map(m=>f(m,t)).join(`
-`);if(r==="loop")return`for (int i = 0; i < ${a}; i++) {
-${f(c,t)}
-}`;if(r==="fn"){let m=f(a,t);return c&&(m+=`
-return ${f(c,t)};`),m}if(r==="if"){let m=`if (${f(a,t)}) {
-${f(c,t)}
-}`;for(let X=2;X<i.length;X+=2){let R=X>=i.length-1;m+=R?` else {
-${f(i[X],t)}
-}`:` else if (${f(i[X],t)}) {
-${f(i[X+1],t)}
-}`}return m}if(r==="declare"){let m=_(c,t),X=a?.props?.id;if(t.isWebGL)return`${m} ${X} = ${f(c,t)};`;let R=V[m];return`var ${X}: ${R} = ${f(c,t)};`}return f(a,t)};var w=null,L=(e,t=()=>{})=>{let r=w;w=e,t(),w=r},A=e=>{w&&(w.props.children||(w.props.children=[]),w.props.children.push(e))},et=(e,t)=>{let r=l("scope");L(r,t);let o=l("if",null,e,r);return A(o),{ElseIf:(n,i)=>{let a=l("scope");L(a,i),o.props.children.push(n,a)},Else:n=>{let i=l("scope");L(i,n),o.props.children.push(i)}}},tt=(e,t)=>{let r=l("scope");L(r,()=>t?.({i:l("variable",{id:"i"})}));let o=l("loop",null,e,r);return A(o),o},rt=e=>(...t)=>{let r,o=l("scope");return L(o,()=>r=e(t)),l("fn",null,o,r)},$=e=>t=>{t||(t=P());let r=l("variable",{id:t}),o=l("declare",null,r,e);return A(o),r},H=e=>t=>{let r=l("assign",null,e,t);return A(r),e};var ve=e=>t=>{if(t==="string")return f(e)},l=(e,t,...r)=>{t||(t={}),r.length&&(t.children=r);let o=new Proxy(()=>{},{get(n,i){return i==="type"?e:i==="props"?t:i==="toVar"?$(o):i==="assign"?H(o):i==="isProxy"?!0:i==="toString"?f.bind(null,o):i===Symbol.toPrimitive?ve(o):z(i)?Z(i,o):Y(i)?(...a)=>ye(i,o,...a):k(i)?(...a)=>s(i,o,...a):$(o)("")},set(n,i,a){return z(i)?(Z(i,o).assign(a),!0):!1}});return o},at=(...e)=>l("variable",{id:P()},...e),F=(e,t)=>l("uniform",{defaultValue:t},e),Z=(e,t)=>l("swizzle",null,e,t),g=(e,...t)=>l("node_type",null,e,...t),ye=(e,...t)=>l("operator",null,e,...t),s=(e,...t)=>l("math_fun",null,e,...t);var ft=F("iResolution",[1280,800]),pt=F("iMouse",[0,0]),mt=F("iTime",0),lt=l("variable",{id:"fragCoord"}),xt=e=>g("float",e),dt=e=>g("int",e),gt=e=>g("uint",e),bt=e=>g("bool",e),Xt=(e,t)=>g("vec2",e,t),vt=(e,t,r)=>g("vec3",e,t,r),yt=(e,t,r,o)=>g("vec4",e,t,r,o),ht=(...e)=>g("mat2",...e),Tt=(...e)=>g("mat3",...e),Et=(...e)=>g("mat4",...e),wt=(e,t)=>g("ivec2",e,t),Rt=(e,t,r)=>g("ivec3",e,t,r),_t=(e,t,r,o)=>g("ivec4",e,t,r,o),Lt=(e,t)=>g("uvec2",e,t),Pt=(e,t,r)=>g("uvec3",e,t,r),Gt=(e,t,r,o)=>g("uvec4",e,t,r,o),St=(e,t)=>g("bvec2",e,t),At=(e,t,r)=>g("bvec3",e,t,r),Ft=(e,t,r,o)=>g("bvec4",e,t,r,o),Ut=e=>s("abs",e),Nt=e=>s("acos",e),zt=e=>s("all",e),Bt=e=>s("any",e),$t=e=>s("asin",e),It=(e,t)=>s("atan",e,t),Ct=(e,t)=>s("bitcast",e,t),Mt=e=>s("cbrt",e),Ot=e=>s("ceil",e),Dt=(e,t,r)=>s("clamp",e,t,r),Wt=e=>s("cos",e),qt=(e,t)=>s("cross",e,t),Vt=e=>s("dFdx",e),Yt=e=>s("dFdy",e),kt=e=>s("degrees",e),jt=(e,t)=>s("difference",e,t),Kt=(e,t)=>s("distance",e,t),Ht=(e,t)=>s("dot",e,t),Zt=(e,t)=>s("equals",e,t),Qt=e=>s("exp",e),Jt=e=>s("exp2",e),er=(e,t,r)=>s("faceforward",e,t,r),tr=e=>s("floor",e),rr=e=>s("fract",e),or=e=>s("fwidth",e),nr=e=>s("inverseSqrt",e),sr=e=>s("length",e),ir=e=>s("lengthSq",e),ar=e=>s("log",e),ur=e=>s("log2",e),cr=(e,t)=>s("max",e,t),fr=(e,t)=>s("min",e,t),pr=(e,t,r)=>s("mix",e,t,r),mr=e=>s("negate",e),lr=e=>s("normalize",e),xr=e=>s("oneMinus",e),dr=(e,t)=>s("pow",e,t),gr=e=>s("pow2",e),br=e=>s("pow3",e),Xr=e=>s("pow4",e),vr=e=>s("radians",e),yr=e=>s("reciprocal",e),hr=(e,t)=>s("reflect",e,t),Tr=(e,t,r)=>s("refract",e,t,r),Er=e=>s("round",e),wr=e=>s("saturate",e),Rr=e=>s("sign",e),_r=e=>s("sin",e),Lr=(e,t,r)=>s("smoothstep",e,t,r),Pr=e=>s("sqrt",e),Gr=(e,t)=>s("step",e,t),Sr=e=>s("tan",e),Ar=(e,t)=>s("transformDirection",e,t),Fr=e=>s("trunc",e);var he=`
-#version 300 es
-void main() {
-  float x = float(gl_VertexID % 2) * 4.0 - 1.0;
-  float y = float(gl_VertexID / 2) * 4.0 - 1.0;
-  gl_Position = vec4(x, y, 0.0, 1.0);
-}
-`,Te=`
-#version 300 es
-precision mediump float;
-uniform vec2 iResolution;
-out vec4 fragColor;
-void main() {
-  fragColor = vec4(fract(gl_FragCoord.xy / iResolution), 0, 1);
-}
-`,Q=(e,t,r)=>{let o=e.createShader(r);if(!o)throw new Error("Failed to create shader");if(e.shaderSource(o,t.trim()),e.compileShader(o),e.getShaderParameter(o,e.COMPILE_STATUS))return o;let n=e.getShaderInfoLog(o);e.deleteShader(o),console.warn(`Could not compile shader: ${n}`)},J=(e,t=he,r=Te)=>{d.str(r)||(r=G(r,{isWebGL:!0})),d.str(t)||(t=S(r,{isWebGL:!0}));let o=e.createProgram(),n=Q(e,t,e.VERTEX_SHADER),i=Q(e,r,e.FRAGMENT_SHADER);if(!n||!i)return;if(e.attachShader(o,n),e.attachShader(o,i),e.linkProgram(o),e.getProgramParameter(o,e.LINK_STATUS))return o;let a=e.getProgramInfoLog(o);e.deleteProgram(o),console.warn(`Could not link pg: ${a}`)},ee=(e,t)=>{let r=e.createBuffer();return e.bindBuffer(e.ARRAY_BUFFER,r),e.bufferData(e.ARRAY_BUFFER,new Float32Array(t),e.STATIC_DRAW),e.bindBuffer(e.ARRAY_BUFFER,null),r},te=(e,t)=>{let r=e.createBuffer();return e.bindBuffer(e.ELEMENT_ARRAY_BUFFER,r),e.bufferData(e.ELEMENT_ARRAY_BUFFER,new Int16Array(t),e.STATIC_DRAW),e.bindBuffer(e.ELEMENT_ARRAY_BUFFER,null),r},re=(e,t,r)=>{r&&(e=Math.max(...r)+1);let o=t.length/e;return Math.floor(o)},oe=(e,t,r,o,n)=>{e.bindBuffer(e.ARRAY_BUFFER,o),e.enableVertexAttribArray(r),e.vertexAttribPointer(r,t,e.FLOAT,!1,0,0),n&&e.bindBuffer(e.ELEMENT_ARRAY_BUFFER,n)},ne=(e,t,r,o)=>{let n=e.createTexture();e.bindTexture(e.TEXTURE_2D,n),e.texImage2D(e.TEXTURE_2D,0,e.RGBA,e.RGBA,e.UNSIGNED_BYTE,t),e.generateMipmap(e.TEXTURE_2D),e.texParameteri(e.TEXTURE_2D,e.TEXTURE_MIN_FILTER,e.LINEAR),e.texParameteri(e.TEXTURE_2D,e.TEXTURE_MAG_FILTER,e.LINEAR),e.texParameteri(e.TEXTURE_2D,e.TEXTURE_WRAP_S,e.CLAMP_TO_EDGE),e.texParameteri(e.TEXTURE_2D,e.TEXTURE_WRAP_T,e.CLAMP_TO_EDGE),e.bindTexture(e.TEXTURE_2D,null),e.uniform1i(r,o),e.activeTexture(e.TEXTURE0+o),e.bindTexture(e.TEXTURE_2D,n)};var se=async e=>{let t=e.el.getContext("webgl2"),r=J(t,e.vs,e.fs),o={context:t,program:r};t.useProgram(r);let n=0,i=I(y=>t.getUniformLocation(r,y)),a=I(y=>t.getAttribLocation(r,y)),c=I(()=>n++);return{webgl:o,render:()=>{t.clear(t.COLOR_BUFFER_BIT),t.viewport(0,0,...e.size),t.drawArrays(t.TRIANGLES,0,3)},clean:()=>t.deleteProgram(r),_attribute:(y="",h,T)=>{let E=a(y,!0),b=ee(t,h),u=te(t,T),p=re(e.count,h,T);oe(t,p,E,b,u)},_uniform:(y,h)=>{let T=i(y);if(d.num(h))return t.uniform1f(T,h);let E=h.length;if(E<=4)return t[`uniform${E}fv`](T,h);E=Math.sqrt(E)<<0,t[`uniformMatrix${E}fv`](T,!1,h)},_texture:(y,h)=>{let T=new Image;Object.assign(T,{src:h,crossOrigin:"anonymous"}),T.decode().then(()=>{let E=i(y),b=c(y);ne(t,T,E,b)})}}};import{nested as C}from"reev";var Ee=`
-@vertex
-fn main(@builtin(vertex_index) vertex_index: u32) -> @builtin(position) vec4f {
-  let x = f32(vertex_index % 2u) * 4.0 - 1.0;
-  let y = f32(vertex_index / 2u) * 4.0 - 1.0;
-  return vec4f(x, y, 0.0, 1.0);
-}
-`,we=`
-@group(0) @binding(0) var<uniform> iResolution: vec2f;
-
-@fragment
-fn main(@builtin(position) position: vec4f) -> @location(0) vec4f {
-  return vec4f(position.xy / iResolution, 0.0, 1.0);
-}
-`,ie=async e=>{let t=navigator.gpu,r=t.getPreferredCanvasFormat(),n=await(await t.requestAdapter()).requestDevice();return e.configure({device:n,format:r,alphaMode:"opaque"}),{device:n,format:r}},ae=(e,t,r,o,n=Ee,i=we)=>{d.str(i)||(i=G(i,{isWebGL:!1})),d.str(n)||(n=S(n,{isWebGL:!1}));let a=e.createPipelineLayout({bindGroupLayouts:o});return e.createRenderPipeline({vertex:{module:e.createShaderModule({code:n.trim()}),entryPoint:"main",buffers:r},fragment:{module:e.createShaderModule({code:i.trim()}),entryPoint:"main",targets:[{format:t}]},layout:a,primitive:{topology:"triangle-list"}})},ue=(e,t)=>{let r=[],o=[];t.forEach((a,c)=>{if(!a)return;let v="buffer"in a,m=a instanceof GPUTextureView,X=a instanceof GPUSampler;if(v)r.push({binding:c,visibility:3,buffer:{type:"uniform"}});else if(m)r.push({binding:c,visibility:2,texture:{}});else if(X)r.push({binding:c,visibility:2,sampler:{}});else return;o.push({binding:c,resource:a})});let n=e.createBindGroupLayout({entries:r}),i=e.createBindGroup({layout:n,entries:o});return{layout:n,bindGroup:i}},ce=e=>({colorAttachments:[{view:e.getCurrentTexture().createView(),clearValue:{r:0,g:0,b:0,a:1},loadOp:"clear",storeOp:"store"}]}),Re=e=>Math.ceil(e/256)*256,fe=(e,t)=>{let r=new Float32Array(t),o=e.createBuffer({size:r.byteLength,usage:40});return{array:r,buffer:o}},pe=(e,t)=>{let r=new Float32Array(t),o=Re(r.byteLength),n=e.createBuffer({size:o,usage:72});return{array:r,buffer:n}},me=(e,t=1280,r=800)=>{let o=e.createTexture({size:[t,r],format:"rgba8unorm",usage:22}),n=e.createSampler({magFilter:"linear",minFilter:"linear"});return{texture:o,sampler:n}},_e=(e,t)=>e/t,Le=e=>e===2?"float32x2":e===3?"float32x3":e===4?"float32x4":"float32",le=(e,t,r=6)=>{let o=_e(t,r);return{arrayStride:o*4,attributes:[{shaderLocation:e,offset:0,format:Le(o)}]}};var xe=async e=>{let t=e.el.getContext("webgpu"),{device:r,format:o}=await ie(t),n={device:r,context:t,resources:[[],[]],loadingImg:0,needsUpdate:!0},i=[],a=[],c=[],v=C((b,u)=>{let{array:p,buffer:x}=fe(r,u);return a.push(x),c.push(le(c.length,p.length,e.count)),n.needsUpdate=!0,{array:p,buffer:x}}),m=C((b,u)=>{let{array:p,buffer:x}=pe(r,u);return n.resources[0].push({buffer:x}),n.needsUpdate=!0,{array:p,buffer:x}}),X=C((b,{width:u,height:p})=>{let{texture:x,sampler:U}=me(r,u,p);return n.resources[1].push(U,x.createView()),n.needsUpdate=!0,{texture:x,width:u,height:p}}),R=()=>{let b=[];i.length=0,n.resources.forEach(u=>{if(!u.length)return;let{layout:p,bindGroup:x}=ue(r,u);b.push(p),i.push(x)}),n.pipeline=ae(r,o,c,b,e.vs,e.fs)};return{webgpu:n,render:()=>{if(n.loadingImg)return;n.needsUpdate&&R(),n.needsUpdate=!1;let b=r.createCommandEncoder(),u=b.beginRenderPass(ce(t));u.setPipeline(n.pipeline),i.forEach((p,x)=>u.setBindGroup(x,p)),a.forEach((p,x)=>u.setVertexBuffer(x,p)),u.draw(e.count,1,0,0),u.end(),r.queue.submit([b.finish()])},clean:()=>{},_attribute:(b="",u)=>{let{array:p,buffer:x}=v(b,u);r.queue.writeBuffer(x,0,p)},_uniform:(b,u)=>{d.num(u)&&(u=[u]);let{array:p,buffer:x}=m(b,u);p.set(u),r.queue.writeBuffer(x,0,p)},_texture:(b,u)=>{n.loadingImg++;let p=Object.assign(new Image,{src:u,crossOrigin:"anonymous"});p.decode().then(()=>{let{texture:x,width:U,height:ge}=X(b,p);r.queue.copyExternalImageToTexture({source:p},{texture:x},{width:U,height:ge}),n.loadingImg--})}}};var ao=e=>d.obj(e)?"isGL"in e:!1,Ae=()=>typeof window>"u",Fe=()=>Ae()?!1:"gpu"in navigator,O=performance.now(),Ue=e=>{let t=Pe({isNative:!1,isWebGL:!0,isLoop:!0,isGL:!0,size:[0,0],mouse:[0,0],count:6,webgl:{},webgpu:{}});return t.queue=Se(),t.frame=Ge(),t.attribute=M((r,o,n)=>t.queue(()=>t._attribute?.(r,o,n))),t.texture=M((r,o)=>t.queue(()=>t._texture?.(r,o))),t.uniform=M((r,o,n)=>t.queue(()=>t._uniform?.(r,o,n))),t.uniform({iResolution:t.size,iMouse:[0,0],iTime:O}),t("mount",async()=>{t.vs=t.vs||t.vert||t.vertex,t.fs=t.fs||t.frag||t.fragment,Fe()||(t.isWebGL=!0),t.isWebGL?t(await se(t)):t(await xe(t)),t.resize(),t.frame(()=>(t.loop(),t.queue.flush(),t.render(),t.isLoop)),!t.isNative&&(window.addEventListener("resize",t.resize),t.el.addEventListener("mousemove",t.mousemove))}),t("clean",()=>{t.frame.stop(),t.frame.clean(t.render),!t.isNative&&(window.removeEventListener("resize",t.resize),t.el.removeEventListener("mousemove",t.mousemove))}),t("resize",()=>{let r=t.width||window.innerWidth,o=t.height||window.innerHeight;t.size[0]=t.el.width=r,t.size[1]=t.el.height=o,t.uniform("iResolution",t.size)}),t("mousemove",(r,o=r.clientX,n=r.clientY)=>{let[i,a]=t.size,{top:c,left:v}=t.el.getBoundingClientRect();t.mouse[0]=(o-c-i/2)/(i/2),t.mouse[1]=-(n-v-a/2)/(a/2),t.uniform("iMouse",t.mouse)}),t("loop",()=>{O=performance.now()/1e3,t.uniform("iTime",O)}),t(e)},uo=Ue;export{q as FUNCTIONS,rt as Fn,et as If,tt as Loop,D as NODE_TYPES,N as OPERATORS,W as OPERATOR_KEYS,Oe as SWIZZLES,V as TYPE_MAPPING,Ut as abs,Nt as acos,Re as alignTo256,zt as all,Bt as any,$t as asin,H as assign,It as atan,Ct as bitcast,bt as bool,St as bvec2,At as bvec3,Ft as bvec4,Mt as cbrt,Ot as ceil,Dt as clamp,f as code,Wt as cos,oe as createAttrib,ue as createBindGroup,le as createBufferLayout,ce as createDescriptor,ie as createDevice,Ue as createGL,te as createIbo,ae as createPipeline,J as createProgram,ne as createTexture,me as createTextureSampler,pe as createUniformBuffer,ee as createVbo,fe as createVertexBuffer,qt as cross,Vt as dFdx,Yt as dFdy,uo as default,Te as defaultFragmentGLSL,he as defaultVertexGLSL,kt as degrees,jt as difference,Ie as dig,Kt as distance,Ht as dot,be as each,Zt as equals,Qt as exp,Jt as exp2,Be as ext,s as f,er as faceforward,$e as fig,xt as float,tr as floor,Ne as flush,rr as fract,lt as fragCoord,G as fragment,or as fwidth,P as getId,re as getStride,pt as iMouse,ft as iResolution,mt as iTime,_ as inferType,dt as int,nr as inverseSqrt,d as is,k as isFunction,ao as isGL,Ye as isNodeType,Y as isOperator,Ae as isServer,z as isSwizzle,Fe as isWebGPUSupported,wt as ivec2,Rt as ivec3,_t as ivec4,B as joins,sr as length,ir as lengthSq,ar as log,ur as log2,ht as mat2,Tt as mat3,Et as mat4,cr as max,fr as min,pr as mix,g as n,mr as negate,l as node,lr as normalize,ye as o,xr as oneMinus,dr as pow,gr as pow2,br as pow3,Xr as pow4,vr as radians,yr as reciprocal,hr as reflect,Tr as refract,ze as replace,Er as round,Z as s,wr as saturate,Ce as sig,Rr as sign,_r as sin,Lr as smoothstep,Pr as sqrt,Gr as step,Sr as tan,$ as toVar,Ar as transformDirection,Fr as trunc,F as u,gt as uint,Lt as uvec2,Pt as uvec3,Gt as uvec4,at as v,Xt as vec2,vt as vec3,yt as vec4,S as vertex,se as webgl,xe as webgpu};
-//# sourceMappingURL=index.mjs.map