melonjs 19.9.1 → 20.1.0

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

@@ -0,0 +1,301 @@
+/**
+ * Byte size of the per-draw mesh uniform block:
+ * mat4x4 model (64) + mat4x4 view (64) + vec4 tint (16) + vec4 params
+ * (alphaCutoff, hasAlphaMap, reserved ×2) (16) + vec4 emissive (16) +
+ * vec4 specular (rgb + shininess) (16) + vec4 eye (camera world position;
+ * w reserved) (16) → 208.
+ * @ignore
+ */
+export const MESH_UNIFORM_SIZE: 208;
+/**
+ * The WebGPU mesh batcher — textured triangle meshes with the same
+ * geometry contract as the WebGL `MeshBatcher` (36-byte unlit layout,
+ * model-space retained geometry, uniform-driven placement) realized on
+ * this backend's recording model:
+ *
+ * - mesh mode is PIPELINE state, not device state: every mesh flush looks
+ *   its pipeline up with the mesh axes (depth write + LEQUAL, per-mesh
+ *   cull/frontFace from `renderer.drawMesh`) and blend forced "none" —
+ *   there is no `bind()`/`unbind()` state to own, and the depth clear is
+ *   the pass's `depthLoadOp` (see `resolveDepthOps`), not a draw-time op
+ * - placement/tint/cutoff/emissive ride ONE per-draw uniform snapshot
+ *   (group 3, dynamic offset into the effect uniform arena) — the
+ *   queue-write law: a shared region would be retroactively clobbered for
+ *   draws already recorded this frame
+ * - the accumulated path chunks through the shared versioned-remap dedup
+ *   (`gpu/meshchunk.ts`) into the frame's vertex arena plus a per-frame
+ *   INDEX arena (`renderer.indexArena`) — one `drawIndexed` per chunk
+ * @augments WebGPUBatcher
+ * @category Rendering
+ */
+export default class WebGPUMeshBatcher extends WebGPUBatcher {
+    /**
+     * @param {import("../webgpu_renderer.js").default} renderer - the owning renderer
+     * @override
+     */
+    override init(renderer: import("../webgpu_renderer.js").default, settings: any): void;
+    meshLayout: GPUBindGroupLayout | undefined;
+    vertexLayoutKey: string | undefined;
+    customShader: any;
+    indexData: Uint32Array<ArrayBuffer> | undefined;
+    indexCount: any;
+    currentMaterial: any;
+    uniformBinding: {
+        bindGroup: any;
+        dynamicOffset: any;
+    } | null | undefined;
+    uniformBindGroups: Map<any, any> | undefined;
+    meshState: {
+        cullMode: string;
+        frontFace: string;
+    } | undefined;
+    retained: Map<any, any> | undefined;
+    instanced: Map<any, any> | undefined;
+    instancedKeys: Map<any, any> | undefined;
+    shadowFamilyKeys: Map<any, any> | undefined;
+    /**
+     * The instanced variant options for this tier (unlit by default) — where
+     * its instance attributes start and how its vertex stage places them.
+     * @ignore
+     */
+    instancedVariant(): {
+        baseLocation: number;
+        varyingLocation: number;
+        geometryInputs: string;
+        body: string;
+    };
+    /**
+     * The pipeline-cache family for a given record layout, registered on
+     * first use.
+     *
+     * WGSL has no preprocessor, so the variant is a module DERIVED from this
+     * tier's ordinary source (see `buildInstancedMeshWGSL`) rather than the
+     * same text compiled with different defines. Its vertex layout is two
+     * groups: this batcher's geometry layout, plus the instance records
+     * stepping once per instance.
+     * @param {object} layout - the instance record layout
+     * @returns {string} the family key
+     * @ignore
+     */
+    instancedFamilyFor(layout: object): string;
+    /**
+     * Get (creating on first use) the GPU instance buffer for one mesh, with
+     * its dirty span already uploaded.
+     * @param {InstancedMesh} mesh - the mesh being drawn
+     * @returns {WebGPUInstanceBuffer} the up-to-date buffer
+     * @ignore
+     */
+    instanceBufferFor(mesh: InstancedMesh): WebGPUInstanceBuffer;
+    /**
+     * Draw every visible instance of a mesh in one recorded call.
+     * @param {InstancedMesh} mesh - the mesh to draw
+     * @param {Matrix3d} modelMatrix - where the group sits in the world
+     * @param {number} tint - tint colour in UINT32 (argb) format
+     * @ignore
+     */
+    drawInstancedMesh(mesh: InstancedMesh, modelMatrix: Matrix3d, tint: number): void;
+    instancedShaderWarned: boolean | undefined;
+    /**
+     * The instanced ground-shadow family (#1515), registered on first use.
+     *
+     * ONE family, not one per record layout: the module reads only the three
+     * transform rows, so `hasColor` / `hasData` make no difference — and the
+     * vertex layout declares only those rows, leaving the instance buffer's
+     * stride and offsets exactly as the mesh pass uses them.
+     * @param {object} layout - the mesh's instance record layout
+     * @returns {string} the pipeline family key
+     * @ignore
+     */
+    instancedShadowFamily(layout: object): string;
+    /**
+     * Record one flat blob per instance, in a single call, over the same
+     * instance buffer the mesh itself drew from (#1515).
+     * @param {InstancedMesh} mesh - the mesh casting the shadows
+     * @param {Matrix3d} shadowMatrix - the group matrix flattened onto the ground
+     * @param {number} tint - tint colour in UINT32 (argb) format
+     * @param {object} quad - the shared shadow quad
+     * @ignore
+     */
+    drawInstancedShadow(mesh: InstancedMesh, shadowMatrix: Matrix3d, tint: number, quad: object): void;
+    /**
+     * Release the instance buffer held for one mesh, if any.
+     * @param {object} mesh - the mesh whose instance records should be freed
+     * @ignore
+     */
+    releaseInstanced(mesh: object): void;
+    /**
+     * Release every instance buffer this batcher holds.
+     * @ignore
+     */
+    releaseAllInstanced(): void;
+    /**
+     * the first-init settings — the lit subclass overrides the key and
+     * appends its normal attribute
+     * @ignore
+     */
+    defaultSettings(): {
+        shaderKey: string;
+        topology: string;
+        attributes: {
+            name: string;
+            format: string;
+            offset: number;
+        }[];
+    };
+    /**
+     * the WGSL module text of this family
+     * @ignore
+     */
+    shaderSource(): any;
+    /**
+     * The vertex attribute layout — identical to the WebGL mesh batcher's:
+     * `aVertex` (3) + `aRegion` (2) + `aColor` (4 floats, deliberately not
+     * unorm8x4 — the layout is shared with GL, where float colors dodge
+     * NaN-pattern canonicalization on Metal-backed drivers) = 9 floats.
+     * @ignore
+     */
+    attributeLayout(): {
+        name: string;
+        format: string;
+        offset: number;
+    }[];
+    /**
+     * the shape signature keying the group-3 layout in the pipeline cache
+     * @ignore
+     */
+    uniformSignature(): string;
+    /**
+     * The shader family for the next recorded draw: the built-in family,
+     * or the hosted custom module when `renderer.drawMesh` routed a
+     * WGSL-carrying {@link GLShader} here — registered lazily against
+     * THIS host's vertex layout and group list, so one instance serves
+     * the unlit and lit hosts as distinct families. An invalid module
+     * (failed async validation) falls back to the built-in family: the
+     * mesh keeps drawing, default-shaded — the ShaderEffect
+     * warn-and-degrade contract.
+     * @returns {string} the pipeline-cache family key
+     * @ignore
+     */
+    activeShaderKey(): string;
+    /**
+     * the positional bind-group-layout list for this family — the lit
+     * subclass swaps the group-2 filler for its light-block layout
+     * @ignore
+     */
+    bindGroupLayoutList(cache: any): any[];
+    /**
+     * Resolve the group-1 material for a mesh: its texture through the
+     * texture store, honouring the mesh's own `textureRepeat` wrap override
+     * (#1503 — sampler state per use, never a mutation of the shared
+     * per-image atlas). A material change with vertices pending flushes
+     * them under the previous binding.
+     * @param {object} mesh - the mesh whose material should be applied
+     * @param {TextureAtlas} [texture] - bind this texture instead of the mesh's
+     * own — how a multi-material model's per-material `map_Kd` reaches the
+     * sampler, one draw range at a time (#1573). The wrap override stays a
+     * property of the mesh, not of the material group.
+     * @ignore
+     */
+    applyMeshMaterial(mesh: object, texture?: TextureAtlas): void;
+    /**
+     * Snapshot the per-draw uniforms — placement (`model`, `view`), tint,
+     * and the mesh's material scalars (alpha cutoff, emissive) — into a
+     * fresh dynamic-offset region of the effect uniform arena. The draws
+     * recorded after this bind against exactly these bytes.
+     * @param {Matrix3d} modelMatrix - the mesh's own placement, or identity
+     *   when its vertices are already positioned
+     * @param {number} tint - tint colour in UINT32 (argb) format
+     * @param {object} mesh - the mesh (alphaCutoff / emissive source)
+     * @ignore
+     */
+    setPlacementUniforms(modelMatrix: Matrix3d, tint: number, mesh: object): void;
+    /**
+     * Write one vertex into the staging buffer. The base (unlit) layout is
+     * `x, y, z, u, v, color` — subclasses override to append per-vertex
+     * data matching their attribute layout.
+     * @ignore
+     */
+    pushVertex(vertexData: any, x: any, y: any, z: any, u: any, v: any, color: any, _mesh: any, _i3: any): void;
+    /**
+     * Add a textured mesh to the batch (the accumulated path: vertices
+     * already CPU-projected, identity model matrix). Chunks triangles
+     * across flushes through the shared versioned-remap dedup, exactly
+     * like the WebGL batcher. Multi-material vertex colors ride `aColor`;
+     * the runtime tint stays a uniform.
+     * @param {object} mesh - a Mesh with vertices, uvs, indices, texture
+     * @param {number} tint - tint color in UINT32 (argb) format
+     */
+    addMesh(mesh: object, tint: number): void;
+    /**
+     * Accumulate one index range of a mesh into the batch, chunking triangles
+     * across flushes as the vertex / index staging arrays fill.
+     * @param {object} mesh - a Mesh with vertices, uvs, indices, texture
+     * @param {number} from - first index to accumulate
+     * @param {number} length - how many indices to accumulate
+     * @ignore
+     */
+    accumulateRange(mesh: object, from: number, length: number): void;
+    /**
+     * Record the pending mesh vertices as one indexed draw: vertex bytes
+     * into the vertex arena, index bytes into the index arena, pipeline
+     * from the mesh family with the depth/cull axes and blend forced
+     * "none" (the GL mesh mode disables BLEND).
+     * @override
+     */
+    override flush(): void;
+    /**
+     * bind group 2 — the unlit family interposes the shared empty group;
+     * the lit subclass overrides with its light block
+     * @ignore
+     */
+    bindLights(pass: any): void;
+    /**
+     * Write one mesh's model-space geometry into `out` in this batcher's
+     * vertex layout, returning how many floats were written — the shared
+     * neutral builder (`gpu/meshvertex.ts`), one copy for both backends.
+     * @param {object} mesh - the mesh to read geometry from
+     * @param {Float32Array} out - destination scratch
+     * @returns {number} number of floats written
+     * @ignore
+     */
+    buildRetainedVertexData(mesh: object, out: Float32Array): number;
+    /**
+     * Get this mesh's retained geometry, building or refreshing it when
+     * the mesh's geometry version has moved on.
+     * @param {object} mesh - the mesh whose geometry is wanted
+     * @returns {WebGPURetainedGeometry} up-to-date geometry for the mesh
+     * @ignore
+     */
+    retainedGeometryFor(mesh: object): WebGPURetainedGeometry;
+    /**
+     * Draw a mesh from its retained geometry: bind the persistent buffers
+     * and record one indexed draw, with placement supplied entirely by the
+     * per-draw uniform snapshot. Unlike {@link WebGPUMeshBatcher#addMesh}
+     * this accumulates nothing and never chunks — the whole mesh is one
+     * draw regardless of size, except for a multi-material model whose
+     * materials carry different diffuse textures: that records one indexed
+     * range per entry in {@link Mesh#textureGroups} (#1573), over the same
+     * buffers, with only the group-1 material binding moving between them.
+     * @param {object} mesh - the mesh to draw
+     * @param {Matrix3d} modelMatrix - where the mesh sits in the world
+     * @param {number} tint - tint colour in UINT32 (argb) format
+     * @ignore
+     */
+    drawRetainedMesh(mesh: object, modelMatrix: Matrix3d, tint: number): void;
+    /**
+     * Release the retained geometry held for one mesh, if any.
+     * @param {object} mesh - the mesh whose geometry should be freed
+     * @ignore
+     */
+    releaseRetained(mesh: object): void;
+    /**
+     * Release every retained geometry this batcher holds.
+     * @ignore
+     */
+    releaseAllRetained(): void;
+}
+import WebGPUBatcher from "./webgpu_batcher.js";
+import WebGPUInstanceBuffer from "../buffer/instance_buffer.js";
+import { Matrix3d } from "../../../math/matrix3d.ts";
+import WebGPURetainedGeometry from "../buffer/retained_geometry.js";
+//# sourceMappingURL=mesh_batcher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mesh_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/batchers/mesh_batcher.js"],"names":[],"mappings":"AAmBA;;;;;;;GAOG;AACH,gCAAiC,GAAG,CAAC;AAUrC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IACC;;;OAGG;IACH,wBAHW,OAAO,uBAAuB,EAAE,OAAO,uBAmFjD;IAzEA,2CAUE;IAuBF,oCAAsC;IAItC,kBAAwB;IAIxB,gDAA+D;IAC/D,gBAAmB;IAGnB,qBAA2B;IAE3B;;;yBAA0B;IAE1B,6CAAkC;IAGlC;;;kBAAuD;IAQvD,oCAAyB;IAQzB,qCAA0B;IAC1B,yCAA8B;IAG9B,4CAAiC;IAGlC;;;;OAIG;IACH;;;;;MAEC;IAED;;;;;;;;;;;;OAYG;IACH,2BAJW,MAAM,GACJ,MAAM,CAmClB;IAED;;;;;;OAMG;IACH,wBAJW,aAAa,GACX,oBAAoB,CAuBhC;IAED;;;;;;OAMG;IACH,wBALW,aAAa,eACb,QAAQ,QACR,MAAM,QA4EhB;IAhDC,2CAAiC;IAkDnC;;;;;;;;;;OAUG;IACH,8BAJW,MAAM,GACJ,MAAM,CA4ClB;IAED;;;;;;;;OAQG;IACH,0BANW,aAAa,gBACb,QAAQ,QACR,MAAM,QACN,MAAM,QA0DhB;IAED;;;;OAIG;IACH,uBAHW,MAAM,QAShB;IAED;;;OAGG;IACH,4BAKC;IAED;;;;OAIG;IACH;;;;;;;;MAMC;IAED;;;OAGG;IACH,oBAEC;IAED;;;;;;OAMG;IACH;;;;QAkBC;IAED;;;OAGG;IACH,2BAEC;IAED;;;;;;;;;;;OAWG;IACH,mBAHa,MAAM,CAkBlB;IAED;;;;OAIG;IACH,uCAOC;IAED;;;;;;;;;;;;OAYG;IACH,wBAPW,MAAM,YACN,YAAY,QAkCtB;IAED;;;;;;;;;;OAUG;IACH,kCANW,QAAQ,QAER,MAAM,QACN,MAAM,QAiEhB;IAED;;;;;OAKG;IACH,4GAEC;IAED;;;;;;;;OAQG;IACH,cAHW,MAAM,QACN,MAAM,QAsBhB;IAED;;;;;;;OAOG;IACH,sBALW,MAAM,QACN,MAAM,UACN,MAAM,QAsEhB;IAED;;;;;;OAMG;IACH,uBAsEC;IAED;;;;OAIG;IACH,4BAEC;IAED;;;;;;;;OAQG;IACH,8BALW,MAAM,OACN,YAAY,GACV,MAAM,CAKlB;IAED;;;;;;OAMG;IACH,0BAJW,MAAM,GACJ,sBAAsB,CAgBlC;IAED;;;;;;;;;;;;;OAaG;IACH,uBALW,MAAM,eACN,QAAQ,QACR,MAAM,QAmEhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,QAUhB;IAED;;;OAGG;IACH,2BAMC;CAsBD;0BA//ByB,qBAAqB;iCARd,8BAA8B;yBATtC,2BAA2B;mCAUjB,gCAAgC"}

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

