melonjs 19.8.0 → 19.9.0

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"}

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

@@ -24,6 +24,23 @@
  * mySprite.shader = pulse;
  * // update the uniform each frame
  * pulse.setUniform("uTime", time);
+ * @example
+ * // Shader builtins — no JS plumbing, no UV math:
+ * // `: screen_texture` keeps the sampler filled with everything drawn so
+ * // far (a back-buffer copy; one screen copy per draw of the effect),
+ * // `screen_uv` is this fragment's 0..1 screen position, and `noise_uv`
+ * // runs 0..1 across the sprite regardless of its atlas frame.
+ * const water = new ShaderEffect(renderer, `
+ *     uniform sampler2D uNoise;
+ *     uniform sampler2D screenTex : screen_texture;
+ *     uniform float uTime;
+ *     vec4 apply(vec4 color, vec2 uv) {
+ *         vec2 flow = texture2D(uNoise, noise_uv + uTime * 0.25).rg;
+ *         vec4 refracted = texture2D(screenTex, screen_uv + flow * 0.005);
+ *         return refracted * texture2D(uSampler, uv + flow * 0.005);
+ *     }
+ * `);
+ * water.setTexture("uNoise", noiseTexture.getTexture(), "repeat");
  */
 export default class ShaderEffect {
     /**
@@ -51,8 +68,56 @@ export default class ShaderEffect {
      * @readonly
      */
     readonly destroyed: boolean;
+    /**
+     * When `true`, a renderable will NOT auto-destroy this effect when it is
+     * removed from its `postEffects` (via the `shader` setter,
+     * {@link Renderable#removePostEffect}, {@link Renderable#clearPostEffects})
+     * or when the renderable itself is destroyed. Set this on an effect 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;
+    /**
+     * the renderer this effect was created for — kept so destroy and
+     * context-loss can release the texture units reserved on its cache
+     * for extra samplers ({@link setTexture}), and so {@link clone} can
+     * compile an independent copy
+     * @ignore
+     */
+    _renderer: any;
+    /**
+     * the construction "recipe" (fragment body + precision), kept so
+     * {@link clone} can compile an independent copy. Stored before the
+     * Canvas-mode early return so cloning behaves consistently there too.
+     * @ignore
+     */
+    _fragmentBody: string;
+    /** @ignore */
+    _precision: string | undefined;
+    /**
+     * samplers annotated `: screen_texture` — the renderer checks this to
+     * know when to refresh the shared frame capture before the effect draws
+     * @type {Array<{name: string, repeat: string}>}
+     * @ignore
+     */
+    _screenTextureUniforms: Array<{
+        name: string;
+        repeat: string;
+    }>;
+    /** @ignore */
+    _hasNoiseUV: boolean | undefined;
     /** @ignore */
     _shader: GLShader | undefined;
+    /**
+     * extra texture samplers bound via {@link setTexture}, keyed by the
+     * uniform name → `{ image, repeat, tex }` (`tex` is the uploaded GL
+     * texture, created lazily on first draw)
+     * @ignore
+     */
+    _extraTextures: Map<any, any> | undefined;
     /** @private */
     private _onContextLost;
     _enabledBeforeSuspend: boolean | undefined;
@@ -64,6 +129,123 @@ export default class ShaderEffect {
      * @param {object|Float32Array} value - the value to assign to that uniform
      */
     setUniform(name: string, value: object | Float32Array): void;
+    /**
+     * Set the shader's `uTime` uniform (elapsed time, in seconds). A convenience
+     * over `setUniform("uTime", ...)`; call it once per frame from your update
+     * loop to animate a shader that declares `uniform float uTime` (e.g. scrolling
+     * a static noise texture's UVs, pulsing, waving). Drive it with whatever clock
+     * you like — real time, a paused/scaled/scrubbed one.
+     *
+     * No-op if the shader does not declare a `uTime` uniform (nothing to update),
+     * or in Canvas mode. The engine does NOT call this for you — animation is
+     * opt-in, exactly like re-baking a {@link NoiseTexture2d} with `update(dt)`.
+     * @param {number} seconds - elapsed time in seconds
+     * @returns {ShaderEffect} this effect for chaining
+     * @example
+     * // a shader that scrolls a static seamless noise texture over time
+     * const flow = new me.ShaderEffect(renderer, `
+     *     uniform float uTime;
+     *     vec4 apply(vec4 color, vec2 uv) {
+     *         return texture2D(uSampler, uv + vec2(uTime * 0.05, 0.0));
+     *     }`);
+     * mySprite.shader = flow;
+     * // then in your Stage's update(dt):
+     * flow.setTime(me.timer.getTime() / 1000);
+     */
+    setTime(seconds: number): ShaderEffect;
+    /**
+     * Feed the `noise_uv` builtin's frame rect for the object about to draw:
+     * the source texture dimensions, the destination (object) dimensions, and
+     * the frame's top-left UV origin. Called by the quad batchers per draw;
+     * a no-op unless this effect's fragment actually uses `noise_uv` (the
+     * `ME_*` uniforms only exist — and are only active — then).
+     * @param {number} sourceWidth - source texture width in pixels
+     * @param {number} sourceHeight - source texture height in pixels
+     * @param {number} objectWidth - destination (object) width in pixels
+     * @param {number} objectHeight - destination (object) height in pixels
+     * @param {number} u0 - the frame's left UV coordinate (flip-normalized)
+     * @param {number} v0 - the frame's top UV coordinate (flip-normalized)
+     * @ignore
+     */
+    _setNoiseUVRect(sourceWidth: number, sourceHeight: number, objectWidth: number, objectHeight: number, u0: number, v0: number): void;
+    /**
+     * Apply the wrap mode a `: screen_texture(<repeat>)` annotation asked for
+     * onto the live capture handle. Captures are NPOT (canvas-sized), which
+     * WebGL 1 cannot repeat — warn once and keep the clamp there. The unit is
+     * force-activated first: the batcher's bind may have been skipped as
+     * redundant while the GL active unit points elsewhere.
+     * @ignore
+     */
+    _applyCaptureWrap(batcher: any, glTex: any, entry: any): void;
+    _captureWrapWarned: boolean | undefined;
+    /**
+     * Bind an **extra** texture to a named `sampler2D` uniform in this shader, so
+     * a custom effect can read a *second* texture — a noise map, mask, gradient,
+     * flow/lookup table — besides the sprite/target it post-processes (`uSampler`).
+     * The engine uploads, caches, and re-binds it to a reserved texture unit each
+     * time the effect draws, and points the sampler uniform at it — no raw WebGL
+     * texture-unit juggling.
+     *
+     * Declare the sampler in your fragment (`uniform sampler2D <name>;`) and pass
+     * that name here. Any engine texture works — a {@link Texture2d} asset
+     * (`NoiseTexture2d`, `TextureAtlas`, …) can be passed directly, or a raw
+     * drawable source. No-op in Canvas mode.
+     * @param {string} name - the `sampler2D` uniform name declared in the fragment
+     * @param {Texture2d|HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap} image - the texture: an engine texture asset, or a raw drawable source
+     * @param {"repeat"|"repeat-x"|"repeat-y"|"no-repeat"} [repeat="no-repeat"] - wrap mode; use `"repeat"` for a tiled/scrolled texture (power-of-two size under WebGL 1)
+     * @returns {ShaderEffect} this effect for chaining
+     * @example
+     * // "water": distort the sprite by a static noise texture scrolled over time
+     * const noise = new me.NoiseTexture2d({ width: 256, height: 256, seamless: true });
+     * const water = new me.ShaderEffect(renderer, `
+     *     uniform sampler2D uNoise;
+     *     uniform float uTime;
+     *     vec4 apply(vec4 color, vec2 uv) {
+     *         vec2 flow = texture2D(uNoise, uv + uTime * 0.03).rg - 0.5;
+     *         return texture2D(uSampler, uv + flow * 0.02);
+     *     }`);
+     * water.setTexture("uNoise", noise, "repeat");
+     * waterSprite.shader = water;
+     * // each frame, in your Stage's update(dt):
+     * water.setTime(me.timer.getTime() / 1000);
+     */
+    setTexture(name: string, image: Texture2d | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap, repeat?: "repeat" | "repeat-x" | "repeat-y" | "no-repeat"): ShaderEffect;
+    /**
+     * (Re)bind this effect's extra textures ({@link setTexture}) to reserved GL
+     * texture units and point their sampler uniforms at them. Called by the
+     * renderer right after this effect's shader is bound — for both the
+     * post-effect blit and the single-effect `customShader` sprite path — so the
+     * bindings survive the batcher's rotating color-texture pool.
+     * @param {object} batcher - the active batcher (owns the GL texture units)
+     * @ignore
+     */
+    _prepareTextures(batcher: object): void;
+    _textureOverflowWarned: boolean | undefined;
+    /**
+     * Create an independent copy of this effect, compiled as its own GL
+     * program. Use it when several renderables need the same effect with
+     * *different* uniform values — a single instance has a single set of
+     * uniforms, shared by everything it is assigned to.
+     *
+     * The clone copies the **recipe**: the fragment source, float precision,
+     * every uniform value set so far, and any extra textures bound via
+     * {@link setTexture} (the clone uploads and owns its own GL copies).
+     * It does NOT copy **ownership or lifecycle** state — in particular the
+     * clone's {@link shared} flag is **always reset to `false`**, even when
+     * cloning a shared shader (such as one returned by `loader.getShader()`):
+     * the clone is caller-owned and will be auto-destroyed by the renderable
+     * it is assigned to, exactly like a hand-constructed effect. Set
+     * `shared = true` on the clone yourself if you intend to reuse it across
+     * several renderables.
+     * @returns {ShaderEffect} a new, caller-owned effect (`shared === false`)
+     * @example
+     * // the loader's shader is ONE shared program — one uniform state for all
+     * sprite.shader = loader.getShader("flash");
+     * // the boss needs its own intensity — clone a private, caller-owned copy
+     * boss.shader = loader.getShader("flash").clone();
+     * boss.shader.setUniform("uIntensity", 0.9);
+     */
+    clone(): ShaderEffect;
     /** @ignore */
     bind(): void;
     /** @ignore */
@@ -88,4 +270,5 @@ export default class ShaderEffect {
     destroy(): void;
 }
 import GLShader from "./glshader.js";
+import Texture2d from "../texture/texture2d.ts";
 //# sourceMappingURL=shadereffect.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"shadereffect.d.ts","sourceRoot":"","sources":["../../../src/video/webgl/shadereffect.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAoBC;;;;;;OAMG;IACH,sBANW,aAAa,GAAC,cAAc,gBAC5B,MAAM,cAGN,MAAM,EAkChB;IA1DD;;;;;;OAMG;IACH,SAFU,OAAO,CAED;IAEhB;;;;;;;OAOG;IACH,oBAHU,OAAO,CAGC;IA6BjB,cAAc;IACd,8BAKC;IAQF,eAAe;IACf,uBAOC;IAFA,2CAAyC;IAI1C,eAAe;IACf,2BAQC;IAED;;;;OAIG;IACH,iBAHW,MAAM,SACN,MAAM,GAAC,YAAY,QAM7B;IAED,cAAc;IACd,aAIC;IAED,cAAc;IACd,qCAEC;IAED,cAAc;IACd,iEAIC;IAED,cAAc;IACd,mCAEC;IAED,cAAc;IACd,kBAEC;IAED,cAAc;IACd,oBAEC;IAED,cAAc;IACd,qBAEC;IAED,cAAc;IACd,uBAEC;IAED;;;;OAIG;IACH,gBAiBC;CACD;qBA9LoB,eAAe"}
+{"version":3,"file":"shadereffect.d.ts","sourceRoot":"","sources":["../../../src/video/webgl/shadereffect.js"],"names":[],"mappings":"AAoHA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH;IAiCC;;;;;;OAMG;IACH,sBANW,aAAa,GAAC,cAAc,gBAC5B,MAAM,cAGN,MAAM,EAyFhB;IA9HD;;;;;;OAMG;IACH,SAFU,OAAO,CAED;IAEhB;;;;;;;OAOG;IACH,oBAHU,OAAO,CAGC;IAElB;;;;;;;;;;OAUG;IACH,QAHU,OAAO,CAGF;IAUd;;;;;;OAMG;IACH,eAAyB;IAEzB;;;;;OAKG;IACH,sBAAiC;IACjC,cAAc;IACd,+BAA2B;IAc3B;;;;;OAKG;IACH,wBAHU,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CAGM;IACrD,cAAc;IACd,iCAAmC;IAgBnC,cAAc;IACd,8BAKC;IAGD;;;;;OAKG;IACH,0CAA+B;IAkBhC,eAAe;IACf,uBAkBC;IAbA,2CAAyC;IAe1C,eAAe;IACf,2BAQC;IAED;;;;OAIG;IACH,iBAHW,MAAM,SACN,MAAM,GAAC,YAAY,QAY7B;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,iBAbW,MAAM,GACJ,YAAY,CA+BxB;IAED;;;;;;;;;;;;;OAaG;IACH,6BARW,MAAM,gBACN,MAAM,eACN,MAAM,gBACN,MAAM,MACN,MAAM,MACN,MAAM,QAyChB;IAED;;;;;;;OAOG;IACH,8DAwBC;IApBE,wCAA8B;IAsBjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,iBAnBW,MAAM,SACN,SAAS,GAAC,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,WACxE,QAAQ,GAAC,UAAU,GAAC,UAAU,GAAC,WAAW,GACxC,YAAY,CA8DxB;IAED;;;;;;;;OAQG;IACH,0BAHW,MAAM,QAuFhB;IA3DI,4CAAkC;IA6DvC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,SARa,YAAY,CA0CxB;IAED,cAAc;IACd,aAIC;IAED,cAAc;IACd,qCAEC;IAED,cAAc;IACd,iEAIC;IAED,cAAc;IACd,mCAEC;IAED,cAAc;IACd,kBAEC;IAED,cAAc;IACd,oBAEC;IAED,cAAc;IACd,qBAEC;IAED,cAAc;IACd,uBAEC;IAED;;;;OAIG;IACH,gBA4BC;CACD;qBAvwBoB,eAAe;sBADd,yBAAyB"}