glre 0.22.0 → 0.23.0

package/src/utils/pipeline.ts

@@ -0,0 +1,128 @@
+import { GPUContext, GPUDevice, GPUPipeline } from '../types'
+
+export const initWebGPUDevice = async (el: HTMLCanvasElement) => {
+        const gpu = (navigator as any).gpu
+        if (!gpu) return null
+        const adapter = await gpu.requestAdapter()
+        if (!adapter) return null
+        const device = await adapter.requestDevice()
+        const context = el.getContext('webgpu') as GPUContext
+        if (!context) return null
+        const format = gpu.getPreferredCanvasFormat()
+        context.configure({ device, format })
+        return { device, context, format }
+}
+
+const defaultVertexWGSL = `
+@vertex
+fn main(@builtin(vertex_index) vertex_index: u32) -> @builtin(position) vec4f {
+  let x = f32(vertex_index % 2u) * 4.0 - 1.0;
+  let y = f32(vertex_index / 2u) * 4.0 - 1.0;
+  return vec4f(x, y, 0.0, 1.0);
+}
+`
+
+const defaultFragmentWGSL = `
+@fragment
+fn main(@builtin(position) position: vec4f) -> @location(0) vec4f {
+  return vec4f(position.xy / vec2f(1280, 800), 0.0, 1.0);
+}
+`
+
+export const createRenderPipeline = (
+        device: GPUDevice,
+        format: string,
+        vs = defaultVertexWGSL,
+        fs = defaultFragmentWGSL,
+        buffers: any[]
+) => {
+        return device.createRenderPipeline({
+                vertex: {
+                        module: device.createShaderModule({ code: vs.trim() }),
+                        entryPoint: 'main',
+                        buffers,
+                },
+                fragment: {
+                        module: device.createShaderModule({ code: fs.trim() }),
+                        entryPoint: 'main',
+                        targets: [{ format }],
+                },
+                layout: 'auto',
+                primitive: { topology: 'triangle-list' },
+        }) as GPUPipeline
+}
+
+export const createDescriptor = (c: GPUContext) => {
+        return {
+                colorAttachments: [
+                        {
+                                view: c.getCurrentTexture().createView(),
+                                clearValue: { r: 0, g: 0, b: 0, a: 1 },
+                                loadOp: 'clear',
+                                storeOp: 'store',
+                        },
+                ],
+        }
+}
+export const alignTo256 = (size: number) => Math.ceil(size / 256) * 256
+
+export const createUniformBuffer = (device: GPUDevice, size: number) => {
+        return device.createBuffer({ size: alignTo256(size), usage: 0x40 | 0x4 }) as Buffer
+}
+
+export const createVertexBuffer = (device: GPUDevice, value: number[]) => {
+        const array = new Float32Array(value)
+        const buffer = device.createBuffer({ size: array.byteLength, usage: 0x20 | 0x4 })
+        device.queue.writeBuffer(buffer, 0, array)
+        return buffer as Buffer
+}
+
+export const createBindGroup = (device: GPUDevice, pipeline: GPUPipeline, entries: any[]) => {
+        const layout = pipeline.getBindGroupLayout(0)
+        return device.createBindGroup({ layout, entries })
+}
+
+export const updateBindGroup = (
+        device: GPUDevice,
+        pipeline: GPUPipeline,
+        uniformBuffer: Buffer,
+        textures: any = {},
+        sampler: any = null
+) => {
+        const entries = [{ binding: 0, resource: { buffer: uniformBuffer } }]
+        let binding = 1
+        Object.values(textures).forEach((texture: any) => {
+                entries.push({ binding: binding++, resource: texture.createView() })
+        })
+        if (sampler && Object.keys(textures).length > 0) entries.push({ binding: binding++, resource: sampler })
+        return createBindGroup(device, pipeline, entries)
+}
+
+export const createUniform = (device: GPUDevice, buffer: any, data: Float32Array, offset = 0) => {
+        device.queue.writeBuffer(buffer, offset, data)
+}
+
+export const createDeviceTexture = (device: GPUDevice, image: HTMLImageElement) => {
+        const texture = device.createTexture({
+                size: { width: image.width, height: image.height },
+                format: 'rgba8unorm',
+                usage: 0x4 | 0x2,
+        })
+        device.queue.copyExternalImageToTexture(
+                { source: image },
+                { texture },
+                { width: image.width, height: image.height }
+        )
+        return texture
+}
+
+export const createSampler = (device: GPUDevice) => {
+        return device.createSampler({
+                magFilter: 'linear',
+                minFilter: 'linear',
+                addressModeU: 'clamp-to-edge',
+                addressModeV: 'clamp-to-edge',
+        })
+}
+
+export const getDefaultVertices = () => new Float32Array([-1, -1, 1, -1, -1, 1, -1, 1, 1, -1, 1, 1])

