melonjs 19.9.1 → 20.1.0

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

@@ -0,0 +1,69 @@
+/**
+ * WebGL 2 sampler objects, deduplicated by their state.
+ *
+ * GL bakes wrap and filter into the texture *object*, which is why the same
+ * image drawn at two repeat modes historically needed two texture units AND
+ * two uploads (#1448). Sampler objects — core in GLES 3.0, and unconditionally
+ * available since 20.0 dropped WebGL 1 — move that state out of the texture and
+ * onto the unit, exactly as the WebGPU backend already separates `GPUTexture`
+ * from `GPUSampler`.
+ *
+ * That separation is what lets texture residency be keyed by **source alone**:
+ * one upload serves every variant, and the variant rides the sampler. Slot
+ * assignment stays per `(source, variant)`, because a bound sampler applies to
+ * a unit and a unit carries one at a time.
+ *
+ * Deliberately mirrors `WebGPUTextureStore.getSampler(filter, repeat, mipmaps)`
+ * — same key, same dedup, so the two backends stay legible side by side.
+ * @ignore
+ */
+export class GLSamplerCache {
+    /**
+     * @param {WebGL2RenderingContext} gl - the owning context
+     * @ignore
+     */
+    constructor(gl: WebGL2RenderingContext);
+    gl: WebGL2RenderingContext;
+    /** @type {Map<string, WebGLSampler>} */
+    samplers: Map<string, WebGLSampler>;
+    lastFilter: number;
+    lastRepeat: any;
+    lastMipmap: any;
+    lastSampler: WebGLSampler | null;
+    /** @type {Array<WebGLSampler|null>} */
+    bound: Array<WebGLSampler | null>;
+    /**
+     * The sampler for a filter/wrap/mip combination, created once and reused.
+     *
+     * There are only a handful of live combinations in any scene — two filters
+     * times four repeat modes — so this Map stays tiny however many textures a
+     * game loads.
+     * @param {number} filter - `gl.NEAREST` or `gl.LINEAR`
+     * @param {string} [repeat="no-repeat"] - canvas-style repeat mode
+     * @param {boolean} [mipmap=false] - sample the mip chain (trilinear)
+     * @returns {WebGLSampler} the shared sampler
+     * @ignore
+     */
+    get(filter: number, repeat?: string, mipmap?: boolean): WebGLSampler;
+    /**
+     * Bind a sampler to a texture unit, or unbind with `null`.
+     *
+     * A bound sampler overrides the texture object's own parameters entirely,
+     * which is what makes one texture usable at several variants at once.
+     * @param {number} unit - the texture unit
+     * @param {WebGLSampler|null} sampler - the sampler, or `null` to fall back
+     * to the texture's own state
+     * @ignore
+     */
+    bind(unit: number, sampler: WebGLSampler | null): void;
+    /**
+     * Delete every sampler. Called on context loss — the GL objects died with
+     * the context, so this only drops our side of the bookkeeping and lets the
+     * next `get` mint fresh ones.
+     * @param {boolean} [destroy=false] - whether to `deleteSampler` first
+     * (orderly teardown; skip it for a lost context)
+     * @ignore
+     */
+    releaseAll(destroy?: boolean): void;
+}
+//# sourceMappingURL=samplercache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"samplercache.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/samplercache.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACC;;;OAGG;IACH,gBAHW,sBAAsB,EAmBhC;IAfA,2BAAY;IACZ,wCAAwC;IACxC,UADW,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CACX;IAKzB,mBAAoB;IACpB,gBAAsB;IACtB,gBAAsB;IACtB,iCAAuB;IAGvB,uCAAuC;IACvC,OADW,KAAK,CAAC,YAAY,GAAC,IAAI,CAAC,CACpB;IAGhB;;;;;;;;;;;OAWG;IACH,YANW,MAAM,WACN,MAAM,WACN,OAAO,GACL,YAAY,CAsCxB;IAED;;;;;;;;;OASG;IACH,WALW,MAAM,WACN,YAAY,GAAC,IAAI,QAU3B;IAED;;;;;;;OAOG;IACH,qBAJW,OAAO,QAiBjB;CACD"}

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

