glre 0.25.0 → 0.27.0

package/README.md

@@ -115,7 +115,7 @@ npm install glre
 ```ts
 import { createRoot } from 'react-dom/client'
 import { useGL, vec4, fract, fragCoord, iResolution } from 'glre/react'
-const frag = vec4(fract(fragCoord.xy / iResolution), 0, 1)
+const frag = vec4(fract(fragCoord.xy.div(iResolution)), 0, 1)
 
 const App = () => {
         const gl = useGL({ frag })
@@ -136,11 +136,11 @@ react-native supported ([codesandbox demo](https://codesandbox.io/p/sandbox/glre
 import { GLView } from 'expo-gl'
 import { registerRootComponent } from 'expo'
 import { useGL, vec4, fract, fragCoord, iResolution } from 'glre/native'
-const frag = vec4(fract(fragCoord.xy / iResolution), 0, 1)
+const frag = vec4(fract(fragCoord.xy.div(iResolution)), 0, 1)
 
 const App = () => {
-        const { gl, ref } = useGL({ frag })
-        return <GLView style={{ flex: 1 }} onContextCreate={ref} />
+        const gl = useGL({ frag })
+        return <GLView style={{ flex: 1 }} onContextCreate={gl.ref} />
 }
 
 registerRootComponent(App)
@@ -157,7 +157,7 @@ solid js supported ([codesandbox demo](https://codesandbox.io/p/sandbox/glre-sol
 ```ts
 import { render } from 'solid-js/web'
 import { onGL, vec4, fract, fragCoord, iResolution } from 'glre/solid'
