melonjs 19.7.1 → 19.9.0

package/build/video/texture/cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../src/video/texture/cache.js"],"names":[],"mappings":";AAeA;;;GAGG;AACH;IACC;;OAEG;IACH,8CAsBC;IApBA,cAAwB;IAExB,qBAAgC;IAChC,sBAAuB;IAavB,qBAAsB;IACtB,oBAA0B;IAC1B,iBAAwB;IAIzB;;OAEG;IACH,cAKC;IAED;;OAEG;IACH,8BAsBC;IAED;;;;OAIG;IACH,6BAIC;IAED;;;;;;;OAOG;IACH,oCAaC;IAED;;OAEG;IACH,2BAYC;IAED;;;OAGG;IACH,4BAKC;IAED;;;OAGG;IACH,yCAEC;IAED;;OAEG;IACH,yBAEC;IAED;;;OAGG;IACH,iCAwCC;IAED;;OAEG;IACH,yBAaC;IAED;;OAEG;IACH,gCAcC;CACD;8BAlP6B,+BAA+B"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../src/video/texture/cache.js"],"names":[],"mappings":";AAeA;;;GAGG;AACH;IACC;;OAEG;IACH,8CA4BC;IA1BA,cAAwB;IAExB,qBAAgC;IAChC,sBAAuB;IAavB,qBAAsB;IACtB,oBAA0B;IAM1B,6BAA8B;IAC9B,iBAAwB;IAIzB;;OAEG;IACH,cAKC;IAED;;OAEG;IACH,8BA4BC;IAED;;;;;;;OAOG;IACH,kBAHW,MAAM,QAKhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,QAUhB;IAED;;;;OAIG;IACH,6BAIC;IAED;;;;;;;;;;OAUG;IACH,oCAaC;IAED;;;;;;;;OAQG;IACH,iCASC;IAED;;;;;;;;;;OAUG;IACH,+BATW,MAAM,OAuBhB;IAED;;;;;;;;OAQG;IACH,kCAIC;IAED;;;;OAIG;IACH,gCAFW,MAAM,OAShB;IAED;;;OAGG;IACH,yCAEC;IAED;;OAEG;IACH,yBAEC;IAED;;;OAGG;IACH,iCAwCC;IAED;;OAEG;IACH,yBAkBC;IAED;;OAEG;IACH,gCAcC;CACD;8BAjV6B,+BAA+B"}

package/build/video/texture/frametexture.d.ts

@@ -0,0 +1,73 @@
+/**
+ * A GPU-resident texture holding a captured frame — the value returned by
+ * {@link WebGLRenderer#toFrameTexture}. Its backing is a live `WebGLTexture`
+ * that the renderer refreshes **in place** on each capture, so a shader that
+ * has bound it once (via {@link ShaderEffect#setTexture}) keeps sampling the
+ * latest frame with no re-bind.
+ *
+ * Not part of the public class surface: obtain instances from
+ * `renderer.toFrameTexture()` and treat them as opaque {@link Texture2d}
+ * values. The `isGPUResident` flag is the discriminant `setTexture` uses to
+ * take its live-bind path (bind the existing handle) instead of uploading a
+ * static copy.
+ * @augments Texture2d
+ * @ignore
+ */
+export class FrameTexture extends Texture2d {
+    /**
+     * @param {WebGLRenderer} renderer - the owning renderer (for the GL context)
+     * @param {number} width - capture width in pixels
+     * @param {number} height - capture height in pixels
+     */
+    constructor(renderer: WebGLRenderer, width: number, height: number);
+    _renderer: WebGLRenderer;
+    /** @type {number} */
+    width: number;
+    /** @type {number} */
+    height: number;
+    /**
+     * the live backing texture, (re)filled by `renderer.toFrameTexture` and
+     * bound (never re-uploaded) by consumers
+     * @type {WebGLTexture|null}
+     */
+    glTexture: WebGLTexture | null;
+    /**
+     * marks this as a live GPU-resident source — see {@link ShaderEffect#setTexture}
+     * @type {boolean}
+     */
+    isGPUResident: boolean;
+    /**
+     * The opaque GPU-resident backing — itself.
+     * @returns {FrameTexture}
+     */
+    getTexture(): FrameTexture;
+}
+/**
+ * The Canvas-renderer counterpart of {@link FrameTexture}: a captured frame
+ * backed by an offscreen `<canvas>` copy of the drawing buffer, keeping the
+ * `toFrameTexture` family renderer-complete. A drawable source (not
+ * GPU-resident), so it flows through the normal image path; custom shaders
+ * don't run under the Canvas renderer, so this exists for API parity and
+ * CPU-side reuse (e.g. drawing the captured frame back onto the scene).
+ * @augments Texture2d
+ * @ignore
+ */
+export class CanvasFrameTexture extends Texture2d {
+    /**
+     * @param {HTMLCanvasElement|OffscreenCanvas} canvas - the backing copy
+     */
+    constructor(canvas: HTMLCanvasElement | OffscreenCanvas);
+    /** @type {HTMLCanvasElement|OffscreenCanvas} */
+    canvas: HTMLCanvasElement | OffscreenCanvas;
+    /** @type {number} */
+    width: number;
+    /** @type {number} */
+    height: number;
+    /**
+     * The backing canvas copy.
+     * @returns {HTMLCanvasElement|OffscreenCanvas}
+     */
+    getTexture(): HTMLCanvasElement | OffscreenCanvas;
+}
+import Texture2d from "./texture2d.ts";
+//# sourceMappingURL=frametexture.d.ts.map

package/build/video/texture/frametexture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frametexture.d.ts","sourceRoot":"","sources":["../../../src/video/texture/frametexture.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;OAIG;IACH,sBAJW,aAAa,SACb,MAAM,UACN,MAAM,EAoBhB;IAhBA,yBAAyB;IACzB,qBAAqB;IACrB,OADW,MAAM,CACC;IAClB,qBAAqB;IACrB,QADW,MAAM,CACG;IACpB;;;;OAIG;IACH,WAFU,YAAY,GAAC,IAAI,CAEN;IACrB;;;OAGG;IACH,eAFU,OAAO,CAEQ;IAG1B;;;OAGG;IACH,cAFa,YAAY,CAIxB;CAaD;AAED;;;;;;;;;GASG;AACH;IACC;;OAEG;IACH,oBAFW,iBAAiB,GAAC,eAAe,EAU3C;IANA,gDAAgD;IAChD,QADW,iBAAiB,GAAC,eAAe,CACxB;IACpB,qBAAqB;IACrB,OADW,MAAM,CACQ;IACzB,qBAAqB;IACrB,QADW,MAAM,CACU;IAG5B;;;OAGG;IACH,cAFa,iBAAiB,GAAC,eAAe,CAI7C;CACD;sBA/FqB,gBAAgB"}

