glre 0.35.0 → 0.37.0

package/src/node/types.ts

@@ -1,13 +1,9 @@
-import { GL } from '../types'
-
-import { CONSTANTS, CONVERSIONS, FUNCTIONS, OPERATOR_KEYS } from './const'
+import { CONSTANTS, CONVERSIONS, FUNCTIONS, OPERATOR_KEYS } from './utils/const'
+import type { GL } from '../types'
 
 export type Constants = (typeof CONSTANTS)[number] | 'void'
-
 export type Conversions = (typeof CONVERSIONS)[number]
-
 export type Functions = (typeof FUNCTIONS)[number]
-
 export type Operators = (typeof OPERATOR_KEYS)[number]
 
 export interface FnLayout {
@@ -25,6 +21,7 @@ export interface FnLayout {
 export type NodeTypes =
         // headers
         | 'attribute'
+        | 'storage'
         | 'uniform'
         | 'constant'
         // variables
@@ -38,6 +35,9 @@ export type NodeTypes =
         // struct
         | 'struct'
         | 'member'
+        | 'element'
+        | 'gather'
+        | 'scatter'
         // scopes
         | 'scope'
         | 'assign'
@@ -55,7 +55,6 @@ export interface NodeProps<T extends Record<string, NodeProxy> = {}> {
         children?: any[]
         inferFrom?: any[]
         layout?: FnLayout
-        parent?: NodeProxy
         // for struct
         fields?: T
         initialValues?: T
@@ -63,9 +62,9 @@ export interface NodeProps<T extends Record<string, NodeProxy> = {}> {
 
 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?: {
@@ -74,6 +73,7 @@ export interface NodeContext {
                 vertInputs: Map<string, string>
                 vertOutputs: Map<string, string>
                 vertVaryings: Map<string, string>
+                computeInputs: Map<string, string>
                 dependencies: Map<string, Set<string>>
         }
 }
@@ -81,6 +81,20 @@ export interface NodeContext {
 /**
  * infer
  */
+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
+
 // Unified logic with infer.ts inferOperator function
 // prettier-ignore
 type InferOperator<L extends Constants, R extends Constants> =
@@ -97,19 +111,13 @@ type InferOperator<L extends Constants, R extends Constants> =
         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
+// Unified logic with infer.ts inferArrayElement function
+// prettier-ignore
+type InferArrayElement<T extends Constants> =
+        T extends 'mat4' ? 'vec4' :
+        T extends 'mat3' ? 'vec3' :
+        T extends 'mat2' ? 'vec2' :
+        'float'
 
 type InferSwizzleType<S extends string> = _StringLength<S> extends 4
         ? 'vec4'
@@ -142,6 +150,72 @@ type NodeProxyMethods =
         | 'assign'
         | 'toVar'
         | '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 = 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<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[]
 
 export interface BaseNodeProxy<T extends Constants> {
         // System properties
@@ -153,6 +227,9 @@ 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>>
+
         // Operators methods
         add<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
         sub<U extends Constants>(x: X<U>): NodeProxy<InferOperator<T, U>>
@@ -199,131 +276,83 @@ export interface BaseNodeProxy<T extends Constants> {
         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
+        /**
+         * 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
-        determinant(): Float
         luminance(): Float
-
-        // Bool return functions
-        all(): Bool
-        any(): Bool
-
-        // Specific return type functions
+        // 3. Always return vec3
         cross<U extends Constants>(y: X<U>): Vec3
-
-        // Two argument functions with variable return types
+        // 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
+        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
+
+        // 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>
-}
-
-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/{const.ts → 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',
@@ -28,29 +53,6 @@ export const TYPE_MAPPING = {
 
 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 OPERATORS = {
         add: '+',
         sub: '-',
@@ -74,84 +76,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 +85,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 +95,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 +145,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