glre 0.37.0 → 0.38.0

package/package.json

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

package/src/node/node.ts

@@ -14,7 +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 === '__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)
@@ -43,7 +44,7 @@ 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)

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
@@ -10,16 +21,16 @@ const addToScope = (x: NodeProxy) => {
         if (!scope.props.children) scope.props.children = []
         scope.props.children.push(x)
         if (x.type !== 'return' || !define) return
-        // define nodes
         const { props } = define
         if (!props.inferFrom) props.inferFrom = []
         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
 }
@@ -36,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>
         }
 }
 
@@ -104,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
 }

package/src/node/types.ts

@@ -6,6 +6,9 @@ export type Conversions = (typeof CONVERSIONS)[number]
 export type Functions = (typeof FUNCTIONS)[number]
 export type Operators = (typeof OPERATOR_KEYS)[number]
 
+/**
+ * scope
+ */
 export interface FnLayout {
         name: string
         type: Constants | 'auto'
@@ -15,8 +18,13 @@ export interface FnLayout {
         }>
 }
 
+export interface FnType<T extends NodeProxy | StructNode | void, Args extends any[]> {
+        (...args: Args): T extends void ? Void : T
+        setLayout(layout: FnLayout): FnType<T, Args>
+}
+
 /**
- * Node
+ * node
  */
 export type NodeTypes =
         // headers
@@ -48,7 +56,7 @@ export type NodeTypes =
         | 'declare'
         | 'return'
 