package/build/video/texture/noise_texture2d.d.ts

@@ -0,0 +1,176 @@
+export default NoiseTexture2d;
+/**
+ * A {@link Texture2d} that bakes a {@link Noise} field into a drawable canvas —
+ * usable directly as a sprite image, a normal map, an image layer, or a custom
+ * shader sampler.
+ *
+ * The bake runs on the CPU (renderer-agnostic, works under both the Canvas and
+ * WebGL backends) and produces an `HTMLCanvasElement` returned by
+ * {@link NoiseTexture2d#getTexture}. Three output modes:
+ * - **grayscale** (default) — the noise value mapped to `[0, 255]`.
+ * - **colorRamp** — the noise value mapped through a {@link Gradient}.
+ * - **asNormalMap** — the noise treated as a height field and encoded as
+ *   tangent-space surface normals (RGB), for per-pixel lighting via
+ *   {@link Sprite#normalMap} + {@link Light2d}.
+ *
+ * With `seamless: true` the texture's edges are cross-faded so it tiles with a
+ * much-reduced seam (an approximate, not pixel-exact, wrap); `seamlessBlendSkirt`
+ * controls how wide that edge blend band is. With `animated: true` the field is
+ * sampled in 3D (`getNoise3d`) using an internal `time` as the third axis —
+ * call {@link NoiseTexture2d#update} from your update loop to evolve it. Each
+ * re-bake bumps a `version` the renderer reads, so the GPU texture re-uploads
+ * automatically (and only when it actually changed — the three.js
+ * `Texture.needsUpdate` model).
+ *
+ * Note: live re-upload is currently wired through the lit **normal-map**
+ * pipeline ({@link Sprite#normalMap} + {@link Light2d}). An `animated` texture
+ * used as a plain color `image` bakes a static snapshot — the color texture
+ * cache does not yet honor `version` — so animate normals, not albedos, for now.
+ * @augments Texture2d
+ * @category Game Objects
+ * @example
+ * // a seamless water normal map fed to a lit sprite
+ * const ripples = new me.NoiseTexture2d({
+ *     width: 256, height: 256,
+ *     type: "simplex", octaves: 4, frequency: 0.03,
+ *     seamless: true, asNormalMap: true, bumpStrength: 2, animated: true, speed: 0.6,
+ * });
+ * const water = new me.Sprite(x, y, { image: albedo, normalMap: ripples });
+ * // drive it yourself from your Stage's update(dt):
+ * ripples.update(dt);
+ */
+declare class NoiseTexture2d extends Texture2d {
+    /**
+     * @param {object} [settings] - configuration; any {@link Noise} setting
+     * (`type`, `seed`, `frequency`/`scale`, `octaves`, `gain`/`persistence`,
+     * `lacunarity`, `fractalType`, domain-warp settings) is forwarded when no
+     * `noise` instance is given.
+     * @param {number} [settings.width=256] - baked texture width in pixels
+     * @param {number} [settings.height=256] - baked texture height in pixels
+     * @param {Noise} [settings.noise] - an existing {@link Noise} to bake; when
+     * omitted one is built from the forwarded settings
+     * @param {boolean} [settings.seamless=false] - tile cleanly in both axes
+     * @param {number} [settings.seamlessBlendSkirt=0.1] - edge blend band width
+     * as a fraction (0..1) of the smaller dimension, when `seamless`
+     * @param {boolean} [settings.invert=false] - invert the noise value (`1 - v`)
+     * @param {boolean} [settings.asNormalMap=false] - encode as a normal map
+     * @param {number} [settings.bumpStrength=1] - normal steepness when `asNormalMap`
+     * @param {Gradient} [settings.colorRamp] - map the noise value to a color
+     * @param {boolean} [settings.animated=false] - sample in 3D (`getNoise3d`)
+     * using an internal `time` as the third axis, advanced by {@link NoiseTexture2d#update}
+     * @param {number} [settings.speed=1] - animation speed in noise z-units per
+     * second (only used while `animated`)
+     */
+    constructor(settings?: {
+        width?: number | undefined;
+        height?: number | undefined;
+        noise?: Noise | undefined;
+        seamless?: boolean | undefined;
+        seamlessBlendSkirt?: number | undefined;
+        invert?: boolean | undefined;
+        asNormalMap?: boolean | undefined;
+        bumpStrength?: number | undefined;
+        colorRamp?: any;
+        animated?: boolean | undefined;
+        speed?: number | undefined;
+    });
+    /** baked texture width in pixels @type {number} */
+    width: number;
+    /** baked texture height in pixels @type {number} */
+    height: number;
+    /** the noise field baked by this texture @type {Noise} */
+    noise: Noise;
+    /** tile cleanly in both axes @type {boolean} */
+    seamless: boolean;
+    /** edge blend band width (0..1 of the smaller dimension) @type {number} */
+    seamlessBlendSkirt: number;
+    /** invert the noise value @type {boolean} */
+    invert: boolean;
+    /** encode the field as a tangent-space normal map @type {boolean} */
+    asNormalMap: boolean;
+    /** normal steepness when `asNormalMap` @type {number} */
+    bumpStrength: number;
+    /** optional color ramp applied to the noise value @type {Gradient|null} */
+    colorRamp: Gradient | null;
+    /** sample the field in 3D using `time` as the third axis @type {boolean} */
+    animated: boolean;
+    /** animation speed in noise z-units per second @type {number} */
+    speed: number;
+    /** the current animation time (third sampling axis) @type {number} */
+    time: number;
+    /** the baked output canvas (reused across re-bakes) @type {HTMLCanvasElement|null} @ignore */
+    _canvas: HTMLCanvasElement | null;
+    /** reused ImageData scratch (avoids a per-bake allocation) @type {ImageData|null} @ignore */
+    _imageData: ImageData | null;
+    /** reused height-field scratch (avoids a per-bake allocation) @type {Float32Array|null} @ignore */
+    _heights: Float32Array | null;
+    /** content revision, bumped on every bake and stamped on the canvas so
+     * the renderer re-uploads the GPU texture when it changes @type {number} @ignore */
+    _version: number;
+    /**
+     * The current content revision, bumped on every {@link NoiseTexture2d#bake}.
+     * Also stamped on the baked canvas (`getTexture().version`) so the renderer
+     * re-uploads the GPU texture only when it actually changed.
+     * @returns {number}
+     */
+    get version(): number;
+    /**
+     * (Re)bake the texture from the current settings into the (reused) output
+     * canvas. Called once on construction; {@link NoiseTexture2d#update} calls it
+     * again per frame for animated textures.
+     * @returns {NoiseTexture2d} this texture for chaining
+     */
+    bake(): NoiseTexture2d;
+    /**
+     * Advance an animated texture by `dt` milliseconds and re-bake it. The
+     * re-bake bumps the texture's `version`, so the renderer re-uploads the GPU
+     * texture automatically on the next draw — no renderer/app handle needed.
+     *
+     * This is NOT auto-called by the engine; drive it from your own update loop
+     * (e.g. {@link Stage#update}) for animated textures. No-op when not `animated`.
+     * @param {number} dt - elapsed time since the last update, in milliseconds
+     * @returns {NoiseTexture2d} this texture for chaining
+     */
+    update(dt: number): NoiseTexture2d;
+    /**
+     * Raw noise sample at a texture pixel (2D, or 3D when animated). The time
+     * axis is divided by the noise frequency so that, after `getNoise3d` scales
+     * all coords by frequency, the field evolves at `speed` noise-units/second —
+     * decoupled from the spatial frequency (otherwise low-frequency textures
+     * would animate imperceptibly slowly).
+     * @ignore
+     */
+    _rawNoise(x: any, y: any): number;
+    /**
+     * x-axis seamless blend: in the right skirt band, cross-fade toward the
+     * wrapped (period-shifted) sample so the left and right edges meet.
+     * @ignore
+     */
+    _blendX(x: any, y: any, w: any, sk: any): any;
+    /**
+     * Sample the noise into a `[0, 1]` height field. When `seamless`, a skirt
+     * cross-fade near the far edges blends opposite edges so the texture tiles
+     * with a much-reduced seam.
+     * @returns {Float32Array} the per-pixel height field (length `width*height`)
+     * @ignore
+     */
+    _buildHeightField(): Float32Array;
+    /** @ignore */
+    _writeGrayscale(data: any, heights: any): void;
+    /** @ignore */
+    _writeColorRamp(data: any, heights: any): void;
+    /**
+     * Encode the height field as a tangent-space normal map (RGB), with screen-Y
+     * flipped to normal-map Y-up so it round-trips through the lit shader's
+     * `rgb * 2 - 1` decode. Neighbor samples wrap when `seamless`.
+     * @ignore
+     */
+    _writeNormalMap(data: any, heights: any): void;
+    /**
+     * @returns {HTMLCanvasElement} the baked texture canvas
+     */
+    getTexture(): HTMLCanvasElement;
+}
+import Texture2d from "./texture2d.ts";
+import { Noise } from "../../math/noise.ts";
+//# sourceMappingURL=noise_texture2d.d.ts.map

