glre 0.38.0 → 0.40.0

package/src/addons/space/tbn.ts

@@ -0,0 +1,26 @@
+import { Fn, Vec3, Mat3, mat3, normalize, cross } from '../../node'
+
+export const tbn = Fn(([t, b, n]: [Vec3, Vec3, Vec3]): Mat3 => {
+        return mat3(t, b, n)
+}).setLayout({
+        name: 'tbn',
+        type: 'mat3',
+        inputs: [
+                { name: 't', type: 'vec3' },
+                { name: 'b', type: 'vec3' },
+                { name: 'n', type: 'vec3' },
+        ],
+})
+
+export const tbnFromNormal = Fn(([n, up]: [Vec3, Vec3]): Mat3 => {
+        const t = normalize(cross(up, n)).toVar('t')
+        const b = cross(n, t).toVar('b')
+        return tbn(t, b, n)
+}).setLayout({
+        name: 'tbnFromNormal',
+        type: 'mat3',
+        inputs: [
+                { name: 'n', type: 'vec3' },
+                { name: 'up', type: 'vec3' },
+        ],
+})

package/src/addons/space/translate.ts

@@ -0,0 +1,12 @@
+import { Fn, Mat3, Vec3, vec4, mat4 } from '../../node'
+
+export const translateMat3 = Fn(([m, translation]: [Mat3, Vec3]) => {
+        return mat4(vec4(m[0], 0), vec4(m[1], 0), vec4(m[2], 0), vec4(translation, 1))
+}).setLayout({
+        name: 'translateMat3',
+        type: 'mat4',
+        inputs: [
+                { name: 'm', type: 'mat3' },
+                { name: 'translation', type: 'vec3' },
+        ],
+})

package/src/addons/space/triTile.ts

@@ -0,0 +1,32 @@
+import { Fn, Vec2, Vec4, Float, mat2, vec2, vec4, floor, fract, dot } from '../../node'
+
+export const triTile = Fn(([st]: [Vec2]): Vec4 => {
+        const transformed = st.mul(mat2(vec2(1, -1 / 1.7320508), vec2(0, 2 / 1.7320508))).toVar()
+        const f = vec4(transformed, transformed.negate()).toVar()
+        const i = floor(f).toVar()
+        const fFractional = fract(f).toVar()
+
+        const dotXY = dot(fFractional.xy, fFractional.xy)
+        const dotZW = dot(fFractional.zw, fFractional.zw)
+
+        const condition = dotXY.lessThan(dotZW)
+        const trueValue = vec4(fFractional.xy, vec2(2, 1).mul(i.xy))
+        const falseValue = vec4(fFractional.zw, vec2(2, 1).mul(i.zw).add(1).negate())
+
+        return falseValue.select(trueValue, condition)
+}).setLayout({
+        name: 'triTile',
+        type: 'vec4',
+        inputs: [{ name: 'st', type: 'vec2' }],
+})
+
+export const triTileScaled = Fn(([st, scale]: [Vec2, Float]): Vec4 => {
+        return triTile(st.mul(scale))
+}).setLayout({
+        name: 'triTileScaled',
+        type: 'vec4',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 'scale', type: 'float' },
+        ],
+})

package/src/addons/space/uncenter.ts

@@ -0,0 +1,32 @@
+import { Fn, Float, Vec2, Vec3 } from '../../node'
+
+function uncenter(x: Float): Float
+function uncenter(v: Vec2): Vec2
+function uncenter(v: Vec3): Vec3
+function uncenter(v: any): any {
+        return v.mul(0.5).add(0.5)
+}
+
+export const uncenterFloat = Fn(([x]: [Float]): Float => {
+        return uncenter(x)
+}).setLayout({
+        name: 'uncenterFloat',
+        type: 'float',
+        inputs: [{ name: 'x', type: 'float' }],
+})
+
+export const uncenterVec2 = Fn(([v]: [Vec2]): Vec2 => {
+        return uncenter(v)
+}).setLayout({
+        name: 'uncenterVec2',
+        type: 'vec2',
+        inputs: [{ name: 'v', type: 'vec2' }],
+})
+
+export const uncenterVec3 = Fn(([v]: [Vec3]): Vec3 => {
+        return uncenter(v)
+}).setLayout({
+        name: 'uncenterVec3',
+        type: 'vec3',
+        inputs: [{ name: 'v', type: 'vec3' }],
+})