@@ -0,0 +1,39 @@
+/**
+ * additional import for TypeScript
+ * @import {Point} from "./../../../geometries/point.ts";
+ */
+/**
+ * The WebGPU primitive batcher — shape geometry accumulation with the same
+ * frozen 24-byte vertex layout and CPU tessellation as the WebGL
+ * `PrimitiveBatcher`, addressed purely in the portable topology vocabulary.
+ *
+ * `uLineWidth` lives in the shared frame-globals uniform block: a width
+ * change flushes pending vertices and pushes a fresh dynamic-offset slot,
+ * replacing the per-program uniform of the GL backend.
+ *
+ * The two non-portable engine topologies are emulated in this front end,
+ * as `PORTABLE_TOPOLOGIES` documents: `"line-loop"` draws as a strip with
+ * an explicit closing vertex, `"triangle-fan"` re-expands on the CPU into
+ * a triangle list. No engine path emits either — they only serve direct
+ * user calls.
+ * @augments WebGPUBatcher
+ * @category Rendering
+ */
+export default class WebGPUPrimitiveBatcher extends WebGPUBatcher {
+    /**
+     * @param {import("../webgpu_renderer.js").default} renderer - the owning renderer
+     * @override
+     */
+    override init(renderer: import("../webgpu_renderer.js").default, settings: any): void;
+    /**
+     * Draw an array of vertices with the given topology.
+     * @param {string} topology - portable topology name ("point-list", "line-list", "line-strip", "triangle-list", "triangle-strip"; "line-loop" and "triangle-fan" are emulated)
+     * @param {Point[]} verts - an array of vertices
+     * @param {number} [vertexCount=verts.length] - amount of points defined in the points array
+     */
+    drawVertices(topology: string, verts: Point[], vertexCount?: number): void;
+    #private;
+}
+import WebGPUBatcher from "./webgpu_batcher.js";
+import type { Point } from "./../../../geometries/point.ts";
+//# sourceMappingURL=primitive_batcher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"primitive_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/batchers/primitive_batcher.js"],"names":[],"mappings":"AAMA;;;GAGG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH;IACC;;;OAGG;IACH,wBAHW,OAAO,uBAAuB,EAAE,OAAO,uBA8BjD;IAED;;;;;OAKG;IACH,uBAJW,MAAM,SACN,KAAK,EAAE,gBACP,MAAM,QAyEhB;;CAsID;0BA7QyB,qBAAqB;2BAIvB,gCAAgC"}

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

