glre 0.33.0 → 0.35.0

package/package.json

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

package/src/index.ts

@@ -45,9 +45,10 @@ const defaultVertex = () =>
         )
 
 export const createGL = (props?: Partial<GL>) => {
-        const gl = event<Partial<GL>>({
+        const gl = event({
                 isNative: false,
                 isWebGL: true,
+                isError: false,
                 isLoop: true,
                 isGL: true,
                 size: [0, 0],
@@ -55,6 +56,12 @@ export const createGL = (props?: Partial<GL>) => {
                 count: 6,
                 webgl: {},
                 webgpu: {},
+                loading: 0,
+                error() {
+                        gl.isError = true
+                        gl.isLoop = false
+                        gl.clean()
+                },
         }) as EventState<GL>
 
         gl.queue = createQueue()
@@ -72,10 +79,12 @@ export const createGL = (props?: Partial<GL>) => {
                 if (gl.isWebGL) {
                         gl((await webgl(gl)) as GL)
                 } else gl((await webgpu(gl)) as GL)
+                if (gl.isError) return // stop if error
                 gl.resize()
                 gl.frame(() => {
                         gl.loop()
                         gl.queue.flush()
+                        if (gl.loading) return true // wait for textures @TODO FIX
                         gl.render()
                         return gl.isLoop
                 })
@@ -86,7 +95,6 @@ export const createGL = (props?: Partial<GL>) => {
 
         gl('clean', () => {
                 gl.frame.stop()
-                gl.frame.clean(gl.render)
                 if (gl.isNative) return
                 window.removeEventListener('resize', gl.resize)
                 gl.el.removeEventListener('mousemove', gl.mousemove)

package/src/node/code.ts

@@ -15,9 +15,9 @@ import {
         parseUniformHead,
 } from './parse'
 import { getBluiltin, getOperator, formatConversions, safeEventCall, getEventFun, initNodeContext } from './utils'
-import type { NodeContext, NodeProxy, X } from './types'
+import type { Constants, NodeContext, X } from './types'
 
-export const code = (target: X, c?: NodeContext | null): string => {
+export const code = <T extends Constants>(target: X<T>, c?: NodeContext | null): string => {
         if (!c) c = {}
         initNodeContext(c)
         if (is.arr(target)) return parseArray(target, c)
@@ -25,12 +25,14 @@ export const code = (target: X, c?: NodeContext | null): string => {
         if (is.num(target)) {
                 const ret = `${target}`
                 if (ret.includes('.')) return ret
+                // Check if this number should be an integer based on the inferred type
+                // For now, keep the original behavior to maintain compatibility
                 return ret + '.0'
         }
         if (is.bol(target)) return target ? 'true' : 'false'
         if (!target) return ''
         const { type, props } = target
-        const { id = '', children = [], fields, initialValues } = props
+        const { id = 'i', children = [], fields, initialValues } = props
         const [x, y, z, w] = children
         /**
          * variables
@@ -39,16 +41,18 @@ export const code = (target: X, c?: NodeContext | null): string => {
         if (type === 'member') return `${code(y, c)}.${code(x, c)}`
         if (type === 'ternary')
                 return c.isWebGL
-                        ? `(${code(x, c)} ? ${code(y, c)} : ${code(z, c)})`
-                        : `select(${code(z, c)}, ${code(y, c)}, ${code(x, c)})`
+                        ? `(${code(z, c)} ? ${code(x, c)} : ${code(y, c)})`
+                        : `select(${code(x, c)}, ${code(y, c)}, ${code(z, c)})`
         if (type === 'conversion') return `${formatConversions(x, c)}(${parseArray(children.slice(1), c)})`
         if (type === 'operator') {
                 if (x === 'not' || x === 'bitNot') return `!${code(y, c)}`
                 return `(${code(y, c)} ${getOperator(x)} ${code(z, c)})`
         }
         if (type === 'function') {
-                if (x === 'negate') return `(-${parseArray(children.slice(1), c)})`
+                if (x === 'negate') return `(-${code(y, c)})`
+                if (x === 'oneMinus') return `(1.0-${code(y, c)})`
                 if (x === 'texture') return parseTexture(c, y, z, w)
+                if (x === 'atan2' && c.isWebGL) return `atan(${code(y, c)}, ${code(z, c)})`
                 return `${x}(${parseArray(children.slice(1), c)})`
         }
         /**
@@ -59,8 +63,8 @@ export const code = (target: X, c?: NodeContext | null): string => {
         if (type === 'return') return `return ${code(x, c)};`
         if (type === 'loop')
                 return c.isWebGL
-                        ? `for (int i = 0; i < ${x}; i += 1) {\n${code(y, c)}\n}`
-                        : `for (var i: i32 = 0; i < ${x}; i++) {\n${code(y, c)}\n}`
+                        ? `for (int ${id} = 0; ${id} < ${code(x, c)}; ${id} += 1) {\n${code(y, c)}\n}`
+                        : `for (var ${id}: i32 = 0; ${id} < ${code(x, c)}; ${id}++) {\n${code(y, c)}\n}`
         if (type === 'if') return parseIf(c, x, y, children)
         if (type === 'switch') return parseSwitch(c, x, children)
         if (type === 'declare') return parseDeclare(c, x, y)
@@ -70,7 +74,7 @@ export const code = (target: X, c?: NodeContext | null): string => {
         }
         if (type === 'struct') {
                 if (!c.code?.headers.has(id)) c.code?.headers.set(id, parseStructHead(c, id, fields))
-                return parseStruct(c, id, (x as NodeProxy).props.id, fields, initialValues)
+                return parseStruct(c, id, x.props.id, fields, initialValues)
         }
         /**
          * headers

package/src/node/const.ts

@@ -74,11 +74,19 @@ export const OPERATORS = {
 
 export const OPERATOR_KEYS = Object.keys(OPERATORS) as (keyof typeof OPERATORS)[]
 
-export const SCALAR_RETURN_FUNCTIONS = ['dot', 'distance', 'length', 'lengthSq', 'determinant', 'luminance'] as const
-
-export const BOOL_RETURN_FUNCTIONS = ['all', 'any'] as const
-
-export const PRESERVE_TYPE_FUNCTIONS = [
+// All shader functions (type inference now handled by inferFrom)
+export const FUNCTIONS = [
+        // Float return functions
+        'dot',
+        'distance',
+        'length',
+        'lengthSq',
+        'determinant',
+        'luminance',
+        // Bool return functions
+        'all',
+        'any',
+        // Component-wise functions (preserve input type)
         'abs',
         'sign',
         'floor',
@@ -92,6 +100,12 @@ export const PRESERVE_TYPE_FUNCTIONS = [
         'asin',
         'acos',
         'atan',
+        'sinh',
+        'cosh',
+        'tanh',
+        'asinh',
+        'acosh',
+        'atanh',
         'exp',
         'exp2',
         'log',
@@ -106,43 +120,38 @@ export const PRESERVE_TYPE_FUNCTIONS = [
         'dFdx',
         'dFdy',
         'fwidth',
-] as const
-
-export const VEC3_RETURN_FUNCTIONS = ['cross'] as const
-
-export const FIRST_ARG_TYPE_FUNCTIONS = ['reflect', 'refract'] as const
-
-export const HIGHEST_TYPE_FUNCTIONS = ['min', 'max', 'mix', 'clamp', 'step', 'smoothstep'] as const
-
-export const VEC4_RETURN_FUNCTIONS = ['texture', 'textureLod', 'textureSize', 'cubeTexture'] as const
-
-export const ADDITIONAL_FUNCTIONS = [
-        'atan2',
         'degrees',
+        'radians',
+        // Vector functions
+        'cross',
+        'reflect',
+        'refract',
+        // Multi-argument functions
+        'min',
+        'max',
+        'mix',
+        'clamp',
+        'step',
+        'smoothstep',
+        'pow',
+        'atan2',
+        // Texture functions
+        'texture',
+        'textureLod',
+        'textureSize',
+        'cubeTexture',
+        // Utility functions
         'faceforward',
         'bitcast',
         'cbrt',
         'difference',
         'equals',
-        'pow',
         'pow2',
         'pow3',
         'pow4',
-        'radians',
         'transformDirection',
 ] as const
 
-export const FUNCTIONS = [
-        ...SCALAR_RETURN_FUNCTIONS,
-        ...BOOL_RETURN_FUNCTIONS,
-        ...PRESERVE_TYPE_FUNCTIONS,
-        ...VEC3_RETURN_FUNCTIONS,
-        ...FIRST_ARG_TYPE_FUNCTIONS,
-        ...HIGHEST_TYPE_FUNCTIONS,
-        ...VEC4_RETURN_FUNCTIONS,
-        ...ADDITIONAL_FUNCTIONS,
-] as const
-
 export const COMPONENT_COUNT_TO_TYPE = {
         1: 'float',
         2: 'vec2',
@@ -152,6 +161,24 @@ export const COMPONENT_COUNT_TO_TYPE = {
         16: 'mat4',
 } as const
 
+// Function return type mapping for method chaining
+export const FUNCTION_RETURN_TYPES = {
+        // Always return vec4
+        texture: 'vec4',
+        cubeTexture: 'vec4',
+        textureSize: 'vec4',
+        // Always return float
+        length: 'float',
+        lengthSq: 'float',
+        distance: 'float',
+        dot: 'float',
+        // Always return bool
+        all: 'bool',
+        any: 'bool',
+        // Always return vec3
+        cross: 'vec3',
+} as const
+
 export const BUILTIN_TYPES = {
         // WGSL builtin variables
         position: 'vec4',

package/src/node/index.ts

@@ -2,7 +2,7 @@ import { is } from '../utils/helpers'
 import { code } from './code'
 import { builtin, conversion as c, function_ as f, uniform as u } from './node'
 import { hex2rgb, sortHeadersByDependencies } from './utils'
-import type { NodeContext, X } from './types'
+import type { Constants as C, NodeContext, X, Vec2, Float, NodeProxy } from './types'
 export * from './code'
 export * from './node'
 export * from './scope'
@@ -56,7 +56,7 @@ export const vertex = (x: X, c: NodeContext) => {
         }
         ret.push('}')
         const main = ret.filter(Boolean).join('\n').trim()
-        console.log(`↓↓↓generated↓↓↓\n${main}`)
+        // console.log(`↓↓↓generated↓↓↓\n${main}`)
         return main
 }
 
@@ -79,31 +79,31 @@ export const fragment = (x: X, c: NodeContext) => {
         }
         ret.push('}')
         const main = ret.filter(Boolean).join('\n').trim()
-        console.log(`↓↓↓generated↓↓↓\n${main}`)
+        // console.log(`↓↓↓generated↓↓↓\n${main}`)
         return main
 }
 
 // Builtin Variables
-export const position = builtin('position')
-export const vertexIndex = builtin('vertex_index')
-export const instanceIndex = builtin('instance_index')
-export const frontFacing = builtin('front_facing')
-export const fragDepth = builtin('frag_depth')
-export const sampleIndex = builtin('sample_index')
-export const sampleMask = builtin('sample_mask')
-export const pointCoord = builtin('point_coord')
+export const position = builtin<'vec4'>('position')
+export const vertexIndex = builtin<'uint'>('vertex_index')
+export const instanceIndex = builtin<'uint'>('instance_index')
+export const frontFacing = builtin<'bool'>('front_facing')
+export const fragDepth = builtin<'float'>('frag_depth')
+export const sampleIndex = builtin<'uint'>('sample_index')
+export const sampleMask = builtin<'uint'>('sample_mask')
+export const pointCoord = builtin<'vec2'>('point_coord')
 
 // TSL Compatible Builtin Variables
-export const normalLocal = builtin('normalLocal')
-export const normalWorld = builtin('normalWorld')
-export const normalView = builtin('normalView')
-export const positionLocal = builtin('position')
-export const positionWorld = builtin('positionWorld')
-export const positionView = builtin('positionView')
-export const screenCoordinate = builtin('screenCoordinate')
-export const screenUV = builtin('screenUV')
-
-// Type constructors
+export const positionLocal = builtin<'vec3'>('position')
+export const positionWorld = builtin<'vec3'>('positionWorld')
+export const positionView = builtin<'vec3'>('positionView')
+export const normalLocal = builtin<'vec3'>('normalLocal')
+export const normalWorld = builtin<'vec3'>('normalWorld')
+export const normalView = builtin<'vec3'>('normalView')
+export const screenCoordinate = builtin<'vec2'>('screenCoordinate')
+export const screenUV = builtin<'vec2'>('screenUV')
+
+// Type constructors with proper type inference
 export const float = (x?: X) => c('float', x)
 export const int = (x?: X) => c('int', x)
 export const uint = (x?: X) => c('uint', x)
@@ -130,80 +130,93 @@ export const color = (r?: X, g?: X, b?: X) => {
         return vec3(r, g, b)
 }
 
-// Default uniforms
-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
-export const texture = (x: X, y: X, z?: X) => f('texture', x, y, z)
-export const cubeTexture = (x: X, y: X, z?: X) => f('cubeTexture', x, y, z)
-export const textureSize = (x: X, y?: X) => f('textureSize', x, y)
-
-// Math Functions
-export const abs = (x: X) => f('abs', x)
-export const acos = (x: X) => f('acos', x)
-export const all = (x: X) => f('all', x)
-export const any = (x: X) => f('any', x)
-export const asin = (x: X) => f('asin', x)
-export const atan = (y: X, x?: X) => (x !== undefined ? f('atan', y, x) : f('atan', y))
-export const atan2 = (y: X, x: X) => f('atan', y, x)
-export const bitcast = (x: X, y: X) => f('bitcast', x, y)
-export const cbrt = (x: X) => f('cbrt', x)
-export const ceil = (x: X) => f('ceil', x)
-export const clamp = (x: X, min: X, max: X) => f('clamp', x, min, max)
-export const cos = (x: X) => f('cos', x)
-export const cross = (x: X, y: X) => f('cross', x, y)
-export const dFdx = (p: X) => f('dFdx', p)
-export const dFdy = (p: X) => f('dFdy', p)
-export const degrees = (radians: X) => f('degrees', radians)
-export const difference = (x: X, y: X) => f('difference', x, y)
-export const distance = (x: X, y: X) => f('distance', x, y)
-export const dot = (x: X, y: X) => f('dot', x, y)
-export const equals = (x: X, y: X) => f('equals', x, y)
-export const exp = (x: X) => f('exp', x)
-export const exp2 = (x: X) => f('exp2', x)
-export const faceforward = (N: X, I: X, Nref: X) => f('faceforward', N, I, Nref)
-export const floor = (x: X) => f('floor', x)
-export const fract = (x: X) => f('fract', x)
-export const fwidth = (x: X) => f('fwidth', x)
-export const inverseSqrt = (x: X) => f('inverseSqrt', x)
-export const length = (x: X) => f('length', x)
-export const lengthSq = (x: X) => f('lengthSq', x)
-export const log = (x: X) => f('log', x)
-export const log2 = (x: X) => f('log2', x)
-export const max = (x: X, y: X) => f('max', x, y)
-export const min = (x: X, y: X) => f('min', x, y)
-export const mix = (x: X, y: X, a: X) => f('mix', x, y, a)
-export const negate = (x: X) => f('negate', x)
-export const normalize = (x: X) => f('normalize', x)
-export const oneMinus = (x: X) => f('oneMinus', x)
-export const pow = (x: X, y: X) => f('pow', x, y)
-export const pow2 = (x: X) => f('pow2', x)
-export const pow3 = (x: X) => f('pow3', x)
-export const pow4 = (x: X) => f('pow4', x)
-export const radians = (degrees: X) => f('radians', degrees)
-export const reciprocal = (x: X) => f('reciprocal', x)
-export const reflect = (I: X, N: X) => f('reflect', I, N)
-export const refract = (I: X, N: X, eta: X) => f('refract', I, N, eta)
-export const round = (x: X) => f('round', x)
-export const saturate = (x: X) => f('saturate', x)
-export const sign = (x: X) => f('sign', x)
-export const sin = (x: X) => f('sin', x)
-export const smoothstep = (e0: X, e1: X, x: X) => f('smoothstep', e0, e1, x)
-export const sqrt = (x: X) => f('sqrt', x)
-export const step = (edge: X, x: X) => f('step', edge, x)
-export const tan = (x: X) => f('tan', x)
-export const transformDirection = (dir: X, matrix: X) => f('transformDirection', dir, matrix)
-export const trunc = (x: X) => f('trunc', x)
-
-// // Struct functions
-// export const struct = (fields: Record<string, X>) => {
-//         const id = getId()
-//         const structNode = node('struct', { id, fields })
-//         // Create constructor function
-//         const constructor = () => node('struct', { id: getId(), type: id })
-//         Object.assign(constructor, structNode)
-//         return constructor as any
-// }
+// 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 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)
+
+// Functions that always return float regardless of input
+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)
+export const cross = (x: X<'vec3'>, y: X<'vec3'>) => f<'vec3'>('cross', x, y)
+
+// Component-wise functions - preserve input type (T -> T)
+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 atanh = <T extends C>(x: X<T>) => f<T>('atanh', 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 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 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)
+
+// 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)
+export const max = <T extends C>(x: X<T>, y: X) => f<T>('max', 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>(y: X<T>, x: X) => f<T>('atan2', y, x)
+export const pow = <T extends C>(x: X<T>, y: X) => f<T>('pow', x, y)
+
+// 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))