package/build/video/texture/noise_texture2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noise_texture2d.d.ts","sourceRoot":"","sources":["../../../src/video/texture/noise_texture2d.js"],"names":[],"mappings":";AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH;IACC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,uBAhBG;QAA0B,KAAK;QACL,MAAM;QACP,KAAK;QAEH,QAAQ;QACT,kBAAkB;QAEjB,MAAM;QACN,WAAW;QACZ,YAAY;QACV,SAAS;QACV,QAAQ;QAET,KAAK;KAEjC,EA4CA;IAxCA,mDAAmD;IACnD,OADyC,MAAM,CACb;IAClC,oDAAoD;IACpD,QAD0C,MAAM,CACZ;IACpC,0DAA0D;IAC1D,OADiD,KAAK,CAEiB;IACvE,gDAAgD;IAChD,UADqC,OAAO,CACF;IAC1C,2EAA2E;IAC3E,oBADiE,MAAM,CAItE;IACD,6CAA6C;IAC7C,QADkC,OAAO,CACH;IACtC,qEAAqE;IACrE,aAD0D,OAAO,CACjB;IAChD,yDAAyD;IACzD,cAD+C,MAAM,CACL;IAChD,2EAA2E;IAC3E,WAD0D,QAAQ,GAAC,IAAI,CAC5B;IAC3C,4EAA4E;IAC5E,UADiE,OAAO,CAC9B;IAC1C,iEAAiE;IACjE,OADuD,MAAM,CAC7B;IAChC,sEAAsE;IACtE,MAD4D,MAAM,CACrD;IAEb,8FAA8F;IAC9F,SAD4D,iBAAiB,GAAC,IAAI,CAC/D;IACnB,6FAA6F;IAC7F,YADmE,SAAS,GAAC,IAAI,CAC3D;IACtB,mGAAmG;IACnG,UADsE,YAAY,GAAC,IAAI,CACnE;IACpB;wFACoF;IACpF,UADkE,MAAM,CACvD;IAKlB;;;;;OAKG;IACH,eAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,QAFa,cAAc,CAiC1B;IAED;;;;;;;;;OASG;IACH,WAHW,MAAM,GACJ,cAAc,CAQ1B;IAED;;;;;;;OAOG;IACH,kCAMC;IAED;;;;OAIG;IACH,8CAOC;IAED;;;;;;OAMG;IACH,qBAHa,YAAY,CA2CxB;IAED,cAAc;IACd,+CASC;IAED,cAAc;IACd,+CAWC;IAED;;;;;OAKG;IACH,+CA+BC;IAED;;OAEG;IACH,cAFa,iBAAiB,CAI7B;CAcD;sBA5VqB,gBAAgB;sBAFhB,qBAAqB"}

