melonjs 19.9.1 → 20.0.0

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

@@ -0,0 +1,65 @@
+/**
+ * The WebGPU twin of the GL `WebGLInstanceBuffer`: one `InstancedMesh`'s
+ * per-instance records resident on the GPU, bound as a second vertex buffer
+ * whose layout steps once per instance.
+ *
+ * The same two queue-ordering laws that shape `WebGPURetainedGeometry`
+ * apply, and matter more here because instance records change far more often
+ * than geometry does:
+ *
+ * 1. `queue.writeBuffer` executes before **every** draw recorded this frame.
+ *    So editing an instance on a mesh that has already drawn this frame — a
+ *    second camera, a mid-frame animation step — must land in a FRESH
+ *    buffer, or the earlier draw would retroactively show the new placement.
+ * 2. Destroying a buffer referenced by recorded draws fails the whole
+ *    submit, so a replaced buffer retires through `renderer.retireBuffer`
+ *    and dies after the frame's submit.
+ *
+ * Within a frame that has not yet drawn, an edit is a partial
+ * `writeBuffer` covering only the dirty span — moving one tree in a forest
+ * of five thousand writes 48 bytes.
+ * @ignore
+ */
+export default class WebGPUInstanceBuffer {
+    /**
+     * @param {import("../webgpu_renderer.js").default} renderer - the owning renderer
+     */
+    constructor(renderer: import("../webgpu_renderer.js").default);
+    renderer: import("../webgpu_renderer.js").default;
+    /** @type {GPUBuffer|null} */
+    buffer: GPUBuffer | null;
+    /** allocated capacity in bytes @type {number} */
+    capacity: number;
+    /** the frame a draw was last recorded against this buffer @type {number} */
+    lastDrawnFrameId: number;
+    /**
+     * Push the dirty span of `data` to the GPU, reallocating when the record
+     * set outgrew the allocation or when this buffer has already been drawn
+     * from this frame.
+     * @param {Float32Array} data - the CPU-side instance records
+     * @param {number} firstFloat - first dirty float offset (inclusive)
+     * @param {number} floatCount - number of dirty floats, 0 when clean
+     * @param {number} usedBytes - bytes of `data` actually in use
+     */
+    upload(data: Float32Array, firstFloat: number, floatCount: number, usedBytes: number): void;
+    /**
+     * One `queue.writeBuffer`, in BYTES throughout.
+     *
+     * `writeBuffer`'s `dataOffset` and `size` are counted in *elements* when
+     * `data` is a TypedArray and in *bytes* otherwise — an ambiguity that
+     * silently changes meaning if the staging array's type ever changes. The
+     * engine's other GPU uploads all pass a `Uint8Array` view with byte
+     * counts, so this does too: one convention, no element/byte confusion.
+     * @param {number} bufferOffset - destination byte offset
+     * @param {number} byteOffset - source byte offset into `data`
+     * @param {number} byteLength - bytes to copy
+     * @param {Float32Array} data - the CPU-side instance records
+     * @ignore
+     */
+    write(bufferOffset: number, byteOffset: number, byteLength: number, data: Float32Array): void;
+    /**
+     * Release the GPU buffer (retired when a frame is recording).
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=instance_buffer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"instance_buffer.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/buffer/instance_buffer.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IACC;;OAEG;IACH,sBAFW,OAAO,uBAAuB,EAAE,OAAO,EAUjD;IAPA,kDAAwB;IACxB,6BAA6B;IAC7B,QADW,SAAS,GAAC,IAAI,CACP;IAClB,iDAAiD;IACjD,UADuC,MAAM,CAC5B;IACjB,4EAA4E;IAC5E,kBADkE,MAAM,CAC9C;IAG3B;;;;;;;;OAQG;IACH,aALW,YAAY,cACZ,MAAM,cACN,MAAM,aACN,MAAM,QA0ChB;IAED;;;;;;;;;;;;;OAaG;IACH,oBANW,MAAM,cACN,MAAM,cACN,MAAM,QACN,YAAY,QAWtB;IAED;;OAEG;IACH,gBAOC;CACD"}

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

@@ -0,0 +1,55 @@
+/**
+ * The WebGPU twin of the GL `RetainedGeometry`: one mesh's model-space
+ * geometry resident on the GPU — a vertex buffer and an index buffer,
+ * uploaded on geometry-version change and bound per draw (`setVertexBuffer`
+ * / `setIndexBuffer`; there is no VAO to capture, binding is explicit and
+ * cheap under this backend).
+ *
+ * The two queue-ordering laws shape the upload rules:
+ * 1. `queue.writeBuffer` executes before EVERY draw recorded this frame —
+ *    so a version bump on a mesh that has already drawn this frame
+ *    (Sprite3d animation UVs, a second camera) must land in FRESH buffers,
+ *    or the earlier draw would retroactively show the new geometry.
+ * 2. destroying a buffer referenced by recorded draws fails the whole
+ *    submit — replaced buffers retire through `renderer.retireBuffer` and
+ *    die after the frame's submit.
+ * @ignore
+ */
+export default class WebGPURetainedGeometry {
+    /**
+     * @param {import("../webgpu_renderer.js").default} renderer - the owning renderer
+     */
+    constructor(renderer: import("../webgpu_renderer.js").default);
+    renderer: import("../webgpu_renderer.js").default;
+    /** @type {GPUBuffer|null} */
+    vertexBuffer: GPUBuffer | null;
+    /** @type {GPUBuffer|null} */
+    indexBuffer: GPUBuffer | null;
+    /** @type {"uint16"|"uint32"} */
+    indexFormat: "uint16" | "uint32";
+    indexCount: number;
+    uploadedVersion: number;
+    lastDrawnFrameId: number;
+    vertexCapacity: number;
+    indexCapacity: number;
+    /**
+     * Upload (or re-upload) the interleaved vertex data and indices.
+     * @param {Float32Array} vertexData - interleaved data scratch
+     * @param {number} floatCount - number of floats to upload
+     * @param {Uint16Array|Uint32Array} indices - the mesh's authored indices
+     * @param {number} version - the mesh's geometry version being uploaded
+     */
+    upload(vertexData: Float32Array, floatCount: number, indices: Uint16Array | Uint32Array, version: number): void;
+    /**
+     * retire both buffers (frame-safe) without resetting the version — the
+     * shared tail of re-allocation and destruction
+     * @ignore
+     */
+    releaseBuffers(): void;
+    /**
+     * Release the GPU buffers. Idempotent — a destroyed geometry object
+     * simply re-uploads if ever used again.
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=retained_geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"retained_geometry.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/buffer/retained_geometry.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;GAgBG;AACH;IACC;;OAEG;IACH,sBAFW,OAAO,uBAAuB,EAAE,OAAO,EAmBjD;IAhBA,kDAAwB;IACxB,6BAA6B;IAC7B,cADW,SAAS,GAAC,IAAI,CACD;IACxB,6BAA6B;IAC7B,aADW,SAAS,GAAC,IAAI,CACF;IACvB,gCAAgC;IAChC,aADW,QAAQ,GAAC,QAAQ,CACD;IAC3B,mBAAmB;IAEnB,wBAAyB;IAGzB,yBAA0B;IAE1B,uBAAuB;IACvB,sBAAsB;IAGvB;;;;;;OAMG;IACH,mBALW,YAAY,cACZ,MAAM,WACN,WAAW,GAAC,WAAW,WACvB,MAAM,QA+DhB;IAED;;;;OAIG;IACH,uBAWC;IAED;;;OAGG;IACH,gBAKC;CACD"}

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

@@ -0,0 +1,68 @@
+/**
+ * Per-frame uniform ring — slot-granular bump allocation over persistent
+ * uniform-buffer pages, with one cached dynamic-offset bind group per page
+ * and per layout.
+ *
+ * This is the WebGPU realization of the "frame globals in one uniform
+ * buffer, bound once" shape (#1555): projection and line width live in
+ * group 0, and a *new slot* is pushed whenever either changes mid-frame
+ * (floating containers swap the projection around their children), so every
+ * recorded draw keeps the dynamic offset that was current when its vertices
+ * were queued. The mid-frame `clearColor` pipeline shares the same pages
+ * through its own layout/bind-group pair.
+ * @ignore
+ */
+export default class WebGPUUniformRing {
+    /**
+     * @param {GPUDevice} device - the device to allocate on
+     * @param {GPUBindGroupLayout} frameLayout - group-0 layout of the draw pipelines
+     * @param {GPUBindGroupLayout} clearLayout - group-0 layout of the clear pipeline
+     */
+    constructor(device: GPUDevice, frameLayout: GPUBindGroupLayout, clearLayout: GPUBindGroupLayout);
+    device: GPUDevice;
+    frameLayout: GPUBindGroupLayout;
+    clearLayout: GPUBindGroupLayout;
+    slotSize: number;
+    slotsPerPage: number;
+    pageSize: number;
+    /** @type {{buffer: GPUBuffer, frameGroup: GPUBindGroup, clearGroup: GPUBindGroup}[]} */
+    pages: {
+        buffer: GPUBuffer;
+        frameGroup: GPUBindGroup;
+        clearGroup: GPUBindGroup;
+    }[];
+    slot: number;
+    scratch: Float32Array<ArrayBuffer>;
+    /**
+     * rewind the ring — called once per frame
+     */
+    reset(): void;
+    /**
+     * Write a frame-globals slot (projection matrix + line width).
+     * @param {import("../../math/matrix3d.ts").Matrix3d} projection - the projection matrix
+     * @param {number} lineWidth - current stroke line width
+     * @returns {{bindGroup: GPUBindGroup, dynamicOffset: number}} the binding for subsequent draws
+     */
+    pushFrameGlobals(projection: any, lineWidth: number): {
+        bindGroup: GPUBindGroup;
+        dynamicOffset: number;
+    };
+    /**
+     * Write a clear-color slot.
+     * @param {number} r - red (0..1)
+     * @param {number} g - green (0..1)
+     * @param {number} b - blue (0..1)
+     * @param {number} a - alpha (0..1)
+     * @returns {{bindGroup: GPUBindGroup, dynamicOffset: number}} the binding for the clear draw
+     */
+    pushClearColor(r: number, g: number, b: number, a: number): {
+        bindGroup: GPUBindGroup;
+        dynamicOffset: number;
+    };
+    /**
+     * release every page (device loss / renderer destroy)
+     */
+    destroy(): void;
+    #private;
+}
+//# sourceMappingURL=uniformring.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uniformring.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/buffer/uniformring.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH;IACC;;;;OAIG;IACH,oBAJW,SAAS,eACT,kBAAkB,eAClB,kBAAkB,EAiB5B;IAdA,kBAAoB;IACpB,gCAA8B;IAC9B,gCAA8B;IAC9B,iBAGC;IACD,qBAAsB;IACtB,iBAAiD;IACjD,wFAAwF;IACxF,OADW;QAAC,MAAM,EAAE,SAAS,CAAC;QAAC,UAAU,EAAE,YAAY,CAAC;QAAC,UAAU,EAAE,YAAY,CAAA;KAAC,EAAE,CACrE;IACf,aAAa;IAEb,mCAAuD;IAGxD;;OAEG;IACH,cAEC;IAyCD;;;;;OAKG;IACH,6CAHW,MAAM,GACJ;QAAC,SAAS,EAAE,YAAY,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAC,CAe5D;IAED;;;;;;;OAOG;IACH,kBANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ;QAAC,SAAS,EAAE,YAAY,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAC,CAiB5D;IAED;;OAEG;IACH,gBAMC;;CACD"}

package/build/video/webgpu/effect_binding.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Prepare an effect for a draw: ensure device state, snapshot the uniform
+ * mirror(s) into the effect uniform arena, and return the pipeline family
+ * key plus the group-3 binding for the pass.
+ * @param {import("./webgpu_renderer.js").default} renderer - the renderer
+ * @param {import("../effects/shadereffect.js").default} effect - the effect to bind
+ * @returns {{key: string, hasEffectGroup: boolean, bindGroup: GPUBindGroup|null, dynamicOffsets: number[]}|null}
+ *   the binding, or null when the effect has no WGSL realization
+ * @ignore
+ */
+export function prepareEffectBinding(renderer: import("./webgpu_renderer.js").default, effect: import("../effects/shadereffect.js").default): {
+    key: string;
+    hasEffectGroup: boolean;
+    bindGroup: GPUBindGroup | null;
+    dynamicOffsets: number[];
+} | null;
+//# sourceMappingURL=effect_binding.d.ts.map

package/build/video/webgpu/effect_binding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect_binding.d.ts","sourceRoot":"","sources":["../../../src/video/webgpu/effect_binding.js"],"names":[],"mappings":"AA6OA;;;;;;;;;GASG;AACH,+CANW,OAAO,sBAAsB,EAAE,OAAO,UACtC,OAAO,4BAA4B,EAAE,OAAO,GAC1C;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,YAAY,GAAC,IAAI,CAAC;IAAC,cAAc,EAAE,MAAM,EAAE,CAAA;CAAC,GAAC,IAAI,CA+I/G"}

package/build/video/webgpu/pipeline/bindgroups.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Frozen bind-group conventions for the WebGPU backend.
+ *
+ * WebGPU bind-group indices are a per-pipeline-layout namespace with a hard
+ * cap of four groups, so — unlike WebGL's context-wide uniform-buffer
+ * binding points, which the renderer hands out from a monotonic counter
+ * (`reserveUniformBindingPoint`) — the collision-proofing here is a frozen
+ * convention: every pipeline in the backend agrees on what each group index
+ * means, and additions claim the reserved slots below instead of inventing
+ * their own.
+ *
+ * - group 0 — frame globals: one dynamic-offset uniform binding shared by
+ *   every draw (projection matrix + line width), served by the uniform
+ *   ring. The clear pipeline substitutes its own group-0 layout (a bare
+ *   color) over the same ring.
+ * - group 1 — material: texture view + sampler (quad pipeline).
+ * - group 2 — reserved: lights (the std140 light block ports here).
+ * - group 3 — reserved: per-effect extras (ShaderEffect-WGSL, post FX).
+ * @ignore
+ */
+export const GROUP_FRAME: 0;
+export const GROUP_MATERIAL: 1;
+export const GROUP_LIGHTS: 2;
+export const GROUP_EFFECT: 3;
+/**
+ * Byte size of the frame-globals uniform block:
+ * mat4x4<f32> projection (64) + f32 lineWidth (4) + pad to 16 → 80.
+ * @ignore
+ */
+export const FRAME_UNIFORM_SIZE: 80;
+/**
+ * Byte size of the clear-color uniform block: vec4<f32> → 16.
+ * @ignore
+ */
+export const CLEAR_UNIFORM_SIZE: 16;
+//# sourceMappingURL=bindgroups.d.ts.map

package/build/video/webgpu/pipeline/bindgroups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bindgroups.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/pipeline/bindgroups.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,0BAA2B,CAAC,CAAC;AAC7B,6BAA8B,CAAC,CAAC;AAChC,2BAA4B,CAAC,CAAC;AAC9B,2BAA4B,CAAC,CAAC;AAE9B;;;;GAIG;AACH,iCAAkC,EAAE,CAAC;AAErC;;;GAGG;AACH,iCAAkC,EAAE,CAAC"}

package/build/video/webgpu/pipeline/cache.d.ts

@@ -0,0 +1,173 @@
+/**
+ * Normalize a user-facing blend-mode string to a cache-key token — the
+ * same collapsing the WebGL backend applies ("add"/"lighter" → additive,
+ * unknown → normal).
+ * @param {string} mode - blend mode as set through `setBlendMode`
+ * @returns {string} normalized token
+ * @ignore
+ */
+export function normalizeBlendMode(mode: string): string;
+/**
+ * Texture slots per quad draw segment — the quad family batches quads
+ * across up to this many distinct textures before a flush is forced (the
+ * GL sampler-ladder equivalent). 8 texture + 8 sampler bindings stays
+ * comfortably inside WebGPU's base limits (16 sampled textures / 16
+ * samplers per stage) with headroom for the effect families' samplers.
+ * @ignore
+ */
+export const MAX_QUAD_TEXTURES: 8;
+/**
+ * The depth-stencil attachment format every pass and every pipeline of this
+ * backend declares. Attached from day one — masks use the stencil half now,
+ * meshes will use the depth half — because a pipeline's depthStencil state
+ * must match the pass attachment, and adding it later would invalidate
+ * every cached pipeline.
+ * @ignore
+ */
+export const DEPTH_STENCIL_FORMAT: "depth24plus-stencil8";
+/**
+ * Lazily-built cache of `GPURenderPipeline`s for the WebGPU backend, keyed
+ * by everything that is pipeline state under WebGPU but dynamic state under
+ * GL: shader family, topology, blend mode, premultiplied-alpha flag,
+ * stencil mode (and, held constant today, the canvas format and sample
+ * count — both stay in the key so render targets and MSAA slot in later
+ * without a reshape).
+ *
+ * Also owns the shader modules, bind-group layouts and pipeline layouts —
+ * the objects every pipeline shares and the uniform ring / texture store
+ * build their bind groups against.
+ * @ignore
+ */
+export default class WebGPUPipelineCache {
+    /**
+     * monotonic construction counter backing {@link WebGPUPipelineCache#epoch}
+     * @ignore
+     */
+    static epochCounter: number;
+    /**
+     * @param {GPUDevice} device - the device to build pipelines on
+     * @param {string} format - the canvas color format (preferredFormat)
+     */
+    constructor(device: GPUDevice, format: string);
+    device: GPUDevice;
+    format: string;
+    sampleCount: number;
+    /** @type {Map<string, GPURenderPipeline>} */
+    pipelines: Map<string, GPURenderPipeline>;
+    /** @type {Map<string, {stride: number, attributes: object[]}>} */
+    vertexLayouts: Map<string, {
+        stride: number;
+        attributes: object[];
+    }>;
+    frameLayout: GPUBindGroupLayout;
+    clearFrameLayout: GPUBindGroupLayout;
+    materialLayout: GPUBindGroupLayout;
+    meshMaterialLayout: GPUBindGroupLayout;
+    multiMaterialLayout: GPUBindGroupLayout;
+    modules: {
+        quad: GPUShaderModule;
+        blit: GPUShaderModule;
+        primitive: GPUShaderModule;
+        clear: GPUShaderModule;
+    };
+    pipelineLayouts: {
+        quad: GPUPipelineLayout;
+        blit: GPUPipelineLayout;
+        primitive: GPUPipelineLayout;
+        clear: GPUPipelineLayout;
+    };
+    /** @type {Map<string, string>} moduleText → family key */
+    registeredModules: Map<string, string>;
+    modulesBySource: Map<any, any>;
+    /** @type {Map<string, {stride: number, attributes: object[]}>} family key → vertex-layout alias */
+    vertexLayoutAliases: Map<string, {
+        stride: number;
+        attributes: object[];
+    }>;
+    /** @type {Map<string, GPUBindGroupLayout>} shape signature → group-3 layout */
+    effectLayouts: Map<string, GPUBindGroupLayout>;
+    emptyLayout: GPUBindGroupLayout;
+    emptyBindGroup: GPUBindGroup;
+    /**
+     * Device generation this cache belongs to — bumped once per cache
+     * construction. Consumers holding device-scoped objects built
+     * against this cache (effect modules, bind groups) compare their
+     * recorded epoch and lazily rebuild after a device loss.
+     * @type {number}
+     */
+    epoch: number;
+    /**
+     * Register a shader family beyond the built-in three, routing it through
+     * the same keyed {@link WebGPUPipelineCache#get} lookup. Identical module
+     * text registers once — the returned key is stable per text, so clones
+     * and same-body effects share the module and every pipeline built on it.
+     * @param {string} code - the complete WGSL module text
+     * @param {object} [options] - family options
+     * @param {GPUBindGroupLayout[]} [options.bindGroupLayouts] - full positional
+     *   bind-group-layout list (defaults to `[frameLayout, materialLayout]`)
+     * @param {string} [options.vertexLayoutKey="quad"] - reuse a registered
+     *   vertex layout under this family (the effect blit rides the quad layout)
+     * @param {string} [options.label] - debug label for the shader module
+     * @returns {string} the family key to pass to {@link WebGPUPipelineCache#get}
+     */
+    registerShader(code: string, options?: {
+        bindGroupLayouts?: GPUBindGroupLayout[] | undefined;
+        vertexLayoutKey?: string | undefined;
+        label?: string | undefined;
+    }): string;
+    /**
+     * Fetch (building on first use) the group-3 bind-group layout for an
+     * effect shape. Effects with the same shape — same uniform block size,
+     * same texture/sampler bindings, same builtins — share one layout, so
+     * their pipeline layouts (and pipelines) are shareable too.
+     * @param {string} signature - the shape signature (caller-composed)
+     * @param {GPUBindGroupLayoutEntry[]} entries - the layout entries
+     * @returns {GPUBindGroupLayout} the cached layout
+     */
+    getEffectLayout(signature: string, entries: GPUBindGroupLayoutEntry[]): GPUBindGroupLayout;
+    /**
+     * Register a shader family's vertex buffer layout from a batcher's
+     * frozen attribute records — the declarative consumption of the
+     * backend-neutral vertex formats (#1492): the records already carry
+     * `format` and `offset` in WebGPU vocabulary, shader locations are
+     * declaration order.
+     * Accepts either the single-buffer form `(key, stride, attributes)` or a
+     * list of buffer groups `(key, [{stride, stepMode, attributes}, …])` —
+     * the latter is what an instanced family registers, with the geometry
+     * group at index 0 and a `stepMode: "instance"` group after it. Shader
+     * locations are assigned in declaration order and continue **across**
+     * groups, since WGSL locations are a single namespace.
+     * @param {string} shaderKey - "quad" | "primitive"
+     * @param {number|object[]} stride - vertex byte stride, or the buffer-group list
+     * @param {{format: string, offset: number}[]} [attributes] - frozen records (single-buffer form)
+     */
+    registerVertexLayout(shaderKey: string, stride: number | object[], attributes?: {
+        format: string;
+        offset: number;
+    }[]): void;
+    /**
+     * Fetch (building on first use) the pipeline for the given state tuple.
+     * @param {string} shaderKey - "quad" | "primitive" | "clear"
+     * @param {string} topology - portable topology name ("triangle-list", …)
+     * @param {string} blendMode - blend mode (normalized internally)
+     * @param {boolean} premultipliedAlpha - source premultiplication flag
+     * @param {string} [stencilMode="none"] - "none" | "write" | "test" | "tag" | "mark"
+     * @param {{cullMode: string, frontFace: string}} [meshState] - mesh pass
+     *   state: its presence switches the depth half of the attachment on —
+     *   depth writes enabled, "less-equal" testing (the GL mesh mode's
+     *   LEQUAL, keeping coplanar geometry stable) — and sets the per-mesh
+     *   face-culling axes. Omitted by the whole 2D tier, whose keys and
+     *   descriptors stay byte-identical to a build without a mesh path.
+     * @returns {GPURenderPipeline} the pipeline
+     */
+    get(shaderKey: string, topology: string, blendMode: string, premultipliedAlpha: boolean, stencilMode?: string, meshState?: {
+        cullMode: string;
+        frontFace: string;
+    }): GPURenderPipeline;
+    /**
+     * drop every cached pipeline (device loss — the whole cache object is
+     * rebuilt by the renderer's restore path, this exists for symmetry)
+     */
+    clear(): void;
+}
+//# sourceMappingURL=cache.d.ts.map

package/build/video/webgpu/pipeline/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/pipeline/cache.js"],"names":[],"mappings":"AAuFA;;;;;;;GAOG;AACH,yCAJW,MAAM,GACJ,MAAM,CAoBlB;AA1GD;;;;;;;GAOG;AACH,gCAAiC,CAAC,CAAC;AAEnC;;;;;;;GAOG;AACH,mCAAoC,sBAAsB,CAAC;AAqK3D;;;;;;;;;;;;GAYG;AACH;IAwKC;;;OAGG;IACH,4BAAwB;IA3KxB;;;OAGG;IACH,oBAHW,SAAS,UACT,MAAM,EAmKhB;IAhKA,kBAAoB;IACpB,eAAoB;IACpB,oBAAoB;IACpB,6CAA6C;IAC7C,WADW,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CACf;IAC1B,kEAAkE;IAClE,eADW,GAAG,CAAC,MAAM,EAAE;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,EAAE,CAAA;KAAC,CAAC,CAChC;IAG9B,gCAaE;IACF,qCAaE;IACF,mCAME;IAYF,uCAQE;IAiBF,wCAGE;IAGF;;;;;MAmBC;IAGD;;;;;MAaC;IAKD,0DAA0D;IAC1D,mBADW,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CACI;IAGlC,+BAAgC;IAChC,mGAAmG;IACnG,qBADW,GAAG,CAAC,MAAM,EAAE;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,EAAE,CAAA;KAAC,CAAC,CAC1B;IAGpC,+EAA+E;IAC/E,eADW,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,CACZ;IAM9B,gCAGE;IACF,6BAIE;IAEF;;;;;;OAMG;IACH,OAFU,MAAM,CAE+B;IAShD;;;;;;;;;;;;;OAaG;IACH,qBATW,MAAM,YAEd;QAAuC,gBAAgB;QAE9B,eAAe;QAEf,KAAK;KAC9B,GAAU,MAAM,CAsClB;IAED;;;;;;;;OAQG;IACH,2BAJW,MAAM,WACN,uBAAuB,EAAE,GACvB,kBAAkB,CAY9B;IAED;;;;;;;;;;;;;;;OAeG;IACH,gCAJW,MAAM,UACN,MAAM,GAAC,MAAM,EAAE,eACf;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,EAAE,QAqC5C;IAED;;;;;;;;;;;;;;OAcG;IACH,eAbW,MAAM,YACN,MAAM,aACN,MAAM,sBACN,OAAO,gBACP,MAAM,cACN;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,GAMnC,iBAAiB,CA4E7B;IAED;;;OAGG;IACH,cAEC;CACD"}

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

@@ -0,0 +1,90 @@
+/**
+ * GPU-accelerated renderer for orthogonal TMX tile layers on the WebGPU
+ * backend — the WGSL realization of the WebGL shader tile path: the
+ * visible region draws as ONE quad per tileset, with the fragment shader
+ * sampling a per-layer GID index texture and the tileset atlas.
+ *
+ * Structure mirrors the WebGL twin; the mechanisms are the backend's:
+ * - the GID index / animation lookup are renderer-owned `rgba8unorm`
+ *   textures written with `queue.writeTexture` (byte-exact `textureLoad`
+ *   reads, no sampler needed) — re-uploaded only when `layer.dataVersion`
+ *   moves or an animation frame advances
+ * - the per-draw uniforms snapshot into the effect uniform arena with a
+ *   dynamic offset (each tileset pass gets its own region, per the
+ *   queue-write-before-draws ordering)
+ * - the tileset atlas rides the standard texture-store material path
+ * - pipelines flow through the registered `tmxlayer.wgsl` family, keyed
+ *   on the frame's blend/stencil state like every other draw
+ * @ignore
+ */
+export default class OrthogonalTMXLayerGPURenderer {
+    /**
+     * @param {WebGPURenderer} renderer - the WebGPU renderer instance
+     */
+    constructor(renderer: WebGPURenderer);
+    renderer: WebGPURenderer;
+    tmxLayout: GPUBindGroupLayout;
+    key: string;
+    epoch: number;
+    /**
+     * per-layer GID index texture: layer → {texture, view, version}
+     * @type {Map<TMXLayer, object>}
+     */
+    resources: Map<TMXLayer, object>;
+    /**
+     * per-tileset animation lookup: tileset → {texture, view, data, tileCount}
+     * @type {Map<object, object>}
+     */
+    animLookups: Map<object, object>;
+    /**
+     * per-(layer, tileset) cached group-3 bind group, keyed on the
+     * uniform arena page it binds
+     * @type {Map<TMXLayer, Map<object, {bindGroup: GPUBindGroup, pageLabel: string, animView: object}>>}
+     */
+    bindGroups: Map<TMXLayer, Map<object, {
+        bindGroup: GPUBindGroup;
+        pageLabel: string;
+        animView: object;
+    }>>;
+    uniformScratch: Float32Array<ArrayBuffer>;
+    vertexScratch: ArrayBuffer;
+    vertexF32: Float32Array<ArrayBuffer>;
+    vertexU32: Uint32Array<ArrayBuffer>;
+    /**
+     * Retire every lookup texture and empty the local maps — called from
+     * `WebGPURenderer.reset()` (GAME_RESET) so each level starts clean.
+     * @ignore
+     */
+    reset(): void;
+    /**
+     * Get-or-create the per-layer GID index texture, re-uploading when the
+     * layer's data version moved (`setTile`/`clearTile` mutations).
+     * @param {TMXLayer} layer - the layer
+     * @returns {{texture: GPUTexture, view: GPUTextureView, version: number}}
+     * @ignore
+     */
+    getResource(layer: TMXLayer): {
+        texture: GPUTexture;
+        view: GPUTextureView;
+        version: number;
+    };
+    /**
+     * Get-or-update the per-tileset animation lookup (undefined for
+     * tilesets without animated tiles). Texel `localId` encodes the
+     * CURRENT frame's local id as (R = lo byte, G = hi byte).
+     * @param {object} tileset - the tileset
+     * @param {number} tileCount - atlas grid tile count
+     * @returns {object|undefined} the lookup entry
+     * @ignore
+     */
+    getOrUpdateAnimLookup(tileset: object, tileCount: number): object | undefined;
+    /**
+     * Draw an orthogonal TMX layer through the shader path.
+     * @param {TMXLayer} layer - the layer to draw
+     * @param {object} rect - the visible viewport rect (world coords)
+     */
+    draw(layer: TMXLayer, rect: object): void;
+}
+import type { default as WebGPURenderer } from "../../webgpu_renderer.js";
+import type { default as TMXLayer } from "../../../../level/tiled/TMXLayer.js";
+//# sourceMappingURL=orthogonal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"orthogonal.d.ts","sourceRoot":"","sources":["../../../../../src/video/webgpu/renderers/tmxlayer/orthogonal.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACC;;OAEG;IACH,sBAFW,cAAc,EAwDxB;IArDA,yBAAwB;IAIxB,8BAYE;IACF,YASE;IAGF,cAAwB;IAExB;;;OAGG;IACH,WAFU,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,CAEL;IAC1B;;;OAGG;IACH,aAFU,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAED;IAC5B;;;;OAIG;IACH,YAFU,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE;QAAC,SAAS,EAAE,YAAY,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC,CAEzE;IAG3B,0CAA4D;IAC5D,2BAA4C;IAC5C,qCAAqD;IACrD,oCAAoD;IAGrD;;;;OAIG;IACH,cAUC;IAED;;;;;;OAMG;IACH,mBAJW,QAAQ,GACN;QAAC,OAAO,EAAE,UAAU,CAAC;QAAC,IAAI,EAAE,cAAc,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CA4BxE;IAED;;;;;;;;OAQG;IACH,+BALW,MAAM,aACN,MAAM,GACJ,MAAM,GAAC,SAAS,CA2D5B;IAED;;;;OAIG;IACH,YAHW,QAAQ,QACR,MAAM,QA2MhB;CACD;+CA/Z6C,0BAA0B;yCADhC,qCAAqC"}

package/build/video/webgpu/shaders/mesh-instanced.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Derive an instanced mesh WGSL module from the ordinary one (#1508).
+ *
+ * WGSL has no preprocessor, and a module carries **both** entry points in
+ * one file — so an instanced variant cannot be a second vertex file the way
+ * it is on the WebGL side. Rather than copy the module (which for the lit
+ * tier would duplicate the whole lighting loop, and the `Light3dBlock`
+ * layout that must agree byte-for-byte with the uniform packer), this
+ * rewrites the shared source:
+ *
+ * - everything before `@vertex` is kept — structs, bindings, `VSOut` —
+ *   with one extra inter-stage field when the custom slot is in play;
+ * - the vertex stage is replaced with one that reads the per-instance
+ *   attributes and applies them;
+ * - the fragment stage is kept **verbatim**, apart from one substitution
+ *   that folds the per-instance slot into the emissive term.
+ *
+ * So the lighting loop, the light block and the alpha-cutout rule exist in
+ * exactly one place, and an instanced mesh shades identically to its
+ * uninstanced twin by construction rather than by review.
+ *
+ * Shader locations for the instance slots are **pinned**
+ * (`INSTANCE_SLOT_OFFSETS`), so a variant that omits the colour slot does
+ * not renumber the data slot.
+ * @param {string} source - the ordinary module (`mesh.wgsl` / `mesh-lit.wgsl`)
+ * @param {object} options - variant options
+ * @param {number} options.baseLocation - first vertex location after the tier's geometry attributes
+ * @param {number} options.varyingLocation - first free inter-stage location in `VSOut`
+ * @param {boolean} options.hasColor - whether the per-instance colour slot is present
+ * @param {boolean} options.hasData - whether the per-instance custom slot is present
+ * @param {string} options.geometryInputs - the tier's geometry attribute declarations
+ * @param {string} options.body - the tier's placement body, which reads the `instance` matrix the generated preamble declares and must leave a `clip` value for the shared tail
+ * @returns {string} the instanced module text
+ * @ignore
+ */
+export function buildInstancedMeshWGSL(source: string, options: {
+    baseLocation: number;
+    varyingLocation: number;
+    hasColor: boolean;
+    hasData: boolean;
+    geometryInputs: string;
+    body: string;
+}): string;
+export namespace UNLIT_INSTANCED {
+    let baseLocation: number;
+    let varyingLocation: number;
+    let geometryInputs: string;
+    let body: string;
+}
+export namespace LIT_INSTANCED {
+    let baseLocation_1: number;
+    export { baseLocation_1 as baseLocation };
+    let varyingLocation_1: number;
+    export { varyingLocation_1 as varyingLocation };
+    let geometryInputs_1: string;
+    export { geometryInputs_1 as geometryInputs };
+    let body_1: string;
+    export { body_1 as body };
+}
+//# sourceMappingURL=mesh-instanced.d.ts.map

package/build/video/webgpu/shaders/mesh-instanced.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh-instanced.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/shaders/mesh-instanced.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,+CAXW,MAAM,WAEd;IAAwB,YAAY,EAA5B,MAAM;IACU,eAAe,EAA/B,MAAM;IACW,QAAQ,EAAzB,OAAO;IACU,OAAO,EAAxB,OAAO;IACS,cAAc,EAA9B,MAAM;IACU,IAAI,EAApB,MAAM;CACd,GAAU,MAAM,CAkIlB"}

package/build/video/webgpu/texture/compressed.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Upload every mip level of a parsed CompressedImage into a GPUTexture
+ * via queue.writeTexture (block-aligned rows, largest mip first — the
+ * parser contract).
+ * @param {GPUDevice} device - the device
+ * @param {GPUTexture} texture - destination created with the mapped format
+ * @param {object} image - the parsed CompressedImage ({mipmaps, format})
+ * @param {object} metrics - the COMPRESSED_FORMATS entry for image.format
+ * @ignore
+ */
+export function uploadCompressedTexture(device: GPUDevice, texture: GPUTexture, image: object, metrics: object): void;
+/**
+ * WebGL compressed-format constant → WebGPU texture format + block
+ * metrics. The loader parsers (dds/pvr/pkm/ktx/ktx2) are backend-neutral
+ * and emit WebGL enum constants; this table is the WebGPU side of that
+ * contract. Families gate on the device features requested at init:
+ * "texture-compression-bc", "texture-compression-etc2",
+ * "texture-compression-astc" (PVRTC has no WebGPU equivalent).
+ * @ignore
+ */
+export const COMPRESSED_FORMATS: Map<number, {
+    format: string;
+    blockW: number;
+    blockH: number;
+    bytes: number;
+}>;
+/**
+ * the optional device features the renderer requests when the adapter
+ * offers them
+ * @ignore
+ */
+export const COMPRESSION_FEATURES: string[];
+//# sourceMappingURL=compressed.d.ts.map

package/build/video/webgpu/texture/compressed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compressed.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/texture/compressed.js"],"names":[],"mappings":"AA+DA;;;;;;;;;GASG;AACH,gDANW,SAAS,WACT,UAAU,SACV,MAAM,WACN,MAAM,QAoBhB;AA1FD;;;;;;;;GAQG;AACH;;;;;GAyCG;AAEH;;;;GAIG;AACH,4CAIE"}