melonjs 19.8.0 → 19.9.1

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,CAyExB;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;qBAlxBoB,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;
     /**
@@ -453,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";
@@ -462,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.8.0",
+	"version": "19.9.1",
 	"description": "melonJS Game Engine",
 	"homepage": "http://www.melonjs.org/",
 	"type": "module",
@@ -59,19 +59,19 @@
 		"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.1",
+		"type-fest": "^5.8.0",
+		"typedoc": "^0.28.20",
 		"typescript": "^6.0.2",
-		"vite": "8.0.16",
-		"vite-plugin-glsl": "^1.6.0"
+		"vite": "8.1.5",
+		"vite-plugin-glsl": "^1.6.1"
 	},
 	"scripts": {
 		"dev": "concurrently --raw \"pnpm build:watch\" \"pnpm tsc:watch\" \"pnpm doc:watch\"",