package/src/utils/program.ts

@@ -0,0 +1,94 @@
+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);
+}
+`
+
+export const createShader = (c: WebGLRenderingContext, source: string, type: number) => {
+        const shader = c.createShader(type)
+        if (!shader) throw new Error('Failed to create shader')
+        c.shaderSource(shader, source.trim())
+        c.compileShader(shader)
+        if (c.getShaderParameter(shader, c.COMPILE_STATUS)) return shader
+        const error = c.getShaderInfoLog(shader)
+        c.deleteShader(shader)
+        throw new Error(`Could not compile shader: ${error}`)
+}
+
+export const createProgram = (c: WebGLRenderingContext, vs = defaultVertexGLSL, fs = defaultFragmentGLSL) => {
+        const pg = c.createProgram()
+        c.attachShader(pg, createShader(c, vs, c.VERTEX_SHADER))
+        c.attachShader(pg, createShader(c, fs, c.FRAGMENT_SHADER))
+        c.linkProgram(pg)
+        if (c.getProgramParameter(pg, c.LINK_STATUS)) return pg
+        const error = c.getProgramInfoLog(pg)
+        c.deleteProgram(pg)
+        throw new Error(`Could not link pg: ${error}`)
+}
+
+export const createVbo = (c: WebGLRenderingContext, data: number[]) => {
+        const buffer = c.createBuffer()
+        c.bindBuffer(c.ARRAY_BUFFER, buffer)
+        c.bufferData(c.ARRAY_BUFFER, new Float32Array(data), c.STATIC_DRAW)
+        c.bindBuffer(c.ARRAY_BUFFER, null)
+        return buffer
+}
+
+export const createIbo = (c: WebGLRenderingContext, data: number[]) => {
+        const buffer = c.createBuffer()
+        c.bindBuffer(c.ELEMENT_ARRAY_BUFFER, buffer)
+        c.bufferData(c.ELEMENT_ARRAY_BUFFER, new Int16Array(data), c.STATIC_DRAW)
+        c.bindBuffer(c.ELEMENT_ARRAY_BUFFER, null)
+        return buffer
+}
+
+export const createAttrib = (
+        c: WebGLRenderingContext,
+        stride: number,
+        location: any,
+        vbo: WebGLBuffer,
+        ibo?: WebGLBuffer
+) => {
+        c.bindBuffer(c.ARRAY_BUFFER, vbo)
+        c.enableVertexAttribArray(location)
+        c.vertexAttribPointer(location, stride, c.FLOAT, false, 0, 0)
+        if (ibo) c.bindBuffer(c.ELEMENT_ARRAY_BUFFER, ibo)
+}
+
+export const createTexture = (c: WebGLRenderingContext, img: HTMLImageElement) => {
+        const texture = c.createTexture()
+        c.bindTexture(c.TEXTURE_2D, texture)
+        c.texImage2D(c.TEXTURE_2D, 0, c.RGBA, c.RGBA, c.UNSIGNED_BYTE, img)
+        c.generateMipmap(c.TEXTURE_2D)
+        c.texParameteri(c.TEXTURE_2D, c.TEXTURE_MIN_FILTER, c.LINEAR)
+        c.texParameteri(c.TEXTURE_2D, c.TEXTURE_MAG_FILTER, c.LINEAR)
+        c.texParameteri(c.TEXTURE_2D, c.TEXTURE_WRAP_S, c.CLAMP_TO_EDGE)
+        c.texParameteri(c.TEXTURE_2D, c.TEXTURE_WRAP_T, c.CLAMP_TO_EDGE)
+        c.bindTexture(c.TEXTURE_2D, null)
+        return texture
+}
+
+export const activeTexture = (
+        c: WebGLRenderingContext,
+        location: WebGLUniformLocation | null,
+        unit: number,
+        texture: WebGLTexture
+) => {
+        if (!location) return
+        c.uniform1i(location, unit)
+        c.activeTexture(c.TEXTURE0 + unit)
+        c.bindTexture(c.TEXTURE_2D, texture)
+}

package/src/webgl.ts

@@ -0,0 +1,78 @@
+import { nested } from 'reev'
+import { glsl } from './code/glsl'
+import { is } from './utils/helpers'
+import type { X } from './node'
+import type { GL } from './types'
+import { activeTexture, createAttrib, createIbo, createProgram, createTexture, createVbo } from './utils/program'
+
+export const webgl = async (gl: GL) => {
+        let vs = gl.vs || gl.vert || gl.vertex
+        let fs = gl.fs || gl.frag || gl.fragment
+        if (is.obj(fs)) fs = glsl(fs as X)
+        if (is.obj(vs)) vs = glsl(vs as X)
+        const c = gl.el.getContext('webgl2')!
+        const pg = createProgram(c, vs, fs)
+
+        let _activeUnit = 0
+        const activeUnits = nested(() => _activeUnit++)
+
+        const locations = nested((key, bool = false) => {
+                if (bool) return c.getAttribLocation(pg, key)
+                return c.getUniformLocation(pg, key) as WebGLUniformLocation
+        })
+
+        const strides = nested((_, count: number, value: number[], iboValue?: number[]) => {
+                if (iboValue) count = Math.max(...iboValue) + 1
+                const stride = value.length / count
+                if (stride !== Math.floor(stride)) console.warn(`Vertex Stride Error: count ${count} is mismatch`)
+                return Math.floor(stride)
+        })
+
+        const uniforms = nested((key, value: number | number[]) => {
+                const loc = locations(key)
+                if (is.num(value)) return (value: any) => c.uniform1f(loc, value)
+                let l = value.length as 3
+                if (l <= 4) return (value: any) => c[`uniform${l}fv`](loc, value)
+                l = (Math.sqrt(l) << 0) as 3
+                return (value: any) => c[`uniformMatrix${l}fv`](loc, false, value)
+        })
+
+        gl('clean', () => c.deleteProgram(pg))
+
+        gl('render', () => {
+                c.useProgram(pg)
+                gl.queue.flush()
+                c.clear(c.COLOR_BUFFER_BIT)
+                c.viewport(0, 0, ...gl.size)
+                c.drawArrays(c.TRIANGLES, 0, 3)
+        })
+
+        gl('_attribute', (key = '', value: number[], iboValue: number[]) => {
+                const loc = locations(key, true)
+                const vbo = createVbo(c, value)
+                const ibo = createIbo(c, iboValue)
+                const str = strides(key, gl.count, value, iboValue)
+                createAttrib(c, str, loc, vbo, ibo)
+        })
+
+        gl('_uniform', (key: string, value: number | number[]) => {
+                uniforms(key, value)(value)
+        })
+
+        const _loadFn = (image: HTMLImageElement) => {
+                const loc = locations(image.alt)
+                const unit = activeUnits(image.alt)
+                const tex = createTexture(c, image)
+                activeTexture(c, loc, unit, tex)
+        }
+
+        gl('_texture', (alt: string, src: string) => {
+                const image = new Image()
+                image.addEventListener('load', _loadFn.bind(null, image), false)
+                Object.assign(image, { src, alt, crossOrigin: 'anonymous' })
+        })
+
+        gl.webgl = { context: c, program: pg }
+
+        return gl
+}

package/src/webgpu.ts

@@ -0,0 +1,70 @@
+import { wgsl } from './code/wgsl'
+import { is } from './utils/helpers'
+import {
+        createRenderPipeline,
+        createDescriptor,
+        // createUniformBuffer,
+        // updateBindGroup,
+        // createVertexBuffer,
+        // createUniform,
+        // createDeviceTexture,
+        // createSampler,
+} from './utils/pipeline'
+import type { X } from './node'
+import type { GL, GPUPipeline } from './types'
+
+const quadVertexCount = 3
+
+export const webgpu = async (gl: GL) => {
+        let vs = gl.vs || gl.vert || gl.vertex
+        let fs = gl.fs || gl.frag || gl.fragment
+        if (is.obj(vs)) vs = wgsl(vs as X)
+        if (is.obj(fs)) fs = wgsl(fs as X)
+        const c = gl.el.getContext('webgpu') as any
+        const gpu = (navigator as any).gpu
+        const adapter = await gpu.requestAdapter()
+        const device = await adapter.requestDevice()
+        const format = gpu.getPreferredCanvasFormat()
+        c.configure({ device, format, alphaMode: 'opaque' })
+
+        gl('clean', () => {})
+
+        let pipeline: GPUPipeline
+
+        gl('render', () => {
+                if (!pipeline) pipeline = createRenderPipeline(device, format, vs, fs, [])
+                const encoder = device.createCommandEncoder()
+                const pass = encoder.beginRenderPass(createDescriptor(c))
+                pass.setPipeline(pipeline)
+                pass.draw(quadVertexCount, 1, 0, 0)
+                pass.end()
+                device.queue.submit([encoder.finish()])
+        })
+
+        gl('_attribute', (key = '', value: number[]) => {
+                // @TODO FIX
+                // vertexBuffers(key, value)
+        })
+
+        gl('_uniform', (key: string, value = 0) => {
+                // @TODO FIX
+                // if (!device || !uniformBuffer) return
+                // uniforms[key] = value
+                // const uniformData = new Float32Array(Object.values(uniforms))
+                // createUniform(device, uniformBuffer, uniformData)
+        })
+
+        // const _loadFun = (image: HTMLImageElement, gl: GL) => {
+        //         const texture = createDeviceTexture(device, image)
+        //         // bindGroup = updateBindGroup(device, pipeline, uniformBuffer, textures, sampler)
+        // }
+
+        gl('_texture', (alt: string, src: string) => {
+                // @TODO FIX
+                // const image = new Image()
+                // image.addEventListener('load', _loadFun.bind(null, image, gl), false)
+                // Object.assign(image, { src, alt, crossOrigin: 'anonymous' })
+        })
+
+        return gl
+}

package/src/webgl/buffer.ts

@@ -1,78 +0,0 @@
-// WebGLバッファー作成と管理
-export const createVbo = (c: WebGLRenderingContext, data: number[]) => {
-        const buffer = c.createBuffer()
-        if (!buffer) throw new Error('Failed to create VBO')
-        c.bindBuffer(c.ARRAY_BUFFER, buffer)
-        c.bufferData(c.ARRAY_BUFFER, new Float32Array(data), c.STATIC_DRAW)
-        c.bindBuffer(c.ARRAY_BUFFER, null)
-        return buffer
-}
-
-// インデックスバッファーオブジェクト作成
-export const createIbo = (c: WebGLRenderingContext, data: number[]) => {
-        const buffer = c.createBuffer()
-        if (!buffer) throw new Error('Failed to create IBO')
-        c.bindBuffer(c.ELEMENT_ARRAY_BUFFER, buffer)
-        c.bufferData(
-                c.ELEMENT_ARRAY_BUFFER,
-                new Int16Array(data),
-                c.STATIC_DRAW
-        )
-        c.bindBuffer(c.ELEMENT_ARRAY_BUFFER, null)
-        return buffer
-}
-
-// アトリビュート設定
-export const createAttribute = (
-        c: WebGLRenderingContext,
-        stride: number,
-        location: number,
-        vbo: WebGLBuffer,
-        ibo?: WebGLBuffer
-) => {
-        c.bindBuffer(c.ARRAY_BUFFER, vbo)
-        c.enableVertexAttribArray(location)
-        c.vertexAttribPointer(location, stride, c.FLOAT, false, 0, 0)
-        if (ibo) c.bindBuffer(c.ELEMENT_ARRAY_BUFFER, ibo)
-}
-
-// バッファーの削除
-export const deleteBuffer = (c: WebGLRenderingContext, buffer: WebGLBuffer) => {
-        c.deleteBuffer(buffer)
-}
-
-// 頂点ストライドを計算
-export const vertexStride = (
-        count: number,
-        value: number[],
-        iboValue?: number[]
-) => {
-        if (iboValue) count = Math.max(...iboValue) + 1
-        const stride = value.length / count
-        if (stride !== Math.floor(stride))
-                console.warn(`Vertex Stride Error: count ${count} is mismatch`)
-        return Math.floor(stride)
-}
-
-// バッファーデータの更新
-export const updateVbo = (
-        c: WebGLRenderingContext,
-        buffer: WebGLBuffer,
-        data: number[],
-        usage = c.STATIC_DRAW
-) => {
-        c.bindBuffer(c.ARRAY_BUFFER, buffer)
-        c.bufferData(c.ARRAY_BUFFER, new Float32Array(data), usage)
-        c.bindBuffer(c.ARRAY_BUFFER, null)
-}
-
-export const updateIbo = (
-        c: WebGLRenderingContext,
-        buffer: WebGLBuffer,
-        data: number[],
-        usage = c.STATIC_DRAW
-) => {
-        c.bindBuffer(c.ELEMENT_ARRAY_BUFFER, buffer)
-        c.bufferData(c.ELEMENT_ARRAY_BUFFER, new Int16Array(data), usage)
-        c.bindBuffer(c.ELEMENT_ARRAY_BUFFER, null)
-}

package/src/webgl/index.ts

@@ -1,79 +0,0 @@
-import { nested } from 'reev'
-import { createAttribute, createIbo, createVbo, vertexStride } from './buffer'
-import { createProgram, deleteProgram, getUniformType } from './program'
-import { createFragmentShader, createVertexShader } from './shader'
-import { activeTexture, createTexture } from './texture'
-import { glsl } from '../code/glsl'
-import { is } from '../utils'
-import type { X } from '../node'
-import type { GL } from '../types'
-export * from './buffer'
-export * from './program'
-export * from './shader'
-export * from './texture'
-
-const a_position = [-1, -1, 1, -1, -1, 1, -1, 1, 1, -1, 1, 1]
-
-export const webgl = (gl: GL) => {
-        gl('init', () => {
-                const c = gl.gl
-                let vs = gl.vs || gl.vert || gl.vertex
-                let fs = gl.fs || gl.frag || gl.fragment
-                if (is.obj(fs)) fs = glsl(fs as X)
-                if (is.obj(vs)) vs = glsl(vs as X)
-                if (gl.count === 6) gl.attribute({ a_position })
-                gl.pg = createProgram(c, createVertexShader(c, vs), createFragmentShader(c, fs))
-                gl.location = nested((key, isAttribute = false) => {
-                        return isAttribute ? c.getAttribLocation(gl.pg, key) : c.getUniformLocation(gl.pg, key)
-                })
-        })
-
-        gl('clean', () => {
-                const c = gl.gl
-                deleteProgram(c, gl.pg)
-        })
-
-        gl('render', () => {
-                const c = gl.gl
-                c.useProgram(gl.pg)
-                gl.queue.flush()
-                c.clear(c.COLOR_BUFFER_BIT)
-                c.viewport(0, 0, ...gl.size)
-                c.drawArrays(c.TRIANGLES, 0, gl.count)
-        })
-
-        gl('_attribute', (key = '', value: number[], iboValue: number[]) => {
-                const c = gl.gl
-                const n = gl.count
-                const loc = gl.location(key, true)
-                const vbo = createVbo(c, value)
-                const ibo = createIbo(c, iboValue)
-                const stride = vertexStride(n, value, iboValue)
-                createAttribute(c, stride, loc, vbo, ibo)
-        })
-
-        gl('_uniform', (key: string, value = 0, isMatrix = false) => {
-                const type = getUniformType(value, isMatrix)
-                const c = gl.gl
-                const loc = gl.location(key)
-                if (isMatrix) c[type](loc, false, value)
-                else c[type](loc, value)
-        })
-
-        const _loadFn = (image: HTMLImageElement) => {
-                const loc = gl.location(image.alt)
-                const unit = gl.activeUnit(image.alt)
-                const tex = createTexture(gl.gl, image)
-                activeTexture(gl.gl, loc, unit, tex)
-        }
-
-        gl('_texture', (alt: string, src: string) => {
-                const image = new Image()
-                image.addEventListener('load', _loadFn.bind(null, image), false)
-                Object.assign(image, { src, alt, crossOrigin: 'anonymous' })
-        })
-
-        let _activeUnit = 0
-        gl.activeUnit = nested(() => _activeUnit++)
-        return gl
-}

package/src/webgl/program.ts

@@ -1,61 +0,0 @@
-// WebGLプログラム作成と管理
-export const createProgram = (
-        c: WebGLRenderingContext,
-        vs: WebGLShader,
-        fs: WebGLShader
-) => {
-        const pg = c.createProgram()
-        if (!pg) throw new Error('Failed to create pg')
-        c.attachShader(pg, vs)
-        c.attachShader(pg, fs)
-        c.linkProgram(pg)
-        if (c.getProgramParameter(pg, c.LINK_STATUS)) return pg
-        const error = c.getProgramInfoLog(pg)
-        c.deleteProgram(pg)
-        throw new Error(`Could not link pg: ${error}`)
-}
-
-// プログラムの削除
-export const deleteProgram = (c: WebGLRenderingContext, pg: WebGLProgram) => {
-        c.deleteProgram(pg)
-}
-
-// プログラムの情報を取得
-export const getProgramInfo = (c: WebGLRenderingContext, pg: WebGLProgram) => {
-        return {
-                linked: c.getProgramParameter(pg, c.LINK_STATUS),
-                log: c.getProgramInfoLog(pg),
-                activeAttributes: c.getProgramParameter(
-                        pg,
-                        c.ACTIVE_ATTRIBUTES
-                ),
-                activeUniforms: c.getProgramParameter(pg, c.ACTIVE_UNIFORMS),
-        }
-}
-
-//  ユニフォームタイプの取得
-export const getUniformType = (value: number | number[], isMatrix = false) => {
-        let length = typeof value === 'number' ? 0 : value?.length
-        if (!length) return `uniform1f`
-        if (!isMatrix) return `uniform${length}fv`
-        length = Math.sqrt(length) << 0
-        return `uniformMatrix${length}fv`
-}
-
-// ユニフォーム位置を取得
-export const getUniformLocation = (
-        c: WebGLRenderingContext,
-        pg: WebGLProgram,
-        name: string
-) => {
-        return c.getUniformLocation(pg, name)
-}
-
-// アトリビュート位置を取得
-export const getAttribLocation = (
-        c: WebGLRenderingContext,
-        pg: WebGLProgram,
-        name: string
-) => {
-        return c.getAttribLocation(pg, name)
-}

package/src/webgl/shader.ts

@@ -1,60 +0,0 @@
-const defaultVertexShader = /* cpp */ `
-attribute vec4 a_position;
-void main() {
-  gl_Position = a_position;
-}
-`
-
-const defaultFragmentShader = /* cpp */ `
-precision mediump float;
-uniform vec2 iResolution;
-void main() {
-  gl_FragColor = vec4(fract(gl_FragCoord.xy / iResolution), 0, 1);
-}
-`
-
-export const deleteShader = (c: WebGLRenderingContext, shader: WebGLShader) => {
-        c.deleteShader(shader)
-}
-
-// WebGLシェーダー作成と管理
-const createShader = (
-        c: WebGLRenderingContext,
-        source: string,
-        type: number
-) => {
-        const shader = c.createShader(type)
-        if (!shader) throw new Error('Failed to create shader')
-        c.shaderSource(shader, source)
-        c.compileShader(shader)
-        if (c.getShaderParameter(shader, c.COMPILE_STATUS)) return shader
-        const error = c.getShaderInfoLog(shader)
-        deleteShader(c, shader)
-        throw new Error(`Could not compile shader: ${error}`)
-}
-
-export const createVertexShader = (
-        c: WebGLRenderingContext,
-        source = defaultVertexShader
-) => {
-        return createShader(c, source, c.VERTEX_SHADER)
-}
-
-export const createFragmentShader = (
-        c: WebGLRenderingContext,
-        source = defaultFragmentShader
-) => {
-        return createShader(c, source, c.FRAGMENT_SHADER)
-}
-
-// シェーダーの情報を取得
-export const getShaderInfo = (
-        c: WebGLRenderingContext,
-        shader: WebGLShader
-) => {
-        return {
-                compiled: c.getShaderParameter(shader, c.COMPILE_STATUS),
-                log: c.getShaderInfoLog(shader),
-                source: c.getShaderSource(shader),
-        }
-}