melonjs 19.3.0 → 19.5.0

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

@@ -0,0 +1,113 @@
+/**
+ * A texture data source that knows how to upload itself to a WebGL
+ * texture. Subclasses provide the actual upload logic for their kind
+ * of source (raw buffer, image, compressed data, etc.).
+ *
+ * Resources flow through the same `TextureCache` / batcher machinery
+ * as image-backed `TextureAtlas` instances: they expose the minimal
+ * shape (`sources`, `activeAtlas`, `getTexture()`, plus `width` /
+ * `height` / `premultipliedAlpha` / `repeat` / `filter`) the cache
+ * uses for unit allocation and the batcher uses for `boundTextures`
+ * bookkeeping. The cache therefore owns every `gl.bindTexture` call,
+ * which keeps the JS-side binding state in lockstep with the actual
+ * GL state across all texture kinds — image atlases included.
+ *
+ * Subclasses MUST implement `upload(gl, target)`. The framework calls
+ * it once per texture on first use (and again on forced re-upload via
+ * `batcher.uploadTexture(resource, w, h, true)`).
+ *
+ * @category Rendering
+ */
+export class TextureResource {
+    /**
+     * @param {object} options
+     * @param {number} options.width   - pixel width of the texture
+     * @param {number} options.height  - pixel height of the texture
+     * @param {boolean} [options.premultipliedAlpha=false]
+     * @param {string}  [options.repeat="no-repeat"] - "no-repeat" | "repeat" | "repeat-x" | "repeat-y"
+     * @param {number}  [options.filter] - `gl.NEAREST` or `gl.LINEAR`; when
+     *   omitted the batcher falls back to the renderer's `antiAlias` setting
+     */
+    constructor({ width, height, premultipliedAlpha, repeat, filter, }?: {
+        width: number;
+        height: number;
+        premultipliedAlpha?: boolean | undefined;
+        repeat?: string | undefined;
+        filter?: number | undefined;
+    });
+    /** @type {number} */
+    width: number;
+    /** @type {number} */
+    height: number;
+    /** @type {boolean} */
+    premultipliedAlpha: boolean;
+    /** @type {string} */
+    repeat: string;
+    /** @type {number|undefined} */
+    filter: number | undefined;
+    sources: Map<string, this>;
+    activeAtlas: string;
+    /**
+     * Returns the upload "source" the batcher hands to `createTexture2D`.
+     * For a resource this is the resource itself — `createTexture2D`
+     * dispatches to `resource.upload(gl, target)`.
+     * @ignore
+     */
+    getTexture(): this;
+    /**
+     * Issue the `gl.texImage2D` (or equivalent) call that uploads this
+     * resource's data into the currently-bound `TEXTURE_2D` slot.
+     * Subclasses MUST override.
+     * @abstract
+     * @param {WebGLRenderingContext|WebGL2RenderingContext} gl
+     * @param {number} target - `gl.TEXTURE_2D` (or future cube-map targets)
+     */
+    upload(gl: WebGLRenderingContext | WebGL2RenderingContext, target: number): void;
+}
+/**
+ * A texture sourced from a raw byte buffer. Used for synthesized
+ * textures (TMX layer GID index, font atlases, color LUTs, signed-
+ * distance fields, palette tables, etc.) — any case where the texture
+ * data isn't an image file.
+ *
+ * The buffer is uploaded as-is; the resource's `premultipliedAlpha`
+ * flag is applied at upload time so a raw-data texture (typical:
+ * `premultipliedAlpha = false`) doesn't get its RGB wiped by the
+ * driver when the alpha channel is zero.
+ *
+ * @category Rendering
+ */
+export class BufferTextureResource extends TextureResource {
+    /**
+     * @param {ArrayBufferView} data - the pixel data; size must be
+     *   `width * height * 4` bytes for the default RGBA / UNSIGNED_BYTE
+     *   format
+     * @param {object} options
+     * @param {number}  options.width
+     * @param {number}  options.height
+     * @param {boolean} [options.premultipliedAlpha=false]
+     * @param {string}  [options.repeat="no-repeat"]
+     * @param {number}  [options.filter]
+     * @param {"rgba8"|"rgba8ui"} [options.format="rgba8"] - storage format.
+     *   `"rgba8"` (default): normalized RGBA, sampled via `sampler2D` /
+     *   `texture()`. `"rgba8ui"`: unsigned-integer RGBA, sampled via
+     *   `usampler2D` / `texelFetch()` — requires WebGL2. Use the integer
+     *   form for raw-data lookups (GID tables, palette indices, etc.) to
+     *   skip the float-decode round trip and gain exact integer reads.
+     */
+    constructor(data: ArrayBufferView, options: {
+        width: number;
+        height: number;
+        premultipliedAlpha?: boolean | undefined;
+        repeat?: string | undefined;
+        filter?: number | undefined;
+        format?: "rgba8" | "rgba8ui" | undefined;
+    });
+    /** @type {ArrayBufferView} */
+    data: ArrayBufferView;
+    /** @type {string} */
+    format: string;
+    /** @ignore */
+    upload(gl: any, target: any): void;
+}
+//# sourceMappingURL=resource.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../../../src/video/texture/resource.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IACC;;;;;;;;OAQG;IACH,qEAPG;QAAwB,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACY,kBAAkB;QAClB,MAAM;QACN,MAAM;KAElC,EAsBA;IAdA,qBAAqB;IACrB,OADW,MAAM,CACC;IAClB,qBAAqB;IACrB,QADW,MAAM,CACG;IACpB,sBAAsB;IACtB,oBADW,OAAO,CAC0B;IAC5C,qBAAqB;IACrB,QADW,MAAM,CACG;IACpB,+BAA+B;IAC/B,QADW,MAAM,GAAC,SAAS,CACP;IAGpB,2BAA2C;IAC3C,oBAA4B;IAG7B;;;;;OAKG;IACH,mBAEC;IAED;;;;;;;OAOG;IAEH,WAJW,qBAAqB,GAAC,sBAAsB,UAC5C,MAAM,QAKhB;CACD;AAED;;;;;;;;;;;;GAYG;AACH;IACC;;;;;;;;;;;;;;;;OAgBG;IACH,kBAhBW,eAAe,WAIvB;QAAyB,KAAK,EAAtB,MAAM;QACW,MAAM,EAAvB,MAAM;QACY,kBAAkB;QAClB,MAAM;QACN,MAAM;QACI,MAAM;KAM5C,EAOA;IAJA,8BAA8B;IAC9B,MADW,eAAe,CACV;IAChB,qBAAqB;IACrB,QADW,MAAM,CACsB;IAGxC,cAAc;IACd,mCAoCC;CACD"}

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

