melonjs 19.7.1 → 19.9.0

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

@@ -1,7 +1,7 @@
 /**
  * A shader effect that sweeps a bright highlight band across the sprite —
  * the classic "shine" pass commonly used for coins, gems, polished metal,
- * and hover-highlighted UI elements. Similar to pixi-filters' ShineFilter.
+ * and hover-highlighted UI elements.
  *
  * Set `bands` > 1 to tile the sweep into N parallel glints (useful for the
  * "etched grooves" look of a coin's rim). An optional subtle brightness
@@ -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/lighting/pack3d.d.ts

@@ -0,0 +1,32 @@
+import type { Light3d } from "../../../lighting/light3d.ts";
+/**
+ * Uniform-ready packing of the active 3D lights for the mesh-lit shader.
+ * @ignore
+ */
+export interface PackedMeshLighting {
+    /** number of active directional lights, clamped to `MAX_LIGHTS`. */
+    count: number;
+    /** `MAX_LIGHTS × 3` surface→light directions (already negated, normalized). */
+    directions: Float32Array;
+    /** `MAX_LIGHTS × 3` directional light colors premultiplied by intensity. */
+    colors: Float32Array;
+    /** the summed ambient color (RGB, 0..1+). */
+    ambient: Float32Array;
+}
+/**
+ * Pack an iterable of {@link Light3d} (e.g. the active `Stage`'s 3D-light set)
+ * into the uniform arrays the mesh-lit shader reads:
+ * - **directional** lights contribute a surface→light direction (negated travel
+ *   direction, normalized) + a color premultiplied by intensity, up to
+ *   `MAX_LIGHTS`. Re-normalized here so a direction mutated at runtime without
+ *   re-normalizing still shades correctly.
+ * - **ambient** lights are summed into a single flat ambient color.
+ *
+ * Other types (`"point"`) are skipped — not shaded yet. The same buffers are
+ * returned each call (overwritten in place).
+ * @param lights - iterable of lights, or `null`/`undefined` (treated as empty)
+ * @returns the packed lighting (reused instance)
+ * @ignore
+ */
+export declare function packMeshLights(lights: Iterable<Light3d> | null | undefined): PackedMeshLighting;
+//# sourceMappingURL=pack3d.d.ts.map

package/build/video/webgl/lighting/pack3d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack3d.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/lighting/pack3d.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAC;AAG5D;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IAClC,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAC;IACd,+EAA+E;IAC/E,UAAU,EAAE,YAAY,CAAC;IACzB,4EAA4E;IAC5E,MAAM,EAAE,YAAY,CAAC;IACrB,6CAA6C;IAC7C,OAAO,EAAE,YAAY,CAAC;CACtB;AAcD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAC7B,MAAM,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,GAC1C,kBAAkB,CAuCpB"}

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

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

@@ -21,7 +21,8 @@ export default class WebGLRenderer extends Renderer {
      * @type {Matrix3d}
      * @ignore
      */
-    _savedEffectProjection: Matrix3d;
+    _effectProjectionStack: Matrix3d;
+    _effectPassDepth: number;
     /**
      * sets or returns the shape used to join two line segments where they meet.
      * Out of the three possible values for this property: "round", "bevel", and "miter", only "round" is supported for now in WebGL
@@ -57,6 +58,7 @@ export default class WebGLRenderer extends Renderer {
     _clipAABB: Bounds;
     _polyVerts: any[];
     _currentGradient: any;
+    _maskVisibleRef: number;
     /**
      * The current transformation matrix used for transformations on the overall scene
      * (alias to renderState.currentTransform for backward compatibility)
@@ -73,6 +75,15 @@ export default class WebGLRenderer extends Renderer {
      * @type {WebGLProgram}
      */
     currentProgram: WebGLProgram;
+    /**
+     * the GL texture unit currently active (`gl.activeTexture`) — global
+     * GL state, so tracked once per renderer and shared by every batcher
+     * through the `MaterialBatcher.currentTextureUnit` accessor. `-1`
+     * forces the next bind to re-issue `gl.activeTexture`.
+     * @type {number}
+     * @ignore
+     */
+    _activeTextureUnit: number;
     /**
      * The list of active batchers
      * @type {Map<Batcher>}
@@ -88,6 +99,7 @@ export default class WebGLRenderer extends Renderer {
     get WebGLVersion(): number;
     _lightShader: RadialGradientEffect | undefined;
     _lightAtlas: TextureAtlas | undefined;
+    _frameTexture: FrameTexture | undefined;
     _orthogonalTMXGPURenderer: OrthogonalTMXLayerGPURenderer | null | undefined;
     /**
      * Draw a TMX tile layer through whichever path the layer's `renderMode`
@@ -149,6 +161,32 @@ export default class WebGLRenderer extends Renderer {
      * @ignore
      */
     _getLightAtlas(): TextureAtlas;
+    /**
+     * The renderer-owned shared frame-capture slot, minted lazily so it has a
+     * stable identity from the moment an effect is constructed — before the
+     * first actual capture fills it (`glTexture` stays `null` until then, and
+     * the live-sampler bind path skips unfilled captures). `ShaderEffect`
+     * wires `: screen_texture` annotated samplers to this object.
+     * @returns {FrameTexture} the shared capture slot
+     * @ignore
+     */
+    getSharedFrameTexture(): FrameTexture;
+    /**
+     * Forget the cached binding for GL texture `unit` on every batcher (except
+     * `except`). Call this whenever a texture is bound to a unit **directly** —
+     * bypassing the shared texture cache and its `GPU_TEXTURE_CACHE_RESET`
+     * coordination — as {@link WebGLRenderer#toFrameTexture}'s capture copy and
+     * {@link ShaderEffect#_prepareTextures}'s reserved extra samplers both do.
+     * Those binds land on the TOP of the unit range, which overlaps the lit quad
+     * batcher's normal-map units; without invalidation a later lit draw would
+     * assume its normal map is still resident there and skip re-binding it,
+     * sampling the directly-bound texture as a normal map (wrong lighting).
+     * @param {number} unit - the GL texture unit that was clobbered
+     * @param {Batcher} [except] - a batcher to skip (the one that just bound the
+     *   texture — its own cache is already accurate)
+     * @ignore
+     */
+    invalidateTextureUnit(unit: number, except?: Batcher): void;
     /** @ignore */
     endPostEffect(renderable: any): void;
     /**
@@ -316,6 +354,24 @@ export default class WebGLRenderer extends Renderer {
      */
     setBlendMode(mode?: string, premultipliedAlpha?: boolean): string;
     currentPremultipliedAlpha: any;
+    /**
+     * Map the backend-neutral default filter mode
+     * ({@link Renderer#getDefaultTextureFilter}) to the GL enum
+     * (`gl.LINEAR` / `gl.NEAREST`) used for textures that don't carry their own
+     * `texture.filter`. The neutral resolver lives on the base renderer so a
+     * future WebGPU backend reuses it and maps to `GPUFilterMode` instead.
+     * @returns {number} `gl.LINEAR` or `gl.NEAREST`
+     * @ignore
+     */
+    _glTextureFilter(): number;
+    /**
+     * Re-apply a min/mag filter to every currently-bound texture across all
+     * batchers (see https://github.com/melonjs/melonJS/issues/1279). Shared by
+     * {@link WebGLRenderer#setAntiAlias} and {@link WebGLRenderer#setTextureFilter}.
+     * @param {number} filter - `gl.LINEAR` or `gl.NEAREST`
+     * @ignore
+     */
+    _reapplyTextureFilter(filter: number): void;
     /**
      * Return the global alpha
      * @returns {number} global alpha value
@@ -435,6 +491,7 @@ export default class WebGLRenderer extends Renderer {
      * @param {boolean} [invert=false] - either the given shape should define what is visible (default) or the opposite
      */
     setMask(mask?: Rect | RoundRect | Polygon | Line | Ellipse, invert?: boolean): void;
+    _maskDepthWarned: boolean | undefined;
     #private;
 }
 import Renderer from "./../renderer.js";
