@babylonjs/lite-gl 0.1.0

package/index.js

@@ -0,0 +1,263 @@
+import { u as useEffect, c as createEffect, d as disposeEffect } from "./effect-BxxwfB_O.js";
+import { a, b, e, g, f, h, i, j, o, k, l, m, r, s, n, p, q, t, v, w, x, y, z, A, B, C, D, E, F, G, H } from "./effect-BxxwfB_O.js";
+import { a as applyGLStates } from "./state--j_ncWIi.js";
+import { b as b2, c, a as a2, d, e as e2, g as g2, l as l2, u, f as f2, h as h2 } from "./texture-DaMd1gGm.js";
+import { clearDynamicTextureSource, createDynamicTexture, updateDynamicTexture } from "./dynamic-texture.js";
+import { bindRenderTarget, createFloatRenderTarget, createPingPong, createRenderTarget, disposePingPong, disposeRenderTarget, generateRenderTargetMipMaps, readRenderTargetPixels, resizePingPong, resizeRenderTarget } from "./render-target.js";
+import { bindAttributes, bindIndexBuffer, bindMeshVao, createIndexBuffer, createMeshVao, createVertexBuffer, disposeBuffer, disposeMeshVao, drawIndexed, drawMesh, unbindInstanceAttributes, updateVertexBuffer } from "./mesh.js";
+import { G as G2, a as a3, c as c2, d as d2, b as b3, r as r2, s as s2, e as e3, f as f3 } from "./sprites--1oyVtJ3.js";
+import { clearEngine, generateRenderTargetStencil, setColorMask, setCullState, setDepthState, setStencilState } from "./depth-stencil.js";
+import { disableScissor, setScissor } from "./scissor.js";
+import { GLSamplingMode, createHtmlElementTexture, updateHtmlElementTexture } from "./html-texture.js";
+function runRenderLoop(engine, fn) {
+  if (engine._disposed) {
+    return;
+  }
+  if (engine._scheduleFrame === null) {
+    engine._scheduleFrame = scheduleFrame;
+  }
+  if (engine._loops.indexOf(fn) !== -1) {
+    return;
+  }
+  engine._loops.push(fn);
+  if (engine._rafId === 0 && !engine._isLost) {
+    scheduleFrame(engine);
+  }
+}
+function stopRenderLoop(engine, fn) {
+  if (fn === void 0) {
+    engine._loops.length = 0;
+  } else {
+    const i2 = engine._loops.indexOf(fn);
+    if (i2 !== -1) {
+      engine._loops.splice(i2, 1);
+    }
+  }
+  if (engine._loops.length === 0 && engine._rafId !== 0) {
+    cancelAnimationFrame(engine._rafId);
+    engine._rafId = 0;
+  }
+}
+function scheduleFrame(engine) {
+  engine._prevNow = performance.now();
+  engine._rafId = requestAnimationFrame((now) => tick(engine, now));
+}
+function tick(engine, now) {
+  engine._rafId = 0;
+  if (engine._disposed || engine._isLost || engine._loops.length === 0) {
+    return;
+  }
+  const dt = now - engine._prevNow;
+  engine._prevNow = now;
+  const loops = engine._loops.slice();
+  for (const cb of loops) {
+    try {
+      cb(dt);
+    } catch (err) {
+      console.error("lite-gl: render loop callback threw", err);
+    }
+  }
+  if (engine._loops.length > 0 && !engine._disposed && !engine._isLost) {
+    engine._rafId = requestAnimationFrame((nextNow) => tick(engine, nextNow));
+  }
+}
+const DEFAULT_FULLSCREEN_VERTEX_SOURCE = `#version 300 es
+layout(location = 0) in vec2 position;
+out vec2 vUv;
+void main() {
+    vUv = position * 0.5 + 0.5;
+    gl_Position = vec4(position, 0.0, 1.0);
+}`;
+function createEffectWrapper(engine, options) {
+  const name = options.name ?? "effect-wrapper";
+  const effect = createEffect(engine, {
+    name,
+    vertexSource: options.vertexSource ?? DEFAULT_FULLSCREEN_VERTEX_SOURCE,
+    fragmentSource: options.fragmentSource,
+    uniformNames: options.uniformNames ?? [],
+    samplerNames: options.samplerNames ?? [],
+    attributeNames: options.attributeNames,
+    defines: options.defines
+  });
+  return { name, effect, _engine: engine, _disposed: false };
+}
+function disposeEffectWrapper(wrapper) {
+  if (wrapper._disposed) {
+    return;
+  }
+  wrapper._disposed = true;
+  disposeEffect(wrapper._engine, wrapper.effect);
+}
+function setViewport(engine, viewport) {
+  if (engine._isLost || engine._disposed) {
+    return;
+  }
+  const x2 = (viewport == null ? void 0 : viewport.x) ?? 0;
+  const y2 = (viewport == null ? void 0 : viewport.y) ?? 0;
+  const w2 = (viewport == null ? void 0 : viewport.w) ?? engine.canvas.width;
+  const h3 = (viewport == null ? void 0 : viewport.h) ?? engine.canvas.height;
+  const s3 = engine._state;
+  if (s3.viewportX === x2 && s3.viewportY === y2 && s3.viewportW === w2 && s3.viewportH === h3) {
+    return;
+  }
+  s3.viewportX = x2;
+  s3.viewportY = y2;
+  s3.viewportW = w2;
+  s3.viewportH = h3;
+  engine.gl.viewport(x2, y2, w2, h3);
+}
+function applyEffectWrapper(wrapper) {
+  const engine = wrapper._engine;
+  if (engine._isLost || engine._disposed || wrapper._disposed) {
+    return;
+  }
+  ensureQuad(engine);
+  useEffect(engine, wrapper.effect);
+}
+function drawEffect(engine) {
+  if (engine._isLost || engine._disposed) {
+    return;
+  }
+  if (engine._state.currentProgram === null) {
+    return;
+  }
+  applyGLStates(engine);
+  engine.gl.drawElements(engine.gl.TRIANGLES, 6, engine.gl.UNSIGNED_SHORT, 0);
+}
+function ensureQuad(engine) {
+  const s3 = engine._state;
+  const gl = engine.gl;
+  if (s3.quadVao !== null) {
+    if (s3.boundVao !== s3.quadVao) {
+      gl.bindVertexArray(s3.quadVao);
+      s3.boundVao = s3.quadVao;
+    }
+    return;
+  }
+  const vao = gl.createVertexArray();
+  if (vao === null) {
+    throw new Error("lite-gl: gl.createVertexArray returned null");
+  }
+  s3.quadVao = vao;
+  gl.bindVertexArray(vao);
+  s3.boundVao = vao;
+  const vbo = gl.createBuffer();
+  if (vbo === null) {
+    throw new Error("lite-gl: gl.createBuffer returned null (VBO)");
+  }
+  s3.quadVbo = vbo;
+  gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
+  s3.boundArrayBuffer = vbo;
+  gl.bufferData(gl.ARRAY_BUFFER, QUAD_POSITIONS, gl.STATIC_DRAW);
+  const ibo = gl.createBuffer();
+  if (ibo === null) {
+    throw new Error("lite-gl: gl.createBuffer returned null (IBO)");
+  }
+  s3.quadIbo = ibo;
+  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo);
+  s3.boundElementBuffer = ibo;
+  gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, QUAD_INDICES, gl.STATIC_DRAW);
+  gl.enableVertexAttribArray(0);
+  gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
+}
+const QUAD_POSITIONS = new Float32Array([1, 1, -1, 1, -1, -1, 1, -1]);
+const QUAD_INDICES = new Uint16Array([0, 1, 2, 0, 2, 3]);
+export {
+  G2 as GLBlendEquation,
+  a3 as GLBlendMode,
+  GLSamplingMode,
+  applyEffectWrapper,
+  bindAttributes,
+  bindIndexBuffer,
+  bindMeshVao,
+  bindRenderTarget,
+  b2 as bindTexture,
+  clearDynamicTextureSource,
+  clearEngine,
+  createDynamicTexture,
+  createEffect,
+  createEffectWrapper,
+  createFloatRenderTarget,
+  c as createFloatTexture,
+  a as createGLEngine,
+  createHtmlElementTexture,
+  createIndexBuffer,
+  createMeshVao,
+  createPingPong,
+  a2 as createRawTexture,
+  createRenderTarget,
+  c2 as createSpriteRenderer,
+  d as createTextureFromHandle,
+  createVertexBuffer,
+  d2 as disableBlend,
+  disableScissor,
+  disposeBuffer,
+  disposeEffect,
+  disposeEffectWrapper,
+  b as disposeGLEngine,
+  disposeMeshVao,
+  disposePingPong,
+  disposeRenderTarget,
+  b3 as disposeSpriteRenderer,
+  e2 as disposeTexture,
+  drawEffect,
+  drawIndexed,
+  drawMesh,
+  e as executeWhenCompiled,
+  generateRenderTargetMipMaps,
+  generateRenderTargetStencil,
+  g2 as generateTextureMipMaps,
+  g as getHardwareScalingLevel,
+  f as getRenderHeight,
+  h as getRenderWidth,
+  i as getRenderingCanvas,
+  j as isEffectReady,
+  l2 as loadTexture2D,
+  o as offContextLost,
+  k as offContextRestored,
+  l as onContextLost,
+  m as onContextRestored,
+  readRenderTargetPixels,
+  r2 as renderSprites,
+  r as resizeGLEngine,
+  resizePingPong,
+  resizeRenderTarget,
+  runRenderLoop,
+  s2 as setBlendMode,
+  e3 as setBlendState,
+  setColorMask,
+  setCullState,
+  setDepthState,
+  s as setEffectColor3,
+  n as setEffectColor4,
+  p as setEffectDirectColor4,
+  q as setEffectFloat,
+  t as setEffectFloat2,
+  v as setEffectFloat3,
+  w as setEffectFloat4,
+  x as setEffectFloatArray,
+  y as setEffectFloatArray4,
+  z as setEffectInt,
+  A as setEffectIntArray,
+  B as setEffectMatrix,
+  C as setEffectMatrix3x3,
+  D as setEffectTexture,
+  E as setEffectVector2,
+  F as setGLEngineSize,
+  G as setHardwareScalingLevel,
+  setScissor,
+  f3 as setSpriteRendererTexture,
+  setStencilState,
+  setViewport,
+  stopRenderLoop,
+  unbindInstanceAttributes,
+  updateDynamicTexture,
+  updateHtmlElementTexture,
+  u as updateRawTexture,
+  f2 as updateTextureSamplingMode,
+  h2 as updateTextureWrapMode,
+  updateVertexBuffer,
+  useEffect,
+  H as wipeGLStateCache
+};
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/render-loop.ts","../src/effect-renderer.ts"],"sourcesContent":["import { type GLEngineContext } from \"./context.js\";\n\n/** Register a per-frame callback. **No-op if `fn` is already registered**\n *  (matches Babylon `AbstractEngine.runRenderLoop`). Starts the rAF if this is\n *  the first registration. */\nexport function runRenderLoop(engine: GLEngineContext, fn: (dt: number) => void): void {\n    if (engine._disposed) {\n        return;\n    }\n    // Install the resume hook on the context (no module-level side effects).\n    if (engine._scheduleFrame === null) {\n        engine._scheduleFrame = scheduleFrame;\n    }\n    if (engine._loops.indexOf(fn) !== -1) {\n        return;\n    }\n    engine._loops.push(fn);\n    if (engine._rafId === 0 && !engine._isLost) {\n        scheduleFrame(engine);\n    }\n}\n\n/** Stop one (or all when omitted) registered callbacks. Cancels the rAF if\n *  no callbacks remain. */\nexport function stopRenderLoop(engine: GLEngineContext, fn?: (dt: number) => void): void {\n    if (fn === undefined) {\n        engine._loops.length = 0;\n    } else {\n        const i = engine._loops.indexOf(fn);\n        if (i !== -1) {\n            engine._loops.splice(i, 1);\n        }\n    }\n    if (engine._loops.length === 0 && engine._rafId !== 0) {\n        cancelAnimationFrame(engine._rafId);\n        engine._rafId = 0;\n    }\n}\n\nfunction scheduleFrame(engine: GLEngineContext): void {\n    engine._prevNow = performance.now();\n    engine._rafId = requestAnimationFrame((now) => tick(engine, now));\n}\n\nfunction tick(engine: GLEngineContext, now: number): void {\n    engine._rafId = 0;\n    if (engine._disposed || engine._isLost || engine._loops.length === 0) {\n        return;\n    }\n    const dt = now - engine._prevNow;\n    engine._prevNow = now;\n    // Snapshot — a callback may call stopRenderLoop on itself or others.\n    const loops = engine._loops.slice();\n    for (const cb of loops) {\n        try {\n            cb(dt);\n        } catch (err) {\n            console.error(\"lite-gl: render loop callback threw\", err);\n        }\n    }\n    if (engine._loops.length > 0 && !engine._disposed && !engine._isLost) {\n        engine._rafId = requestAnimationFrame((nextNow) => tick(engine, nextNow));\n    }\n}\n","import type { GLEngineContext } from \"./context.js\";\nimport { createEffect, disposeEffect, type GLEffect, useEffect } from \"./effect.js\";\nimport { applyGLStates } from \"./apply-states.js\";\n\n/** Built-in fullscreen-quad vertex shader, used when `GLEffectWrapperOptions`\n *  omits `vertexSource`. Maps the package's fullscreen-quad positions\n *  (attribute location 0) to clip space and forwards a 0..1 `vUv` varying —\n *  the WebGL counterpart of lite's default `vertexWGSL`, so callers can pass\n *  only `fragmentSource`. */\nconst DEFAULT_FULLSCREEN_VERTEX_SOURCE = `#version 300 es\nlayout(location = 0) in vec2 position;\nout vec2 vUv;\nvoid main() {\n    vUv = position * 0.5 + 0.5;\n    gl_Position = vec4(position, 0.0, 1.0);\n}`;\n\n/** Inputs to `createEffectWrapper`. Mirrors lite's `EffectWrapperOptions`: the\n *  wrapper compiles and OWNS the effect built from this shader source. */\nexport interface GLEffectWrapperOptions {\n    /** Human-readable label for the wrapper and its effect. Defaults to\n     *  `\"effect-wrapper\"`. */\n    name?: string;\n    /** GLSL ES 3.00 vertex source. Defaults to a built-in fullscreen-quad\n     *  vertex shader (exposing a `vUv` varying), mirroring lite's default\n     *  `vertexWGSL`. */\n    vertexSource?: string;\n    /** GLSL ES 3.00 fragment source (≙ lite's `fragmentWGSL`). Required. */\n    fragmentSource: string;\n    /** Declared uniform names. Defaults to none. */\n    uniformNames?: readonly string[];\n    /** Declared sampler names, in unit-assignment order. Defaults to none. */\n    samplerNames?: readonly string[];\n    /** Attribute names; the first is bound to location 0. Defaults to\n     *  `[\"position\"]`. */\n    attributeNames?: readonly string[];\n    /** Optional `#define` block prepended to both shader stages. */\n    defines?: string;\n}\n\n/** A reusable fullscreen effect that compiles and OWNS its `GLEffect` — the\n *  WebGL counterpart of lite's `EffectWrapper`. The wrapper retains the engine\n *  it was created for, so `disposeEffectWrapper` / `applyEffectWrapper` take\n *  only the wrapper. */\nexport interface GLEffectWrapper {\n    /** Name alias for the wrapper (and its effect). */\n    readonly name: string;\n    /** The compiled effect this wrapper owns. Exposed so the per-uniform\n     *  setters (`setEffectFloat`/`setEffectTexture`/…) can target it — the\n     *  WebGL divergence from lite's UBO-based `setEffectUniforms(wrapper, …)`. */\n    readonly effect: GLEffect;\n    /** @internal The engine the wrapper was created for. */\n    _engine: GLEngineContext;\n    /** @internal */\n    _disposed: boolean;\n}\n\n/** Compile a fullscreen effect from shader source and wrap it; the wrapper OWNS\n *  the resulting `GLEffect`. Mirrors lite's `createEffectWrapper(engine, options)`.\n *  When `vertexSource` is omitted, a built-in fullscreen-quad vertex shader is\n *  used, so callers can supply only `fragmentSource`. */\nexport function createEffectWrapper(engine: GLEngineContext, options: GLEffectWrapperOptions): GLEffectWrapper {\n    const name = options.name ?? \"effect-wrapper\";\n    const effect = createEffect(engine, {\n        name,\n        vertexSource: options.vertexSource ?? DEFAULT_FULLSCREEN_VERTEX_SOURCE,\n        fragmentSource: options.fragmentSource,\n        uniformNames: options.uniformNames ?? [],\n        samplerNames: options.samplerNames ?? [],\n        attributeNames: options.attributeNames,\n        defines: options.defines,\n    });\n    return { name, effect, _engine: engine, _disposed: false };\n}\n\n/** Dispose the wrapper and the effect it owns (idempotent). Mirrors lite's\n *  `disposeEffectWrapper(wrapper)`. */\nexport function disposeEffectWrapper(wrapper: GLEffectWrapper): void {\n    if (wrapper._disposed) {\n        return;\n    }\n    wrapper._disposed = true;\n    disposeEffect(wrapper._engine, wrapper.effect);\n}\n\n/** Pixel-space viewport rectangle passed to `setViewport`. */\nexport interface GLViewport {\n    /** Lower-left X origin in physical pixels. */\n    x: number;\n    /** Lower-left Y origin in physical pixels. */\n    y: number;\n    /** Width in physical pixels. */\n    w: number;\n    /** Height in physical pixels. */\n    h: number;\n}\n\n/** Cached `gl.viewport`. Defaults to the full canvas in pixel coordinates. */\nexport function setViewport(engine: GLEngineContext, viewport?: GLViewport): void {\n    if (engine._isLost || engine._disposed) {\n        return;\n    }\n    const x = viewport?.x ?? 0;\n    const y = viewport?.y ?? 0;\n    const w = viewport?.w ?? engine.canvas.width;\n    const h = viewport?.h ?? engine.canvas.height;\n    const s = engine._state;\n    if (s.viewportX === x && s.viewportY === y && s.viewportW === w && s.viewportH === h) {\n        return;\n    }\n    s.viewportX = x;\n    s.viewportY = y;\n    s.viewportW = w;\n    s.viewportH = h;\n    engine.gl.viewport(x, y, w, h);\n}\n\n/** Make `wrapper.effect` current and ensure the shared fullscreen quad VAO\n *  is bound. This MUST be called BEFORE any `setEffect*` call for the same\n *  effect in the current frame (uniform setters write to the currently bound\n *  program). */\nexport function applyEffectWrapper(wrapper: GLEffectWrapper): void {\n    const engine = wrapper._engine;\n    if (engine._isLost || engine._disposed || wrapper._disposed) {\n        return;\n    }\n    ensureQuad(engine);\n    useEffect(engine, wrapper.effect);\n}\n\n/** `gl.drawElements(TRIANGLES, 6, UNSIGNED_SHORT, 0)`. No-op when the\n *  context is lost or there is no current program. */\nexport function drawEffect(engine: GLEngineContext): void {\n    if (engine._isLost || engine._disposed) {\n        return;\n    }\n    if (engine._state.currentProgram === null) {\n        return;\n    }\n    applyGLStates(engine);\n    engine.gl.drawElements(engine.gl.TRIANGLES, 6, engine.gl.UNSIGNED_SHORT, 0);\n}\n\n/** Lazy fullscreen quad. Built on first call; thereafter the VAO is cached on\n *  `_state.quadVao` and rebinding is a single cached call. Cleared by\n *  `webglcontextlost` and transparently rebuilt by the next\n *  `applyEffectWrapper` after restore.\n *\n *  Position attribute is enabled at location 0 — every effect's\n *  `createEffect` calls `gl.bindAttribLocation(program, 0, attributeNames[0])`\n *  BEFORE link, so the shared VAO is correct across all programs. */\nfunction ensureQuad(engine: GLEngineContext): void {\n    const s = engine._state;\n    const gl = engine.gl;\n    if (s.quadVao !== null) {\n        if (s.boundVao !== s.quadVao) {\n            gl.bindVertexArray(s.quadVao);\n            s.boundVao = s.quadVao;\n        }\n        return;\n    }\n    const vao = gl.createVertexArray();\n    if (vao === null) {\n        throw new Error(\"lite-gl: gl.createVertexArray returned null\");\n    }\n    s.quadVao = vao;\n    gl.bindVertexArray(vao);\n    s.boundVao = vao;\n\n    const vbo = gl.createBuffer();\n    if (vbo === null) {\n        throw new Error(\"lite-gl: gl.createBuffer returned null (VBO)\");\n    }\n    s.quadVbo = vbo;\n    gl.bindBuffer(gl.ARRAY_BUFFER, vbo);\n    s.boundArrayBuffer = vbo;\n    gl.bufferData(gl.ARRAY_BUFFER, QUAD_POSITIONS, gl.STATIC_DRAW);\n\n    const ibo = gl.createBuffer();\n    if (ibo === null) {\n        throw new Error(\"lite-gl: gl.createBuffer returned null (IBO)\");\n    }\n    s.quadIbo = ibo;\n    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo);\n    s.boundElementBuffer = ibo;\n    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, QUAD_INDICES, gl.STATIC_DRAW);\n\n    gl.enableVertexAttribArray(0);\n    gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);\n}\n\n/** Typed-array literal — pure per bundler convention. Matches Babylon's\n *  `EffectRenderer` default geometry exactly. */\nconst QUAD_POSITIONS = new Float32Array([1, 1, -1, 1, -1, -1, 1, -1]);\nconst QUAD_INDICES = new Uint16Array([0, 1, 2, 0, 2, 3]);\n"],"names":["i","x","y","w","h","s"],"mappings":"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"}

