glre 0.46.0 → 0.47.0

package/package.json

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

package/src/node/utils/index.ts

@@ -114,7 +114,10 @@ export const code = <T extends C>(target: Y<T>, c?: NodeContext | null): string
                 setupEvent(c, id, varType, target, x)
                 head = parseUniformHead(c, id, varType)
         }
-        if (type === 'storage') head = parseStorageHead(c, id, infer(target, c))
+        if (type === 'storage') {
+                setupEvent(c, id, type, target, x)
+                head = parseStorageHead(c, id, infer(target, c))
+        }
         if (type === 'constant') head = parseConstantHead(c, id, infer(target, c), code(x, c))
         if (head) {
                 c.code?.headers.set(id, head)

package/src/node/utils/infer.ts

@@ -1,6 +1,6 @@
 import { isConstants, isElement, isX, isSwizzle } from './utils'
 import { BUILTIN_TYPES, COMPONENT_COUNT_TO_TYPE, FUNCTION_RETURN_TYPES, getOperatorResultType, validateOperatorTypes } from './const'
-import { is, getStride } from '../../helpers'
+import { is, getStride, isFloat32 } from '../../helpers'
 import type { Constants as C, NodeContext, X, Y } from '../types'
 
 const inferBuiltin = <T extends C>(id: string | undefined) => {
@@ -16,7 +16,7 @@ export const inferPrimitiveType = <T extends C>(x: Y<T>) => {
         if (is.bol(x)) return 'bool' as T
         if (is.str(x)) return 'texture' as T
         if (is.num(x)) return 'float' as T // @TODO FIX:  Number.isInteger(x) ? 'int' : 'float'
-        if (is.arr(x)) return COMPONENT_COUNT_TO_TYPE[x.length as keyof typeof COMPONENT_COUNT_TO_TYPE] as T
+        if (is.arr(x) || isFloat32(x)) return COMPONENT_COUNT_TO_TYPE[x.length as keyof typeof COMPONENT_COUNT_TO_TYPE] as T
         if (isElement(x)) return 'texture' as T
         return 'void' as T
 }

package/src/node/utils/utils.ts

@@ -1,5 +1,5 @@
 import { CONSTANTS, CONVERSIONS, FUNCTIONS, OPERATOR_KEYS, OPERATORS, TYPE_MAPPING, WGSL_TO_GLSL_BUILTIN } from './const'
-import { is } from '../../helpers'
+import { is, isFloat32 } from '../../helpers'
 import { storageSize } from '../../webgl/utils'
 import type { Constants as C, Conversions, Functions, NodeContext, Operators, Swizzles, X, Y } from '../types'
 
@@ -103,28 +103,33 @@ export const addDependency = (c: NodeContext, id = '', type: string) => {
  */
 const getEventFun = (c: NodeContext, id: string, type: string) => {
         if (c.isWebGL) {
-                if (type === 'attribute') return (value: any) => c.gl?.attribute?.(id, value)
-                if (type === 'instance') return (value: any) => c.gl?.instance?.(id, value)
-                if (type === 'texture') return (value: any) => c.gl?.texture?.(id, value)
+                if (type === 'attribute') return c.gl?.attribute?.bind(null, id as any)
+                if (type === 'instance') return c.gl?.instance?.bind(null, id as any)
+                if (type === 'texture') return c.gl?.texture?.bind(null, id as any)
+                if (type === 'storage') return c.gl?.storage?.bind(null, id as any)
                 return (value: any) => c.gl?.uniform?.(id, value)
         }
-        if (type === 'attribute') return (value: any) => c.gl?._attribute?.(id, value)
-        if (type === 'instance') return (value: any) => c.gl?._instance?.(id, value)
-        if (type === 'texture') return (value: any) => c.gl?._texture?.(id, value)
+        if (type === 'attribute') return c.gl?._attribute?.bind(null, id)
+        if (type === 'instance') return c.gl?._instance?.bind(null, id)
+        if (type === 'texture') return c.gl?._texture?.bind(null, id)
+        if (type === 'storage') return c.gl?._storage?.bind(null, id)
         return (value: any) => c.gl?._uniform?.(id, value)
 }
 
-const safeEventCall = <T extends C>(x: X<T>, fun: (value: unknown) => void) => {
+const safeEventCall = <T extends C>(x: X<T>, fun: (value: any) => void) => {
         if (is.und(x)) return
         if (!isX(x)) return fun(x) // for uniform(0) or uniform([0, 1])
         if (x.type !== 'conversion') return
         const args = x.props.children?.slice(1)
         if (is.und(args?.[0])) return // ignore if uniform(vec2())
+        if (is.arr(args[0])) return fun(args[0]) // for attribute(vec2([0, 0.73, -1, -1, 1, -1]))
+        if (isFloat32(args[0])) return fun(args[0]) // for storage(float(new Float32Array(1024)))
         fun(args.map((x) => x ?? args[0])) // for uniform(vec2(1)) or uniform(vec2(1, 1))
 }
 
 export const setupEvent = (c: NodeContext, id: string, type: string, target: X, child: X) => {
         const fun = getEventFun(c, id, type)
+        if (!fun) return
         safeEventCall(child, fun)
         target.listeners.add(fun)
         return fun