@babylonjs/lite-gl 0.1.0 → 1.0.0

package/sprites.d.ts

@@ -1,263 +1,182 @@
-/**
- * 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;
-
-/** 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;
-
-/**
- * Supported blend presets. Values mirror Babylon's `Constants.ALPHA_*` so the
- * raw Babylon integers can be passed straight through.
- */
-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`). */
-declare type GLBlendMode = (typeof GLBlendMode)[keyof typeof GLBlendMode];
-
-/** 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 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;
-}
-
-/**
- * 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.
- */
-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;
-
-/**
- * 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;
-
-/** 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;
-
-export { }
+/**
+ * Sprite / instanced-quad renderer.
+ *
+ * Part of the public API via the `@babylonjs/lite-gl` barrel. The package is
+ * `sideEffects: false`, so consumers that don't render sprites tree-shake it out.
+ *
+ * This is the lite-gl equivalent of Babylon's `SpriteRenderer` + `ThinSprite`
+ * (`Sprites/spriteRenderer.js`, `Sprites/thinSprite.js`). The vertex layout,
+ * per-cell UV math and corner/rotation transform are copied verbatim from the
+ * non-instanced path of Babylon's `SpriteRenderer` so a future NeonBrush port
+ * renders identically. The shaders are the GLSL ES 3.00 translation of
+ * Babylon's `Shaders/sprites.vertex.js` / `sprites.fragment.js`, with the
+ * fog / log-depth / pixel-perfect / alpha-test branches removed (lite-gl has
+ * no depth attachment by default — see notes on `disableDepthWrite` below).
+ */
+import { type GLEngineContext } from "./context.js";
+import { GLBlendMode } from "./blend.js";
+import { type GLTexture } from "./texture.js";
+/** An RGBA color with each channel in `[0, 1]`, used for per-sprite tint. */
+export interface GLSpriteColor {
+    /** Red, 0..1. */
+    r: number;
+    /** Green, 0..1. */
+    g: number;
+    /** Blue, 0..1. */
+    b: number;
+    /** Alpha, 0..1. */
+    a: number;
+}
+/** 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 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;
+}
+/** Options for {@link createSpriteRenderer}. */
+export 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;
+}
+/**
+ * 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 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;
+}
+/**
+ * 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;
+/**
+ * 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;
+/** 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;
+/** 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;