@@ -444,6 +501,7 @@ import type { Batcher } from "./batchers/batcher.js";
 import TextureCache from "./../texture/cache.js";
 import RadialGradientEffect from "./effects/radialGradient.js";
 import { TextureAtlas } from "./../texture/atlas.js";
+import { FrameTexture } from "./../texture/frametexture.js";
 import OrthogonalTMXLayerGPURenderer from "./renderers/tmxlayer/orthogonal.js";
 import { Color } from "./../../math/color.ts";
 import type { Rect } from "./../../geometries/rectangle.ts";

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

@@ -1 +1 @@
-{"version":3,"file":"webgl_renderer.d.ts","sourceRoot":"","sources":["../../../src/video/webgl/webgl_renderer.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"webgl_renderer.d.ts","sourceRoot":"","sources":["../../../src/video/webgl/webgl_renderer.js"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "melonjs",
-	"version": "19.7.1",
+	"version": "19.9.0",
 	"description": "melonJS Game Engine",
 	"homepage": "http://www.melonjs.org/",
 	"type": "module",
@@ -59,16 +59,16 @@
 		"howler": "2.2.4"
 	},
 	"devDependencies": {
-		"@types/howler": "^2.2.12",
+		"@types/howler": "^2.2.13",
 		"@types/node": "^25.6.0",
 		"concurrently": "^9.2.1",
 		"del-cli": "^7.0.0",
 		"esbuild": "^0.27.3",
 		"serve": "^14.2.6",
 		"tsconfig": "workspace:^",
-		"tsx": "^4.21.0",
-		"type-fest": "^5.5.0",
-		"typedoc": "^0.28.19",
+		"tsx": "^4.23.0",
+		"type-fest": "^5.8.0",
+		"typedoc": "^0.28.20",
 		"typescript": "^6.0.2",
 		"vite": "8.0.16",
 		"vite-plugin-glsl": "^1.6.0"

package/build/renderable/light2d.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"light2d.d.ts","sourceRoot":"","sources":["../../src/renderable/light2d.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,eAPW,MAAM,KACN,MAAM,WACN,MAAM,YACN,MAAM,UACN,KAAK,GAAC,MAAM,cACZ,MAAM,EAiGhB;IAlFA;;;;OAIG;IACH,OAHU,KAAK,CAG6B;IAE5C;;;OAGG;IACH,SAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,SAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,WAHU,MAAM,CAGU;IAa1B,cAAc;IACd,qBAKC;IAKD;;;;;;;;;;;;;OAaG;IACH,kBAHU,OAAO,CAGY;IAE7B;;;;;;;;;;;;;;;;OAgBG;IACH,aAFU,MAAM,CAEqC;IAiCtD;;;;;;;;;;;;;;;;OAgBG;IACH,kBAHW,MAAM,YACN,MAAM,QAMhB;IAED;;;;;OAKG;IACH,kBAFa,OAAO,CAOnB;IAED;;;OAGG;IACH,UAFa,OAAO,CAInB;IAED;;;OAGG;IACH,kBAFW,QAAQ,QAKlB;IAED;;;;;;;;OAQG;IACH,eAFW,QAAQ,QAOlB;IAED;;;;;;OAMG;IACH,wBAKC;IAED;;;;OAIG;IACH,0BAKC;IAED;;;OAGG;IACH,gBAQC;CACD;uBArSsB,iBAAiB;2BAIhB,oBAAoB;6BAClB,4BAA4B;0BAC7B,wBAAwB"}