package/mesh.d.ts

@@ -0,0 +1,307 @@
+/**
+ * Configure vertex attributes from `vb`, reproducing Babylon's
+ * `bindInstancesBuffer` exactly. For each descriptor: resolves the location
+ * (explicit `index` or via the effect), enables the attribute array, issues
+ * `vertexAttribPointer`, and sets the vertex divisor (`undefined → 1`). Every
+ * touched location is tracked so {@link unbindInstanceAttributes} can reset its
+ * divisor afterwards.
+ *
+ * `computeStride` controls the GL stride passed to `vertexAttribPointer`:
+ * - `false` (default) → stride `0`: each attribute is independently tightly
+ *   packed. Combined with overlapping `offset`s this yields the "sliding window"
+ *   ShapeBuilder uses for distance-field tape buffers.
+ * - `true` → stride = Σ(`size`·4 bytes): interleaved per-vertex/per-instance.
+ *
+ * Runs on the default (null) VAO — never corrupts the quad / sprite VAOs.
+ * No-op on a lost/disposed context or before the effect is ready.
+ *
+ * @param engine - The engine.
+ * @param vb - The buffer supplying the attribute data.
+ * @param descriptors - The attribute layout.
+ * @param effect - The effect whose attribute locations resolve unnamed indices.
+ * @param computeStride - See above. Default `false`.
+ */
+export declare function bindAttributes(engine: GLEngineContext, vb: GLVertexBuffer, descriptors: readonly GLAttributeDescriptor[], effect: GLEffect, computeStride?: boolean): void;
+
+/**
+ * Bind an index buffer as the current element-array buffer (on the default
+ * VAO). Cached. The lite-gl equivalent of Babylon's `_bindIndexBufferWithCache`.
+ *
+ * @param engine - The engine.
+ * @param ib - The index buffer to bind.
+ */
+export declare function bindIndexBuffer(engine: GLEngineContext, ib: GLIndexBuffer): void;
+
+/**
+ * Bind a {@link GLMeshVao} (cached `gl.bindVertexArray`). Rarely called directly —
+ * {@link drawMesh} binds it for you. Binding restores the VAO's recorded element
+ * binding, so the element-buffer cache is updated in lock-step.
+ *
+ * @param engine - The engine.
+ * @param vao - The mesh VAO to bind.
+ */
+export declare function bindMeshVao(engine: GLEngineContext, vao: GLMeshVao): void;
+
+/**
+ * Create a GPU index buffer. `Uint16Array` → 16-bit indices, `Uint32Array` →
+ * 32-bit. Binds the default VAO first so it never corrupts the quad / sprite
+ * VAO element bindings.
+ *
+ * @param engine - The engine.
+ * @param data - The index data. Retained by reference for context-restore.
+ * @returns The new {@link GLIndexBuffer}.
+ */
+export declare function createIndexBuffer(engine: GLEngineContext, data: Uint16Array | Uint32Array): GLIndexBuffer;
+
+/**
+ * Record a static mesh's attribute layout + index binding into a new VAO. The
+ * effect MUST be ready (its attribute locations are resolved here, once). Returns
+ * a {@link GLMeshVao} to draw with {@link drawMesh}.
+ *
+ * @param engine - The engine.
+ * @param vertexBuffers - One or more buffers + their attribute layouts.
+ * @param indexBuffer - The index buffer recorded into the VAO.
+ * @param effect - The effect whose attribute locations resolve unnamed indices.
+ * @returns The recorded {@link GLMeshVao}.
+ */
+export declare function createMeshVao(engine: GLEngineContext, vertexBuffers: readonly GLMeshVertexBuffer[], indexBuffer: GLIndexBuffer, effect: GLEffect): GLMeshVao;
+
+/**
+ * Create a GPU vertex buffer from interleaved float data.
+ *
+ * @param engine - The engine.
+ * @param data - The vertex data. Retained by reference for context-restore — do
+ *  not mutate it in place; use {@link updateVertexBuffer} to change contents.
+ * @param dynamic - Hint that the buffer will be updated frequently
+ *  (`DYNAMIC_DRAW`). Default `false` (`STATIC_DRAW`).
+ * @returns The new {@link GLVertexBuffer}.
+ */
+export declare function createVertexBuffer(engine: GLEngineContext, data: Float32Array, dynamic?: boolean): GLVertexBuffer;
+
+/** Dispose a vertex or index buffer (delete the GL buffer + unregister). Clears
+ *  the array/element-buffer cache slot if it pointed at this buffer. Idempotent. */
+export declare function disposeBuffer(engine: GLEngineContext, buffer: GLVertexBuffer | GLIndexBuffer): void;
+
+/** Dispose a {@link GLMeshVao}: delete the VAO and unregister its restore hook.
+ *  Does NOT dispose the vertex/index buffers (the caller owns those). Idempotent. */
+export declare function disposeMeshVao(engine: GLEngineContext, vao: GLMeshVao): void;
+
+/**
+ * Draw indexed triangles from `ib` — the lite-gl equivalent of Babylon's
+ * `drawElementsType` (triangle fill mode). When `instanceCount > 0` issues
+ * `drawElementsInstanced`, otherwise `drawElements`. No-op on a lost/disposed
+ * context or when no program is current.
+ *
+ * @param engine - The engine.
+ * @param ib - The index buffer (also bound as a side-effect, cached).
+ * @param indexCount - Number of indices to draw.
+ * @param indexStart - First index offset (in indices, not bytes). Default 0.
+ * @param instanceCount - Instance count for instanced draws. Default 0
+ *  (non-instanced).
+ */
+export declare function drawIndexed(engine: GLEngineContext, ib: GLIndexBuffer, indexCount: number, indexStart?: number, instanceCount?: number): void;
+
+/**
+ * Draw a static mesh recorded with {@link createMeshVao}: binds its VAO (cached),
+ * flushes deferred GL state, and issues ONE `drawElements` (or
+ * `drawElementsInstanced` when `instanceCount > 0`) over the VAO's full index
+ * buffer. No per-draw attribute (re)binding. No-op on a lost/disposed context, a
+ * disposed VAO, or when no program is current.
+ *
+ * @param engine - The engine.
+ * @param vao - The mesh VAO to draw.
+ * @param instanceCount - Instance count for instanced draws. Default 0 (non-instanced).
+ */
+export declare function drawMesh(engine: GLEngineContext, vao: GLMeshVao, instanceCount?: number): void;
+
+/**
+ * Describes one vertex attribute fed from a buffer — the lite-gl equivalent of
+ * Babylon's `InstancingAttributeInfo`. Pass an array of these to
+ * {@link bindAttributes}.
+ */
+export declare interface GLAttributeDescriptor {
+    /** Attribute name; resolved to a location via the effect when `index` is
+     *  omitted (`Effect.getAttributeLocationByName`). */
+    name?: string;
+    /** Explicit attribute location. When set, overrides the `name` lookup. */
+    index?: number;
+    /** Number of components, 1–4. */
+    size: number;
+    /** Byte offset of this attribute's first element within the buffer. Default 0. */
+    offset?: number;
+    /**
+     * Per-instance vertex divisor. **Omitted/`undefined` → `1` (instanced)**,
+     * matching Babylon's `bindInstancesBuffer`. Pass `0` explicitly for a
+     * per-vertex attribute (e.g. the base mesh position).
+     */
+    divisor?: number;
+    /** GL component type. Default `gl.FLOAT`. */
+    type?: GLenum;
+    /** Normalize fixed-point integer data to `[0,1]`/`[-1,1]`. Default `false`. */
+    normalized?: boolean;
+}
+
+/** A compiled + linked shader program with cached uniform, sampler and
+ *  attribute locations. Created by `createEffect`; most fields are managed
+ *  internally — drive it via `isEffectReady` / `useEffect` / the `setEffect*`
+ *  setters rather than mutating it directly. */
+declare interface GLEffect {
+    /** The `name` from the originating `GLEffectOptions`. */
+    readonly name: string;
+    /** The options this effect was created from (retained for context-restore). */
+    readonly options: GLEffectOptions;
+    /** The live `WebGLProgram`. Swapped for a fresh handle after context-restore. */
+    program: WebGLProgram;
    /** Resolved during readiness finalization. Missing names map to `null` —
+     *  setters with a `null` location are silent no-ops (matches Babylon). */
+    uniformLocations: {
+        [name: string]: WebGLUniformLocation | null;
+    };
+    /** Fixed unit assignment for declared samplers, index into
+     *  `_state.boundTextures`. */
+    samplerUnits: {
+        [name: string]: number;
+    };
    /** Resolved attribute locations, keyed by attribute name. */
+    attributeLocations: {
+        [name: string]: number;
+    };
    /** True once the program has linked and finalization has run; the
+     *  `setEffect*` setters are no-ops until then. Poll `isEffectReady` to advance it. */
+    isReady: boolean;
+
+/** Inputs to `createEffect`: shader sources plus the uniform, sampler and
+ *  attribute names whose locations are resolved during readiness finalization. */
+declare interface GLEffectOptions {
+    /** Human-readable label, surfaced in compile/link error messages. */
+    name: string;
+    /** GLSL ES 3.00 source, ready for `gl.shaderSource`. */
+    vertexSource: string;
+    /** GLSL ES 3.00 source, ready for `gl.shaderSource`. */
+    fragmentSource: string;
+    /** Declared uniform names. Locations are resolved during readiness
+     *  finalization. Names not declared here are legal but allocate cache
+     *  slots lazily on first setter use. */
+    uniformNames: readonly string[];
+    /** Declared sampler names, in unit-assignment order. Each gets a fixed
+     *  texture unit assigned during readiness finalization, and
+     *  `gl.uniform1i(loc, unit)` is called exactly once per program lifetime
+     *  (re-run after `webglcontextrestored`). */
+    samplerNames: readonly string[];
+    /** Default `["position"]`. The first attribute is bound to location 0 via
+     *  `gl.bindAttribLocation(program, 0, name)` BEFORE link, so the shared
+     *  fullscreen-quad VAO always feeds the same location. */
+    attributeNames?: readonly string[];
+    /** Optional `#define` block. Each unique `defines` string must be paired
+     *  with the same vertex/fragment source via a separate `createEffect` call —
+     *  the package does NOT cache compiled variants. */
+    defines?: string;
+}
+
+/** Read-only WebGL2 capability limits, queried once at context creation. */
+declare interface GLEngineCaps {
+    /** `gl.MAX_TEXTURE_SIZE` — largest supported texture dimension, in texels. */
+    readonly maxTextureSize: number;
+    /** `gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS` — number of sampler binding slots. */
+    readonly maxTextureUnits: number;
+    /** The `KHR_parallel_shader_compile` extension used for async link polling,
+     *  or null when unsupported — linking is then treated as synchronous. */
+    readonly parallelShaderCompile: {
+        COMPLETION_STATUS_KHR: number;
+    } | null;
+    /** True when 32-bit float color attachments are renderable
+     *  (`EXT_color_buffer_float`). Mirrors Babylon's `caps.textureFloatRender`. */
+    readonly textureFloatRender: boolean;
+    /** True when 32-bit float textures support linear filtering
+     *  (`OES_texture_float_linear`). Mirrors `caps.textureFloatLinearFiltering`. */
+    readonly textureFloatLinearFiltering: boolean;
+    /** True when 16-bit half-float color attachments are renderable
+     *  (`EXT_color_buffer_float` or `EXT_color_buffer_half_float`). Mirrors
+     *  `caps.textureHalfFloatRender`. */
+    readonly textureHalfFloatRender: boolean;
+    /** Half-float linear filtering — always `true` in WebGL2 (it is core).
+     *  Kept as a field to mirror Babylon's `caps.textureHalfFloatLinearFiltering`. */
+    readonly textureHalfFloatLinearFiltering: boolean;
+    /** Whether non-power-of-two textures need POT dimensions for mips / wrap.
+     *  Always `false` in WebGL2 (NPOT is core). Mirrors `engine.needPOTTextures`. */
+    readonly needPOTTextures: boolean;
+}
+
+/**
+ * Pure-state handle for a WebGL2 canvas + its cached GL state.
+ *
+ * INVARIANT: consumers MUST NOT mutate GL state directly through `engine.gl`.
+ * Doing so silently corrupts the cache in `_state`. The package owns every
+ * GL call. (`engine.gl` is exposed only so downstream code that already has the
+ * pattern of poking `engine._gl.getExtension(...)` can do that, but must NOT
+ * call `bindTexture`/`useProgram`/`bindBuffer`/`viewport`/etc.)
+ */
+declare interface GLEngineContext {
+    /** The canvas the WebGL2 context was acquired from. An `OffscreenCanvas` is
+     *  supported for worker render paths (e.g. the Lottie player); it has no CSS
+     *  box, so it must be sized explicitly via `setGLEngineSize` rather than the
+     *  CSS-derived `resizeGLEngine`. */
+    readonly canvas: HTMLCanvasElement | OffscreenCanvas;
+    /** The raw WebGL2 context. Do NOT mutate GL state through it — see the
+     *  type-level invariant above; the package owns every state-changing call. */
+    readonly gl: WebGL2RenderingContext;
+    /** Queried capability limits for this context. */
+    readonly caps: GLEngineCaps;
+
+/** A GPU index buffer. The lite-gl counterpart of Babylon's `DataBuffer` for
+ *  index data. */
+export declare interface GLIndexBuffer {
+    /** The live `WebGLBuffer`. Swapped on `webglcontextrestored`. */
+    handle: WebGLBuffer;
+    /** Number of indices. */
+    count: number;
+    /** `true` for 32-bit (`Uint32Array`) indices, `false` for 16-bit. */
+    is32Bits: boolean;
+
+/** A recorded Vertex Array Object capturing a static mesh's attribute layout +
+ *  index binding. Bind + draw it with {@link drawMesh} each frame — the GPU
+ *  replays the entire attribute setup from one `bindVertexArray`. Re-recorded
+ *  automatically on `webglcontextrestored`. */
+export declare interface GLMeshVao {
+    /** The live `WebGLVertexArrayObject`. Swapped on `webglcontextrestored`. */
+    handle: WebGLVertexArrayObject;
+
+/** One vertex buffer + its attribute layout, for {@link createMeshVao}. */
+export declare interface GLMeshVertexBuffer {
+    /** The buffer supplying this group's attributes. */
+    buffer: GLVertexBuffer;
+    /** The attributes read from `buffer` (same shape as {@link bindAttributes}). */
+    attributes: readonly GLAttributeDescriptor[];
+    /** Stride mode (see {@link bindAttributes}): `false` (default) → stride `0`
+     *  per attribute; `true` → interleaved stride = Σ(`size`·4). */
+    computeStride?: boolean;
+}
+
+/** A GPU vertex buffer holding interleaved float vertex data. The lite-gl
+ *  counterpart of Babylon's `DataBuffer` for vertex data. */
+export declare interface GLVertexBuffer {
+    /** The live `WebGLBuffer`. Swapped on `webglcontextrestored`. */
+    handle: WebGLBuffer;
+    /** Size of the GL buffer in bytes. */
+    byteLength: number;
+
+/**
+ * Reset the vertex divisor of every attribute touched by {@link bindAttributes}
+ * back to 0 — the lite-gl equivalent of Babylon's `unbindInstanceAttributes`.
+ * Call after an instanced draw so a following non-instanced draw is not skewed.
+ * No-op on a lost/disposed context.
+ *
+ * @param engine - The engine.
+ */
+export declare function unbindInstanceAttributes(engine: GLEngineContext): void;
+
+/**
+ * Upload new contents into (part of) a vertex buffer via `bufferSubData`. A
+ * full-buffer update from offset 0 also refreshes the retained CPU data used
+ * for context-restore.
+ *
+ * @param engine - The engine.
+ * @param vb - The vertex buffer to update.
+ * @param data - The new float data.
+ * @param dstByteOffset - Destination byte offset within the buffer. Default 0.
+ */
+export declare function updateVertexBuffer(engine: GLEngineContext, vb: GLVertexBuffer, data: Float32Array, dstByteOffset?: number): void;
+
+export { }