@babylonjs/lite-gl 0.1.0

package/mesh.js

@@ -0,0 +1,334 @@
+import { I as getEffectAttributeLocation, m as onContextRestored, k as offContextRestored } from "./effect-BxxwfB_O.js";
+import { a as applyGLStates } from "./state--j_ncWIi.js";
+const ARRAY_BUFFER = 34962;
+const ELEMENT_ARRAY_BUFFER = 34963;
+const STATIC_DRAW = 35044;
+const DYNAMIC_DRAW = 35048;
+const FLOAT = 5126;
+const TRIANGLES = 4;
+const UNSIGNED_SHORT = 5123;
+const UNSIGNED_INT = 5125;
+function createVertexBuffer(engine, data, dynamic = false) {
+  const gl = engine.gl;
+  const handle = gl.createBuffer();
+  if (handle === null) {
+    throw new Error("lite-gl: gl.createBuffer returned null (vertex buffer)");
+  }
+  const vb = {
+    handle,
+    byteLength: data.byteLength,
+    _data: data,
+    _dynamic: dynamic,
+    _disposed: false,
+    _deleteGpu: () => {
+    },
+    _restore: () => {
+    }
+  };
+  vb._deleteGpu = (g) => {
+    g.deleteBuffer(vb.handle);
+  };
+  vb._restore = (target) => {
+    const g = target.gl;
+    const fresh = g.createBuffer();
+    if (fresh === null) {
+      return;
+    }
+    vb.handle = fresh;
+    bindArrayBufferRaw(target, fresh);
+    g.bufferData(ARRAY_BUFFER, vb._data, vb._dynamic ? DYNAMIC_DRAW : STATIC_DRAW);
+  };
+  bindArrayBufferRaw(engine, handle);
+  gl.bufferData(ARRAY_BUFFER, data, dynamic ? DYNAMIC_DRAW : STATIC_DRAW);
+  engine._buffers.push(vb);
+  return vb;
+}
+function updateVertexBuffer(engine, vb, data, dstByteOffset = 0) {
+  if (engine._isLost || engine._disposed || vb._disposed) {
+    return;
+  }
+  bindArrayBufferRaw(engine, vb.handle);
+  engine.gl.bufferSubData(ARRAY_BUFFER, dstByteOffset, data);
+  if (dstByteOffset === 0 && data.byteLength >= vb.byteLength) {
+    vb._data = data;
+    vb.byteLength = data.byteLength;
+  }
+}
+function createIndexBuffer(engine, data) {
+  const gl = engine.gl;
+  const handle = gl.createBuffer();
+  if (handle === null) {
+    throw new Error("lite-gl: gl.createBuffer returned null (index buffer)");
+  }
+  const is32 = data instanceof Uint32Array;
+  const ib = {
+    handle,
+    count: data.length,
+    is32Bits: is32,
+    _data: data,
+    _disposed: false,
+    _deleteGpu: () => {
+    },
+    _restore: () => {
+    }
+  };
+  ib._deleteGpu = (g) => {
+    g.deleteBuffer(ib.handle);
+  };
+  ib._restore = (target) => {
+    const g = target.gl;
+    const fresh = g.createBuffer();
+    if (fresh === null) {
+      return;
+    }
+    ib.handle = fresh;
+    bindDefaultVao(target);
+    g.bindBuffer(ELEMENT_ARRAY_BUFFER, fresh);
+    target._state.boundElementBuffer = fresh;
+    g.bufferData(ELEMENT_ARRAY_BUFFER, ib._data, STATIC_DRAW);
+  };
+  bindDefaultVao(engine);
+  gl.bindBuffer(ELEMENT_ARRAY_BUFFER, handle);
+  engine._state.boundElementBuffer = handle;
+  gl.bufferData(ELEMENT_ARRAY_BUFFER, data, STATIC_DRAW);
+  engine._buffers.push(ib);
+  return ib;
+}
+function disposeBuffer(engine, buffer) {
+  if (buffer._disposed) {
+    return;
+  }
+  buffer._disposed = true;
+  const i = engine._buffers.indexOf(buffer);
+  if (i !== -1) {
+    engine._buffers.splice(i, 1);
+  }
+  const s = engine._state;
+  if (!engine._isLost && !engine._disposed) {
+    engine.gl.deleteBuffer(buffer.handle);
+  }
+  if (s.boundArrayBuffer === buffer.handle) {
+    s.boundArrayBuffer = null;
+  }
+  if (s.boundElementBuffer === buffer.handle) {
+    s.boundElementBuffer = null;
+  }
+}
+function bindIndexBuffer(engine, ib) {
+  if (engine._isLost || engine._disposed || ib._disposed) {
+    return;
+  }
+  bindDefaultVao(engine);
+  const s = engine._state;
+  if (s.boundElementBuffer === ib.handle) {
+    return;
+  }
+  engine.gl.bindBuffer(ELEMENT_ARRAY_BUFFER, ib.handle);
+  s.boundElementBuffer = ib.handle;
+}
+function bindAttributes(engine, vb, descriptors, effect, computeStride = false) {
+  if (engine._isLost || engine._disposed || vb._disposed || !effect.isReady) {
+    return;
+  }
+  const gl = engine.gl;
+  const s = engine._state;
+  bindDefaultVao(engine);
+  bindArrayBufferRaw(engine, vb.handle);
+  let stride = 0;
+  if (computeStride) {
+    for (let i = 0; i < descriptors.length; i++) {
+      stride += descriptors[i].size * 4;
+    }
+  }
+  for (let i = 0; i < descriptors.length; i++) {
+    const d = descriptors[i];
+    const loc = d.index !== void 0 ? d.index : d.name !== void 0 ? getEffectAttributeLocation(engine, effect, d.name) : -1;
+    if (loc < 0) {
+      continue;
+    }
+    if (!s.enabledAttribs[loc]) {
+      gl.enableVertexAttribArray(loc);
+      s.enabledAttribs[loc] = true;
+    }
+    gl.vertexAttribPointer(loc, d.size, d.type ?? FLOAT, d.normalized ?? false, stride, d.offset ?? 0);
+    gl.vertexAttribDivisor(loc, d.divisor === void 0 ? 1 : d.divisor);
+    s.instanceLocations.push(loc);
+  }
+}
+function unbindInstanceAttributes(engine) {
+  if (engine._isLost || engine._disposed) {
+    return;
+  }
+  const gl = engine.gl;
+  const locs = engine._state.instanceLocations;
+  for (let i = 0; i < locs.length; i++) {
+    gl.vertexAttribDivisor(locs[i], 0);
+  }
+  locs.length = 0;
+}
+function drawIndexed(engine, ib, indexCount, indexStart = 0, instanceCount = 0) {
+  if (engine._isLost || engine._disposed || ib._disposed) {
+    return;
+  }
+  if (engine._state.currentProgram === null) {
+    return;
+  }
+  bindIndexBuffer(engine, ib);
+  const gl = engine.gl;
+  const type = ib.is32Bits ? UNSIGNED_INT : UNSIGNED_SHORT;
+  const byteOffset = indexStart * (ib.is32Bits ? 4 : 2);
+  applyGLStates(engine);
+  if (instanceCount > 0) {
+    gl.drawElementsInstanced(TRIANGLES, indexCount, type, byteOffset, instanceCount);
+  } else {
+    gl.drawElements(TRIANGLES, indexCount, type, byteOffset);
+  }
+}
+function createMeshVao(engine, vertexBuffers, indexBuffer, effect) {
+  const gl = engine.gl;
+  if (!effect.isReady) {
+    throw new Error("lite-gl: createMeshVao requires a ready effect (poll isEffectReady first)");
+  }
+  const handle = gl.createVertexArray();
+  if (handle === null) {
+    throw new Error("lite-gl: gl.createVertexArray returned null (mesh VAO)");
+  }
+  const bindings = [];
+  for (const vbb of vertexBuffers) {
+    let stride = 0;
+    if (vbb.computeStride) {
+      for (let i = 0; i < vbb.attributes.length; i++) {
+        stride += vbb.attributes[i].size * 4;
+      }
+    }
+    const attrs = [];
+    for (let i = 0; i < vbb.attributes.length; i++) {
+      const d = vbb.attributes[i];
+      const loc = d.index !== void 0 ? d.index : d.name !== void 0 ? getEffectAttributeLocation(engine, effect, d.name) : -1;
+      if (loc < 0) {
+        continue;
+      }
+      attrs.push({
+        loc,
+        size: d.size,
+        type: d.type ?? FLOAT,
+        normalized: d.normalized ?? false,
+        stride,
+        offset: d.offset ?? 0,
+        divisor: d.divisor === void 0 ? 1 : d.divisor
+      });
+    }
+    bindings.push({ buffer: vbb.buffer, attrs });
+  }
+  const vao = { handle, _disposed: false, _indexBuffer: indexBuffer, _bindings: bindings, _restore: () => {
+  } };
+  vao._restore = () => {
+    if (engine._isLost || engine._disposed || vao._disposed) {
+      return;
+    }
+    const fresh = engine.gl.createVertexArray();
+    if (fresh === null) {
+      return;
+    }
+    vao.handle = fresh;
+    recordMeshVao(engine, vao);
+  };
+  recordMeshVao(engine, vao);
+  onContextRestored(engine, vao._restore);
+  return vao;
+}
+function bindMeshVao(engine, vao) {
+  if (engine._isLost || engine._disposed || vao._disposed) {
+    return;
+  }
+  const s = engine._state;
+  if (s.boundVao === vao.handle) {
+    return;
+  }
+  engine.gl.bindVertexArray(vao.handle);
+  s.boundVao = vao.handle;
+  s.boundElementBuffer = vao._indexBuffer.handle;
+}
+function drawMesh(engine, vao, instanceCount = 0) {
+  if (engine._isLost || engine._disposed || vao._disposed) {
+    return;
+  }
+  if (engine._state.currentProgram === null) {
+    return;
+  }
+  bindMeshVao(engine, vao);
+  applyGLStates(engine);
+  const ib = vao._indexBuffer;
+  const gl = engine.gl;
+  const type = ib.is32Bits ? UNSIGNED_INT : UNSIGNED_SHORT;
+  if (instanceCount > 0) {
+    gl.drawElementsInstanced(TRIANGLES, ib.count, type, 0, instanceCount);
+  } else {
+    gl.drawElements(TRIANGLES, ib.count, type, 0);
+  }
+}
+function disposeMeshVao(engine, vao) {
+  if (vao._disposed) {
+    return;
+  }
+  vao._disposed = true;
+  offContextRestored(engine, vao._restore);
+  if (!engine._isLost && !engine._disposed) {
+    const s = engine._state;
+    engine.gl.deleteVertexArray(vao.handle);
+    if (s.boundVao === vao.handle) {
+      engine.gl.bindVertexArray(null);
+      s.boundVao = null;
+      s.boundElementBuffer = null;
+    }
+  }
+}
+function recordMeshVao(engine, vao) {
+  const gl = engine.gl;
+  const s = engine._state;
+  gl.bindVertexArray(vao.handle);
+  s.boundVao = vao.handle;
+  for (const b of vao._bindings) {
+    bindArrayBufferRaw(engine, b.buffer.handle);
+    for (const a of b.attrs) {
+      gl.enableVertexAttribArray(a.loc);
+      gl.vertexAttribPointer(a.loc, a.size, a.type, a.normalized, a.stride, a.offset);
+      gl.vertexAttribDivisor(a.loc, a.divisor);
+    }
+  }
+  gl.bindBuffer(ELEMENT_ARRAY_BUFFER, vao._indexBuffer.handle);
+  gl.bindVertexArray(null);
+  s.boundVao = null;
+  s.boundElementBuffer = null;
+}
+function bindDefaultVao(engine) {
+  const s = engine._state;
+  if (s.boundVao !== null) {
+    engine.gl.bindVertexArray(null);
+    s.boundVao = null;
+    s.boundElementBuffer = null;
+  }
+}
+function bindArrayBufferRaw(engine, handle) {
+  const s = engine._state;
+  if (s.boundArrayBuffer === handle) {
+    return;
+  }
+  engine.gl.bindBuffer(ARRAY_BUFFER, handle);
+  s.boundArrayBuffer = handle;
+}
+export {
+  bindAttributes,
+  bindIndexBuffer,
+  bindMeshVao,
+  createIndexBuffer,
+  createMeshVao,
+  createVertexBuffer,
+  disposeBuffer,
+  disposeMeshVao,
+  drawIndexed,
+  drawMesh,
+  unbindInstanceAttributes,
+  updateVertexBuffer
+};
+//# sourceMappingURL=mesh.js.map

