@bigmistqke/view.gl 0.2.0 → 0.4.0

package/src/tag.ts

@@ -18,7 +18,7 @@ import type {
   ViewSchema,
   ViewSchemaPartial,
 } from './types'
-import { createUpsertMap } from './utils'
+import { createUpsertMap, once } from './utils'
 
 export function glsl<TSlot extends GLSLSlot, const TSlots extends TSlot[]>(
   template: TemplateStringsArray,
@@ -99,6 +99,11 @@ export function interleave<
 export interface CompileOptions<TSchema extends ViewSchemaPartial> {
   schema?: TSchema
   webgl2?: boolean
+  /**
+   * Disposes what `compile` made: the program, and the buffers the view created
+   * for itself. Buffers named by the schema belong to whoever made them.
+   */
+  signal?: AbortSignal
 }
 
 export function compile<
@@ -127,6 +132,11 @@ export function compile<
       ..._vertex.schema.interleavedAttributes,
       ..._fragment.schema.interleavedAttributes,
     },
+    // Never produced by a tag — a buffer has no name in the source to be
+    // parsed out of one — but `options.schema` may name buffers for the view to
+    // own, and the deep merge below indexes this object by every key it finds
+    // there. Missing, that threw.
+    buffers: {} as NonNullable<ViewSchema['buffers']>,
   }
 
   // Deep merge options.schema with generated schema
@@ -145,10 +155,21 @@ export function compile<
   try {
     const program = createProgram(gl, _vertex.template, _fragment.template)
 
+    // The same rule the views follow: `compile` made this program, so `compile`
+    // is what deletes it. A program handed in from outside would not be ours to
+    // delete, and there is no way to hand one in.
+    const resolvedView = view(gl, program, schema)
+    const dispose = once(() => {
+      resolvedView.dispose()
+      gl.deleteProgram(program)
+    })
+    options?.signal?.addEventListener('abort', dispose)
+
     return {
       program,
       schema,
-      view: view(gl, program, schema),
+      view: resolvedView,
+      dispose,
       vertex: _vertex.template,
       fragment: _fragment.template,
     } as unknown as Prettify<CompileResult<TVertex, TFragment, TSchema>>

package/src/types.ts

@@ -365,6 +365,15 @@ export interface AttributeMethods<T extends AttributeDefinition = AttributeDefin
    */
   bind(): () => void
   set(data: FormatToArray[ResolvedFormat<T>], usage?: GLUsage): { bind(): () => void }
+  /**
+   * Delete the buffer, if this attribute is the one that made it.
+   *
+   * A buffer named by the schema came from somewhere else and is deleted by
+   * whoever made it — a shared buffer is the point of passing one in, and one
+   * view cannot know whether the others are done. So this is safe to call
+   * twice and safe to call on a borrowed buffer, and it is not a way to free
+   * one: dispose the view that created it.
+   */
   dispose(): void
 }
 
