glre 0.31.0 → 0.32.0

package/dist/{index.d.cts → index.d.ts}

@@ -1,10 +1,9 @@
 import * as refr from 'refr';
 import { Queue, Frame } from 'refr';
 export { Frame, Fun, Queue } from 'refr';
-import { EventState } from 'reev';
+import { Nested, EventState } from 'reev';
 
-declare const SWIZZLES: readonly ["x", "y", "z", "w", "r", "g", "b", "a", "s", "t", "p", "q"];
-declare const CONSTANTS: readonly ["bool", "uint", "int", "float", "bvec2", "ivec2", "uvec2", "vec2", "bvec3", "ivec3", "uvec3", "vec3", "bvec4", "ivec4", "uvec4", "vec4", "color", "mat2", "mat3", "mat4"];
+declare const CONSTANTS: readonly ["bool", "uint", "int", "float", "bvec2", "ivec2", "uvec2", "vec2", "bvec3", "ivec3", "uvec3", "vec3", "bvec4", "ivec4", "uvec4", "vec4", "color", "mat2", "mat3", "mat4", "texture", "sampler2D"];
 declare const CONVERSIONS: readonly ["toBool", "toUint", "toInt", "toFloat", "toBvec2", "toIvec2", "toUvec2", "toVec2", "toBvec3", "toIvec3", "toUvec3", "toVec3", "toBvec4", "toIvec4", "toUvec4", "toVec4", "toColor", "toMat2", "toMat3", "toMat4"];
 declare const OPERATORS: {
     readonly add: "+";
@@ -27,86 +26,7 @@ declare const OPERATORS: {
     readonly shiftRight: ">>";
 };
 declare const OPERATOR_KEYS: (keyof typeof OPERATORS)[];
-declare const SCALAR_RETURN_FUNCTIONS: readonly ["dot", "distance", "length", "lengthSq", "determinant", "luminance"];
-declare const BOOL_RETURN_FUNCTIONS: readonly ["all", "any"];
-declare const PRESERVE_TYPE_FUNCTIONS: readonly ["abs", "sign", "floor", "ceil", "round", "fract", "trunc", "sin", "cos", "tan", "asin", "acos", "atan", "exp", "exp2", "log", "log2", "sqrt", "inverseSqrt", "normalize", "oneMinus", "saturate", "negate", "reciprocal", "dFdx", "dFdy", "fwidth"];
-declare const VEC3_RETURN_FUNCTIONS: readonly ["cross"];
-declare const FIRST_ARG_TYPE_FUNCTIONS: readonly ["reflect", "refract"];
-declare const HIGHEST_TYPE_FUNCTIONS: readonly ["min", "max", "mix", "clamp", "step", "smoothstep"];
-declare const VEC4_RETURN_FUNCTIONS: readonly ["texture", "textureLod", "textureSize", "cubeTexture"];
-declare const ADDITIONAL_FUNCTIONS: readonly ["atan2", "degrees", "faceforward", "bitcast", "cbrt", "difference", "equals", "pow", "pow2", "pow3", "pow4", "radians", "transformDirection"];
 declare const FUNCTIONS: readonly ["dot", "distance", "length", "lengthSq", "determinant", "luminance", "all", "any", "abs", "sign", "floor", "ceil", "round", "fract", "trunc", "sin", "cos", "tan", "asin", "acos", "atan", "exp", "exp2", "log", "log2", "sqrt", "inverseSqrt", "normalize", "oneMinus", "saturate", "negate", "reciprocal", "dFdx", "dFdy", "fwidth", "cross", "reflect", "refract", "min", "max", "mix", "clamp", "step", "smoothstep", "texture", "textureLod", "textureSize", "cubeTexture", "atan2", "degrees", "faceforward", "bitcast", "cbrt", "difference", "equals", "pow", "pow2", "pow3", "pow4", "radians", "transformDirection"];
-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>";
-};
-declare const COMPONENT_COUNT_TO_TYPE: {
-    readonly 1: "float";
-    readonly 2: "vec2";
-    readonly 3: "vec3";
-    readonly 4: "vec4";
-    readonly 9: "mat3";
-    readonly 16: "mat4";
-};
-declare const BUILTIN_TYPES: {
-    readonly position: "vec4";
-    readonly vertex_index: "uint";
-    readonly instance_index: "uint";
-    readonly front_facing: "bool";
-    readonly frag_depth: "float";
-    readonly sample_index: "uint";
-    readonly sample_mask: "uint";
-    readonly point_coord: "vec2";
-    readonly positionLocal: "vec3";
-    readonly positionWorld: "vec3";
-    readonly positionView: "vec3";
-    readonly normalLocal: "vec3";
-    readonly normalWorld: "vec3";
-    readonly normalView: "vec3";
-    readonly screenCoordinate: "vec2";
-    readonly screenUV: "vec2";
-    readonly gl_FragCoord: "vec4";
-    readonly gl_VertexID: "uint";
-    readonly gl_InstanceID: "uint";
-    readonly gl_FrontFacing: "bool";
-    readonly gl_FragDepth: "float";
-    readonly gl_SampleID: "uint";
-    readonly gl_SampleMask: "uint";
-    readonly gl_PointCoord: "vec2";
-    readonly normal: "vec3";
-    readonly uv: "vec2";
-    readonly color: "vec4";
-};
-declare const COMPARISON_OPERATORS: readonly ["equal", "notEqual", "lessThan", "lessThanEqual", "greaterThan", "greaterThanEqual"];
-declare const LOGICAL_OPERATORS: readonly ["and", "or"];
-declare const WGSL_TO_GLSL_BUILTIN: {
-    readonly position: "gl_FragCoord";
-    readonly vertex_index: "gl_VertexID";
-    readonly instance_index: "gl_InstanceID";
-    readonly front_facing: "gl_FrontFacing";
-    readonly frag_depth: "gl_FragDepth";
-    readonly sample_index: "gl_SampleID";
-    readonly sample_mask: "gl_SampleMask";
-    readonly point_coord: "gl_PointCoord";
-    readonly uv: "gl_FragCoord.xy";
-};
 
 type Constants = (typeof CONSTANTS)[number] | 'void';
 type Conversions = (typeof CONVERSIONS)[number];