@@ -57,8 +57,15 @@ export class MaterialBatcher extends Batcher {
     unbindTexture2D(texture?: WebGLTexture, unit?: number): number;
     /**
      * @ignore
+     * @param {TextureAtlas|TextureResource} texture
+     * @param {number} [w] - ignored when the source has its own `width` (the
+     *   common case); kept for the legacy signature where callers passed a
+     *   destination size. Forwarded only as a last-resort default.
+     * @param {number} [h] - same as `w`.
+     * @param {boolean} [force=false]
+     * @param {boolean} [flush=true]
      */
-    uploadTexture(texture: any, w: any, h: any, force?: boolean, flush?: boolean): any;
+    uploadTexture(texture: TextureAtlas | TextureResource, w?: number, h?: number, force?: boolean, flush?: boolean): 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":"AAGA;;;GAGG;AAEH;;;;GAIG;AACH;IAQE;;;OAGG;IACH,wBAA4B;IAE5B;;;OAGG;IACH,iCAAuB;IA0BxB;;;;;;;;;;;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,CAmHxB;IAED;;;OAGG;IACH,yBAFW,YAAY,GAAC,YAAY,QAiBnC;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;;OAEG;IACH,mFAsBC;CACD;wBA7RuB,cAAc;kCAIP,0BAA0B"}
+{"version":3,"file":"material_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/material_batcher.js"],"names":[],"mappings":"AAGA;;;GAGG;AAEH;;;;GAIG;AACH;IAQE;;;OAGG;IACH,wBAA4B;IAE5B;;;OAGG;IACH,iCAAuB;IA0BxB;;;;;;;;;;;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,CAqJxB;IAED;;;OAGG;IACH,yBAFW,YAAY,GAAC,YAAY,QAiBnC;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;wBA/VuB,cAAc;kCAIP,0BAA0B"}

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