@@ -0,0 +1,143 @@
+/**
+ * The WebGPU quad batcher — textured-quad accumulation with the same
+ * frozen 28-byte vertex layout as the WebGL `QuadBatcher` and the same
+ * static 6-indices-per-quad pattern.
+ *
+ * Texture batching is single-texture-per-draw-segment in this first
+ * version: a texture (bind group) change flushes the pending quads — the
+ * `aTextureId` attribute is written as 0 and kept in the layout so the
+ * later multi-texture upgrade (`binding_array` / texture arrays) changes
+ * only the group-1 layout and the fragment shader, never the vertex
+ * stream. A WebGPU flush is one `writeBuffer` of the pending bytes plus
+ * one `drawIndexed`, so the per-change cost is far below the GL
+ * full-buffer re-upload this design avoids there.
+ * @augments WebGPUBatcher
+ * @category Rendering
+ */
+export default class WebGPUQuadBatcher extends WebGPUBatcher {
+    /**
+     * @param {import("../webgpu_renderer.js").default} renderer - the owning renderer
+     * @override
+     */
+    override init(renderer: import("../webgpu_renderer.js").default, settings: any): void;
+    currentMaterial: any;
+    currentEffect: any;
+    slotTable: TextureSlotTable | undefined;
+    /** @type {{view: GPUTextureView, sampler: GPUSampler}[]} indexed by slot */
+    segmentEntries: {
+        view: GPUTextureView;
+        sampler: GPUSampler;
+    }[] | undefined;
+    segmentGroup: GPUBindGroup | null | undefined;
+    /** @type {Map<string, GPUBindGroup>} */
+    composedGroups: Map<string, GPUBindGroup> | undefined;
+    resourceIds: WeakMap<object, any> | undefined;
+    nextResourceId: number | undefined;
+    indexBuffer: GPUBuffer | null | undefined;
+    /**
+     * Add a textured quad. Same contract as the WebGL `QuadBatcher.addQuad`
+     * — the CPU corner transform (view matrix + per-renderable depth) is
+     * identical, only the texture-binding mechanism differs.
+     * @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 (video frames)
+     */
+    addQuad(texture: object, x: number, y: number, w: number, h: number, u0: number, v0: number, u1: number, v1: number, tint: number, reupload?: boolean): void;
+    /**
+     * Resolve a texture to its slot in the pending segment, claiming a new
+     * slot (and flushing a full segment) when this (view, sampler) pair is
+     * new. The upload rules — same-frame content changes, recycled units,
+     * forced video re-uploads — all live in the store's resident-record
+     * path, exactly as before.
+     * @param {object} texture - the texture atlas to resolve
+     * @param {boolean} reupload - force the source pixels to re-upload
+     * @returns {number} the slot index written to aTextureId
+     * @ignore
+     */
+    segmentSlotFor(texture: object, reupload: boolean): number;
+    /**
+     * a stable id for a GPU resource object (bind-group composition keys)
+     * @ignore
+     */
+    resourceId(resource: any): any;
+    /**
+     * The composed group-1 bind group for the pending segment: the claimed
+     * slots, with empty slots padded by slot 0 (every declared binding
+     * needs a resource; the padding is never selected). Cached by the slot
+     * resources' identity, so steady-state segments re-use one group.
+     * @returns {GPUBindGroup} the segment's material bind group
+     * @ignore
+     */
+    composeSegmentGroup(): GPUBindGroup;
+    /**
+     * start the next segment fresh (the pending one was just recorded)
+     * @ignore
+     */
+    resetSegment(): void;
+    /**
+     * Drop every composed segment bind group — each embeds samplers
+     * resolved from the default texture filter, so a filter change must
+     * rebuild them (the multi-texture counterpart of the texture store's
+     * invalidateBindGroups).
+     */
+    clearMaterialCache(): void;
+    /**
+     * Transform and queue the four corners of a quad — shared by the base
+     * and lit addQuad paths. Stamps per-sprite depth onto z BEFORE
+     * `m.apply` so Camera3d's view matrix (3D R⁻¹ ∘ T(-pos)) fully rotates
+     * the vertex; for 2D-only matrices the z column is identity, so the
+     * output (x, y) is bit-identical and z passes through. textureId is the
+     * quad's segment slot (constant across its four corners); the lit and
+     * fast paths pass 0 (single-texture bind groups).
+     * @ignore
+     */
+    pushQuadVertices(x: any, y: any, w: any, h: any, u0: any, v0: any, u1: any, v1: any, tint: any, textureId?: number): void;
+    /**
+     * Composite a render target through an effect's pipeline as one
+     * screen-space quad — the WebGPU counterpart of the GL blitTexture.
+     * The caller ({@link WebGPURenderer#blitEffect}) has already set the
+     * screen-space projection; this records the draw with the effect's
+     * shader family and group-3 binding (uniforms snapshot-uploaded per
+     * bind). An effect without a WGSL realization composites as a plain
+     * un-effected blit, so the scene content is never lost.
+     * @param {import("../../rendertarget/webgpurendertarget.js").default} source - the render target to sample
+     * @param {number} x - destination x
+     * @param {number} y - destination y
+     * @param {number} w - destination width
+     * @param {number} h - destination height
+     * @param {ShaderEffect} [effect] - the effect to composite with
+     * @param {boolean} [keepBlend=false] - keep the current blend mode (else replace)
+     * @ignore
+     */
+    blitTexture(source: import("../../rendertarget/webgpurendertarget.js").default, x: number, y: number, w: number, h: number, effect?: ShaderEffect, keepBlend?: boolean): void;
+    /**
+     * @override
+     */
+    override flush(topology: any): void;
+    /**
+     * whether the pending vertices have a material to draw with — the lit
+     * subclass overrides (its material model is the combined color+normal
+     * group, not the segment slots)
+     * @ignore
+     */
+    hasPendingMaterial(): boolean;
+    /**
+     * record the pending vertices through an effect's pipeline — blending
+     * KEPT (the sprite composites live against the backdrop, the defining
+     * semantic of the fast path vs the pooled blit)
+     * @param {object} binding - the prepared effect binding
+     * @ignore
+     */
+    flushWithEffect(binding: object): void;
+}
+import WebGPUBatcher from "./webgpu_batcher.js";
+import { TextureSlotTable } from "../../gpu/textureslots.js";
+//# sourceMappingURL=quad_batcher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"quad_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/batchers/quad_batcher.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;GAeG;AACH;IACC;;;OAGG;IACH,wBAHW,OAAO,uBAAuB,EAAE,OAAO,uBA2FjD;IApDA,qBAA2B;IAM3B,mBAAyB;IASzB,wCASE;IACF,4EAA4E;IAC5E;cADkB,cAAc;iBAAW,UAAU;oBAC7B;IAExB,8CAAwB;IAIxB,wCAAwC;IACxC,sDAA+B;IAE/B,8CAAgC;IAChC,mCAAuB;IAQvB,0CAKE;IAKH;;;;;;;;;;;;;;;OAeG;IACH,iBAZW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,OAAO,QAyEjB;IAED;;;;;;;;;;OAUG;IACH,wBALW,MAAM,YACN,OAAO,GACL,MAAM,CAyBlB;IAED;;;OAGG;IACH,+BAOC;IAED;;;;;;;OAOG;IACH,uBAHa,YAAY,CA+BxB;IAED;;;OAGG;IACH,qBAMC;IAED;;;;;OAKG;IACH,2BAGC;IAED;;;;;;;;;OASG;IACH,0HAgBC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,oBATW,OAAO,0CAA0C,EAAE,OAAO,KAC1D,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,WACN,YAAY,cACZ,OAAO,QAyDjB;IAqBD;;OAEG;IACH,oCA6BC;IAED;;;;;OAKG;IACH,8BAEC;IAED;;;;;;OAMG;IACH,yBAHW,MAAM,QAuChB;CAwBD;0BA9hByB,qBAAqB;iCAHd,2BAA2B"}

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