@@ -120,25 +40,48 @@ interface FnLayout {
         type: Constants;
     }>;
 }
+/**
+ * Node
+ */
+type NodeTypes = 'attribute' | 'uniform' | 'constant' | 'variable' | 'varying' | 'swizzle' | 'ternary' | 'builtin' | 'conversion' | 'operator' | 'function' | 'scope' | 'assign' | 'loop' | 'define' | 'if' | 'switch' | 'declare' | 'return';
 interface NodeProps {
     id?: string;
     args?: X[];
     type?: string;
     children?: X[];
-    inferFrom?: X;
+    inferFrom?: X[];
     layout?: FnLayout;
+    parent?: NodeProxy;
 }
-interface NodeConfig {
+interface NodeContext {
+    isFrag?: boolean;
     isWebGL?: boolean;
     binding?: number;
     infers?: WeakMap<NodeProxy, Constants>;
-    headers?: Map<string, string>;
     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>;
 }
+/**
+ * NodeProxy
+ */
 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 = 'attribute' | 'uniform' | 'varying' | 'constant' | 'variable' | 'swizzle' | 'ternary' | 'builtin' | 'conversion' | 'operator' | 'function' | 'scope' | 'assign' | 'loop' | 'define' | 'if' | 'switch' | 'declare';
-interface NodeProxy extends Record<Swizzles, NodeProxy> {
+type NodeProxyMethods = Functions | Operators | Conversions | Swizzles | 'type' | 'props' | 'isProxy' | 'assign' | 'toVar' | 'toString';
+type DynamicProperties = {
+    [K in string as K extends NodeProxyMethods ? never : K]: NodeProxy;
+};
+interface BaseNodeProxy extends Record<Swizzles, NodeProxy> {
+    assign(n: X): NodeProxy;
+    toVar(name?: string): NodeProxy;
+    toString(c?: NodeContext): string;
+    type: NodeTypes;
+    props: NodeProps;
+    isProxy: true;
     add(n: X): NodeProxy;
     sub(n: X): NodeProxy;
     mul(n: X): NodeProxy;
@@ -153,8 +96,26 @@ interface NodeProxy extends Record<Swizzles, NodeProxy> {
     and(n: X): NodeProxy;
     or(n: X): NodeProxy;
     not(): NodeProxy;
-    assign(n: X): NodeProxy;
-    toVar(name?: string): NodeProxy;
+    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;
     abs(): NodeProxy;
     sin(): NodeProxy;
     cos(): NodeProxy;
@@ -199,53 +160,28 @@ interface NodeProxy extends Record<Swizzles, NodeProxy> {
     dFdx(): NodeProxy;
     dFdy(): NodeProxy;
     fwidth(): NodeProxy;
-    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;
-    toString(c?: NodeConfig): string;
-    type: NodeTypes;
-    props: NodeProps;
-    isProxy: true;
 }
+type NodeProxy = BaseNodeProxy & DynamicProperties;
 type X = NodeProxy | number | string | boolean | undefined;
 
-declare const code: (target: X, c?: NodeConfig | null) => string;
-
-declare const inferImpl: (target: NodeProxy, c: NodeConfig) => Constants;
-declare const infer: (target: X, c?: NodeConfig | null) => Constants;
+declare const code: (target: X, c?: NodeContext | null) => string;
 
 declare const node: (type: NodeTypes, props?: NodeProps | null, ...args: X[]) => NodeProxy;
 declare const attribute: (x: X, id?: string) => NodeProxy;
-declare const uniform: (x: X, id?: string) => NodeProxy;
-declare const varying: (x: X, id?: string) => NodeProxy;
 declare const constant: (x: X, id?: string) => NodeProxy;
-declare const variable: (id: string) => NodeProxy;
-declare const builtin: (id: string) => NodeProxy;
-declare const swizzle: (key: Swizzles, arg: X) => NodeProxy;
-declare const operator: (key: Operators, ...args: X[]) => NodeProxy;
-declare const function_: (key: Functions, ...args: X[]) => NodeProxy;
-declare const conversion: (key: string, ...args: X[]) => NodeProxy;
+declare const uniform: (x: X, id?: string) => NodeProxy;
+declare const variable: (id?: string) => NodeProxy;
+declare const builtin: (id?: string) => NodeProxy;
+declare const vertexStage: (x: X, id?: string) => NodeProxy;
+declare const swizzle: (key: Swizzles, x: X) => NodeProxy;
+declare const operator: (key: Operators, ...x: X[]) => NodeProxy;
+declare const function_: (key: Functions, ...x: X[]) => NodeProxy;
+declare const conversion: (key: string, ...x: X[]) => NodeProxy;
 declare const select: (x: X, y: X, z: X) => NodeProxy;
 
 declare const toVar: (x: X, id?: string) => NodeProxy;
 declare const assign: (x: X, y: X) => X;
+declare const Return: (x: X) => NodeProxy;
 declare const If: (x: X, fun: () => void) => {
     ElseIf: (_x: X, _fun: () => void) => /*elided*/ any;
     Else: (_fun: () => void) => void;
@@ -267,17 +203,17 @@ declare const isOperator: (key: unknown) => key is Operators;
 declare const isFunction: (key: unknown) => key is Functions;
 declare const isConversion: (key: unknown) => key is Conversions;
 declare const isNodeProxy: (x: unknown) => x is NodeProxy;
+declare const isConstantsType: (type?: Constants | "auto") => type is Constants;
 declare const hex2rgb: (hex: number) => number[];
 declare const getId: () => string;
-declare const joins: (children: X[], c: NodeConfig) => string;
-declare const formatConversions: (x: X, c?: NodeConfig) => string;
-declare const getOperator: (op: X) => "/" | "+" | "-" | "*" | "%" | "==" | "!=" | "<" | "<=" | ">" | ">=" | "&&" | "||" | "&" | "|" | "^" | "<<" | ">>";
+declare const joins: (children: X[], c: NodeContext) => string;
+declare const formatConversions: (x: X, c?: NodeContext) => string;
+declare const getOperator: (op: X) => "+" | "-" | "*" | "/" | "%" | "==" | "!=" | "<" | "<=" | ">" | ">=" | "&&" | "||" | "&" | "|" | "^" | "<<" | ">>";
 declare const getBluiltin: (id: string) => "gl_FragCoord" | "gl_VertexID" | "gl_InstanceID" | "gl_FrontFacing" | "gl_FragDepth" | "gl_SampleID" | "gl_SampleMask" | "gl_PointCoord" | "gl_FragCoord.xy";
 declare const conversionToConstant: (conversionKey: string) => Constants;
-declare const generateDefine: (props: NodeProps, c: NodeConfig) => string;
-declare const fragment: (x: X, c?: NodeConfig) => string;
-declare const vertex: (x: X, c: NodeConfig) => string;
 
+declare const vertex: (x: X, c: NodeContext) => string;
+declare const fragment: (x: X, c: NodeContext) => string;
 declare const position: NodeProxy;
 declare const vertexIndex: NodeProxy;
 declare const instanceIndex: NodeProxy;
@@ -313,10 +249,13 @@ 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 texture2D: () => NodeProxy;
+declare const sampler2D: () => NodeProxy;
 declare const color: (r?: X, g?: X, b?: X) => NodeProxy;
 declare const iResolution: NodeProxy;
 declare const iMouse: NodeProxy;
 declare const iTime: NodeProxy;
+declare const uv: () => NodeProxy;
 declare const texture: (x: X, y: X, z?: X) => NodeProxy;
 declare const cubeTexture: (x: X, y: X, z?: X) => NodeProxy;
 declare const textureSize: (x: X, y?: X) => NodeProxy;
@@ -376,32 +315,42 @@ 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;
-type GPUBuffer = any;
-type GPUPipeline = any;
-type GPUBindGroup = any;
-type Uniform = number | number[];
-type Attribute = number[];
-type Attributes = Record<string, Attribute>;
-type Uniforms = Record<string, Uniform>;
 type PrecisionMode = 'highp' | 'mediump' | 'lowp';
 type GLClearMode = 'COLOR_BUFFER_BIT' | 'DEPTH_BUFFER_BIT' | 'STENCIL_BUFFER_BIT';
 type GLDrawType = 'UNSIGNED_BYTE' | 'UNSIGNED_SHORT' | 'UNSIGNED_INT';
 type GLDrawMode = 'POINTS' | 'LINE_STRIP' | 'LINE_LOOP' | 'LINES' | 'TRIANGLE_STRIP' | 'TRIANGLE_FAN' | 'TRIANGLES';
+interface UniformData {
+    array: Float32Array;
+    buffer: GPUBuffer;
+    binding: number;
+    group: number;
+}
+interface TextureData {
+    binding: number;
+    group: number;
+    texture: GPUTexture;
+    sampler: GPUSampler;
+}
+interface AttribData {
+    array: Float32Array;
+    buffer: GPUBuffer;
+    location: number;
+    stride: number;
+}
 interface WebGLState {
     context: WebGLRenderingContext;
     program: WebGLProgram;
 }
 interface WebGPUState {
     device: GPUDevice;
-    context: GPUContext;
-    pipeline: GPUPipeline;
-    groups: any[];
-    resources: any[];
-    loadingImg: number;
-    needsUpdate: boolean;
+    uniforms: Nested<UniformData>;
+    textures: Nested<TextureData>;
+    attribs: Nested<AttribData>;
 }
+type Uniform = number | number[];
+type Attribute = number[];
+type Attributes = Record<string, Attribute>;
+type Uniforms = Record<string, Uniform>;
 type GL = EventState<{
     /**
      * initial value
@@ -445,6 +394,7 @@ type GL = EventState<{
      */
     _uniform?(key: string, value: Uniform, isMatrix?: boolean): GL;
     uniform(key: string, value: Uniform, isMatrix?: boolean): GL;
+    uniform(node: NodeProxy): GL;
     uniform(target: {
         [key: string]: Uniform;
     }): GL;
@@ -492,53 +442,57 @@ declare const fig: (x?: number) => number;
 declare const dig: (x?: number) => number;
 declare const sig: (value?: number, digit?: number) => number;
 
-declare const createDevice: (c: GPUContext) => Promise<{
-    device: any;
-    format: any;
+/**
+ * initialize
+ */
+declare const createDevice: (c: GPUCanvasContext) => Promise<{
+    device: GPUDevice;
+    format: GPUTextureFormat;
 }>;
-declare const createPipeline: (device: GPUDevice, format: string, bufferLayouts: any[], bindGroupLayouts: any[], vs?: string | NodeProxy, fs?: string | NodeProxy) => GPUPipeline;
-declare const createBindGroup: (device: GPUDevice, resources: any[]) => {
-    layout: any;
-    bindGroup: any;
-};
-declare const createDescriptor: (c: GPUContext) => {
-    colorAttachments: {
-        view: any;
-        clearValue: {
-            r: number;
-            g: number;
-            b: number;
-            a: number;
-        };
-        loadOp: string;
-        storeOp: string;
-    }[];
+declare const createBindings: () => {
+    uniform: () => {
+        group: number;
+        binding: number;
+    };
+    texture: () => {
+        group: number;
+        binding: number;
+    };
+    attrib: () => {
+        location: number;
+    };
 };
-declare const alignTo256: (size: number) => number;
-declare const createVertexBuffer: (device: GPUDevice, value: number[]) => {
+declare const createPipeline: (device: GPUDevice, format: GPUTextureFormat, bufferLayouts: GPUVertexBufferLayout[], bindGroupLayouts: GPUBindGroupLayout[], webgpu: WebGPUState, vs: string | X, fs: string | X) => GPURenderPipeline;
+/**
+ * buffers
+ */
+declare const createUniformBuffer: (device: GPUDevice, value: number[]) => {
     array: Float32Array<ArrayBuffer>;
-    buffer: any;
+    buffer: GPUBuffer;
 };
-declare const createUniformBuffer: (device: GPUDevice, value: number[]) => {
+declare const createAttribBuffer: (device: GPUDevice, value: number[]) => {
     array: Float32Array<ArrayBuffer>;
-    buffer: Buffer;
+    buffer: GPUBuffer;
 };
+/**
+ * uniforms
+ */
+declare const createBindGroup: (device: GPUDevice, uniforms: Map<string, UniformData>, textures: Map<string, TextureData>) => {
+    bindGroups: GPUBindGroup[];
+    bindGroupLayouts: GPUBindGroupLayout[];
+};
+declare const createDescriptor: (c: GPUCanvasContext, depthTexture: GPUTexture) => GPURenderPassDescriptor;
 declare const createTextureSampler: (device: GPUDevice, width?: number, height?: number) => {
-    texture: any;
-    sampler: any;
+    texture: GPUTexture;
+    sampler: GPUSampler;
 };
-declare const createBufferLayout: (shaderLocation: number, dataLength: number, count?: number) => {
-    arrayStride: number;
-    attributes: {
-        shaderLocation: number;
-        offset: number;
-        format: string;
-    }[];
+declare const createDepthTexture: (device: GPUDevice, width: number, height: number) => GPUTexture;
+declare const createVertexBuffers: (attribs: Map<string, AttribData>) => {
+    vertexBuffers: GPUBuffer[];
+    bufferLayouts: GPUVertexBufferLayout[];
 };
 
-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 | NodeProxy, fs?: string | NodeProxy, onError?: () => void) => void | WebGLProgram;
+declare const createProgram: (c: WebGLRenderingContext, vs: X, fs: string | X, onError?: () => void, gl?: any) => void | WebGLProgram;
 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;
@@ -546,17 +500,18 @@ declare const createAttrib: (c: WebGLRenderingContext, stride: number, loc: any,
 declare const createTexture: (c: WebGLRenderingContext, img: HTMLImageElement, loc: any, unit: number) => void;
 
 declare const webgl: (gl: Partial<GL>) => Promise<{
-    webgl: WebGLState;
     render: () => void;
     clean: () => void;
     _attribute: (key: string | undefined, value: number[], iboValue: number[]) => void;
     _uniform: (key: string, value: number | number[]) => void;
     _texture: (key: string, src: string) => void;
+    webgl: WebGLState;
 }>;
 
 declare const webgpu: (gl: Partial<GL>) => Promise<{
     webgpu: WebGPUState;
     render: () => void;
+    resize: () => void;
     clean: () => void;
     _attribute: (key: string | undefined, value: number[]) => void;
     _uniform: (key: string, value: number | number[]) => void;
@@ -597,6 +552,7 @@ declare const createGL: (props?: Partial<GL>) => EventState<{
     mousemove(e: Event): void;
     _uniform?(key: string, value: Uniform, isMatrix?: boolean): GL;
     uniform(key: string, value: Uniform, isMatrix?: boolean): GL;
+    uniform(node: NodeProxy): GL;
     uniform(target: {
         [key: string]: Uniform;
     }): GL;
@@ -612,4 +568,4 @@ declare const createGL: (props?: Partial<GL>) => EventState<{
     }): GL;
 }, any[] | unknown[]>;
 
-export { ADDITIONAL_FUNCTIONS, type Attribute, type Attributes, BOOL_RETURN_FUNCTIONS, BUILTIN_TYPES, COMPARISON_OPERATORS, COMPONENT_COUNT_TO_TYPE, CONSTANTS, CONVERSIONS, type Constants, type Conversions, FIRST_ARG_TYPE_FUNCTIONS, FUNCTIONS, Fn, type FnLayout, type Functions, type GL, type GLClearMode, type GLDrawMode, type GLDrawType, type GPUBindGroup, type GPUBuffer, type GPUContext, type GPUDevice, type GPUPipeline, HIGHEST_TYPE_FUNCTIONS, If, LOGICAL_OPERATORS, Loop, type NodeConfig, type NodeProps, type NodeProxy, type NodeTypes, OPERATORS, OPERATOR_KEYS, type Operators, PRESERVE_TYPE_FUNCTIONS, type PrecisionMode, SCALAR_RETURN_FUNCTIONS, SWIZZLES, Switch, type Swizzles, TYPE_MAPPING, type Uniform, type Uniforms, VEC3_RETURN_FUNCTIONS, VEC4_RETURN_FUNCTIONS, WGSL_TO_GLSL_BUILTIN, type WebGLState, type WebGPUState, type X, abs, acos, alignTo256, all, any, asin, assign, atan, atan2, attribute, bitcast, bool, builtin, bvec2, bvec3, bvec4, cbrt, ceil, clamp, code, color, constant, conversion, conversionToConstant, cos, createAttrib, createBindGroup, createBufferLayout, createDescriptor, createDevice, createGL, createIbo, createPipeline, createProgram, createTexture, createTextureSampler, createUniformBuffer, createVbo, createVertexBuffer, cross, cubeTexture, dFdx, dFdy, createGL as default, defaultFragmentGLSL, defaultVertexGLSL, degrees, difference, dig, distance, dot, each, equals, exp, exp2, ext, faceforward, fig, float, floor, flush, formatConversions, fract, fragDepth, fragment, frontFacing, function_, fwidth, generateDefine, getBluiltin, getId, getOperator, getStride, hex2rgb, iMouse, iResolution, iTime, infer, inferImpl, instanceIndex, int, inverseSqrt, is, isConversion, isFunction, isGL, isNodeProxy, isOperator, isServer, isSwizzle, isWebGPUSupported, ivec2, ivec3, ivec4, joins, length, lengthSq, log, log2, mat2, mat3, mat4, max, min, mix, negate, node, normalLocal, normalView, normalWorld, normalize, oneMinus, operator, pointCoord, position, positionLocal, positionView, positionWorld, pow, pow2, pow3, pow4, radians, reciprocal, reflect, refract, replace, round, sampleIndex, sampleMask, saturate, screenCoordinate, screenUV, select, sig, sign, sin, smoothstep, sqrt, step, swizzle, tan, texture, textureSize, toVar, transformDirection, trunc, uint, uniform, uvec2, uvec3, uvec4, variable, varying, vec2, vec3, vec4, vertex, vertexIndex, webgl, webgpu };
+export { AttribData, Attribute, Attributes, BaseNodeProxy, Constants, Conversions, DynamicProperties, Fn, FnLayout, Functions, GL, GLClearMode, GLDrawMode, GLDrawType, If, Loop, NodeContext, NodeProps, NodeProxy, NodeTypes, Operators, PrecisionMode, Return, Switch, Swizzles, TextureData, Uniform, UniformData, Uniforms, WebGLState, WebGPUState, X, abs, acos, all, any, asin, assign, atan, atan2, attribute, bitcast, bool, builtin, bvec2, bvec3, bvec4, cbrt, ceil, clamp, code, color, constant, conversion, conversionToConstant, cos, createAttrib, createAttribBuffer, createBindGroup, createBindings, createDepthTexture, createDescriptor, createDevice, createGL, createIbo, createPipeline, createProgram, createTexture, createTextureSampler, createUniformBuffer, createVbo, createVertexBuffers, cross, cubeTexture, dFdx, dFdy, createGL as default, degrees, difference, dig, distance, dot, each, equals, exp, exp2, ext, faceforward, fig, float, floor, flush, formatConversions, fract, fragDepth, fragment, frontFacing, function_, fwidth, getBluiltin, getId, getOperator, getStride, hex2rgb, iMouse, iResolution, iTime, instanceIndex, int, inverseSqrt, is, isConstantsType, isConversion, isFunction, isGL, isNodeProxy, isOperator, isServer, isSwizzle, isWebGPUSupported, ivec2, ivec3, ivec4, joins, length, lengthSq, log, log2, mat2, mat3, mat4, max, min, mix, negate, node, normalLocal, normalView, normalWorld, normalize, oneMinus, operator, pointCoord, position, positionLocal, positionView, positionWorld, pow, pow2, pow3, pow4, radians, reciprocal, reflect, refract, replace, round, sampleIndex, sampleMask, sampler2D, saturate, screenCoordinate, screenUV, select, sig, sign, sin, smoothstep, sqrt, step, swizzle, tan, texture, texture2D, textureSize, toVar, transformDirection, trunc, uint, uniform, uv, uvec2, uvec3, uvec4, variable, vec2, vec3, vec4, vertex, vertexIndex, vertexStage, webgl, webgpu };