glre 0.32.0 → 0.34.0

package/src/index.ts

@@ -5,7 +5,7 @@ import { webgpu } from './webgpu'
 import { is } from './utils/helpers'
 import type { EventState } from 'reev'
 import type { GL } from './types'
-import { float, fract, int, iResolution, position, uint, vec4, vertexIndex } from './node'
+import { float, fract, int, iResolution, position, vec4, vertexIndex } from './node'
 export * from './node'
 export * from './types'
 export * from './utils/helpers'

package/src/node/code.ts

@@ -1,61 +1,57 @@
 import { is } from '../utils/helpers'
 import { infer } from './infer'
-import { getBluiltin, getOperator, formatConversions, joins } from './utils'
-import type { NodeContext, X } from './types'
 import {
+        parseArray,
         parseAttribHead,
         parseConstantHead,
-        parseUniformHead,
         parseDeclare,
         parseDefine,
         parseIf,
+        parseStruct,
+        parseStructHead,
         parseSwitch,
         parseTexture,
         parseVaryingHead,
+        parseUniformHead,
 } from './parse'
+import { getBluiltin, getOperator, formatConversions, safeEventCall, getEventFun, initNodeContext } from './utils'
+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 = {}
-        if (!c.headers) c.headers = new Map()
-        if (!c.vertVaryings) c.vertVaryings = new Map()
-        if (!c.fragInputs) c.fragInputs = new Map()
-        if (!c.vertInputs) c.vertInputs = new Map()
-        if (!c.vertOutputs) {
-                c.vertOutputs = new Map()
-                if (!c.isWebGL) {
-                        c.fragInputs.set('position', '@builtin(position) position: vec4f')
-                        c.vertOutputs.set('position', '@builtin(position) position: vec4f')
-                }
-        }
+        initNodeContext(c)
+        if (is.arr(target)) return parseArray(target, c)
         if (is.str(target)) return target
         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 = [] } = props
+        const { id = '', children = [], fields, initialValues } = props
         const [x, y, z, w] = children
         /**
          * variables
          */
         if (type === 'variable') return id