@@ -0,0 +1,87 @@
+/**
+ * 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.
+ *
+ * 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
+ * pulse can be layered on top via `pulseDepth` — set to 0 to disable.
+ *
+ * The `time` uniform must be updated each frame for the animation.
+ * @category Effects
+ * @see {@link Renderable.shader} for usage
+ * @example
+ * // single diagonal sweep — classic "button shine"
+ * const shine = new ShineEffect(renderer, {
+ *     color: [1.0, 0.95, 0.7],
+ *     speed: 0.5,
+ *     width: 0.18,
+ *     angle: 0.5,
+ * });
+ *
+ * // gold coin with ~14 parallel glints and a subtle brightness pulse
+ * const coinShine = new ShineEffect(renderer, {
+ *     color: [1.0, 0.95, 0.7],
+ *     bands: 14.5,
+ *     width: 0.15,
+ *     intensity: 0.4,
+ *     speed: 0.8,
+ *     pulseDepth: 0.08,
+ * });
+ *
+ * mySprite.addPostEffect(coinShine);
+ *
+ * // update each frame
+ * coinShine.setTime(timer.getTime() / 1000);
+ */
+export default class ShineEffect extends ShaderEffect {
+    /**
+     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {object} [options] - effect options
+     * @param {number[]} [options.color=[1.0, 1.0, 1.0]] - shine color as [r, g, b] (0.0–1.0)
+     * @param {number} [options.speed=0.5] - sweeps per second
+     * @param {number} [options.width=0.15] - glint half-width as a fraction of one tile (0.0–1.0)
+     * @param {number} [options.intensity=0.5] - maximum highlight strength
+     * @param {number} [options.angle=0.5] - sweep direction in radians (0 = horizontal L→R, π/2 = vertical T→B)
+     * @param {number} [options.bands=1.0] - number of parallel glints (1 = single shine; ~14.5 mimics a coin's etched-rim look)
+     * @param {number} [options.pulseDepth=0.0] - subtle base-brightness pulse amplitude (0 disables the pulse)
+     * @param {number} [options.pulseSpeed=3.0] - pulse oscillation rate (radians/second)
+     */
+    constructor(renderer: import("../webgl_renderer.js").default, options?: {
+        color?: number[] | undefined;
+        speed?: number | undefined;
+        width?: number | undefined;
+        intensity?: number | undefined;
+        angle?: number | undefined;
+        bands?: number | undefined;
+        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)
+     */
+    setColor(color: number[]): void;
+    /**
+     * set the sweep speed
+     * @param {number} value - sweeps per second
+     */
+    setSpeed(value: number): void;
+    /**
+     * set the highlight intensity
+     * @param {number} value - maximum highlight strength
+     */
+    setIntensity(value: number): void;
+    /**
+     * set the number of parallel glints
+     * @param {number} value - 1 for a single shine, >1 for tiled stripes
+     */
+    setBands(value: number): void;
+}
+import ShaderEffect from "../shadereffect.js";
+//# sourceMappingURL=shine.d.ts.map

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

@@ -0,0 +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"}

package/build/video/webgl/renderers/tmxlayer/orthogonal.d.ts

@@ -0,0 +1,108 @@
+/**
+ * GPU-accelerated renderer for orthogonal TMX tile layers (WebGL2). Draws
+ * the visible region of a layer as one screen-aligned quad per tileset
+ * referenced by the layer — the fragment shader samples a per-layer GID
+ * index texture and the tileset atlas, eliminating the per-tile draw
+ * loop. The visible rect, GID range, tile size, opacity, and tint are
+ * pushed as uniforms; the index texture is uploaded once at activation
+ * and re-uploaded only when `layer.dataVersion` changes (mutations from
+ * `setTile`/`clearTile`).
+ *
+ * The per-layer index texture is a `BufferTextureResource` flowing
+ * through the standard `TextureCache` / batcher path — same lane as
+ * every other texture in the engine. Dynamic unit allocation, correct
+ * `boundTextures` bookkeeping, and per-resource premultiplied-alpha /
+ * filter all come for free; nothing here pokes `gl.bindTexture` or
+ * `gl.activeTexture` directly.
+ *
+ * Cache lifecycle: one `BufferTextureResource` per `TMXLayer`. Tile
+ * layers don't come and go individually — they only churn on game reset
+ * — so the cache is freed in bulk via `reset()`, called from
+ * `WebGLRenderer.reset()` (which the `GAME_RESET` event already
+ * triggers).
+ *
+ * @ignore
+ */
+export default class OrthogonalTMXLayerGPURenderer {
+    /**
+     * @param {WebGLRenderer} renderer - the WebGL renderer instance
+     */
+    constructor(renderer: WebGLRenderer);
+    renderer: WebGLRenderer;
+    gl: WebGLRenderingContext;
+    shader: GLShader;
+    resources: Map<any, any>;
+    animLookups: Map<any, any>;
+    _v2: Float32Array<ArrayBuffer>;
+    _v4: Float32Array<ArrayBuffer>;
+    /**
+     * Free every cached per-layer index texture and empty the local
+     * resource map. Called from `WebGLRenderer.reset()` (which
+     * `GAME_RESET` triggers) so each level transition starts clean.
+     * @ignore
+     */
+    reset(): void;
+    /**
+     * Write a `vec2` uniform without allocating a fresh Float32Array per
+     * call. Both components flow into the shared `_v2` scratch buffer,
+     * which `setUniform` reads synchronously and forwards to
+     * `gl.uniform2fv` — so reusing the buffer across calls is safe.
+     * @param {string} name
+     * @param {number} x
+     * @param {number} y
+     * @private
+     */
+    private _setV2;
+    /**
+     * `vec4` counterpart to {@link _setV2}.
+     * @param {string} name
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} w
+     * @private
+     */
+    private _setV4;
+    /**
+     * Get-or-create the per-tileset animation-lookup entry. Returns
+     * `undefined` for tilesets that have no animated tiles (the shader's
+     * `uAnimEnabled` uniform is then set to 0 and the lookup texture is
+     * not bound).
+     *
+     * The entry holds a `tileCount × 1` RGBA8 `BufferTextureResource`
+     * where texel `localId` encodes the CURRENT frame's local id as
+     * `R = lo byte, G = hi byte` (same encoding as the GID index
+     * texture). Each call walks `tileset.animations` and rewrites
+     * dirty texels — `tileset.update(dt)` (driven by the layer) advances
+     * `anim.cur.tileid` independently of this renderer.
+     *
+     * @param {object} tileset
+     * @param {number} tileCount - tiles in the tileset's atlas grid
+     *   (`atlasCols * atlasRows`)
+     * @returns {{resource: BufferTextureResource, data: Uint8Array,
+     *   tileCount: number, dirty: boolean}|undefined}
+     */
+    _getOrUpdateAnimLookup(tileset: object, tileCount: number): {
+        resource: BufferTextureResource;
+        data: Uint8Array;
+        tileCount: number;
+        dirty: boolean;
+    } | undefined;
+    /**
+     * Get-or-create the per-layer index `BufferTextureResource`.
+     * @param {TMXLayer} layer
+     * @returns {BufferTextureResource}
+     */
+    _getResource(layer: TMXLayer): BufferTextureResource;
+    /**
+     * Draw an orthogonal TMX layer through the shader path.
+     * @param {TMXLayer} layer
+     * @param {object} rect - the visible viewport rect (world coords)
+     */
+    draw(layer: TMXLayer, rect: object): void;
+}
+import type { default as WebGLRenderer } from "../../webgl_renderer.js";
+import GLShader from "../../glshader.js";
+import { BufferTextureResource } from "../../../texture/resource.js";
+import type { default as TMXLayer } from "../../../../level/tiled/TMXLayer.js";
+//# sourceMappingURL=orthogonal.d.ts.map

package/build/video/webgl/renderers/tmxlayer/orthogonal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orthogonal.d.ts","sourceRoot":"","sources":["../../../../../src/video/webgl/renderers/tmxlayer/orthogonal.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IACC;;OAEG;IACH,sBAFW,aAAa,EAkCvB;IA/BA,wBAAwB;IACxB,0BAAqB;IAUrB,iBAKC;IAMD,yBAA0B;IAI1B,2BAA4B;IAG5B,+BAA8B;IAC9B,+BAA8B;IAG/B;;;;;OAKG;IACH,cAyBC;IAED;;;;;;;;;OASG;IACH,eAIC;IAED;;;;;;;;OAQG;IACH,eAMC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,gCANW,MAAM,aACN,MAAM,GAEJ;QAAC,QAAQ,EAAE,qBAAqB,CAAC;QAAC,IAAI,EAAE,UAAU,CAAC;QAC3D,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAC,GAAC,SAAS,CA+ChD;IAED;;;;OAIG;IACH,oBAHW,QAAQ,GACN,qBAAqB,CA6BjC;IAED;;;;OAIG;IACH,YAHW,QAAQ,QACR,MAAM,QA0JhB;CACD;8CA1Y4C,yBAAyB;qBAPjD,mBAAmB;sCADF,8BAA8B;yCAO5B,qCAAqC"}

package/build/video/webgl/utils/attributes.d.ts

@@ -1,4 +1,11 @@
 /**
+ * Pick out every vertex attribute name from a shader source, regardless of
+ * GLSL version. GLSL 1.00 marks attributes with the `attribute` storage
+ * qualifier; GLSL ES 3.00 reuses `in` at file scope for the same purpose
+ * (and `in` inside function parameter lists, which we exclude by requiring
+ * the qualifier to start at the beginning of a line). Skipping the 3.00
+ * form leaves the shader with no bound vertex data and the rasterizer
+ * silently degenerates every triangle.
  * @ignore
  */
 export function extractAttributes(gl: any, shader: any): {};

package/build/video/webgl/utils/attributes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/attributes.js"],"names":[],"mappings":"AAAA;;GAEG;AACH,4DAYC"}
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/attributes.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,4DAmBC"}

package/build/video/webgl/utils/precision.d.ts

@@ -1,5 +1,5 @@
 /**
- * set precision for the fiven shader source
+ * set precision for the given shader source
  * won't do anything if the precision is already specified
  * @ignore
  */

package/build/video/webgl/utils/precision.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"precision.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/precision.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,4DAKC;AAED;;;;;;GAMG;AACH,0CAJW,qBAAqB,kBACrB,OAAO,GACL,MAAM,CAoBlB"}
+{"version":3,"file":"precision.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/precision.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,4DA+BC;AAED;;;;;;GAMG;AACH,0CAJW,qBAAqB,kBACrB,OAAO,GACL,MAAM,CAoBlB"}

