@babylonjs/lite-gl 0.1.0 → 0.2.0

package/index.d.ts

@@ -1,1482 +1,23 @@
-/** Make `wrapper.effect` current and ensure the shared fullscreen quad VAO
- *  is bound. This MUST be called BEFORE any `setEffect*` call for the same
- *  effect in the current frame (uniform setters write to the currently bound
- *  program). */
-export declare function applyEffectWrapper(wrapper: GLEffectWrapper): void;
-
-/**
- * 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;
-
-/**
- * Bind the render target's framebuffer as the draw target and set the viewport
- * to cover it. `rt = null` binds the default (canvas) framebuffer and resets the
- * viewport to the full canvas — the counterpart of Babylon's
- * `restoreDefaultFramebuffer`. Subsequent `drawEffect` / `drawIndexed` /
- * `clearEngine` calls write into the bound target.
- *
- * Cached. No-op on a lost/disposed context or a disposed `rt`. Mipmaps are NOT
- * regenerated here — refresh a target's mip chain explicitly via
- * {@link generateRenderTargetMipMaps} after rendering into it.
- *
- * @param engine - The engine.
- * @param rt - The render target to draw into, or `null` for the canvas.
- */
-export declare function bindRenderTarget(engine: GLEngineContext, rt: GLRenderTarget | null): void;
-
-/** Cached bind. Skips `gl.activeTexture` and/or `gl.bindTexture` when nothing
- *  changes. No-op when `tex._disposed` or `engine._isLost`. */
-export declare function bindTexture(engine: GLEngineContext, unit: number, tex: GLTexture | null): void;
-
-/** Forget the source a dynamic texture retained for context-restore replay.
- *  The current GPU pixels are kept (no re-upload), but the source reference is
- *  dropped so it can be garbage-collected — and a subsequent
- *  `webglcontextrestored` will re-blank the texture instead of replaying. Use
- *  after the final {@link updateDynamicTexture} once the source (e.g. a large
- *  atlas canvas) is no longer needed. No-op on a non-dynamic texture. */
-export declare function clearDynamicTextureSource(tex: GLTexture): void;
-
-/**
- * Clear the currently-bound framebuffer's color / depth / stencil buffers — the
- * lite-gl equivalent of Babylon's `clear(color, backBuffer, depth, stencil)`.
- * Depth/stencil clears respect the current write masks (set them first via
- * {@link setDepthState} / {@link setStencilState}). No-op when nothing is
- * requested or the context is lost/disposed.
- *
- * @param engine - The engine.
- * @param options - Which buffers to clear (and the color value).
- */
-export declare function clearEngine(engine: GLEngineContext, options: GLClearOptions): void;
-
-/** Create a texture backed by an empty (blank) `width × height` RGBA8
- *  allocation, whose pixels are pushed on demand with
- *  {@link updateDynamicTexture} — the WebGL counterpart of Babylon's
- *  `ThinEngine.createDynamicTexture` + `ThinTexture` wrapper.
- *
- *  The texture is immediately sampleable (reads as transparent black until the
- *  first update). It is context-restore-safe: the most recent source pushed via
- *  {@link updateDynamicTexture} is replayed into the fresh handle on
- *  `webglcontextrestored` (and re-blanked if no update happened yet).
- *
- *  `options.invertY` is ignored here (the blank allocation is flip-invariant);
- *  per-update flip is controlled by {@link updateDynamicTexture}'s `invertY`.
- *
- *  @param engine - The engine to create GL resources on.
- *  @param width - Texture width in texels (clamped to ≥ 1).
- *  @param height - Texture height in texels (clamped to ≥ 1).
- *  @param options - Optional sampling/wrap config (see {@link GLTextureOptions})
- *    plus this factory's own `generateMipMaps` flag (mipmaps are built after an
- *    update when a source is present; defaults to `false`).
- *  @returns The new {@link GLTexture}. */
-export declare function createDynamicTexture(engine: GLEngineContext, width: number, height: number, options?: GLTextureOptions & {
-    generateMipMaps?: boolean;
-}): GLTexture;
-
-/** Compile + link a new effect. Does NOT block on link completion — `isReady`
- *  starts false; consumers poll `isEffectReady` (typically from their render
- *  callback) to drive finalization. */
-export declare function createEffect(engine: GLEngineContext, options: GLEffectOptions): GLEffect;
-
-/** Compile a fullscreen effect from shader source and wrap it; the wrapper OWNS
- *  the resulting `GLEffect`. Mirrors lite's `createEffectWrapper(engine, options)`.
- *  When `vertexSource` is omitted, a built-in fullscreen-quad vertex shader is
- *  used, so callers can supply only `fragmentSource`. */
-export declare function createEffectWrapper(engine: GLEngineContext, options: GLEffectWrapperOptions): GLEffectWrapper;
-
-/**
- * Create an offscreen **float / half-float** render target — the HDR opt-in
- * counterpart of {@link createRenderTarget}. This is the only render-target
- * factory that references the `RGBA16F` / `RGBA32F` sized-format table, so RGBA8
- * consumers ship none of it.
- *
- * Defaults to `gl.HALF_FLOAT`; pass `options.type = gl.FLOAT` for full 32-bit.
- * The requested type is downgraded to the best renderable type the engine
- * supports (mirroring Babylon's `getTextureType`).
- *
- * @param engine - The engine to allocate GL resources on.
- * @param options - See {@link GLFloatRenderTargetOptions}.
- * @returns The new {@link GLRenderTarget}.
- * @throws As {@link createRenderTarget}.
- */
-export declare function createFloatRenderTarget(engine: GLEngineContext, options: GLFloatRenderTargetOptions): GLRenderTarget;
-
-/**
- * Create a float / half-float raw texture — the HDR counterpart of
- * {@link createRawTexture}. This is the ONLY texture factory that carries the
- * `RGBA16F` / `RGBA32F` sized-format knowledge (via {@link pickSizedInternalFormat}),
- * so byte-only consumers calling {@link createRawTexture} ship none of it.
- * Defaults to `gl.HALF_FLOAT`; pass `options.type = gl.FLOAT` for full 32-bit.
- * The caller is responsible for the matching engine cap (e.g.
- * `caps.textureFloatLinearFiltering`) when sampling these with `LINEAR`.
- *
- * @param engine - The engine.
- * @param data - Initial pixels (`Float32Array` for FLOAT, `Uint16Array` for
- *  HALF_FLOAT), or `null` for an uninitialised allocation.
- * @param width - Texture width in texels (≥ 1).
- * @param height - Texture height in texels (≥ 1).
- * @param options - See {@link GLFloatTextureOptions}.
- * @returns The new {@link GLTexture}.
- */
-export declare function createFloatTexture(engine: GLEngineContext, data: ArrayBufferView | null, width: number, height: number, options?: GLFloatTextureOptions): GLTexture;
-
-/** Acquire a WebGL2 context on the canvas and build the pure-state handle.
- *  Accepts an `HTMLCanvasElement` or an `OffscreenCanvas` (worker render paths —
- *  e.g. the Lottie player — which size the drawing buffer via `setGLEngineSize`).
- *  Throws if WebGL2 is unsupported. */
-export declare function createGLEngine(canvas: HTMLCanvasElement | OffscreenCanvas, options?: GLEngineOptions): GLEngineContext;
-
-/** Create a texture backed by an `<canvas>` / `<img>` / `<video>` element.
- *  The initial upload is performed immediately; call `updateHtmlElementTexture`
- *  to re-upload after the source has changed. */
-export declare function createHtmlElementTexture(engine: GLEngineContext, element: HTMLCanvasElement | HTMLImageElement | HTMLVideoElement, options?: GLHtmlElementTextureOptions): GLTexture;
-
-/**
- * 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 {@link GLPingPong}: two same-sized {@link GLRenderTarget}s for
- * self-feedback effects. `read` starts as the first target and `write` the
- * second; {@link GLPingPong.swap} exchanges them allocation-free.
- *
- * @param engine - The engine to create GL resources on.
- * @param options - Applied identically to both targets.
- * @returns The new {@link GLPingPong}.
- * @throws As {@link createRenderTarget}. If the second target fails to build the
- *  first is disposed before rethrowing (no leak).
- */
-export declare function createPingPong(engine: GLEngineContext, options: GLRenderTargetOptions): GLPingPong;
-
-/** Uint8 / float raw texture upload. The pixel data can be replaced later via
- *  {@link updateRawTexture}; the sampling and wrap can be changed via
- *  {@link updateTextureSamplingMode} / {@link updateTextureWrapMode}. */
-export declare function createRawTexture(engine: GLEngineContext, data: ArrayBufferView | null, width: number, height: number, format: GLenum, type: GLenum, options?: GLTextureOptions): GLTexture;
-
-/**
- * Create an offscreen **RGBA8** render target.
- *
- * The color attachment is an owned {@link GLTexture} (rebuilt by this target's
- * own restore hook), unless {@link GLRenderTargetOptions.colorTexture} supplies a
- * caller-managed (BYO) one. Mirrors Babylon's `createRenderTargetTexture`.
- *
- * @param engine - The engine to allocate GL resources on.
- * @param options - See {@link GLRenderTargetOptions} (`width`/`height` required).
- * @returns The new {@link GLRenderTarget}.
- * @throws If `width`/`height` are not positive integers, a GL handle could not
- *  be allocated, or the resulting framebuffer is not complete. On failure every
- *  partial GPU object (including an owned color texture) is released first.
- */
-export declare function createRenderTarget(engine: GLEngineContext, options: GLRenderTargetOptions): GLRenderTarget;
-
-/**
- * Create a sprite renderer with its own GPU buffers and compiled effect.
- *
- * Preallocates the CPU vertex scratch and the index buffer at `capacity`, so
- * {@link renderSprites} performs no allocations. The sprite GPU buffers are
- * rebuilt automatically on `webglcontextrestored` (the owned effect is rebuilt
- * by the engine's context-restore protocol).
- *
- * @param engine - The engine to create GL resources on.
- * @param options - See {@link GLSpriteRendererOptions}.
- * @returns The new {@link GLSpriteRenderer}.
- * @throws If `capacity` is not an integer in `[1, 16384]`, or if a provided
- *  `cellWidth`/`cellHeight` is not positive.
- */
-export declare function createSpriteRenderer(engine: GLEngineContext, options: GLSpriteRendererOptions): GLSpriteRenderer;
-
-/**
- * Wrap an existing raw `WebGLTexture` (e.g. one created by a host renderer or a
- * previous engine) as a {@link GLTexture} — the lite-gl equivalent of
- * ShapeBuilder's `createTextureGraphicsResourceFromExternalWebGLTexture`.
- *
- * The wrapper does NOT own the underlying handle's upload — it is NOT registered
- * for context-restore replay (the external owner is responsible for that) and is
- * marked ready immediately. `disposeTexture` will still `gl.deleteTexture` it, so
- * only wrap a handle whose deletion you intend lite-gl to manage.
- *
- * @param engine - The engine.
- * @param handle - The external `WebGLTexture`.
- * @param width - Texture width in texels.
- * @param height - Texture height in texels.
- * @param options - Optional sampling/wrap to apply once (min/mag/wrapS/wrapT).
- * @returns A {@link GLTexture} wrapping the handle.
- */
-export declare function createTextureFromHandle(engine: GLEngineContext, handle: WebGLTexture, width: number, height: number, options?: GLTextureOptions): GLTexture;
-
-/**
- * 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;
-
-/**
- * Disable blending — the equivalent of Babylon's `AlphaState.alphaBlend = false`.
- * Records the desired "blend off" state (flushed by `applyGLStates` before the
- * next draw); the actual `gl.disable(gl.BLEND)` is elided when blending is
- * already off at flush time. No-op when the context is lost or disposed.
- *
- * @param engine - The engine whose desired blend state is updated.
- */
-export declare function disableBlend(engine: GLEngineContext): void;
-
-/**
- * Disable the scissor test (`gl.disable(SCISSOR_TEST)`), cached. Repeated calls
- * after the first are elided.
- *
- * @param engine - The engine.
- */
-export declare function disableScissor(engine: GLEngineContext): void;
-
-/** 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;
-
-/** Decrement the share count and, on the last release, delete the effect's
- *  program + shaders, unregister it from the context + cache, and clear the
- *  cached current-program if it pointed at this effect. A shared effect (still
- *  referenced by another `createEffect` caller) is kept alive. Call exactly ONCE
- *  per `createEffect` (each call decrements the ref count); safe (no-op) once the
- *  effect is fully torn down. */
-export declare function disposeEffect(engine: GLEngineContext, effect: GLEffect): void;
-
-/** Dispose the wrapper and the effect it owns (idempotent). Mirrors lite's
- *  `disposeEffectWrapper(wrapper)`. */
-export declare function disposeEffectWrapper(wrapper: GLEffectWrapper): void;
-
-/** Stops the render loop, removes DOM listeners, releases all known effects
- *  and textures, then marks the context disposed. The browser-owned canvas
- *  is left intact. */
-export declare function disposeGLEngine(engine: GLEngineContext): 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;
-
-/**
- * Release both targets of a {@link GLPingPong}. Idempotent, and a no-op for
- * `null`/`undefined` (matching {@link disposeRenderTarget}).
- *
- * @param engine - The engine that owns `pp`.
- * @param pp - The ping-pong pair to release, or `null`/`undefined` for a no-op.
- */
-export declare function disposePingPong(engine: GLEngineContext, pp: GLPingPong | null | undefined): void;
-
-/**
- * Release the render target's framebuffer, depth/stencil renderbuffer and (iff
- * owned) color texture, and unregister it from the engine. Idempotent, and a
- * no-op for `null`/`undefined` (so an optional target can be released
- * unconditionally). Clears the bound-framebuffer cache if it pointed at this
- * target, and any sampler slot that held the color texture handle.
- *
- * A BYO {@link GLRenderTargetOptions.colorTexture} is NOT disposed here — it is
- * engine-managed and the caller owns its lifetime.
- *
- * @param engine - The engine.
- * @param rt - The render target to dispose, or `null`/`undefined` for a no-op.
- */
-export declare function disposeRenderTarget(engine: GLEngineContext, rt: GLRenderTarget | null | undefined): void;
-
-/** Release the renderer's VAO/VBO/IBO and the effect it owns, and unregister
- *  its context-restore handler. Idempotent. Does NOT dispose the texture — the
- *  consumer that supplied it owns its lifetime. */
-export declare function disposeSpriteRenderer(renderer: GLSpriteRenderer): void;
-
-/** Disposes the texture. Walks `_state.boundTextures` and clears every slot
- *  that still references the handle — otherwise a later `bindTexture(unit, B)`
- *  to the same unit would be wrongly elided when slot still showed handle A. */
-export declare function disposeTexture(engine: GLEngineContext, tex: GLTexture): void;
-
-/** `gl.drawElements(TRIANGLES, 6, UNSIGNED_SHORT, 0)`. No-op when the
- *  context is lost or there is no current program. */
-export declare function drawEffect(engine: GLEngineContext): 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;
-
-/** Fires `cb` synchronously if the effect is already ready; otherwise queues
- *  it for the next finalization. */
-export declare function executeWhenCompiled(engine: GLEngineContext, effect: GLEffect, cb: (e: GLEffect) => void): void;
-
-/** Regenerate a render target's color-attachment mip chain from its (freshly
- *  rendered) level-0 — mipmaps for render targets are a pure manual opt-in
- *  (call this after rendering into the target). No-op for a disposed target, a
- *  handle-less color attachment, or a lost/disposed context. */
-export declare function generateRenderTargetMipMaps(engine: GLEngineContext, rt: GLRenderTarget): void;
-
-/**
- * Opt-in: give a `/render-target` {@link GLRenderTarget} a stencil attachment,
- * replacing the core's depth-only `DEPTH_COMPONENT16` renderbuffer with either a
- * packed **`DEPTH24_STENCIL8`** buffer (default — depth *and* stencil) or a
- * stencil-only **`STENCIL_INDEX8`** buffer.
- *
- * Stencil is intentionally NOT a {@link createRenderTarget} option: keeping this
- * helper in the `/depth-stencil` sub-entry means the stencil/packed renderbuffer
- * code tree-shakes out of every bundle that only needs a color (and optional
- * depth) target.
- *
- * The attachment is **restore-correct**: it is rebuilt automatically — at the new
- * size on {@link resizeRenderTarget}, and into the fresh framebuffer after a
- * `webglcontextrestored` event — so the stencil survives for the life of the
- * target, and {@link disposeRenderTarget} releases it along with the target.
- *
- * No-op on a lost/disposed context or a disposed target.
- *
- * @param engine - The engine that owns `rt`.
- * @param rt - The render target to attach the stencil buffer to.
- * @param options - `depth` (default `true`): when `true` the attachment is a
- *  packed depth+stencil buffer (`DEPTH24_STENCIL8` on `DEPTH_STENCIL_ATTACHMENT`)
- *  — the common case, and the correct choice when the target was created with
- *  `generateDepthBuffer: true`. When `false` the attachment is stencil-only
- *  (`STENCIL_INDEX8` on `STENCIL_ATTACHMENT`).
- * @throws If a renderbuffer handle could not be allocated or the framebuffer is
- *  incomplete after attaching.
- */
-export declare function generateRenderTargetStencil(engine: GLEngineContext, rt: GLRenderTarget, options?: {
-    depth?: boolean;
-}): void;
-
-/** Generate the mip chain for a texture from its level-0 contents — mipmaps as
- *  an explicit opt-in function rather than baked into the create path. Binds for
- *  upload (unit 0). No-op on a lost/disposed context or a handle-less texture. */
-export declare function generateTextureMipMaps(engine: GLEngineContext, tex: GLTexture): void;
-
-/** Current hardware-scaling factor — drawing-buffer = clientSize × dpr / level. */
-export declare function getHardwareScalingLevel(engine: GLEngineContext): number;
-
-/** Drawing-buffer height in physical pixels (`canvas.height`). */
-export declare function getRenderHeight(engine: GLEngineContext): number;
-
-/** The backing canvas element (an `HTMLCanvasElement`, or an `OffscreenCanvas`
- *  for worker render paths). */
-export declare function getRenderingCanvas(engine: GLEngineContext): HTMLCanvasElement | OffscreenCanvas;
-
-/** Drawing-buffer width in physical pixels (`canvas.width`). */
-export declare function getRenderWidth(engine: GLEngineContext): number;
-
-/**
- * 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;
-}
-
-/**
- * Blend equation presets — the values WebGL2 accepts for
- * `gl.blendEquationSeparate`. Numeric values equal the GL enums so raw GL
- * integers (or Babylon's identical `Constants.GL_ALPHA_EQUATION_*`) pass
- * straight through.
- */
-export declare const GLBlendEquation: {
-    /** `src + dst` (the GL default). */
-    readonly ADD: 32774;
-    /** `src - dst`. */
-    readonly SUBTRACT: 32778;
-    /** `dst - src`. */
-    readonly REVERSE_SUBTRACT: 32779;
-    /** `min(src, dst)`. */
-    readonly MIN: 32775;
-    /** `max(src, dst)`. */
-    readonly MAX: 32776;
-};
-
-/** One of the {@link GLBlendEquation} preset values. */
-export declare type GLBlendEquation = (typeof GLBlendEquation)[keyof typeof GLBlendEquation];
-
-/**
- * Supported blend presets. Values mirror Babylon's `Constants.ALPHA_*` so the
- * raw Babylon integers can be passed straight through.
- */
-export declare const GLBlendMode: {
-    /** No blending — `gl.disable(gl.BLEND)`. (`Constants.ALPHA_DISABLE`) */
-    readonly DISABLE: 0;
-    /** Additive — `blendFuncSeparate(SRC_ALPHA, ONE, ZERO, ONE)`. (`Constants.ALPHA_ADD`) */
-    readonly ADD: 1;
-    /** Standard (non-premultiplied) alpha — `blendFuncSeparate(SRC_ALPHA, ONE_MINUS_SRC_ALPHA, ONE, ONE)`. (`Constants.ALPHA_COMBINE`) */
-    readonly ALPHA: 2;
-    /** Premultiplied alpha — `blendFuncSeparate(ONE, ONE_MINUS_SRC_ALPHA, ONE, ONE)`. (`Constants.ALPHA_PREMULTIPLIED`) */
-    readonly PREMULTIPLIED: 7;
-};
-
-/** One of the {@link GLBlendMode} preset values (`0`, `1`, `2` or `7`). */
-export declare type GLBlendMode = (typeof GLBlendMode)[keyof typeof GLBlendMode];
-
-/**
- * Arbitrary separate-channel blend configuration — the lite-gl equivalent of
- * Babylon's `AlphaState.setAlphaBlendFunctionParameters` +
- * `setAlphaEquationParameters`. All factor / equation fields are raw WebGL2
- * enums (`gl.ONE`, `gl.SRC_ALPHA`, `gl.MIN`, …); use {@link GLBlendEquation} for
- * the equations if you prefer named presets.
- */
-export declare interface GLBlendState {
-    /** RGB source factor (`gl.blendFuncSeparate` arg 1). */
-    srcRGB: GLenum;
-    /** RGB destination factor (`gl.blendFuncSeparate` arg 2). */
-    dstRGB: GLenum;
-    /** Alpha source factor (`gl.blendFuncSeparate` arg 3). */
-    srcAlpha: GLenum;
-    /** Alpha destination factor (`gl.blendFuncSeparate` arg 4). */
-    dstAlpha: GLenum;
-    /** RGB blend equation. Defaults to `FUNC_ADD`. */
-    equationRGB?: GLenum;
-    /** Alpha blend equation. Defaults to `FUNC_ADD`. */
-    equationAlpha?: GLenum;
-}
-
-/** Options for {@link clearEngine}. */
-export declare interface GLClearOptions {
-    /** When set, clears the color buffer to this RGBA color (alpha default 1). */
-    color?: {
-        r: number;
-        g: number;
-        b: number;
-        a?: number;
-    };
-    /** Clear the depth buffer (respects the current depth write mask). */
-    depth?: boolean;
-    /** Clear the stencil buffer (respects the current stencil write mask). */
-    stencil?: boolean;
-}
-
-/** Depth-buffer configuration for {@link setDepthState}. Omitted fields are
- *  left unchanged. */
-export declare interface GLDepthState {
-    /** Enable/disable the depth test (`gl.enable/disable(DEPTH_TEST)`). */
-    test?: boolean;
-    /** Enable/disable depth writes (`gl.depthMask`). */
-    write?: boolean;
-    /** Depth comparison function (`gl.depthFunc`), e.g. `gl.LESS`. */
-    func?: GLenum;
-}
-
-/** 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. */
-export 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. */
-export 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;
-}
-
-/** A reusable fullscreen effect that compiles and OWNS its `GLEffect` — the
- *  WebGL counterpart of lite's `EffectWrapper`. The wrapper retains the engine
- *  it was created for, so `disposeEffectWrapper` / `applyEffectWrapper` take
- *  only the wrapper. */
-export declare interface GLEffectWrapper {
-    /** Name alias for the wrapper (and its effect). */
-    readonly name: string;
-    /** The compiled effect this wrapper owns. Exposed so the per-uniform
-     *  setters (`setEffectFloat`/`setEffectTexture`/…) can target it — the
-     *  WebGL divergence from lite's UBO-based `setEffectUniforms(wrapper, …)`. */
-    readonly effect: GLEffect;
-
-/** Inputs to `createEffectWrapper`. Mirrors lite's `EffectWrapperOptions`: the
- *  wrapper compiles and OWNS the effect built from this shader source. */
-export declare interface GLEffectWrapperOptions {
-    /** Human-readable label for the wrapper and its effect. Defaults to
-     *  `"effect-wrapper"`. */
-    name?: string;
-    /** GLSL ES 3.00 vertex source. Defaults to a built-in fullscreen-quad
-     *  vertex shader (exposing a `vUv` varying), mirroring lite's default
-     *  `vertexWGSL`. */
-    vertexSource?: string;
-    /** GLSL ES 3.00 fragment source (≙ lite's `fragmentWGSL`). Required. */
-    fragmentSource: string;
-    /** Declared uniform names. Defaults to none. */
-    uniformNames?: readonly string[];
-    /** Declared sampler names, in unit-assignment order. Defaults to none. */
-    samplerNames?: readonly string[];
-    /** Attribute names; the first is bound to location 0. Defaults to
-     *  `["position"]`. */
-    attributeNames?: readonly string[];
-    /** Optional `#define` block prepended to both shader stages. */
-    defines?: string;
-}
-
-/** Read-only WebGL2 capability limits, queried once at context creation. */
-export 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.)
- */
-export 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;
-
-/** Constructor options forwarded to `canvas.getContext('webgl2', …)`. */
-export declare interface GLEngineOptions {
-    /** Default: true. */
-    alpha?: boolean;
-    /** Default: true. */
-    premultipliedAlpha?: boolean;
-    /** Default: false. */
-    antialias?: boolean;
-    /** Default: false. */
-    preserveDrawingBuffer?: boolean;
-    /** Default: false — disabled for fullscreen-quad workloads. */
-    depth?: boolean;
-    /** Default: false. */
-    stencil?: boolean;
-    /** Default: "default". */
-    powerPreference?: WebGLPowerPreference;
-    /** Default: false. */
-    failIfMajorPerformanceCaveat?: boolean;
-}
-
-/** Options for {@link createFloatRenderTarget} — {@link GLRenderTargetOptions}
- *  plus the float color `type`. */
-export declare interface GLFloatRenderTargetOptions extends GLRenderTargetOptions {
-    /** Float color attachment type. Default `gl.HALF_FLOAT`. Pass `gl.FLOAT` for
-     *  full 32-bit. Downgraded to the best renderable type the engine supports
-     *  (`caps.textureFloatRender` / `caps.textureHalfFloatRender`), mirroring
-     *  Babylon's `getTextureType`. */
-    type?: GLenum;
-}
-
-/** Options for {@link createFloatTexture} — the shared {@link GLTextureOptions}
- *  plus the float-specific `type` / `format`. */
-export declare interface GLFloatTextureOptions extends GLTextureOptions {
-    /** Float texel type — `gl.HALF_FLOAT` (default) or `gl.FLOAT`. */
-    type?: GLenum;
-    /** Color format. Default `gl.RGBA`. */
-    format?: GLenum;
-}
-
-/** Options for `createHtmlElementTexture` — the base texture options plus
- *  HTML-source-specific settings. */
-export declare interface GLHtmlElementTextureOptions extends GLTextureOptions {
-    /** High-level sampling preset. When set, derives `minFilter`/`magFilter`
-     *  (and `generateMipMaps` for `TRILINEAR`). Explicit `minFilter` /
-     *  `magFilter` / `generateMipMaps` options still take precedence. Omit for
-     *  the GL defaults (linear min + mag, no mipmaps). */
-    samplingMode?: GLSamplingMode;
-    /** Build a full mip chain after each upload. Independent of the core
-     *  texture options (this factory's mip behavior is sampling-mode-driven):
-     *  defaults to `true` only when `samplingMode` is `TRILINEAR`, otherwise
-     *  `false`. */
-    generateMipMaps?: boolean;
-}
-
-/** 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 pair of {@link GLRenderTarget}s for self-feedback effects: SAMPLE the
- * {@link GLPingPong.read | read} target (last frame's output) while RENDERING
- * into the {@link GLPingPong.write | write} target, then {@link GLPingPong.swap}.
- */
-export declare interface GLPingPong {
-    /** The target to SAMPLE this frame (the previous frame's output). */
-    readonly read: GLRenderTarget;
-    /** The target to RENDER into this frame. */
-    readonly write: GLRenderTarget;
-    /** Exchange `read` and `write`. Call after rendering the `write` target each
-     *  frame. Allocation-free — flips an internal index, no objects created. */
-    swap(): void;
-
-/**
- * An offscreen render target — a `WebGLFramebuffer` wrapping a color
- * {@link GLTexture} and an optional depth / stencil renderbuffer. The lite-gl
- * counterpart of Babylon's `RenderTargetWrapper`.
- */
-export declare interface GLRenderTarget {
-    /** The color attachment, sampleable like any other {@link GLTexture}
-     *  (`setEffectTexture` / `bindTexture`). For an owned attachment its handle
-     *  is swapped on `webglcontextrestored` while consumers keep this same
-     *  reference. */
-    texture: GLTexture;
-    /** Color attachment width in texels. */
-    width: number;
-    /** Color attachment height in texels. */
-    height: number;
-    /** True once the color attachment + framebuffer are allocated. */
-    isReady: boolean;
-
-/** Options for {@link createRenderTarget}. `width`/`height` are required; every
- *  other field has a Babylon-matching default. The bare
- *  `createRenderTarget(engine, { width, height })` makes an RGBA8 color-only
- *  target with linear filtering and clamp wrapping. */
-export declare interface GLRenderTargetOptions {
-    /** Color attachment width in texels. Must be a positive integer. */
-    width: number;
-    /** Color attachment height in texels. Must be a positive integer. */
-    height: number;
-    /** Allocate a depth renderbuffer (`DEPTH_COMPONENT16`). Default `false`.
-     *  Stencil is NOT a create option — opt in (packed depth+stencil, or
-     *  stencil-only) via `generateRenderTargetStencil`
-     *  (`@babylonjs/lite-gl/depth-stencil`), which keeps the stencil/packed
-     *  renderbuffer code out of the render-target core bundle. */
-    generateDepthBuffer?: boolean;
-    /** Color texture minification filter. Default `gl.LINEAR`. */
-    minFilter?: GLenum;
-    /** Color texture magnification filter. Default `gl.LINEAR`. */
-    magFilter?: GLenum;
-    /** Color texture S wrap. Default `gl.CLAMP_TO_EDGE`. */
-    wrapS?: GLenum;
-    /** Color texture T wrap. Default `gl.CLAMP_TO_EDGE`. */
-    wrapT?: GLenum;
-    /** Attach a caller-supplied (BYO) color {@link GLTexture} instead of creating
-     *  one. When supplied the render target does NOT own or restore it — the
-     *  texture is engine-managed (restored by the standard texture-restore path
-     *  first) and the RT re-attaches its swapped handle afterwards. The caller is
-     *  responsible for sizing it to `width`×`height` and for disposing it. */
-    colorTexture?: GLTexture;
-}
-
-/** High-level sampling presets, mirroring Babylon's `Texture.*_SAMPLINGMODE`
- *  numeric constants. Each resolves to GL min/mag filters (and mip generation
- *  for `TRILINEAR`). */
-export declare const GLSamplingMode: {
-    /** Nearest min + mag, no mipmaps. (`Texture.NEAREST_SAMPLINGMODE`) */
-    readonly NEAREST: 1;
-    /** Linear min + mag, no mipmaps. (`Texture.BILINEAR_SAMPLINGMODE`) */
-    readonly BILINEAR: 2;
-    /** Linear mag + linear-mipmap-linear min, mipmaps generated.
-     *  (`Texture.TRILINEAR_SAMPLINGMODE`) */
-    readonly TRILINEAR: 3;
-};
-
-/** One of the {@link GLSamplingMode} preset values (`1`, `2` or `3`). */
-export declare type GLSamplingMode = (typeof GLSamplingMode)[keyof typeof GLSamplingMode];
-
-/** A single sprite — a plain data object mirroring the fields of Babylon's
- *  `ThinSprite` that the renderer reads. No animation state: `cellIndex` is set
- *  directly by the consumer (lite-gl does not port `ThinSprite.playAnimation`). */
-export declare interface GLSprite {
-    /** World-space position of the sprite center. */
-    position: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    /** Width in world units. */
-    width: number;
-    /** Height in world units. */
-    height: number;
-    /** Rotation angle, in radians. */
-    angle: number;
-    /** Sprite-sheet cell index (0-based, row-major). Out-of-range / negative
-     *  values are clamped to 0, matching Babylon's `if (!cellIndex) = 0`. Ignored
-     *  when a manual UV rect (`uSize`) is set. Optional — defaults to `0`. */
-    cellIndex?: number;
-    /** Optional tint; defaults to opaque white `{ r: 1, g: 1, b: 1, a: 1 }`. */
-    color?: GLSpriteColor;
-    /** Flip the cell horizontally. Defaults to `false`. */
-    invertU?: boolean;
-    /** Flip the cell vertically. Defaults to `false`. */
-    invertV?: boolean;
-    /** Manual UV rect — normalized left (U) origin in `[0, 1]`, mirroring
-     *  Babylon's `ThinSprite._xOffset`. Set together with {@link GLSprite.uSize}
-     *  to address an arbitrary sub-rectangle of the sheet instead of the fixed
-     *  `cellIndex` grid (used by the lottie atlas, whose cells vary in size). */
-    uOffset?: number;
-    /** Manual UV rect — normalized top (V) origin in `[0, 1]` (≙ Babylon
-     *  `ThinSprite._yOffset`). See {@link GLSprite.uSize}. */
-    vOffset?: number;
-    /** Manual UV rect — cell width in **texels** (≙ Babylon `ThinSprite._xSize`;
-     *  divided by the texture width when building vertices). Presence of `uSize`
-     *  switches the sprite into manual-UV mode (the `cellIndex` grid is ignored).
-     *  `0` samples a single column — the "solid color" trick. */
-    uSize?: number;
-    /** Manual UV rect — cell height in **texels** (≙ Babylon `ThinSprite._ySize`).
-     *  See {@link GLSprite.uSize}. Defaults to `0` when `uSize` is set but `vSize`
-     *  is omitted. */
-    vSize?: number;
-    /** When `false`, the sprite is skipped. Defaults to `true`. */
-    isVisible?: boolean;
-}
-
-/** An RGBA color with each channel in `[0, 1]`, used for per-sprite tint. */
-export declare interface GLSpriteColor {
-    /** Red, 0..1. */
-    r: number;
-    /** Green, 0..1. */
-    g: number;
-    /** Blue, 0..1. */
-    b: number;
-    /** Alpha, 0..1. */
-    a: number;
-}
-
-/**
- * A sprite renderer owning its own VBO/IBO/VAO and `GLEffect`. Created by
- * {@link createSpriteRenderer}; drive it with {@link renderSprites} and release
- * it with {@link disposeSpriteRenderer}.
- */
-export declare interface GLSpriteRenderer {
-    /** The sprite-sheet texture sampled by the shader. Swap via
-     *  {@link setSpriteRendererTexture}. */
-    texture: GLTexture;
-    /** Cell width in texels (selects the sub-rectangle for `cellIndex`). */
-    cellWidth: number;
-    /** Cell height in texels. */
-    cellHeight: number;
-    /** Per-corner UV/position inset (Babylon `SpriteRenderer` `epsilon`). */
-    epsilon: number;
-    /** Active blend mode applied by `renderSprites` before drawing. */
-    blendMode: GLBlendMode;
-    /** When `true`, `renderSprites` resets blend to {@link GLBlendMode.DISABLE}
-     *  after drawing (Babylon `autoResetAlpha`). */
-    autoResetAlpha: boolean;
-    /** Babylon-parity flag (no effect without a depth attachment). */
-    disableDepthWrite: boolean;
-    /** Maximum sprites per draw, fixed at creation. */
-    readonly capacity: number;
-
-/** Options for {@link createSpriteRenderer}. */
-export declare interface GLSpriteRendererOptions {
-    /** Maximum number of sprites drawable in one `renderSprites` call. Must be
-     *  an integer in `[1, 16384]` (the `Uint16` index-buffer limit). */
-    capacity: number;
-    /** Cell width in texels within the sprite sheet, for the fixed-grid
-     *  `cellIndex` path. Optional — defaults to `1`; irrelevant when every
-     *  sprite supplies a manual UV rect (`uSize`), as the lottie atlas does. */
-    cellWidth?: number;
-    /** Cell height in texels within the sprite sheet. Optional — defaults to
-     *  `1`. See {@link GLSpriteRendererOptions.cellWidth}. */
-    cellHeight?: number;
-    /** Per-corner UV/position inset applied to each quad vertex, in the `[0, 0.5)`
-     *  range — the `epsilon` constructor argument of Babylon's `SpriteRenderer`.
-     *  It both insets cell UV sampling (so a cell never bleeds its neighbours) and
-     *  shrinks the quad by `epsilon * size` per side. Defaults to `0.01` (Babylon's
-     *  `SpriteRenderer` default). Pass `0` to disable insetting — the lottie atlas
-     *  does this (it relies on edge-extruded cells + center sampling instead, so a
-     *  non-zero inset would shrink every sprite by ~`0.01·size` per edge). */
-    epsilon?: number;
-    /** The sprite-sheet texture. May be swapped later via
-     *  {@link setSpriteRendererTexture}. */
-    texture: GLTexture;
-    /** Blend mode for the draw. Defaults to {@link GLBlendMode.ALPHA} (2),
-     *  matching Babylon's `SpriteRenderer.blendMode` default. */
-    blendMode?: GLBlendMode;
-    /** When `true` (default), `renderSprites` resets the blend mode to
-     *  {@link GLBlendMode.DISABLE} after drawing — mirroring Babylon's
-     *  `SpriteRenderer.autoResetAlpha = true`. Set `false` to leave the
-     *  renderer's `blendMode` applied after the draw (the lottie player relies
-     *  on this so its premultiplied alpha mode persists across passes). */
-    autoResetAlpha?: boolean;
-    /** Accepted for Babylon API parity. lite-gl's default engine has no depth
-     *  attachment (`depth: false`), so there is no depth pre-pass and this flag
-     *  has no observable effect; it is stored verbatim for a future depth-aware
-     *  consumer. Defaults to `false`. */
-    disableDepthWrite?: boolean;
-}
-
-/** Stencil configuration for {@link setStencilState}. Omitted fields are left
- *  unchanged. The `func`/`ref`/`funcMask` triple and the
- *  `opFail`/`opZFail`/`opZPass` triple are each applied as a unit (any member
- *  present re-issues that GL call, merging the unspecified members from cache). */
-export declare interface GLStencilState {
-    /** Enable/disable the stencil test (`gl.enable/disable(STENCIL_TEST)`). */
-    test?: boolean;
-    /** Stencil write mask (`gl.stencilMask`). */
-    mask?: number;
-    /** Comparison function (`gl.stencilFunc` arg 1), e.g. `gl.ALWAYS`. */
-    func?: GLenum;
-    /** Reference value (`gl.stencilFunc` arg 2). */
-    ref?: number;
-    /** Comparison mask (`gl.stencilFunc` arg 3). */
-    funcMask?: number;
-    /** Op when the stencil test fails (`gl.stencilOp` arg 1). */
-    opFail?: GLenum;
-    /** Op when the stencil test passes but depth fails (`gl.stencilOp` arg 2). */
-    opZFail?: GLenum;
-    /** Op when both stencil and depth pass (`gl.stencilOp` arg 3). */
-    opZPass?: GLenum;
-}
-
-/**
- * Pure-state texture handle. The `handle` field is MUTABLE so the same logical
- * texture survives a `webglcontextrestored` event — every consumer keeps the
- * same `GLTexture` reference; only the internal `WebGLTexture` is swapped.
- *
- * `loadTexture2D` also uses the same handle for the 1×1 placeholder upload AND
- * the final image upload — so a `bindTexture(engine, unit, tex)` made before the
- * image has decoded remains valid once the image arrives.
- */
-export declare interface GLTexture {
-    /** The live `WebGLTexture`. MUTABLE — swapped for a fresh handle on
-     *  `webglcontextrestored` while consumers keep the same `GLTexture` reference. */
-    handle: WebGLTexture;
-    /** GL texture target (always `gl.TEXTURE_2D` for this package). */
-    readonly target: GLenum;
-    /** Texture width in texels. Updated once an async upload resolves. */
-    width: number;
-    /** Texture height in texels. Updated once an async upload resolves. */
-    height: number;
-    /** True when the texture is safe to sample with final content (placeholders
-     *  read as not-ready until their image/upload completes). */
-    isReady: boolean;
-
-/** Texture sampling / wrap options. All have GL-spec defaults. Mipmaps are NOT
- *  a create option — generate the chain explicitly via {@link generateTextureMipMaps}. */
-export declare interface GLTextureOptions {
-    /** Default: false (matches Babylon's default raw-texture behaviour). */
-    invertY?: boolean;
-    /** Default: gl.LINEAR. */
-    minFilter?: GLenum;
-    /** Default: gl.LINEAR. */
-    magFilter?: GLenum;
-    /** Default: gl.CLAMP_TO_EDGE. May be `gl.REPEAT` / `gl.MIRRORED_REPEAT`
-     *  (NPOT-safe in WebGL2). */
-    wrapS?: GLenum;
-    /** Default: gl.CLAMP_TO_EDGE. May be `gl.REPEAT` / `gl.MIRRORED_REPEAT`. */
-    wrapT?: GLenum;
-    /** `gl.pixelStorei(UNPACK_ALIGNMENT)` for the upload (1/2/4/8). Default 4.
-     *  Use 1 for tightly-packed non-RGBA rows. */
-    unpackAlignment?: number;
-    /** Premultiply alpha at upload (`UNPACK_PREMULTIPLY_ALPHA_WEBGL`). Default
-     *  false. */
-    premultiplyAlpha?: boolean;
-    /** Explicit sized internalFormat for `texImage2D`. When provided it is used
-     *  verbatim and the inline LDR resolver is bypassed — this is how
-     *  {@link createFloatTexture} injects its `RGBA16F` / `RGBA32F` choice
-     *  without the byte path ever referencing the float-format table (keeping it
-     *  tree-shakeable out of RGBA8-only bundles). Default: derived from
-     *  `format`/`type` via the LDR resolver. */
-    internalFormat?: GLenum;
-}
-
-/** 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;
-
-/** Pixel-space viewport rectangle passed to `setViewport`. */
-export declare interface GLViewport {
-    /** Lower-left X origin in physical pixels. */
-    x: number;
-    /** Lower-left Y origin in physical pixels. */
-    y: number;
-    /** Width in physical pixels. */
-    w: number;
-    /** Height in physical pixels. */
-    h: number;
-}
-
-/** Poll the link state and, on first success, run finalization (uniform-
- *  location resolution + one-shot sampler-unit `uniform1i` assignment +
- *  `_onCompiled` callbacks). Returns `true` once the effect is usable. */
-export declare function isEffectReady(engine: GLEngineContext, effect: GLEffect): boolean;
-
-/** Asynchronous image upload.The returned texture is immediately usable (1×1
- *  transparent placeholder); `isReady` flips true once the image has been
- *  decoded and uploaded. The decoded `ImageBitmap` is retained on the texture
- *  for offline-safe `webglcontextrestored` replay. */
-export declare function loadTexture2D(engine: GLEngineContext, url: string, options?: GLTextureOptions, onLoad?: (tex: GLTexture) => void, onError?: (err: Error) => void): GLTexture;
-
-/** Remove a previously-registered context-lost callback. */
-export declare function offContextLost(engine: GLEngineContext, cb: () => void): void;
-
-/** Remove a previously-registered context-restored callback. */
-export declare function offContextRestored(engine: GLEngineContext, cb: () => void): void;
-
-/** Register a `webglcontextlost` callback. Duplicate registrations are ignored. */
-export declare function onContextLost(engine: GLEngineContext, cb: () => void): void;
-
-/** Register a `webglcontextrestored` callback. Duplicate registrations are ignored. */
-export declare function onContextRestored(engine: GLEngineContext, cb: () => void): void;
-
-/**
- * Synchronously read back a rectangle of the render target's color attachment
- * via `gl.readPixels` — the lite-gl equivalent of Babylon's
- * `_readTexturePixelsSync`. Binds the target's framebuffer (leaving it bound,
- * matching Babylon).
- *
- * The returned array element type follows the color attachment type:
- * `Uint8Array` for `UNSIGNED_BYTE`, `Float32Array` for `FLOAT`, `Uint16Array`
- * for `HALF_FLOAT`. Origin is GL bottom-left.
- *
- * @param engine - The engine.
- * @param rt - The render target to read from.
- * @param x - Lower-left X of the read rectangle, in texels.
- * @param y - Lower-left Y of the read rectangle, in texels.
- * @param width - Read rectangle width in texels.
- * @param height - Read rectangle height in texels.
- * @param into - Optional preallocated buffer (`width*height*4` elements of the
- *  matching type). Reused to avoid per-call allocation.
- * @returns The pixel buffer (the provided `into`, or a freshly allocated one).
- *  Empty buffer on a lost/disposed context.
- */
-export declare function readRenderTargetPixels(engine: GLEngineContext, rt: GLRenderTarget, x: number, y: number, width: number, height: number, into?: ArrayBufferView): ArrayBufferView;
-
-/**
- * Build the per-sprite vertex data and draw all visible sprites in one
- * `drawElements` call. Performs no allocations — the vertex scratch is reused
- * and uploaded with `bufferSubData`.
- *
- * No-op when the context is lost/disposed, the renderer is disposed, the
- * texture is not ready, the effect is not ready, or there are no visible
- * sprites. Sets the renderer's blend mode before drawing and resets to
- * {@link GLBlendMode.DISABLE} afterwards (matching Babylon's
- * `autoResetAlpha = true`), so a subsequent `drawEffect` is unaffected.
- *
- * @param renderer - The renderer to draw with.
- * @param sprites - The sprites to draw (only `isVisible !== false` are drawn;
- *  excess beyond `capacity` is ignored, matching Babylon).
- * @param deltaTime - Accepted for Babylon API parity; unused (lite-gl `GLSprite`
- *  holds no animation state, so `cellIndex` is consumer-driven).
- * @param viewMatrix - Column-major 4x4 view matrix.
- * @param projectionMatrix - Column-major 4x4 projection matrix.
- */
-export declare function renderSprites(renderer: GLSpriteRenderer, sprites: readonly GLSprite[], deltaTime: number, viewMatrix: Float32Array | number[], projectionMatrix: Float32Array | number[]): void;
-
-/** Match drawing-buffer size to (clientSize × devicePixelRatio / _hsl). No-op
- *  if size already matches. Never touches viewport — `setViewport` owns that. */
-export declare function resizeGLEngine(engine: GLEngineContext): void;
-
-/**
- * Resize both targets of a {@link GLPingPong}. No-op when disposed.
- *
- * @param engine - The engine that owns `pp`.
- * @param pp - The ping-pong pair to resize.
- * @param width - New width in texels (positive integer).
- * @param height - New height in texels (positive integer).
- */
-export declare function resizePingPong(engine: GLEngineContext, pp: GLPingPong, width: number, height: number): void;
-
-/**
- * Resize the render target's color attachment (and depth/stencil renderbuffer).
- * Reallocates storage at the new size; the contents are discarded. The
- * `GLRenderTarget` / `GLTexture` identity is preserved, so consumers and
- * effect-sampler bindings holding the reference stay valid. If this target was
- * the live draw target, it is rebound (with the new-size viewport) afterwards.
- *
- * No-op when the size is unchanged or `rt` is disposed. While the context is
- * lost the new size is recorded but the GL reallocation is deferred to the
- * restore hook.
- *
- * @param engine - The engine.
- * @param rt - The render target to resize.
- * @param width - New width in texels (≥ 1).
- * @param height - New height in texels (≥ 1).
- */
-export declare function resizeRenderTarget(engine: GLEngineContext, rt: GLRenderTarget, width: number, height: number): void;
-
-/** Register a per-frame callback. **No-op if `fn` is already registered**
- *  (matches Babylon `AbstractEngine.runRenderLoop`). Starts the rAF if this is
- *  the first registration. */
-export declare function runRenderLoop(engine: GLEngineContext, fn: (dt: number) => void): void;
-
-/**
- * Set the GL blend state to match Babylon's `setAlphaMode(mode)` exactly.
- *
- * | Mode               | `gl.blendFuncSeparate(srcRGB, dstRGB, srcA, dstA)`          |
- * |--------------------|------------------------------------------------------------|
- * | `DISABLE` (0)      | — (`gl.disable(gl.BLEND)`)                                  |
- * | `ADD` (1)          | `SRC_ALPHA, ONE, ZERO, ONE`                                 |
- * | `ALPHA` (2)        | `SRC_ALPHA, ONE_MINUS_SRC_ALPHA, ONE, ONE`                  |
- * | `PREMULTIPLIED` (7)| `ONE, ONE_MINUS_SRC_ALPHA, ONE, ONE`                        |
- *
- * No-op when the context is lost or disposed.
- *
- * @param engine - The engine whose GL blend state is updated.
- * @param mode - The {@link GLBlendMode} preset to apply.
- */
-export declare function setBlendMode(engine: GLEngineContext, mode: GLBlendMode): void;
-
-/**
- * Enable blending with an arbitrary separate-channel function and equation —
- * the lite-gl equivalent of Babylon's `AlphaState` with
- * `setAlphaBlendFunctionParameters` + `setAlphaEquationParameters`.
- *
- * Supports every WebGL2 blend equation, including `MIN`, `MAX`,
- * `FUNC_SUBTRACT` and `FUNC_REVERSE_SUBTRACT` (used by ShapeBuilder's darken /
- * cutout blend modes). Records the desired config (flushed by `applyGLStates`
- * before the next draw); at flush time the enable flag, the equation and the func
- * are each cached independently, so a redundant state is fully elided and only
- * the call whose params changed is re-issued — mirroring Babylon's `AlphaState`
- * dirty flags. Because GL keeps the equation + func across `gl.disable(BLEND)`,
- * re-enabling with unchanged params re-issues neither.
- *
- * No-op when the context is lost or disposed.
- *
- * @param engine - The engine whose desired blend state is updated.
- * @param state - The separate-channel blend factors + equations to apply.
- */
-export declare function setBlendState(engine: GLEngineContext, state: GLBlendState): void;
-
-/**
- * Buffer the color write mask into the DESIRED state — the lite-gl equivalent of
- * Babylon's `setColorWrite` (which passes the same flag to all four channels).
- * Flushed to GL (`gl.colorMask`) by `applyGLStates` before the next draw /
- * clear.
- *
- * @param engine - The engine.
- * @param r - Write red.
- * @param g - Write green.
- * @param b - Write blue.
- * @param a - Write alpha.
- */
-export declare function setColorMask(engine: GLEngineContext, r: boolean, g: boolean, b: boolean, a: boolean): void;
-
-/**
- * Enable/disable face culling and (optionally) set the cull face — the lite-gl
- * equivalent of `engine.depthCullingState.cull` + `cullFace`.
- *
- * @param engine - The engine.
- * @param enabled - Enable (`true`) or disable (`false`) `gl.CULL_FACE`.
- * @param face - Optional cull face (`gl.BACK` / `gl.FRONT` / `gl.FRONT_AND_BACK`).
- */
-export declare function setCullState(engine: GLEngineContext, enabled: boolean, face?: GLenum): void;
-
-/**
- * Buffer depth-buffer state (test enable, write mask, comparison function) into
- * the DESIRED state — the lite-gl equivalent of mutating Babylon's
- * `engine.depthCullingState.{depthTest,depthMask,depthFunc}`. Flushed to GL by
- * `applyGLStates` before the next draw / clear; omitted fields are untouched.
- *
- * @param engine - The engine.
- * @param state - The depth fields to change. Omitted fields are untouched.
- */
-export declare function setDepthState(engine: GLEngineContext, state: GLDepthState): void;
-
-/** Cached `gl.uniform3f` from an r/g/b color object. Delegates to `setEffectFloat3`. */
-export declare function setEffectColor3(engine: GLEngineContext, effect: GLEffect, name: string, c: {
-    r: number;
-    g: number;
-    b: number;
-}): void;
-
-/** Cached `gl.uniform4f` from an r/g/b/a color object. Delegates to `setEffectFloat4`. */
-export declare function setEffectColor4(engine: GLEngineContext, effect: GLEffect, name: string, c: {
-    r: number;
-    g: number;
-    b: number;
-    a: number;
-}): void;
-
-/** Cached `gl.uniform4f` from an r/g/b/a color WITHOUT premultiplication — the
- *  lite-gl equivalent of Babylon's `Effect.setDirectColor4`. Delegates to
- *  `setEffectFloat4` (lite-gl never premultiplies in the uniform setters, so
- *  this matches `setEffectColor4`; the distinct name eases the ShapeBuilder
- *  port). */
-export declare function setEffectDirectColor4(engine: GLEngineContext, effect: GLEffect, name: string, c: {
-    r: number;
-    g: number;
-    b: number;
-    a: number;
-}): void;
-
-/** Cached `gl.uniform1f`. No-op when context-lost, the effect isn't ready, the
- *  uniform is absent, or the value is unchanged since last upload. */
-export declare function setEffectFloat(engine: GLEngineContext, effect: GLEffect, name: string, x: number): void;
-
-/** Cached `gl.uniform2f`. No-op when context-lost, the effect isn't ready, the
- *  uniform is absent, or the value is unchanged since last upload. */
-export declare function setEffectFloat2(engine: GLEngineContext, effect: GLEffect, name: string, x: number, y: number): void;
-
-/** Cached `gl.uniform3f`. No-op when context-lost, the effect isn't ready, the
- *  uniform is absent, or the value is unchanged since last upload. */
-export declare function setEffectFloat3(engine: GLEngineContext, effect: GLEffect, name: string, x: number, y: number, z: number): void;
-
-/** Cached `gl.uniform4f`. No-op when context-lost, the effect isn't ready, the
- *  uniform is absent, or the value is unchanged since last upload. */
-export declare function setEffectFloat4(engine: GLEngineContext, effect: GLEffect, name: string, x: number, y: number, z: number, w: number): void;
-
-/** `gl.uniform1fv` — a flat float array (`Effect.setFloatArray` / `setArray`).
- *  Not value-cached. */
-export declare function setEffectFloatArray(engine: GLEngineContext, effect: GLEffect, name: string, array: Float32Array | number[]): void;
-
-/** `gl.uniform4fv` — an array of `vec4`s (`Effect.setFloatArray4` / `setArray4`).
- *  Not value-cached. */
-export declare function setEffectFloatArray4(engine: GLEngineContext, effect: GLEffect, name: string, array: Float32Array | number[]): void;
-
-/** Cached `gl.uniform1i`. No-op when context-lost, the effect isn't ready, the
- *  uniform is absent, or the value is unchanged since last upload. */
-export declare function setEffectInt(engine: GLEngineContext, effect: GLEffect, name: string, x: number): void;
-
-/** `gl.uniform1iv` — a flat int array (`Effect.setIntArray`). Not value-cached. */
-export declare function setEffectIntArray(engine: GLEngineContext, effect: GLEffect, name: string, array: Int32Array | number[]): void;
-
-/** `gl.uniformMatrix4fv` from a column-major 4×4 matrix — the lite-gl
- *  equivalent of Babylon's `Effect.setMatrix`. Not value-cached. */
-export declare function setEffectMatrix(engine: GLEngineContext, effect: GLEffect, name: string, matrix: Float32Array | number[]): void;
-
-/** `gl.uniformMatrix3fv` from a column-major 3×3 matrix — the lite-gl
- *  equivalent of Babylon's `Effect.setMatrix3x3`. Not value-cached. */
-export declare function setEffectMatrix3x3(engine: GLEngineContext, effect: GLEffect, name: string, matrix: Float32Array | number[]): void;
-
-/** Bind a texture to the sampler's pre-assigned unit (§4.4). NO `gl.uniform1i`
- *  is issued — that was done exactly once per program lifetime during
- *  finalization. This is the key win over Babylon's `Effect.setTexture` which
- *  re-issues the sampler binding on every call. */
-export declare function setEffectTexture(engine: GLEngineContext, effect: GLEffect, samplerName: string, tex: GLTexture): void;
-
-/** Cached `gl.uniform2f` from an `{x,y}` vector object — the lite-gl equivalent
- *  of Babylon's `Effect.setVector2`. Delegates to `setEffectFloat2`. */
-export declare function setEffectVector2(engine: GLEngineContext, effect: GLEffect, name: string, v: {
-    x: number;
-    y: number;
-}): void;
-
-/**
- * Set the drawing-buffer size to an EXPLICIT width/height in physical pixels
- * (each divided by `_hsl`), independent of the canvas client/CSS size — the
- * counterpart of Babylon's `ThinEngine.setSize`. Use when the render resolution
- * is computed directly (e.g. animation dimensions × scale × dpr) rather than
- * derived from CSS layout via {@link resizeGLEngine}. No-op on a disposed
- * engine. Never touches the viewport — `setViewport` owns that.
- *
- * @param engine - The engine to resize.
- * @param width - Target drawing-buffer width in physical pixels.
- * @param height - Target drawing-buffer height in physical pixels.
- */
-export declare function setGLEngineSize(engine: GLEngineContext, width: number, height: number): void;
-
-/** Updates the hardware-scaling factor and triggers a resize. */
-export declare function setHardwareScalingLevel(engine: GLEngineContext, level: number): void;
-
-/**
- * Enable the scissor test and set the clip rectangle (lower-left origin),
- * cached. Re-issues `gl.scissor` only when the rectangle changes, and
- * `gl.enable(SCISSOR_TEST)` only on the disabled→enabled transition.
- *
- * @param engine - The engine.
- * @param x - Lower-left X of the scissor rectangle, in pixels.
- * @param y - Lower-left Y of the scissor rectangle, in pixels.
- * @param width - Rectangle width in pixels.
- * @param height - Rectangle height in pixels.
- */
-export declare function setScissor(engine: GLEngineContext, x: number, y: number, width: number, height: number): void;
-
-/** Swap the sprite-sheet texture (≙ Babylon assigning `SpriteRenderer.texture`
- *  after an async load). The cell size is unchanged — adjust `cellWidth` /
- *  `cellHeight` on the renderer directly if the new sheet differs. No-op when
- *  the renderer is disposed. */
-export declare function setSpriteRendererTexture(renderer: GLSpriteRenderer, texture: GLTexture): void;
-
-/**
- * Buffer stencil state (test enable, write mask, comparison func triple, op
- * triple) into the DESIRED state — the lite-gl equivalent of mutating Babylon's
- * `engine.stencilState.*`. Flushed by `applyGLStates` before the next draw /
- * clear; omitted fields are untouched (merge-from-desired).
- *
- * @param engine - The engine.
- * @param state - The stencil fields to change. Omitted fields are untouched.
- */
-export declare function setStencilState(engine: GLEngineContext, state: GLStencilState): void;
-
-/** Cached `gl.viewport`. Defaults to the full canvas in pixel coordinates. */
-export declare function setViewport(engine: GLEngineContext, viewport?: GLViewport): void;
-
-/** Stop one (or all when omitted) registered callbacks. Cancels the rAF if
- *  no callbacks remain. */
-export declare function stopRenderLoop(engine: GLEngineContext, fn?: (dt: number) => void): void;
-
-/**
- * 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;
-
-/** Push 2D pixels into a {@link createDynamicTexture} texture from a canvas /
- *  `OffscreenCanvas` / image / video / `ImageBitmap` / `ImageData` source — the
- *  WebGL counterpart of Babylon's `ThinEngine.updateDynamicTexture`. The source
- *  is retained on the texture so it is replayed on `webglcontextrestored`.
- *  No-op when the context is lost/disposed or the texture is disposed.
- *
- *  @param engine - The engine that owns the texture.
- *  @param tex - A texture created by {@link createDynamicTexture}.
- *  @param source - The 2D pixel source to upload.
- *  @param invertY - Flip vertically on upload (`UNPACK_FLIP_Y_WEBGL`). Default `false`.
- *  @param premultiplyAlpha - Premultiply on upload (`UNPACK_PREMULTIPLY_ALPHA_WEBGL`).
- *   Default `false`, matching Babylon's `updateDynamicTexture` default. */
-export declare function updateDynamicTexture(engine: GLEngineContext, tex: GLTexture, source: TexImageSource, invertY?: boolean, premultiplyAlpha?: boolean): void;
-
-/** Re-upload the texture from its source element. No-op when the context is
- *  lost/disposed or the texture is disposed. */
-export declare function updateHtmlElementTexture(engine: GLEngineContext, tex: GLTexture): void;
-
-/**
- * Re-upload the pixel data (and optionally resize) of a texture created by
- * {@link createRawTexture} — the lite-gl equivalent of Babylon's
- * `updateRawTexture` / `_uploadDataToTextureDirectly`. Goes through the same
- * upload closure used by context-restore, so the new contents survive a context
- * loss. No-op on a lost/disposed/non-raw texture.
- *
- * @param engine - The engine.
- * @param tex - The raw texture to update.
- * @param data - New pixel data (must match the original `format`/`type`).
- * @param options - Optional new `width`/`height` (default: unchanged) and
- *  `unpackAlignment` (default 4).
- */
-export declare function updateRawTexture(engine: GLEngineContext, tex: GLTexture, data: ArrayBufferView | null, options?: {
-    width?: number;
-    height?: number;
-    unpackAlignment?: number;
-}): void;
-
-/** Update a texture's min/mag sampling filters — the lite-gl equivalent of
- *  Babylon's `updateTextureSamplingMode`. Binds for upload (unit 0) so the
- *  `texParameteri` lands on this texture. No-op on a lost/disposed context. */
-export declare function updateTextureSamplingMode(engine: GLEngineContext, tex: GLTexture, minFilter: GLenum, magFilter: GLenum): void;
-
-/** Update a texture's S/T wrap modes (`gl.CLAMP_TO_EDGE` / `gl.REPEAT` /
- *  `gl.MIRRORED_REPEAT`) — the lite-gl equivalent of Babylon's
- *  `updateTextureWrappingMode`. No-op on a lost/disposed context. */
-export declare function updateTextureWrapMode(engine: GLEngineContext, tex: GLTexture, wrapS: GLenum, wrapT: GLenum): 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;
-
-/** Cached `gl.useProgram`. No-op when the effect is not ready or already current. */
-export declare function useEffect(engine: GLEngineContext, effect: GLEffect): void;
-
-/**
- * Invalidate lite-gl's cached GL state so the next state-setting call in each
- * category (program / buffer / texture / VAO / framebuffer bindings, blend,
- * depth, stencil, scissor, color-mask, viewport, unpack) is re-issued instead
- * of elided.
- *
- * Use this when a host application that SHARES this WebGL2 context mutates raw
- * `gl.*` state outside lite-gl — e.g. a save/restore wrapper that resets the
- * context to GL defaults around each render scope, or any interop layer that
- * issues GL calls directly. Without it, lite-gl's redundant-call elision would
- * skip the state changes needed to re-establish the scope, producing corrupted
- * output. Owned GPU resources (the shared quad, render targets, meshes,
- * effects, textures) are preserved — only the cached "current GL state" is
- * reset. Mirrors Babylon's `Engine.wipeCaches()`.
- *
- * No-op while the context is lost or the engine is disposed.
- */
-export declare function wipeGLStateCache(engine: GLEngineContext): void;
-
-export { }
+export { createGLEngine, disposeGLEngine, resizeGLEngine, setGLEngineSize, wipeGLStateCache, getRenderWidth, getRenderHeight, getHardwareScalingLevel, setHardwareScalingLevel, getRenderingCanvas, onContextLost, offContextLost, onContextRestored, offContextRestored, } from "./context.js";
+export type { GLEngineOptions, GLEngineCaps, GLEngineContext } from "./context.js";
+export { runRenderLoop, stopRenderLoop } from "./render-loop.js";
+export { createEffect, useEffect, isEffectReady, executeWhenCompiled, disposeEffect, setEffectFloat, setEffectFloat2, setEffectFloat3, setEffectFloat4, setEffectColor3, setEffectColor4, setEffectVector2, setEffectDirectColor4, setEffectInt, setEffectTexture, setEffectMatrix, setEffectMatrix3x3, setEffectFloatArray, setEffectFloatArray4, setEffectIntArray, } from "./effect.js";
+export type { GLEffectOptions, GLEffect } from "./effect.js";
+export { createEffectWrapper, applyEffectWrapper, drawEffect, setViewport, disposeEffectWrapper } from "./effect-renderer.js";
+export type { GLEffectWrapperOptions, GLEffectWrapper, GLViewport } from "./effect-renderer.js";
+export { createRawTexture, createFloatTexture, generateTextureMipMaps, loadTexture2D, bindTexture, disposeTexture, updateRawTexture, updateTextureSamplingMode, updateTextureWrapMode, createTextureFromHandle, } from "./texture.js";
+export type { GLTextureOptions, GLFloatTextureOptions, GLTexture } from "./texture.js";
+export { createDynamicTexture, updateDynamicTexture, clearDynamicTextureSource } from "./dynamic-texture.js";
+export { createRenderTarget, createFloatRenderTarget, bindRenderTarget, generateRenderTargetMipMaps, resizeRenderTarget, readRenderTargetPixels, disposeRenderTarget, createPingPong, resizePingPong, disposePingPong, } from "./render-target.js";
+export type { GLRenderTarget, GLRenderTargetOptions, GLFloatRenderTargetOptions, GLPingPong } from "./render-target.js";
+export { createVertexBuffer, updateVertexBuffer, createIndexBuffer, disposeBuffer, bindIndexBuffer, bindAttributes, unbindInstanceAttributes, drawIndexed, createMeshVao, bindMeshVao, drawMesh, disposeMeshVao, } from "./mesh.js";
+export type { GLVertexBuffer, GLIndexBuffer, GLAttributeDescriptor, GLMeshVertexBuffer, GLMeshVao } from "./mesh.js";
+export { GLBlendMode, GLBlendEquation, setBlendMode, setBlendState, disableBlend } from "./blend.js";
+export type { GLBlendState } from "./blend.js";
+export { setDepthState, setCullState, setStencilState, setColorMask, clearEngine, generateRenderTargetStencil } from "./depth-stencil.js";
+export type { GLDepthState, GLStencilState, GLClearOptions } from "./depth-stencil.js";
+export { setScissor, disableScissor } from "./scissor.js";
+export { createSpriteRenderer, renderSprites, setSpriteRendererTexture, disposeSpriteRenderer } from "./sprites.js";
+export type { GLSprite, GLSpriteColor, GLSpriteRendererOptions, GLSpriteRenderer } from "./sprites.js";
+export { createHtmlElementTexture, updateHtmlElementTexture, GLSamplingMode } from "./html-texture.js";
+export type { GLHtmlElementTextureOptions } from "./html-texture.js";