melonjs 19.9.1 → 20.0.0

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