glre 0.30.0 → 0.32.0

package/src/utils/program.ts

@@ -1,24 +1,6 @@
-import { fragment, isNodeProxy, vertex } from '../node'
-import type { NodeProxy } from '../node'
-
-export const defaultVertexGLSL = /* cpp */ `
-#version 300 es
-void main() {
-  float x = float(gl_VertexID % 2) * 4.0 - 1.0;
-  float y = float(gl_VertexID / 2) * 4.0 - 1.0;
-  gl_Position = vec4(x, y, 0.0, 1.0);
-}
-`
-
-export const defaultFragmentGLSL = /* cpp */ `
-#version 300 es
-precision mediump float;
-uniform vec2 iResolution;
-out vec4 fragColor;
-void main() {
-  fragColor = vec4(fract(gl_FragCoord.xy / iResolution), 0, 1);
-}
-`
+import { fragment, vertex } from '../node'
+import type { X } from '../node'
+import { is } from './helpers'
 
 const createShader = (c: WebGLRenderingContext, source: string, type: number) => {
         const shader = c.createShader(type)
@@ -31,14 +13,10 @@ const createShader = (c: WebGLRenderingContext, source: string, type: number) =>
         console.warn(`Could not compile shader: ${error}`)
 }
 
-export const createProgram = (
-        c: WebGLRenderingContext,
-        vs: string | NodeProxy = defaultVertexGLSL,
-        fs: string | NodeProxy = defaultFragmentGLSL,
-        onError = () => {}
-) => {
-        if (isNodeProxy(fs)) fs = fragment(fs, { isWebGL: true })
-        if (isNodeProxy(vs)) vs = vertex(fs, { isWebGL: true })
+export const createProgram = (c: WebGLRenderingContext, vs: X, fs: string | X, onError = () => {}, gl?: any) => {
+        const config = { isWebGL: true, gl }
+        if (!is.str(fs)) fs = fragment(fs, config)
+        if (!is.str(vs)) vs = vertex(vs, config)
         const pg = c.createProgram()
         const _vs = createShader(c, vs, c.VERTEX_SHADER)
         const _fs = createShader(c, fs, c.FRAGMENT_SHADER)

package/src/webgl.ts

@@ -5,13 +5,12 @@ import type { GL, WebGLState } from './types'
 
 export const webgl = async (gl: Partial<GL>) => {
         const c = gl.el!.getContext('webgl2')!
-        const pg = createProgram(c, gl.vs, gl.fs, () => void (gl.isLoop = false))!
+        const pg = createProgram(c, gl.vs, gl.fs, () => void (gl.isLoop = false), gl)!
         c.useProgram(pg)
         let _activeUnit = 0
         const uniforms = cached((key) => c.getUniformLocation(pg, key))
         const attribs = cached((key) => c.getAttribLocation(pg, key))
         const units = cached(() => _activeUnit++)
-        const state = { context: c, program: pg } as WebGLState
 
         const clean = () => c.deleteProgram(pg)
 
@@ -48,5 +47,5 @@ export const webgl = async (gl: Partial<GL>) => {
                 })
         }
 
-        return { webgl: state, render, clean, _attribute, _uniform, _texture }
+        return { render, clean, _attribute, _uniform, _texture, webgl: { context: c, program: pg } as WebGLState }
 }

package/src/webgpu.ts

