glre 0.32.0 → 0.34.0

package/src/node/parse.ts

@@ -1,12 +1,20 @@
-import { infer } from './infer'
-import { formatConversions, joins } from './utils'
+import { is } from '../utils/helpers'
 import { code } from './code'
-import type { Constants, NodeContext, NodeProps, X } from './types'
+import { infer } from './infer'
+import { formatConversions, addDependency } from './utils'
+import type { Constants, NodeContext, NodeProps, NodeProxy, X } from './types'
+
+export const parseArray = (children: X[], c: NodeContext) => {
+        return children
+                .filter((x) => !is.und(x) && !is.nul(x))
+                .map((x) => code(x, c))
+                .join(', ')
+}
 
 export const parseTexture = (c: NodeContext, y: X, z: X, w: X) => {
         if (c.isWebGL) {
                 const args = w ? [y, z, w] : [y, z]
-                return `texture(${joins(args, c)})`
+                return `texture(${parseArray(args, c)})`
         }
         const _y = code(y, c)
         const args = [_y, _y + 'Sampler', code(z, c)]
@@ -43,10 +51,10 @@ export const parseSwitch = (c: NodeContext, x: X, children: X[]) => {
 }
 
 export const parseDeclare = (c: NodeContext, x: X, y: X) => {
-        const varType = infer(x, c)
+        const type = infer(x, c)
         const varName = (y as any)?.props?.id
-        if (c.isWebGL) return `${varType} ${varName} = ${code(x, c)};`
-        const wgslType = formatConversions(varType)
+        if (c.isWebGL) return `${type} ${varName} = ${code(x, c)};`
+        const wgslType = formatConversions(type)
         return `var ${varName}: ${wgslType} = ${code(x, c)};`
 }
 
@@ -65,10 +73,14 @@ export const parseDefine = (c: NodeContext, props: NodeProps, returnType: Consta
                 }
         const ret = []
         if (c?.isWebGL) {
-                for (const [id, type] of argParams) params.push(`${type} ${id}`)
+                for (const [paramId, type] of argParams) {
+                        addDependency(c, id!, type)
+                        params.push(`${type} ${paramId}`)
+                }
+                addDependency(c, id!, returnType)
                 ret.push(`${returnType} ${id}(${params}) {`)
         } else {
-                for (const [id, type] of argParams) params.push(`${id}: ${formatConversions(type, c)}`)
+                for (const [paramId, type] of argParams) params.push(`${paramId}: ${formatConversions(type, c)}`)
                 ret.push(`fn ${id}(${params}) -> ${formatConversions(returnType, c)} {`)
         }
         const scopeCode = code(x, c)
@@ -77,42 +89,74 @@ export const parseDefine = (c: NodeContext, props: NodeProps, returnType: Consta
         return ret.join('\n')
 }
 
+export const parseStructHead = (c: NodeContext, id: string, fields: Record<string, NodeProxy> = {}) => {
+        const lines: string[] = []
+        for (const key in fields) {
+                const fieldType = fields[key]
+                const type = infer(fieldType, c)
+                if (c.isWebGL) addDependency(c, id, type)
+                lines.push(c.isWebGL ? `${type} ${key};` : `${key}: ${formatConversions(type, c)},`)
+        }
+        const ret = lines.join('\n  ')
+        return `struct ${id} {\n  ${ret}\n};`
+}
+
+export const parseStruct = (
+        c: NodeContext,
+        id: string,
+        instanceId = '',
+        fields?: Record<string, NodeProxy>,
+        initialValues?: Record<string, NodeProxy>
+) => {
+        if (c.isWebGL) {
+                if (initialValues) {
+                        const ordered = []
+                        for (const key in fields) ordered.push(initialValues[key])
+                        return `${id} ${instanceId} = ${id}(${parseArray(ordered, c)});`
+                } else return `${id} ${instanceId};`
+        } else {
+                if (initialValues) {
+                        const ordered = []
+                        for (const key in fields) ordered.push(initialValues[key])
+                        return `var ${instanceId}: ${id} = ${id}(${parseArray(ordered, c)});`
+                } else return `var ${instanceId}: ${id};`
+        }
+}
+
 /**
  * headers
  */
-export const parseVaryingHead = (c: NodeContext, id: string, varType: string) => {
+export const parseVaryingHead = (c: NodeContext, id: string, type: string) => {
         return c.isWebGL
-                ? `${varType} ${id};`
-                : `@location(${c.vertVaryings!.size}) ${id}: ${formatConversions(varType, c)}`
+                ? `${type} ${id};`
+                : `@location(${c.code?.vertVaryings?.size || 0}) ${id}: ${formatConversions(type, c)}`
 }
 
-export const parseUniformHead = (c: NodeContext, id: string, varType: Constants) => {
-        const isTexture = varType === 'sampler2D' || varType === 'texture'
+export const parseUniformHead = (c: NodeContext, id: string, type: Constants) => {
+        const isTexture = type === 'sampler2D' || type === 'texture'
         if (c.isWebGL)
                 return isTexture //
                         ? `uniform sampler2D ${id};`
-                        : `uniform ${varType} ${id};`
+                        : `uniform ${type} ${id};`
         if (isTexture) {
-                const { group = 1, binding = 0 } = c.webgpu?.textures.map.get(id) || {}
+                const { group = 1, binding = 0 } = c.gl?.webgpu?.textures.map.get(id) || {}
                 return (
                         `@group(${group}) @binding(${binding}) var ${id}Sampler: sampler;\n` +
                         `@group(${group}) @binding(${binding + 1}) var ${id}: texture_2d<f32>;`
                 )
         }
-        const { group = 0, binding = 0 } = c.webgpu?.uniforms.map.get(id) || {}
-        const wgslType = formatConversions(varType, c)
+        const { group = 0, binding = 0 } = c.gl?.webgpu?.uniforms.map.get(id) || {}
+        const wgslType = formatConversions(type, c)
         return `@group(${group}) @binding(${binding}) var<uniform> ${id}: ${wgslType};`
 }
 
-export const parseAttribHead = (c: NodeContext, id: string, varType: Constants) => {
-        if (c.isWebGL) return `${varType} ${id};`
-        const { location = 0 } = c.webgpu?.attribs.map.get(id) || {}
-        const wgslType = formatConversions(varType, c)
+export const parseAttribHead = (c: NodeContext, id: string, type: Constants) => {
+        if (c.isWebGL) return `${type} ${id};`
+        const { location = 0 } = c.gl?.webgpu?.attribs.map.get(id) || {}
+        const wgslType = formatConversions(type, c)
         return `@location(${location}) ${id}: ${wgslType}`
 }
 
-export const parseConstantHead = (c: NodeContext, id: string, varType: Constants, value: string) => {
-        return c.isWebGL
-                ? `const ${varType} ${id} = ${value};`
-                : `const ${id}: ${formatConversions(varType, c)} = ${value};`
+export const parseConstantHead = (c: NodeContext, id: string, type: Constants, value: string) => {
+        return c.isWebGL ? `const ${type} ${id} = ${value};` : `const ${id}: ${formatConversions(type, c)} = ${value};`
 }

package/src/node/scope.ts

@@ -1,7 +1,6 @@
-import { int } from '.'
 import { conversion, node } from './node'
 import { getId } from './utils'
-import type { FnLayout, NodeProps, NodeProxy, X } from './types'
+import type { FnLayout, NodeProps, NodeProxy, X, Constants, Int } from './types'
 
 let scope: NodeProxy | null = null
 let define: NodeProxy | null = null
@@ -16,26 +15,35 @@ const addToScope = (x: NodeProxy) => {
         props.inferFrom.push(x)
 }
 
-export const toVar = (x: X, id?: string) => {
+export const toVar = <T extends Constants>(x: X<T>, id?: string): NodeProxy<T> => {
         if (!id) id = getId()
-        const y = node('variable', { id, inferFrom: [x] })
+        const y = node<T>('variable', { id, inferFrom: [x] })
         const z = node('declare', null, x, y)
         addToScope(z)
         return y
 }
 
-export const assign = (x: X, y: X) => {
+export const assign = <T extends Constants>(x: X<T>, y: X<T>): X<T> => {
         const z = node('assign', null, x, y)
         addToScope(z)
         return x
 }
 
-export const Return = (x: X) => {
-        const y = node('return', { inferFrom: [x] }, x)
+export const Return = <T extends Constants>(x: X<T>): NodeProxy<T> => {
+        const y = node<T>('return', { inferFrom: [x] }, x)
         addToScope(y)
         return y
 }
 
+export const struct = <T extends Record<string, NodeProxy>>(fields: T, id = getId()) => {
+        return (initialValues: T = {} as T, instanceId = getId()) => {
+                const x = node('variable', { id: instanceId, inferFrom: [id] })
+                const y = node('struct', { id, fields, initialValues }, x)
+                addToScope(y)
+                return x
+        }
+}
+
 const scoped = (x: NodeProxy, fun: () => NodeProxy | void, y = define) => {
         // cache to revert
         const _scope = scope
@@ -51,7 +59,7 @@ const scoped = (x: NodeProxy, fun: () => NodeProxy | void, y = define) => {
         define = _define
 }
 
-export const If = (x: X, fun: () => void) => {
+export const If = (x: NodeProxy, fun: () => void) => {
         const y = node('scope')
         scoped(y, fun)
         const ifNode = node('if', null, x, y)
@@ -72,15 +80,15 @@ export const If = (x: X, fun: () => void) => {
         return ret()
 }
 
-export const Loop = (x: X, fun: (params: { i: NodeProxy }) => void) => {
+export const Loop = (x: NodeProxy, fun: (params: { i: Int }) => void) => {
         const y = node('scope')
-        scoped(y, () => fun({ i: node('variable', { id: 'i', inferFrom: [int(0)] }) }))
+        scoped(y, () => fun({ i: node<'int'>('variable', { id: 'i', inferFrom: [conversion('int', 0)] }) }))
         const ret = node('loop', null, x, y)
         addToScope(ret)
         return ret
 }
 
-export const Switch = (x: X) => {
+export const Switch = (x: NodeProxy) => {
         const switchNode = node('switch', null, x)
         addToScope(switchNode)
         const ret = () => ({
@@ -98,14 +106,16 @@ export const Switch = (x: X) => {
                         switchNode.props.children!.push(scope)
                 },
         })
-
         return ret()
 }
 
-export const Fn = (fun: (paramVars: NodeProxy[]) => NodeProxy) => {
+export const Fn = <ReturnType extends Constants, Args extends Constants[]>(
+        fun: (paramVars: NodeProxy[]) => NodeProxy<ReturnType> | void,
+        defaultId = getId()
+) => {
         let layout: FnLayout
-        const ret = (...args: X[]) => {
-                const id = layout?.name || getId()
+        const ret = (...args: X<Args[number]>[]): NodeProxy<ReturnType> => {
+                const id = layout?.name || defaultId
                 const x = node('scope')
                 const paramVars: NodeProxy[] = []
                 const paramDefs: NodeProps[] = []
@@ -118,12 +128,12 @@ export const Fn = (fun: (paramVars: NodeProxy[]) => NodeProxy) => {
                                 paramDefs.push({ id: `p${i}`, inferFrom: [args[i]] })
                         }
                 for (const props of paramDefs) paramVars.push(node('variable', props))
-                const y = node('define', { id, layout }, x, ...args)
+                const y = node<ReturnType>('define', { id, layout }, x, ...args)
                 scoped(x, () => fun(paramVars), y)
                 return y
         }
-        ret.setLayout = (newLayout: FnLayout) => {
-                layout = newLayout
+        ret.setLayout = (_layout: FnLayout) => {
+                layout = _layout
                 return ret
         }
         return ret

package/src/node/types.ts

@@ -1,4 +1,5 @@
-import { WebGPUState } from '../types'
+import { GL } from '../types'
+
 import { CONSTANTS, CONVERSIONS, FUNCTIONS, OPERATOR_KEYS } from './const'
 
 export type Constants = (typeof CONSTANTS)[number] | 'void'
@@ -29,12 +30,14 @@ export type NodeTypes =
         // variables
         | 'variable'
         | 'varying'
-        | 'swizzle'
         | 'ternary'
         | 'builtin'
         | 'conversion'
         | 'operator'
         | 'function'
+        // struct
+        | 'struct'
+        | 'member'
         // scopes
         | 'scope'
         | 'assign'
@@ -45,32 +48,79 @@ export type NodeTypes =
         | 'declare'
         | 'return'
 
-export interface NodeProps {
+export interface NodeProps<T extends Record<string, NodeProxy> = {}> {
         id?: string
-        args?: X[]
+        args?: any[]
         type?: string
-        children?: X[]
-        inferFrom?: X[]
+        children?: any[]
+        inferFrom?: any[]
         layout?: FnLayout
         parent?: NodeProxy
+        // for struct
+        fields?: T
+        initialValues?: T
 }
 
 export interface NodeContext {
+        gl?: Partial<GL>
         isFrag?: boolean
         isWebGL?: boolean
         binding?: number
         infers?: WeakMap<NodeProxy, Constants>
         onMount?: (name: string) => void
-        webgpu?: WebGPUState
-        headers?: Map<string, string>
-        fragInputs?: Map<string, string>
-        vertInputs?: Map<string, string>
-        vertOutputs?: Map<string, string>
-        vertVaryings?: Map<string, string>
+        code?: {
+                headers: Map<string, string>
+                fragInputs: Map<string, string>
+                vertInputs: Map<string, string>
+                vertOutputs: Map<string, string>
+                vertVaryings: Map<string, string>
+                dependencies: Map<string, Set<string>>
+        }
 }
 
 /**
- * NodeProxy
+ * infer
+ */
+// Unified logic with infer.ts inferOperator function
+// prettier-ignore
+type InferOperator<L extends Constants, R extends Constants> =
+        L extends R ? L :
+        // broadcast
+        L extends 'float' | 'int' ? R :
+        R extends 'float' | 'int' ? L :
+        // mat * vec → vec
+        L extends 'mat4' ? R extends 'vec4' ? R /* default */ : L :
+        L extends 'mat3' ? R extends 'vec3' ? R /* default */ : L :
+        L extends 'mat2' ? R extends 'vec2' ? R /* default */ : L :
+        // vec * mat → vec
+        L extends 'vec4' ? R extends 'mat4' ? L /* default */ : L :
+        L extends 'vec3' ? R extends 'mat3' ? L /* default */ : L :
+        L extends 'vec2' ? R extends 'mat2' ? L /* default */ : L : L
+
+type _StringLength<S extends string> = S extends `${infer _}${infer Rest}`
+        ? Rest extends ''
+                ? 1
+                : Rest extends `${infer _}${infer Rest2}`
+                ? Rest2 extends ''
+                        ? 2
+                        : Rest2 extends `${infer _}${infer Rest3}`
+                        ? Rest3 extends ''
+                                ? 3
+                                : 4
+                        : never
+                : never
+        : 0
+
+type InferSwizzleType<S extends string> = _StringLength<S> extends 4
+        ? 'vec4'
+        : _StringLength<S> extends 3
+        ? 'vec3'
+        : _StringLength<S> extends 2
+        ? 'vec2'
+        : 'float'
+
+/**
+ * Swizzles
  */
 type _Swizzles<T extends string> = T | `${T}${T}` | `${T}${T}${T}` | `${T}${T}${T}${T}`
 
@@ -93,104 +143,187 @@ type NodeProxyMethods =
         | 'toVar'
         | 'toString'
 
-export type DynamicProperties = {
-        [K in string as K extends NodeProxyMethods ? never : K]: NodeProxy
-}
-
-export interface BaseNodeProxy extends Record<Swizzles, NodeProxy> {
+export interface BaseNodeProxy<T extends Constants> {
         // System properties
-        assign(n: X): NodeProxy
-        toVar(name?: string): NodeProxy
+        assign(x: any): NodeProxy<T>
+        toVar(name?: string): NodeProxy<T>
         toString(c?: NodeContext): string
         type: NodeTypes
         props: NodeProps
         isProxy: true
+        listeners: Set<(value: any) => void>
 
         // Operators methods
-        add(n: X): NodeProxy
-        sub(n: X): NodeProxy
-        mul(n: X): NodeProxy
-        div(n: X): NodeProxy
-        mod(n: X): NodeProxy
-        equal(n: X): NodeProxy
-        notEqual(n: X): NodeProxy
-        lessThan(n: X): NodeProxy
-        lessThanEqual(n: X): NodeProxy
-        greaterThan(n: X): NodeProxy
-        greaterThanEqual(n: X): NodeProxy
-        and(n: X): NodeProxy
-        or(n: X): NodeProxy
-        not(): NodeProxy
-
-        // Conversations methods
-        toBool(): NodeProxy
-        toUint(): NodeProxy
-        toInt(): NodeProxy
-        toFloat(): NodeProxy
-        toBvec2(): NodeProxy
-        toIvec2(): NodeProxy
-        toUvec2(): NodeProxy
-        toVec2(): NodeProxy
-        toBvec3(): NodeProxy
-        toIvec3(): NodeProxy
-        toUvec3(): NodeProxy
-        toVec3(): NodeProxy
-        toBvec4(): NodeProxy
-        toIvec4(): NodeProxy
-        toUvec4(): NodeProxy
-        toVec4(): NodeProxy
-        toColor(): NodeProxy
-        toMat2(): NodeProxy
-        toMat3(): NodeProxy
-        toMat4(): NodeProxy
-
-        // Function methods
-        abs(): NodeProxy
-        sin(): NodeProxy
-        cos(): NodeProxy
-        tan(): NodeProxy
-        asin(): NodeProxy
-        acos(): NodeProxy
-        atan(): NodeProxy
-        atan2(x: X): NodeProxy
-        pow(y: X): NodeProxy
-        pow2(): NodeProxy
-        pow3(): NodeProxy
-        pow4(): NodeProxy
-        sqrt(): NodeProxy
-        inverseSqrt(): NodeProxy
-        exp(): NodeProxy
-        exp2(): NodeProxy
-        log(): NodeProxy
-        log2(): NodeProxy
-        floor(): NodeProxy
-        ceil(): NodeProxy
-        round(): NodeProxy
-        fract(): NodeProxy
-        trunc(): NodeProxy
-        min(y: X): NodeProxy
-        max(y: X): NodeProxy
-        clamp(min: X, max: X): NodeProxy
-        saturate(): NodeProxy
-        mix(y: X, a: X): NodeProxy
-        step(edge: X): NodeProxy
-        smoothstep(edge0: X, edge1: X): NodeProxy
-        length(): NodeProxy
-        distance(y: X): NodeProxy
-        dot(y: X): NodeProxy
-        cross(y: X): NodeProxy
-        normalize(): NodeProxy
-        reflect(N: X): NodeProxy
-        refract(N: X, eta: X): NodeProxy
-        sign(): NodeProxy
-        oneMinus(): NodeProxy
-        reciprocal(): NodeProxy
-        negate(): NodeProxy
-        dFdx(): NodeProxy
-        dFdy(): NodeProxy
-        fwidth(): NodeProxy
+        add<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
+        sub<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
+        mul<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
+        div<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
+        mod<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
+        equal<U extends Constants>(x: X<U>): Bool
+        notEqual<U extends Constants>(x: X<U>): Bool
+        lessThan<U extends Constants>(x: X<U>): Bool
+        lessThanEqual<U extends Constants>(x: X<U>): Bool
+        greaterThan<U extends Constants>(x: X<U>): Bool
+        greaterThanEqual<U extends Constants>(x: X<U>): Bool
+        and(x: X<'bool'>): Bool
+        or(x: X<'bool'>): Bool
+        not(): Bool
+
+        // Bitwise operators
+        bitAnd(x: X<T>): NodeProxy<T>
+        bitOr(x: X<T>): NodeProxy<T>
+        bitXor(x: X<T>): NodeProxy<T>
+        bitNot(): NodeProxy<T>
+        shiftLeft<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
+        shiftRight<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
+
+        // Conversion methods
+        toBool(): Bool
+        toUint(): UInt
+        toInt(): Int
+        toFloat(): Float
+        toBvec2(): BVec2
+        toIvec2(): IVec2
+        toUvec2(): UVec2
+        toVec2(): Vec2
+        toBvec3(): BVec3
+        toIvec3(): IVec3
+        toUvec3(): UVec3
+        toVec3(): Vec3
+        toBvec4(): BVec4
+        toIvec4(): IVec4
+        toUvec4(): UVec4
+        toVec4(): Vec4
+        toColor(): Color
+        toMat2(): Mat2
+        toMat3(): Mat3
+        toMat4(): Mat4
+
+        // Mathematical function methods (preserve type functions)
+        abs(): NodeProxy<T>
+        sign(): NodeProxy<T>
+        floor(): NodeProxy<T>
+        ceil(): NodeProxy<T>
+        round(): NodeProxy<T>
+        fract(): NodeProxy<T>
+        trunc(): NodeProxy<T>
+        sin(): NodeProxy<T>
+        cos(): NodeProxy<T>
+        tan(): NodeProxy<T>
+        asin(): NodeProxy<T>
+        acos(): NodeProxy<T>
+        atan(): NodeProxy<T>
+        exp(): NodeProxy<T>
+        exp2(): NodeProxy<T>
+        log(): NodeProxy<T>
+        log2(): NodeProxy<T>
+        sqrt(): NodeProxy<T>
+        inverseSqrt(): NodeProxy<T>
+        normalize(): NodeProxy<T>
+        oneMinus(): NodeProxy<T>
+        saturate(): NodeProxy<T>
+        negate(): NodeProxy<T>
+        reciprocal(): NodeProxy<T>
+        dFdx(): NodeProxy<T>
+        dFdy(): NodeProxy<T>
+        fwidth(): NodeProxy<T>
+
+        // Scalar return functions
+        length(): Float
+        lengthSq(): Float
+        determinant(): Float
+        luminance(): Float
+
+        // Bool return functions
+        all(): Bool
+        any(): Bool
+
+        // Specific return type functions
+        cross<U extends Constants>(y: X<U>): Vec3
+
+        // Two argument functions with variable return types
+        atan2<U extends Constants>(x: X<U>): NodeProxy<T>
+        pow<U extends Constants>(y: X<U>): NodeProxy<T>
+        distance<U extends Constants>(y: X<U>): Float
+        dot<U extends Constants>(y: X<U>): Float
+        reflect<U extends Constants>(N: X<U>): NodeProxy<T>
+        refract<U extends Constants>(N: X<U>, eta: any): NodeProxy<T>
+
+        // Multi-argument functions that return highest priority type
+        min<U extends Constants>(y: X<U>): NodeProxy<InferOperator<T, U>>
+        max<U extends Constants>(y: X<U>): NodeProxy<InferOperator<T, U>>
+        mix<U extends Constants, V>(y: X<U>, a: V): NodeProxy<InferOperator<T, U>>
+        clamp<U extends Constants, V>(mix: X<U>, max: V): NodeProxy<InferOperator<T, U>>
+        step<U extends Constants>(edge: X<U>): NodeProxy<InferOperator<T, U>>
+        smoothstep<U extends Constants, V>(edge0: X<U>, edge1: V): NodeProxy<InferOperator<T, U>>
+
+        // Power functions
+        pow2(): NodeProxy<T>
+        pow3(): NodeProxy<T>
+        pow4(): NodeProxy<T>
+}
+
+type ReadNodeProxy = {
+        [K in string as K extends NodeProxyMethods ? never : K]: any
+} & {
+        [K in Swizzles]: NodeProxy<InferSwizzleType<K>>
+}
+
+// Internal NodeProxy implementation (renamed from original)
+type NodeProxyImpl<T extends Constants = string> = BaseNodeProxy<T> & ReadNodeProxy
+
+export type Bool = NodeProxyImpl<'bool'>
+export type UInt = NodeProxyImpl<'uint'>
+export type Int = NodeProxyImpl<'int'>
+export type Float = NodeProxyImpl<'float'>
+export type BVec2 = NodeProxyImpl<'bvec2'>
+export type IVec2 = NodeProxyImpl<'ivec2'>
+export type UVec2 = NodeProxyImpl<'uvec2'>
+export type Vec2 = NodeProxyImpl<'vec2'>
+export type BVec3 = NodeProxyImpl<'bvec3'>
+export type IVec3 = NodeProxyImpl<'ivec3'>
+export type UVec3 = NodeProxyImpl<'uvec3'>
+export type Vec3 = NodeProxyImpl<'vec3'>
+export type BVec4 = NodeProxyImpl<'bvec4'>
+export type IVec4 = NodeProxyImpl<'ivec4'>
+export type UVec4 = NodeProxyImpl<'uvec4'>
+export type Vec4 = NodeProxyImpl<'vec4'>
+export type Color = NodeProxyImpl<'color'>
+export type Mat2 = NodeProxyImpl<'mat2'>
+export type Mat3 = NodeProxyImpl<'mat3'>
+export type Mat4 = NodeProxyImpl<'mat4'>
+export type Texture = NodeProxyImpl<'texture'>
+export type Sampler2D = NodeProxyImpl<'sampler2D'>
+export type Struct = NodeProxyImpl<'struct'>
+
+export interface ConstantsToType {
+        bool: Bool
+        uint: UInt
+        int: Int
+        float: Float
+        bvec2: BVec2
+        ivec2: IVec2
+        uvec2: UVec2
+        vec2: Vec2
+        bvec3: BVec3
+        ivec3: IVec3
+        uvec3: UVec3
+        vec3: Vec3
+        bvec4: BVec4
+        ivec4: IVec4
+        uvec4: UVec4
+        vec4: Vec4
+        color: Color
+        mat2: Mat2
+        mat3: Mat3
+        mat4: Mat4
+        texture: Texture
+        sampler2D: Sampler2D
+        struct: Struct
 }
 
-export type NodeProxy = BaseNodeProxy & DynamicProperties
+export type NodeProxy<T extends Constants = string> = T extends keyof ConstantsToType
+        ? ConstantsToType[T]
+        : NodeProxyImpl<T>
 
-export type X = NodeProxy | number | string | boolean | undefined
+export type X<T extends Constants = string> = number | string | boolean | undefined | NodeProxy<T> | X[]