melonjs 19.9.0 → 20.0.0

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"}

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

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

@@ -0,0 +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"}

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

@@ -0,0 +1,149 @@
+/**
+ * Renderer-owned GPU texture store for the WebGPU backend — the counterpart
+ * of `MaterialBatcher`'s createTexture2D/bindTexture2D/deleteTexture2D tier,
+ * kept on the renderer (rather than a batcher) so the quad path and the
+ * future mesh / tile-layer paths share one resident-texture map.
+ *
+ * The engine-side bookkeeping is untouched: `TextureCache` still allocates
+ * the logical "unit" for each `(source, repeat)` pair; here a unit keys a
+ * `{GPUTexture, view, bind groups}` record instead of a GL texture binding.
+ * Bind groups pair the texture view with a cached `GPUSampler` — one bind
+ * group per (texture, sampler) combination, invalidated wholesale when the
+ * filter setting changes (textures stay resident; only the pairing is
+ * rebuilt — the WebGPU analogue of `_reapplyTextureFilter`, without the
+ * re-parameterization).
+ * @ignore
+ */
+export default class WebGPUTextureStore extends TextureStore {
+    /**
+     * @param {import("../webgpu_renderer.js").default} renderer - the owning renderer
+     */
+    constructor(renderer: import("../webgpu_renderer.js").default);
+    renderer: import("../webgpu_renderer.js").default;
+    device: GPUDevice | undefined;
+    /** @type {Map<string, GPUSampler>} */
+    samplers: Map<string, GPUSampler>;
+    onCacheReset: () => void;
+    /**
+     * resolve (creating on first use) the sampler for a filter/wrap combo
+     * @param {string} filter - "nearest" | "linear"
+     * @param {string} repeat - engine wrap mode string
+     * @returns {GPUSampler} the sampler
+     * @ignore
+     */
+    getSampler(filter: string, repeat: string, mipmaps?: boolean): GPUSampler;
+    /**
+     * The per-draw entry point: resolve the atlas to a bind group pairing
+     * its resident GPU texture with the currently-applicable sampler,
+     * uploading the source on first use (or re-uploading when forced — the
+     * video-frame path).
+     * @param {object} texture - a TextureAtlas
+     * @param {object} [options] - resolution options
+     * @param {boolean} [options.force=false] - re-upload the source pixels
+     * @param {string} [options.repeat] - per-use wrap override (else texture.repeat)
+     * @returns {GPUBindGroup} the material bind group for this draw
+     */
+    getBinding(texture: object, options?: {
+        force?: boolean | undefined;
+        repeat?: string | undefined;
+    }): GPUBindGroup;
+    lastRecord: {
+        handle: any;
+        version: number;
+        generation: number;
+    } | undefined;
+    /**
+     * Build the full mip chain of a freshly-uploaded record: one blit pass
+     * per level, each rendering the previous level with linear filtering.
+     * Runs in its own encoder submitted immediately — queue ordering places
+     * it after the level-0 copy (a queue operation) and before the frame's
+     * own command buffer, so the frame's draws sample a complete chain.
+     * @param {object} record - the resident record (mipLevelCount > 1)
+     * @ignore
+     */
+    generateMipmaps(record: object): void;
+    mipLayout: GPUBindGroupLayout | undefined;
+    mipPipeline: GPURenderPipeline | undefined;
+    mipSampler: GPUSampler | undefined;
+    /**
+     * Resolve the view + sampler a resident record should be bound with,
+     * plus the cache key identifying that pair. Shared by the one-texture
+     * material path and the mesh path, so the two cannot drift on which
+     * view a mip-wanting consumer gets.
+     * @ignore
+     */
+    viewAndSampler(record: any, texture: any, wrap: any, wantMips: any): {
+        view: any;
+        sampler: GPUSampler;
+        key: string;
+    };
+    /**
+     * The group-1 material for a MESH: the diffuse texture/sampler pair plus
+     * the per-texel opacity pair (MTL `map_d`, #1575).
+     *
+     * Always four bindings. A mesh with no alpha map passes the shared white
+     * pixel, whose red channel is 1 — so the shader's multiply is a no-op and
+     * the same pipeline layout serves both cases rather than splitting the
+     * mesh family in two.
+     * @param {TextureAtlas} texture - the diffuse texture
+     * @param {TextureAtlas} alphaTexture - the opacity map, or the white pixel
+     * @param {object} [options] - wrap / mipmap options, as `getBinding` takes
+     * @returns {GPUBindGroup} the group-1 bind group
+     * @ignore
+     */
+    getMeshBinding(texture: TextureAtlas, alphaTexture: TextureAtlas, options?: object): GPUBindGroup;
+    /**
+     * the per-sampler material bind group for a resident record (shared by
+     * the image and compressed upload paths)
+     * @ignore
+     */
+    bindGroupFor(record: any, texture: any, wrap: any, wantMips?: boolean): any;
+    /**
+     * Ensure the texture is resident (same upload/validation path as
+     * getBinding) and return its record — callers composing their own bind
+     * groups (the lit batcher pairs the color view with a normal map) need
+     * the raw view rather than the standard material group.
+     * @param {object} texture - the texture atlas to resolve
+     * @param {object} [options] - same options as getBinding
+     * @returns {object} the resident record ({texture, view, width, height, …})
+     */
+    getResidentRecord(texture: object, options?: object): object;
+    /**
+     * Dispose of a GPUTexture safely: while a frame is being recorded the
+     * texture may be referenced by already-recorded draws (destroying it
+     * would make `queue.submit()` reject the whole command buffer), so it
+     * parks on the renderer's retired list and is destroyed after submit.
+     * @param {GPUTexture} gpuTexture - the texture to dispose of
+     * @ignore
+     */
+    retire(gpuTexture: GPUTexture): void;
+    /**
+     * drop every (texture, sampler) bind-group pairing while keeping the
+     * textures resident — the filter setting changed and the next draw
+     * re-pairs each texture with the newly-resolved sampler
+     */
+    invalidateBindGroups(): void;
+    /**
+     * Destroy the resident GPU texture(s) associated with an image — every
+     * `(source, repeat)` unit the cache knows about, mirroring
+     * `MaterialBatcher.deleteTexture2D`'s multi-repeat sweep.
+     * @param {object} texture - a TextureAtlas
+     */
+    destroyTexture(texture: object): void;
+    /**
+     * drop every unit association and dispose of the resident textures
+     */
+    /**
+     * Release the GPU texture behind a record. The base calls this; the device
+     * defers the actual destroy until the frame that referenced it has retired.
+     * @param {GPUTexture} handle - the texture to release
+     * @ignore
+     */
+    onDestroy(handle: GPUTexture): void;
+    /**
+     * full teardown (device loss / renderer destroy)
+     */
+    destroy(): void;
+}
+import { TextureStore } from "../../gpu/texturestore.js";
+//# sourceMappingURL=store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/texture/store.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AACH;IACC;;OAEG;IACH,sBAFW,OAAO,uBAAuB,EAAE,OAAO,EAoBjD;IAhBA,kDAAwB;IACxB,8BAA6B;IAC7B,sCAAsC;IACtC,UADW,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CACT;IAKzB,yBAMC;IAIF;;;;;;OAMG;IACH,mBALW,MAAM,UACN,MAAM,sBACJ,UAAU,CAkCtB;IAED;;;;;;;;;;OAUG;IACH,oBANW,MAAM,YAEd;QAA0B,KAAK;QACN,MAAM;KAC/B,GAAU,YAAY,CAuMxB;IAlHE;;;;kBAAwB;IAoH3B;;;;;;;;OAQG;IACH,wBAHW,MAAM,QAyEhB;IA/DC,0CAME;IAIF,2CAYE;IACF,mCAIE;IAsCJ;;;;;;OAMG;IACH;;;;MAqBC;IAED;;;;;;;;;;;;;OAaG;IACH,wBANW,YAAY,gBACZ,YAAY,YACZ,MAAM,GACJ,YAAY,CAmExB;IAED;;;;OAIG;IACH,4EAeC;IAED;;;;;;;;OAQG;IACH,2BAJW,MAAM,YACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;OAOG;IACH,mBAHW,UAAU,QAKpB;IAED;;;;OAIG;IACH,6BAIC;IAED;;;;;OAKG;IACH,wBAFW,MAAM,QAchB;IAED;;OAEG;IACH;;;;;OAKG;IACH,kBAHW,UAAU,QAKpB;IAED;;OAEG;IACH,gBAIC;CACD;6BAzkB4B,2BAA2B"}