@@ -3,4 +3,20 @@
  * @ignore
  */
 export function minify(src: any): any;
+/**
+ * Prepend preprocessor defines to a GLSL source, respecting `#version`.
+ *
+ * `#version` must be the very first statement of a GLSL ES 3.00 shader —
+ * anything before it, including a `#define`, is a compile error. So defines
+ * go immediately *after* that line when one is present, and at the top when
+ * it is not (GLSL ES 1.00 sources declare no version).
+ *
+ * Used to compile shader variants from one source: the optional parts are
+ * `#ifdef`-guarded, and the variant is what defines are injected here.
+ * @param {string} source - the shader source
+ * @param {string} defines - `#define` lines, each newline-terminated
+ * @returns {string} the source with the defines injected
+ * @ignore
+ */
+export function injectDefines(source: string, defines: string): string;
 //# sourceMappingURL=string.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/string.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,sCAWC"}
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/string.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,sCAWC;AAED;;;;;;;;;;;;;;GAcG;AACH,sCALW,MAAM,WACN,MAAM,GACJ,MAAM,CAoBlB"}

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

@@ -0,0 +1,24 @@
+/**
+ * Normalize a draw mode to its GL enum.
+ *
+ * Accepts either vocabulary and always returns a number, so callers can keep
+ * comparing modes numerically. This matters more than it looks: a topology
+ * string that reaches a GL draw call is coerced to `NaN` and then to `0`,
+ * which *is* `POINTS` — so a missed translation does not throw, it silently
+ * renders the batch as points.
+ * @param {WebGL2RenderingContext} gl - the rendering context
+ * @param {string|GLenum} value - a topology name or a GL primitive enum
+ * @returns {GLenum} the GL primitive mode
+ * @throws {Error} when `value` is neither a known topology nor a number
+ * @ignore
+ */
+export function resolveTopology(gl: WebGL2RenderingContext, value: string | GLenum): GLenum;
+/**
+ * Name a GL primitive mode in the neutral vocabulary.
+ * @param {WebGL2RenderingContext} gl - the rendering context
+ * @param {GLenum} mode - a GL primitive mode
+ * @returns {string|undefined} the topology name, or `undefined` for an unknown mode
+ * @ignore
+ */
+export function topologyFromGL(gl: WebGL2RenderingContext, mode: GLenum): string | undefined;
+//# sourceMappingURL=topology.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"topology.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/topology.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;GAaG;AACH,oCANW,sBAAsB,SACtB,MAAM,GAAC,MAAM,GACX,MAAM,CA0BlB;AAED;;;;;;GAMG;AACH,mCALW,sBAAsB,QACtB,MAAM,GACJ,MAAM,GAAC,SAAS,CAa5B"}

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

@@ -0,0 +1,27 @@
+/**
+ * The GL enum a vertex format's components are read as.
+ * @param {WebGL2RenderingContext} gl - the rendering context
+ * @param {string} format - a supported vertex format name
+ * @returns {GLenum} the matching component type
+ * @throws {Error} when `format` is not a supported format name
+ * @ignore
+ */
+export function glTypeForFormat(gl: WebGL2RenderingContext, format: string): GLenum;
+/**
+ * Name a WebGL attribute description in the neutral vocabulary.
+ *
+ * Returns `undefined` when the combination has no name — three-component 8-
+ * and 16-bit types, for instance, which the GPU vocabulary simply does not
+ * define. That absence is deliberate and meaningful: a made-up name would
+ * travel into a backend that cannot honour it and fail there, far from the
+ * layout that produced it. An attribute with no portable format is still
+ * perfectly valid on the WebGL path.
+ * @param {WebGL2RenderingContext} gl - the rendering context
+ * @param {number} size - component count (1-4)
+ * @param {GLenum} type - component type
+ * @param {boolean} normalized - whether integers are scaled into `[0, 1]` / `[-1, 1]`
+ * @returns {string|undefined} the format name, or `undefined` when none exists
+ * @ignore
+ */
+export function formatFromGL(gl: WebGL2RenderingContext, size: number, type: GLenum, normalized: boolean): string | undefined;
+//# sourceMappingURL=vertexformat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vertexformat.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/vertexformat.js"],"names":[],"mappings":"AAgCA;;;;;;;GAOG;AACH,oCANW,sBAAsB,UACtB,MAAM,GACJ,MAAM,CAOlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,iCAPW,sBAAsB,QACtB,MAAM,QACN,MAAM,cACN,OAAO,GACL,MAAM,GAAC,SAAS,CAwC5B"}

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