@@ -0,0 +1,70 @@
+/**
+ * The base WebGPU Batcher — realizes the backend-neutral {@link Batcher}
+ * lifecycle (`init` / `bind` / `unbind` / `flush` / `reset` / `destroy`,
+ * driven by `renderer.addBatcher` / `setBatcher`) on a
+ * `GPURenderPassEncoder` instead of GL state. Custom WebGPU batchers
+ * extend this class.
+ *
+ * A "flush" here is one `queue.writeBuffer` of the pending vertex bytes
+ * into a fresh region of the renderer's per-frame buffer arena, plus one
+ * draw recorded into the frame's open pass — nothing is submitted until
+ * the frame ends. Attribute layouts are declared in the backend-neutral
+ * vocabulary of `src/video/gpu/vertexformat.ts` and consumed declaratively
+ * into the pipeline's `GPUVertexBufferLayout` (#1492) — no enum bridge.
+ * @augments Batcher
+ * @category Rendering
+ */
+export default class WebGPUBatcher extends Batcher {
+    /**
+     * @param {import("../webgpu_renderer.js").default} renderer - the owning renderer
+     * @param {object} [settings] - batcher settings (see {@link WebGPUBatcher#init})
+     */
+    constructor(renderer: import("../webgpu_renderer.js").default, settings?: object);
+    /**
+     * Initialize (or re-initialize after device loss) this batcher.
+     * @param {import("../webgpu_renderer.js").default} renderer - the owning renderer
+     * @param {object} [settings] - batcher settings
+     * @param {object[]} [settings.attributes] - neutral attribute descriptors
+     * @param {string} [settings.shaderKey] - pipeline-cache shader family
+     * @param {string} [settings.topology] - default portable topology
+     * @param {number} [settings.maxVertices] - staging capacity in vertices
+     */
+    init(renderer: import("../webgpu_renderer.js").default, settings?: {
+        attributes?: object[] | undefined;
+        shaderKey?: string | undefined;
+        topology?: string | undefined;
+        maxVertices?: number | undefined;
+    }): void;
+    device: GPUDevice | undefined;
+    shaderKey: string | undefined;
+    topology: string | undefined;
+    attributes: {
+        name: any;
+        format: any;
+        offset: any;
+        bytes: number;
+    }[] | undefined;
+    stride: any;
+    vertexSize: number | undefined;
+    vertexData: VertexArrayBuffer | undefined;
+    /**
+     * per-draw refresh hook (pass-scoped state that `bind()` cannot own
+     * because `setBatcher` early-returns when already current)
+     */
+    updatePassState(): void;
+    /**
+     * record the pending vertices as one draw in the frame's open pass
+     * @param {string} [topology] - override the batcher's default topology
+     */
+    flush(topology?: string): void;
+    /**
+     * record the actual draw call — non-indexed by default; the quad
+     * batcher overrides with its indexed 6-per-quad pattern
+     * @param {GPURenderPassEncoder} pass - the open pass
+     * @param {number} vertexCount - pending vertex count
+     */
+    recordDraw(pass: GPURenderPassEncoder, vertexCount: number): void;
+}
+import { Batcher } from "../../gpu/batcher.js";
+import VertexArrayBuffer from "../../buffer/vertex.js";
+//# sourceMappingURL=webgpu_batcher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"webgpu_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/batchers/webgpu_batcher.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH;IACC;;;OAGG;IACH,sBAHW,OAAO,uBAAuB,EAAE,OAAO,aACvC,MAAM,EAKhB;IAED;;;;;;;;OAQG;IACH,eAPW,OAAO,uBAAuB,EAAE,OAAO,aAE/C;QAA4B,UAAU;QACZ,SAAS;QACT,QAAQ;QACR,WAAW;KACvC,QAqDA;IAlDA,8BAA6B;IAG5B,8BAAmC;IACnC,6BAAoD;IAKpD;;;;;oBAQE;IAEF,YAAsC;IACtC,+BAA8D;IAE9D,0CAGC;IAuCH;;;OAGG;IACH,wBAAoB;IAEpB;;;OAGG;IACH,iBAFW,MAAM,QAuChB;IAED;;;;;OAKG;IACH,iBAHW,oBAAoB,eACpB,MAAM,QAIhB;CAeD;wBAhL6C,sBAAsB;8BADtC,wBAAwB"}

