@bigmistqke/view.gl 0.1.19 → 0.2.0

package/dist/{chunk-ZP4HP5H7.mjs → chunk-EYXOSM7B.mjs}

@@ -112,9 +112,62 @@ function view(gl, program, schema, options) {
     uniforms: !schema.uniforms ? void 0 : uniformView(gl, program, schema.uniforms),
     attributes: !schema.attributes ? void 0 : attributeView(gl, program, schema.attributes, options),
     interleavedAttributes: !schema.interleavedAttributes ? void 0 : interleavedAttributeView(gl, program, schema.interleavedAttributes, options),
-    buffers: !schema.buffers ? void 0 : bufferView(gl, schema.buffers)
+    buffers: !schema.buffers ? void 0 : bufferView(gl, schema.buffers),
+    vao(participants) {
+      return vaoView(gl, participants, options);
+    }
   };
 }
+function bindDefaultVertexArray(gl) {
+  const feature = getVertexArrayObject(gl);
+  if (!feature) {
+    return () => {
+    };
+  }
+  const previous = gl.getParameter(VERTEX_ARRAY_BINDING);
+  feature.bindVertexArray(null);
+  return () => feature.bindVertexArray(previous);
+}
+function vaoView(gl, participants, { signal } = {}) {
+  const feature = getVertexArrayObject(gl);
+  const methods = !feature ? {
+    bind() {
+      const restores = participants.map((participant) => participant.applyToVertexArray());
+      participants.forEach((participant) => participant.applyToContext?.());
+      return once(() => restores.forEach((restore) => restore()));
+    },
+    unbind() {
+    },
+    dispose() {
+    }
+  } : (() => {
+    const vertexArray = assertedNotNullish(feature.createVertexArray());
+    const previous = gl.getParameter(VERTEX_ARRAY_BINDING);
+    feature.bindVertexArray(vertexArray);
+    for (const participant of participants) {
+      participant.applyToVertexArray();
+    }
+    feature.bindVertexArray(previous);
+    return {
+      bind() {
+        const previousVertexArray = gl.getParameter(
+          VERTEX_ARRAY_BINDING
+        );
+        feature.bindVertexArray(vertexArray);
+        participants.forEach((participant) => participant.applyToContext?.());
+        return once(() => feature.bindVertexArray(previousVertexArray));
+      },
+      unbind() {
+        feature.bindVertexArray(null);
+      },
+      dispose() {
+        feature.deleteVertexArray(vertexArray);
+      }
+    };
+  })();
+  signal?.addEventListener("abort", () => methods.dispose());
+  return methods;
+}
 function uniformView(gl, program, schema) {
   return mapObject(schema, ({ kind, size }, key) => {
     const name2 = toID(key);
@@ -234,14 +287,23 @@ function attributeView(gl, program, schema, { signal } = {}) {
       const resolvedFormat = format ?? defaultFormat(kind);
       const glType = FORMAT_TO_GL_TYPE[resolvedFormat];
       const isIntKind = kind.startsWith("i") || kind.startsWith("u");
+      function applyToVertexArray() {
+        const previousDivisor = readDivisor(gl, location);
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        handleAttribute(gl, location, size, 0, 0, glType, isIntKind, normalized, instanced);
+        return once(() => {
+          getInstancedArrays(gl)?.vertexAttribDivisor(location, previousDivisor);
+        });
+      }
       return {
         buffer,
+        applyToVertexArray,
         bind() {
-          const previousDivisor = readDivisor(gl, location);
-          gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-          handleAttribute(gl, location, size, 0, 0, glType, isIntKind, normalized, instanced);
+          const restoreVertexArray = bindDefaultVertexArray(gl);
+          const restore = applyToVertexArray();
           return once(() => {
-            getInstancedArrays(gl)?.vertexAttribDivisor(location, previousDivisor);
+            restore();
+            restoreVertexArray();
           });
         },
         dispose() {
@@ -260,8 +322,58 @@ function attributeView(gl, program, schema, { signal } = {}) {
   });
   return attributes;
 }
+function constantSource(gl, layout, locations) {
+  const setters = layout.map((entry, index2) => {
+    const size = kindToSize(entry.kind);
+    const name2 = toID(entry.key);
+    if (isMatKind(entry.kind) || size > 4) {
+      throw new Error(
+        `'${name2}' is a ${entry.kind}, which cannot be a constant attribute: vertexAttrib* takes at most 4 floats and has no matrix form. Use the buffer source for it.`
+      );
+    }
+    let values = [];
+    const fn = gl[`vertexAttrib${size}f`].bind(gl);
+    return {
+      name: name2,
+      location: locations[index2],
+      write: () => {
+        if (values.length) {
+          ;
+          fn(locations[index2], ...values);
+        }
+      },
+      methods: {
+        set(...args) {
+          values = args;
+        }
+      }
+    };
+  });
+  return Object.assign(Object.fromEntries(setters.map((setter) => [setter.name, setter.methods])), {
+    applyToVertexArray() {
+      const restores = setters.map(({ location }) => {
+        const wasEnabled = gl.getVertexAttrib(location, gl.VERTEX_ATTRIB_ARRAY_ENABLED);
+        gl.disableVertexAttribArray(location);
+        return () => wasEnabled ? gl.enableVertexAttribArray(location) : void 0;
+      });
+      return once(() => restores.forEach((restore) => restore()));
+    },
+    applyToContext() {
+      setters.forEach((setter) => setter.write());
+    },
+    bind() {
+      const restoreVertexArray = bindDefaultVertexArray(gl);
+      const restore = this.applyToVertexArray();
+      this.applyToContext();
+      return once(() => {
+        restore();
+        restoreVertexArray();
+      });
+    }
+  });
+}
 function interleavedAttributeView(gl, program, schema, { signal } = {}) {
-  const interleavedAttributes = mapObject(schema, ({ layout, instanced }) => {
+  const interleavedAttributes = mapObject(schema, ({ layout }) => {
     let index2 = 0;
     const locations = [];
     const handles = layout.map((layout2) => {
@@ -278,7 +390,7 @@ function interleavedAttributeView(gl, program, schema, { signal } = {}) {
       const isIntKind = layout2.kind.startsWith("i") || layout2.kind.startsWith("u");
       const normalized = layout2.normalized ?? false;
       index2 += size * FORMAT_BYTE_SIZE[resolvedFormat];
-      return () => handleAttribute(
+      return (divisor) => handleAttribute(
         gl,
         location,
         size,
@@ -287,78 +399,57 @@ function interleavedAttributeView(gl, program, schema, { signal } = {}) {
         glType,
         isIntKind,
         normalized,
-        instanced
+        divisor === 1
       );
     });
     const stride = index2;
     const buffer = assertedNotNullish(gl.createBuffer());
-    let vao = void 0;
-    const feature = getVertexArrayObject(gl);
-    if (feature) {
-      const vertexArray = feature.createVertexArray();
-      feature.bindVertexArray(vertexArray);
+    function applyToVertexArray(divisor) {
+      const previousDivisors = locations.map(
+        (location) => [location, readDivisor(gl, location)]
+      );
       gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
       for (const handle of handles) {
-        handle();
+        handle(divisor);
       }
-      feature.bindVertexArray(null);
-      vao = {
-        unbind() {
-          feature.bindVertexArray(null);
-        },
+      return once(() => {
+        const instancedArrays = getInstancedArrays(gl);
+        previousDivisors.forEach(([location, previous]) => {
+          instancedArrays?.vertexAttribDivisor(location, previous);
+        });
+      });
+    }
+    let constant;
+    function bufferSource(divisor) {
+      const apply = () => applyToVertexArray(divisor);
+      return {
+        applyToVertexArray: apply,
         bind() {
-          feature.bindVertexArray(vertexArray);
-        },
-        dispose() {
-          feature.deleteVertexArray(vertexArray);
+          const restoreVertexArray = bindDefaultVertexArray(gl);
+          const restore = apply();
+          return once(() => {
+            restore();
+            restoreVertexArray();
+          });
         }
       };
     }
-    const unbind = () => {
-      if (vao) {
-        vao.unbind();
-      }
-    };
     return {
-      bind() {
-        const previousVertexArray = feature ? gl.getParameter(VERTEX_ARRAY_BINDING) : null;
-        const previousDivisors = vao ? [] : locations.map((location) => [location, readDivisor(gl, location)]);
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        if (vao) {
-          vao.bind();
-        } else {
-          for (const handle of handles) {
-            handle();
-          }
+      buffer: Object.assign(bufferSource(0), {
+        /** The same buffer, stepped once per instance instead of once per vertex. */
+        perInstance: bufferSource(1),
+        set(value, usage = "STATIC_DRAW") {
+          gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+          gl.bufferData(gl.ARRAY_BUFFER, value, gl[usage]);
         }
-        return once(() => {
-          if (feature) {
-            feature.bindVertexArray(previousVertexArray);
-          }
-          if (!vao) {
-            const instancedArrays = getInstancedArrays(gl);
-            previousDivisors.forEach(([location, divisor]) => {
-              instancedArrays?.vertexAttribDivisor(location, divisor);
-            });
-          }
-        });
+      }),
+      // Lazy: a layout key can be perfectly good in a buffer and impossible as
+      // a constant, and finding that out should wait until someone asks for one.
+      get constant() {
+        return constant ??= constantSource(gl, layout, locations);
       },
-      unbind,
       dispose() {
         gl.deleteBuffer(buffer);
-        if (vao) {
-          vao.dispose();
-        }
-      },
-      set(value, usage = "STATIC_DRAW") {
-        if (vao) {
-          vao.bind();
-        }
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-        gl.bufferData(gl.ARRAY_BUFFER, value, gl[usage]);
-        if (vao) {
-          vao.unbind();
-        }
       }
     };
   });
@@ -370,12 +461,21 @@ function interleavedAttributeView(gl, program, schema, { signal } = {}) {
 function bufferView(gl, schema, { signal } = {}) {
   const buffers = mapObject(schema, ({ target = "ARRAY_BUFFER", usage = "STATIC_DRAW" }) => {
     const buffer = assertedNotNullish(gl.createBuffer());
+    function applyToVertexArray() {
+      const previousBuffer = gl.getParameter(gl[`${target}_BINDING`]);
+      gl.bindBuffer(gl[target], buffer);
+      return once(() => {
+        gl.bindBuffer(gl[target], previousBuffer);
+      });
+    }
     return {
+      applyToVertexArray,
       bind() {
-        const previousBuffer = gl.getParameter(gl[`${target}_BINDING`]);
-        gl.bindBuffer(gl[target], buffer);
+        const restoreVertexArray = bindDefaultVertexArray(gl);
+        const restore = applyToVertexArray();
         return once(() => {
-          gl.bindBuffer(gl[target], previousBuffer);
+          restore();
+          restoreVertexArray();
         });
       },
       dispose() {
@@ -397,9 +497,10 @@ export {
   createUpsertMap,
   toID,
   view,
+  vaoView,
   uniformView,
   attributeView,
   interleavedAttributeView,
   bufferView
 };
-//# sourceMappingURL=chunk-ZP4HP5H7.mjs.map
+//# sourceMappingURL=chunk-EYXOSM7B.mjs.map

package/dist/chunk-EYXOSM7B.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils.ts","../src/index.ts"],"sourcesContent":["import type {\n  AttributeKind,\n  FramebufferDefinition,\n  GL,\n  KIND_TO_SIZE_MAP,\n  KIND_TO_UNIFORM_FN_NAME_MAP,\n  TextureDefinition,\n  UniformKind,\n} from './types'\n\nexport function assertedNotNullish<T>(value: T, message?: string): NonNullable<T> {\n  if (value === undefined || value === null) throw new Error(message)\n  return value\n}\n\n/**********************************************************************************/\n/*                                                                                */\n/*                              Kind To Uniform Name                              */\n/*                                                                                */\n/**********************************************************************************/\n\nexport const kindToUniformFnName = <T extends UniformKind>(\n  kind: T,\n): KIND_TO_UNIFORM_FN_NAME_MAP[T] => {\n  switch (kind[0]) {\n    // mat\n    case 'm':\n      return ('Matrix' + kind.slice(3) + 'fv') as KIND_TO_UNIFORM_FN_NAME_MAP[T]\n    // sampler/booleans/integer\n    case 's':\n    case 'b':\n    case 'i':\n      return ((kind.match(/\\d/)?.[0] ?? '1') + 'i') as KIND_TO_UNIFORM_FN_NAME_MAP[T]\n    // unsigned integers\n    case 'u':\n      return ((kind[4] || '1') + 'ui') as KIND_TO_UNIFORM_FN_NAME_MAP[T]\n    // vec\n    case 'v':\n      return (kind[3] + 'f') as KIND_TO_UNIFORM_FN_NAME_MAP[T]\n    default:\n      switch (kind) {\n        case 'float':\n          return '1f' as KIND_TO_UNIFORM_FN_NAME_MAP[T]\n        case 'uint':\n          return '1ui' as KIND_TO_UNIFORM_FN_NAME_MAP[T]\n        default:\n          return '1i' as KIND_TO_UNIFORM_FN_NAME_MAP[T]\n      }\n  }\n}\n\n/**********************************************************************************/\n/*                                                                                */\n/*                                   Kind To Size                                 */\n/*                                                                                */\n/**********************************************************************************/\n\nexport const kindToSize = <T extends UniformKind>(kind: T): KIND_TO_SIZE_MAP[T] => {\n  switch (kind[0]) {\n    case 'm':\n      const [a, b] = kind.match(/\\d+/g)!.map(Number) as [number, number?]\n      return (a * (b ?? a)) as KIND_TO_SIZE_MAP[T]\n    case 'v':\n    case 'i':\n    case 'b':\n    case 'u':\n      const match = kind.match(/\\d/) as [string] | undefined\n      return (match ? +match[0] : 1) as KIND_TO_SIZE_MAP[T]\n    default:\n      return 1 as KIND_TO_SIZE_MAP[T]\n  }\n}\n\n/**********************************************************************************/\n/*                                                                                */\n/*                                      Guards                                    */\n/*                                                                                */\n/**********************************************************************************/\n\nexport const isMatKind = <\n  T extends UniformKind | AttributeKind,\n  TPrefix extends string,\n  TPostfix extends string,\n>(\n  kind: T,\n): kind is T & `${TPrefix}mat${TPostfix}` => kind.includes('mat')\n\nexport const isSamplerKind = <TPrefix extends string, TPostfix extends string>(\n  kind: UniformKind,\n): kind is UniformKind & `${TPrefix}sampler${TPostfix}` => kind.includes('sampler')\n\nexport const isVecKind = <TPrefix extends string, TPostfix extends string>(\n  kind: UniformKind,\n): kind is UniformKind & `${TPrefix}vec${TPostfix}` => kind.includes('vec')\n\n/**********************************************************************************/\n/*                                                                                */\n/*                                  Create Texture                                */\n/*                                                                                */\n/**********************************************************************************/\n\nexport function createTexture(\n  gl: GL,\n  {\n    target = 'TEXTURE_2D',\n    internalFormat = 'RGBA',\n    format = 'RGBA',\n    type = 'UNSIGNED_BYTE',\n    minFilter = 'NEAREST',\n    magFilter = 'NEAREST',\n    wrapS = 'CLAMP_TO_EDGE',\n    wrapT = 'CLAMP_TO_EDGE',\n    width,\n    height,\n  }: TextureDefinition,\n  data?: ArrayBufferView | null,\n): WebGLTexture {\n  const texture = gl.createTexture()\n\n  function getTextureConstant(name: string) {\n    if (!(name in gl)) {\n      throw new Error(`Attempted to create webgl2-only texture (${name}) in webgl1`)\n    }\n    return gl[name as keyof typeof gl] as any\n  }\n\n  gl.bindTexture(gl[target], texture)\n  gl.texImage2D(\n    gl[target],\n    0,\n    getTextureConstant(internalFormat),\n    width,\n    height,\n    0,\n    getTextureConstant(format),\n    getTextureConstant(type),\n    data ?? null,\n  )\n\n  console.log(minFilter)\n  // Set texture parameters\n  gl.texParameteri(gl[target], gl.TEXTURE_MIN_FILTER, gl[minFilter])\n  gl.texParameteri(gl[target], gl.TEXTURE_MAG_FILTER, gl[magFilter])\n  gl.texParameteri(gl[target], gl.TEXTURE_WRAP_S, gl[wrapS])\n  gl.texParameteri(gl[target], gl.TEXTURE_WRAP_T, gl[wrapT])\n\n  return texture\n}\n\n/**********************************************************************************/\n/*                                                                                */\n/*                               Create Framebuffer                               */\n/*                                                                                */\n/**********************************************************************************/\n\nconst FRAMEBUFFER_ATTACHMENT_MAP = {\n  color: 'COLOR_ATTACHMENT0',\n  depth: 'DEPTH_ATTACHMENT',\n  stencil: 'STENCIL_ATTACHMENT',\n  depthStencil: 'DEPTH_STENCIL_ATTACHMENT',\n} as const\n\nclass FramebufferError extends Error {\n  constructor(gl: GL, status: number) {\n    let errorMessage = `Framebuffer '${name}' not complete. Status: `\n    switch (status) {\n      case gl.FRAMEBUFFER_INCOMPLETE_ATTACHMENT:\n        errorMessage += 'FRAMEBUFFER_INCOMPLETE_ATTACHMENT'\n        break\n      case gl.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:\n        errorMessage += 'FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT'\n        break\n      case gl.FRAMEBUFFER_INCOMPLETE_DIMENSIONS:\n        errorMessage += 'FRAMEBUFFER_INCOMPLETE_DIMENSIONS'\n        break\n      case gl.FRAMEBUFFER_UNSUPPORTED:\n        errorMessage += 'FRAMEBUFFER_UNSUPPORTED'\n        break\n      default:\n        errorMessage += `Unknown (${status})`\n    }\n    super(errorMessage)\n  }\n}\n\nexport function createFramebuffer(\n  gl: GL,\n  { attachment, texture, ...options }: FramebufferDefinition,\n) {\n  // Create texture for the framebuffer\n  texture ??= createTexture(gl, options)\n\n  // Create framebuffer\n  const framebuffer = assertedNotNullish(\n    gl.createFramebuffer(),\n    `Failed to create framebuffer: ${name}`,\n  )\n\n  gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer)\n\n  gl.framebufferTexture2D(\n    gl.FRAMEBUFFER,\n    // Determine attachment point based on attachment kind\n    gl[FRAMEBUFFER_ATTACHMENT_MAP[attachment]],\n    gl.TEXTURE_2D,\n    texture,\n    0,\n  )\n\n  // Check framebuffer completeness\n  const status = gl.checkFramebufferStatus(gl.FRAMEBUFFER)\n  if (status !== gl.FRAMEBUFFER_COMPLETE) {\n    throw new FramebufferError(gl, status)\n  }\n\n  return {\n    texture,\n    framebuffer,\n  }\n}\n\n/**********************************************************************************/\n/*                                                                                */\n/*                                  Create Upsert                                 */\n/*                                                                                */\n/**********************************************************************************/\n\ntype UpsertMapKind<T, U> = Map<T, U> | (T extends WeakKey ? WeakMap<T, U> : never)\n\nexport function createUpsertMap<T extends UpsertMapKind<any, any> = Map<any, any>>(\n  constructor?: new () => T,\n) {\n  const map = new (constructor ?? Map)() as T\n  return Object.assign(map, {\n    getOrInsert(\n      key: T extends UpsertMapKind<infer U, any> ? U : never,\n      value: T extends UpsertMapKind<any, infer U> ? () => U : never,\n    ) {\n      let result = map.get(key)\n      if (result) {\n        return result\n      }\n      result = value()\n      map.set(key, result)\n      return result\n    },\n  })\n}\n\nexport function forEachObject<T extends Record<string, any>>(\n  value: T,\n  callback: (value: T[keyof T], key: keyof T, index: number) => void,\n) {\n  let index = 0\n  for (const key in value) {\n    callback(value[key], key, index)\n    index++\n  }\n  for (const key of Object.getOwnPropertySymbols(value)) {\n    callback(value[key as keyof T], key as keyof T, index)\n    index++\n  }\n}\n\nexport function mapObject<T extends Record<string, any>, TReturn>(\n  value: T,\n  callback: (value: T[keyof T], key: keyof T, index: number) => TReturn,\n): { [TKey in keyof T]: TReturn } {\n  const result = {} as { [TKey in keyof T]: TReturn }\n\n  forEachObject(value, (value, key, index) => {\n    result[key] = callback(value, key, index)\n  })\n\n  return result\n}\n","import { getInstancedArrays, getVertexArrayObject } from './gl'\nimport type {\n  AttributeFormat,\n  AttributeKind,\n  AttributeMethods,\n  AttributeSchema,\n  AttributeView,\n  BufferSchema,\n  BufferView,\n  GL,\n  UniformView as InferUniformView,\n  GLUsage,\n  InterleavedAttributeLayout,\n  InterleavedAttributeMethods,\n  InterleavedAttributeSchema,\n  InterleavedAttributeView,\n  UniformSchema,\n  VertexArrayMethods,\n  VertexArrayParticipant,\n  View,\n  ViewOptions,\n  ViewSchema,\n} from './types'\nimport {\n  isSamplerKind,\n  kindToUniformFnName,\n  isMatKind,\n  assertedNotNullish,\n  kindToSize,\n  forEachObject,\n} from './utils'\nimport { createUpsertMap, mapObject } from './utils'\nexport * from './types'\n\n/**********************************************************************************/\n/*                                                                                */\n/*                                      To ID                                     */\n/*                                                                                */\n/**********************************************************************************/\n\nlet index = 0\nconst PREFIX = 'VIEW_GL_ALIAS'\n// Firefox has currently a bug where it can not handle symbol as WeakRef / key for WeakMap\n// see https://bugzilla.mozilla.org/show_bug.cgi?id=1710433\nconst HAS_WEAK_SYMBOL = (() => {\n  try {\n    const symbol = Symbol()\n    new WeakMap().set(symbol, '')\n    return true\n  } catch {\n    return false\n  }\n})()\n// NOTE:  fallback to Map will currently cause a minor memory leak.\nconst SYMBOL_MAP = createUpsertMap(HAS_WEAK_SYMBOL ? WeakMap<symbol, string> : Map<symbol, string>)\n\nexport function toID(key: string | number | symbol) {\n  if (typeof key === 'string') {\n    return key\n  }\n  if (typeof key === 'symbol') {\n    return SYMBOL_MAP.getOrInsert(key, () => `${PREFIX}_${index++}`)\n  }\n  return key.toString()\n}\n\n/**********************************************************************************/\n/*                                                                                */\n/*                                      View                                      */\n/*                                                                                */\n/**********************************************************************************/\n\nexport function view<TSchema extends ViewSchema>(\n  gl: GL,\n  program: WebGLProgram,\n  schema: TSchema,\n  options?: ViewOptions,\n): View<TSchema> {\n  return {\n    uniforms: !schema.uniforms ? undefined : uniformView(gl, program, schema.uniforms),\n    attributes: !schema.attributes\n      ? undefined\n      : attributeView(gl, program, schema.attributes, options),\n    interleavedAttributes: !schema.interleavedAttributes\n      ? undefined\n      : interleavedAttributeView(gl, program, schema.interleavedAttributes, options),\n    buffers: !schema.buffers ? undefined : bufferView(gl, schema.buffers),\n    vao(participants: VertexArrayParticipant[]) {\n      return vaoView(gl, participants, options)\n    },\n  } as View<TSchema>\n}\n\n/**********************************************************************************/\n/*                                                                                */\n/*                                    Vertex Array                                */\n/*                                                                                */\n/**********************************************************************************/\n\n/**\n * Bind the default vertex array, returning a disposer that puts the previous\n * one back. The pointer calls name no destination, so anything applied without\n * a vertex array of its own has to say which one it means — and a vertex array\n * keeps what it is given, so writing into a caller's array by accident would\n * outlive the call that did it.\n */\nfunction bindDefaultVertexArray(gl: GL): () => void {\n  const feature = getVertexArrayObject(gl)\n  if (!feature) {\n    return () => {}\n  }\n  const previous = gl.getParameter(VERTEX_ARRAY_BINDING) as WebGLVertexArrayObject | null\n  feature.bindVertexArray(null)\n  return () => feature.bindVertexArray(previous)\n}\n\n/**\n * A vertex array over the participants one draw needs.\n *\n * Where the context has vertex arrays, each participant writes itself in once,\n * here, and `bind()` is a single `bindVertexArray`. Where it does not — WebGL1\n * without `OES_vertex_array_object` — there is nowhere to keep the state, so\n * `bind()` re-applies every participant and the disposer puts back what they\n * displaced. Same contract, and the emulation is why the name still fits.\n */\nexport function vaoView(\n  gl: GL,\n  participants: VertexArrayParticipant[],\n  { signal }: ViewOptions = {},\n): VertexArrayMethods {\n  const feature = getVertexArrayObject(gl)\n\n  const methods: VertexArrayMethods = !feature\n    ? {\n        bind() {\n          const restores = participants.map(participant => participant.applyToVertexArray())\n          participants.forEach(participant => participant.applyToContext?.())\n          return once(() => restores.forEach(restore => restore()))\n        },\n        unbind() {},\n        dispose() {},\n      }\n    : (() => {\n        const vertexArray = assertedNotNullish(feature.createVertexArray())\n        const previous = gl.getParameter(VERTEX_ARRAY_BINDING) as WebGLVertexArrayObject | null\n        feature.bindVertexArray(vertexArray)\n        // Discarding the restorers is the point: the state lives in this array\n        // now, and the array is thrown away whole.\n        for (const participant of participants) {\n          participant.applyToVertexArray()\n        }\n        feature.bindVertexArray(previous)\n\n        return {\n          bind() {\n            const previousVertexArray = gl.getParameter(\n              VERTEX_ARRAY_BINDING,\n            ) as WebGLVertexArrayObject | null\n            feature.bindVertexArray(vertexArray)\n            // Context state the array cannot hold — see applyToContext.\n            participants.forEach(participant => participant.applyToContext?.())\n            return once(() => feature.bindVertexArray(previousVertexArray))\n          },\n          unbind() {\n            feature.bindVertexArray(null)\n          },\n          dispose() {\n            feature.deleteVertexArray(vertexArray)\n          },\n        }\n      })()\n\n  signal?.addEventListener('abort', () => methods.dispose())\n\n  return methods\n}\n\n/**********************************************************************************/\n/*                                                                                */\n/*                                    Uniform View                                */\n/*                                                                                */\n/**********************************************************************************/\n\nexport function uniformView<T extends UniformSchema>(\n  gl: GL,\n  program: WebGLProgram,\n  schema: T,\n): InferUniformView<T> {\n  // @ts-expect-error - conditional return type based on size is hard to infer\n  return mapObject(schema, ({ kind, size }, key) => {\n    const name = toID(key)\n\n    if (isSamplerKind(kind)) {\n      const location = gl.getUniformLocation(program, name)\n      return {\n        set(arg: number) {\n          gl.uniform1i(location, arg)\n        },\n      }\n    }\n\n    // Array uniform - support both bulk set and indexed access\n    if (size) {\n      const bulkFnName = `uniform${kindToUniformFnName(kind)}v`\n      // @ts-ignore FIX WEBGL/WEBGL2 TYPES\n      const bulkFn = gl[bulkFnName].bind(gl)\n      const bulkLocation = gl.getUniformLocation(program, name)\n\n      const elementFnName = `uniform${kindToUniformFnName(kind)}`\n      // @ts-ignore FIX WEBGL/WEBGL2 TYPES\n      const elementFn = gl[elementFnName].bind(gl)\n\n      // Build array of element setters\n      const elements: Array<{ set(...args: any[]): void }> = []\n      for (let i = 0; i < size; i++) {\n        const location = gl.getUniformLocation(program, `${name}[${i}]`)\n        elements[i] = {\n          set(...args: any[]) {\n            elementFn(location, ...args)\n          },\n        }\n      }\n\n      // Return array-like object with bulk set\n      return Object.assign(elements, {\n        set(arg: Float32Array) {\n          bulkFn(bulkLocation, arg)\n        },\n      })\n    }\n\n    // Non-array uniform\n    const location = gl.getUniformLocation(program, name)\n    const fnName = `uniform${kindToUniformFnName(kind)}`\n\n    // @ts-ignore FIX WEBGL/WEBGL2 TYPES\n    const fn = gl[fnName].bind(gl)\n\n    if (isMatKind(kind)) {\n      return {\n        set(...args: any[]) {\n          fn(location, false, args[0])\n        },\n      }\n    }\n\n    return {\n      set(...args: any[]) {\n        fn(location, ...args)\n      },\n    }\n  })\n}\n\n/**********************************************************************************/\n/*                                                                                */\n/*                                   Attribute View                               */\n/*                                                                                */\n/**********************************************************************************/\n\ntype GLType =\n  | 'FLOAT'\n  | 'INT'\n  | 'UNSIGNED_INT'\n  | 'SHORT'\n  | 'UNSIGNED_SHORT'\n  | 'BYTE'\n  | 'UNSIGNED_BYTE'\n\nconst FORMAT_TO_GL_TYPE: Record<AttributeFormat, GLType> = {\n  float32: 'FLOAT',\n  int32: 'INT',\n  uint32: 'UNSIGNED_INT',\n  int16: 'SHORT',\n  uint16: 'UNSIGNED_SHORT',\n  int8: 'BYTE',\n  uint8: 'UNSIGNED_BYTE',\n}\n\nconst FORMAT_BYTE_SIZE: Record<AttributeFormat, number> = {\n  float32: 4,\n  int32: 4,\n  uint32: 4,\n  int16: 2,\n  uint16: 2,\n  int8: 1,\n  uint8: 1,\n}\n\nfunction defaultFormat(kind: AttributeKind): AttributeFormat {\n  if (kind.startsWith('u')) return 'uint32'\n  if (kind.startsWith('i')) return 'int32'\n  return 'float32'\n}\n\n// Shared attribute helper functions\n// between attributeView and interleavedAttributeView\nfunction handleAttribute(\n  gl: GL,\n  location: number,\n  size: number,\n  stride: number,\n  offset: number,\n  glType: GLType,\n  isIntegerKind: boolean,\n  normalized: boolean,\n  instanced?: boolean,\n) {\n  gl.enableVertexAttribArray(location)\n  if (isIntegerKind) {\n    ;(gl as WebGL2RenderingContext).vertexAttribIPointer(location, size, gl[glType], stride, offset)\n  } else {\n    gl.vertexAttribPointer(location, size, gl[glType], normalized, stride, offset)\n  }\n\n  // Always stated, never inherited: the divisor belongs to the location rather\n  // than to the program, so a location left at 1 by an earlier instanced\n  // attribute would feed one value to every vertex here.\n  // Get instanced-arrays-feature: extension if webgl, gl if webgl2\n  const instancedArrays = getInstancedArrays(gl)\n  if (instanced) {\n    assertedNotNullish(instancedArrays).vertexAttribDivisor(location, 1)\n  } else if (instancedArrays) {\n    instancedArrays.vertexAttribDivisor(location, 0)\n  }\n}\n\n// Same enum in webgl2 and in the webgl1 extensions, which expose no constants\nconst VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88fe\nconst VERTEX_ARRAY_BINDING = 0x85b5\n\n// Reads the divisor currently attached to a location, 0 where instancing is\n// unavailable and nothing can have set one\nfunction readDivisor(gl: GL, location: number): number {\n  return getInstancedArrays(gl)\n    ? (gl.getVertexAttrib(location, VERTEX_ATTRIB_ARRAY_DIVISOR) as number)\n    : 0\n}\n\n// Wraps a restore so it runs once: a disposer is per bind() and undoing twice\n// would put back state a later bind() is relying on\nfunction once(restore: () => void): () => void {\n  let done = false\n  return () => {\n    if (done) return\n    done = true\n    restore()\n  }\n}\n\nexport function attributeView<T extends AttributeSchema>(\n  gl: GL,\n  program: WebGLProgram,\n  schema: T,\n  { signal }: ViewOptions = {},\n): AttributeView<T> {\n  const attributes = mapObject(\n    schema,\n    (\n      {\n        kind,\n        format,\n        normalized = false,\n        instanced,\n        buffer = assertedNotNullish(gl.createBuffer()),\n      },\n      key,\n    ): AttributeMethods => {\n      const name = toID(key)\n\n      const location = gl.getAttribLocation(program, name)\n      if (location < 0) {\n        throw new Error(`Attribute '${name}' not found`)\n      }\n\n      const size = kindToSize(kind)\n      const resolvedFormat = format ?? defaultFormat(kind)\n      const glType = FORMAT_TO_GL_TYPE[resolvedFormat]\n      const isIntKind = kind.startsWith('i') || kind.startsWith('u')\n\n      function applyToVertexArray() {\n        // Snapshot before the change, restore in the disposer\n        const previousDivisor = readDivisor(gl, location)\n        // vertexAttribPointer captures whatever is bound to ARRAY_BUFFER when\n        // it runs, so this binding is the setup for the pointer, not a lasting\n        // part of the vertex array's state.\n        gl.bindBuffer(gl.ARRAY_BUFFER, buffer)\n        handleAttribute(gl, location, size, 0, 0, glType, isIntKind, normalized, instanced)\n        return once(() => {\n          getInstancedArrays(gl)?.vertexAttribDivisor(location, previousDivisor)\n        })\n      }\n\n      return {\n        buffer,\n        applyToVertexArray,\n        bind() {\n          const restoreVertexArray = bindDefaultVertexArray(gl)\n          const restore = applyToVertexArray()\n          return once(() => {\n            restore()\n            restoreVertexArray()\n          })\n        },\n        dispose() {\n          gl.deleteBuffer(buffer)\n        },\n        set(data, usage = 'STATIC_DRAW') {\n          gl.bindBuffer(gl.ARRAY_BUFFER, buffer)\n          gl.bufferData(gl.ARRAY_BUFFER, data, gl[usage])\n          return this\n        },\n      }\n    },\n  )\n\n  signal?.addEventListener('abort', function dispose() {\n    forEachObject(attributes, value => value.dispose())\n  })\n\n  return attributes\n}\n\n/**********************************************************************************/\n/*                                                                                */\n/*                               Interleaved Attribute View                       */\n/*                                                                                */\n/**********************************************************************************/\n\n/**\n * The other place an attribute's value can come from: not a buffer, but the\n * context's current generic vertex attribute values, which an attribute reads\n * for every vertex when its array is disabled.\n *\n * A constant is a uniform in all but name — one value for the whole draw, set\n * by a function chosen from the kind — so it gets the setters a uniform gets,\n * off the same layout the buffer source uses.\n *\n * `vertexAttrib*` tops out at four floats and has no matrix form, so a layout\n * key that is fine in a buffer can be impossible as a constant. That is a hard\n * limit of the API rather than a choice, and it is worth saying so out loud at\n * the point someone reaches for it.\n */\nfunction constantSource(gl: GL, layout: InterleavedAttributeLayout[], locations: number[]) {\n  const setters = layout.map((entry, index) => {\n    const size = kindToSize(entry.kind)\n    const name = toID(entry.key)\n    if (isMatKind(entry.kind) || size > 4) {\n      throw new Error(\n        `'${name}' is a ${entry.kind}, which cannot be a constant attribute: vertexAttrib* takes at most 4 floats and has no matrix form. Use the buffer source for it.`,\n      )\n    }\n    // The values are context state, not vertex-array state, so they are held\n    // here and written again on every bind — see applyToContext.\n    let values: number[] = []\n    const fn = gl[`vertexAttrib${size as 1 | 2 | 3 | 4}f`].bind(gl)\n    return {\n      name,\n      location: locations[index]!,\n      write: () => {\n        if (values.length) {\n          ;(fn as (location: number, ...args: number[]) => void)(locations[index]!, ...values)\n        }\n      },\n      methods: {\n        set(...args: number[]) {\n          values = args\n        },\n      },\n    }\n  })\n\n  return Object.assign(Object.fromEntries(setters.map(setter => [setter.name, setter.methods])), {\n    applyToVertexArray() {\n      const restores = setters.map(({ location }) => {\n        const wasEnabled = gl.getVertexAttrib(location, gl.VERTEX_ATTRIB_ARRAY_ENABLED) as boolean\n        gl.disableVertexAttribArray(location)\n        return () => (wasEnabled ? gl.enableVertexAttribArray(location) : undefined)\n      })\n      return once(() => restores.forEach(restore => restore()))\n    },\n    applyToContext() {\n      setters.forEach(setter => setter.write())\n    },\n    bind() {\n      const restoreVertexArray = bindDefaultVertexArray(gl)\n      const restore = this.applyToVertexArray()\n      this.applyToContext()\n      return once(() => {\n        restore()\n        restoreVertexArray()\n      })\n    },\n  })\n}\n\nexport function interleavedAttributeView<T extends InterleavedAttributeSchema>(\n  gl: GL,\n  program: WebGLProgram,\n  schema: T,\n  { signal }: ViewOptions = {},\n): InterleavedAttributeView<T> {\n  // Initialize interleaved attributes\n  const interleavedAttributes = mapObject(schema, ({ layout }) => {\n    // Increment number to keep track of offset\n    let index = 0\n\n    // Calculate layout information\n    const locations: number[] = []\n    const handles = layout.map(layout => {\n      const name = toID(layout.key)\n\n      const location = gl.getAttribLocation(program, name)\n\n      if (location < 0) {\n        throw new Error(`Attribute '${name}' not found`)\n      }\n\n      locations.push(location)\n\n      const size = kindToSize(layout.kind)\n      const offset = index\n      const resolvedFormat = layout.format ?? defaultFormat(layout.kind)\n      const glType = FORMAT_TO_GL_TYPE[resolvedFormat]\n      const isIntKind = layout.kind.startsWith('i') || layout.kind.startsWith('u')\n      const normalized = layout.normalized ?? false\n      index += size * FORMAT_BYTE_SIZE[resolvedFormat]\n\n      return (divisor: 0 | 1) =>\n        handleAttribute(\n          gl,\n          location,\n          size,\n          stride,\n          offset,\n          glType,\n          isIntKind,\n          normalized,\n          divisor === 1,\n        )\n    })\n\n    // Set stride to final index\n    const stride = index\n\n    // Create a buffer\n    const buffer = assertedNotNullish(gl.createBuffer())\n\n    // This layout used to create a vertex array of its own, here, which is why\n    // the other participants in a draw had to be bound after it to be included\n    // — the array they landed in was whichever one happened to be current.\n    // Arrays are `vao()`'s job now; a layout is a layout and a buffer.\n    function applyToVertexArray(divisor: 0 | 1) {\n      const previousDivisors = locations.map(\n        location => [location, readDivisor(gl, location)] as const,\n      )\n      gl.bindBuffer(gl.ARRAY_BUFFER, buffer)\n      for (const handle of handles) {\n        handle(divisor)\n      }\n      return once(() => {\n        const instancedArrays = getInstancedArrays(gl)\n        previousDivisors.forEach(([location, previous]) => {\n          instancedArrays?.vertexAttribDivisor(location, previous)\n        })\n      })\n    }\n\n    let constant: ReturnType<typeof constantSource> | undefined\n\n    /** One layout, one buffer, but a divisor per draw rather than per schema. */\n    function bufferSource(divisor: 0 | 1) {\n      const apply = () => applyToVertexArray(divisor)\n      return {\n        applyToVertexArray: apply,\n        bind() {\n          const restoreVertexArray = bindDefaultVertexArray(gl)\n          const restore = apply()\n          return once(() => {\n            restore()\n            restoreVertexArray()\n          })\n        },\n      }\n    }\n\n    return {\n      buffer: Object.assign(bufferSource(0), {\n        /** The same buffer, stepped once per instance instead of once per vertex. */\n        perInstance: bufferSource(1),\n        set(value: Float32Array, usage: GLUsage = 'STATIC_DRAW') {\n          // Uploading is storage, not binding: ARRAY_BUFFER is not vertex-array\n          // state, so this touches no array, whichever one is bound.\n          gl.bindBuffer(gl.ARRAY_BUFFER, buffer)\n          gl.bufferData(gl.ARRAY_BUFFER, value, gl[usage])\n        },\n      }),\n      // Lazy: a layout key can be perfectly good in a buffer and impossible as\n      // a constant, and finding that out should wait until someone asks for one.\n      get constant() {\n        return (constant ??= constantSource(gl, layout, locations))\n      },\n      dispose() {\n        gl.deleteBuffer(buffer)\n      },\n    } satisfies InterleavedAttributeMethods\n  })\n\n  signal?.addEventListener('abort', function dispose() {\n    forEachObject(interleavedAttributes, value => value.dispose())\n  })\n\n  return interleavedAttributes\n}\n\n/**********************************************************************************/\n/*                                                                                */\n/*                                     Buffer View                                */\n/*                                                                                */\n/**********************************************************************************/\n\nexport function bufferView<T extends BufferSchema>(\n  gl: GL,\n  schema: T,\n  { signal }: ViewOptions = {},\n): BufferView<T> {\n  // Initialize buffers\n  const buffers = mapObject(schema, ({ target = 'ARRAY_BUFFER', usage = 'STATIC_DRAW' }) => {\n    const buffer = assertedNotNullish(gl.createBuffer())\n\n    function applyToVertexArray() {\n      // Snapshot before the change, restore in the disposer. Restoring the\n      // previous buffer rather than null matters for ELEMENT_ARRAY_BUFFER,\n      // whose binding is recorded in the bound vertex array: clearing it\n      // would strip the index buffer from an array the caller may not own.\n      const previousBuffer = gl.getParameter(gl[`${target}_BINDING`]) as WebGLBuffer | null\n      gl.bindBuffer(gl[target], buffer)\n      return once(() => {\n        gl.bindBuffer(gl[target], previousBuffer)\n      })\n    }\n\n    return {\n      applyToVertexArray,\n      bind() {\n        // ELEMENT_ARRAY_BUFFER's binding belongs to the bound vertex array, so\n        // like the attributes this has to say which array it means. ARRAY_BUFFER\n        // is context state and unaffected either way.\n        const restoreVertexArray = bindDefaultVertexArray(gl)\n        const restore = applyToVertexArray()\n        return once(() => {\n          restore()\n          restoreVertexArray()\n        })\n      },\n      dispose() {\n        gl.deleteBuffer(buffer)\n      },\n      set(data: Float32Array) {\n        gl.bindBuffer(gl[target], buffer)\n        gl.bufferData(gl[target], data, gl[usage])\n      },\n    }\n  })\n\n  signal?.addEventListener('abort', function dispose() {\n    forEachObject(buffers, value => value.dispose())\n  })\n\n  return buffers\n}\n"],"mappings":"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","names":["index","value","name","location","index","layout"]}

package/dist/gl.d.mts

@@ -1,4 +1,4 @@
-import { G as GL, R as RemoveSuffix } from './types-DTSPQclW.mjs';
+import { G as GL, R as RemoveSuffix } from './types-CyGyGi18.mjs';
 
 /**********************************************************************************/
 /**********************************************************************************/

package/dist/index.d.mts

@@ -1,19 +1,27 @@
-import { V as ViewSchema, G as GL, a as ViewOptions, b as View, U as UniformSchema, c as UniformView, A as AttributeSchema, d as AttributeView, I as InterleavedAttributeSchema, e as InterleavedAttributeView, B as BufferSchema, f as BufferView } from './types-DTSPQclW.mjs';
-export { z as AttributeDefinition, y as AttributeFormat, x as AttributeKind, C as AttributeMethods, w as AttributeShortHand, a6 as AttributeToken, a7 as AttributeTokenFn, H as BufferDefinition, J as BufferMethods, ae as CompileResult, ac as FlattenSlots, Z as Format, M as Framebuffer, L as FramebufferDefinition, a3 as GLSL, a1 as GLSLResult, a2 as GLSLSlot, ab as GLSLSlotsToSchema, a9 as GLSLToSchema, aa as GLSLToView, g as GLTarget, l as GLTextureFilter, j as GLTextureFormat, i as GLTextureTarget, k as GLTextureType, m as GLTextureWrap, h as GLUsage, a8 as InterleaveToken, E as InterleavedAttributeDefinition, D as InterleavedAttributeLayout, F as InterleavedAttributeMethods, Y as InternalFormat, n as KIND_TO_SIZE_MAP, K as KIND_TO_UNIFORM_FN_NAME_MAP, ad as MergeGLSLSchema, _ as PixelType, $ as TexImage2DOptions, T as TextureDefinition, P as TextureMethods, S as TextureParameterName, W as TextureParameterValue, X as TextureParameters, O as TextureSchema, N as TextureTarget, Q as TextureView, t as UniformArrayMethods, r as UniformDefinition, s as UniformElementMethods, o as UniformFnName, p as UniformKind, q as UniformKindMap, u as UniformMethods, a4 as UniformToken, a5 as UniformTokenFn, v as UniformValue, a0 as ViewSchemaPartial } from './types-DTSPQclW.mjs';
+import { V as ViewSchema, G as GL, a as ViewOptions, b as View, c as VertexArrayParticipant, d as VertexArrayMethods, U as UniformSchema, e as UniformView, A as AttributeSchema, f as AttributeView, I as InterleavedAttributeSchema, g as InterleavedAttributeView, B as BufferSchema, h as BufferView } from './types-CyGyGi18.mjs';
+export { D as AttributeDefinition, C as AttributeFormat, z as AttributeKind, E as AttributeMethods, y as AttributeShortHand, ac as AttributeToken, ad as AttributeTokenFn, O as BufferDefinition, P as BufferMethods, J as BufferSource, ak as CompileResult, L as ConstantAttributeMethods, M as ConstantSource, ai as FlattenSlots, a3 as Format, W as Framebuffer, Q as FramebufferDefinition, a9 as GLSL, a7 as GLSLResult, a8 as GLSLSlot, ah as GLSLSlotsToSchema, af as GLSLToSchema, ag as GLSLToView, i as GLTarget, n as GLTextureFilter, l as GLTextureFormat, k as GLTextureTarget, m as GLTextureType, o as GLTextureWrap, j as GLUsage, ae as InterleaveToken, H as InterleavedAttributeDefinition, F as InterleavedAttributeLayout, N as InterleavedAttributeMethods, a2 as InternalFormat, p as KIND_TO_SIZE_MAP, K as KIND_TO_UNIFORM_FN_NAME_MAP, aj as MergeGLSLSchema, a4 as PixelType, S as Source, a5 as TexImage2DOptions, T as TextureDefinition, Z as TextureMethods, $ as TextureParameterName, a0 as TextureParameterValue, a1 as TextureParameters, Y as TextureSchema, X as TextureTarget, _ as TextureView, v as UniformArrayMethods, t as UniformDefinition, u as UniformElementMethods, q as UniformFnName, r as UniformKind, s as UniformKindMap, w as UniformMethods, aa as UniformToken, ab as UniformTokenFn, x as UniformValue, a6 as ViewSchemaPartial } from './types-CyGyGi18.mjs';
 
 declare function toID(key: string | number | symbol): any;
 /**********************************************************************************/
 /**********************************************************************************/
 declare function view<TSchema extends ViewSchema>(gl: GL, program: WebGLProgram, schema: TSchema, options?: ViewOptions): View<TSchema>;
+/**
+ * A vertex array over the participants one draw needs.
+ *
+ * Where the context has vertex arrays, each participant writes itself in once,
+ * here, and `bind()` is a single `bindVertexArray`. Where it does not — WebGL1
+ * without `OES_vertex_array_object` — there is nowhere to keep the state, so
+ * `bind()` re-applies every participant and the disposer puts back what they
+ * displaced. Same contract, and the emulation is why the name still fits.
+ */
+declare function vaoView(gl: GL, participants: VertexArrayParticipant[], { signal }?: ViewOptions): VertexArrayMethods;
 /**********************************************************************************/
 /**********************************************************************************/
 declare function uniformView<T extends UniformSchema>(gl: GL, program: WebGLProgram, schema: T): UniformView<T>;
 declare function attributeView<T extends AttributeSchema>(gl: GL, program: WebGLProgram, schema: T, { signal }?: ViewOptions): AttributeView<T>;
-/**********************************************************************************/
-/**********************************************************************************/
 declare function interleavedAttributeView<T extends InterleavedAttributeSchema>(gl: GL, program: WebGLProgram, schema: T, { signal }?: ViewOptions): InterleavedAttributeView<T>;
 /**********************************************************************************/
 /**********************************************************************************/
 declare function bufferView<T extends BufferSchema>(gl: GL, schema: T, { signal }?: ViewOptions): BufferView<T>;
 
-export { AttributeSchema, AttributeView, BufferSchema, BufferView, GL, InterleavedAttributeSchema, InterleavedAttributeView, UniformSchema, UniformView, View, ViewOptions, ViewSchema, attributeView, bufferView, interleavedAttributeView, toID, uniformView, view };
+export { AttributeSchema, AttributeView, BufferSchema, BufferView, GL, InterleavedAttributeSchema, InterleavedAttributeView, UniformSchema, UniformView, VertexArrayMethods, VertexArrayParticipant, View, ViewOptions, ViewSchema, attributeView, bufferView, interleavedAttributeView, toID, uniformView, vaoView, view };

package/dist/index.mjs

@@ -4,8 +4,9 @@ import {
   interleavedAttributeView,
   toID,
   uniformView,
+  vaoView,
   view
-} from "./chunk-ZP4HP5H7.mjs";
+} from "./chunk-EYXOSM7B.mjs";
 import "./chunk-CJTT7WPV.mjs";
 export {
   attributeView,
@@ -13,6 +14,7 @@ export {
   interleavedAttributeView,
   toID,
   uniformView,
+  vaoView,
   view
 };
 //# sourceMappingURL=index.mjs.map

package/dist/tag.d.mts

@@ -1,4 +1,4 @@
-import { a2 as GLSLSlot, a3 as GLSL, a5 as UniformTokenFn, a7 as AttributeTokenFn, a6 as AttributeToken, x as AttributeKind, z as AttributeDefinition, a8 as InterleaveToken, a0 as ViewSchemaPartial, ae as CompileResult, af as Prettify, a9 as GLSLToSchema, G as GL } from './types-DTSPQclW.mjs';
+import { a8 as GLSLSlot, a9 as GLSL, ab as UniformTokenFn, ad as AttributeTokenFn, ac as AttributeToken, z as AttributeKind, D as AttributeDefinition, ae as InterleaveToken, a6 as ViewSchemaPartial, ak as CompileResult, al as Prettify, af as GLSLToSchema, G as GL } from './types-CyGyGi18.mjs';
 
 declare function glsl<TSlot extends GLSLSlot, const TSlots extends TSlot[]>(template: TemplateStringsArray, ...slots: [...TSlots]): GLSL<TSlots>;
 declare const uniform: {

package/dist/tag.mjs

@@ -2,7 +2,7 @@ import {
   createUpsertMap,
   toID,
   view
-} from "./chunk-ZP4HP5H7.mjs";
+} from "./chunk-EYXOSM7B.mjs";
 import {
   createProgram
 } from "./chunk-CJTT7WPV.mjs";

package/dist/{types-DTSPQclW.d.mts → types-CyGyGi18.d.mts}

@@ -210,9 +210,45 @@ type FormatToArray = {
     int8: Int8Array;
     uint8: Uint8Array;
 };
-interface AttributeMethods<T extends AttributeDefinition = AttributeDefinition> {
+/**
+ * What a participant contributes to a vertex array.
+ *
+ * `enableVertexAttribArray`, `vertexAttribPointer`, `vertexAttribDivisor` and
+ * the `ELEMENT_ARRAY_BUFFER` binding all write into whichever vertex array is
+ * bound when they run — they name no destination of their own. That is what
+ * makes them a participant in something rather than a property of themselves,
+ * and why `vao()` exists: it binds the array first, then asks each participant
+ * to write itself in.
+ *
+ * The returned function undoes the write. It is only used where there is no
+ * vertex array to hold the state — a WebGL1 context without
+ * `OES_vertex_array_object` — since a real vertex array is thrown away whole.
+ */
+interface VertexArrayParticipant {
+    applyToVertexArray(): () => void;
+    /**
+     * State the CONTEXT holds rather than the vertex array, re-applied on every
+     * bind because no array can keep it.
+     *
+     * There is exactly one such thing: the current generic vertex attribute
+     * values, which an attribute reads when its array is disabled. The enable
+     * flag saying to read them is vertex-array state; the values themselves are
+     * not. So a constant source splits across the two hooks — and the tempting
+     * optimisation of skipping this when nothing changed would let one draw's
+     * constants leak into the next.
+     */
+    applyToContext?(): void;
+}
+interface AttributeMethods<T extends AttributeDefinition = AttributeDefinition> extends VertexArrayParticipant {
     buffer: WebGLBuffer;
-    /** Binds the attribute, returning a disposer that restores the divisor */
+    /**
+     * Apply this attribute to the DEFAULT vertex array, returning a disposer.
+     *
+     * Explicitly the default one: these calls have no destination of their own,
+     * so without binding first this would edit whichever array happened to be
+     * bound — and a vertex array keeps what it is given, so the damage would
+     * outlive the call. Use `vao()` to build an array of your own.
+     */
     bind(): () => void;
     set(data: FormatToArray[ResolvedFormat<T>], usage?: GLUsage): {
         bind(): () => void;
@@ -235,11 +271,48 @@ interface InterleavedAttributeDefinition {
     instanced?: boolean;
 }
 type InterleavedAttributeSchema = Record<string | symbol, InterleavedAttributeDefinition>;
+/**
+ * A source is where one draw's values for a layout come from. Both kinds are
+ * participants, so either can go into a `vao()`.
+ */
+interface Source extends VertexArrayParticipant {
+    /**
+     * Apply this source to the DEFAULT vertex array, returning a disposer. See
+     * `AttributeMethods.bind` — and prefer `vao()`, which is the only way to get
+     * a source and its fellow participants into an array of their own.
+     */
+    bind(): () => void;
+}
+interface BufferSource extends Source {
+    /**
+     * The same buffer, stepped once per instance rather than once per vertex.
+     *
+     * A divisor is a property of the draw, not of the data — the same markers
+     * are an instanced fleet in one draw and a single mesh in the next — so it
+     * is chosen here rather than declared in the schema.
+     */
+    perInstance: Source;
+    set(data: Float32Array, usage?: GLUsage): void;
+}
+interface ConstantAttributeMethods {
+    set(...values: number[]): void;
+}
+/**
+ * Per-key setters over the same layout the buffer source uses — a constant
+ * attribute is a uniform in all but name, so it is written like one.
+ */
+type ConstantSource<T extends InterleavedAttributeLayout[]> = Source & {
+    [K in T[number] as K['key'] extends string ? K['key'] : never]: ConstantAttributeMethods;
+};
 interface InterleavedAttributeMethods<T extends InterleavedAttributeLayout[] = InterleavedAttributeLayout[]> {
+    buffer: BufferSource;
+    constant: ConstantSource<T>;
+    dispose(): void;
+}
+interface VertexArrayMethods {
     /** Binds the vertex array, returning a disposer that restores the previous one */
     bind(): () => void;
     unbind(): void;
-    set(data: Float32Array, usage?: GLUsage): void;
     dispose(): void;
 }
 type InterleavedAttributeView<T extends InterleavedAttributeSchema> = {
@@ -252,7 +325,7 @@ interface BufferDefinition {
     usage?: GLUsage;
 }
 type BufferSchema = Record<string | symbol, BufferDefinition>;
-interface BufferMethods {
+interface BufferMethods extends VertexArrayParticipant {
     set(data: Float32Array | Uint16Array | Uint32Array): void;
     /** Binds the buffer, returning a disposer that restores the previous binding */
     bind(): () => void;
@@ -338,6 +411,16 @@ 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']>> : {};
+    /**
+     * Build a vertex array from the participants one draw needs — its attributes,
+     * its interleaved layouts, its element buffer.
+     *
+     * This is the one member the schema cannot declare, because its input is the
+     * schema's own output. It is also the only place a vertex array is created:
+     * the participants no longer make one each, so which array they end up in is
+     * something you say rather than something you inherit from call order.
+     */
+    vao(participants: VertexArrayParticipant[]): VertexArrayMethods;
 };
 /**********************************************************************************/
 /**********************************************************************************/
@@ -439,4 +522,4 @@ type CompileResult<TVertex extends GLSL, TFragment extends GLSL, TOverrideSchema
     fragment: string;
 } : never;
 
-export type { TexImage2DOptions as $, AttributeSchema as A, BufferSchema as B, AttributeMethods as C, InterleavedAttributeLayout as D, InterleavedAttributeDefinition as E, InterleavedAttributeMethods as F, GL as G, BufferDefinition as H, InterleavedAttributeSchema as I, BufferMethods as J, KIND_TO_UNIFORM_FN_NAME_MAP as K, FramebufferDefinition as L, Framebuffer as M, TextureTarget as N, TextureSchema as O, TextureMethods as P, TextureView as Q, RemoveSuffix as R, TextureParameterName as S, TextureDefinition as T, UniformSchema as U, ViewSchema as V, TextureParameterValue as W, TextureParameters as X, InternalFormat as Y, Format as Z, PixelType as _, ViewOptions as a, ViewSchemaPartial as a0, GLSLResult as a1, GLSLSlot as a2, GLSL as a3, UniformToken as a4, UniformTokenFn as a5, AttributeToken as a6, AttributeTokenFn as a7, InterleaveToken as a8, GLSLToSchema as a9, GLSLToView as aa, GLSLSlotsToSchema as ab, FlattenSlots as ac, MergeGLSLSchema as ad, CompileResult as ae, Prettify as af, View as b, UniformView as c, AttributeView as d, InterleavedAttributeView as e, BufferView as f, GLTarget as g, GLUsage as h, GLTextureTarget as i, GLTextureFormat as j, GLTextureType as k, GLTextureFilter as l, GLTextureWrap as m, KIND_TO_SIZE_MAP as n, UniformFnName as o, UniformKind as p, UniformKindMap as q, UniformDefinition as r, UniformElementMethods as s, UniformArrayMethods as t, UniformMethods as u, UniformValue as v, AttributeShortHand as w, AttributeKind as x, AttributeFormat as y, AttributeDefinition as z };
+export type { TextureParameterName as $, AttributeSchema as A, BufferSchema as B, AttributeFormat as C, AttributeDefinition as D, AttributeMethods as E, InterleavedAttributeLayout as F, GL as G, InterleavedAttributeDefinition as H, InterleavedAttributeSchema as I, BufferSource as J, KIND_TO_UNIFORM_FN_NAME_MAP as K, ConstantAttributeMethods as L, ConstantSource as M, InterleavedAttributeMethods as N, BufferDefinition as O, BufferMethods as P, FramebufferDefinition as Q, RemoveSuffix as R, Source as S, TextureDefinition as T, UniformSchema as U, ViewSchema as V, Framebuffer as W, TextureTarget as X, TextureSchema as Y, TextureMethods as Z, TextureView as _, ViewOptions as a, TextureParameterValue as a0, TextureParameters as a1, InternalFormat as a2, Format as a3, PixelType as a4, TexImage2DOptions as a5, ViewSchemaPartial as a6, GLSLResult as a7, GLSLSlot as a8, GLSL as a9, UniformToken as aa, UniformTokenFn as ab, AttributeToken as ac, AttributeTokenFn as ad, InterleaveToken as ae, GLSLToSchema as af, GLSLToView as ag, GLSLSlotsToSchema as ah, FlattenSlots as ai, MergeGLSLSchema as aj, CompileResult as ak, Prettify as al, View as b, VertexArrayParticipant as c, VertexArrayMethods as d, UniformView as e, AttributeView as f, InterleavedAttributeView as g, BufferView as h, GLTarget as i, GLUsage as j, GLTextureTarget as k, GLTextureFormat as l, GLTextureType as m, GLTextureFilter as n, GLTextureWrap as o, KIND_TO_SIZE_MAP as p, UniformFnName as q, UniformKind as r, UniformKindMap as s, UniformDefinition as t, UniformElementMethods as u, UniformArrayMethods as v, UniformMethods as w, UniformValue as x, AttributeShortHand as y, AttributeKind as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bigmistqke/view.gl",
-  "version": "0.1.19",
+  "version": "0.2.0",
   "description": "👀 Utilities for managing WebGL resources.",
   "exports": {
     ".": {