package/src/addons/space/unratio.ts

@@ -0,0 +1,12 @@
+import { Fn, Vec2, vec2 } from '../../node'
+
+export const unratio = Fn(([st, s]: [Vec2, Vec2]): Vec2 => {
+        return vec2(st.x, st.y.mul(s.x.div(s.y)).add(s.y.mul(0.5).sub(s.x.mul(0.5)).div(s.y)))
+}).setLayout({
+        name: 'unratio',
+        type: 'vec2',
+        inputs: [
+                { name: 'st', type: 'vec2' },
+                { name: 's', type: 'vec2' },
+        ],
+})

package/src/addons/space/viewZ2depth.ts

@@ -0,0 +1,25 @@
+import { Fn, Float } from '../../node'
+
+export const viewZ2depth = Fn(([viewZ, near, far]: [Float, Float, Float]): Float => {
+        return viewZ.add(near).mul(far).div(far.sub(near).mul(viewZ))
+}).setLayout({
+        name: 'viewZ2depth',
+        type: 'float',
+        inputs: [
+                { name: 'viewZ', type: 'float' },
+                { name: 'near', type: 'float' },
+                { name: 'far', type: 'float' },
+        ],
+})
+
+export const viewZ2depthOrthographic = Fn(([viewZ, near, far]: [Float, Float, Float]): Float => {
+        return viewZ.add(near).div(near.sub(far))
+}).setLayout({
+        name: 'viewZ2depthOrthographic',
+        type: 'float',
+        inputs: [
+                { name: 'viewZ', type: 'float' },
+                { name: 'near', type: 'float' },
+                { name: 'far', type: 'float' },
+        ],
+})

package/src/addons/space/windmillTile.ts

@@ -0,0 +1,58 @@
+import { Fn, Vec2, Vec4, Float, mod, abs, vec4 } from '../../node'
+import { rotate2DBasic } from './rotate'
+import { sqTile } from './sqTile'
+
+export const windmillTile = Fn(([t, turn]: [Vec4, Float]): Vec4 => {
+        const a = abs(mod(t.z, 2).sub(mod(t.w, 2)))
+                .add(mod(t.w, 2).mul(2))
+                .mul(0.25)
+        return vec4(rotate2DBasic(t.xy, a.mul(turn)), t.zw)
+}).setLayout({
+        name: 'windmillTile',
+        type: 'vec4',
+        inputs: [
+                { name: 't', type: 'vec4' },
+                { name: 'turn', type: 'float' },
+        ],
+})
+
+export const windmillTileDefault = Fn(([t]: [Vec4]): Vec4 => {
+        const a = abs(mod(t.z, 2).sub(mod(t.w, 2)))
+                .add(mod(t.w, 2).mul(2))
+                .mul(0.25)
+        return vec4(rotate2DBasic(t.xy, a.mul(6.283185307179586)), t.zw)
+}).setLayout({
+        name: 'windmillTileDefault',
+        type: 'vec4',
+        inputs: [{ name: 't', type: 'vec4' }],
+})
+
+export const windmillTileVec2 = Fn(([v]: [Vec2]): Vec4 => {
+        return windmillTileDefault(sqTile(v))
+}).setLayout({
+        name: 'windmillTileVec2',
+        type: 'vec4',
+        inputs: [{ name: 'v', type: 'vec2' }],
+})
+
+export const windmillTileFloat = Fn(([v, s]: [Vec2, Float]): Vec4 => {
+        return windmillTileVec2(v.mul(s))
+}).setLayout({
+        name: 'windmillTileFloat',
+        type: 'vec4',
+        inputs: [
+                { name: 'v', type: 'vec2' },
+                { name: 's', type: 'float' },
+        ],
+})
+
+export const windmillTileVec2Scale = Fn(([v, s]: [Vec2, Vec2]): Vec4 => {
+        return windmillTileVec2(v.mul(s))
+}).setLayout({
+        name: 'windmillTileVec2Scale',
+        type: 'vec4',
+        inputs: [
+                { name: 'v', type: 'vec2' },
+                { name: 's', type: 'vec2' },
+        ],
+})