package/build/video/webgpu/buffer/arena.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Per-frame GPU buffer arena — a bump allocator over a persistent list of
+ * fixed-size `GPUBuffer` pages.
+ *
+ * Why an arena: melonJS flushes many times per frame (texture change, blend
+ * change, scissor change, …). Under WebGL each flush re-uploads the shared
+ * vertex buffer; under WebGPU all draw commands of a frame are recorded
+ * first and execute at `queue.submit()` time, so every flush must write its
+ * vertices into a region **no later flush overwrites** — `queue.writeBuffer`
+ * data lands before the submitted commands run, and two flushes sharing one
+ * region would have the second write clobber the first before either draw
+ * executes.
+ *
+ * Why a page *list* rather than one growable buffer: draw commands already
+ * recorded against earlier pages must stay valid; replacing a buffer
+ * mid-frame would invalidate them. Pages persist across frames; `reset()`
+ * just rewinds the bump pointer.
+ * @ignore
+ */
+export default class WebGPUBufferArena {
+    /**
+     * @param {GPUDevice} device - the device to allocate pages on
+     * @param {object} [options] - arena options
+     * @param {number} [options.pageSize=1048576] - byte size of each page
+     * @param {number} [options.usage] - GPUBufferUsage flags for the pages
+     * @param {string} [options.label] - debug label prefix for the pages
+     */
+    constructor(device: GPUDevice, options?: {
+        pageSize?: number | undefined;
+        usage?: number | undefined;
+        label?: string | undefined;
+    });
+    device: GPUDevice;
+    pageSize: number;
+    usage: number;
+    label: string;
+    /** @type {GPUBuffer[]} */
+    pages: GPUBuffer[];
+    pageIndex: number;
+    offset: number;
+    /**
+     * rewind the arena — called once per frame, before any allocation
+     */
+    reset(): void;
+    /**
+     * Reserve `byteLength` bytes and return where they live. The region is
+     * valid until the next `reset()`.
+     * @param {number} byteLength - bytes to reserve (must fit in one page)
+     * @param {number} [alignment=4] - required offset alignment (a power of
+     *   two; effect uniform snapshots pass the device's
+     *   `minUniformBufferOffsetAlignment` so the region can serve as a
+     *   dynamic bind-group offset)
+     * @returns {{buffer: GPUBuffer, offset: number}} the reserved region
+     */
+    alloc(byteLength: number, alignment?: number): {
+        buffer: GPUBuffer;
+        offset: number;
+    };
+    /**
+     * release every page (device loss / renderer destroy)
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=arena.d.ts.map

package/build/video/webgpu/buffer/arena.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arena.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/buffer/arena.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACC;;;;;;OAMG;IACH,oBANW,SAAS,YAEjB;QAAyB,QAAQ;QACR,KAAK;QACL,KAAK;KAChC,EAWA;IATA,kBAAoB;IACpB,iBAA2C;IAC3C,cACiE;IACjE,cAA6C;IAC7C,0BAA0B;IAC1B,OADW,SAAS,EAAE,CACP;IACf,kBAAkB;IAClB,eAAe;IAGhB;;OAEG;IACH,cAGC;IAED;;;;;;;;;OASG;IACH,kBAPW,MAAM,cACN,MAAM,GAIJ;QAAC,MAAM,EAAE,SAAS,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CA8B/C;IAED;;OAEG;IACH,gBAOC;CACD"}