glre 0.36.0 → 0.38.0

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,12 +18,18 @@ 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
         | 'attribute'
+        | 'storage'
         | 'uniform'
         | 'constant'
         // variables
@@ -35,6 +44,8 @@ export type NodeTypes =
         | 'struct'
         | 'member'
         | 'element'
+        | 'gather'
+        | 'scatter'
         // scopes
         | 'scope'
         | 'assign'
@@ -45,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
@@ -53,15 +64,15 @@ 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 {
         gl?: Partial<GL>
-        isFrag?: boolean
+        label?: 'vert' | 'frag' | 'compute'
         isWebGL?: boolean
-        binding?: number
+        units?: any // @TODO FIX
         infers?: WeakMap<NodeProxy, Constants>
         onMount?: (name: string) => void
         code?: {
@@ -70,7 +81,9 @@ export interface NodeContext {
                 vertInputs: Map<string, string>
                 vertOutputs: Map<string, string>
                 vertVaryings: Map<string, string>
+                computeInputs: Map<string, string>
                 dependencies: Map<string, Set<string>>
+                structFields: Map<string, StructFields>
         }
 }
 
@@ -140,6 +153,7 @@ type NodeProxyMethods =
         | Conversions
         | Swizzles
         // system property
+        | '__nodeType'
         | 'type'
         | 'props'
         | 'isProxy'
@@ -148,8 +162,86 @@ type NodeProxyMethods =
         | 'toString'
         | 'element'
 
+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> = BaseNodeProxy<T> & ReadNodeProxy
+
+export type Void = NodeProxyImpl<'void'>
+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 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
+        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<T extends Constants = Constants> = T extends keyof ConstantsToType
+        ? ConstantsToType[T]
+        : BaseNodeProxy<T>
+
+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
@@ -158,6 +250,14 @@ export interface BaseNodeProxy<T extends Constants> {
         isProxy: true
         listeners: Set<(value: any) => void>
 
+        // 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>>
@@ -204,134 +304,83 @@ export interface BaseNodeProxy<T extends Constants> {
         toMat3(): Mat3
         toMat4(): Mat4
 
-        // Mathematical function methods (preserve type functions)
+        /**
+         * 3.1. unified logic with:
+         * 1.1. index.ts functions and
+         * 2.1. const.ts FUNCTION_RETURN_TYPES
+         */
+        // 0. Always return bool
+        all(): Bool
+        any(): Bool
+        // 2. Always return float
+        determinant(): Float
+        distance<U extends Constants>(y: X<U>): Float
+        dot<U extends Constants>(y: X<U>): Float
+        length(): Float
+        lengthSq(): Float
+        luminance(): Float
+        // 3. Always return vec3
+        cross<U extends Constants>(y: X<U>): Vec3
+        // 4. Always return vec4
+        cubeTexture(...args: X[]): Vec4
+        texture(...args: X[]): Vec4
+        texelFetch(...args: X[]): Vec4
+        textureLod(...args: X[]): Vec4
+
+        /**
+         * 3.1. unified with:
+         * 1.1. index.ts functions and
+         * 2.1. const.ts FUNCTIONS
+         */
+        // 0. Component-wise 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>
+        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>
-        sqrt(): NodeProxy<T>
-        inverseSqrt(): NodeProxy<T>
+        negate(): NodeProxy<T>
         normalize(): NodeProxy<T>
         oneMinus(): NodeProxy<T>
-        saturate(): NodeProxy<T>
-        negate(): NodeProxy<T>
+        radians(): 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
+        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>
 
-        // Two argument functions with variable return types
+        // 1. Functions where first argument determines return type
         atan2<U extends Constants>(x: X<U>): NodeProxy<T>
+        clamp<U extends Constants, V>(mix: X<U>, max: V): NodeProxy<InferOperator<T, U>>
+        max<U extends Constants>(y: X<U>): NodeProxy<InferOperator<T, U>>
+        min<U extends Constants>(y: X<U>): NodeProxy<InferOperator<T, U>>
+        mix<U extends Constants, V>(y: X<U>, a: V): NodeProxy<InferOperator<T, U>>
         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>>
+        // 2. Functions where not first argument determines return type
         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>
-
-        // Element access for array/matrix types
-        element<Index extends X>(index: Index): NodeProxy<InferArrayElement<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
+        step<U extends Constants>(edge: X<U>): NodeProxy<InferOperator<T, U>>
+        // @NOTE: mod is operator
 }
-
-export type NodeProxy<T extends Constants = string> = T extends keyof ConstantsToType
-        ? ConstantsToType[T]
-        : NodeProxyImpl<T>
-
-export type X<T extends Constants = string> = number | string | boolean | undefined | NodeProxy<T> | X[]

package/src/node/utils/const.ts

@@ -1,5 +1,30 @@
 export const SWIZZLES = ['x', 'y', 'z', 'w', 'r', 'g', 'b', 'a', 's', 't', 'p', 'q'] as const
 
+// Unified order with TYPE_MAPPING array
+export const CONVERSIONS = [
+        'toBool',
+        'toUint',
+        'toInt',
+        'toFloat',
+        'toBvec2',
+        'toIvec2',
+        'toUvec2',
+        'toVec2',
+        'toBvec3',
+        'toIvec3',
+        'toUvec3',
+        'toVec3',
+        'toBvec4',
+        'toIvec4',
+        'toUvec4',
+        'toVec4',
+        'toColor',
+        'toMat2',
+        'toMat3',
+        'toMat4',
+] as const
+
+// Unified order with CONVERSIONS array
 export const TYPE_MAPPING = {
         bool: 'bool',
         uint: 'u32',
@@ -26,32 +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 CONVERSIONS = [
-        'toBool',
-        'toUint',
-        'toInt',
-        'toFloat',
-        'toBvec2',
-        'toIvec2',
-        'toUvec2',
-        'toVec2',
-        'toBvec3',
-        'toIvec3',
-        'toUvec3',
-        'toVec3',
-        'toBvec4',
-        'toIvec4',
-        'toUvec4',
-        'toVec4',
-        'toColor',
-        'toMat2',
-        'toMat3',
-        'toMat4',
-] as const
+export const CONSTANTS = Object.keys(TYPE_MAPPING) as (keyof typeof TYPE_MAPPING)[]
 
 export const OPERATORS = {
+        not: '', // IGNORED
         add: '+',
         sub: '-',
         mul: '*',
@@ -74,84 +77,6 @@ export const OPERATORS = {
 
 export const OPERATOR_KEYS = Object.keys(OPERATORS) as (keyof typeof OPERATORS)[]
 
-// 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',
-        'ceil',
-        'round',
-        'fract',
-        'trunc',
-        'sin',
-        'cos',
-        'tan',
-        'asin',
-        'acos',
-        'atan',
-        'sinh',
-        'cosh',
-        'tanh',
-        'asinh',
-        'acosh',
-        'atanh',
-        'exp',
-        'exp2',
-        'log',
-        'log2',
-        'sqrt',
-        'inverseSqrt',
-        'normalize',
-        'oneMinus',
-        'saturate',
-        'negate',
-        'reciprocal',
-        'dFdx',
-        'dFdy',
-        'fwidth',
-        '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',
-        'pow2',
-        'pow3',
-        'pow4',
-        'transformDirection',
-] as const
-
 export const COMPONENT_COUNT_TO_TYPE = {
         1: 'float',
         2: 'vec2',
@@ -161,24 +86,6 @@ 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',
@@ -189,6 +96,7 @@ export const BUILTIN_TYPES = {
         sample_index: 'uint',
         sample_mask: 'uint',
         point_coord: 'vec2',
+        global_invocation_id: 'uvec3',
 
         // TSL compatible variables
         positionLocal: 'vec3',
@@ -238,3 +146,88 @@ export const WGSL_TO_GLSL_BUILTIN = {
         point_coord: 'gl_PointCoord',
         uv: 'gl_FragCoord.xy',
 } as const
+
+/**
+ * 2.1. unified with:
+ * 1.1. index.ts functions and
+ * 3.1. types.ts BaseNodeProxy
+ */
+// Function return type mapping for method chaining
+export const FUNCTION_RETURN_TYPES = {
+        // 0. Always return bool
+        all: 'bool',
+        any: 'bool',
+        // 2. Always return float
+        determinant: 'float',
+        distance: 'float',
+        dot: 'float',
+        length: 'float',
+        lengthSq: 'float',
+        luminance: 'float',
+        // 3. Always return vec3
+        cross: 'vec3',
+        // 4. Always return vec4
+        cubeTexture: 'vec4',
+        texture: 'vec4',
+        texelFetch: 'vec4',
+        textureLod: 'vec4',
+} as const
+
+/**
+ * 2.2. unified with:
+ * 1.2. index.ts functions and
+ * 3.2. types.ts BaseNodeProxy
+ */
+// All shader functions (type inference now handled by inferFrom)
+export const FUNCTIONS = [
+        ...(Object.keys(FUNCTION_RETURN_TYPES) as (keyof typeof FUNCTION_RETURN_TYPES)[]),
+        // 0. Component-wise functions
+        'abs',
+        'acos',
+        'acosh',
+        'asin',
+        'asinh',
+        'atan',
+        'atanh',
+        'ceil',
+        'cos',
+        'cosh',
+        'dFdx',
+        'dFdy',
+        'degrees',
+        'exp',
+        'exp2',
+        'floor',
+        'fract',
+        'fwidth',
+        'inverseSqrt',
+        'log',
+        'log2',
+        'negate',
+        'normalize',
+        'oneMinus',
+        'radians',
+        'reciprocal',
+        'round',
+        'saturate',
+        'sign',
+        'sin',
+        'sinh',
+        'sqrt',
+        'tan',
+        'tanh',
+        'trunc',
+        // 1. Functions where first argument determines return type
+        'atan2',
+        'clamp',
+        'max',
+        'min',
+        'mix',
+        'pow',
+        'reflect',
+        'refract',
+        // 2. Functions where not first argument determines return type
+        'smoothstep',
+        'step',
+        // @NOTE: mod is operator
+] as const