package/build/video/webgl/utils/uniforms.d.ts

@@ -1,4 +1,17 @@
 /**
+ * Build the `uniforms` proxy object for a compiled shader program.
+ *
+ * Each detected uniform gets a defineProperty getter (returns its
+ * `WebGLUniformLocation`) and a setter that pushes the value to GL. The
+ * setter caches the last value it sent and skips the underlying
+ * `gl.uniform*` call when the incoming value matches — uniform writes are
+ * cheap individually, but a typical per-frame draw pass sets a dozen of
+ * them per shader, and most are layer-lifetime constants (`uMapSize`,
+ * `uCellSize`, `uOpacity`, projection matrix on idle frames, etc.).
+ *
+ * Cache scope is per-shader: each `GLShader` calls `extractUniforms` once
+ * and gets its own closure-captured `cache` map, so caches don't leak
+ * across programs.
  * @ignore
  */
 export function extractUniforms(gl: any, shader: any): {};

package/build/video/webgl/utils/uniforms.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uniforms.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/uniforms.js"],"names":[],"mappings":"AAuBA;;GAEG;AACH,0DAuDC"}
+{"version":3,"file":"uniforms.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/uniforms.js"],"names":[],"mappings":"AA0FA;;;;;;;;;;;;;;;GAeG;AACH,0DAmEC"}

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

