glre 0.21.0 → 0.22.0

package/dist/index.d.ts

@@ -1,9 +1,526 @@
-import { G as GL } from './types-f429c8b1.js';
-export { Fun } from 'refr';
-import 'reev';
+import * as reev from 'reev';
+import { EventState, Nested } from 'reev';
+import * as refr from 'refr';
+import { Queue, Frame } from 'refr';
+export { Frame, Fun, Queue } from 'refr';
+import * as refr_dist_types_687121c7 from 'refr/dist/types-687121c7';
 
-declare const createGL: (props?: Partial<GL>) => GL;
-declare const gl: GL;
-declare const createTF: (props?: Partial<GL>, self?: GL) => GL;
+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 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];
 
-export { GL, createGL, createTF, gl as default, gl };
+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;
+};
+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;
+}
+interface ConditionalNode {
+    ElseIf(condition: X, callback: () => void): ConditionalNode;
+    Else(callback: () => void): void;
+}
+interface ConversionContext {
+    target: 'webgl' | 'webgpu';
+    nodes: Map<string, Node>;
+    variables: Map<string, string>;
+    functions: Map<string, string>;
+}
+
+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 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 createNode: (type: NodeType, value?: any, options?: Partial<Node>) => Node;
+declare const node: (type: NodeType, value?: any, options?: Partial<Node>) => 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 Fn: (jsFunc: Function) => FunctionNode;
+declare const If: (condition: X, callback: () => void) => ConditionalNode;
+declare const gl_FragCoord: X;
+declare const gl_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;
+
+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 GLDrawMode = 'POINTS' | 'LINE_STRIP' | 'LINE_LOOP' | 'LINES' | 'TRIANGLE_STRIP' | 'TRIANGLE_FAN' | 'TRIANGLES';
+type GLDrawType = 'UNSIGNED_BYTE' | 'UNSIGNED_SHORT' | 'UNSIGNED_INT';
+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;
+    vs: string | X;
+    fs: string | X;
+    vert: string | X;
+    frag: string | X;
+    vertex: string | X;
+    fragment: string | X;
+    /**
+     * for webgl
+     */
+    int: PrecisionMode;
+    float: PrecisionMode;
+    sampler2D: PrecisionMode;
+    samplerCube: PrecisionMode;
+    lastActiveUnit: number;
+    /**
+     * core state
+     */
+    gl: any;
+    pg: any;
+    el: any;
+    queue: Queue;
+    frame: Frame;
+    stride: Nested<number>;
+    location: Nested<any>;
+    activeUnit: Nested<number>;
+    default: any;
+    /**
+     * 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(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;
+}>;
+
+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;
+    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;
+};
+declare const isServer: () => boolean;
+declare const isWebGPUSupported: () => boolean;
+/**
+ * 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;
+
+declare const createVbo: (c: WebGLRenderingContext, data: number[]) => WebGLBuffer;
+declare const createIbo: (c: WebGLRenderingContext, data: number[]) => WebGLBuffer;
+declare const createAttribute: (c: WebGLRenderingContext, stride: number, location: number, vbo: WebGLBuffer, ibo?: WebGLBuffer) => void;
+declare const deleteBuffer: (c: WebGLRenderingContext, buffer: WebGLBuffer) => void;
+declare const vertexStride: (count: number, value: number[], iboValue?: number[]) => number;
+declare const updateVbo: (c: WebGLRenderingContext, buffer: WebGLBuffer, data: number[], usage?: 35044) => void;
+declare const updateIbo: (c: WebGLRenderingContext, buffer: WebGLBuffer, data: number[], usage?: 35044) => void;
+
+declare const createProgram: (c: WebGLRenderingContext, vs: WebGLShader, fs: WebGLShader) => WebGLProgram;
+declare const deleteProgram: (c: WebGLRenderingContext, pg: WebGLProgram) => void;
+declare const getProgramInfo: (c: WebGLRenderingContext, pg: WebGLProgram) => {
+    linked: any;
+    log: string | null;
+    activeAttributes: any;
+    activeUniforms: any;
+};
+declare const getUniformType: (value: number | number[], isMatrix?: boolean) => string;
+declare const getUniformLocation: (c: WebGLRenderingContext, pg: WebGLProgram, name: string) => WebGLUniformLocation | null;
+declare const getAttribLocation: (c: WebGLRenderingContext, pg: WebGLProgram, name: string) => number;
+
+declare const deleteShader: (c: WebGLRenderingContext, shader: WebGLShader) => void;
+declare const createVertexShader: (c: WebGLRenderingContext, source?: string) => WebGLShader;
+declare const createFragmentShader: (c: WebGLRenderingContext, source?: string) => WebGLShader;
+declare const getShaderInfo: (c: WebGLRenderingContext, shader: WebGLShader) => {
+    compiled: any;
+    log: string | null;
+    source: string | null;
+};
+
+declare const createTexture: (c: WebGLRenderingContext, img: HTMLImageElement) => WebGLTexture;
+declare const activeTexture: (c: WebGLRenderingContext, location: WebGLUniformLocation | null, unit: number, texture: WebGLTexture) => void;
+declare const deleteTexture: (c: WebGLRenderingContext, texture: WebGLTexture) => void;
+declare const createEmptyTexture: (c: WebGLRenderingContext, w?: number, h?: number, format?: 6408, type?: 5121) => WebGLTexture;
+declare const createCubeTexture: (c: WebGLRenderingContext, imgs: HTMLImageElement[]) => WebGLTexture;
+
+declare const webgl: (gl: GL) => GL;
+
+declare const createBuffer: (device: any, data: Float32Array | Uint32Array | number[], usage: number) => any;
+declare const createVertexBuffer: (device: any, data: number[]) => any;
+declare const createIndexBuffer: (device: any, data: number[]) => any;
+declare const createUniformBuffer: (device: any, size: number) => any;
+declare const createStorageBuffer: (device: any, size: number) => any;
+declare const updateBuffer: (device: any, buffer: any, data: Float32Array | Uint32Array | number[], offset?: number) => void;
+declare const destroyBuffer: (buffer: any) => any;
+declare const calculateBufferSize: (data: number[]) => number;
+declare const alignBufferSize: (size: number, alignment?: number) => number;
+declare const createBuffers: (device: any, bufferConfigs: Array<{
+    data: number[];
+    usage: number;
+}>) => any[];
+declare const BufferUsage: {
+    readonly VERTEX: 32;
+    readonly INDEX: 64;
+    readonly UNIFORM: 64;
+    readonly STORAGE: 128;
+    readonly COPY_SRC: 4;
+    readonly COPY_DST: 8;
+    readonly MAP_READ: 1;
+    readonly MAP_WRITE: 2;
+};
+
+declare const requestWebGPUDevice: () => Promise<{
+    adapter: any;
+    device: any;
+}>;
+declare const checkWebGPUSupport: () => boolean;
+declare const getDeviceLimits: (device: any) => {
+    maxTextureDimension1D: any;
+    maxTextureDimension2D: any;
+    maxTextureDimension3D: any;
+    maxTextureArrayLayers: any;
+    maxBindGroups: any;
+    maxDynamicUniformBuffersPerPipelineLayout: any;
+    maxDynamicStorageBuffersPerPipelineLayout: any;
+    maxSampledTexturesPerShaderStage: any;
+    maxSamplersPerShaderStage: any;
+    maxStorageBuffersPerShaderStage: any;
+    maxStorageTexturesPerShaderStage: any;
+    maxUniformBuffersPerShaderStage: any;
+    maxUniformBufferBindingSize: any;
+    maxStorageBufferBindingSize: any;
+    maxVertexBuffers: any;
+    maxVertexAttributes: any;
+    maxVertexBufferArrayStride: any;
+    maxComputeWorkgroupStorageSize: any;
+    maxComputeInvocationsPerWorkgroup: any;
+    maxComputeWorkgroupSizeX: any;
+    maxComputeWorkgroupSizeY: any;
+    maxComputeWorkgroupSizeZ: any;
+    maxComputeWorkgroupsPerDimension: any;
+};
+declare const setupDeviceErrorHandling: (device: any) => void;
+declare const configureCanvasContext: (canvas: HTMLCanvasElement, device: any, format?: any) => RenderingContext;
+
+declare const createRenderPipeline: (device: any, vertexShader?: string, fragmentShader?: string, format?: string) => any;
+declare const createComputePipeline: (device: any, computeShader: string) => any;
+declare const createShaderModule: (device: any, code: string) => any;
+declare const createBindGroupLayout: (device: any, entries: any[]) => any;
+declare const createBindGroup: (device: any, layout: any, entries: any[]) => any;
+declare const createRenderPass: (encoder: any, colorAttachment: any, depthStencilAttachment?: any) => any;
+declare const createCommandEncoder: (device: any) => any;
+
+declare const createTextureFromImage: (device: any, image: HTMLImageElement | ImageBitmap, format?: string) => any;
+declare const createDepthTexture: (device: any, w?: number, h?: number, format?: string) => any;
+declare const createSampler: (device: any, options?: {
+    magFilter?: string;
+    minFilter?: string;
+    addressModeU?: string;
+    addressModeV?: string;
+    addressModeW?: string;
+}) => any;
+declare const createTextureView: (texture: any, options?: {
+    format?: string;
+    dimension?: string;
+    aspect?: string;
+    baseMipLevel?: number;
+    mipLevelCount?: number;
+    baseArrayLayer?: number;
+    arrayLayerCount?: number;
+}) => any;
+declare const updateTexture: (device: any, texture: any, data: Uint8Array | Uint8ClampedArray, w?: number, h?: number) => void;
+declare const destroyTexture: (texture: any) => any;
+declare const TextureUsage: {
+    readonly COPY_SRC: 1;
+    readonly COPY_DST: 2;
+    readonly TEXTURE_BINDING: 4;
+    readonly STORAGE_BINDING: 8;
+    readonly RENDER_ATTACHMENT: 16;
+};
+declare const TextureFormat: {
+    readonly RGBA8_UNORM: "rgba8unorm";
+    readonly RGBA8_SRGB: "rgba8unorm-srgb";
+    readonly BGRA8_UNORM: "bgra8unorm";
+    readonly BGRA8_SRGB: "bgra8unorm-srgb";
+    readonly DEPTH24_PLUS: "depth24plus";
+    readonly DEPTH32_FLOAT: "depth32float";
+};
+
+declare const webgpu: (gl: GL) => reev.EventState<{
+    isNative: boolean;
+    isWebGL: boolean;
+    isLoop: boolean;
+    isGL: true;
+    width: number;
+    height: number;
+    size: [number, number];
+    mouse: [number, number];
+    count: number;
+    vs: string | X;
+    fs: string | X;
+    vert: string | X;
+    frag: string | X;
+    vertex: string | X;
+    fragment: string | X;
+    int: PrecisionMode;
+    float: PrecisionMode;
+    sampler2D: PrecisionMode;
+    samplerCube: PrecisionMode;
+    lastActiveUnit: number;
+    gl: any;
+    pg: any;
+    el: any;
+    queue: refr_dist_types_687121c7.Q;
+    frame: refr_dist_types_687121c7.a;
+    stride: reev.Nested<number>;
+    location: reev.Nested<any>;
+    activeUnit: reev.Nested<number>;
+    default: any;
+    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(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[]>;
+
+declare const isGL: (a: unknown) => a is EventState<GL>;
+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;
+    vs: string | X;
+    fs: string | X;
+    vert: string | X;
+    frag: string | X;
+    vertex: string | X;
+    fragment: string | X;
+    int: PrecisionMode;
+    float: PrecisionMode;
+    sampler2D: PrecisionMode;
+    samplerCube: PrecisionMode;
+    lastActiveUnit: number;
+    gl: any;
+    pg: any;
+    el: any;
+    queue: refr.Queue;
+    frame: refr.Frame;
+    stride: reev.Nested<number>;
+    location: reev.Nested<any>;
+    activeUnit: reev.Nested<number>;
+    default: any;
+    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(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 { Attribute, Attributes, BufferUsage, CACHE_BOOLS, CACHE_FLOATS, CACHE_INTS, ConditionalNode, ConversionContext, FUNCTIONS, Fn, FunctionNode, GL, GLClearMode, GLDrawMode, GLDrawType, If, MathFunction, MathMethods, Node, NodeCreator, NodeType, OPERATORS, Operator, OperatorMethods, PrecisionMode, ProxyCallback, SWIZZLES, Swillzes, SwizzleProperties, TYPES, TextureFormat, TextureUsage, Uniform, UniformNode, Uniforms, X, abs, activeTexture, alignBufferSize, bool, calculateBufferSize, ceil, checkWebGPUSupport, color, configureCanvasContext, convertToNode, cos, createAttribute, createBindGroup, createBindGroupLayout, createBuffer, createBuffers, createCommandEncoder, createComputePipeline, createCubeTexture, createDepthTexture, createEmptyTexture, createFragmentShader, createGL, createIbo, createIndexBuffer, createNode, createProgram, createRenderPass, createRenderPipeline, createSampler, createShaderModule, createStorageBuffer, createTexture, createTextureFromImage, createTextureView, createUniformBuffer, createVbo, createVertexBuffer, createVertexShader, createGL as default, deleteBuffer, deleteProgram, deleteShader, deleteTexture, destroyBuffer, destroyTexture, dig, each, ext, fig, findDuplicateNodes, float, floor, flush, fract, getAttribLocation, getCachedBool, getCachedFloat, getCachedInt, getDeviceLimits, getProgramInfo, getShaderInfo, getUniformLocation, getUniformType, gl_FragCoord, gl_Position, glsl, iDeltaTime, iMouse, iPrevTime, iResolution, iTime, int, is, isGL, isServer, isWebGPUSupported, length, node, nodeToGLSL, nodeToWGSL, normalize, replace, requestWebGPUDevice, setupDeviceErrorHandling, sig, sin, sqrt, tan, uniform, updateBuffer, updateIbo, updateTexture, updateUniforms, updateVbo, vec2, vec3, vec4, vertexStride, webgl, webgpu, wgsl };