package/build/video/texture/parser/aseprite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aseprite.d.ts","sourceRoot":"","sources":["../../../../src/video/texture/parser/aseprite.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,oCALW,MAAM,gBACN,YAAY,GACV,MAAM,CAqElB"}
+{"version":3,"file":"aseprite.d.ts","sourceRoot":"","sources":["../../../../src/video/texture/parser/aseprite.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,oCALW,MAAM,gBACN,YAAY,GACV,MAAM,CAsFlB"}

package/build/video/texture/texture2d.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Compile-time-only brand key; no runtime value can hold it.
+ * @ignore
+ */
+declare const gpuResidentBrand: unique symbol;
+/**
+ * An opaque, GPU-resident texture backing — the source a GPU-resident
+ * {@link Texture2d} resolves to (for example the framebuffer copy
+ * {@link WebGLRenderer#toFrameTexture} produces). Such a backing uploads/binds
+ * itself through the texture cache instead of being read back to the CPU. Its
+ * concrete shape is an engine internal that may change between releases:
+ * obtain values from the engine and pass them back to the engine — do not
+ * construct or inspect them.
+ *
+ * Nominally branded with a `unique symbol`, so only engine-provided values
+ * satisfy the type — a plain object is NOT assignable, keeping
+ * {@link Texture2dSource} (and {@link Texture2d#getTexture}) honestly typed.
+ */
+export interface GPUResidentTexture {
+    /**
+     * Phantom nominal brand — never present at runtime.
+     * @ignore
+     */
+    readonly [gpuResidentBrand]: true;
+}
+/**
+ * The backing source a {@link Texture2d} resolves to through
+ * {@link Texture2d#getTexture}: a drawable (canvas/image) for CPU-backed
+ * assets, or an opaque {@link GPUResidentTexture} for GPU-resident ones.
+ */
+export type Texture2dSource = HTMLCanvasElement | HTMLImageElement | OffscreenCanvas | ImageBitmap | GPUResidentTexture;
+/**
+ * Abstract base for a 2D texture asset — an object that owns a texture
+ * source and can be used anywhere the engine expects an image:
+ * {@link Sprite#image}, {@link Sprite#normalMap}, an {@link ImageLayer}, or
+ * bound as a sampler uniform in a custom shader (see
+ * {@link ShaderEffect#setTexture}).
+ *
+ * A `Texture2d` is recognized via `instanceof` and resolved to its backing
+ * source through {@link Texture2d#getTexture} — so passing the asset object
+ * directly (`{ image: myTexture }`) works the same as passing a raw
+ * `HTMLCanvasElement`. Raw DOM image/canvas sources and the loader's decoded
+ * `CompressedImage` data are accepted too, but are not part of this class
+ * hierarchy.
+ *
+ * Most assets are **CPU-backed** and resolve to a drawable canvas/image — those
+ * are the ones assignable to {@link Sprite#image} / {@link Sprite#normalMap} /
+ * an {@link ImageLayer} (which upload the drawable through the texture cache).
+ * Subclasses may also be **GPU-resident**, resolving to an opaque renderer
+ * backing that never leaves the GPU (e.g. the capture returned by
+ * `renderer.toFrameTexture()`). A GPU-resident texture is **not** a drawable
+ * source: use it as a custom-shader sampler via {@link ShaderEffect#setTexture}
+ * (which binds its live GL handle), NOT as `Sprite#image`. The contract admits
+ * both (a future WebGPU backend follows the same shape with a `GPUTexture`).
+ *
+ * Concrete implementations:
+ * - {@link TextureAtlas} — packed multi-region sprite sheet (CPU-backed)
+ * @category Game Objects
+ */
+export default abstract class Texture2d {
+    /**
+     * Return the backing source for this texture — a drawable canvas/image for
+     * CPU-backed assets (assignable to {@link Sprite#image} /
+     * {@link Sprite#normalMap} / an {@link ImageLayer}), or an opaque
+     * GPU-resident backing for GPU-resident ones (bind those as a custom-shader
+     * sampler via {@link ShaderEffect#setTexture}; they are not drawable sources).
+     * @returns the backing source
+     */
+    abstract getTexture(): Texture2dSource;
+    /**
+     * Release any GPU/CPU resources held by this texture. The texture must not
+     * be used after calling destroy.
+     *
+     * Broadcasts {@link event.TEXTURE2D_DESTROYED} with the backing source so
+     * GPU-side caches keyed by source image (e.g. the lit batcher's normal-map
+     * textures) release what they hold for it. Subclasses that own additional
+     * resources override this and call `super.destroy()` FIRST — the source
+     * must still be resolvable when the event fires.
+     */
+    destroy(): void;
+}
+export {};
+//# sourceMappingURL=texture2d.d.ts.map

package/build/video/texture/texture2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"texture2d.d.ts","sourceRoot":"","sources":["../../../src/video/texture/texture2d.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,OAAO,CAAC,MAAM,gBAAgB,EAAE,OAAO,MAAM,CAAC;AAE9C;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,kBAAkB;IAClC;;;OAGG;IACH,QAAQ,CAAC,CAAC,gBAAgB,CAAC,EAAE,IAAI,CAAC;CAClC;AAED;;;;GAIG;AACH,MAAM,MAAM,eAAe,GACxB,iBAAiB,GACjB,gBAAgB,GAChB,eAAe,GACf,WAAW,GACX,kBAAkB,CAAC;AAEtB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,SAAS;IACtC;;;;;;;OAOG;IACH,QAAQ,CAAC,UAAU,IAAI,eAAe;IAEtC;;;;;;;;;OASG;IACH,OAAO,IAAI,IAAI;CAGf"}

package/build/video/webgl/batchers/batcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/batcher.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH;IACC;;;;;;;;;;;;;;;OAeG;IACH,sBAfW,aAAa,YAErB;QAA2B,UAAU,EACrC;YAAoC,IAAI,EAAhC,MAAM;YACsB,IAAI,EAAhC,MAAM;YACsB,IAAI,EAAhC,MAAM;YACuB,UAAU,EAAvC,OAAO;YACqB,MAAM,EAAlC,MAAM;SACd;QAAyB,MAAM,EAC/B;YAAgC,MAAM,EAA9B,MAAM;YACkB,QAAQ,EAAhC,MAAM;SACd;QAA0B,WAAW;QACV,OAAO;QACR,iBAAiB;KAC7C,EAGA;IAED;;;OAGG;IACH,yCA6HC;IA3HA,cAAwB;IAGxB,QAAqB;IAGrB,gBAA2C;IAE3C;;;OAGG;IACH,oCAA8B;IAE9B;;;OAGG;IACH,oCAA8B;IAE9B;;;;OAIG;IACH,yBAA6B;IAE7B;;;;OAIG;IACH,iCAAoB;IAEpB;;;;;OAKG;IACH,2BAAe;IAEf;;;;;OAKG;IACH,+BAAmB;IAEnB;;;OAGG;IACH,0CAAsB;IAqCtB;;;OAGG;IACH,sCAA0E;IAE1E;;;OAGG;IACH,oCAA+C;IAE/C;;;;OAIG;IACH,+CAA0B;IAE1B;;;;OAIG;IACH,iDAAuB;IAUxB;;;OAGG;IACH,cAUC;IAED;;OAEG;IACH,aAYC;IAED;;;;OAIG;IACH,eAaC;IAED;;;;OAIG;IACH,kBAFW,QAAQ,QA8BlB;IAHE,uCAA4B;IAK/B;;;;;;;OAOG;IACH,mBANW,MAAM,QACN,MAAM,QACN,MAAM,cACN,OAAO,UACP,MAAM,QA+BhB;IAED;;;OAGG;IACH,sBAFW,QAAQ,QAIlB;IAED;;;;OAIG;IACH,oBAFW,MAAM,EAAE,QAOlB;IAED;;;OAGG;IACH,aAFW,MAAM,QAgFhB;CACD;;qBApZoB,gBAAgB;8BAFP,wBAAwB;6BACzB,oBAAoB;8BAMtB,2BAA2B;+BADxB,wBAAwB"}
+{"version":3,"file":"batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/batcher.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH;IACC;;;;;;;;;;;;;;;OAeG;IACH,sBAfW,aAAa,YAErB;QAA2B,UAAU,EACrC;YAAoC,IAAI,EAAhC,MAAM;YACsB,IAAI,EAAhC,MAAM;YACsB,IAAI,EAAhC,MAAM;YACuB,UAAU,EAAvC,OAAO;YACqB,MAAM,EAAlC,MAAM;SACd;QAAyB,MAAM,EAC/B;YAAgC,MAAM,EAA9B,MAAM;YACkB,QAAQ,EAAhC,MAAM;SACd;QAA0B,WAAW;QACV,OAAO;QACR,iBAAiB;KAC7C,EAGA;IAED;;;OAGG;IACH,yCA6HC;IA3HA,cAAwB;IAGxB,QAAqB;IAGrB,gBAA2C;IAE3C;;;OAGG;IACH,oCAA8B;IAE9B;;;OAGG;IACH,oCAA8B;IAE9B;;;;OAIG;IACH,yBAA6B;IAE7B;;;;OAIG;IACH,iCAAoB;IAEpB;;;;;OAKG;IACH,2BAAe;IAEf;;;;;OAKG;IACH,+BAAmB;IAEnB;;;OAGG;IACH,0CAAsB;IAqCtB;;;OAGG;IACH,sCAA0E;IAE1E;;;OAGG;IACH,oCAA+C;IAE/C;;;;OAIG;IACH,+CAA0B;IAE1B;;;;OAIG;IACH,iDAAuB;IAUxB;;;OAGG;IACH,cAoBC;IAED;;OAEG;IACH,aAYC;IAED;;;;OAIG;IACH,eAaC;IAED;;;;OAIG;IACH,kBAFW,QAAQ,QA8BlB;IAHE,uCAA4B;IAK/B;;;;;;;OAOG;IACH,mBANW,MAAM,QACN,MAAM,QACN,MAAM,cACN,OAAO,UACP,MAAM,QA+BhB;IAED;;;OAGG;IACH,sBAFW,QAAQ,QAIlB;IAED;;;;OAIG;IACH,oBAFW,MAAM,EAAE,QAOlB;IAED;;;OAGG;IACH,aAFW,MAAM,QAgFhB;CACD;;qBA9ZoB,gBAAgB;8BAFP,wBAAwB;6BACzB,oBAAoB;8BAMtB,2BAA2B;+BADxB,wBAAwB"}

package/build/video/webgl/batchers/lit_mesh_batcher.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A {@link MeshBatcher} variant that shades meshes with the active stage's
+ * {@link Light3d} lights (half-Lambert diffuse from directional lights +
+ * ambient). It extends the unlit batcher, adding a world-space `aNormal`
+ * vertex attribute (12-float layout vs 9) and a lit shader.
+ *
+ * Meshes opt in via `mesh.lit` — so standalone, unlit meshes keep the lean
+ * 9-float `MeshBatcher` and pay nothing for lighting. Both batchers share the
+ * mesh-mode depth-clear state (a single clear per target) since this one
+ * inherits {@link MeshBatcher#bind}.
+ * @category Rendering
+ */
+export default class LitMeshBatcher extends MeshBatcher {
+    /** push the 12-float lit vertex, appending the mesh's world-space normal. @ignore */
+    _pushVertex(vertexData: any, x: any, y: any, z: any, u: any, v: any, color: any, mesh: any, i3: any): void;
+}
+import MeshBatcher from "./mesh_batcher.js";
+//# sourceMappingURL=lit_mesh_batcher.d.ts.map

package/build/video/webgl/batchers/lit_mesh_batcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lit_mesh_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/lit_mesh_batcher.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;GAWG;AACH;IAqBC,qFAAqF;IACrF,2GAaC;CA0BD;wBAzFuB,mBAAmB"}

package/build/video/webgl/batchers/lit_quad_batcher.d.ts

@@ -28,13 +28,38 @@ export default class LitQuadBatcher extends QuadBatcher {
      */
     boundNormalMaps: (ImageBitmap | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | null)[] | undefined;
     /**
-     * Map from a normal-map source image to its GL texture object.
-     * @type {Map<HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap, WebGLTexture>}
+     * Per-slot content `version` of the normal map currently bound there. An
+     * animated source keeps a stable canvas reference across re-bakes but
+     * bumps its `version`, so `addQuad` compares this (not just the reference)
+     * to know when to re-bind/re-upload. `-1` = nothing bound.
+     * @type {number[]}
      * @ignore
      */
-    normalMapTextures: Map<ImageBitmap | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas, WebGLTexture> | undefined;
+    boundNormalVersions: number[] | undefined;
+    /**
+     * Map from a normal-map source image to its uploaded GL texture and the
+     * source `version` it was uploaded at. A source that bumps its `version`
+     * (e.g. an animated {@link NoiseTexture2d}) is re-uploaded on next bind —
+     * the three.js `Texture.needsUpdate` model, scoped to normal maps which
+     * live outside the color `TextureCache`.
+     * @type {Map<HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap, {tex: WebGLTexture, version: number}>}
+     * @ignore
+     */
+    normalMapTextures: Map<ImageBitmap | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas, {
+        tex: WebGLTexture;
+        version: number;
+    }> | undefined;
     _lightCount: number | undefined;
     _maxLights: number | undefined;
+    _onTexture2dDestroyed: ((source: any) => void) | null | undefined;
+    _normalRangeReserved: boolean | undefined;
+    /**
+     * Release the cached GL texture uploaded for the given normal-map source
+     * and clear any slot bookkeeping referencing it. Safe to call for images
+     * that were never bound.
+     * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap} image - normal-map source
+     */
+    evictNormalMap(image: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap): void;
     /**
      * Bind the paired normal sampler uniforms (`uNormalSampler0..N-1`)
      * to texture units `maxBatchTextures..2*maxBatchTextures-1`. Called
@@ -85,8 +110,9 @@ export default class LitQuadBatcher extends QuadBatcher {
      * encoding for any non-opaque texel.
      * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap} image - normal-map source
      * @param {number} unit - GL texture unit (already offset by `maxBatchTextures`)
+     * @param {number} [version=0] - the source revision being uploaded
      */
-    uploadNormalMap(image: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap, unit: number): void;
+    uploadNormalMap(image: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap, unit: number, version?: number): void;
     /**
      * Add a textured quad with optional paired normal map.
      * @param {TextureAtlas} texture - Source texture atlas

package/build/video/webgl/batchers/lit_quad_batcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lit_quad_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/lit_quad_batcher.js"],"names":[],"mappings":"AAKA;;;GAGG;AAEH;;;;;;;;;;;;;;;GAeG;AACH;IAsEE;;;;;;OAMG;IACH,6GAAmD;IAEnD;;;;OAIG;IACH,uHAAkC;IAElC,gCAAoB;IACpB,+BAA4B;IAK7B;;;;;OAKG;IACH,2BAOC;IAsBD;;;;;;;;;;;;;;OAcG;IACH,2BANG;QAA+B,SAAS,EAAhC,YAAY;QACW,MAAM,EAA7B,YAAY;QACY,OAAO;QACd,KAAK,EAAtB,MAAM;QACc,OAAO;KACrC,QAgBA;IAED;;;;;;;;;OASG;IACH,qBAHW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,QAC9D,MAAM,QAahB;IAED;;;;;;;;;;OAUG;IACH,uBAHW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,QAC9D,MAAM,QAiBhB;IAED;;;;;;;;;;;;;;OAcG;IACH,iBAbW,YAAY,KACZ,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,OAAO,cACP,gBAAgB,GAAC,iBAAiB,GAAC,IAAI,QAkHjD;CA0DD;wBAlaoC,mBAAmB;kCAIzB,0BAA0B"}
+{"version":3,"file":"lit_quad_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/lit_quad_batcher.js"],"names":[],"mappings":"AAMA;;;GAGG;AAEH;;;;;;;;;;;;;;;GAeG;AACH;IAsEE;;;;;;OAMG;IACH,6GAAmD;IAEnD;;;;;;;OAOG;IACH,0CAAqD;IAErD;;;;;;;;OAQG;IACH;aAHoF,YAAY;iBAAW,MAAM;mBAG/E;IAElC,gCAAoB;IACpB,+BAA4B;IAQ3B,kEAEC;IAiCD,0CAAgC;IAoBlC;;;;;OAKG;IACH,sBAFW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,QAcxE;IAED;;;;;OAKG;IACH,2BAOC;IA4DD;;;;;;;;;;;;;;OAcG;IACH,2BANG;QAA+B,SAAS,EAAhC,YAAY;QACW,MAAM,EAA7B,YAAY;QACY,OAAO;QACd,KAAK,EAAtB,MAAM;QACc,OAAO;KACrC,QAgBA;IAED;;;;;;;;;OASG;IACH,qBAHW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,QAC9D,MAAM,QAiBhB;IAED;;;;;;;;;;;OAWG;IACH,uBAJW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,QAC9D,MAAM,YACN,MAAM,QAwBhB;IAED;;;;;;;;;;;;;;OAcG;IACH,iBAbW,YAAY,KACZ,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,OAAO,cACP,gBAAgB,GAAC,iBAAiB,GAAC,IAAI,QAwIjD;CA8DD;wBA1kBoC,mBAAmB;kCAIzB,0BAA0B"}

package/build/video/webgl/batchers/material_batcher.d.ts

@@ -8,17 +8,35 @@
  * @category Rendering
  */
 export class MaterialBatcher extends Batcher {
+    set currentTextureUnit(unit: number);
     /**
-     * the current active texture unit
+     * The GL texture unit currently active (`gl.activeTexture`). Tracked on
+     * the RENDERER, not per batcher: the active unit is global GL state
+     * shared by every batcher instance, and a per-batcher copy desyncs as
+     * soon as another batcher (or a blit, or an FBO pass) moves the active
+     * unit — the stale copy then lets `bindTexture2D` skip `gl.activeTexture`
+     * and bind (or upload) a texture onto whatever unit is REALLY active.
+     * Symptom was video force-re-uploads overwriting a mesh texture with
+     * video frames after a mesh pass.
+     * @type {number}
      * @ignore
      */
-    currentTextureUnit: any;
+    get currentTextureUnit(): number;
     /**
      * bound textures by unit
      * @ignore
      */
     boundTextures: any[] | undefined;
     _onCacheReset: (() => void) | null | undefined;
+    /**
+     * Drop every cached texture binding after a {@link GPU_TEXTURE_CACHE_RESET}
+     * (the shared texture cache reassigned units — our per-unit view is stale).
+     * Subclasses that pair extra samplers to units (lit normal maps) override to
+     * forget those too; without that they'd assume the extra texture is still
+     * resident and skip re-binding it after the reset.
+     * @ignore
+     */
+    _onTextureCacheReset(): void;
     /**
      * Free resources used by the batcher. Currently unsubscribes the
      * texture-cache-reset listener so a discarded batcher doesn't keep
@@ -64,6 +82,19 @@ export class MaterialBatcher extends Batcher {
      * @returns {number} unit the unit number that was associated with the given texture
      */
     unbindTexture2D(texture?: WebGLTexture, unit?: number): number;
+    /**
+     * Forget whatever texture this batcher believes is bound to `unit`, so the
+     * next bind to it re-issues the GL bind. Used when a GL texture unit is
+     * clobbered OUTSIDE this batcher's own accounting — e.g.
+     * {@link WebGLRenderer#toFrameTexture}, which binds its capture to a scratch
+     * unit directly (not via the shared texture cache), so a different batcher's
+     * unit cache would otherwise skip a needed re-bind. Subclasses that pair
+     * extra samplers to the same unit (lit normal maps) override to drop those
+     * too.
+     * @param {number} unit - the GL texture unit to invalidate
+     * @ignore
+     */
+    invalidateUnit(unit: number): void;
     /**
      * @ignore
      * @param {TextureAtlas|TextureResource} texture
@@ -73,8 +104,13 @@ export class MaterialBatcher extends Batcher {
      * @param {number} [h] - same as `w`.
      * @param {boolean} [force=false]
      * @param {boolean} [flush=true]
+     * @param {string} [repeat] - per-use wrap-mode override (a mesh's
+     *   `textureRepeat`, #1503) — sampled with this wrap without mutating
+     *   the shared atlas's `repeat`. The texture-unit cache keys by
+     *   `(source, repeat)`, so each wrap gets its own unit + GL texture.
+     *   Omit to use `texture.repeat`.
      */
-    uploadTexture(texture: TextureAtlas | TextureResource, w?: number, h?: number, force?: boolean, flush?: boolean): any;
+    uploadTexture(texture: TextureAtlas | TextureResource, w?: number, h?: number, force?: boolean, flush?: boolean, repeat?: string): any;
 }
 import { Batcher } from "./batcher.js";
 import type { TextureAtlas } from "./../../texture/atlas.js";

package/build/video/webgl/batchers/material_batcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"material_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/material_batcher.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;GAIG;AACH;IAQE;;;OAGG;IACH,wBAA4B;IAE5B;;;OAGG;IACH,iCAAuB;IAsBtB,+CAIC;IAKH;;;;;;OAMG;IACH,gBAKC;IAmBD;;;;;;;;;;;OAWG;IACH,sBAVW,MAAM,WACN,8DAAM,iBAAiB,GAAC,SAAS,GAAC,UAAU,EAAE,GAAC,YAAY,EAAE,UAC7D,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,uBACN,OAAO,WACP,OAAO,kCACL,YAAY,CA0JxB;IAED;;;OAGG;IACH,yBAFW,YAAY,GAAC,YAAY,QA+BnC;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,YAAY,CAIxB;IAED;;;;OAIG;IACH,uBAHW,YAAY,QACZ,MAAM,yBAsBhB;IAED;;;;;OAKG;IACH,0BAJW,YAAY,SACZ,MAAM,GACJ,MAAM,CAalB;IAED;;;;;;;;;OASG;IACH,uBARW,YAAY,GAAC,eAAe,MAC5B,MAAM,MAGN,MAAM,UACN,OAAO,UACP,OAAO,OAiDjB;CACD;wBAtZuB,cAAc;kCAIP,0BAA0B"}
+{"version":3,"file":"material_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/material_batcher.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;GAIG;AACH;IA6EC,6BAPU,MAAM,EASf;IAlBD;;;;;;;;;;;OAWG;IACH,0BAHU,MAAM,CAKf;IA/DA;;;OAGG;IACH,iCAAuB;IAwBtB,+CAEC;IAKH;;;;;;;OAOG;IACH,6BAIC;IAsBD;;;;;;OAMG;IACH,gBAKC;IAmBD;;;;;;;;;;;OAWG;IACH,sBAVW,MAAM,WACN,8DAAM,iBAAiB,GAAC,SAAS,GAAC,UAAU,EAAE,GAAC,YAAY,EAAE,UAC7D,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,uBACN,OAAO,WACP,OAAO,kCACL,YAAY,CAmKxB;IAED;;;OAGG;IACH,yBAFW,YAAY,GAAC,YAAY,QAgCnC;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,YAAY,CAIxB;IAED;;;;OAIG;IACH,uBAHW,YAAY,QACZ,MAAM,yBAsBhB;IAED;;;;;OAKG;IACH,0BAJW,YAAY,SACZ,MAAM,GACJ,MAAM,CAalB;IAED;;;;;;;;;;;OAWG;IACH,qBAHW,MAAM,QAQhB;IAED;;;;;;;;;;;;;;OAcG;IACH,uBAbW,YAAY,GAAC,eAAe,MAC5B,MAAM,MAGN,MAAM,UACN,OAAO,UACP,OAAO,WACP,MAAM,OAsDhB;CACD;wBAzduB,cAAc;kCAIP,0BAA0B"}

package/build/video/webgl/batchers/mesh_batcher.d.ts

@@ -29,20 +29,61 @@ export default class MeshBatcher extends MaterialBatcher {
      * @ignore
      */
     init(renderer: any): void;
+    currentAlphaCutoff: any;
+    currentEmissiveR: any;
+    currentEmissiveG: any;
+    currentEmissiveB: any;
+    _onTargetChanged: ((emitter: any) => void) | null | undefined;
     /**
-     * Tracks whether the active framebuffer's depth attachment still
-     * needs a clear before this batcher's next draw. Flipped to
-     * `true` by the `RENDER_TARGET_CHANGED` listener installed
-     * below (frame start, post-effect FBO bind/unbind), back to
-     * `false` by the first `bind()` of the new target after the
-     * lazy clear runs. Lifts depth clearing from per-mesh (legacy)
-     * to per-target — same model Three.js uses. The GPU's `LEQUAL`
-     * depth test then resolves inter-mesh occlusion per pixel
-     * against the accumulated buffer.
+     * The vertex attribute layout. The base (unlit) mesh batcher is
+     * `aVertex` (3) + `aRegion` (2) + `aColor` (4) = 9 floats. Subclasses
+     * (e.g. {@link LitMeshBatcher}) append their own attributes.
      * @ignore
      */
-    _depthDirty: boolean | undefined;
-    _onTargetChanged: (() => void) | null | undefined;
+    _attributeLayout(renderer: any): {
+        name: string;
+        size: number;
+        type: any;
+        normalized: boolean;
+        offset: number;
+    }[];
+    /**
+     * The shader sources for this batcher (unlit by default). Subclasses
+     * override to supply a lit shader.
+     * @ignore
+     */
+    _shaderSources(): {
+        vertex: any;
+        fragment: any;
+    };
+    /**
+     * Invalidate the per-mesh `uAlphaCutoff` / `uEmissive` caches when the bound
+     * shader (GL program) changes — the new program's uniforms are at their own
+     * defaults, so the next mesh must re-issue them rather than trust the cache.
+     * Mirrors the base batcher's `currentSamplerUnit` reset (same condition), and
+     * matters when a custom mesh shader declaring those uniforms is interleaved
+     * with the built-in one on this batcher (e.g. `drawMesh` swapping a custom
+     * shader in and back out).
+     * @ignore
+     */
+    useShader(shader: any): void;
+    /**
+     * Write one vertex into the buffer. The base (unlit) layout is
+     * `x, y, z, u, v, color`. Subclasses override to append per-vertex data
+     * matching their {@link MeshBatcher#_attributeLayout} (e.g.
+     * {@link LitMeshBatcher} pushes the world-space normal too).
+     * @param {object} vertexData - the batcher's vertex buffer
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} u
+     * @param {number} v
+     * @param {number} color - packed ARGB Uint32
+     * @param {object} _mesh - the source mesh (unused here; for subclasses)
+     * @param {number} _i3 - the source vertex's `index * 3` (for subclasses)
+     * @ignore
+     */
+    _pushVertex(vertexData: object, x: number, y: number, z: number, u: number, v: number, color: number, _mesh: object, _i3: number): void;
     /**
      * Add a textured mesh to the batch. When the mesh has a
      * `vertexColors` array (multi-material OBJ + bound MTL), each

package/build/video/webgl/batchers/mesh_batcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mesh_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/mesh_batcher.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IACC;;;OAGG;IACH,0BAuEC;IA1BA;;;;;;;;;;;OAWG;IACH,iCAAuB;IAStB,kDAEC;IA4DH;;;;;;;;;;;;;;OAcG;IACH,cAHW,MAAM,QACN,MAAM,QAuFhB;CACD;gCAtS+B,uBAAuB"}
+{"version":3,"file":"mesh_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/mesh_batcher.js"],"names":[],"mappings":"AAyFA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IACC;;;OAGG;IACH,0BAsCC;IA5BA,wBAA4B;IAI5B,sBAA0B;IAC1B,sBAA0B;IAC1B,sBAA0B;IAYzB,8DAOC;IAKH;;;;;OAKG;IACH;;;;;;QAgCC;IAED;;;;OAIG;IACH;;;MAEC;IAED;;;;;;;;;OASG;IACH,6BAWC;IAyDD;;;;;;;;;;;;;;;OAeG;IACH,wBAXW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,SACN,MAAM,SACN,MAAM,OACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;OAcG;IACH,cAHW,MAAM,QACN,MAAM,QA+JhB;CACD;gCA3d+B,uBAAuB"}

package/build/video/webgl/batchers/primitive_batcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"primitive_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/primitive_batcher.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;GAIG;AACH;IACC;;;OAGG;IACH,0BAsCC;IALA;;;OAGG;IACH,sBAAyB;IA0B1B;;;;;OAKG;IACH,mBAJW,MAAM,SACN,KAAK,EAAE,gBACP,MAAM,QAqEhB;;CAuFD;wBAhPuB,cAAc;2BAId,gCAAgC"}
+{"version":3,"file":"primitive_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/primitive_batcher.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;GAIG;AACH;IACC;;;OAGG;IACH,0BAsCC;IALA;;;OAGG;IACH,sBAAyB;IA0B1B;;;;;OAKG;IACH,mBAJW,MAAM,SACN,KAAK,EAAE,gBACP,MAAM,QAoDhB;;CAyMD;wBAjVuB,cAAc;2BAId,gCAAgC"}

package/build/video/webgl/batchers/quad_batcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quad_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/quad_batcher.js"],"names":[],"mappings":"AAMA;;;GAGG;AAUH,iCAKE;AAEF;;;;GAIG;AACH;IACC;;;OAGG;IACH,0BA0DC;IAzDA;;;;OAIG;IACH,qCAA0D;IA2C1D;;;;;OAKG;IACH,qCAA2B;IAK5B;;;;OAIG;IACH,0BAQC;IAED;;;;OAIG;IACH,0BAIC;IAED;;;;;;;OAOG;IACH,kBAFW,QAAQ,GAAC,YAAY,QAK/B;IAyDD;;;;;;;;;;OAUG;IACH,oBAPW,YAAY,KACZ,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,QAAQ,GAAC,YAAY,QAyD/B;IAED;;;;;;;;;;;;;OAaG;IACH,iBAZW,YAAY,KACZ,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,OAAO,QA2DjB;CACD;yBA1UwB,2BAA2B;gCAIpB,uBAAuB;kCAIxB,0BAA0B"}
+{"version":3,"file":"quad_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/quad_batcher.js"],"names":[],"mappings":"AAMA;;;GAGG;AAUH,iCAKE;AAEF;;;;GAIG;AACH;IACC;;;OAGG;IACH,0BA0DC;IAzDA;;;;OAIG;IACH,qCAA0D;IA2C1D;;;;;OAKG;IACH,qCAA2B;IAK5B;;;;OAIG;IACH,0BAcC;IAED;;;;OAIG;IACH,0BAIC;IAED;;;;;;;OAOG;IACH,kBAFW,QAAQ,GAAC,YAAY,QAK/B;IAyDD;;;;;;;;;;OAUG;IACH,oBAPW,YAAY,KACZ,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,QAAQ,GAAC,YAAY,QAkE/B;IAED;;;;;;;;;;;;;OAaG;IACH,iBAZW,YAAY,KACZ,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,OAAO,QAwEjB;CACD;yBAtWwB,2BAA2B;gCAIpB,uBAAuB;kCAIxB,0BAA0B"}

package/build/video/webgl/buffer/index.d.ts

@@ -20,6 +20,19 @@ export default class WebGLIndexBuffer extends IndexBuffer {
      * Bind this index buffer
      */
     bind(): void;
+    /**
+     * Replace the underlying GL buffer with a fresh one, deleting the old.
+     * Needed on context restore — the old buffer object belongs to the lost
+     * context and every upload through it would silently fail. Also keeps
+     * plain resets leak-free (`deleteBuffer` on a lost-context object is a
+     * harmless no-op).
+     */
+    recreate(): void;
+    /**
+     * Delete the underlying GL buffer. The index buffer must not be used
+     * after calling destroy.
+     */
+    destroy(): void;
 }
 import IndexBuffer from "../../buffer/index.js";
 //# sourceMappingURL=index.d.ts.map