-export interface NodeProps<T extends Record<string, NodeProxy> = {}> {
+export interface NodeProps {
         id?: string
         args?: any[]
         type?: string
@@ -56,8 +64,8 @@ export interface NodeProps<T extends Record<string, NodeProxy> = {}> {
         inferFrom?: any[]
         layout?: FnLayout
         // for struct
-        fields?: T
-        initialValues?: T
+        fields?: StructFields
+        initialValues?: StructFields
 }
 
 export interface NodeContext {
@@ -75,6 +83,7 @@ export interface NodeContext {
                 vertVaryings: Map<string, string>
                 computeInputs: Map<string, string>
                 dependencies: Map<string, Set<string>>
+                structFields: Map<string, StructFields>
         }
 }
 
@@ -144,6 +153,7 @@ type NodeProxyMethods =
         | Conversions
         | Swizzles
         // system property
+        | '__nodeType'
         | 'type'
         | 'props'
         | 'isProxy'
@@ -159,8 +169,9 @@ type ReadNodeProxy = {
 }
 
 // Internal NodeProxy implementation (renamed from original)
-type NodeProxyImpl<T extends Constants = string> = BaseNodeProxy<T> & ReadNodeProxy
+type NodeProxyImpl<T extends Constants> = BaseNodeProxy<T> & ReadNodeProxy
 
+export type Void = NodeProxyImpl<'void'>
 export type Bool = NodeProxyImpl<'bool'>
 export type UInt = NodeProxyImpl<'uint'>
 export type Int = NodeProxyImpl<'int'>
@@ -184,8 +195,19 @@ export type Mat4 = NodeProxyImpl<'mat4'>
 export type Texture = NodeProxyImpl<'texture'>
 export type Sampler2D = NodeProxyImpl<'sampler2D'>
 export type Struct = NodeProxyImpl<'struct'>
+export type StructFields = Record<string, NodeProxy>
+export type StructNode<T extends StructFields = any> = Omit<Struct, keyof T> & {
+        [K in keyof T]: T[K] extends NodeProxy<infer U> ? NodeProxy<U> : never
+} & {
+        toVar(id?: string): StructNode<T>
+}
+
+export interface StructFactory<T extends StructFields> {
+        (initialValues?: StructFields, instanceId?: string): StructNode<T>
+}
 
 export interface ConstantsToType {
+        void: Void
         bool: Bool
         uint: UInt
         int: Int
@@ -211,14 +233,15 @@ export interface ConstantsToType {
         struct: Struct
 }
 
-export type NodeProxy<T extends Constants = string> = T extends keyof ConstantsToType
+export type NodeProxy<T extends Constants = Constants> = T extends keyof ConstantsToType
         ? ConstantsToType[T]
-        : NodeProxyImpl<T>
+        : BaseNodeProxy<T>
 
-export type X<T extends Constants = string> = number | string | boolean | undefined | NodeProxy<T> | X[]
+export type X<T extends Constants = Constants> = number | string | boolean | undefined | NodeProxy<T>
 
 export interface BaseNodeProxy<T extends Constants> {
         // System properties
+        readonly __nodeType?: T
         assign(x: any): NodeProxy<T>
         toVar(name?: string): NodeProxy<T>
         toString(c?: NodeContext): string
@@ -230,6 +253,11 @@ export interface BaseNodeProxy<T extends Constants> {
         // Element access for array/matrix types
         element<Index extends X>(index: Index): NodeProxy<InferArrayElement<T>>
 
+        // Enhanced member access with type preservation
+        member<K extends string>(
+                key: K
+        ): K extends keyof T ? (T[K] extends NodeProxy<infer U> ? NodeProxy<U> : never) : never
+
         // Operators methods
         add<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
         sub<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
@@ -305,41 +333,41 @@ export interface BaseNodeProxy<T extends Constants> {
          * 2.1. const.ts FUNCTIONS
          */
         // 0. Component-wise functions
-        abs(): NodeProxy
-        acos(): NodeProxy
-        acosh(): NodeProxy
-        asin(): NodeProxy
-        asinh(): NodeProxy
-        atan(): NodeProxy
-        atanh(): NodeProxy
-        ceil(): NodeProxy
-        cos(): NodeProxy
-        cosh(): NodeProxy
-        degrees(): NodeProxy
-        dFdx(): NodeProxy
-        dFdy(): NodeProxy
-        exp(): NodeProxy
-        exp2(): NodeProxy
-        floor(): NodeProxy
-        fract(): NodeProxy
-        fwidth(): NodeProxy
-        inverseSqrt(): NodeProxy
-        log(): NodeProxy
-        log2(): NodeProxy
-        negate(): NodeProxy
-        normalize(): NodeProxy
-        oneMinus(): NodeProxy
-        radians(): NodeProxy
-        reciprocal(): NodeProxy
-        round(): NodeProxy
-        saturate(): NodeProxy
-        sign(): NodeProxy
-        sin(): NodeProxy
-        sinh(): NodeProxy
-        sqrt(): NodeProxy
-        tan(): NodeProxy
-        tanh(): NodeProxy
-        trunc(): NodeProxy
+        abs(): NodeProxy<T>
+        acos(): NodeProxy<T>
+        acosh(): NodeProxy<T>
+        asin(): NodeProxy<T>
+        asinh(): NodeProxy<T>
+        atan(): NodeProxy<T>
+        atanh(): NodeProxy<T>
+        ceil(): NodeProxy<T>
+        cos(): NodeProxy<T>
+        cosh(): NodeProxy<T>
+        degrees(): NodeProxy<T>
+        dFdx(): NodeProxy<T>
+        dFdy(): NodeProxy<T>
+        exp(): NodeProxy<T>
+        exp2(): NodeProxy<T>
+        floor(): NodeProxy<T>
+        fract(): NodeProxy<T>
+        fwidth(): NodeProxy<T>
+        inverseSqrt(): NodeProxy<T>
+        log(): NodeProxy<T>
+        log2(): NodeProxy<T>
+        negate(): NodeProxy<T>
+        normalize(): NodeProxy<T>
+        oneMinus(): NodeProxy<T>
+        radians(): NodeProxy<T>
+        reciprocal(): NodeProxy<T>
+        round(): NodeProxy<T>
+        saturate(): NodeProxy<T>
+        sign(): NodeProxy<T>
+        sin(): NodeProxy<T>
+        sinh(): NodeProxy<T>
+        sqrt(): NodeProxy<T>
+        tan(): NodeProxy<T>
+        tanh(): NodeProxy<T>
+        trunc(): NodeProxy<T>
 
         // 1. Functions where first argument determines return type
         atan2<U extends Constants>(x: X<U>): NodeProxy<T>

package/src/node/utils/const.ts

@@ -51,9 +51,10 @@ export const TYPE_MAPPING = {
         struct: 'struct',
 } as const
 
-export const CONSTANTS = Object.keys(TYPE_MAPPING) as unknown as keyof typeof TYPE_MAPPING
+export const CONSTANTS = Object.keys(TYPE_MAPPING) as (keyof typeof TYPE_MAPPING)[]
 
 export const OPERATORS = {
+        not: '', // IGNORED
         add: '+',
         sub: '-',
         mul: '*',

package/src/node/utils/index.ts

@@ -85,12 +85,12 @@ export const code = <T extends Constants>(target: X<T>, c?: NodeContext | null):
         if (type === 'switch') return parseSwitch(c, x, children)
         if (type === 'declare') return parseDeclare(c, x, y)
         if (type === 'define') {
-                if (!c.code?.headers.has(id)) c.code?.headers.set(id, parseDefine(c, props, infer(target, c)))
+                if (!c.code?.headers.has(id)) c.code?.headers.set(id, parseDefine(c, props, target))
                 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)
+                return parseStruct(c, id, x.props.id, initialValues)
         }
         /**
          * headers

package/src/node/utils/infer.ts

@@ -48,8 +48,8 @@ const inferFromArray = <T extends C>(arr: X<T>[], c: NodeContext) => {
         const [x] = arr
         if (is.str(x)) return x as T // for struct
         const ret = infer(x, c)
-        for (const x of arr.slice(1))
-                if (ret !== infer(x, c)) throw new Error(`glre node system error: defined scope return mismatch`)
+        // for (const x of arr.slice(1))
+        //         if (ret !== infer(x, c)) throw new Error(`glre node system error: defined scope return mismatch`)
         return ret
 }
 
@@ -63,7 +63,6 @@ export const inferImpl = <T extends C>(target: NodeProxy<T>, c: NodeContext): T
         const [x, y, z] = children
         if (type === 'conversion') return x
         if (type === 'operator') return inferOperator(infer(y, c), infer(z, c), x)
-        if (type === 'ternary') return inferOperator(infer(y, c), infer(z, c), 'add')
         if (type === 'builtin') return inferBuiltin(id)
         if (type === 'function') return inferFunction(x) || infer(y, c)
         if (type === 'define') {
@@ -75,10 +74,11 @@ export const inferImpl = <T extends C>(target: NodeProxy<T>, c: NodeContext): T
         if (type === 'member') {
                 if (isSwizzle(y)) return inferFromCount(y.length)
                 if (isNodeProxy(x)) {
-                        const field = (x as any).props.fields[y] // for variable node of struct member
-                        if (field) return infer(field, c)
+                        const structType = infer(x, c)
+                        const fields = c.code?.structFields?.get(structType)
+                        if (fields && fields[y]) return infer(fields[y], c) as T
                 }
-                return 'float' as T // fallback @TODO FIX
+                return 'float' as T
         }
         if (inferFrom) return inferFromArray(inferFrom, c)
         return infer(x, c) // for uniform and storage gather and scatter
@@ -92,5 +92,5 @@ export const infer = <T extends C>(target: X<T>, c?: NodeContext | null): T => {
         if (c.infers.has(target)) return c.infers.get(target) as T
         const ret = inferImpl(target, c)
         c.infers.set(target, ret)
-        return ret
+        return ret as T
 }

package/src/node/utils/parse.ts

@@ -2,7 +2,7 @@ import { code } from '.'
 import { infer } from './infer'
 import { getConversions, addDependency } from './utils'
 import { is } from '../../utils/helpers'
-import type { Constants, NodeContext, NodeProps, NodeProxy, X } from '../types'
+import type { Constants, NodeContext, NodeProps, NodeProxy, StructFields, X } from '../types'
 
 export const parseArray = (children: X[], c: NodeContext) => {
         return children
@@ -87,7 +87,8 @@ export const parseDeclare = (c: NodeContext, x: X, y: X) => {
         return `var ${varName}: ${wgslType} = ${code(x, c)};`
 }
 
-export const parseStructHead = (c: NodeContext, id: string, fields: Record<string, NodeProxy> = {}) => {
+export const parseStructHead = (c: NodeContext, id: string, fields: StructFields = {}) => {
+        c.code?.structFields?.set(id, fields)
         const lines: string[] = []
         for (const key in fields) {
                 const fieldType = fields[key]
@@ -99,13 +100,8 @@ export const parseStructHead = (c: NodeContext, id: string, fields: Record<strin
         return `struct ${id} {\n  ${ret}\n};`
 }
 
-export const parseStruct = (
-        c: NodeContext,
-        id: string,
-        instanceId = '',
-        fields?: Record<string, NodeProxy>,
-        initialValues?: Record<string, NodeProxy>
-) => {
+export const parseStruct = (c: NodeContext, id: string, instanceId = '', initialValues?: StructFields) => {
+        const fields = c.code?.structFields?.get(id) || {}
         if (c.isWebGL) {
                 if (initialValues) {
                         const ordered = []
@@ -124,7 +120,7 @@ export const parseStruct = (
 /**
  * define
  */
-export const parseDefine = (c: NodeContext, props: NodeProps, returnType: Constants) => {
+export const parseDefine = (c: NodeContext, props: NodeProps, target: NodeProxy) => {
         const { id, children = [], layout } = props
         const [x, ...args] = children
         const argParams: [name: string, type: string][] = []
@@ -137,6 +133,8 @@ export const parseDefine = (c: NodeContext, props: NodeProps, returnType: Consta
                 for (let i = 0; i < args.length; i++) {
                         argParams.push([`p${i}`, infer(args[i], c)])
                 }
+        const scopeCode = code(x, c) // build struct headers before inferring returnType
+        const returnType = infer(target, c)
         const ret = []
         if (c?.isWebGL) {
                 for (const [paramId, type] of argParams) {
@@ -152,7 +150,6 @@ export const parseDefine = (c: NodeContext, props: NodeProps, returnType: Consta
                         ret.push(`fn ${id}(${params}) {`)
                 } else ret.push(`fn ${id}(${params}) -> ${getConversions(returnType, c)} {`)
         }
-        const scopeCode = code(x, c)
         if (scopeCode) ret.push(scopeCode)
         ret.push('}')
         return ret.join('\n')

package/src/node/utils/utils.ts

@@ -34,7 +34,7 @@ export const isNodeProxy = <T extends Constants>(x: unknown): x is NodeProxy<T>
 
 export const isConstants = (type?: unknown): type is Constants => {
         if (!is.str(type)) return false
-        return CONSTANTS.includes(type)
+        return CONSTANTS.includes(type as any)
 }
 
 export const hex2rgb = (hex: number) => {
@@ -64,7 +64,7 @@ export const getConversions = <T extends Constants>(x: X<T>, c?: NodeContext) =>
         return TYPE_MAPPING[x as keyof typeof TYPE_MAPPING] || x // for struct type
 }
 
-export const getOperator = (op: X<string>) => {
+export const getOperator = (op: X) => {
         return OPERATORS[op as keyof typeof OPERATORS] || op
 }
 
@@ -86,11 +86,11 @@ export const getEventFun = (c: NodeContext, id: string, isAttribute = false, isT
 
 export const safeEventCall = <T extends Constants>(x: X<T>, fun: (value: unknown) => void) => {
         if (is.und(x)) return
-        if (!isNodeProxy(x)) return fun(x) // for uniform(1)
+        if (!isNodeProxy(x)) return fun(x) // for uniform(0) or uniform([0, 1])
         if (x.type !== 'conversion') return
-        const value = x.props.children?.slice(1).filter(Boolean)
-        if (!value?.length) return // for uniform(vec2())
-        fun(value)
+        const args = x.props.children?.slice(1)
+        if (is.und(args?.[0])) return // ignore if uniform(vec2())
+        fun(args.map((x) => x ?? args[0])) // for uniform(vec2(1)) or uniform(vec2(1, 1))
 }
 
 export const initNodeContext = (c: NodeContext) => {
@@ -103,6 +103,7 @@ export const initNodeContext = (c: NodeContext) => {
                 vertVaryings: new Map(),
                 computeInputs: new Map(),
                 dependencies: new Map(),
+                structFields: new Map(),
         }
         if (c.isWebGL) return c
         c.code.fragInputs.set('position', '@builtin(position) position: vec4f')

package/src/types.ts

@@ -1,6 +1,6 @@
 import type { EventState, Nested } from 'reev'
 import type { Fun, Queue, Frame } from 'refr'
-import type { NodeProxy, Vec4 } from './node'
+import type { NodeProxy, Vec4, Void } from './node'
 export type { Fun, Queue, Frame }
 
 export type GL = EventState<{
@@ -21,13 +21,13 @@ export type GL = EventState<{
         particles: 64 | 256 | 576 | 1024 | 1600 | 2304 | 3136 | 4096 | 4096 | 5184 | 6400 // (8k)^2
         el: HTMLCanvasElement
         vs?: string | Vec4
-        cs?: string | Vec4
+        cs?: string | Void
         fs?: string | Vec4
         vert?: string | Vec4
-        comp?: string | Vec4
+        comp?: string | Void
         frag?: string | Vec4
         vertex?: string | Vec4
-        compute?: string | Vec4
+        compute?: string | Void
         fragment?: string | Vec4
 
         /**

package/src/utils/program.ts

@@ -9,7 +9,7 @@ const createShader = (c: WebGLRenderingContext, source: string, type: number, on
         if (c.getShaderParameter(shader, c.COMPILE_STATUS)) return shader
         const error = c.getShaderInfoLog(shader)
         c.deleteShader(shader)
-        onError(`Could not compile shader: ${error}`)
+        onError(`Could not compile shader: ${error}\n\n↓↓↓generated↓↓↓\n${source}`)
 }
 
 export const createProgram = (c: WebGLRenderingContext, frag: string, vert: string, gl: GL) => {