@@ -22,12 +22,6 @@ export default class WebGLRenderer extends Renderer {
      * @ignore
      */
     _savedEffectProjection: Matrix3d;
-    /**
-     * sets or returns the thickness of lines for shape drawing
-     * @type {number}
-     * @default 1
-     */
-    lineWidth: 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
@@ -94,6 +88,24 @@ export default class WebGLRenderer extends Renderer {
     get WebGLVersion(): number;
     _lightShader: RadialGradientEffect | undefined;
     _lightAtlas: TextureAtlas | undefined;
+    _orthogonalTMXGPURenderer: OrthogonalTMXLayerGPURenderer | null | undefined;
+    /**
+     * Draw a TMX tile layer through whichever path the layer's `renderMode`
+     * resolves to. WebGL2-eligible layers (`renderMode === "shader"`) take
+     * the procedural shader path — one quad per tileset, GID lookup in a
+     * per-layer data texture. All other layers fall through to the base
+     * `Renderer.drawTileLayer` (preRender blit or per-tile loop).
+     * @param {object} layer - the TMXLayer to draw
+     * @param {object} rect - the visible region in world coords
+     */
+    drawTileLayer(layer: object, rect: object): void;
+    /**
+     * Lazy-init the orientation-specific GPU tilemap renderer.
+     * @param {string} orientation
+     * @returns {object|undefined}
+     * @ignore
+     */
+    _getTMXGPURendererFor(orientation: string): object | undefined;
     /**
      * add a new batcher to this renderer
      * @param {Batcher} batcher - a batcher instance
@@ -304,58 +316,6 @@ export default class WebGLRenderer extends Renderer {
      */
     setBlendMode(mode?: string, premultipliedAlpha?: boolean): string;
     currentPremultipliedAlpha: any;
-    /**
-     * restores the most recently saved renderer state by popping the top entry in the drawing state stack
-     * @example
-     * // Save the current state
-     * renderer.save();
-     *
-     * // apply a transform and draw a rect
-     * renderer.tranform(matrix);
-     * renderer.fillRect(10, 10, 100, 100);
-     *
-     * // Restore to the state saved by the most recent call to save()
-     * renderer.restore();
-     */
-    restore(): void;
-    /**
-     * saves the entire state of the renderer by pushing the current state onto a stack.
-     * @example
-     * // Save the current state
-     * renderer.save();
-     *
-     * // apply a transform and draw a rect
-     * renderer.tranform(matrix);
-     * renderer.fillRect(10, 10, 100, 100);
-     *
-     * // Restore to the state saved by the most recent call to save()
-     * renderer.restore();
-     */
-    save(): void;
-    /**
-     * adds a rotation to the transformation matrix.
-     * @param {number} angle - the rotation angle, clockwise in radians
-     * @example
-     * // Rotated rectangle
-     * renderer.rotate((45 * Math.PI) / 180);
-     * renderer.setColor("red");
-     * renderer.fillRect(10, 10, 100, 100);
-     *
-     * // Reset transformation matrix to the identity matrix
-     * renderer.setTransform(1, 0, 0, 1, 0, 0);
-     */
-    rotate(angle: number): void;
-    /**
-     * adds a scaling transformation to the renderer units horizontally and/or vertically
-     * @param {number} x - Scaling factor in the horizontal direction. A negative value flips pixels across the vertical axis. A value of 1 results in no horizontal scaling.
-     * @param {number} y - Scaling factor in the vertical direction. A negative value flips pixels across the horizontal axis. A value of 1 results in no vertical scaling
-     */
-    scale(x: number, y: number): void;
-    /**
-     * Set the global alpha
-     * @param {number} alpha - 0.0 to 1.0 values accepted.
-     */
-    setGlobalAlpha(alpha: number): void;
     /**
      * Return the global alpha
      * @returns {number} global alpha value
@@ -382,31 +342,6 @@ export default class WebGLRenderer extends Renderer {
      * @param {boolean} [antiClockwise=false] - draw arc anti-clockwise
      */
     fillArc(x: number, y: number, radius: number, start: number, end: number, antiClockwise?: boolean): void;
-    /**
-     * Stroke an ellipse at the specified coordinates with given radius
-     * @param {number} x - ellipse center point x-axis
-     * @param {number} y - ellipse center point y-axis
-     * @param {number} w - horizontal radius of the ellipse
-     * @param {number} h - vertical radius of the ellipse
-     * @param {boolean} [fill=false] - also fill the shape with the current color if true
-     */
-    strokeEllipse(x: number, y: number, w: number, h: number, fill?: boolean): void;
-    /**
-     * Fill an ellipse at the specified coordinates with given radius
-     * @param {number} x - ellipse center point x-axis
-     * @param {number} y - ellipse center point y-axis
-     * @param {number} w - horizontal radius of the ellipse
-     * @param {number} h - vertical radius of the ellipse
-     */
-    fillEllipse(x: number, y: number, w: number, h: number): void;
-    /**
-     * Stroke a line of the given two points
-     * @param {number} startX - the start x coordinate
-     * @param {number} startY - the start y coordinate
-     * @param {number} endX - the end x coordinate
-     * @param {number} endY - the end y coordinate
-     */
-    strokeLine(startX: number, startY: number, endX: number, endY: number): void;
     /**
      * Fill a line of the given two points
      * @param {number} startX - the start x coordinate
@@ -426,23 +361,6 @@ export default class WebGLRenderer extends Renderer {
      * @param {Polygon} poly - the shape to draw
      */
     fillPolygon(poly: Polygon): void;
-    /**
-     * Draw a stroke rectangle at the specified coordinates
-     * @param {number} x - x axis of the coordinate for the rectangle starting point.
-     * @param {number} y - y axis of the coordinate for the rectangle starting point.
-     * @param {number} width - The rectangle's width.
-     * @param {number} height - The rectangle's height.
-     * @param {boolean} [fill=false] - also fill the shape with the current color if true
-     */
-    strokeRect(x: number, y: number, width: number, height: number, fill?: boolean): void;
-    /**
-     * Draw a filled rectangle at the specified coordinates
-     * @param {number} x - x axis of the coordinate for the rectangle starting point.
-     * @param {number} y - y axis of the coordinate for the rectangle starting point.
-     * @param {number} width - The rectangle's width.
-     * @param {number} height - The rectangle's height.
-     */
-    fillRect(x: number, y: number, width: number, height: number): void;
     /**
      * Stroke a rounded rectangle at the specified coordinates
      * @param {number} x - x axis of the coordinate for the rounded rectangle starting point.
@@ -496,12 +414,6 @@ export default class WebGLRenderer extends Renderer {
      * @param {number} f - the f component to multiply the current matrix by
      */
     transform(a: Matrix2d | Matrix3d | number, b: number, c: number, d: number, e: number, f: number): void;
-    /**
-     * adds a translation transformation to the current matrix.
-     * @param {number} x - Distance to move in the horizontal direction. Positive values are to the right, and negative to the left.
-     * @param {number} y - Distance to move in the vertical direction. Positive values are down, and negative are up.
-     */
-    translate(x: number, y: number): void;
     /**
      * clip the given region from the original canvas. Once a region is clipped,
      * all future drawing will be limited to the clipped region.
@@ -532,6 +444,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 OrthogonalTMXLayerGPURenderer from "./renderers/tmxlayer/orthogonal.js";
 import { Color } from "./../../math/color.ts";
 import type { Rect } from "./../../geometries/rectangle.ts";
 import type { RoundRect } from "./../../geometries/roundrect.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.3.0",
+	"version": "19.5.0",
 	"description": "melonJS Game Engine",
 	"homepage": "http://www.melonjs.org/",
 	"type": "module",