melonjs 20.2.0 → 20.4.0

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

@@ -1,12 +1,4 @@
-/**
- * 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,
@@ -53,169 +45,7 @@ export default class WebGPUMeshBatcher extends WebGPUBatcher {
     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
@@ -226,15 +56,6 @@ export default class WebGPUMeshBatcher extends WebGPUBatcher {
      * @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
@@ -243,56 +64,6 @@ export default class WebGPUMeshBatcher extends WebGPUBatcher {
      * @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";

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

@@ -1 +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"}
+{"version":3,"file":"mesh_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/batchers/mesh_batcher.js"],"names":[],"mappings":"AA8BA;;;;;;;;;GASG;AACH,gCAAiC,GAAG,CAAC;AAWrC;;;;;;;;;;;;;;;;;;;;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;;;;;OAKG;IACH;;;;;MAEC;IAED;;;;;;;;;;;;;OAaG;IACH,2BALW,MAAM,GACJ,MAAM,CAoClB;IAED;;;;;;;OAOG;IACH,wBALW,aAAa,GACX,oBAAoB,CAwBhC;IAED;;;;;;;OAOG;IACH,wBANW,aAAa,eACb,QAAQ,QACR,MAAM,QAmFhB;IAtDC,2CAAiC;IAwDnC;;;;;;;;;;;OAWG;IACH,8BALW,MAAM,GACJ,MAAM,CA6ClB;IAED;;;;;;;;;OASG;IACH,0BAPW,aAAa,gBACb,QAAQ,QACR,MAAM,QACN,MAAM,QA4DhB;IAED;;;;;OAKG;IACH,uBAJW,MAAM,QAUhB;IAED;;;;OAIG;IACH,4BAKC;IAED;;;;;OAKG;IACH;;;;;;;;MAMC;IAED;;;;OAIG;IACH,oBAEC;IAED;;;;;;;OAOG;IACH;;;;QAkBC;IAED;;;;OAIG;IACH,2BAEC;IAED;;;;;;;;;;;;OAYG;IACH,mBAJa,MAAM,CAmBlB;IAED;;;;;OAKG;IACH,uCAOC;IAED;;;;;;;;;;;;;OAaG;IACH,wBARW,MAAM,YACN,YAAY,QAmCtB;IAED;;;;;;;;;;;OAWG;IACH,kCAPW,QAAQ,QAER,MAAM,QACN,MAAM,QA0GhB;IAED;;;;;;OAMG;IACH,4GAEC;IAED;;;;;;;;OAQG;IACH,cAHW,MAAM,QACN,MAAM,QAsBhB;IAED;;;;;;;;OAQG;IACH,sBANW,MAAM,QACN,MAAM,UACN,MAAM,QAuEhB;IAED;;;;;;OAMG;IACH,uBAuEC;IAED;;;;;OAKG;IACH,4BAEC;IAED;;;;;;;;;OASG;IACH,8BANW,MAAM,OACN,YAAY,GACV,MAAM,CAMlB;IAED;;;;;;;OAOG;IACH,0BALW,MAAM,GACJ,sBAAsB,CAiBlC;IAED;;;;;;;;;;;;;;OAcG;IACH,uBANW,MAAM,eACN,QAAQ,QACR,MAAM,QA4EhB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,QAWhB;IAED;;;;OAIG;IACH,2BAMC;CAsBD;0BA7lCyB,qBAAqB;iCARd,8BAA8B;yBATtC,2BAA2B;mCAUjB,gCAAgC"}

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

@@ -1 +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"}
+{"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;;CA0ID;0BAjRyB,qBAAqB;2BAIvB,gCAAgC"}

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

@@ -23,18 +23,11 @@ export default class WebGPUQuadBatcher extends WebGPUBatcher {
     currentMaterial: any;
     currentEffect: any;
     slotTable: TextureSlotTable | undefined;
-    _memoView: any;
     /** @type {{view: GPUTextureView, sampler: GPUSampler}[]} indexed by slot */
     segmentEntries: {
         view: GPUTextureView;
         sampler: GPUSampler;
     }[] | undefined;
-    /** @ignore */
-    _memoFilter: any;
-    /** @ignore */
-    _memoWrap: any;
-    /** @ignore */
-    _memoSlot: number | undefined;
     segmentGroup: GPUBindGroup | null | undefined;
     /** @type {Map<string, GPUBindGroup>} */
     composedGroups: Map<string, GPUBindGroup> | undefined;
@@ -58,37 +51,6 @@ export default class WebGPUQuadBatcher extends WebGPUBatcher {
      * @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
@@ -96,54 +58,10 @@ export default class WebGPUQuadBatcher extends WebGPUBatcher {
      * 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";

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

@@ -1 +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,uBAwGjD;IAjEA,qBAA2B;IAM3B,mBAAyB;IASzB,wCAcE;IAHC,eAAqB;IAIxB,4EAA4E;IAC5E;cADkB,cAAc;iBAAW,UAAU;oBAC7B;IAGxB,cAAc;IACd,iBAAuB;IACvB,cAAc;IACd,eAAqB;IACrB,cAAc;IACd,8BAAkB;IAElB,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,CAuDlB;IAED;;;OAGG;IACH,+BAOC;IAED;;;;;;;OAOG;IACH,uBAHa,YAAY,CA+BxB;IAED;;;OAGG;IACH,qBAQC;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;0BA3kByB,qBAAqB;iCAHd,2BAA2B"}
+{"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,uBAqHjD;IA9EA,qBAA2B;IAM3B,mBAAyB;IASzB,wCAcE;IAHC,eAAqB;IAIxB,4EAA4E;IAC5E;cADkB,cAAc;iBAAW,UAAU;oBAC7B;IAOxB;;;OAGG;IACH,iBAAuB;IACvB;;;OAGG;IACH,eAAqB;IACrB;;;OAGG;IACH,8BAAkB;IAElB,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;;;;;;;;;;;OAWG;IACH,wBANW,MAAM,YACN,OAAO,GACL,MAAM,CAwDlB;IAED;;;;OAIG;IACH,+BAOC;IAED;;;;;;;;OAQG;IACH,uBAJa,YAAY,CAgCxB;IAED;;;;OAIG;IACH,qBAQC;IAED;;;;;OAKG;IACH,2BAGC;IAED;;;;;;;;;;OAUG;IACH,0HAgBC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,oBAVW,OAAO,0CAA0C,EAAE,OAAO,KAC1D,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,WACN,YAAY,cACZ,OAAO,QA0DjB;IAqBD;;OAEG;IACH,oCA6BC;IAED;;;;;;OAMG;IACH,8BAEC;IAED;;;;;;;OAOG;IACH,yBAJW,MAAM,QAwChB;CAwBD;0BAhmByB,qBAAqB;iCAHd,2BAA2B"}

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

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

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

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

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

@@ -1 +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"}
+{"version":3,"file":"instance_buffer.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/buffer/instance_buffer.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;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;;;;;;;;;;;;;;OAcG;IACH,oBAPW,MAAM,cACN,MAAM,cACN,MAAM,QACN,YAAY,QAYtB;IAED;;OAEG;IACH,gBAOC;CACD"}

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

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

@@ -1 +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"}
+{"version":3,"file":"retained_geometry.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/buffer/retained_geometry.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;GAiBG;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;;;;;OAKG;IACH,uBAWC;IAED;;;OAGG;IACH,gBAKC;CACD"}