melonjs 19.8.0 → 19.9.1

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_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,QAgBhB;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;wBAjaoC,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

@@ -33,7 +33,7 @@ export default class MeshBatcher extends MaterialBatcher {
     currentEmissiveR: any;
     currentEmissiveG: any;
     currentEmissiveB: any;
-    _onTargetChanged: (() => void) | null | undefined;
+    _onTargetChanged: ((emitter: any) => void) | null | undefined;
     /**
      * The vertex attribute layout. The base (unlit) mesh batcher is
      * `aVertex` (3) + `aRegion` (2) + `aColor` (4) = 9 floats. Subclasses

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":"AAsFA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IACC;;;OAGG;IACH,0BA8BC;IApBA,wBAA4B;IAI5B,sBAA0B;IAC1B,sBAA0B;IAC1B,sBAA0B;IASzB,kDAEC;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,QAoJhB;CACD;gCArc+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

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/buffer/index.js"],"names":[],"mappings":"AAEA;;;GAGG;AAEH;IACC;;;;OAIG;IACH,gBAJW,qBAAqB,GAAC,sBAAsB,cAC5C,MAAM,cACN,OAAO,EAOjB;IAHA,mDAAY;IACZ,kBAA2D;IAC3D,oBAA+B;IAiBhC;;OAEG;IACH,eAOC;IAED;;OAEG;IACH,aAEC;CACD;wBApDuB,uBAAuB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/buffer/index.js"],"names":[],"mappings":"AAEA;;;GAGG;AAEH;IACC;;;;OAIG;IACH,gBAJW,qBAAqB,GAAC,sBAAsB,cAC5C,MAAM,cACN,OAAO,EAOjB;IAHA,mDAAY;IACZ,kBAA2D;IAC3D,oBAA+B;IAiBhC;;OAEG;IACH,eAOC;IAED;;OAEG;IACH,aAEC;IAED;;;;;;OAMG;IACH,iBAIC;IAED;;;OAGG;IACH,gBAGC;CACD;wBA1EuB,uBAAuB"}

package/build/video/webgl/effects/hologram.d.ts

@@ -22,11 +22,6 @@ export default class HologramEffect extends ShaderEffect {
         color?: number[] | undefined;
         intensity?: number | undefined;
     });
-    /**
-     * set the current time (call each frame for animation)
-     * @param {number} time - time in seconds
-     */
-    setTime(time: number): void;
     /**
      * set the hologram tint color
      * @param {number[]} color - color as [r, g, b] (0.0–1.0)

package/build/video/webgl/effects/hologram.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hologram.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/hologram.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH;IACC;;;;;OAKG;IACH,sBALW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAA2B,KAAK;QACP,SAAS;KACpC,EAyBA;IAED;;;OAGG;IACH,cAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;CACD;yBA/DwB,oBAAoB"}
+{"version":3,"file":"hologram.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/hologram.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH;IACC;;;;;OAKG;IACH,sBALW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAA2B,KAAK;QACP,SAAS;KACpC,EAyBA;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;CACD;yBAvDwB,oBAAoB"}

package/build/video/webgl/effects/shine.d.ts

@@ -57,11 +57,6 @@ export default class ShineEffect extends ShaderEffect {
         pulseDepth?: number | undefined;
         pulseSpeed?: number | undefined;
     });
-    /**
-     * set the current time (call each frame for animation)
-     * @param {number} time - time in seconds
-     */
-    setTime(time: number): void;
     /**
      * set the shine color
      * @param {number[]} color - shine color as [r, g, b] (0.0–1.0)

package/build/video/webgl/effects/shine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shine.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/shine.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH;IACC;;;;;;;;;;;OAWG;IACH,sBAXW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAA2B,KAAK;QACP,KAAK;QACL,KAAK;QACL,SAAS;QACT,KAAK;QACL,KAAK;QACL,UAAU;QACV,UAAU;KACrC,EAuDA;IAED;;;OAGG;IACH,cAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,oBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAIhB;CACD;yBAlJwB,oBAAoB"}
+{"version":3,"file":"shine.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/shine.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH;IACC;;;;;;;;;;;OAWG;IACH,sBAXW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAA2B,KAAK;QACP,KAAK;QACL,KAAK;QACL,SAAS;QACT,KAAK;QACL,KAAK;QACL,UAAU;QACV,UAAU;KACrC,EAuDA;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,oBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAIhB;CACD;yBA1IwB,oBAAoB"}

package/build/video/webgl/glshader.d.ts

@@ -45,6 +45,17 @@ export default class GLShader {
      * @readonly
      */
     readonly destroyed: boolean;
+    /**
+     * When `true`, a renderable will NOT auto-destroy this shader when it is
+     * removed from its `postEffects` (via the `shader` setter,
+     * `removePostEffect`, `clearPostEffects`) or when the renderable itself
+     * is destroyed. Set this on a shader shared across several renderables so
+     * one of them going away doesn't free the GL program still used by the
+     * others — you then own its lifecycle and call {@link destroy} yourself.
+     * @type {boolean}
+     * @default false
+     */
+    shared: boolean;
     /**
      * `true` while the WebGL context is lost (and until it's
      * restored). The GL program/attributes/uniforms are released
@@ -113,6 +124,24 @@ export default class GLShader {
      * @param {number} stride - the size of a single vertex in bytes
      */
     setVertexAttributes(gl: WebGLRenderingContext, attributes: object[], stride: number): void;
+    /**
+     * Create an independent copy of this shader, compiled as its own GL
+     * program from the same vertex + fragment sources (and precision), with
+     * every uniform value set so far replayed onto the copy. Use it when
+     * several renderables need the same custom shader with *different*
+     * uniform values — a single instance has a single set of uniforms.
+     *
+     * Ownership and lifecycle state do NOT carry over: the clone's
+     * {@link shared} flag is **always reset to `false`**, even when cloning
+     * a shared shader — the clone is caller-owned and will be auto-destroyed
+     * by the renderable it is assigned to, unless you explicitly set
+     * `shared = true` on it yourself. Note that `ShaderEffect` (which wraps
+     * a GLShader by composition) has its own `clone()` with the same
+     * semantics, which additionally copies its effect-level state (extra
+     * `setTexture` bindings).
+     * @returns {GLShader} a new, caller-owned shader (`shared === false`)
+     */
+    clone(): GLShader;
     /**
      * destroy this shader objects resources (program, attributes, uniforms).
      * Idempotent — calling destroy twice (or after a context-lost suspend)

package/build/video/webgl/glshader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"glshader.d.ts","sourceRoot":"","sources":["../../../src/video/webgl/glshader.js"],"names":[],"mappings":"AAYA;;;GAGG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,gBA1BW,qBAAqB,UACrB,MAAM,YACN,MAAM,cACN,MAAM,EAyEhB;IAjDA;;;OAGG;IACH,IAFU,qBAAqB,CAEnB;IAEZ;;;;;;;OAOG;IACH,oBAHU,OAAO,CAGK;IAEtB;;;;;;;;;;OAUG;IACH,oBAHU,OAAO,CAGK;IAGtB,sBAA2B;IAC3B,wBAA+B;IAC/B,+BAA2B;IAG3B,mBAAwC;IAKvC,sBAAmB;IACnB,iBAAoB;IACpB,qBAAsB;IASxB;;;;;;OAMG;IACH,iBA0CC;IAzCA,YAGC;IACD,cAGC;IAoCF;;;;;OAKG;IACH,uBAgBC;IAED;;;;;OAKG;IACH,2BAMC;IAED;;OAEG;IACH,aAKC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,KAAK,CAYjB;IAED;;;;;;OAMG;IACH,iBALW,MAAM,SACN,MAAM,GAAC,YAAY,QA0C7B;IAED;;;;;OAKG;IACH,wBAJW,qBAAqB,cACrB,MAAM,EAAE,UACR,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,gBA2BC;CACD"}
+{"version":3,"file":"glshader.d.ts","sourceRoot":"","sources":["../../../src/video/webgl/glshader.js"],"names":[],"mappings":"AAYA;;;GAGG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,gBA1BW,qBAAqB,UACrB,MAAM,YACN,MAAM,cACN,MAAM,EAqFhB;IA7DA;;;OAGG;IACH,IAFU,qBAAqB,CAEnB;IAEZ;;;;;;;OAOG;IACH,oBAHU,OAAO,CAGK;IAEtB;;;;;;;;;OASG;IACH,QAHU,OAAO,CAGE;IAEnB;;;;;;;;;;OAUG;IACH,oBAHU,OAAO,CAGK;IAGtB,sBAA2B;IAC3B,wBAA+B;IAC/B,+BAA2B;IAG3B,mBAAwC;IAKvC,sBAAmB;IACnB,iBAAoB;IACpB,qBAAsB;IASxB;;;;;;OAMG;IACH,iBA0CC;IAzCA,YAGC;IACD,cAGC;IAoCF;;;;;OAKG;IACH,uBAgBC;IAED;;;;;OAKG;IACH,2BAMC;IAED;;OAEG;IACH,aAKC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,KAAK,CAYjB;IAED;;;;;;OAMG;IACH,iBALW,MAAM,SACN,MAAM,GAAC,YAAY,QA0C7B;IAED;;;;;OAKG;IACH,wBAJW,qBAAqB,cACrB,MAAM,EAAE,UACR,MAAM,QAmBhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,SAFa,QAAQ,CAyBpB;IAED;;;;;OAKG;IACH,gBA2BC;CACD"}