@@ -16,6 +16,7 @@ export default class WebGLRenderer extends Renderer {
      * @type {WebGLRenderingContext}
      */
     gl: WebGLRenderingContext;
+    _renderTargetPool: RenderTargetPool;
     /**
      * Saved projection matrix for begin/endPostEffect.
      * @type {Matrix3d}
@@ -35,12 +36,46 @@ export default class WebGLRenderer extends Renderer {
      * @type {WebGLBuffer}
      */
     vertexBuffer: WebGLBuffer;
+    /**
+     * Sampler objects, deduplicated by state. GL bakes wrap/filter into the
+     * texture object; a bound sampler overrides that, so one texture can
+     * serve several variants at once — which is what lets residency be
+     * keyed by source alone. Renderer-owned so every batcher shares it.
+     * @type {GLSamplerCache}
+     * @ignore
+     */
+    samplerCache: GLSamplerCache;
+    /**
+     * Texture residency, keyed by SOURCE. The GL handle used to be
+     * reachable only through a batcher's per-unit array, so dropping a unit
+     * assignment destroyed the texture and the next draw rebuilt it from
+     * scratch — a full re-upload and mip regeneration per quad once past
+     * the batching limit. Owning it here, per renderer, means a texture
+     * that merely moves units costs a bind.
+     *
+     * Renderer-owned rather than batcher-owned on purpose: `init()` re-runs
+     * on context restore, so a batcher-owned store would be REPLACED there,
+     * orphaning every handle it tracked and leaking them on the next loss.
+     * @type {TextureStore}
+     * @ignore
+     */
+    textureStore: TextureStore;
     /**
      * Maximum number of texture unit supported under the current context
      * @type {number}
      * @readonly
      */
     readonly maxTextures: number;
+    /**
+     * Next free indexed `UNIFORM_BUFFER` binding point, handed out by
+     * {@link WebGLRenderer#reserveUniformBindingPoint}. Binding points are
+     * a context-wide namespace shared by every uniform block, so they are
+     * allocated here rather than picked as literals by whoever needs one —
+     * the same reason texture units go through `TextureCache.reserveUnit`.
+     * @type {number}
+     * @ignore
+     */
+    _nextUniformBindingPoint: number;
     /**
      * the default shader precision based on application settings
      * @type {string}
@@ -67,9 +102,9 @@ export default class WebGLRenderer extends Renderer {
     currentTransform: Matrix3d;
     /**
      * The current batcher used by the renderer
-     * @type {Batcher}
+     * @type {WebGLBatcher}
      */
-    currentBatcher: Batcher;
+    currentBatcher: WebGLBatcher;
     /**
      * a reference to the current shader program used by the renderer
      * @type {WebGLProgram}
@@ -86,17 +121,46 @@ export default class WebGLRenderer extends Renderer {
     _activeTextureUnit: number;
     /**
      * The list of active batchers
-     * @type {Map<Batcher>}
+     * @type {Map<WebGLBatcher>}
      */
-    batchers: Map<Batcher, any>;
+    batchers: Map<WebGLBatcher, any>;
     _scissorActive: boolean;
     cache: TextureCache;
+    onGameReset: () => void;
+    onContextRestoredInvalidate: (renderer: any) => void;
+    onCanvasResize: (width: any, height: any) => void;
     /**
-     * The WebGL version used by this renderer (1 or 2)
+     * The WebGL version used by this renderer.
      * @type {number}
-     * @default 1
+     * @default 2
+     * @deprecated since 20.0.0 — the WebGL renderer is WebGL 2 only, this is always `2`
      */
     get WebGLVersion(): number;
+    _compressedTextureFormats: {
+        astc: any;
+        bptc: any;
+        s3tc: any;
+        s3tc_srgb: any;
+        pvrtc: any;
+        etc1: any;
+        etc2: any;
+    } | undefined;
+    /**
+     * Reset context state
+     */
+    /**
+     * Tear down this renderer and free GPU/event resources. Walks every
+     * registered batcher's `destroy()` so cross-renderer subscriptions
+     * (`GPU_TEXTURE_CACHE_RESET` on `MaterialBatcher`, etc.) don't
+     * leak across `Application.destroy()` cycles. Safe to call multiple
+     * times — subsequent calls are no-ops.
+     */
+    /**
+     * Release any GPU geometry retained for the given mesh. Called when a mesh
+     * is destroyed; harmless if it never had any.
+     * @param {object} mesh - the mesh whose geometry should be freed
+     */
+    deleteMeshGeometry(mesh: object): void;
     _lightShader: RadialGradientEffect | undefined;
     _lightAtlas: TextureAtlas | undefined;
     _frameTexture: FrameTexture | undefined;
@@ -120,22 +184,35 @@ export default class WebGLRenderer extends Renderer {
     _getTMXGPURendererFor(orientation: string): object | undefined;
     /**
      * add a new batcher to this renderer
-     * @param {Batcher} batcher - a batcher instance
+     * @param {WebGLBatcher} batcher - a batcher instance (must extend WebGLBatcher)
      * @param {string} name - a name uniquely identifying this batcher
      * @param {boolean} [activate=false] - true if the given batcher should be set as the active one
      */
-    addBatcher(batcher: Batcher, name?: string, activate?: boolean): void;
+    addBatcher(batcher: WebGLBatcher, name?: string, activate?: boolean): void;
     /**
      * set the active batcher for this renderer
      * @param {string} name - a batcher name
      * @param {GLShader} [shader] - an optional shader program to be used, instead of the default one, when activating the batcher
-     * @returns {Batcher} an instance to the current active batcher
-     */
-    setBatcher(name?: string, shader?: GLShader): Batcher;
-    /**
-     * Reset the gl transform to identity
+     * @returns {WebGLBatcher} an instance to the current active batcher
+     */
+    setBatcher(name?: string, shader?: GLShader): WebGLBatcher;
+    /**
+     * Whether the device state right now is the scene's, so a deferred
+     * ground-shadow drain (#1515) would actually land where it is meant to.
+     *
+     * A batcher transition is normally the end of the mesh pass — but not
+     * every one is. `setMask` fills its shape through the primitive batcher
+     * with **colour writes off and `stencilOp(…, INCR)` armed**, so draining
+     * there both discards every blob and stamps their footprints into the mask
+     * being built. A transition inside a post-effect bracket is bound to the
+     * child's FBO, so the blobs would be captured into that effect chain and
+     * lost from the world. In either case the queue simply waits: the camera
+     * drains it at the end of the world walk, which is the point that is always
+     * correct.
+     * @returns {boolean} true when a drain is safe here
+     * @ignore
      */
-    resetTransform(): void;
+    _canDrainShadows(): boolean;
     /**
      * Create a pattern with the specified repetition
      * @param {HTMLImageElement|SVGImageElement|HTMLVideoElement|HTMLCanvasElement|ImageBitmap|OffscreenCanvas|VideoFrame} image - Source image to be used as the pattern's image
@@ -150,6 +227,23 @@ export default class WebGLRenderer extends Renderer {
      */
     createPattern(image: HTMLImageElement | SVGImageElement | HTMLVideoElement | HTMLCanvasElement | ImageBitmap | OffscreenCanvas | VideoFrame, repeat?: string): TextureAtlas;
     _lightUniformsScratch: import("./lighting/pack.ts").LightUniformScratch | undefined;
+    /**
+     * Claim the next indexed `UNIFORM_BUFFER` binding point.
+     *
+     * Binding points are context-wide: two uniform blocks sharing one silently
+     * overwrite each other, and the loser reads the winner's bytes as its own.
+     * Allocating them from here rather than hard-coding an integer per feature
+     * makes that collision impossible, and mirrors how texture units are
+     * claimed through {@link TextureCache#reserveUnit}.
+     *
+     * Callers hold their point for the life of the batcher — a context restore
+     * re-runs `init()`, which must reuse the point it already has rather than
+     * claim another, or a long-lived session would leak through the budget.
+     * @returns {number} the claimed binding point
+     * @throws {Error} when the device's binding points are exhausted
+     * @ignore
+     */
+    reserveUniformBindingPoint(): number;
     /**
      * Lazy-init a shared 1×1 white `TextureAtlas` used as the source
      * texture for `drawLight`'s procedural shader. The shader ignores
@@ -182,11 +276,11 @@ export default class WebGLRenderer extends Renderer {
      * 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
+     * @param {WebGLBatcher} [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;
+    invalidateTextureUnit(unit: number, except?: WebGLBatcher): void;
     /** @ignore */
     endPostEffect(renderable: any): void;
     /**
@@ -233,6 +327,38 @@ export default class WebGLRenderer extends Renderer {
      * @see WebGLRenderer#createPattern
      */
     drawPattern(pattern: TextureAtlas, x: number, y: number, width: number, height: number): void;
+    /**
+     * Draw a textured triangle mesh.
+     * Enables hardware depth testing and backface culling for the
+     * duration of the draw, then restores the previous GL state. Large
+     * meshes are automatically chunked across multiple draw calls to
+     * fit the vertex/index buffer limits.
+     *
+     * Multi-material meshes (OBJ files with multiple `usemtl` groups +
+     * a bound MTL) don't add any per-material draw calls here — the
+     * per-material colors are baked into `mesh.vertexColors` at
+     * construction time and pushed through the batcher's per-vertex
+     * `aColor` attribute. `mesh.tint` still multiplies on top at draw
+     * time, so flash / fade / team-color via `setTint` work the same
+     * as single-material. (The chunking-for-buffer-limits behavior
+     * above still applies to multi-material meshes as well.)
+     * @param {Mesh} mesh - a Mesh renderable or compatible object
+     * @param {Matrix3d} [modelMatrix] - where the mesh sits in the world. When
+     * given, the mesh is drawn from persistent model-space geometry and placed
+     * entirely by uniforms; when omitted, its vertices are taken as already
+     * positioned and accumulated through the batcher (the 2D-camera path).
+     */
+    /**
+     * Draw one ground shadow per instance of an `InstancedMesh` (#1515), in a
+     * single call over the same instance buffer the mesh drew from.
+     * @param {InstancedMesh} mesh - the mesh casting the shadows
+     * @param {Matrix3d} shadowMatrix - the group matrix flattened onto the ground
+     * @param {object} quad - the shared shadow quad
+     * @ignore
+     */
+    drawInstancedShadow(mesh: InstancedMesh, shadowMatrix: Matrix3d, quad: object): void;
+    drawMesh(mesh: any, modelMatrix: any): void;
+    _meshShaderWarned: boolean | undefined;
     /**
      * starts a new path by emptying the list of sub-paths. Call this method when you want to create a new path
      * @example
@@ -344,6 +470,8 @@ export default class WebGLRenderer extends Renderer {
      * <img src="../images/darken-blendmode.png" width="180"/> <br>
      * - "lighten" : retains the lightest pixels of both layers <br>
      * <img src="../images/lighten-blendmode.png" width="180"/> <br>
+     * - "none" : blending disabled — the source replaces the destination
+     * outright, alpha included (matches the WebGPU renderer's "none") <br>
      * Other CSS blend modes ("overlay", "color-dodge", "color-burn", "hard-light", "soft-light",
      * "difference", "exclusion") may be supported by the Canvas renderer (browser-dependent)
      * and will always fall back to "normal" in WebGL. <br>
@@ -470,18 +598,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;
-    /**
-     * clip the given region from the original canvas. Once a region is clipped,
-     * all future drawing will be limited to the clipped region.
-     * You can however save the current region using the save(),
-     * and restore it (with the restore() method) any time in the future.
-     * (<u>this is an experimental feature !</u>)
-     * @param {number} x - x axis of the coordinate for the upper-left corner of the rectangle to start clipping from.
-     * @param {number} y - y axis of the coordinate for the upper-left corner of the rectangle to start clipping from.
-     * @param {number} width - the width of the rectangle to start clipping from.
-     * @param {number} height - the height of the rectangle to start clipping from.
-     */
-    clipRect(x: number, y: number, width: number, height: number): void;
     /**
      * A mask limits rendering elements to the shape and position of the given mask object.
      * If the drawing or rendering area is larger than the mask, only the intersecting part of the renderable will be visible.
@@ -495,11 +611,13 @@ export default class WebGLRenderer extends Renderer {
     #private;
 }
 import Renderer from "./../renderer.js";
+import RenderTargetPool from "../rendertarget/render_target_pool.js";
 import { Matrix3d } from "../../math/matrix3d.ts";
+import { GLSamplerCache } from "./utils/samplercache.js";
 import { Bounds } from "../../physics/bounds.ts";
-import type { Batcher } from "./batchers/batcher.js";
+import { WebGLBatcher } from "./batchers/batcher.js";
 import TextureCache from "./../texture/cache.js";
-import RadialGradientEffect from "./effects/radialGradient.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";

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/build/video/webgpu/batchers/lit_mesh_batcher.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The WebGPU lit mesh batcher — meshes shaded by the active stage's
+ * {@link Light3d} lights (half-Lambert diffuse from directional lights +
+ * ambient), the port of the GL `LitMeshBatcher`:
+ *
+ * - adds the `aNormal` vertex attribute (48-byte layout vs 36) and the lit
+ *   shader family; meshes opt in via `mesh.lit`, so unlit meshes keep the
+ *   lean base batcher and pay nothing for lighting
+ * - the std140 `Light3dBlock` binds at group 2 with a dynamic offset. The
+ *   GL batcher re-packs and dirty-compares per draw
+ *   (`UniformBlock.upload`); here a change lands in a FRESH arena region
+ *   (queue-write law — an in-place write would retroactively re-light
+ *   draws already recorded this frame), and an unchanged rig re-uses the
+ *   frame's existing snapshot at zero upload cost
+ * @augments WebGPUMeshBatcher
+ * @category Rendering
+ */
+export default class WebGPULitMeshBatcher extends WebGPUMeshBatcher {
+    /**
+     * @override
+     */
+    override init(renderer: any, settings: any): void;
+    lightsLayout: GPUBindGroupLayout | undefined;
+    blockData: Float32Array<ArrayBuffer> | undefined;
+    uploadedBlock: Float32Array<ArrayBuffer> | undefined;
+    lightBindGroups: Map<any, any> | undefined;
+    lightBinding: {
+        bindGroup: any;
+        dynamicOffset: any;
+        frameId: any;
+    } | null | undefined;
+    /**
+     * build the light-block layout once per device (init drops it when the
+     * device changes)
+     * @ignore
+     */
+    ensureLightsLayout(): GPUBindGroupLayout;
+}
+import WebGPUMeshBatcher from "./mesh_batcher.js";
+//# sourceMappingURL=lit_mesh_batcher.d.ts.map

package/build/video/webgpu/batchers/lit_mesh_batcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lit_mesh_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/batchers/lit_mesh_batcher.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;GAgBG;AACH;IACC;;OAEG;IACH,kDAoBC;IAhBC,6CAA6B;IAU9B,iDAAiD;IACjD,qDAAqD;IAErD,2CAAgC;IAEhC;;;;yBAAwB;IA2CzB;;;;OAIG;IACH,yCAkBC;CA4JD;8BA7Q6B,mBAAmB"}

package/build/video/webgpu/batchers/lit_quad_batcher.d.ts

@@ -0,0 +1,82 @@
+/**
+ * The WebGPU lit quad batcher — normal-mapped sprites shaded by the
+ * Light2d std140 block, the port of the GL `LitQuadBatcher` under this
+ * backend's single-texture-per-draw-segment model:
+ *
+ * - group 1 is a combined material (color texture + normal map, four
+ *   entries); a change of either flushes the segment, so there is no
+ *   per-vertex normal-texture id and no sampler ladder
+ * - group 2 binds the std140 `Light2dBlock` with a dynamic offset — each
+ *   `setLightUniforms` call snapshots the packed block into the effect
+ *   uniform arena (queue writes execute before every recorded draw, so a
+ *   shared buffer region per camera would be retroactively clobbered)
+ * - normal maps live outside the TextureCache (same as GL): resident
+ *   GPUTextures keyed by source object, re-uploaded when the source's
+ *   duck-typed `version` stamp advances (NoiseTexture2d and friends)
+ * @augments WebGPUQuadBatcher
+ * @category Rendering
+ */
+export default class WebGPULitQuadBatcher extends WebGPUQuadBatcher {
+    /**
+     * @override
+     */
+    override init(renderer: any, settings: any): void;
+    litMaterialLayout: any;
+    lightsLayout: any;
+    blockData: Float32Array<ArrayBuffer> | undefined;
+    lightBindGroups: Map<any, any> | undefined;
+    lightBinding: {
+        bindGroup: any;
+        dynamicOffset: any;
+        frameId: any;
+    } | null | undefined;
+    litMaterials: Map<any, any> | undefined;
+    normalTextures: Map<any, any> | undefined;
+    /**
+     * Snapshot the packed light uniforms for the draws that follow — called
+     * by {@link WebGPURenderer#setLightUniforms} once per camera per frame.
+     * @param {object} packed - what packLights produced
+     */
+    setLightUniforms(packed: object): void;
+    /**
+     * Whether a light block was snapshotted during the given frame — the
+     * renderer's lit gate requires this: a previous-frame binding points
+     * into a reset arena region, so it would sample reused bytes.
+     * @param {number} frameId - the renderer's current frame stamp
+     * @returns {boolean} true when lit draws can bind a valid light block
+     */
+    hasCurrentLightBinding(frameId: number): boolean;
+    /**
+     * Resolve (and lazily upload) the resident texture for a normal-map
+     * source, re-uploading when its duck-typed `version` stamp advances.
+     * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap} source - the normal-map image
+     * @returns {object} {texture, view, version, width, height}
+     * @ignore
+     */
+    residentNormalMap(source: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap): object;
+    /**
+     * Add a lit textured quad — the base contract plus the normal map the
+     * segment shades with.
+     * @param {object} texture - the texture atlas to draw with
+     * @param {number} x - destination x
+     * @param {number} y - destination y
+     * @param {number} w - destination width
+     * @param {number} h - destination height
+     * @param {number} u0 - texture UV (u0)
+     * @param {number} v0 - texture UV (v0)
+     * @param {number} u1 - texture UV (u1)
+     * @param {number} v1 - texture UV (v1)
+     * @param {number} tint - tint color in UINT32 (argb) format
+     * @param {boolean} [reupload=false] - force the source pixels to re-upload
+     * @param {object} [normalMap] - the normal-map image paired with the texture
+     * @override
+     */
+    override addQuad(texture: object, x: number, y: number, w: number, h: number, u0: number, v0: number, u1: number, v1: number, tint: number, reupload?: boolean, normalMap?: object): void;
+    /**
+     * lit draws bind the combined material at 1 and the light block at 2
+     * @override
+     */
+    override recordDraw(pass: any, vertexCount: any): void;
+}
+import WebGPUQuadBatcher from "./quad_batcher.js";
+//# sourceMappingURL=lit_quad_batcher.d.ts.map

package/build/video/webgpu/batchers/lit_quad_batcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lit_quad_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/batchers/lit_quad_batcher.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;GAiBG;AACH;IACC;;OAEG;IACH,kDAmDC;IA9CA,uBAQE;IACF,kBAaE;IAcF,iDAA+C;IAE/C,2CAAgC;IAEhC;;;;yBAAwB;IAGxB,wCAA6B;IAE7B,0CAA+B;IAGhC;;;;OAIG;IACH,yBAFW,MAAM,QAuChB;IAED;;;;;;OAMG;IACH,gCAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;OAMG;IACH,0BAJW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,GAC5D,MAAM,CAsDlB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,0BAdW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,OAAO,cACP,MAAM,QAyDhB;IAwBD;;;OAGG;IACH,uDASC;CAuBD;8BAnU6B,mBAAmB"}