glre 0.36.0 → 0.38.0

package/package.json

@@ -1,6 +1,6 @@
 {
         "name": "glre",
-        "version": "0.36.0",
+        "version": "0.38.0",
         "author": "tseijp",
         "license": "MIT",
         "private": false,

package/src/index.ts

@@ -51,6 +51,7 @@ export const createGL = (props?: Partial<GL>) => {
                 size: [0, 0],
                 mouse: [0, 0],
                 count: 6,
+                particles: 1024,
                 webgl: {},
                 webgpu: {},
                 loading: 0,
@@ -58,6 +59,7 @@ export const createGL = (props?: Partial<GL>) => {
                         gl.isError = true
                         gl.isLoop = false
                         gl.clean()
+                        console.warn('GLRE Error:', ...arguments)
                 },
         }) as EventState<GL>
 

package/src/node/core.ts

@@ -43,7 +43,7 @@ const generateStruct = (id: string, map: Map<string, string>) => {
 export const fragment = (x: X, c: NodeContext) => {
         if (is.str(x)) return x.trim()
         c.code?.headers?.clear()
-        c.isFrag = true // for varying inputs or outputs
+        c.label = 'frag' // for varying inputs or outputs
         const [head, body] = generateHead(x, c)
         const ret = []
         if (c.isWebGL) {
@@ -66,7 +66,7 @@ export const fragment = (x: X, c: NodeContext) => {
 export const vertex = (x: X, c: NodeContext) => {
         if (is.str(x)) return x.trim()
         c.code?.headers?.clear()
-        c.isFrag = false // for varying inputs or outputs
+        c.label = 'vert' // for varying inputs or outputs
         const [head, body] = generateHead(x, c)
         const ret = []
         if (c.isWebGL) {
@@ -94,7 +94,28 @@ export const vertex = (x: X, c: NodeContext) => {
         return main
 }
 
-export const compute = (x: X, _c: NodeContext) => {
+export const compute = (x: X, c: NodeContext) => {
         if (is.str(x)) return x.trim()
-        return ''
+        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/index.ts

@@ -1,7 +1,7 @@
 import { hex2rgb } from './utils'
 import { builtin as b, conversion as c, function_ as f, uniform as u } from './node'
 import { is } from '../utils/helpers'
-import type { Constants as C, X, Vec2, Float, NodeProxy } from './types'
+import type { Constants as C, X, NodeProxy } from './types'
 export * from './core'
 export * from './node'
 export * from './scope'
@@ -16,6 +16,7 @@ export const fragDepth = b<'float'>('frag_depth')
 export const sampleIndex = b<'uint'>('sample_index')
 export const sampleMask = b<'uint'>('sample_mask')
 export const pointCoord = b<'vec2'>('point_coord')
+export const id = b<'vec3'>('global_invocation_id')
 
 // TSL Compatible Builtin Variables
 export const positionLocal = b<'vec3'>('position')
@@ -55,92 +56,88 @@ export const color = (r?: X, g?: X, b?: X) => {
 }
 
 // Default uniforms with proper typing
-export const iResolution: Vec2 = u(vec2(), 'iResolution')
-export const iMouse: Vec2 = u(vec2(), 'iMouse')
-export const iTime: Float = u(float(), 'iTime')
+export const iResolution = u(vec2(), 'iResolution')
+export const iMouse = u(vec2(), 'iMouse')
+export const iTime = u(float(), 'iTime')
 export const uv = position.xy.div(iResolution)
 
-// Texture Functions - always return vec4
-export const texture = (x: X, y: X, z?: X) => f<'vec4'>('texture', x, y, z)
-export const cubeTexture = (x: X, y: X, z?: X) => f<'vec4'>('cubeTexture', x, y, z)
-export const textureSize = (x: X, y?: X) => f<'vec4'>('textureSize', x, y)
+/**
+ * 1.1. unified with:
+ * 2.1. const.ts BUILTIN_VARIABLES and
+ * 3.1. types.ts BaseNodeProxy
+ */
+// 0. Always return bool
+export const all = <T extends C>(x: X<T>) => f<'bool'>('all', x)
+export const any = <T extends C>(x: X<T>) => f<'bool'>('any', x)
 
-// Functions that always return float regardless of input
+// 2. Always return float
 export const length = (x: X) => f<'float'>('length', x)
 export const lengthSq = (x: X) => f<'float'>('lengthSq', x)
 export const distance = (x: X, y: X) => f<'float'>('distance', x, y)
 export const dot = (x: X, y: X) => f<'float'>('dot', x, y)
 
-// Functions that always return bool
-export const all = <T extends C>(x: X<T>) => f<'bool'>('all', x)
-export const any = <T extends C>(x: X<T>) => f<'bool'>('any', x)
-
-// Functions that always return vec3 (cross product only works with vec3)
+// 3. Always return vec3
 export const cross = (x: X<'vec3'>, y: X<'vec3'>) => f<'vec3'>('cross', x, y)
 
-// Component-wise functions - preserve input type (T -> T)
+// 4. Always return vec4
+export const cubeTexture = (x: X, y: X, z?: X) => f<'vec4'>('cubeTexture', x, y, z)
+export const texture = (x: X, y: X, z?: X) => f<'vec4'>('texture', x, y, z)
+export const texelFetch = (x: X, y: X, z?: X) => f<'vec4'>('texelFetch', x, y, z)
+export const textureLod = (x: X, y: X, z?: X) => f<'vec4'>('textureLod', x, y, z)
+
+/**
+ * 1.2. unified with:
+ * 2.2. const.ts FUNCTIONS and
+ * 3.2. types.ts BaseNodeProxy
+ */
+// 0. Component-wise functions
 export const abs = <T extends C>(x: X<T>) => f<T>('abs', x)
-export const sign = <T extends C>(x: X<T>) => f<T>('sign', x)
-export const floor = <T extends C>(x: X<T>) => f<T>('floor', x)
-export const ceil = <T extends C>(x: X<T>) => f<T>('ceil', x)
-export const round = <T extends C>(x: X<T>) => f<T>('round', x)
-export const fract = <T extends C>(x: X<T>) => f<T>('fract', x)
-export const trunc = <T extends C>(x: X<T>) => f<T>('trunc', x)
-export const sin = <T extends C>(x: X<T>) => f<T>('sin', x)
-export const cos = <T extends C>(x: X<T>) => f<T>('cos', x)
-export const tan = <T extends C>(x: X<T>) => f<T>('tan', x)
-export const asin = <T extends C>(x: X<T>) => f<T>('asin', x)
 export const acos = <T extends C>(x: X<T>) => f<T>('acos', x)
-export const atan = <T extends C>(x: X<T>) => f<T>('atan', x)
-export const sinh = <T extends C>(x: X<T>) => f<T>('sinh', x)
-export const cosh = <T extends C>(x: X<T>) => f<T>('cosh', x)
-export const tanh = <T extends C>(x: X<T>) => f<T>('tanh', x)
-export const asinh = <T extends C>(x: X<T>) => f<T>('asinh', x)
 export const acosh = <T extends C>(x: X<T>) => f<T>('acosh', x)
+export const asin = <T extends C>(x: X<T>) => f<T>('asin', x)
+export const asinh = <T extends C>(x: X<T>) => f<T>('asinh', x)
+export const atan = <T extends C>(x: X<T>) => f<T>('atan', x)
 export const atanh = <T extends C>(x: X<T>) => f<T>('atanh', x)
+export const ceil = <T extends C>(x: X<T>) => f<T>('ceil', x)
+export const cos = <T extends C>(x: X<T>) => f<T>('cos', x)
+export const cosh = <T extends C>(x: X<T>) => f<T>('cosh', x)
+export const dFdx = <T extends C>(x: X<T>) => f<T>('dFdx', x)
+export const dFdy = <T extends C>(x: X<T>) => f<T>('dFdy', x)
+export const degrees = <T extends C>(x: X<T>) => f<T>('degrees', x)
 export const exp = <T extends C>(x: X<T>) => f<T>('exp', x)
 export const exp2 = <T extends C>(x: X<T>) => f<T>('exp2', x)
+export const floor = <T extends C>(x: X<T>) => f<T>('floor', x)
+export const fract = <T extends C>(x: X<T>) => f<T>('fract', x)
+export const fwidth = <T extends C>(x: X<T>) => f<T>('fwidth', x)
+export const inverseSqrt = <T extends C>(x: X<T>) => f<T>('inverseSqrt', x)
 export const log = <T extends C>(x: X<T>) => f<T>('log', x)
 export const log2 = <T extends C>(x: X<T>) => f<T>('log2', x)
-export const sqrt = <T extends C>(x: X<T>) => f<T>('sqrt', x)
-export const inverseSqrt = <T extends C>(x: X<T>) => f<T>('inverseSqrt', x)
+export const negate = <T extends C>(x: X<T>) => f<T>('negate', x)
 export const normalize = <T extends C>(x: X<T>) => f<T>('normalize', x)
 export const oneMinus = <T extends C>(x: X<T>) => f<T>('oneMinus', x)
-export const saturate = <T extends C>(x: X<T>) => f<T>('saturate', x)
-export const negate = <T extends C>(x: X<T>) => f<T>('negate', x)
-export const reciprocal = <T extends C>(x: X<T>) => f<T>('reciprocal', x)
-export const dFdx = <T extends C>(x: X<T>) => f<T>('dFdx', x)
-export const dFdy = <T extends C>(x: X<T>) => f<T>('dFdy', x)
-export const fwidth = <T extends C>(x: X<T>) => f<T>('fwidth', x)
-export const degrees = <T extends C>(x: X<T>) => f<T>('degrees', x)
 export const radians = <T extends C>(x: X<T>) => f<T>('radians', x)
+export const reciprocal = <T extends C>(x: X<T>) => f<T>('reciprocal', x)
+export const round = <T extends C>(x: X<T>) => f<T>('round', x)
+export const saturate = <T extends C>(x: X<T>) => f<T>('saturate', x)
+export const sign = <T extends C>(x: X<T>) => f<T>('sign', x)
+export const sin = <T extends C>(x: X<T>) => f<T>('sin', x)
+export const sinh = <T extends C>(x: X<T>) => f<T>('sinh', x)
+export const sqrt = <T extends C>(x: X<T>) => f<T>('sqrt', x)
+export const tan = <T extends C>(x: X<T>) => f<T>('tan', x)
+export const tanh = <T extends C>(x: X<T>) => f<T>('tanh', x)
+export const trunc = <T extends C>(x: X<T>) => f<T>('trunc', x)
 
-// Functions where first argument determines return type
-export const reflect = <T extends C>(I: X<T>, N: X) => f<T>('reflect', I, N)
-export const refract = <T extends C>(I: X<T>, N: X, eta: X) => f<T>('refract', I, N, eta)
-
-// Functions with highest priority type among arguments (using first arg for simplicity)
-export const min = <T extends C>(x: X<T>, y: X) => f<T>('min', x, y)
+// 1. Functions where first argument determines return type
+export const atan2 = <T extends C>(x: X<T>, y: X) => f<T>('atan2', x, y)
+export const clamp = <T extends C>(x: X<T>, y: X, z: X) => f<T>('clamp', x, y, z)
 export const max = <T extends C>(x: X<T>, y: X) => f<T>('max', x, y)
+export const min = <T extends C>(x: X<T>, y: X) => f<T>('min', x, y)
 export const mix = <T extends C>(x: X<T>, y: X, a: X) => f<T>('mix', x, y, a)
-export const clamp = <T extends C>(x: X<T>, minVal: X, maxVal: X) => f<T>('clamp', x, minVal, maxVal)
-export const step = <T extends C>(edge: X, x: X<T>) => f<T>('step', edge, x)
-export const smoothstep = <T extends C>(e0: X, e1: X, x: X<T>) => f<T>('smoothstep', e0, e1, x)
-
-// Two-argument functions with highest priority type
-export const atan2 = <T extends C>(x: X<T>, y: X) => f<T>('atan2', x, y)
 export const pow = <T extends C>(x: X<T>, y: X) => f<T>('pow', x, y)
+export const reflect = <T extends C>(I: X<T>, N: X) => f<T>('reflect', I, N)
+export const refract = <T extends C>(I: X<T>, N: X, eta: X) => f<T>('refract', I, N, eta)
 
-// Component-wise power functions
-export const pow2 = <T extends C>(x: X<T>) => f<T>('pow2', x)
-export const pow3 = <T extends C>(x: X<T>) => f<T>('pow3', x)
-export const pow4 = <T extends C>(x: X<T>) => f<T>('pow4', x)
-
-// Utility functions
-export const bitcast = <T extends C>(x: X<T>, y: X) => f<T>('bitcast', x, y)
-export const cbrt = <T extends C>(x: X<T>) => f<T>('cbrt', x)
-export const difference = <T extends C>(x: X<T>, y: X) => f<T>('difference', x, y)
-export const equals = (x: X, y: X) => f<'bool'>('equals', x, y)
-export const faceforward = <T extends C>(N: X<T>, I: X, Nref: X) => f<T>('faceforward', N, I, Nref)
-export const transformDirection = <T extends C>(dir: X<T>, matrix: X) => f<T>('transformDirection', dir, matrix)
-export const mod = <T extends C>(x: NodeProxy<T>, y: X<T>) => x.sub(x.div(y).floor().mul(y))
+// 2. Functions where not first argument determines return type
+export const smoothstep = <T extends C>(e0: X, e1: X, x: X<T>) => f<T>('smoothstep', e0, e1, x)
+export const step = <T extends C>(edge: X, x: X<T>) => f<T>('step', edge, x)
+export const mod = <T extends C>(x: NodeProxy<T>, y: X<T>) => x.sub(x.div(y).toFloat().floor().mul(y))

package/src/node/node.ts

@@ -4,7 +4,7 @@ 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)
+        if (hint === 'string') return code(x, null)
 }
 
 export const node = <T extends C>(type: NodeTypes, props?: NodeProps | null, ...args: X[]) => {
@@ -14,8 +14,8 @@ export const node = <T extends C>(type: NodeTypes, props?: NodeProps | null, ...
         const get = (_: unknown, y: string | Symbol) => {
                 if (y === 'type') return type
                 if (y === 'props') return props
-                if (y === 'toVar') return toVar.bind(null, x)
-                if (y === 'assign') return assign.bind(null, x)
+                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)
@@ -26,8 +26,9 @@ export const node = <T extends C>(type: NodeTypes, props?: NodeProps | null, ...
                 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) => element(x, z)
+                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)
@@ -43,9 +44,10 @@ export const node = <T extends C>(type: NodeTypes, props?: NodeProps | null, ...
 }
 
 // headers with proper type inference
-export const attribute = <T extends C>(x: X, id = getId()) => node<T>('attribute', { id }, x)
+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()) => {
@@ -55,6 +57,8 @@ export const vertexStage = <T extends C>(x: X<T>, id = getId()) => {
 // 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)

package/src/node/scope.ts

@@ -1,6 +1,17 @@
 import { getId } from './utils'
 import { conversion, node } from './node'
-import type { FnLayout, NodeProps, NodeProxy, X, Constants, Int } from './types'
+import type {
+        FnLayout,
+        FnType,
+        NodeProps,
+        NodeProxy,
+        X,
+        Constants,
+        Int,
+        StructFactory,
+        StructNode,
+        StructFields,
+} from './types'
 
 let scope: NodeProxy | null = null
 let define: NodeProxy | null = null
@@ -15,16 +26,17 @@ const addToScope = (x: NodeProxy) => {
         props.inferFrom.push(x)
 }
 
-export const toVar = <T extends Constants>(x: X<T>, id?: string): NodeProxy<T> => {
+export function toVar<T extends StructFields>(x: StructNode<T>, id?: string): StructNode<T>
+export function toVar<T extends Constants>(x: NodeProxy<T>, id?: string): NodeProxy<T> {
         if (!id) id = getId()
         const y = node<T>('variable', { id, inferFrom: [x] })
-        const z = node('declare', null, x, y)
+        const z = node<T>('declare', null, x as NodeProxy, y)
         addToScope(z)
         return y
 }
 
-export const assign = <T extends Constants>(x: X<T>, y: X<T>): X<T> => {
-        const z = node('assign', null, x, y)
+export const assign = <T extends Constants>(x: NodeProxy<T>, isScatter = false, y: X<T>): X<T> => {
+        const z = node(isScatter ? 'scatter' : 'assign', null, x, y)
         addToScope(z)
         return x
 }
@@ -35,12 +47,12 @@ export const Return = <T extends Constants>(x: X<T>): NodeProxy<T> => {
         return y
 }
 
-export const struct = <T extends Record<string, NodeProxy>>(fields: T, id = getId()) => {
-        return (initialValues: T = {} as T, instanceId = getId()) => {
+export const struct = <T extends StructFields>(fields: T, id = getId()): StructFactory<T> => {
+        return (initialValues: StructFields = {}, instanceId = getId()) => {
                 const x = node('variable', { id: instanceId, inferFrom: [id] })
                 const y = node('struct', { id, fields, initialValues }, x)
                 addToScope(y)
-                return x
+                return x as StructNode<T>
         }
 }
 
@@ -103,32 +115,33 @@ export const Switch = (x: NodeProxy) => {
         return ret()
 }
 
-export const Fn = <ReturnType extends Constants, Args extends Constants[]>(
-        fun: (paramVars: NodeProxy[]) => NodeProxy<ReturnType> | void,
+export function Fn<T extends NodeProxy | StructNode | void, Args extends any[]>(
+        fun: (args: Args) => T,
         defaultId = getId()
-) => {
+) {
         let layout: FnLayout
-        const ret = (...args: X<Args[number]>[]): NodeProxy<ReturnType> => {
+        const ret = (...args: any[]) => {
                 const id = layout?.name || defaultId
                 const x = node('scope')
                 const paramVars: NodeProxy[] = []
                 const paramDefs: NodeProps[] = []
-                if (layout?.inputs)
+                if (layout?.inputs) {
                         for (const input of layout.inputs) {
                                 paramDefs.push({ id: input.name, inferFrom: [conversion(input.type)] })
                         }
-                else
+                } else {
                         for (let i = 0; i < args.length; i++) {
                                 paramDefs.push({ id: `p${i}`, inferFrom: [args[i]] })
                         }
+                }
                 for (const props of paramDefs) paramVars.push(node('variable', props))
-                const y = node<ReturnType>('define', { id, layout }, x, ...args)
-                scoped(x, () => fun(paramVars), y)
+                const y = node('define', { id, layout }, x, ...args)
+                scoped(x, () => fun(paramVars as Args) as any, y)
                 return y
         }
         ret.setLayout = (_layout: FnLayout) => {
                 layout = _layout
                 return ret
         }
-        return ret
+        return ret as unknown as Args extends readonly unknown[] ? FnType<T, Args> : never
 }