@@ -1,84 +1,85 @@
 import { nested as cached } from 'reev'
 import { is } from './utils/helpers'
 import {
+        createAttribBuffer,
+        createBindGroup,
+        createBindings,
+        createDepthTexture,
+        createDescriptor,
         createDevice,
         createPipeline,
-        createDescriptor,
-        createUniformBuffer,
-        createBindGroup,
         createTextureSampler,
-        createVertexBuffer,
-        createBufferLayout,
+        createUniformBuffer,
+        createVertexBuffers,
 } from './utils/pipeline'
 import type { GL, WebGPUState } from './types'
 
 export const webgpu = async (gl: Partial<GL>) => {
-        const c = gl.el!.getContext('webgpu') as any
+        const c = gl.el!.getContext('webgpu') as GPUCanvasContext
         const { device, format } = await createDevice(c)
-        const state = {
-                device,
-                context: c,
-                resources: [[], []],
-                loadingImg: 0,
-                needsUpdate: true,
-        } as WebGPUState
-
-        const bindGroups = [] as any[]
-        const vertexBuffers = [] as any[]
-        const bufferLayouts = [] as any[]
-
-        const attributes = cached((_, value: number[]) => {
-                const { array, buffer } = createVertexBuffer(device, value)
-                vertexBuffers.push(buffer)
-                bufferLayouts.push(createBufferLayout(bufferLayouts.length, array.length, gl.count))
-                state.needsUpdate = true
-                return { array, buffer }
-        })
+        const bindings = createBindings()
+        let imageLoading = 0
+        let needsUpdate = true
+        let depthTexture: GPUTexture
+        let _render = (_pass: GPURenderPassEncoder) => {}
 
-        const uniforms = cached((_, value: number[]) => {
+        const uniforms = cached((_key, value: number[]) => {
+                needsUpdate = true
+                const { group, binding } = bindings.uniform()
                 const { array, buffer } = createUniformBuffer(device, value)
-                state.resources[0].push({ buffer })
-                state.needsUpdate = true
-                return { array, buffer }
+                return { array, buffer, binding, group }
         })
 
-        const textures = cached((_, { width, height }: HTMLImageElement) => {
+        const textures = cached((_key, { width, height }: HTMLImageElement) => {
+                needsUpdate = true
+                const { group, binding } = bindings.texture()
                 const { texture, sampler } = createTextureSampler(device, width, height)
-                state.resources[1].push(sampler, texture.createView())
-                state.needsUpdate = true
-                return { texture, width, height }
+                return { texture, sampler, binding, group }
+        })
+
+        const attribs = cached((_key, value: number[]) => {
+                needsUpdate = true
+                const stride = value.length / gl.count!
+                const { location } = bindings.attrib()
+                const { array, buffer } = createAttribBuffer(device, value)
+                return { array, buffer, location, stride }
         })
 
         const update = () => {
-                const bindGroupLayouts = [] as any
-                bindGroups.length = 0
-                state.resources.forEach((resource) => {
-                        if (!resource.length) return
-                        const { layout, bindGroup } = createBindGroup(device, resource)
-                        bindGroupLayouts.push(layout)
-                        bindGroups.push(bindGroup)
-                })
-                state.pipeline = createPipeline(device, format, bufferLayouts, bindGroupLayouts, gl.vs, gl.fs)
+                const { vertexBuffers, bufferLayouts } = createVertexBuffers(attribs.map)
+                const { bindGroups, bindGroupLayouts } = createBindGroup(device, uniforms.map, textures.map)
+                const pipeline = createPipeline(device, format, bufferLayouts, bindGroupLayouts, webgpu, gl.vs, gl.fs)
+                _render = (pass) => {
+                        pass.setPipeline(pipeline)
+                        bindGroups.forEach((v, i) => pass.setBindGroup(i, v))
+                        vertexBuffers.forEach((v, i) => pass.setVertexBuffer(i, v))
+                        pass.draw(gl.count!, 1, 0, 0)
+                        pass.end()
+                }
         }
 
         const render = () => {
-                if (state.loadingImg) return // ignore if loading img
-                if (state.needsUpdate) update() // first rendering
-                state.needsUpdate = false
+                if (imageLoading) return
+                if (needsUpdate) update()
+                needsUpdate = false
                 const encoder = device.createCommandEncoder()
-                const pass = encoder.beginRenderPass(createDescriptor(c))
-                pass.setPipeline(state.pipeline)
-                bindGroups.forEach((v, i) => pass.setBindGroup(i, v))
-                vertexBuffers.forEach((v, i) => pass.setVertexBuffer(i, v))
-                pass.draw(gl.count, 1, 0, 0)
-                pass.end()
+                _render(encoder.beginRenderPass(createDescriptor(c, depthTexture)))
                 device.queue.submit([encoder.finish()])
         }
 
-        const clean = () => {}
+        const resize = () => {
+                const canvas = gl.el as HTMLCanvasElement
+                depthTexture?.destroy()
+                depthTexture = createDepthTexture(device, canvas.width, canvas.height)
+        }
+
+        const clean = () => {
+                depthTexture?.destroy()
+        }
 
         const _attribute = (key = '', value: number[]) => {
-                const { array, buffer } = attributes(key, value)
+                const { array, buffer } = attribs(key, value)
+                array.set(value)
                 device.queue.writeBuffer(buffer, 0, array)
         }
 
@@ -90,14 +91,22 @@ export const webgpu = async (gl: Partial<GL>) => {
         }
 
         const _texture = (key: string, src: string) => {
-                state.loadingImg++
+                imageLoading++
                 const source = Object.assign(new Image(), { src, crossOrigin: 'anonymous' })
                 source.decode().then(() => {
-                        const { texture, width, height } = textures(key, source)
-                        device.queue.copyExternalImageToTexture({ source }, { texture }, { width, height })
-                        state.loadingImg--
+                        const texture = textures(key, source)
+                        device.queue.copyExternalImageToTexture(
+                                { source },
+                                { texture: texture.texture },
+                                { width: source.width, height: source.height }
+                        )
+                        imageLoading--
                 })
         }
 
-        return { webgpu: state, render, clean, _attribute, _uniform, _texture }
+        resize()
+
+        const webgpu = { device, uniforms, textures, attribs } as WebGPUState
+
+        return { webgpu, render, resize, clean, _attribute, _uniform, _texture }
 }

package/dist/index-q8W5cl04.d.cts

@@ -1,358 +0,0 @@
-import * as refr from 'refr';
-import { Queue, Frame } from 'refr';
-import { 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"];
-
-type Constants = (typeof CONSTANTS)[number] | 'void';
-interface FnLayout {
-    name: string;
-    type: Constants | 'auto';
-    inputs?: Array<{
-        name: string;
-        type: Constants;
-    }>;
-}
-interface NodeProps {
-    id?: string;
-    args?: X[];
-    type?: string;
-    children?: X[];
-    inferFrom?: X;
-    layout?: FnLayout;
-}
-interface NodeConfig {
-    isWebGL?: boolean;
-    binding?: number;
-    infers?: WeakMap<NodeProxy, Constants>;
-    headers?: Map<string, string>;
-    onMount?: (name: string) => void;
-}
-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> {
-    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;
-    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;
-    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 X = NodeProxy | number | string | boolean | undefined;
-
-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 WebGLState {
-    context: WebGLRenderingContext;
-    program: WebGLProgram;
-}
-interface WebGPUState {
-    device: GPUDevice;
-    context: GPUContext;
-    pipeline: GPUPipeline;
-    groups: any[];
-    resources: any[];
-    loadingImg: number;
-    needsUpdate: boolean;
-}
-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(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;
-
-declare const createDevice: (c: GPUContext) => Promise<{
-    device: any;
-    format: any;
-}>;
-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 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) => {
-    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 | NodeProxy, fs?: string | NodeProxy, onError?: () => void) => 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<{
-    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;
-}>;
-
-declare const webgpu: (gl: Partial<GL>) => Promise<{
-    webgpu: WebGPUState;
-    render: () => 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(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 { type Attribute as A, createDescriptor as B, alignTo256 as C, createVertexBuffer as D, createUniformBuffer as E, createTextureSampler as F, type GL as G, createBufferLayout as H, defaultVertexGLSL as I, defaultFragmentGLSL as J, createProgram as K, createVbo as L, createIbo as M, type NodeProxy as N, getStride as O, type PrecisionMode as P, createAttrib as Q, createTexture as R, webgl as S, webgpu as T, type Uniform as U, type WebGPUState as W, type WebGLState as a, isServer as b, isWebGPUSupported as c, createGL as d, type GPUContext as e, type GPUDevice as f, type GPUBuffer as g, type GPUPipeline as h, isGL as i, type GPUBindGroup as j, type Attributes as k, type Uniforms as l, type GLClearMode as m, type GLDrawType as n, type GLDrawMode as o, is as p, each as q, flush as r, replace as s, ext as t, fig as u, dig as v, sig as w, createDevice as x, createPipeline as y, createBindGroup as z };

package/dist/index.d.cts

@@ -1,3 +0,0 @@
-export { Frame, Fun, Queue } from 'refr';
-export { A as Attribute, k as Attributes, G as GL, m as GLClearMode, o as GLDrawMode, n as GLDrawType, j as GPUBindGroup, g as GPUBuffer, e as GPUContext, f as GPUDevice, h as GPUPipeline, P as PrecisionMode, U as Uniform, l as Uniforms, a as WebGLState, W as WebGPUState, C as alignTo256, Q as createAttrib, z as createBindGroup, H as createBufferLayout, B as createDescriptor, x as createDevice, d as createGL, M as createIbo, y as createPipeline, K as createProgram, R as createTexture, F as createTextureSampler, E as createUniformBuffer, L as createVbo, D as createVertexBuffer, d as default, J as defaultFragmentGLSL, I as defaultVertexGLSL, v as dig, q as each, t as ext, u as fig, r as flush, O as getStride, p as is, i as isGL, b as isServer, c as isWebGPUSupported, s as replace, w as sig, S as webgl, T as webgpu } from './index-q8W5cl04.cjs';
-import 'reev';

package/dist/native.d.cts

@@ -1,53 +0,0 @@
-import * as reev from 'reev';
-import * as refr_dist_types_687121c7 from 'refr/dist/types-687121c7';
-import { G as GL, N as NodeProxy, W as WebGPUState, a as WebGLState, U as Uniform, A as Attribute } from './index-q8W5cl04.cjs';
-export { k as Attributes, m as GLClearMode, o as GLDrawMode, n as GLDrawType, j as GPUBindGroup, g as GPUBuffer, e as GPUContext, f as GPUDevice, h as GPUPipeline, P as PrecisionMode, l as Uniforms, C as alignTo256, Q as createAttrib, z as createBindGroup, H as createBufferLayout, B as createDescriptor, x as createDevice, d as createGL, M as createIbo, y as createPipeline, K as createProgram, R as createTexture, F as createTextureSampler, E as createUniformBuffer, L as createVbo, D as createVertexBuffer, J as defaultFragmentGLSL, I as defaultVertexGLSL, v as dig, q as each, t as ext, u as fig, r as flush, O as getStride, p as is, i as isGL, b as isServer, c as isWebGPUSupported, s as replace, w as sig, S as webgl, T as webgpu } from './index-q8W5cl04.cjs';
-export { Frame, Fun, Queue } from 'refr';
-
-declare const useGL: (props?: Partial<GL>) => reev.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_dist_types_687121c7.Q;
-    frame: refr_dist_types_687121c7.a;
-    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, GL, Uniform, WebGLState, WebGPUState, useGL };

package/dist/react.d.cts

@@ -1,8 +0,0 @@
-import * as reev from 'reev';
-import { G as GL } from './index-q8W5cl04.cjs';
-export { A as Attribute, k as Attributes, m as GLClearMode, o as GLDrawMode, n as GLDrawType, j as GPUBindGroup, g as GPUBuffer, e as GPUContext, f as GPUDevice, h as GPUPipeline, P as PrecisionMode, U as Uniform, l as Uniforms, a as WebGLState, W as WebGPUState, C as alignTo256, Q as createAttrib, z as createBindGroup, H as createBufferLayout, B as createDescriptor, x as createDevice, d as createGL, M as createIbo, y as createPipeline, K as createProgram, R as createTexture, F as createTextureSampler, E as createUniformBuffer, L as createVbo, D as createVertexBuffer, J as defaultFragmentGLSL, I as defaultVertexGLSL, v as dig, q as each, t as ext, u as fig, r as flush, O as getStride, p as is, i as isGL, b as isServer, c as isWebGPUSupported, s as replace, w as sig, S as webgl, T as webgpu } from './index-q8W5cl04.cjs';
-export { Frame, Fun, Queue } from 'refr';
-
-declare const useGL: (props?: Partial<GL>) => reev.EventState<GL>;
-
-export { GL, useGL };

package/dist/solid.d.cts

@@ -1,8 +0,0 @@
-import * as reev from 'reev';
-import { G as GL } from './index-q8W5cl04.cjs';
-export { A as Attribute, k as Attributes, m as GLClearMode, o as GLDrawMode, n as GLDrawType, j as GPUBindGroup, g as GPUBuffer, e as GPUContext, f as GPUDevice, h as GPUPipeline, P as PrecisionMode, U as Uniform, l as Uniforms, a as WebGLState, W as WebGPUState, C as alignTo256, Q as createAttrib, z as createBindGroup, H as createBufferLayout, B as createDescriptor, x as createDevice, d as createGL, M as createIbo, y as createPipeline, K as createProgram, R as createTexture, F as createTextureSampler, E as createUniformBuffer, L as createVbo, D as createVertexBuffer, J as defaultFragmentGLSL, I as defaultVertexGLSL, v as dig, q as each, t as ext, u as fig, r as flush, O as getStride, p as is, i as isGL, b as isServer, c as isWebGPUSupported, s as replace, w as sig, S as webgl, T as webgpu } from './index-q8W5cl04.cjs';
-export { Frame, Fun, Queue } from 'refr';
-
-declare const onGL: (props?: Partial<GL>) => reev.EventState<GL>;
-
-export { GL, onGL };