package/mesh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh.js","sources":["../src/mesh.ts"],"sourcesContent":["/**\n * Sub-entry: indexed meshes, dynamic vertex/index buffers, and hardware\n * instancing.\n *\n * Dynamic-importable via `import { ... } from \"@babylonjs/lite-gl/mesh\"` so\n * consumers that only render the fullscreen quad / sprites don't pull the mesh\n * code into their bundles.\n *\n * This is the lite-gl equivalent of Babylon's `ThinEngine.createVertexBuffer` /\n * `createIndexBuffer` / `_releaseBuffer` / `bindIndexBuffer` /\n * `bindInstancesBuffer` / `unbindInstanceAttributes` / `drawElementsType`. The\n * attribute binder reproduces Babylon's instancing semantics EXACTLY, including\n * the `computeStride = false → stride 0` \"sliding window\" used by ShapeBuilder's\n * tape buffers (consecutive instances read overlapping vec4 windows) and the\n * `divisor === undefined → 1` default.\n *\n * The mesh path runs on the DEFAULT (null) VAO — every buffer/attribute op binds\n * `gl.bindVertexArray(null)` first, so it never corrupts the quad / sprite VAOs.\n * Vertex and index buffers retain their CPU data and re-upload automatically on\n * `webglcontextrestored`.\n */\nimport type { GLEngineContext } from \"./context.js\";\nimport { onContextRestored, offContextRestored } from \"./context.js\";\nimport { getEffectAttributeLocation, type GLEffect } from \"./effect.js\";\nimport { applyGLStates } from \"./apply-states.js\";\n\n/** GL `gl.ARRAY_BUFFER`. */\nconst ARRAY_BUFFER = 0x8892;\n/** GL `gl.ELEMENT_ARRAY_BUFFER`. */\nconst ELEMENT_ARRAY_BUFFER = 0x8893;\n/** GL `gl.STATIC_DRAW`. */\nconst STATIC_DRAW = 0x88e4;\n/** GL `gl.DYNAMIC_DRAW`. */\nconst DYNAMIC_DRAW = 0x88e8;\n/** GL `gl.FLOAT`. */\nconst FLOAT = 0x1406;\n/** GL `gl.TRIANGLES`. */\nconst TRIANGLES = 0x0004;\n/** GL `gl.UNSIGNED_SHORT`. */\nconst UNSIGNED_SHORT = 0x1403;\n/** GL `gl.UNSIGNED_INT`. */\nconst UNSIGNED_INT = 0x1405;\n\n/** A GPU vertex buffer holding interleaved float vertex data. The lite-gl\n *  counterpart of Babylon's `DataBuffer` for vertex data. */\nexport interface GLVertexBuffer {\n    /** The live `WebGLBuffer`. Swapped on `webglcontextrestored`. */\n    handle: WebGLBuffer;\n    /** Size of the GL buffer in bytes. */\n    byteLength: number;\n    /** @internal */\n    _disposed: boolean;\n    /** @internal Delete the underlying GL buffer. */\n    _deleteGpu: (gl: WebGL2RenderingContext) => void;\n    /** @internal Re-create + re-upload the retained CPU data into a fresh handle. */\n    _restore: (engine: GLEngineContext) => void;\n    /** @internal Retained CPU data for context-restore replay (the creation /\n     *  last full-buffer upload). */\n    _data: Float32Array;\n    /** @internal `true` for `DYNAMIC_DRAW` (updated via `updateVertexBuffer`). */\n    _dynamic: boolean;\n}\n\n/** A GPU index buffer. The lite-gl counterpart of Babylon's `DataBuffer` for\n *  index data. */\nexport interface GLIndexBuffer {\n    /** The live `WebGLBuffer`. Swapped on `webglcontextrestored`. */\n    handle: WebGLBuffer;\n    /** Number of indices. */\n    count: number;\n    /** `true` for 32-bit (`Uint32Array`) indices, `false` for 16-bit. */\n    is32Bits: boolean;\n    /** @internal */\n    _disposed: boolean;\n    /** @internal Delete the underlying GL buffer. */\n    _deleteGpu: (gl: WebGL2RenderingContext) => void;\n    /** @internal Re-create + re-upload the retained CPU data into a fresh handle. */\n    _restore: (engine: GLEngineContext) => void;\n    /** @internal Retained CPU data for context-restore replay. */\n    _data: Uint16Array | Uint32Array;\n}\n\n/**\n * Describes one vertex attribute fed from a buffer — the lite-gl equivalent of\n * Babylon's `InstancingAttributeInfo`. Pass an array of these to\n * {@link bindAttributes}.\n */\nexport interface GLAttributeDescriptor {\n    /** Attribute name; resolved to a location via the effect when `index` is\n     *  omitted (`Effect.getAttributeLocationByName`). */\n    name?: string;\n    /** Explicit attribute location. When set, overrides the `name` lookup. */\n    index?: number;\n    /** Number of components, 1–4. */\n    size: number;\n    /** Byte offset of this attribute's first element within the buffer. Default 0. */\n    offset?: number;\n    /**\n     * Per-instance vertex divisor. **Omitted/`undefined` → `1` (instanced)**,\n     * matching Babylon's `bindInstancesBuffer`. Pass `0` explicitly for a\n     * per-vertex attribute (e.g. the base mesh position).\n     */\n    divisor?: number;\n    /** GL component type. Default `gl.FLOAT`. */\n    type?: GLenum;\n    /** Normalize fixed-point integer data to `[0,1]`/`[-1,1]`. Default `false`. */\n    normalized?: boolean;\n}\n\n/* ────────────────────────────────  buffers  ──────────────────────────────── */\n\n/**\n * Create a GPU vertex buffer from interleaved float data.\n *\n * @param engine - The engine.\n * @param data - The vertex data. Retained by reference for context-restore — do\n *  not mutate it in place; use {@link updateVertexBuffer} to change contents.\n * @param dynamic - Hint that the buffer will be updated frequently\n *  (`DYNAMIC_DRAW`). Default `false` (`STATIC_DRAW`).\n * @returns The new {@link GLVertexBuffer}.\n */\nexport function createVertexBuffer(engine: GLEngineContext, data: Float32Array, dynamic = false): GLVertexBuffer {\n    const gl = engine.gl;\n    const handle = gl.createBuffer();\n    if (handle === null) {\n        throw new Error(\"lite-gl: gl.createBuffer returned null (vertex buffer)\");\n    }\n    const vb: GLVertexBuffer = {\n        handle,\n        byteLength: data.byteLength,\n        _data: data,\n        _dynamic: dynamic,\n        _disposed: false,\n        _deleteGpu: () => {},\n        _restore: () => {},\n    };\n    vb._deleteGpu = (g: WebGL2RenderingContext): void => {\n        g.deleteBuffer(vb.handle);\n    };\n    vb._restore = (target: GLEngineContext): void => {\n        const g = target.gl;\n        const fresh = g.createBuffer();\n        if (fresh === null) {\n            return;\n        }\n        vb.handle = fresh;\n        bindArrayBufferRaw(target, fresh);\n        g.bufferData(ARRAY_BUFFER, vb._data, vb._dynamic ? DYNAMIC_DRAW : STATIC_DRAW);\n    };\n    bindArrayBufferRaw(engine, handle);\n    gl.bufferData(ARRAY_BUFFER, data, dynamic ? DYNAMIC_DRAW : STATIC_DRAW);\n    engine._buffers.push(vb);\n    return vb;\n}\n\n/**\n * Upload new contents into (part of) a vertex buffer via `bufferSubData`. A\n * full-buffer update from offset 0 also refreshes the retained CPU data used\n * for context-restore.\n *\n * @param engine - The engine.\n * @param vb - The vertex buffer to update.\n * @param data - The new float data.\n * @param dstByteOffset - Destination byte offset within the buffer. Default 0.\n */\nexport function updateVertexBuffer(engine: GLEngineContext, vb: GLVertexBuffer, data: Float32Array, dstByteOffset = 0): void {\n    if (engine._isLost || engine._disposed || vb._disposed) {\n        return;\n    }\n    bindArrayBufferRaw(engine, vb.handle);\n    engine.gl.bufferSubData(ARRAY_BUFFER, dstByteOffset, data);\n    if (dstByteOffset === 0 && data.byteLength >= vb.byteLength) {\n        vb._data = data;\n        vb.byteLength = data.byteLength;\n    }\n}\n\n/**\n * Create a GPU index buffer. `Uint16Array` → 16-bit indices, `Uint32Array` →\n * 32-bit. Binds the default VAO first so it never corrupts the quad / sprite\n * VAO element bindings.\n *\n * @param engine - The engine.\n * @param data - The index data. Retained by reference for context-restore.\n * @returns The new {@link GLIndexBuffer}.\n */\nexport function createIndexBuffer(engine: GLEngineContext, data: Uint16Array | Uint32Array): GLIndexBuffer {\n    const gl = engine.gl;\n    const handle = gl.createBuffer();\n    if (handle === null) {\n        throw new Error(\"lite-gl: gl.createBuffer returned null (index buffer)\");\n    }\n    const is32 = data instanceof Uint32Array;\n    const ib: GLIndexBuffer = {\n        handle,\n        count: data.length,\n        is32Bits: is32,\n        _data: data,\n        _disposed: false,\n        _deleteGpu: () => {},\n        _restore: () => {},\n    };\n    ib._deleteGpu = (g: WebGL2RenderingContext): void => {\n        g.deleteBuffer(ib.handle);\n    };\n    ib._restore = (target: GLEngineContext): void => {\n        const g = target.gl;\n        const fresh = g.createBuffer();\n        if (fresh === null) {\n            return;\n        }\n        ib.handle = fresh;\n        bindDefaultVao(target);\n        g.bindBuffer(ELEMENT_ARRAY_BUFFER, fresh);\n        target._state.boundElementBuffer = fresh;\n        g.bufferData(ELEMENT_ARRAY_BUFFER, ib._data, STATIC_DRAW);\n    };\n    bindDefaultVao(engine);\n    gl.bindBuffer(ELEMENT_ARRAY_BUFFER, handle);\n    engine._state.boundElementBuffer = handle;\n    gl.bufferData(ELEMENT_ARRAY_BUFFER, data, STATIC_DRAW);\n    engine._buffers.push(ib);\n    return ib;\n}\n\n/** Dispose a vertex or index buffer (delete the GL buffer + unregister). Clears\n *  the array/element-buffer cache slot if it pointed at this buffer. Idempotent. */\nexport function disposeBuffer(engine: GLEngineContext, buffer: GLVertexBuffer | GLIndexBuffer): void {\n    if (buffer._disposed) {\n        return;\n    }\n    buffer._disposed = true;\n    const i = engine._buffers.indexOf(buffer);\n    if (i !== -1) {\n        engine._buffers.splice(i, 1);\n    }\n    const s = engine._state;\n    if (!engine._isLost && !engine._disposed) {\n        engine.gl.deleteBuffer(buffer.handle);\n    }\n    if (s.boundArrayBuffer === buffer.handle) {\n        s.boundArrayBuffer = null;\n    }\n    if (s.boundElementBuffer === buffer.handle) {\n        s.boundElementBuffer = null;\n    }\n}\n\n/* ──────────────────────────────  binding + draw  ──────────────────────────── */\n\n/**\n * Bind an index buffer as the current element-array buffer (on the default\n * VAO). Cached. The lite-gl equivalent of Babylon's `_bindIndexBufferWithCache`.\n *\n * @param engine - The engine.\n * @param ib - The index buffer to bind.\n */\nexport function bindIndexBuffer(engine: GLEngineContext, ib: GLIndexBuffer): void {\n    if (engine._isLost || engine._disposed || ib._disposed) {\n        return;\n    }\n    bindDefaultVao(engine);\n    const s = engine._state;\n    if (s.boundElementBuffer === ib.handle) {\n        return;\n    }\n    engine.gl.bindBuffer(ELEMENT_ARRAY_BUFFER, ib.handle);\n    s.boundElementBuffer = ib.handle;\n}\n\n/**\n * Configure vertex attributes from `vb`, reproducing Babylon's\n * `bindInstancesBuffer` exactly. For each descriptor: resolves the location\n * (explicit `index` or via the effect), enables the attribute array, issues\n * `vertexAttribPointer`, and sets the vertex divisor (`undefined → 1`). Every\n * touched location is tracked so {@link unbindInstanceAttributes} can reset its\n * divisor afterwards.\n *\n * `computeStride` controls the GL stride passed to `vertexAttribPointer`:\n * - `false` (default) → stride `0`: each attribute is independently tightly\n *   packed. Combined with overlapping `offset`s this yields the \"sliding window\"\n *   ShapeBuilder uses for distance-field tape buffers.\n * - `true` → stride = Σ(`size`·4 bytes): interleaved per-vertex/per-instance.\n *\n * Runs on the default (null) VAO — never corrupts the quad / sprite VAOs.\n * No-op on a lost/disposed context or before the effect is ready.\n *\n * @param engine - The engine.\n * @param vb - The buffer supplying the attribute data.\n * @param descriptors - The attribute layout.\n * @param effect - The effect whose attribute locations resolve unnamed indices.\n * @param computeStride - See above. Default `false`.\n */\nexport function bindAttributes(engine: GLEngineContext, vb: GLVertexBuffer, descriptors: readonly GLAttributeDescriptor[], effect: GLEffect, computeStride = false): void {\n    if (engine._isLost || engine._disposed || vb._disposed || !effect.isReady) {\n        return;\n    }\n    const gl = engine.gl;\n    const s = engine._state;\n    bindDefaultVao(engine);\n    bindArrayBufferRaw(engine, vb.handle);\n\n    let stride = 0;\n    if (computeStride) {\n        for (let i = 0; i < descriptors.length; i++) {\n            stride += (descriptors[i] as GLAttributeDescriptor).size * 4;\n        }\n    }\n\n    for (let i = 0; i < descriptors.length; i++) {\n        const d = descriptors[i] as GLAttributeDescriptor;\n        const loc = d.index !== undefined ? d.index : d.name !== undefined ? getEffectAttributeLocation(engine, effect, d.name) : -1;\n        if (loc < 0) {\n            continue;\n        }\n        if (!s.enabledAttribs[loc]) {\n            gl.enableVertexAttribArray(loc);\n            s.enabledAttribs[loc] = true;\n        }\n        gl.vertexAttribPointer(loc, d.size, d.type ?? FLOAT, d.normalized ?? false, stride, d.offset ?? 0);\n        gl.vertexAttribDivisor(loc, d.divisor === undefined ? 1 : d.divisor);\n        s.instanceLocations.push(loc);\n    }\n}\n\n/**\n * Reset the vertex divisor of every attribute touched by {@link bindAttributes}\n * back to 0 — the lite-gl equivalent of Babylon's `unbindInstanceAttributes`.\n * Call after an instanced draw so a following non-instanced draw is not skewed.\n * No-op on a lost/disposed context.\n *\n * @param engine - The engine.\n */\nexport function unbindInstanceAttributes(engine: GLEngineContext): void {\n    if (engine._isLost || engine._disposed) {\n        return;\n    }\n    const gl = engine.gl;\n    const locs = engine._state.instanceLocations;\n    for (let i = 0; i < locs.length; i++) {\n        gl.vertexAttribDivisor(locs[i] as number, 0);\n    }\n    locs.length = 0;\n}\n\n/**\n * Draw indexed triangles from `ib` — the lite-gl equivalent of Babylon's\n * `drawElementsType` (triangle fill mode). When `instanceCount > 0` issues\n * `drawElementsInstanced`, otherwise `drawElements`. No-op on a lost/disposed\n * context or when no program is current.\n *\n * @param engine - The engine.\n * @param ib - The index buffer (also bound as a side-effect, cached).\n * @param indexCount - Number of indices to draw.\n * @param indexStart - First index offset (in indices, not bytes). Default 0.\n * @param instanceCount - Instance count for instanced draws. Default 0\n *  (non-instanced).\n */\nexport function drawIndexed(engine: GLEngineContext, ib: GLIndexBuffer, indexCount: number, indexStart = 0, instanceCount = 0): void {\n    if (engine._isLost || engine._disposed || ib._disposed) {\n        return;\n    }\n    if (engine._state.currentProgram === null) {\n        return;\n    }\n    bindIndexBuffer(engine, ib);\n    const gl = engine.gl;\n    const type = ib.is32Bits ? UNSIGNED_INT : UNSIGNED_SHORT;\n    const byteOffset = indexStart * (ib.is32Bits ? 4 : 2);\n    applyGLStates(engine);\n    if (instanceCount > 0) {\n        gl.drawElementsInstanced(TRIANGLES, indexCount, type, byteOffset, instanceCount);\n    } else {\n        gl.drawElements(TRIANGLES, indexCount, type, byteOffset);\n    }\n}\n\n/* ──────────────────────────  static mesh VAO  ─────────────────────────────\n * The VAO-cached counterpart of the manual `bindAttributes` path above — Babylon's\n * `recordVertexArrayObject` / `_cachedVertexArrayObject` for STATIC meshes. A\n * `GLMeshVao` records the whole attribute layout (enable + pointer + divisor for\n * every attribute, across one or more vertex buffers) AND the index binding into a\n * single VAO ONCE. The per-frame draw is then just `bindVertexArray` +\n * `drawElements[Instanced]` — zero per-draw `vertexAttribPointer`/`vertexAttribDivisor`,\n * and no `unbindInstanceAttributes` (the VAO isolates the divisors from the default\n * VAO). Use this for fixed-layout meshes; keep `bindAttributes` for dynamic layouts\n * (e.g. ShapeBuilder's per-draw sliding-window tape buffers). */\n\n/** One vertex buffer + its attribute layout, for {@link createMeshVao}. */\nexport interface GLMeshVertexBuffer {\n    /** The buffer supplying this group's attributes. */\n    buffer: GLVertexBuffer;\n    /** The attributes read from `buffer` (same shape as {@link bindAttributes}). */\n    attributes: readonly GLAttributeDescriptor[];\n    /** Stride mode (see {@link bindAttributes}): `false` (default) → stride `0`\n     *  per attribute; `true` → interleaved stride = Σ(`size`·4). */\n    computeStride?: boolean;\n}\n\n/** A recorded Vertex Array Object capturing a static mesh's attribute layout +\n *  index binding. Bind + draw it with {@link drawMesh} each frame — the GPU\n *  replays the entire attribute setup from one `bindVertexArray`. Re-recorded\n *  automatically on `webglcontextrestored`. */\nexport interface GLMeshVao {\n    /** The live `WebGLVertexArrayObject`. Swapped on `webglcontextrestored`. */\n    handle: WebGLVertexArrayObject;\n    /** @internal */\n    _disposed: boolean;\n    /** @internal The index buffer recorded into the VAO. */\n    _indexBuffer: GLIndexBuffer;\n    /** @internal Resolved attribute bindings, reused to re-record on restore. */\n    _bindings: _ResolvedBinding[];\n    /** @internal `webglcontextrestored` re-record hook. */\n    _restore: () => void;\n}\n\n/** @internal A single attribute with its location resolved once at record time\n *  (locations are stable across re-link via `bindAttribLocation`, so the VAO can\n *  re-record on context-restore without the effect). */\ninterface _ResolvedAttr {\n    loc: number;\n    size: number;\n    type: number;\n    normalized: boolean;\n    stride: number;\n    offset: number;\n    divisor: number;\n}\n\n/** @internal A vertex buffer + its resolved attributes. */\ninterface _ResolvedBinding {\n    buffer: GLVertexBuffer;\n    attrs: _ResolvedAttr[];\n}\n\n/**\n * Record a static mesh's attribute layout + index binding into a new VAO. The\n * effect MUST be ready (its attribute locations are resolved here, once). Returns\n * a {@link GLMeshVao} to draw with {@link drawMesh}.\n *\n * @param engine - The engine.\n * @param vertexBuffers - One or more buffers + their attribute layouts.\n * @param indexBuffer - The index buffer recorded into the VAO.\n * @param effect - The effect whose attribute locations resolve unnamed indices.\n * @returns The recorded {@link GLMeshVao}.\n */\nexport function createMeshVao(engine: GLEngineContext, vertexBuffers: readonly GLMeshVertexBuffer[], indexBuffer: GLIndexBuffer, effect: GLEffect): GLMeshVao {\n    const gl = engine.gl;\n    // The effect's attribute locations are resolved (once) below; an unready effect\n    // would resolve every name to -1 → a silently-empty VAO. Fail fast — callers\n    // must gate on isEffectReady (see scene10's first-ready-frame creation).\n    if (!effect.isReady) {\n        throw new Error(\"lite-gl: createMeshVao requires a ready effect (poll isEffectReady first)\");\n    }\n    const handle = gl.createVertexArray();\n    if (handle === null) {\n        throw new Error(\"lite-gl: gl.createVertexArray returned null (mesh VAO)\");\n    }\n    // Resolve every attribute location ONCE (stable across re-link), so a restore\n    // re-record needs only the buffer handles, not the effect.\n    const bindings: _ResolvedBinding[] = [];\n    for (const vbb of vertexBuffers) {\n        let stride = 0;\n        if (vbb.computeStride) {\n            for (let i = 0; i < vbb.attributes.length; i++) {\n                stride += (vbb.attributes[i] as GLAttributeDescriptor).size * 4;\n            }\n        }\n        const attrs: _ResolvedAttr[] = [];\n        for (let i = 0; i < vbb.attributes.length; i++) {\n            const d = vbb.attributes[i] as GLAttributeDescriptor;\n            const loc = d.index !== undefined ? d.index : d.name !== undefined ? getEffectAttributeLocation(engine, effect, d.name) : -1;\n            if (loc < 0) {\n                continue;\n            }\n            attrs.push({\n                loc,\n                size: d.size,\n                type: d.type ?? FLOAT,\n                normalized: d.normalized ?? false,\n                stride,\n                offset: d.offset ?? 0,\n                divisor: d.divisor === undefined ? 1 : d.divisor,\n            });\n        }\n        bindings.push({ buffer: vbb.buffer, attrs });\n    }\n    const vao: GLMeshVao = { handle, _disposed: false, _indexBuffer: indexBuffer, _bindings: bindings, _restore: () => {} };\n    vao._restore = (): void => {\n        if (engine._isLost || engine._disposed || vao._disposed) {\n            return;\n        }\n        const fresh = engine.gl.createVertexArray();\n        if (fresh === null) {\n            return;\n        }\n        vao.handle = fresh;\n        recordMeshVao(engine, vao);\n    };\n    recordMeshVao(engine, vao);\n    onContextRestored(engine, vao._restore);\n    return vao;\n}\n\n/**\n * Bind a {@link GLMeshVao} (cached `gl.bindVertexArray`). Rarely called directly —\n * {@link drawMesh} binds it for you. Binding restores the VAO's recorded element\n * binding, so the element-buffer cache is updated in lock-step.\n *\n * @param engine - The engine.\n * @param vao - The mesh VAO to bind.\n */\nexport function bindMeshVao(engine: GLEngineContext, vao: GLMeshVao): void {\n    if (engine._isLost || engine._disposed || vao._disposed) {\n        return;\n    }\n    const s = engine._state;\n    if (s.boundVao === vao.handle) {\n        return;\n    }\n    engine.gl.bindVertexArray(vao.handle);\n    s.boundVao = vao.handle;\n    s.boundElementBuffer = vao._indexBuffer.handle;\n}\n\n/**\n * Draw a static mesh recorded with {@link createMeshVao}: binds its VAO (cached),\n * flushes deferred GL state, and issues ONE `drawElements` (or\n * `drawElementsInstanced` when `instanceCount > 0`) over the VAO's full index\n * buffer. No per-draw attribute (re)binding. No-op on a lost/disposed context, a\n * disposed VAO, or when no program is current.\n *\n * @param engine - The engine.\n * @param vao - The mesh VAO to draw.\n * @param instanceCount - Instance count for instanced draws. Default 0 (non-instanced).\n */\nexport function drawMesh(engine: GLEngineContext, vao: GLMeshVao, instanceCount = 0): void {\n    if (engine._isLost || engine._disposed || vao._disposed) {\n        return;\n    }\n    if (engine._state.currentProgram === null) {\n        return;\n    }\n    bindMeshVao(engine, vao);\n    applyGLStates(engine);\n    const ib = vao._indexBuffer;\n    const gl = engine.gl;\n    const type = ib.is32Bits ? UNSIGNED_INT : UNSIGNED_SHORT;\n    if (instanceCount > 0) {\n        gl.drawElementsInstanced(TRIANGLES, ib.count, type, 0, instanceCount);\n    } else {\n        gl.drawElements(TRIANGLES, ib.count, type, 0);\n    }\n}\n\n/** Dispose a {@link GLMeshVao}: delete the VAO and unregister its restore hook.\n *  Does NOT dispose the vertex/index buffers (the caller owns those). Idempotent. */\nexport function disposeMeshVao(engine: GLEngineContext, vao: GLMeshVao): void {\n    if (vao._disposed) {\n        return;\n    }\n    vao._disposed = true;\n    offContextRestored(engine, vao._restore);\n    if (!engine._isLost && !engine._disposed) {\n        const s = engine._state;\n        engine.gl.deleteVertexArray(vao.handle);\n        if (s.boundVao === vao.handle) {\n            // Return to the default VAO so the cache stays coherent.\n            engine.gl.bindVertexArray(null);\n            s.boundVao = null;\n            s.boundElementBuffer = null;\n        }\n    }\n}\n\n/** @internal Record `vao._bindings` + the index binding into `vao.handle`. Leaves\n *  the default (null) VAO bound afterwards (so the mesh VAO is not left current),\n *  forgetting the element-buffer cache. Touches neither `s.enabledAttribs` (those\n *  track the DEFAULT VAO) nor the divisor reset — all of that lives in the VAO. */\nfunction recordMeshVao(engine: GLEngineContext, vao: GLMeshVao): void {\n    const gl = engine.gl;\n    const s = engine._state;\n    gl.bindVertexArray(vao.handle);\n    s.boundVao = vao.handle;\n    for (const b of vao._bindings) {\n        bindArrayBufferRaw(engine, b.buffer.handle);\n        for (const a of b.attrs) {\n            gl.enableVertexAttribArray(a.loc);\n            gl.vertexAttribPointer(a.loc, a.size, a.type, a.normalized, a.stride, a.offset);\n            gl.vertexAttribDivisor(a.loc, a.divisor);\n        }\n    }\n    gl.bindBuffer(ELEMENT_ARRAY_BUFFER, vao._indexBuffer.handle);\n    gl.bindVertexArray(null);\n    s.boundVao = null;\n    s.boundElementBuffer = null;\n}\n\n/* ────────────────────────────  internal helpers  ──────────────────────────── */\n\n/** Bind the default (null) VAO if not already bound. The mesh path lives here so\n *  it never disturbs the quad / sprite VAO state. Binding a VAO restores ITS\n *  element-array binding, so the element-buffer cache is forgotten on the\n *  switch (the next `bindIndexBuffer` re-binds). */\nfunction bindDefaultVao(engine: GLEngineContext): void {\n    const s = engine._state;\n    if (s.boundVao !== null) {\n        engine.gl.bindVertexArray(null);\n        s.boundVao = null;\n        s.boundElementBuffer = null;\n    }\n}\n\n/** Cached `gl.bindBuffer(ARRAY_BUFFER, …)`. ARRAY_BUFFER binding is global (not\n *  VAO state), so this cache is coherent across VAO switches. */\nfunction bindArrayBufferRaw(engine: GLEngineContext, handle: WebGLBuffer): void {\n    const s = engine._state;\n    if (s.boundArrayBuffer === handle) {\n        return;\n    }\n    engine.gl.bindBuffer(ARRAY_BUFFER, handle);\n    s.boundArrayBuffer = handle;\n}\n"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@babylonjs/lite-gl",
+  "version": "0.1.0",
+  "description": "Function-based, tree-shakeable WebGL2 micro-engine for fullscreen effects, sprites and dynamic textures — the WebGL counterpart of @babylonjs/lite.",
+  "keywords": [
+    "babylon",
+    "babylonjs",
+    "webgl",
+    "webgl2",
+    "effect",
+    "shader",
+    "sprite",
+    "lite",
+    "rendering"
+  ],
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BabylonJS/Babylon-Lite.git",
+    "directory": "packages/babylon-lite-gl"
+  },
+  "homepage": "https://github.com/BabylonJS/Babylon-Lite/tree/main/packages/babylon-lite-gl",
+  "type": "module",
+  "main": "./index.js",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": "./index.js",
+      "types": "./index.d.ts"
+    },
+    "./html-texture": {
+      "import": "./html-texture.js",
+      "types": "./html-texture.d.ts"
+    },
+    "./sprites": {
+      "import": "./sprites.js",
+      "types": "./sprites.d.ts"
+    },
+    "./render-target": {
+      "import": "./render-target.js",
+      "types": "./render-target.d.ts"
+    },
+    "./mesh": {
+      "import": "./mesh.js",
+      "types": "./mesh.d.ts"
+    },
+    "./depth-stencil": {
+      "import": "./depth-stencil.js",
+      "types": "./depth-stencil.d.ts"
+    },
+    "./scissor": {
+      "import": "./scissor.js",
+      "types": "./scissor.d.ts"
+    },
+    "./dynamic-texture": {
+      "import": "./dynamic-texture.js",
+      "types": "./dynamic-texture.d.ts"
+    }
+  }
+}