-        if (type === 'swizzle') return `${code(y, c)}.${code(x, c)}`
+        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)})`
+                        ? `(${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)}(${joins(children.slice(1), 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 `(-${joins(children.slice(1), c)})`
+                if (x === 'negate') return `(-${parseArray(children.slice(1), c)})`
                 if (x === 'texture') return parseTexture(c, y, z, w)
-                return `${x}(${joins(children.slice(1), c)})`
+                return `${x}(${parseArray(children.slice(1), c)})`
         }
         /**
          * scopes
@@ -65,26 +61,28 @@ 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 i = 0; i < ${code(x, c)}; i += 1) {\n${code(y, c)}\n}`
+                        : `for (var i: i32 = 0; i < ${code(x, c)}; i++) {\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)
         if (type === 'define') {
-                const ret = `${id}(${joins(children.slice(1), c)})`
-                if (c.headers.has(id)) return ret
-                c.headers.set(id, parseDefine(c, props, infer(target, c)))
-                return ret
+                if (!c.code?.headers.has(id)) c.code?.headers.set(id, parseDefine(c, props, infer(target, c)))
+                return `${id}(${parseArray(children.slice(1), c)})`
+        }
+        if (type === 'struct') {
+                if (!c.code?.headers.has(id)) c.code?.headers.set(id, parseStructHead(c, id, fields))
+                return parseStruct(c, id, x.props.id, fields, initialValues)
         }
         /**
          * headers
          */
         if (type === 'varying') {
-                if (c.vertOutputs.has(id)) return c.isWebGL ? `${id}` : `out.${id}`
+                if (c.code?.vertOutputs.has(id)) return c.isWebGL ? `${id}` : `out.${id}`
                 const field = parseVaryingHead(c, id, infer(target, c))
-                c.fragInputs.set(id, field)
-                c.vertOutputs.set(id, field)
-                c.vertVaryings.set(id, code(x, c))
+                c.code?.fragInputs.set(id, field)
+                c.code?.vertOutputs.set(id, field)
+                c.code?.vertVaryings.set(id, code(x, c))
                 return c.isWebGL ? `${id}` : `out.${id}`
         }
         if (type === 'builtin') {
@@ -92,20 +90,29 @@ export const code = (target: X, c?: NodeContext | null): string => {
                 if (id === 'position') return 'out.position'
                 const field = `@builtin(${id}) ${id}: ${formatConversions(infer(target, c), c)}`
                 if (c.isFrag) {
-                        c.fragInputs.set(id, field)
-                } else c.vertInputs.set(id, field)
+                        c.code?.fragInputs.set(id, field)
+                } else c.code?.vertInputs.set(id, field)
                 return `in.${id}`
         }
         if (type === 'attribute') {
-                c.vertInputs.set(id, parseAttribHead(c, id, infer(target, c)))
+                const fun = getEventFun(c, id, true)
+                safeEventCall(x, fun)
+                target.listeners.add(fun)
+                c.code?.vertInputs.set(id, parseAttribHead(c, id, infer(target, c)))
                 return c.isWebGL ? `${id}` : `in.${id}`
         }
-        if (c.headers.has(id)) return id // must last
+        if (c.code?.headers.has(id)) return id // must last
         let head = ''
-        if (type === 'uniform') head = parseUniformHead(c, id, infer(target, c))
+        if (type === 'uniform') {
+                const varType = infer(target, c)
+                const fun = getEventFun(c, id, false, varType === 'texture')
+                safeEventCall(x, fun)
+                target.listeners.add(fun)
+                head = parseUniformHead(c, id, varType)
+        }
         if (type === 'constant') head = parseConstantHead(c, id, infer(target, c), code(x, c))
         if (head) {
-                c.headers.set(id, head)
+                c.code?.headers.set(id, head)
                 return id
         }
         return code(x, c)

package/src/node/const.ts

@@ -1,29 +1,32 @@
 export const SWIZZLES = ['x', 'y', 'z', 'w', 'r', 'g', 'b', 'a', 's', 't', 'p', 'q'] as const
 
-export const CONSTANTS = [
-        'bool',
-        'uint',
-        'int',
-        'float',
-        'bvec2',
-        'ivec2',
-        'uvec2',
-        'vec2',
-        'bvec3',
-        'ivec3',
-        'uvec3',
-        'vec3',
-        'bvec4',
-        'ivec4',
-        'uvec4',
-        'vec4',
-        'color',
-        'mat2',
-        'mat3',
-        'mat4',
-        'texture',
-        'sampler2D',
-] as const
+export const TYPE_MAPPING = {
+        bool: 'bool',
+        uint: 'u32',
+        int: 'i32',
+        float: 'f32',
+        bvec2: 'vec2<bool>',
+        ivec2: 'vec2i',
+        uvec2: 'vec2u',
+        vec2: 'vec2f',
+        bvec3: 'vec3<bool>',
+        ivec3: 'vec3i',
+        uvec3: 'vec3u',
+        vec3: 'vec3f',
+        bvec4: 'vec4<bool>',
+        ivec4: 'vec4i',
+        uvec4: 'vec4u',
+        vec4: 'vec4f',
+        color: 'color',
+        mat2: 'mat2x2f',
+        mat3: 'mat3x3f',
+        mat4: 'mat4x4f',
+        texture: 'texture_2d<f32>',
+        sampler2D: 'sampler',
+        struct: 'struct',
+} as const
+
+export const CONSTANTS = Object.keys(TYPE_MAPPING) as unknown as keyof typeof TYPE_MAPPING
 
 export const CONVERSIONS = [
         'toBool',
@@ -71,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',
@@ -89,6 +100,12 @@ export const PRESERVE_TYPE_FUNCTIONS = [
         'asin',
         'acos',
         'atan',
+        'sinh',
+        'cosh',
+        'tanh',
+        'asinh',
+        'acosh',
+        'atanh',
         'exp',
         'exp2',
         'log',
@@ -103,65 +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 TYPE_MAPPING = {
-        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>',
-} as const
-
 export const COMPONENT_COUNT_TO_TYPE = {
         1: 'float',
         2: 'vec2',
@@ -171,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',