package/src/addons/space/xyz2equirect.ts

@@ -0,0 +1,10 @@
+import { Fn, Vec3, Vec2, vec2, atan2, acos } from '../../node'
+import { PI, TWO_PI } from '../math/const'
+
+export const xyz2equirect = Fn(([d]: [Vec3]): Vec2 => {
+        return vec2(atan2(d.z, d.x).add(PI), acos(d.y.negate())).div(vec2(TWO_PI, PI))
+}).setLayout({
+        name: 'xyz2equirect',
+        type: 'vec2',
+        inputs: [{ name: 'd', type: 'vec3' }],
+})

package/src/index.ts

@@ -1,15 +1,11 @@
 import { durable, event } from 'reev'
 import { createFrame, createQueue } from 'refr'
-import { webgl } from './webgl'
-import { webgpu } from './webgpu'
 import { is } from './utils/helpers'
+import { webgl } from './utils/webgl'
+import { webgpu } from './utils/webgpu'
 import type { EventState } from 'reev'
 import type { GL } from './types'
-import { float, fract, int, iResolution, position, vec4, vertexIndex } from './node'
-export * from './node'
 export * from './types'
-export * from './webgl'
-export * from './webgpu'
 
 export const isGL = (a: unknown): a is EventState<GL> => {
         if (!is.obj(a)) return false
@@ -28,30 +24,20 @@ export const isWebGPUSupported = () => {
 
 let iTime = performance.now()
 
-const defaultFragment = () => vec4(fract(position.xy.div(iResolution)), 0, 1)
-const defaultVertex = () =>
-        vec4(
-                float(int(vertexIndex).mod(int(2)))
-                        .mul(4)
-                        .sub(1),
-                float(int(vertexIndex).div(int(2)))
-                        .mul(4)
-                        .sub(1),
-                0,
-                1
-        )
-
 export const createGL = (props?: Partial<GL>) => {
         const gl = event({
                 isNative: false,
                 isWebGL: true,
                 isError: false,
                 isLoop: true,
+                isDebug: false,
+                isDepth: false,
                 isGL: true,
                 size: [0, 0],
                 mouse: [0, 0],
                 count: 6,
-                particles: 1024,
+                instanceCount: 1,
+                particleCount: 1024,
                 webgl: {},
                 webgpu: {},
                 loading: 0,
@@ -67,16 +53,17 @@ export const createGL = (props?: Partial<GL>) => {
         gl.frame = createFrame()
 
         gl.attribute = durable((k, v, i) => gl.queue(() => gl._attribute?.(k, v, i)), gl)
+        gl.instance = durable((k, v, at) => gl.queue(() => gl._instance?.(k, v, at)), gl)
         gl.storage = durable((k, v) => gl.queue(() => gl._storage?.(k, v)), gl)
         gl.uniform = durable((k, v) => gl.queue(() => gl._uniform?.(k, v)), gl)
         gl.texture = durable((k, v) => gl.queue(() => gl._texture?.(k, v)), gl)
         gl.uniform({ iResolution: gl.size, iMouse: [0, 0], iTime })
 
         gl('mount', async () => {
-                gl.vs = gl.vs || gl.vert || gl.vertex || defaultVertex()
-                gl.fs = gl.fs || gl.frag || gl.fragment || defaultFragment()
-                gl.cs = gl.cs || gl.comp || gl.compute
                 if (!isWebGPUSupported()) gl.isWebGL = true
+                gl.vs = gl.vs || gl.vert || gl.vertex
+                gl.fs = gl.fs || gl.frag || gl.fragment
+                gl.cs = gl.cs || gl.comp || gl.compute
                 if (gl.isWebGL) {
                         gl((await webgl(gl)) as GL)
                 } else gl((await webgpu(gl)) as GL)

package/src/node/build.ts

@@ -0,0 +1,127 @@
+import { code } from './utils'
+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 build = (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')
+        let [lines, ret] = body.split('return ')
+        if (ret) ret = ret.replace(';', '')
+        else [lines, ret] = ['', body]
+        return [head, lines.trim(), ret]
+}
+
+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 = {}) => {
+        c.code?.headers?.clear()
+        c.label = 'frag' // for varying inputs or outputs
+        const [head, lines, ret] = build(x, c)
+        const result = []
+        if (c.isWebGL) {
+                result.push(GLSL_FRAGMENT_HEAD)
+                for (const code of c.code?.fragInputs?.values() || []) result.push(`in ${code}`)
+                result.push(head)
+                result.push('void main() {')
+                result.push(`  ${lines}`)
+                result.push(`  fragColor = ${ret};`)
+        } else {
+                if (c.code?.fragInputs?.size) result.push(generateStruct('Out', c.code.fragInputs))
+                result.push(head)
+                result.push(`@fragment\nfn main(out: Out) -> @location(0) vec4f {`)
+                result.push(`  ${lines}`)
+                result.push(`  return ${ret};`)
+        }
+        result.push('}')
+        const main = result.filter(Boolean).join('\n').trim()
+        if (c.gl?.isDebug) console.log(`↓↓↓generated↓↓↓\n${main}`)
+        return main
+}
+
+export const vertex = (x: X, c: NodeContext = {}) => {
+        c.code?.headers?.clear()
+        c.label = 'vert' // for varying inputs or outputs
+        const [head, lines, ret] = build(x, c)
+        const result = []
+        if (c.isWebGL) {
+                result.push('#version 300 es')
+                for (const code of c.code?.vertInputs?.values() || []) result.push(`in ${code}`)
+                for (const code of c.code?.vertOutputs?.values() || []) result.push(`out ${code}`)
+                result.push(head)
+                result.push('void main() {')
+                result.push(`  ${lines}`)
+                result.push(`  gl_Position = ${ret};`)
+                for (const [id, code] of c.code?.vertVaryings?.entries() || []) result.push(`  ${id} = ${code};`)
+        } else {
+                if (c.code?.vertInputs?.size) result.push(generateStruct('In', c.code.vertInputs))
+                if (c.code?.vertOutputs?.size) result.push(generateStruct('Out', c.code.vertOutputs))
+                result.push(head)
+                result.push('@vertex')
+                result.push(`fn main(${c.code?.vertInputs?.size ? 'in: In' : ''}) -> Out {`)
+                result.push('  var out: Out;')
+                result.push(`  ${lines}`)
+                result.push(`  out.position = ${ret};`)
+                for (const [id, code] of c.code?.vertVaryings?.entries() || []) result.push(`  out.${id} = ${code};`)
+                result.push('  return out;')
+        }
+        result.push('}')
+        const main = result.filter(Boolean).join('\n').trim()
+        if (c.gl?.isDebug) console.log(`↓↓↓generated↓↓↓\n${main}`)
+        return main
+}
+
+export const compute = (x: X, c: NodeContext = {}) => {
+        c.code?.headers?.clear()
+        c.label = 'compute'
+        const [head, lines, ret] = build(x, c)
+        const result = []
+        if (c.isWebGL) {
+                result.push('#version 300 es')
+                result.push('precision mediump float;')
+                result.push(head)
+                result.push('void main() {')
+                result.push(`  ${lines}`)
+                result.push(`  ${ret};`)
+                result.push('}')
+        } else {
+                if (c.code?.computeInputs?.size) result.push(generateStruct('In', c.code.computeInputs))
+                result.push(head)
+                result.push('@compute @workgroup_size(32)')
+                result.push(`fn main(${c.code?.computeInputs?.size ? 'in: In' : ''}) {`)
+                result.push(`  ${lines}`)
+                result.push(`  ${ret};`)
+                result.push('}')
+        }
+        const main = result.filter(Boolean).join('\n').trim()
+        if (c.gl?.isDebug) console.log(`↓↓↓generated↓↓↓\n${main}`)
+        return main
+}

package/src/node/create.ts

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