glre 0.30.0 → 0.32.0

package/dist/index.d.ts

@@ -0,0 +1,571 @@
+import * as refr from 'refr';
+import { Queue, Frame } from 'refr';
+export { Frame, Fun, Queue } from 'refr';
+import { Nested, EventState } from 'reev';
+
+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: "+";
+    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 ["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"];
+
+type Constants = (typeof CONSTANTS)[number] | 'void';
+type Conversions = (typeof CONVERSIONS)[number];
+type Functions = (typeof FUNCTIONS)[number];
+type Operators = (typeof OPERATOR_KEYS)[number];
+interface FnLayout {
+    name: string;
+    type: Constants | 'auto';
+    inputs?: Array<{
+        name: string;
+        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[];
+    layout?: FnLayout;
+    parent?: NodeProxy;
+}
+interface NodeContext {
+    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>;
+}
+/**
+ * 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 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;
+    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;
+    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;
+    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;
+}
+type NodeProxy = BaseNodeProxy & DynamicProperties;
+type X = NodeProxy | number | string | boolean | undefined;
+
+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 constant: (x: X, id?: string) => 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;
+};
+declare const Loop: (x: X, fun: (params: {
+    i: NodeProxy;
+}) => void) => NodeProxy;
+declare const Switch: (x: X) => {
+    Case: (...values: X[]) => (fun: () => void) => /*elided*/ any;
+    Default: (fun: () => void) => void;
+};
+declare const Fn: (fun: (paramVars: NodeProxy[]) => NodeProxy) => {
+    (...args: X[]): NodeProxy;
+    setLayout(newLayout: FnLayout): /*elided*/ any;
+};
+
+declare const isSwizzle: (key: unknown) => key is Swizzles;
+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: 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 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;
+declare const frontFacing: NodeProxy;
+declare const fragDepth: NodeProxy;
+declare const sampleIndex: NodeProxy;
+declare const sampleMask: NodeProxy;
+declare const pointCoord: NodeProxy;
+declare const normalLocal: NodeProxy;
+declare const normalWorld: NodeProxy;
+declare const normalView: NodeProxy;
+declare const positionLocal: NodeProxy;
+declare const positionWorld: NodeProxy;
+declare const positionView: NodeProxy;
+declare const screenCoordinate: NodeProxy;
+declare const screenUV: 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 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;
+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 atan2: (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 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;
+    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
+     */
+    isNative: boolean;
+    isWebGL: boolean;
+    isLoop: boolean;
+    isGL: true;
+    width: number;
+    height: number;
+    size: [number, number];
+    mouse: [number, number];
+    count: number;
+    el: HTMLCanvasElement;
+    vs: string | NodeProxy;
+    fs: string | NodeProxy;
+    vert: string | NodeProxy;
+    frag: string | NodeProxy;
+    vertex: string | NodeProxy;
+    fragment: string | NodeProxy;
+    /**
+     * core state
+     */
+    webgpu: WebGPUState;
+    webgl: WebGLState;
+    queue: Queue;
+    frame: Frame;
+    /**
+     * events
+     */
+    ref?: any;
+    init(): void;
+    loop(): void;
+    mount(): void;
+    clean(): void;
+    render(): void;
+    resize(e?: Event): void;
+    mousemove(e: Event): void;
+    /**
+     * setter
+     */
+    _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;
+    _texture?(key: string, value: string): GL;
+    texture(key: string, value: string): GL;
+    texture(target: {
+        [key: string]: string;
+    }): GL;
+    _attribute?(key: string, value: Attribute, iboValue?: Attribute): GL;
+    attribute(key: string, value: Attribute, iboValue?: Attribute): GL;
+    attribute(target: {
+        [key: string]: Attribute;
+    }): GL;
+}>;
+
+declare const is: {
+    arr: (arg: any) => arg is any[];
+    bol: (a: unknown) => a is boolean;
+    str: (a: unknown) => a is string;
+    num: (a: unknown) => a is number;
+    int: (a: unknown) => a is number;
+    fun: (a: unknown) => a is Function;
+    und: (a: unknown) => a is undefined;
+    nul: (a: unknown) => a is null;
+    set: (a: unknown) => a is Set<unknown>;
+    map: (a: unknown) => a is Map<unknown, unknown>;
+    obj: (a: unknown) => a is object;
+    nan: (a: unknown) => a is number;
+};
+/**
+ * each
+ */
+type EachFn<Value, Key, This> = (this: This, value: Value, key: Key) => void;
+type Eachable<Value = any, Key = any, This = any> = {
+    forEach(cb: EachFn<Value, Key, This>, ctx?: This): void;
+};
+declare const each: <Value, Key, This>(obj: Eachable<Value, Key, This>, fn: EachFn<Value, Key, This>) => void;
+declare const flush: <Value extends Function, Key, This>(obj: Eachable<Value, Key, This>, ...args: any[]) => void;
+/**
+ * other
+ */
+declare const replace: (x?: string, from?: string, to?: string) => string;
+declare const ext: (src?: string) => string;
+declare const fig: (x?: number) => number;
+declare const dig: (x?: number) => number;
+declare const sig: (value?: number, digit?: number) => number;
+
+/**
+ * initialize
+ */
+declare const createDevice: (c: GPUCanvasContext) => Promise<{
+    device: GPUDevice;
+    format: GPUTextureFormat;
+}>;
+declare const createBindings: () => {
+    uniform: () => {
+        group: number;
+        binding: number;
+    };
+    texture: () => {
+        group: number;
+        binding: number;
+    };
+    attrib: () => {
+        location: 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: GPUBuffer;
+};
+declare const createAttribBuffer: (device: GPUDevice, value: number[]) => {
+    array: Float32Array<ArrayBuffer>;
+    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: GPUTexture;
+    sampler: GPUSampler;
+};
+declare const createDepthTexture: (device: GPUDevice, width: number, height: number) => GPUTexture;
+declare const createVertexBuffers: (attribs: Map<string, AttribData>) => {
+    vertexBuffers: GPUBuffer[];
+    bufferLayouts: GPUVertexBufferLayout[];
+};
+
+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;
+declare const createAttrib: (c: WebGLRenderingContext, stride: number, loc: any, vbo: WebGLBuffer, ibo?: WebGLBuffer) => void;
+declare const createTexture: (c: WebGLRenderingContext, img: HTMLImageElement, loc: any, unit: number) => void;
+
+declare const webgl: (gl: Partial<GL>) => Promise<{
+    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;
+    _texture: (key: string, src: string) => void;
+}>;
+
+declare const isGL: (a: unknown) => a is EventState<GL>;
+declare const isServer: () => boolean;
+declare const isWebGPUSupported: () => boolean;
+declare const createGL: (props?: Partial<GL>) => EventState<{
+    isNative: boolean;
+    isWebGL: boolean;
+    isLoop: boolean;
+    isGL: true;
+    width: number;
+    height: number;
+    size: [number, number];
+    mouse: [number, number];
+    count: number;
+    el: HTMLCanvasElement;
+    vs: string | NodeProxy;
+    fs: string | NodeProxy;
+    vert: string | NodeProxy;
+    frag: string | NodeProxy;
+    vertex: string | NodeProxy;
+    fragment: string | NodeProxy;
+    webgpu: WebGPUState;
+    webgl: WebGLState;
+    queue: refr.Queue;
+    frame: refr.Frame;
+    ref?: any;
+    init(): void;
+    loop(): void;
+    mount(): void;
+    clean(): void;
+    render(): void;
+    resize(e?: Event): void;
+    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;
+    _texture?(key: string, value: string): GL;
+    texture(key: string, value: string): GL;
+    texture(target: {
+        [key: string]: string;
+    }): GL;
+    _attribute?(key: string, value: Attribute, iboValue?: Attribute): GL;
+    attribute(key: string, value: Attribute, iboValue?: Attribute): GL;
+    attribute(target: {
+        [key: string]: Attribute;
+    }): GL;
+}, any[] | unknown[]>;
+
+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 };