@@ -502,6 +511,12 @@ export interface TextureDefinition {
 export interface Framebuffer {
   texture: WebGLTexture
   framebuffer: WebGLFramebuffer
+  /**
+   * Delete the framebuffer, and the texture only if `createFramebuffer` made
+   * it. A texture handed in belongs to whoever made it. Idempotent, and exactly
+   * what aborting the signal does.
+   */
+  dispose(): void
 }
 
 /**********************************************************************************/
@@ -617,6 +632,21 @@ export interface ViewOptions {
   signal?: AbortSignal
 }
 
+/**
+ * What a view builds for one program.
+ *
+ * A buffer declared here is OWNED by the view: it lives and dies with it, on
+ * the one signal, which is the common case — an index buffer whose lifetime is
+ * its program's has no reason to be declared apart from the attributes it is
+ * drawn with.
+ *
+ * The other two lifetimes have their own spellings, and neither is this one. A
+ * buffer that outlives the view, or is shared between views, is a standalone
+ * `bufferView` — `compile.toQuad`'s per-context quad, a buffer handed from one
+ * program's view to another's. A buffer that belongs to somebody else is NAMED
+ * by an attribute schema, and is borrowed: the view uses it and never deletes
+ * it.
+ */
 export interface ViewSchema {
   uniforms?: UniformSchema
   attributes?: AttributeSchema
@@ -641,8 +671,8 @@ export type View<T extends ViewSchema = ViewSchema> = {
   interleavedAttributes: T['interleavedAttributes'] extends InterleavedAttributeSchema
     ? Prettify<InterleavedAttributeView<T['interleavedAttributes']>>
     : {}
-  buffers: T['buffers'] extends BufferSchema ? Prettify<BufferView<T['buffers']>> : {}
   uniforms: T['uniforms'] extends UniformSchema ? Prettify<UniformView<T['uniforms']>> : {}
+  buffers: T['buffers'] extends BufferSchema ? Prettify<BufferView<T['buffers']>> : {}
   /**
    * Build a vertex array from the participants one draw needs — its attributes,
    * its interleaved layouts, its element buffer.
@@ -653,6 +683,13 @@ export type View<T extends ViewSchema = ViewSchema> = {
    * something you say rather than something you inherit from call order.
    */
   vao(participants: VertexArrayParticipant[]): VertexArrayMethods
+  /**
+   * Delete everything the view made: the buffers behind its attributes and
+   * layouts, and any vertex array still held from `vao()`. Buffers named by the
+   * schema are left alone — those belong to whoever made them. Idempotent, and
+   * exactly what aborting the signal does.
+   */
+  dispose(): void
 }
 
 /**********************************************************************************/
@@ -881,5 +918,10 @@ export type CompileResult<
         view: Prettify<View<TSchema>>
         vertex: string
         fragment: string
+        /**
+         * Delete the program and everything its view made. Idempotent, and
+         * exactly what aborting the signal does.
+         */
+        dispose(): void
       }
     : never

package/src/utils.ts

@@ -6,6 +6,7 @@ import type {
   KIND_TO_UNIFORM_FN_NAME_MAP,
   TextureDefinition,
   UniformKind,
+  ViewOptions,
 } from './types'
 
 export function assertedNotNullish<T>(value: T, message?: string): NonNullable<T> {
@@ -13,6 +14,24 @@ export function assertedNotNullish<T>(value: T, message?: string): NonNullable<T
   return value
 }
 
+/**
+ * Wraps a teardown so it runs once.
+ *
+ * Two reasons, and both bite. A disposer is per `bind()`, and undoing twice
+ * would put back state a later `bind()` is relying on. And a `dispose()` that
+ * deletes twice invalidates a handle someone else may still be holding — the
+ * object survives while it is bound, so the fault surfaces later, somewhere
+ * else. Idempotent is the only safe shape for either.
+ */
+export function once(teardown: () => void): () => void {
+  let done = false
+  return () => {
+    if (done) return
+    done = true
+    teardown()
+  }
+}
+
 /**********************************************************************************/
 /*                                                                                */
 /*                              Kind To Uniform Name                              */
@@ -114,8 +133,9 @@ export function createTexture(
     height,
   }: TextureDefinition,
   data?: ArrayBufferView | null,
+  { signal }: ViewOptions = {},
 ): WebGLTexture {
-  const texture = gl.createTexture()
+  const texture = assertedNotNullish(gl.createTexture(), 'Failed to create texture')
 
   function getTextureConstant(name: string) {
     if (!(name in gl)) {
@@ -137,13 +157,17 @@ export function createTexture(
     data ?? null,
   )
 
-  console.log(minFilter)
   // Set texture parameters
   gl.texParameteri(gl[target], gl.TEXTURE_MIN_FILTER, gl[minFilter])
   gl.texParameteri(gl[target], gl.TEXTURE_MAG_FILTER, gl[magFilter])
   gl.texParameteri(gl[target], gl.TEXTURE_WRAP_S, gl[wrapS])
   gl.texParameteri(gl[target], gl.TEXTURE_WRAP_T, gl[wrapT])
 
+  signal?.addEventListener(
+    'abort',
+    once(() => gl.deleteTexture(texture)),
+  )
+
   return texture
 }
 
@@ -162,7 +186,7 @@ const FRAMEBUFFER_ATTACHMENT_MAP = {
 
 class FramebufferError extends Error {
   constructor(gl: GL, status: number) {
-    let errorMessage = `Framebuffer '${name}' not complete. Status: `
+    let errorMessage = 'Framebuffer not complete. Status: '
     switch (status) {
       case gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
         errorMessage += 'FRAMEBUFFER_INCOMPLETE_ATTACHMENT'
@@ -185,16 +209,15 @@ class FramebufferError extends Error {
 
 export function createFramebuffer(
   gl: GL,
-  { attachment, texture, ...options }: FramebufferDefinition,
+  { attachment, texture: providedTexture, ...definition }: FramebufferDefinition,
+  { signal }: ViewOptions = {},
 ) {
-  // Create texture for the framebuffer
-  texture ??= createTexture(gl, options)
+  // Create texture for the framebuffer, unless one was handed in. Which one it
+  // is decides who deletes it below — the same rule the attribute buffers follow.
+  const texture = providedTexture ?? createTexture(gl, definition)
 
   // Create framebuffer
-  const framebuffer = assertedNotNullish(
-    gl.createFramebuffer(),
-    `Failed to create framebuffer: ${name}`,
-  )
+  const framebuffer = assertedNotNullish(gl.createFramebuffer(), 'Failed to create framebuffer')
 
   gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer)
 
@@ -213,9 +236,21 @@ export function createFramebuffer(
     throw new FramebufferError(gl, status)
   }
 
+  const dispose = once(() => {
+    gl.deleteFramebuffer(framebuffer)
+    // A texture handed in belongs to whoever made it — it commonly outlives the
+    // framebuffer, ping-ponged between two of them.
+    if (!providedTexture) {
+      gl.deleteTexture(texture)
+    }
+  })
+
+  signal?.addEventListener('abort', dispose)
+
   return {
     texture,
     framebuffer,
+    dispose,
   }
 }
 

package/test/index.test.ts

@@ -2,6 +2,8 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 import {
   attributeView,
   bufferView,
+  createFramebuffer,
+  createTexture,
   interleavedAttributeView,
   uniformView,
   vaoView,
@@ -45,7 +47,6 @@ describe('view', () => {
     expect(result.uniforms!.u_texture.set).toBeInstanceOf(Function)
     expect(result.attributes).toBeUndefined()
     expect(result.interleavedAttributes).toBeUndefined()
-    expect(result.buffers).toBeUndefined()
   })
 
   it('should create a view with attributes', () => {
@@ -91,23 +92,6 @@ describe('view', () => {
     expect(result.interleavedAttributes!.data.buffer.set).toBeInstanceOf(Function)
   })
 
-  it('should create a view with buffers', () => {
-    const schema = {
-      buffers: {
-        vertices: { target: 'ARRAY_BUFFER', usage: 'STATIC_DRAW' },
-        indices: { target: 'ELEMENT_ARRAY_BUFFER', usage: 'DYNAMIC_DRAW' },
-      },
-    } satisfies ViewSchema
-
-    const result = view(gl, program, schema)
-
-    expect(result.buffers).toBeDefined()
-    expect(result.buffers!.vertices).toBeDefined()
-    expect(result.buffers!.vertices.bind).toBeInstanceOf(Function)
-    expect(result.buffers!.vertices.dispose).toBeInstanceOf(Function)
-    expect(result.buffers!.vertices.set).toBeInstanceOf(Function)
-  })
-
   it('should create a view with all components', () => {
     const schema = {
       uniforms: {
@@ -122,9 +106,6 @@ describe('view', () => {
           instanced: false,
         },
       },
-      buffers: {
-        vertices: {},
-      },
     } satisfies ViewSchema
 
     const result = view(gl, program, schema)
@@ -132,14 +113,12 @@ describe('view', () => {
     expect(result.uniforms).toBeDefined()
     expect(result.attributes).toBeDefined()
     expect(result.interleavedAttributes).toBeDefined()
-    expect(result.buffers).toBeDefined()
   })
 
   it('should create a view with symbols for all component types', () => {
     const u_time_symbol = Symbol('u_time')
     const a_position_symbol = Symbol('a_position')
     const data_symbol = Symbol('data')
-    const vertices_symbol = Symbol('vertices')
     
     const schema = {
       uniforms: {
@@ -154,9 +133,6 @@ describe('view', () => {
           instanced: false,
         },
       },
-      buffers: {
-        [vertices_symbol]: {},
-      },
     } satisfies ViewSchema
 
     const result = view(gl, program, schema)
@@ -169,9 +145,6 @@ describe('view', () => {
     
     expect(result.interleavedAttributes![data_symbol]).toBeDefined()
     expect(result.interleavedAttributes![data_symbol].buffer.bind).toBeInstanceOf(Function)
-    
-    expect(result.buffers![vertices_symbol]).toBeDefined()
-    expect(result.buffers![vertices_symbol].bind).toBeInstanceOf(Function)
   })
 
   it('should create a view with mixed string and symbol keys', () => {
@@ -201,6 +174,94 @@ describe('view', () => {
   })
 })
 
+describe('disposing a view', () => {
+  let gl: WebGL2RenderingContext
+  let program: WebGLProgram
+  beforeEach(() => {
+    const mock = createMockCanvas()
+    gl = mock.gl
+    program = gl.createProgram()!
+  })
+
+  const schema = {
+    attributes: { a_position: { kind: 'vec2' } },
+    interleavedAttributes: { data: { layout: [{ key: 'a_uv', kind: 'vec2' }] } },
+  } satisfies ViewSchema
+
+  it('deletes the buffers it made, and the arrays it handed out', () => {
+    const result = view(gl, program, schema)
+    const vertexArray = result.vao([result.attributes.a_position])
+
+    result.dispose()
+
+    expect(gl.deleteBuffer).toHaveBeenCalledTimes(2)
+    expect(gl.deleteVertexArray).toHaveBeenCalledTimes(1)
+    void vertexArray
+  })
+
+  it('does the same thing on abort as it does on dispose', () => {
+    const controller = new AbortController()
+    const result = view(gl, program, schema, { signal: controller.signal })
+    result.vao([result.attributes.a_position])
+
+    controller.abort()
+    const afterAbort = (gl.deleteBuffer as any).mock.calls.length
+
+    // Both routes lead to the same teardown, so taking both must not delete
+    // twice: the second delete would invalidate a handle someone else holds.
+    result.dispose()
+    expect((gl.deleteBuffer as any).mock.calls).toHaveLength(afterAbort)
+    expect(gl.deleteVertexArray).toHaveBeenCalledTimes(1)
+  })
+
+  it('deletes a buffer the schema declared, on its own signal', () => {
+    // The regression this key exists for. It used to be built with the options
+    // dropped — `bufferView(gl, schema.buffers)` — so a view's buffers were the
+    // only resources it did not dispose, and every caller had to remember one
+    // extra line beside an abort that covered everything else.
+    const controller = new AbortController()
+    const withBuffer = {
+      attributes: { a_position: { kind: 'vec2' } },
+      buffers: { b_index: { target: 'ELEMENT_ARRAY_BUFFER' } },
+    } satisfies ViewSchema
+    const result = view(gl, program, withBuffer, { signal: controller.signal })
+    void result.buffers.b_index
+
+    controller.abort()
+
+    // The attribute's buffer and the declared one.
+    expect(gl.deleteBuffer).toHaveBeenCalledTimes(2)
+  })
+
+  it('leaves a buffer the schema NAMED to whoever made it', () => {
+    // Borrowed, not owned — the other half of the rule. A named buffer is the
+    // point of sharing one, and one view cannot know whether the others are
+    // done with it.
+    const borrowed = bufferView(gl, { shared: { target: 'ARRAY_BUFFER' } })
+    ;(gl.deleteBuffer as any).mockClear()
+    const result = view(gl, program, {
+      attributes: { a_position: { kind: 'vec2', buffer: borrowed.shared } },
+    } satisfies ViewSchema)
+
+    result.dispose()
+
+    expect(gl.deleteBuffer).not.toHaveBeenCalled()
+  })
+
+  it('forgets a vertex array the caller disposed itself', () => {
+    const result = view(gl, program, schema)
+    const vertexArray = result.vao([result.attributes.a_position])
+
+    vertexArray.dispose()
+    vertexArray.dispose()
+    result.dispose()
+
+    // Held only until disposed, so a view handing out an array per frame does
+    // not accumulate them — and disposing one twice deletes it once.
+    expect(gl.deleteVertexArray).toHaveBeenCalledTimes(1)
+  })
+})
+
 describe('uniformView', () => {
   let gl: ReturnType<typeof createMockGL>
   let program: WebGLProgram
@@ -482,6 +543,28 @@ describe('attributeView', () => {
     expect(gl.createBuffer).toHaveBeenCalledTimes(1) // Only for the custom buffer
   })
 
+  it('does not delete a buffer it did not create', () => {
+    const customBuffer = gl.createBuffer()!
+    const controller = new AbortController()
+    const attributes = attributeView(
+      gl,
+      program,
+      {
+        a_position: { kind: 'vec2', buffer: customBuffer },
+        a_normal: { kind: 'vec2' },
+      } satisfies AttributeSchema,
+      { signal: controller.signal },
+    )
+    const own = attributes.a_normal.buffer
+
+    controller.abort()
+
+    // A schema can name a buffer another view owns — compile.toQuad shares one
+    // across every program on a context — and disposing here must not take it.
+    expect(gl.deleteBuffer).not.toHaveBeenCalledWith(customBuffer)
+    expect(gl.deleteBuffer).toHaveBeenCalledWith(own)
+  })
+
   it('should handle float attributes', () => {
     const schema = {
       a_scalar: { kind: 'float' },
@@ -1445,3 +1528,36 @@ describe('the constant source', () => {
     expect(() => a_instance.constant).toThrow(/cannot be a constant attribute/)
   })
 })
+
+describe('createFramebuffer', () => {
+  let gl: ReturnType<typeof createMockGL>
+
+  beforeEach(() => {
+    gl = createMockGL()
+    gl.checkFramebufferStatus = vi.fn(() => gl.FRAMEBUFFER_COMPLETE) as any
+  })
+
+  const definition = { attachment: 'color', width: 4, height: 4 } as const
+
+  it('deletes the texture it made', () => {
+    const controller = new AbortController()
+    const { texture } = createFramebuffer(gl, definition, { signal: controller.signal })
+
+    controller.abort()
+
+    expect(gl.deleteTexture).toHaveBeenCalledWith(texture)
+  })
+
+  it('leaves a texture it was handed', () => {
+    // Ping-ponged textures outlive the framebuffers pointing at them, so the
+    // one case that matters is the one where the texture came from outside.
+    const texture = createTexture(gl, { width: 4, height: 4 })
+    const target = createFramebuffer(gl, { ...definition, texture })
+
+    target.dispose()
+    target.dispose()
+
+    expect(gl.deleteFramebuffer).toHaveBeenCalledTimes(1)
+    expect(gl.deleteTexture).not.toHaveBeenCalled()
+  })
+})

package/test/mocks/webgl.ts

@@ -64,6 +64,20 @@ export function createMockGL() {
     LINEAR: 0x2601,
     TEXTURE_MAG_FILTER: 0x2800,
     TEXTURE_MIN_FILTER: 0x2801,
+    TEXTURE_WRAP_S: 0x2802,
+    TEXTURE_WRAP_T: 0x2803,
+    CLAMP_TO_EDGE: 0x812f,
+    REPEAT: 0x2901,
+    RGBA: 0x1908,
+    RGB: 0x1907,
+    DEPTH_ATTACHMENT: 0x8d00,
+    STENCIL_ATTACHMENT: 0x8d20,
+    DEPTH_STENCIL_ATTACHMENT: 0x821a,
+    FRAMEBUFFER_COMPLETE: 0x8cd5,
+    FRAMEBUFFER_INCOMPLETE_ATTACHMENT: 0x8cd6,
+    FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: 0x8cd7,
+    FRAMEBUFFER_INCOMPLETE_DIMENSIONS: 0x8cd9,
+    FRAMEBUFFER_UNSUPPORTED: 0x8cdd,
 
     // Buffer methods
     createBuffer: vi.fn(() => {

package/test/tag.test.ts

@@ -1205,6 +1205,47 @@ describe('compile', () => {
     gl.createProgram = vi.fn(() => mockProgram)
   })
 
+  it('disposes the same way whether by hand or by signal', () => {
+    const vertex = glsl`${attribute.vec2('a_position')}
+      void main() { gl_Position = vec4(a_position, 0.0, 1.0); }`
+    const fragment = glsl`void main() {}`
+    gl.deleteProgram = vi.fn()
+    gl.deleteBuffer = vi.fn()
+
+    const controller = new AbortController()
+    const result = compile(gl as WebGLRenderingContext, vertex, fragment, {
+      signal: controller.signal,
+    })
+
+    controller.abort()
+    result.dispose()
+
+    // Idempotent across both routes: the program and the view's own buffer go
+    // exactly once, however many times teardown is asked for.
+    expect(gl.deleteProgram).toHaveBeenCalledTimes(1)
+    expect(gl.deleteBuffer).toHaveBeenCalledTimes(1)
+  })
+
+  it('deletes the program it created, and nothing it borrowed', () => {
+    const vertex = glsl`${attribute.vec2('a_position')}
+      void main() { gl_Position = vec4(a_position, 0.0, 1.0); }`
+    const fragment = glsl`void main() {}`
+    const borrowed = gl.createBuffer()!
+    gl.deleteProgram = vi.fn()
+    gl.deleteBuffer = vi.fn()
+
+    const controller = new AbortController()
+    compile(gl as WebGLRenderingContext, vertex, fragment, {
+      signal: controller.signal,
+      schema: { attributes: { a_position: { buffer: borrowed } } },
+    })
+
+    controller.abort()
+
+    expect(gl.deleteProgram).toHaveBeenCalledWith(mockProgram)
+    expect(gl.deleteBuffer).not.toHaveBeenCalledWith(borrowed)
+  })
+
   it('should compile shaders and return program with schema', () => {
     const vertex = glsl`
       ${attribute.vec2('a_position')}

package/dist/chunk-CJTT7WPV.mjs

@@ -1,75 +0,0 @@
-// src/gl.ts
-function isWebGL2RenderingContext(gl) {
-  return typeof WebGL2RenderingContext !== "undefined" && gl instanceof WebGL2RenderingContext;
-}
-function createShader(gl, type, source) {
-  const shader = gl.createShader(type);
-  if (!shader) throw new Error("Failed to create shader");
-  gl.shaderSource(shader, source);
-  gl.compileShader(shader);
-  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-    const info = gl.getShaderInfoLog(shader);
-    gl.deleteShader(shader);
-    throw new Error(
-      `Failed to compile ${type === gl.VERTEX_SHADER ? "vertex" : "fragment"} shader: ${info}`
-    );
-  }
-  return shader;
-}
-function createProgram(gl, vertexSource, fragmentSource) {
-  const program = gl.createProgram();
-  if (!program) throw new Error("Failed to create WebGL program");
-  const vertexShader = createShader(gl, gl.VERTEX_SHADER, vertexSource);
-  const fragmentShader = createShader(gl, gl.FRAGMENT_SHADER, fragmentSource);
-  gl.attachShader(program, vertexShader);
-  gl.attachShader(program, fragmentShader);
-  gl.linkProgram(program);
-  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
-    const info = gl.getProgramInfoLog(program);
-    gl.deleteProgram(program);
-    gl.deleteShader(vertexShader);
-    gl.deleteShader(fragmentShader);
-    throw new Error(`Failed to link program: ${info}`);
-  }
-  gl.deleteShader(vertexShader);
-  gl.deleteShader(fragmentShader);
-  return program;
-}
-var INSTANCED_ARRAYS_WRAPPER_MAP = /* @__PURE__ */ new WeakMap();
-function getInstancedArrays(gl) {
-  if (isWebGL2RenderingContext(gl)) return gl;
-  const cached = INSTANCED_ARRAYS_WRAPPER_MAP.get(gl);
-  if (cached) return cached;
-  const ext = gl.getExtension("ANGLE_instanced_arrays");
-  if (!ext) return void 0;
-  const wrapper = {
-    drawArraysInstanced: ext.drawArraysInstancedANGLE.bind(ext),
-    drawElementsInstanced: ext.drawElementsInstancedANGLE.bind(ext),
-    vertexAttribDivisor: ext.vertexAttribDivisorANGLE.bind(ext)
-  };
-  INSTANCED_ARRAYS_WRAPPER_MAP.set(gl, wrapper);
-  return wrapper;
-}
-var VERTEX_ARRAY_OBJECT_WRAPPER_MAP = /* @__PURE__ */ new WeakMap();
-function getVertexArrayObject(gl) {
-  if (isWebGL2RenderingContext(gl)) return gl;
-  const cached = VERTEX_ARRAY_OBJECT_WRAPPER_MAP.get(gl);
-  if (cached) return cached;
-  const ext = gl.getExtension("OES_vertex_array_object");
-  if (!ext) return null;
-  const wrapper = {
-    bindVertexArray: ext.bindVertexArrayOES.bind(ext),
-    createVertexArray: ext.createVertexArrayOES.bind(ext),
-    deleteVertexArray: ext.deleteVertexArrayOES.bind(ext)
-  };
-  VERTEX_ARRAY_OBJECT_WRAPPER_MAP.set(gl, wrapper);
-  return wrapper;
-}
-
-export {
-  createShader,
-  createProgram,
-  getInstancedArrays,
-  getVertexArrayObject
-};
-//# sourceMappingURL=chunk-CJTT7WPV.mjs.map

package/dist/chunk-CJTT7WPV.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/gl.ts"],"sourcesContent":["import { RemoveSuffix } from './type-utils'\nimport type { GL } from './types'\n\nfunction isWebGL2RenderingContext(\n  gl: WebGLRenderingContext | WebGL2RenderingContext,\n): gl is WebGL2RenderingContext {\n  return typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext\n}\n\n/**********************************************************************************/\n/*                                                                                */\n/*                                 Create Shader                                  */\n/*                                                                                */\n/**********************************************************************************/\n\nexport function createShader(gl: GL, type: number, source: string): WebGLShader {\n  const shader = gl.createShader(type)\n  if (!shader) throw new Error('Failed to create shader')\n\n  gl.shaderSource(shader, source)\n  gl.compileShader(shader)\n\n  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {\n    const info = gl.getShaderInfoLog(shader)\n    gl.deleteShader(shader)\n    throw new Error(\n      `Failed to compile ${type === gl.VERTEX_SHADER ? 'vertex' : 'fragment'} shader: ${info}`,\n    )\n  }\n\n  return shader\n}\n\n/**********************************************************************************/\n/*                                                                                */\n/*                                Create Program                                  */\n/*                                                                                */\n/**********************************************************************************/\n\nexport function createProgram(gl: GL, vertexSource: string, fragmentSource: string): WebGLProgram {\n  const program = gl.createProgram()\n  if (!program) throw new Error('Failed to create WebGL program')\n\n  const vertexShader = createShader(gl, gl.VERTEX_SHADER, vertexSource)\n  const fragmentShader = createShader(gl, gl.FRAGMENT_SHADER, fragmentSource)\n\n  gl.attachShader(program, vertexShader)\n  gl.attachShader(program, fragmentShader)\n  gl.linkProgram(program)\n\n  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {\n    const info = gl.getProgramInfoLog(program)\n    gl.deleteProgram(program)\n    gl.deleteShader(vertexShader)\n    gl.deleteShader(fragmentShader)\n    throw new Error(`Failed to link program: ${info}`)\n  }\n\n  // Clean up shaders after linking\n  gl.deleteShader(vertexShader)\n  gl.deleteShader(fragmentShader)\n\n  return program\n}\n\n/**********************************************************************************/\n/*                                                                                */\n/*                              Get Instanced Arrays                              */\n/*                                                                                */\n/**********************************************************************************/\n\nconst INSTANCED_ARRAYS_WRAPPER_MAP = new WeakMap<\n  GL,\n  RemoveSuffix<\n    Pick<\n      ANGLE_instanced_arrays,\n      'drawArraysInstancedANGLE' | 'drawElementsInstancedANGLE' | 'vertexAttribDivisorANGLE'\n    >,\n    'ANGLE'\n  > | null\n>()\nexport function getInstancedArrays(gl: GL) {\n  if (isWebGL2RenderingContext(gl)) return gl\n\n  const cached = INSTANCED_ARRAYS_WRAPPER_MAP.get(gl)\n  if (cached) return cached\n\n  const ext = gl.getExtension('ANGLE_instanced_arrays')\n  if (!ext) return undefined\n\n  const wrapper = {\n    drawArraysInstanced: ext.drawArraysInstancedANGLE.bind(ext),\n    drawElementsInstanced: ext.drawElementsInstancedANGLE.bind(ext),\n    vertexAttribDivisor: ext.vertexAttribDivisorANGLE.bind(ext),\n  }\n  INSTANCED_ARRAYS_WRAPPER_MAP.set(gl, wrapper)\n\n  return wrapper\n}\n\n/**********************************************************************************/\n/*                                                                                */\n/*                             Get Vertex Array Object                            */\n/*                                                                                */\n/**********************************************************************************/\n\nconst VERTEX_ARRAY_OBJECT_WRAPPER_MAP = new WeakMap<\n  GL,\n  RemoveSuffix<\n    Pick<\n      OES_vertex_array_object,\n      'bindVertexArrayOES' | 'createVertexArrayOES' | 'deleteVertexArrayOES'\n    >,\n    'OES'\n  > | null\n>()\nexport function getVertexArrayObject(gl: GL) {\n  if (isWebGL2RenderingContext(gl)) return gl\n\n  const cached = VERTEX_ARRAY_OBJECT_WRAPPER_MAP.get(gl)\n  if (cached) return cached\n\n  const ext = gl.getExtension('OES_vertex_array_object')\n  if (!ext) return null\n\n  const wrapper = {\n    bindVertexArray: ext.bindVertexArrayOES.bind(ext),\n    createVertexArray: ext.createVertexArrayOES.bind(ext),\n    deleteVertexArray: ext.deleteVertexArrayOES.bind(ext),\n  }\n  VERTEX_ARRAY_OBJECT_WRAPPER_MAP.set(gl, wrapper)\n\n  return wrapper\n}\n"],"mappings":";AAGA,SAAS,yBACP,IAC8B;AAC9B,SAAO,OAAO,2BAA2B,eAAe,cAAc;AACxE;AAQO,SAAS,aAAa,IAAQ,MAAc,QAA6B;AAC9E,QAAM,SAAS,GAAG,aAAa,IAAI;AACnC,MAAI,CAAC,OAAQ,OAAM,IAAI,MAAM,yBAAyB;AAEtD,KAAG,aAAa,QAAQ,MAAM;AAC9B,KAAG,cAAc,MAAM;AAEvB,MAAI,CAAC,GAAG,mBAAmB,QAAQ,GAAG,cAAc,GAAG;AACrD,UAAM,OAAO,GAAG,iBAAiB,MAAM;AACvC,OAAG,aAAa,MAAM;AACtB,UAAM,IAAI;AAAA,MACR,qBAAqB,SAAS,GAAG,gBAAgB,WAAW,UAAU,YAAY,IAAI;AAAA,IACxF;AAAA,EACF;AAEA,SAAO;AACT;AAQO,SAAS,cAAc,IAAQ,cAAsB,gBAAsC;AAChG,QAAM,UAAU,GAAG,cAAc;AACjC,MAAI,CAAC,QAAS,OAAM,IAAI,MAAM,gCAAgC;AAE9D,QAAM,eAAe,aAAa,IAAI,GAAG,eAAe,YAAY;AACpE,QAAM,iBAAiB,aAAa,IAAI,GAAG,iBAAiB,cAAc;AAE1E,KAAG,aAAa,SAAS,YAAY;AACrC,KAAG,aAAa,SAAS,cAAc;AACvC,KAAG,YAAY,OAAO;AAEtB,MAAI,CAAC,GAAG,oBAAoB,SAAS,GAAG,WAAW,GAAG;AACpD,UAAM,OAAO,GAAG,kBAAkB,OAAO;AACzC,OAAG,cAAc,OAAO;AACxB,OAAG,aAAa,YAAY;AAC5B,OAAG,aAAa,cAAc;AAC9B,UAAM,IAAI,MAAM,2BAA2B,IAAI,EAAE;AAAA,EACnD;AAGA,KAAG,aAAa,YAAY;AAC5B,KAAG,aAAa,cAAc;AAE9B,SAAO;AACT;AAQA,IAAM,+BAA+B,oBAAI,QASvC;AACK,SAAS,mBAAmB,IAAQ;AACzC,MAAI,yBAAyB,EAAE,EAAG,QAAO;AAEzC,QAAM,SAAS,6BAA6B,IAAI,EAAE;AAClD,MAAI,OAAQ,QAAO;AAEnB,QAAM,MAAM,GAAG,aAAa,wBAAwB;AACpD,MAAI,CAAC,IAAK,QAAO;AAEjB,QAAM,UAAU;AAAA,IACd,qBAAqB,IAAI,yBAAyB,KAAK,GAAG;AAAA,IAC1D,uBAAuB,IAAI,2BAA2B,KAAK,GAAG;AAAA,IAC9D,qBAAqB,IAAI,yBAAyB,KAAK,GAAG;AAAA,EAC5D;AACA,+BAA6B,IAAI,IAAI,OAAO;AAE5C,SAAO;AACT;AAQA,IAAM,kCAAkC,oBAAI,QAS1C;AACK,SAAS,qBAAqB,IAAQ;AAC3C,MAAI,yBAAyB,EAAE,EAAG,QAAO;AAEzC,QAAM,SAAS,gCAAgC,IAAI,EAAE;AACrD,MAAI,OAAQ,QAAO;AAEnB,QAAM,MAAM,GAAG,aAAa,yBAAyB;AACrD,MAAI,CAAC,IAAK,QAAO;AAEjB,QAAM,UAAU;AAAA,IACd,iBAAiB,IAAI,mBAAmB,KAAK,GAAG;AAAA,IAChD,mBAAmB,IAAI,qBAAqB,KAAK,GAAG;AAAA,IACpD,mBAAmB,IAAI,qBAAqB,KAAK,GAAG;AAAA,EACtD;AACA,kCAAgC,IAAI,IAAI,OAAO;AAE/C,SAAO;AACT;","names":[]}