melonjs 20.3.0 → 20.5.0

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

@@ -1,68 +1,2 @@
-/**
- * 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

@@ -1 +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"}
+{"version":3,"file":"uniformring.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/buffer/uniformring.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;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;IA4CD;;;;;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

@@ -1,17 +1,2 @@
-/**
- * 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

@@ -1 +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"}
+{"version":3,"file":"effect_binding.d.ts","sourceRoot":"","sources":["../../../src/video/webgpu/effect_binding.js"],"names":[],"mappings":"AAkPA;;;;;;;;;;GAUG;AACH,+CAPW,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,CAgJ/G"}

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

@@ -1,36 +1,5 @@
-/**
- * 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

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

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

@@ -1,164 +1,2 @@
-/**
- * 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

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/pipeline/cache.js"],"names":[],"mappings":"AA6BA;;;;;;;GAOG;AACH,gCAAiC,CAAC,CAAC;AAEnC;;;;;;;GAOG;AACH,mCAAoC,sBAAsB,CAAC;AA6E3D;;;;;;;;;;;;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"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/pipeline/cache.js"],"names":[],"mappings":"AA8BA;;;;;;;;GAQG;AACH,gCAAiC,CAAC,CAAC;AAEnC;;;;;;;;GAQG;AACH,mCAAoC,sBAAsB,CAAC;AA8E3D;;;;;;;;;;;;;GAaG;AACH;IAwKC;;;;OAIG;IACH,4BAAwB;IA5KxB;;;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;IAUhD;;;;;;;;;;;;;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,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,CAAC;QAAC,GAAG,CAAC,EAAE,OAAO,CAAA;KAAC,GAMxE,iBAAiB,CAyF7B;IAED;;;OAGG;IACH,cAEC;CACD"}

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

@@ -1,90 +1,4 @@
-/**
- * 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

@@ -1 +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"}
+{"version":3,"file":"orthogonal.d.ts","sourceRoot":"","sources":["../../../../../src/video/webgpu/renderers/tmxlayer/orthogonal.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;GAmBG;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;;;;;OAKG;IACH,cAUC;IAED;;;;;;;OAOG;IACH,mBALW,QAAQ,GACN;QAAC,OAAO,EAAE,UAAU,CAAC;QAAC,IAAI,EAAE,cAAc,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CA6BxE;IAED;;;;;;;;;OASG;IACH,+BANW,MAAM,aACN,MAAM,GACJ,MAAM,GAAC,SAAS,CA4D5B;IAED;;;;OAIG;IACH,YAHW,QAAQ,QACR,MAAM,QA2MhB;CACD;+CApa6C,0BAA0B;yCADhC,qCAAqC"}

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

@@ -1,46 +1,4 @@
-/**
- * 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;

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

@@ -1 +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"}
+{"version":3,"file":"mesh-instanced.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/shaders/mesh-instanced.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,+CAZW,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,CAmIlB"}

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

@@ -1,33 +1,2 @@
-/**
- * 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

@@ -1 +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"}
+{"version":3,"file":"compressed.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/texture/compressed.js"],"names":[],"mappings":"AAiEA;;;;;;;;;;GAUG;AACH,gDAPW,SAAS,WACT,UAAU,SACV,MAAM,WACN,MAAM,QAqBhB;AA7FD;;;;;;;;;GASG;AACH;;;;;GAyCG;AAEH;;;;;GAKG;AACH,4CAIE"}

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

@@ -1,65 +1,4 @@
-/**
- * The WebGPU counterpart of the WebGL `FrameTexture`: a GPU-resident
- * capture of the frame rendered so far, refreshed IN PLACE by
- * {@link WebGPURenderer#captureFrame} via `copyTextureToTexture` — an
- * encoder-ordered command, so the copy sees exactly the draws recorded
- * before the capture point and none after (no queue-write retroactivity).
- *
- * Effects sample it through the `screen_texture` builtin: the effect's
- * group-3 bind group binds `view`, keyed by `generation` so a size-change
- * reallocation rebuilds stale bind groups. `isGPUResident` keeps the
- * `setTexture` discriminant contract of the WebGL twin.
- * @augments Texture2d
- * @ignore
- */
-export class WebGPUFrameTexture extends Texture2d {
-    /**
-     * monotonic generation source shared by every capture instance
-     * @ignore
-     */
-    static generationCounter: number;
-    /**
-     * @param {import("../webgpu_renderer.js").default} renderer - the owning renderer
-     * @param {number} width - capture width in pixels
-     * @param {number} height - capture height in pixels
-     */
-    constructor(renderer: import("../webgpu_renderer.js").default, width: number, height: number);
-    renderer: import("../webgpu_renderer.js").default;
-    /**
-     * marks this as a live GPU-resident source — see {@link ShaderEffect#setTexture}
-     * @type {boolean}
-     */
-    isGPUResident: boolean;
-    /** @type {GPUTexture} */
-    gpuTexture: GPUTexture;
-    /**
-     * (Re)allocate the backing texture at the given size, keeping this
-     * object's identity — the caller-owned-refresh contract of
-     * `toFrameTexture({target})`. The old texture is retired (draws
-     * already recorded against it stay valid) and `generation` advances,
-     * so bind groups referencing the old view re-key instead of pointing
-     * at a destroyed texture and failing every subsequent submit.
-     * @param {number} width - capture width in pixels
-     * @param {number} height - capture height in pixels
-     */
-    realloc(width: number, height: number): void;
-    /** @type {number} */
-    width: number | undefined;
-    /** @type {number} */
-    height: number | undefined;
-    /**
-     * unique per allocation (module-wide counter) — the bind-group key
-     * @type {number}
-     */
-    generation: number | undefined;
-    /** @type {GPUTextureView} */
-    view: GPUTextureView | undefined;
-    /**
-     * The opaque GPU-resident backing — itself.
-     * @returns {WebGPUFrameTexture}
-     */
-    getTexture(): WebGPUFrameTexture;
-}
+
 export default WebGPUFrameTexture;
 import Texture2d from "../../texture/texture2d.ts";
 //# sourceMappingURL=frametexture.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"frametexture.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/texture/frametexture.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH;IACC;;;OAGG;IACH,iCAA6B;IAE7B;;;;OAIG;IACH,sBAJW,OAAO,uBAAuB,EAAE,OAAO,SACvC,MAAM,UACN,MAAM,EAahB;IATA,kDAAwB;IACxB;;;OAGG;IACH,eAFU,OAAO,CAEQ;IACzB,yBAAyB;IACzB,YADW,UAAU,CACC;IAIvB;;;;;;;;;OASG;IACH,eAHW,MAAM,UACN,MAAM,QAuBhB;IAjBA,qBAAqB;IACrB,0BAAkB;IAClB,qBAAqB;IACrB,2BAAoB;IACpB;;;OAGG;IACH,+BAAwD;IAOxD,6BAA6B;IAC7B,iCAAwC;IAGzC;;;OAGG;IACH,cAFa,kBAAkB,CAI9B;CAaD;;sBA7FqB,4BAA4B"}
+{"version":3,"file":"frametexture.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/texture/frametexture.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;OAIG;IACH,iCAA6B;IAE7B;;;;OAIG;IACH,sBAJW,OAAO,uBAAuB,EAAE,OAAO,SACvC,MAAM,UACN,MAAM,EAahB;IATA,kDAAwB;IACxB;;;OAGG;IACH,eAFU,OAAO,CAEQ;IACzB,yBAAyB;IACzB,YADW,UAAU,CACC;IAIvB;;;;;;;;;OASG;IACH,eAHW,MAAM,UACN,MAAM,QAuBhB;IAjBA,qBAAqB;IACrB,0BAAkB;IAClB,qBAAqB;IACrB,2BAAoB;IACpB;;;OAGG;IACH,+BAAwD;IAOxD,6BAA6B;IAC7B,iCAAwC;IAGzC;;;OAGG;IACH,cAFa,kBAAkB,CAI9B;CAaD;;sBA/FqB,4BAA4B"}