-const frag = vec4(fract(fragCoord.xy / iResolution), 0, 1)
+const frag = c4(fract(fragCoord.xy.div(iResolution)), 0, 1)
 
 const App = () => {
         const gl = onGL({ frag })
@@ -177,8 +177,9 @@ esm supported ([codesandbox demo](https://codesandbox.io/s/glre-basic-demo3-3bhr
 
 ```html
 <script type="module">
-        import { createGL, vec4, fract, fragCoord, iResolution } from 'https://esm.sh/glre'
-        const frag = vec4(fract(fragCoord.xy / iResolution), 0, 1)
+        import createGL from 'https://esm.sh/glre'
+        import { vec4, fract, fragCoord, iResolution } from 'https://esm.sh/glre'
+        const frag = vec4(fract(fragCoord.xy.div(iResolution)), 0, 1)
         function App() {
                 const el = document.createElement('canvas')
                 createGL({ el, frag }).mount()
@@ -207,7 +208,7 @@ The node system provides various types and functions that mirror GLSL functional
 import { float, int, vec2, vec3, vec4, mat3, mat4 } from 'glre'
 
 // Built-in variables
-import { fragCoord, gl_Position, iResolution, iTime } from 'glre'
+import { fragCoord, position, iResolution, iTime } from 'glre'
 
 // Math functions
 import { sin, cos, abs, pow, mix, clamp, normalize } from 'glre'

package/dist/index.d.ts

@@ -3,142 +3,200 @@ import { Queue, Frame } from 'refr';
 export { Frame, Fun, Queue } from 'refr';
 import { EventState } from 'reev';
 
-declare const TYPES: readonly ["float", "int", "uint", "bool", "color", "vec2", "vec3", "vec4", "mat2", "mat3", "mat4", "ivec2", "ivec3", "ivec4", "uvec2", "uvec3", "uvec4", "bvec2", "bvec3", "bvec4"];
-type NodeType = (typeof TYPES)[number];
 declare const SWIZZLES: readonly ["x", "y", "z", "w", "r", "g", "b", "a", "s", "t", "p", "q"];
-type AllSwizzles<T extends string> = T | `${T}${T}` | `${T}${T}${T}` | `${T}${T}${T}${T}`;
-type Swillzes = AllSwizzles<'x' | 'y' | 'z' | 'w'> | AllSwizzles<'r' | 'g' | 'b' | 'a'> | AllSwizzles<'p' | 'q'> | AllSwizzles<'s' | 't'>;
-declare const OPERATORS: readonly ["add", "sub", "mul", "div", "mod", "equal", "notEqual", "lessThan", "lessThanEqual", "greaterThan", "greaterThanEqual", "and", "or", "not", "assign", "xor", "bitAnd", "bitNot", "bitOr", "bitXor", "shiftLeft", "shiftRight"];
-type Operator = (typeof OPERATORS)[number];
+declare const NODE_TYPES: readonly ["float", "int", "uint", "bool", "color", "vec2", "vec3", "vec4", "mat2", "mat3", "mat4", "ivec2", "ivec3", "ivec4", "uvec2", "uvec3", "uvec4", "bvec2", "bvec3", "bvec4"];
+declare const OPERATORS: {
+    readonly add: "+";
+    readonly sub: "-";
+    readonly mul: "*";
+    readonly div: "/";
+    readonly mod: "%";
+    readonly equal: "==";
+    readonly notEqual: "!=";
+    readonly lessThan: "<";
+    readonly lessThanEqual: "<=";
+    readonly greaterThan: ">";
+    readonly greaterThanEqual: ">=";
+    readonly and: "&&";
+    readonly or: "||";
+    readonly bitAnd: "&";
+    readonly bitOr: "|";
+    readonly bitXor: "^";
+    readonly shiftLeft: "<<";
+    readonly shiftRight: ">>";
+};
+declare const OPERATOR_KEYS: (keyof typeof OPERATORS)[];
 declare const FUNCTIONS: readonly ["abs", "acos", "asin", "atan", "atan2", "ceil", "clamp", "cos", "cross", "degrees", "distance", "dot", "exp", "exp2", "faceforward", "floor", "fract", "length", "all", "any", "bitcast", "cbrt", "dFdx", "dFdy", "difference", "equals", "fwidth", "inverseSqrt", "lengthSq", "log", "log2", "max", "min", "mix", "negate", "normalize", "oneMinus", "pow", "pow2", "pow3", "pow4", "radians", "reciprocal", "reflect", "refract", "round", "saturate", "sign", "sin", "smoothstep", "sqrt", "step", "tan", "transformDirection", "trunc"];
-type MathFunction = (typeof FUNCTIONS)[number];
-declare const CACHE_BOOLS: readonly [true, false];
-declare const CACHE_INTS: readonly [0, 1, 2, 3, 4, 5];
-declare const CACHE_FLOATS: readonly [0, 1, 0.5, 2];
-
-interface Node {
-    id: string;
-    type: NodeType;
-    value?: any;
-    property?: string;
-    parent?: Node;
-    children?: Node[];
-    operator?: Operator;
-    mathFunction?: MathFunction;
-}
-interface ProxyCallback {
-    path: string[];
-    args: any[];
-}
-type NodeCreator = (value?: any) => X;
-interface OperatorMethods {
-    add(x: X | number): X;
-    sub(x: X | number): X;
-    mul(x: X | number): X;
-    div(x: X | number): X;
-    mod(x: X | number): X;
-    equal(x: X | number): X;
-    notEqual(x: X | number): X;
-    lessThan(x: X | number): X;
-    lessThanEqual(x: X | number): X;
-    greaterThan(x: X | number): X;
-    greaterThanEqual(x: X | number): X;
-    and(x: X): X;
-    or(x: X): X;
-    not(): X;
-}
-interface MathMethods {
-    abs(): X;
-    acos(): X;
-    asin(): X;
-    atan(): X;
-    ceil(): X;
-    cos(): X;
-    floor(): X;
-    fract(): X;
-    length(): X;
-    normalize(): X;
-    sin(): X;
-    sqrt(): X;
-    tan(): X;
-    toVar(): X;
-}
-type SwizzleProperties = {
-    [k in Swillzes]: X;
+declare const TYPE_MAPPING: {
+    readonly float: "f32";
+    readonly int: "i32";
+    readonly uint: "u32";
+    readonly bool: "bool";
+    readonly vec2: "vec2f";
+    readonly vec3: "vec3f";
+    readonly vec4: "vec4f";
+    readonly mat2: "mat2x2f";
+    readonly mat3: "mat3x3f";
+    readonly mat4: "mat4x4f";
+    readonly ivec2: "vec2i";
+    readonly ivec3: "vec3i";
+    readonly ivec4: "vec4i";
+    readonly uvec2: "vec2u";
+    readonly uvec3: "vec3u";
+    readonly uvec4: "vec4u";
+    readonly bvec2: "vec2<bool>";
+    readonly bvec3: "vec3<bool>";
+    readonly bvec4: "vec4<bool>";
 };
-interface X extends MathMethods, OperatorMethods, SwizzleProperties {
-    readonly id: string;
-    readonly type: NodeType;
-    readonly value: any;
-    readonly property: string;
-    (...args: any[]): X;
-}
-interface UniformNode extends X {
-    set(value: any): void;
-    onObjectUpdate(callback: (context: any) => any): UniformNode;
-    onRenderUpdate(callback: (context: any) => any): UniformNode;
-}
-interface FunctionNode {
-    (...args: any[]): X;
-    call(x: X[]): X;
+
+type NodeType = (typeof NODE_TYPES)[number];
+type Functions = (typeof FUNCTIONS)[number];
+type Operators = (typeof OPERATOR_KEYS)[number];
+interface NodeProps {
+    id?: string;
+    children?: X[];
+    defaultValue?: number | number[];
 }
-interface ConditionalNode {
-    ElseIf(condition: X, callback: () => void): ConditionalNode;
-    Else(callback: () => void): void;
+interface NodeConfig {
+    isWebGL?: boolean;
+    uniforms?: Set<string>;
+    onUniform?: (name: string, value: any) => void;
 }
-interface ConversionContext {
-    target: 'webgl' | 'webgpu';
-    nodes: Map<string, Node>;
-    variables: Map<string, string>;
-    functions: Map<string, string>;
+type _Swizzles<T extends string> = T | `${T}${T}` | `${T}${T}${T}` | `${T}${T}${T}${T}`;
+type Swizzles = _Swizzles<'x' | 'y' | 'z' | 'w'> | _Swizzles<'r' | 'g' | 'b' | 'a'> | _Swizzles<'p' | 'q'> | _Swizzles<'s' | 't'>;
+type NodeTypes = 'uniform' | 'variable' | 'swizzle' | 'operator' | 'node_type' | 'math_fun' | 'declare' | 'assign' | 'fn' | 'if' | 'loop' | 'scope';
+interface NodeProxy extends Record<Swizzles, NodeProxy> {
+    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;
+    assign(n: X): NodeProxy;
+    toVar(name?: string): NodeProxy;
+    toString(c?: NodeConfig): string;
+    type: NodeTypes;
+    props: NodeProps;
+    isProxy: true;
 }
+type X = NodeProxy | number | string | null | undefined;
 
-declare const getCachedBool: (x: boolean) => X;
-declare const getCachedInt: (x: number) => X;
-declare const getCachedFloat: (x: number) => X;
-declare const findDuplicateNodes: (nodes: X[]) => Map<string, X[]>;
+declare const code: (target: X, c?: NodeConfig | null) => string;
 
-declare const convertToNode: (x: unknown) => X;
-declare const float: (x: unknown) => X;
-declare const int: (x: unknown) => X;
-declare const bool: (x: unknown) => X;
-declare const vec2: (x?: any, y?: any) => X;
-declare const vec3: (x?: any, y?: any, z?: any) => X;
-declare const vec4: (x?: any, y?: any, z?: any, w?: any) => X;
-declare const color: (r?: any, g?: any, b?: any) => X;
+declare const node: (type: NodeTypes, props?: NodeProps | null, ...args: X[]) => NodeProxy;
+declare const v: (...args: X[]) => NodeProxy;
+declare const u: (key: string, defaultValue?: number | number[]) => NodeProxy;
+declare const s: (key: Swizzles, arg: X) => NodeProxy;
+declare const n: (key: string, ...args: X[]) => NodeProxy;
+declare const o: (key: Operators, ...args: X[]) => NodeProxy;
+declare const f: (key: Functions, ...args: X[]) => NodeProxy;
 
-declare const createNode: (type: NodeType, value?: any, options?: Partial<Node>) => Node;
-declare const node: (type: NodeType, value?: any, options?: Partial<Node>) => X;
+declare const If: (x: X, callback: () => void) => {
+    ElseIf: (y: X, elseCallback: () => void) => void;
+    Else: (elseCallback: () => void) => void;
+};
+declare const Loop: (x: X, callback?: (params: {
+    i: NodeProxy;
+}) => void) => NodeProxy;
+declare const Fn: (callback: (args: X[]) => NodeProxy) => (...args: X[]) => NodeProxy;
+declare const toVar: (x: X) => (id: string) => NodeProxy;
+declare const assign: (x: X) => (y: X) => X;
 
-interface UpdateContext {
-    object?: any;
-    camera?: any;
-    renderer?: any;
-    scene?: any;
-    time?: number;
-}
-declare const uniform: (initialValue: any) => UniformNode;
-declare const iPrevTime: UniformNode;
-declare const iDeltaTime: UniformNode;
-declare const updateUniforms: (context: UpdateContext) => void;
+declare const isSwizzle: (key: unknown) => key is Swizzles;
+declare const isOperator: (key: unknown) => key is Operators;
+declare const isNodeType: (key: unknown) => key is NodeType;
+declare const isFunction: (key: unknown) => key is Functions;
+declare const getId: () => string;
+declare const joins: (children: X[], c: NodeConfig) => string;
+declare const inferType: (target: X, c: NodeConfig) => string;
+declare const fragment: (x: X, c: NodeConfig) => string;
+declare const vertex: (x: X, c: NodeConfig) => string;
 
-declare const Fn: (jsFunc: Function) => FunctionNode;
-declare const If: (condition: X, callback: () => void) => ConditionalNode;
-declare const fragCoord: X;
-declare const position: X;
-declare const iTime: UniformNode;
-declare const iResolution: UniformNode;
-declare const iMouse: UniformNode;
-declare const abs: (x: X) => X;
-declare const sin: (x: X) => X;
-declare const cos: (x: X) => X;
-declare const tan: (x: X) => X;
-declare const sqrt: (x: X) => X;
-declare const floor: (x: X) => X;
-declare const ceil: (x: X) => X;
-declare const fract: (x: X) => X;
-declare const normalize: (x: X) => X;
-declare const length: (x: X) => X;
+declare const iResolution: NodeProxy;
+declare const iMouse: NodeProxy;
+declare const iTime: NodeProxy;
+declare const fragCoord: NodeProxy;
+declare const float: (x: X) => NodeProxy;
+declare const int: (x: X) => NodeProxy;
+declare const uint: (x: X) => NodeProxy;
+declare const bool: (x: X) => NodeProxy;
+declare const vec2: (x?: X, y?: X) => NodeProxy;
+declare const vec3: (x?: X, y?: X, z?: X) => NodeProxy;
+declare const vec4: (x?: X, y?: X, z?: X, w?: X) => NodeProxy;
+declare const mat2: (...args: X[]) => NodeProxy;
+declare const mat3: (...args: X[]) => NodeProxy;
+declare const mat4: (...args: X[]) => NodeProxy;
+declare const ivec2: (x?: X, y?: X) => NodeProxy;
+declare const ivec3: (x?: X, y?: X, z?: X) => NodeProxy;
+declare const ivec4: (x?: X, y?: X, z?: X, w?: X) => NodeProxy;
+declare const uvec2: (x?: X, y?: X) => NodeProxy;
+declare const uvec3: (x?: X, y?: X, z?: X) => NodeProxy;
+declare const uvec4: (x?: X, y?: X, z?: X, w?: X) => NodeProxy;
+declare const bvec2: (x?: X, y?: X) => NodeProxy;
+declare const bvec3: (x?: X, y?: X, z?: X) => NodeProxy;
+declare const bvec4: (x?: X, y?: X, z?: X, w?: X) => NodeProxy;
+declare const abs: (x: X) => NodeProxy;
+declare const acos: (x: X) => NodeProxy;
+declare const all: (x: X) => NodeProxy;
+declare const any: (x: X) => NodeProxy;
+declare const asin: (x: X) => NodeProxy;
+declare const atan: (y: X, x: X) => NodeProxy;
+declare const bitcast: (x: X, y: X) => NodeProxy;
+declare const cbrt: (x: X) => NodeProxy;
+declare const ceil: (x: X) => NodeProxy;
+declare const clamp: (x: X, min: X, max: X) => NodeProxy;
+declare const cos: (x: X) => NodeProxy;
+declare const cross: (x: X, y: X) => NodeProxy;
+declare const dFdx: (p: X) => NodeProxy;
+declare const dFdy: (p: X) => NodeProxy;
+declare const degrees: (radians: X) => NodeProxy;
+declare const difference: (x: X, y: X) => NodeProxy;
+declare const distance: (x: X, y: X) => NodeProxy;
+declare const dot: (x: X, y: X) => NodeProxy;
+declare const equals: (x: X, y: X) => NodeProxy;
+declare const exp: (x: X) => NodeProxy;
+declare const exp2: (x: X) => NodeProxy;
+declare const faceforward: (N: X, I: X, Nref: X) => NodeProxy;
+declare const floor: (x: X) => NodeProxy;
+declare const fract: (x: X) => NodeProxy;
+declare const fwidth: (x: X) => NodeProxy;
+declare const inverseSqrt: (x: X) => NodeProxy;
+declare const length: (x: X) => NodeProxy;
+declare const lengthSq: (x: X) => NodeProxy;
+declare const log: (x: X) => NodeProxy;
+declare const log2: (x: X) => NodeProxy;
+declare const max: (x: X, y: X) => NodeProxy;
+declare const min: (x: X, y: X) => NodeProxy;
+declare const mix: (x: X, y: X, a: X) => NodeProxy;
+declare const negate: (x: X) => NodeProxy;
+declare const normalize: (x: X) => NodeProxy;
+declare const oneMinus: (x: X) => NodeProxy;
+declare const pow: (x: X, y: X) => NodeProxy;
+declare const pow2: (x: X) => NodeProxy;
+declare const pow3: (x: X) => NodeProxy;
+declare const pow4: (x: X) => NodeProxy;
+declare const radians: (degrees: X) => NodeProxy;
+declare const reciprocal: (x: X) => NodeProxy;
+declare const reflect: (I: X, N: X) => NodeProxy;
+declare const refract: (I: X, N: X, eta: X) => NodeProxy;
+declare const round: (x: X) => NodeProxy;
+declare const saturate: (x: X) => NodeProxy;
+declare const sign: (x: X) => NodeProxy;
+declare const sin: (x: X) => NodeProxy;
+declare const smoothstep: (e0: X, e1: X, x: X) => NodeProxy;
+declare const sqrt: (x: X) => NodeProxy;
+declare const step: (edge: X, x: X) => NodeProxy;
+declare const tan: (x: X) => NodeProxy;
+declare const transformDirection: (dir: X, matrix: X) => NodeProxy;
+declare const trunc: (x: X) => NodeProxy;
 
 type GPUContext = any;
 type GPUDevice = any;
@@ -158,12 +216,10 @@ interface WebGLState {
     program: WebGLProgram;
 }
 interface WebGPUState {
-    uniforms: any;
-    textures: any;
     device: GPUDevice;
     context: GPUContext;
-    groups: any[];
     pipeline: GPUPipeline;
+    groups: any[];
     resources: any[];
     loadingImg: number;
     needsUpdate: boolean;
@@ -226,26 +282,6 @@ type GL = EventState<{
     }): GL;
 }>;
 
-interface GLSLContext extends ConversionContext {
-    target: 'webgl';
-    precision: 'lowp' | 'mediump' | 'highp';
-    version: '100' | '300 es';
-}
-declare const nodeToGLSL: (nodeProxy: X, context?: Partial<GLSLContext>) => string;
-declare const glsl: (fragmentNode: X, options?: {
-    precision?: "lowp" | "mediump" | "highp";
-    version?: "100" | "300 es";
-    uniforms?: Record<string, any>;
-}) => string;
-
-interface WGSLContext extends ConversionContext {
-    target: 'webgpu';
-}
-declare const nodeToWGSL: (nodeProxy: X, context?: Partial<WGSLContext>) => string;
-declare const wgsl: (fragmentNode: X, options?: {
-    uniforms?: Record<string, any>;
-}) => string;
-
 declare const is: {
     arr: (arg: any) => arg is any[];
     bol: (a: unknown) => a is boolean;
@@ -278,12 +314,15 @@ declare const fig: (x?: number) => number;
 declare const dig: (x?: number) => number;
 declare const sig: (value?: number, digit?: number) => number;
 
-declare const createDevive: (c: GPUContext) => Promise<{
+declare const createDevice: (c: GPUContext) => Promise<{
     device: any;
     format: any;
 }>;
-declare const createPipeline: (device: GPUDevice, format: string, buffers: any[], layouts: any[], vs?: string | X, fs?: string | X) => GPUPipeline;
-declare const createBindGroup: (device: GPUDevice, resources: any[]) => any[];
+declare const createPipeline: (device: GPUDevice, format: string, bufferLayouts: any[], bindGroupLayouts: any[], vs?: string | X, fs?: string | X) => GPUPipeline;
+declare const createBindGroup: (device: GPUDevice, resources: any[]) => {
+    layout: any;
+    bindGroup: any;
+};
 declare const createDescriptor: (c: GPUContext) => {
     colorAttachments: {
         view: any;
@@ -298,15 +337,30 @@ declare const createDescriptor: (c: GPUContext) => {
     }[];
 };
 declare const alignTo256: (size: number) => number;
+declare const createVertexBuffer: (device: GPUDevice, value: number[]) => {
+    array: Float32Array<ArrayBuffer>;
+    buffer: any;
+};
 declare const createUniformBuffer: (device: GPUDevice, value: number[]) => {
     array: Float32Array<ArrayBuffer>;
     buffer: Buffer;
 };
-declare const createTextureSampler: (device: GPUDevice, width?: number, height?: number) => readonly [any, any];
+declare const createTextureSampler: (device: GPUDevice, width?: number, height?: number) => {
+    texture: any;
+    sampler: any;
+};
+declare const createBufferLayout: (shaderLocation: number, dataLength: number, count?: number) => {
+    arrayStride: number;
+    attributes: {
+        shaderLocation: number;
+        offset: number;
+        format: string;
+    }[];
+};
 
 declare const defaultVertexGLSL = "\n#version 300 es\nvoid main() {\n  float x = float(gl_VertexID % 2) * 4.0 - 1.0;\n  float y = float(gl_VertexID / 2) * 4.0 - 1.0;\n  gl_Position = vec4(x, y, 0.0, 1.0);\n}\n";
 declare const defaultFragmentGLSL = "\n#version 300 es\nprecision mediump float;\nuniform vec2 iResolution;\nout vec4 fragColor;\nvoid main() {\n  fragColor = vec4(fract(gl_FragCoord.xy / iResolution), 0, 1);\n}\n";
-declare const createProgram: (c: WebGLRenderingContext, vs?: string | X, fs?: string | X) => WebGLProgram;
+declare const createProgram: (c: WebGLRenderingContext, vs?: string | X, fs?: string | X) => WebGLProgram | undefined;
 declare const createVbo: (c: WebGLRenderingContext, data: number[]) => WebGLBuffer;
 declare const createIbo: (c: WebGLRenderingContext, data: number[]) => WebGLBuffer;
 declare const getStride: (count: number, value: number[], iboValue?: number[]) => number;
@@ -319,7 +373,7 @@ declare const webgl: (gl: Partial<GL>) => Promise<{
     clean: () => void;
     _attribute: (key: string | undefined, value: number[], iboValue: number[]) => void;
     _uniform: (key: string, value: number | number[]) => void;
-    _texture: (alt: string, src: string) => void;
+    _texture: (key: string, src: string) => void;
 }>;
 
 declare const webgpu: (gl: Partial<GL>) => Promise<{
@@ -380,4 +434,4 @@ declare const createGL: (props?: Partial<GL>) => EventState<{
     }): GL;
 }, any[] | unknown[]>;
 
-export { Attribute, Attributes, CACHE_BOOLS, CACHE_FLOATS, CACHE_INTS, ConditionalNode, ConversionContext, FUNCTIONS, Fn, FunctionNode, GL, GLClearMode, GLDrawMode, GLDrawType, GPUBindGroup, GPUBuffer, GPUContext, GPUDevice, GPUPipeline, If, MathFunction, MathMethods, Node, NodeCreator, NodeType, OPERATORS, Operator, OperatorMethods, PrecisionMode, ProxyCallback, SWIZZLES, Swillzes, SwizzleProperties, TYPES, Uniform, UniformNode, Uniforms, WebGLState, WebGPUState, X, abs, alignTo256, bool, ceil, color, convertToNode, cos, createAttrib, createBindGroup, createDescriptor, createDevive, createGL, createIbo, createNode, createPipeline, createProgram, createTexture, createTextureSampler, createUniformBuffer, createVbo, createGL as default, defaultFragmentGLSL, defaultVertexGLSL, dig, each, ext, fig, findDuplicateNodes, float, floor, flush, fract, fragCoord, getCachedBool, getCachedFloat, getCachedInt, getStride, glsl, iDeltaTime, iMouse, iPrevTime, iResolution, iTime, int, is, isGL, isServer, isWebGPUSupported, length, node, nodeToGLSL, nodeToWGSL, normalize, position, replace, sig, sin, sqrt, tan, uniform, updateUniforms, vec2, vec3, vec4, webgl, webgpu, wgsl };
+export { type Attribute, type Attributes, FUNCTIONS, Fn, type Functions, type GL, type GLClearMode, type GLDrawMode, type GLDrawType, type GPUBindGroup, type GPUBuffer, type GPUContext, type GPUDevice, type GPUPipeline, If, Loop, NODE_TYPES, type NodeConfig, type NodeProps, type NodeProxy, type NodeType, type NodeTypes, OPERATORS, OPERATOR_KEYS, type Operators, type PrecisionMode, SWIZZLES, type Swizzles, TYPE_MAPPING, type Uniform, type Uniforms, type WebGLState, type WebGPUState, type X, abs, acos, alignTo256, all, any, asin, assign, atan, bitcast, bool, bvec2, bvec3, bvec4, cbrt, ceil, clamp, code, cos, createAttrib, createBindGroup, createBufferLayout, createDescriptor, createDevice, createGL, createIbo, createPipeline, createProgram, createTexture, createTextureSampler, createUniformBuffer, createVbo, createVertexBuffer, cross, dFdx, dFdy, createGL as default, defaultFragmentGLSL, defaultVertexGLSL, degrees, difference, dig, distance, dot, each, equals, exp, exp2, ext, f, faceforward, fig, float, floor, flush, fract, fragCoord, fragment, fwidth, getId, getStride, iMouse, iResolution, iTime, inferType, int, inverseSqrt, is, isFunction, isGL, isNodeType, isOperator, isServer, isSwizzle, isWebGPUSupported, ivec2, ivec3, ivec4, joins, length, lengthSq, log, log2, mat2, mat3, mat4, max, min, mix, n, negate, node, normalize, o, oneMinus, pow, pow2, pow3, pow4, radians, reciprocal, reflect, refract, replace, round, s, saturate, sig, sign, sin, smoothstep, sqrt, step, tan, toVar, transformDirection, trunc, u, uint, uvec2, uvec3, uvec4, v, vec2, vec3, vec4, vertex, webgl, webgpu };