melonjs 19.9.1 → 20.1.0

package/build/video/renderer.d.ts

@@ -104,11 +104,75 @@ declare class Renderer {
      */
     path2D: Path2D;
     /**
-     * The renderer type : Canvas, WebGL, etc...
-     * (override this property with a specific value when implementing a custom renderer)
+     * The renderer backend identity — the built-in renderers report
+     * `"CANVAS"`, `"WebGL2"` and `"WebGPU"`. Use it for identity
+     * checks (code coupled to one backend's machinery); prefer the
+     * capability flags (`shaderLanguage`, `supportsDepthBuffer`,
+     * `supportsRetainedMesh`, `supportsShaderTileLayers`) when the
+     * requirement is a capability rather than a specific backend.
+     * (override this property with a specific value when implementing
+     * a custom renderer)
      * @type {string}
      */
     type: string;
+    /**
+     * The {@link Application} this renderer belongs to, set by
+     * `Application.init()` — engine code holding a renderer reference
+     * must use this rather than the global game instance.
+     * @type {Application|undefined}
+     */
+    parentApplication: Application | undefined;
+    /**
+     * Whether this renderer backend can draw TMX tile layers through a
+     * GPU shader path (see the `gpuTilemap` application setting).
+     * `false` here on the base/Canvas renderer; GPU backends flip it.
+     * A capability flag rather than a version/class check so future
+     * backends advertise support without consumers growing type checks.
+     * @type {boolean}
+     * @default false
+     */
+    supportsShaderTileLayers: boolean;
+    /**
+     * Whether this renderer backend can keep mesh geometry resident on the
+     * GPU, letting a mesh supply a model matrix instead of vertices it has
+     * already positioned itself. `false` here on the base/Canvas renderer.
+     * @type {boolean}
+     * @default false
+     */
+    supportsRetainedMesh: boolean;
+    /**
+     * Whether this renderer backend can draw one geometry many times in a
+     * single call from per-instance data — what {@link InstancedMesh}
+     * needs. `false` here on the base/Canvas renderer, which falls back to
+     * drawing each instance individually.
+     * @type {boolean}
+     * @default false
+     */
+    supportsInstancing: boolean;
+    /**
+     * The source language this backend accepts for user-supplied shaders,
+     * or `null` when it has no programmable pipeline at all (the Canvas
+     * backend). `"glsl"` on the WebGL backend, `"wgsl"` on the WebGPU
+     * backend.
+     *
+     * Consumers that need a *specific* language — `ShaderEffect` and the
+     * loader's `{vertex, fragment}` shader assets both hand GLSL source
+     * straight to the driver — must compare against the language rather
+     * than test for a GPU backend, or they would accept a backend that
+     * cannot read what they are about to give it.
+     * @type {"glsl"|"wgsl"|null}
+     * @default null
+     */
+    shaderLanguage: "glsl" | "wgsl" | null;
+    /**
+     * Whether this backend has a depth buffer, and with it the 3D
+     * projection and mesh paths a depth-sorted scene needs (`Camera3d`
+     * and any camera declaring `defaultSortOn = "depth"`). `false` here
+     * on the base/Canvas renderer.
+     * @type {boolean}
+     * @default false
+     */
+    supportsDepthBuffer: boolean;
     /**
      * The background color used to clear the main framebuffer.
      * Note: alpha value will be set based on the transparent property of the renderer settings.
@@ -168,8 +232,8 @@ declare class Renderer {
     get currentBlendMode(): string;
     set currentDepth(value: number);
     /**
-     * Current per-renderable depth value. GPU batchers (WebGL today,
-     * WebGPU once it lands) push it into the vertex stream as the `z`
+     * Current per-renderable depth value. The GPU batchers (WebGL and
+     * WebGPU) push it into the vertex stream as the `z`
      * component of each vertex — a no-op under the default orthographic
      * projection, used by perspective (Camera3d) to
      * scale and parallax sprites by distance. Mirrors `renderable.depth`,
@@ -190,6 +254,16 @@ declare class Renderer {
      * @returns {number} width of the system Canvas
      */
     get width(): number;
+    /**
+     * Acquire whatever the backend cannot acquire synchronously — awaited by
+     * {@link Application#init} right after the renderer is constructed, and
+     * the reason `Application#init` is asynchronous at all. The Canvas and
+     * WebGL backends have their context by the end of the constructor and
+     * resolve immediately (this default); the WebGPU backend performs its
+     * adapter/device negotiation here.
+     * @returns {Promise<void>} resolves once the renderer is ready to draw
+     */
+    init(): Promise<void>;
     /**
      * prepare the framebuffer for drawing a new frame
      */
@@ -198,16 +272,61 @@ declare class Renderer {
      * render the main framebuffer on screen
      */
     flush(): void;
+    /**
+     * Hold one ground shadow ({@link Mesh#castGroundShadow}) back until the end
+     * of the mesh pass (#1515).
+     *
+     * A blob shadow deliberately writes no depth, so that two overlapping at
+     * one ground height blend instead of fighting. The price of that choice is
+     * that it leaves nothing in the depth buffer to defend itself with: any
+     * opaque mesh drawn afterwards simply paints over it. The ground plane is
+     * exactly that mesh whenever it sorts after the props standing on it — the
+     * common case, because a large plane's single sort key says nothing useful
+     * about where it sits relative to what stands on it.
+     *
+     * So shadows are collected here and drawn once the opaque meshes are down.
+     * Depth *testing* stays on throughout, so a shadow is still correctly
+     * hidden behind geometry genuinely in front of it: deferring changes only
+     * who paints over whom among draws that write no depth.
+     * @param {object} quad - the shared shadow quad
+     * @param {Matrix3d} modelMatrix - where the blob sits (copied, not retained)
+     * @param {number} tint - packed ARGB tint for the draw
+     * @param {object} [instanced] - the `InstancedMesh` whose instance buffer
+     * supplies one blob per instance, for the instanced tier
+     * @ignore
+     */
+    queueGroundShadow(quad: object, modelMatrix: Matrix3d, tint: number, instanced?: object): void;
+    _shadowCount: any;
+    /**
+     * Draw every ground shadow queued since the last drain, then empty the
+     * queue (#1515). Called when the renderer leaves mesh mode, and once more
+     * at end of frame for a scene made only of meshes, which never switches
+     * away from mesh mode on its own.
+     *
+     * Inert on a backend that never queues — the Canvas renderer has no depth
+     * buffer and so no ground shadows at all.
+     */
+    flushGroundShadows(): void;
+    _shadowFlushing: boolean | undefined;
     /**
      * Draw a textured triangle mesh.
      * The mesh object must provide: `vertices` (Float32Array, x/y/z triplets),
      * `uvs` (Float32Array, u/v pairs), `indices` (Uint16Array, triangle indices),
      * `texture` (TextureAtlas), `vertexCount` (number), and optionally
      * `cullBackFaces` (boolean, default true).
-     * WebGL uses hardware depth testing; Canvas uses painter's algorithm (back-to-front sort).
+     *
+     * On the GPU backends (WebGL and WebGPU — hardware depth testing),
+     * passing a `modelMatrix` selects the **retained** path: the mesh's
+     * model-space geometry stays resident on the GPU and the matrix
+     * places it, so redrawing never re-uploads vertices (see
+     * {@link Renderer#supportsRetainedMesh}). Without a matrix the
+     * vertices are taken as already CPU-projected (the 2D-camera path —
+     * the only path the Canvas renderer supports, using painter's
+     * algorithm). `Mesh.draw` selects the right form automatically.
      * @param {Mesh} mesh - a Mesh renderable or compatible object
+     * @param {Matrix3d} [modelMatrix] - the mesh's placement, for the retained path (GPU backends)
      */
-    drawMesh(mesh: Mesh): void;
+    drawMesh(mesh: Mesh, modelMatrix?: Matrix3d): void;
     /**
      * Reset context state
      */
@@ -223,11 +342,23 @@ declare class Renderer {
      * @returns {HTMLCanvasElement}
      */
     getCanvas(): HTMLCanvasElement;
+    /**
+     * Create and return a new Canvas element, sized as requested.
+     *
+     * The instance form of {@link Renderer.createCanvas}. `app.renderer` is
+     * the renderer entry point, and a static is not reachable through an
+     * instance — so this is what user code actually calls.
+     * @param {number} width - width in pixels
+     * @param {number} height - height in pixels
+     * @param {boolean} [returnOffscreenCanvas=false] - return an OffscreenCanvas where supported
+     * @returns {HTMLCanvasElement|OffscreenCanvas} the new canvas
+     */
+    createCanvas(width: number, height: number, returnOffscreenCanvas?: boolean): HTMLCanvasElement | OffscreenCanvas;
     /**
      * return a reference to the current render target corresponding Context
-     * @returns {CanvasRenderingContext2D|WebGLRenderingContext}
+     * @returns {CanvasRenderingContext2D|WebGLRenderingContext|GPUCanvasContext}
      */
-    getContext(): CanvasRenderingContext2D | WebGLRenderingContext;
+    getContext(): CanvasRenderingContext2D | WebGLRenderingContext | GPUCanvasContext;
     /**
      * return the list of supported compressed texture formats.
      * The base implementation returns null for all formats (no GPU
@@ -496,6 +627,20 @@ declare class Renderer {
      * @returns {HTMLCanvasElement|OffscreenCanvas} a new canvas or offscreencanvas (if supported) element representing the tinted image
      */
     tint(src: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas, color: Color | string, mode?: string): HTMLCanvasElement | OffscreenCanvas;
+    /**
+     * Clip the region anything drawn afterwards is confined to.
+     * Implemented by subclasses.
+     * @param {number} x - x position of the clipping rectangle
+     * @param {number} y - y position of the clipping rectangle
+     * @param {number} width - width of the clipping rectangle
+     * @param {number} height - height of the clipping rectangle
+     */
+    clipRect(x: number, y: number, width: number, height: number): void;
+    /**
+     * Reset the current transform back to the identity matrix.
+     * Implemented by subclasses.
+     */
+    resetTransform(): void;
     /**
      * Push the current transform / alpha / clip state onto an internal
      * stack. Pair with {@link Renderer#restore}. Implemented by subclasses.

package/build/video/renderer.d.ts.map

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

package/build/video/rendertarget/canvasrendertarget.d.ts

@@ -11,8 +11,7 @@ declare class CanvasRenderTarget extends RenderTarget {
      * @param {number} width - the desired width of the canvas
      * @param {number} height - the desired height of the canvas
      * @param {object} attributes - The attributes to create both the canvas and context
-     * @param {string} [attributes.context="2d"] - the context type to be created ("2d", "webgl")
-     * @param {boolean} [attributes.preferWebGL1=false] - set to true for force using WebGL1 instead of WebGL2 (if supported)
+     * @param {string} [attributes.context="2d"] - the context type to be created ("2d", "webgl" — a "webgl" request creates a WebGL 2 context — or "webgpu")
      * @param {boolean} [attributes.transparent=false] - specify if the canvas contains an alpha channel
      * @param {boolean} [attributes.offscreenCanvas=false] - will create an offscreenCanvas if true instead of a standard canvas
      * @param {boolean} [attributes.willReadFrequently=false] - Indicates whether or not a lot of read-back operations are planned
@@ -20,7 +19,6 @@ declare class CanvasRenderTarget extends RenderTarget {
      */
     constructor(width: number, height: number, attributes?: {
         context?: string | undefined;
-        preferWebGL1?: boolean | undefined;
         transparent?: boolean | undefined;
         offscreenCanvas?: boolean | undefined;
         willReadFrequently?: boolean | undefined;
@@ -36,11 +34,9 @@ declare class CanvasRenderTarget extends RenderTarget {
         stencil: boolean;
         blendMode: string;
         failIfMajorPerformanceCaveat: boolean;
-        preferWebGL1: boolean;
         powerPreference: string;
     } & {
         context?: string | undefined;
-        preferWebGL1?: boolean | undefined;
         transparent?: boolean | undefined;
         offscreenCanvas?: boolean | undefined;
         willReadFrequently?: boolean | undefined;
@@ -48,7 +44,12 @@ declare class CanvasRenderTarget extends RenderTarget {
     };
     canvas: any;
     context: any;
-    WebGLVersion: any;
+    /**
+     * The WebGL version of the created context.
+     * @type {number}
+     * @deprecated since 20.0.0 — the WebGL renderer is WebGL 2 only, this is always `2`
+     */
+    WebGLVersion: number;
     /**
      * @ignore
      */

package/build/video/rendertarget/canvasrendertarget.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"canvasrendertarget.d.ts","sourceRoot":"","sources":["../../../src/video/rendertarget/canvasrendertarget.js"],"names":[],"mappings":";AA+EA;;;;;;GAMG;AACH;IACC;;;;;;;;;;OAUG;IACH,mBAVW,MAAM,UACN,MAAM,eAEd;QAA4B,OAAO;QACN,YAAY;QACZ,WAAW;QACX,eAAe;QACf,kBAAkB;QAClB,SAAS;KACxC,EA6BA;IAzBA;;;;;;;;;;;;;;;;;;;MAAkE;IASjE,YAA+B;IAUhC,aAA0D;IAE1D,kBAAgC;IAMjC;;OAEG;IACH,4CAGC;IAUD;;;OAGG;IACH,sBAFW,OAAO,QAwBjB;IAYD;;;;;;;;OAQG;IACH,gBANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,GACJ,SAAS,CAUrB;IAoDD;;;;OAIG;IACH,qBAFW,cAAc,GAAC,aAAa,QAatC;IALC,mBAEC;IAKH;;;;OAIG;IACH,mBAHW,cAAc,GAAC,aAAa,QAiCtC;CA2BD;yBAxUwB,mBAAmB;gCAIb,gCAAgC;+BACjC,8BAA8B"}
+{"version":3,"file":"canvasrendertarget.d.ts","sourceRoot":"","sources":["../../../src/video/rendertarget/canvasrendertarget.js"],"names":[],"mappings":";AA6EA;;;;;;GAMG;AACH;IACC;;;;;;;;;OASG;IACH,mBATW,MAAM,UACN,MAAM,eAEd;QAA4B,OAAO;QACN,WAAW;QACX,eAAe;QACf,kBAAkB;QAClB,SAAS;KACxC,EAoCA;IAhCA;;;;;;;;;;;;;;;;;MAAkE;IASjE,YAA+B;IAUhC,aAA0D;IAGzD;;;;OAIG;IACH,cAHU,MAAM,CAGK;IAOvB;;OAEG;IACH,4CAGC;IAUD;;;OAGG;IACH,sBAFW,OAAO,QAwBjB;IAYD;;;;;;;;OAQG;IACH,gBANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,GACJ,SAAS,CAUrB;IAoDD;;;;OAIG;IACH,qBAFW,cAAc,GAAC,aAAa,QAyBtC;IAfC,mBAEC;IAeH;;;;OAIG;IACH,mBAHW,cAAc,GAAC,aAAa,QAyCtC;CA2BD;yBAhWwB,mBAAmB;gCAIb,gCAAgC;+BACjC,8BAA8B"}

package/build/video/rendertarget/render_target_pool.d.ts

@@ -16,9 +16,9 @@
  */
 export default class RenderTargetPool {
     /**
-     * @param {function(number, number): RenderTarget} factory - creates a RenderTarget with the given width and height
+     * @param {function(number, number, boolean=): RenderTarget} factory - creates a RenderTarget with the given width and height; the third argument is `true` for CAPTURE slots (scene rasterization — may be multisampled) and `false` for ping-pong intermediates
      */
-    constructor(factory: (arg0: number, arg1: number) => RenderTarget);
+    constructor(factory: (arg0: number, arg1: number, arg2: boolean | undefined) => RenderTarget);
     /** @type {function(number, number): RenderTarget} */
     _factory: (arg0: number, arg1: number) => RenderTarget;
     /** @type {RenderTarget[]} */

package/build/video/rendertarget/render_target_pool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render_target_pool.d.ts","sourceRoot":"","sources":["../../../src/video/rendertarget/render_target_pool.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;GAYG;AACH;IACC;;OAEG;IACH,qBAFW,CAAS,IAAM,EAAN,MAAM,EAAE,IAAM,EAAN,MAAM,KAAG,YAAY,EAchD;IAXA,qDAAqD;IACrD,UADW,CAAS,IAAM,EAAN,MAAM,EAAE,IAAM,EAAN,MAAM,KAAG,YAAY,CAC1B;IACvB,6BAA6B;IAC7B,OADW,YAAY,EAAE,CACV;IACf;;;;;OAKG;IACH,YAFU,MAAM,EAAE,CAEE;IAGrB;;;OAGG;IACH,kBAFa,MAAM,CAMlB;IAED;;;;;;OAMG;IACH,WALW,MAAM,SACN,MAAM,UACN,MAAM,GACJ,YAAY,CASxB;IAED;;;;;;;;OAQG;IACH,gBANW,OAAO,eACP,MAAM,SACN,MAAM,UACN,MAAM,GACJ,YAAY,CAuBxB;IAED;;;OAGG;IACH,oBAFa,YAAY,GAAC,SAAS,CAQlC;IAED;;;OAGG;IACH,qBAFa,YAAY,GAAC,SAAS,CAQlC;IAED;;;;OAIG;IACH,OAFa,YAAY,GAAC,IAAI,CAS7B;IAED;;;;OAIG;IACH,iBAHW,MAAM,UACN,MAAM,QAQhB;IAED;;OAEG;IACH,gBAQC;CACD;8BA3J4B,mBAAmB"}
+{"version":3,"file":"render_target_pool.d.ts","sourceRoot":"","sources":["../../../src/video/rendertarget/render_target_pool.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;GAYG;AACH;IACC;;OAEG;IACH,qBAFW,CAAS,IAAM,EAAN,MAAM,EAAE,IAAM,EAAN,MAAM,EAAE,IAAQ,EAAR,OAAO,YAAC,KAAG,YAAY,EAc1D;IAXA,qDAAqD;IACrD,UADW,CAAS,IAAM,EAAN,MAAM,EAAE,IAAM,EAAN,MAAM,KAAG,YAAY,CAC1B;IACvB,6BAA6B;IAC7B,OADW,YAAY,EAAE,CACV;IACf;;;;;OAKG;IACH,YAFU,MAAM,EAAE,CAEE;IAGrB;;;OAGG;IACH,kBAFa,MAAM,CAMlB;IAED;;;;;;OAMG;IACH,WALW,MAAM,SACN,MAAM,UACN,MAAM,GACJ,YAAY,CAaxB;IAED;;;;;;;;OAQG;IACH,gBANW,OAAO,eACP,MAAM,SACN,MAAM,UACN,MAAM,GACJ,YAAY,CAuBxB;IAED;;;OAGG;IACH,oBAFa,YAAY,GAAC,SAAS,CAQlC;IAED;;;OAGG;IACH,qBAFa,YAAY,GAAC,SAAS,CAQlC;IAED;;;;OAIG;IACH,OAFa,YAAY,GAAC,IAAI,CAS7B;IAED;;;;OAIG;IACH,iBAHW,MAAM,UACN,MAAM,QAQhB;IAED;;OAEG;IACH,gBAQC;CACD;8BA/J4B,mBAAmB"}

package/build/video/rendertarget/webglrendertarget.d.ts

@@ -11,11 +11,41 @@ export default class WebGLRenderTarget extends RenderTarget {
      * @param {number} width - initial width in pixels
      * @param {number} height - initial height in pixels
      */
-    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, width: number, height: number);
+    /**
+     * @param {WebGLRenderingContext|WebGL2RenderingContext} gl - the WebGL context
+     * @param {number} width - initial width in pixels
+     * @param {number} height - initial height in pixels
+     * @param {object} [options] - target options
+     * @param {number} [options.samples=0] - MSAA sample count for the scene
+     * rasterization. When > 0 the target keeps a multisampled render FBO
+     * (color + depth-stencil renderbuffers) that draws rasterize into, and
+     * resolves it into the sampleable texture via `blitFramebuffer` on
+     * {@link WebGLRenderTarget#resolve} (called automatically by `unbind`).
+     */
+    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, width: number, height: number, options?: {
+        samples?: number | undefined;
+    });
     gl: WebGLRenderingContext | WebGL2RenderingContext;
+    /**
+     * MSAA sample count of the render half (0 = single-sampled)
+     * @type {number}
+     */
+    samples: number;
+    _needsResolve: boolean;
     framebuffer: WebGLFramebuffer;
-    texture: WebGLTexture;
     depthStencilBuffer: WebGLRenderbuffer;
+    renderFramebuffer: WebGLFramebuffer | null;
+    colorRenderbuffer: WebGLRenderbuffer | null;
+    /**
+     * (Re)create the sampleable color texture with immutable storage
+     * (`texStorage2D` — the driver skips completeness validation and the
+     * layout is explicit) and attach it to the resolve framebuffer.
+     * Immutable storage can never be respecified, so a resize replaces the
+     * texture object. Caller manages ACTIVE_TEXTURE save/restore.
+     * @ignore
+     */
+    _allocateColorTexture(width: any, height: any): void;
+    texture: WebGLTexture | null | undefined;
     /**
      * (Re)attach the depth/stencil renderbuffer at the given size and
      * update `_hasStencil` based on the resulting framebuffer status.
@@ -25,6 +55,12 @@ export default class WebGLRenderTarget extends RenderTarget {
      */
     _applyDepthStencil(width: any, height: any): void;
     _hasStencil: boolean | undefined;
+    /**
+     * Resolve the multisampled render half into the sampleable texture
+     * (no-op when single-sampled or already resolved). Leaves no
+     * framebuffer bound — callers rebind what they need.
+     */
+    resolve(): void;
 }
 import RenderTarget from "./rendertarget.ts";
 //# sourceMappingURL=webglrendertarget.d.ts.map

package/build/video/rendertarget/webglrendertarget.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webglrendertarget.d.ts","sourceRoot":"","sources":["../../../src/video/rendertarget/webglrendertarget.js"],"names":[],"mappings":"AA8DA;;;;;;GAMG;AACH;IACC;;;;OAIG;IACH,gBAJW,qBAAqB,GAAC,sBAAsB,SAC5C,MAAM,UACN,MAAM,EAqDhB;IAjDA,mDAAY;IAKZ,8BAAyC;IAMzC,sBAAiC;IAoBjC,sCAAiD;IAoBlD;;;;;;OAMG;IACH,kDAkBC;IAVA,iCAAoC;CAmIrC;yBAlRwB,mBAAmB"}
+{"version":3,"file":"webglrendertarget.d.ts","sourceRoot":"","sources":["../../../src/video/rendertarget/webglrendertarget.js"],"names":[],"mappings":"AA2EA;;;;;;GAMG;AACH;IACC;;;;OAIG;IACH;;;;;;;;;;OAUG;IACH,gBAVW,qBAAqB,GAAC,sBAAsB,SAC5C,MAAM,UACN,MAAM,YAEd;QAAyB,OAAO;KAKlC,EAgEA;IA7DA,mDAAY;IAIZ;;;OAGG;IACH,SAFU,MAAM,CAEmB;IAGnC,uBAA0B;IAI1B,8BAAyC;IAWzC,sCAAiD;IAKhD,2CAA+C;IAC/C,4CAAgD;IA+BlD;;;;;;;OAOG;IACH,qDAqBC;IAhBA,yCAAiC;IAkBlC;;;;;;OAMG;IACH,kDAmBC;IAVA,iCAAoC;IA0BrC;;;;OAIG;IACH,gBAqBC;CAuID;yBA9YwB,mBAAmB"}

package/build/video/rendertarget/webgpurendertarget.d.ts

@@ -0,0 +1,83 @@
+/**
+ * WebGPU offscreen render target — the WebGPU counterpart of the WebGL
+ * FBO-backed {@link WebGLRenderTarget}, used by the post-effect chain
+ * through the shared {@link RenderTargetPool}.
+ *
+ * Owns one color `GPUTexture` (renderable AND sampleable — the whole point
+ * of a post-effect target) in the renderer's preferred canvas format, so
+ * pipelines keyed on that format serve canvas and offscreen passes alike.
+ * The depth-stencil attachment is NOT per-target: every pass shares the
+ * renderer's canvas-sized depth-stencil texture (targets in this flow are
+ * canvas-sized, only one pass is open at a time — and sharing the stencil
+ * means a mask active around a post-effect renderable keeps clipping its
+ * offscreen content, which is what masks promise).
+ *
+ * Under the recording model "binding" a target is a pass break: draws
+ * recorded after {@link WebGPURenderer#setRenderTarget} land in a new pass
+ * whose color attachment is this texture. Mid-frame resize/destroy retire
+ * the texture (a texture referenced by recorded draws must not be
+ * destroyed before submit).
+ * @augments RenderTarget
+ * @category Rendering
+ */
+export default class WebGPURenderTarget extends RenderTarget {
+    /**
+     * @param {import("../webgpu/webgpu_renderer.js").default} renderer - the owning renderer
+     * @param {number} width - width in pixels
+     * @param {number} height - height in pixels
+     */
+    constructor(renderer: import("../webgpu/webgpu_renderer.js").default, width: number, height: number, options?: {});
+    renderer: import("../webgpu/webgpu_renderer.js").default;
+    /**
+     * MSAA sample count for scene rasterization into this target
+     * (1 = single-sampled). When > 1 the target owns a multisampled
+     * color texture that passes rasterize into and resolve into
+     * `texture` at every pass end — so anything sampling the target
+     * always sees resolved pixels.
+     * @type {number}
+     */
+    sampleCount: number;
+    /** @type {GPUTexture|null} */
+    texture: GPUTexture | null;
+    /** @type {GPUTextureView|null} */
+    colorView: GPUTextureView | null;
+    /** the multisampled render half, when sampleCount > 1 @type {GPUTexture|null} */
+    msaaTexture: GPUTexture | null;
+    /** @type {GPUTextureView|null} */
+    msaaView: GPUTextureView | null;
+    /**
+     * bumped whenever the backing texture is reallocated — cached bind
+     * groups referencing the old view key on this
+     * @type {number}
+     */
+    generation: number;
+    materialBindGroup: GPUBindGroup | null;
+    materialBindGroupGeneration: number;
+    pendingClear: boolean;
+    /**
+     * The group-1 (material) bind group sampling this target with a linear
+     * clamp sampler — what the effect blit binds as its source. Rebuilt
+     * lazily when the backing texture was reallocated.
+     * @returns {GPUBindGroup} the bind group
+     * @ignore
+     */
+    getMaterialBindGroup(): GPUBindGroup;
+    /**
+     * Synchronous readback is impossible under WebGPU — use
+     * {@link WebGPURenderTarget#readPixels}.
+     * @throws {Error} always
+     * @override
+     */
+    override getImageData(): void;
+    /**
+     * Asynchronously read back this target's pixels.
+     * @param {number} [x=0] - x of the top-left corner
+     * @param {number} [y=0] - y of the top-left corner
+     * @param {number} [width=this.width] - width of the area to read
+     * @param {number} [height=this.height] - height of the area to read
+     * @returns {Promise<ImageData>} the pixel data (RGBA order)
+     */
+    readPixels(x?: number, y?: number, width?: number, height?: number): Promise<ImageData>;
+}
+import RenderTarget from "./rendertarget.ts";
+//# sourceMappingURL=webgpurendertarget.d.ts.map

package/build/video/rendertarget/webgpurendertarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgpurendertarget.d.ts","sourceRoot":"","sources":["../../../src/video/rendertarget/webgpurendertarget.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,8BAA8B,EAAE,OAAO,SAC9C,MAAM,UACN,MAAM,gBAsChB;IAlCA,yDAAwB;IAGxB;;;;;;;OAOG;IACH,aAFU,MAAM,CAE2B;IAC3C,8BAA8B;IAC9B,SADW,UAAU,GAAC,IAAI,CACP;IACnB,kCAAkC;IAClC,WADW,cAAc,GAAC,IAAI,CACT;IACrB,iFAAiF;IACjF,aAD8D,UAAU,GAAC,IAAI,CACtD;IACvB,kCAAkC;IAClC,UADW,cAAc,GAAC,IAAI,CACV;IACpB;;;;OAIG;IACH,YAFU,MAAM,CAEG;IAGnB,uCAA6B;IAC7B,oCAAqC;IAErC,sBAAyB;IA+E1B;;;;;;OAMG;IACH,wBAHa,YAAY,CAuBxB;IAED;;;;;OAKG;IACH,8BAIC;IAED;;;;;;;OAOG;IACH,eANW,MAAM,MACN,MAAM,UACN,MAAM,WACN,MAAM,GACJ,OAAO,CAAC,SAAS,CAAC,CAyD9B;CAqBD;yBA3QwB,mBAAmB"}

package/build/video/texture/atlas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"atlas.d.ts","sourceRoot":"","sources":["../../../src/video/texture/atlas.js"],"names":[],"mappings":"AAUA;;;GAGG;AAEH;;;GAGG;AACH;;;;;;;;;;;;;;;;;;;EAoBC;AAED;;;GAGG;AACH,+FAYC;AAED;;;;;;;;;;GAUG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,qBAjCW,MAAM,GAAC,MAAM,EAAE,QACf,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,eAAe,GAAC,MAAM,GAAC,eAAe,EAAE,GAAC,gBAAgB,EAAE,GAAC,iBAAiB,EAAE,GAAC,MAAM,EAAE,YAC3I,OAAO,GAAC,MAAM,EAuOxB;IAjMA;;;OAGG;IACH,sBAAkB;IAElB;;;;OAIG;IACH,uBAAwB;IAExB;;;;;;OAMG;IACH,6BAA8B;IAE9B;;;;OAIG;IACH,uBAAwB;IAExB;;;;OAIG;IACH,2BAA4B;IAE5B;;;OAGG;IACH;;;;;;MAA6D;IAW1D,YAA8C;IAgJlD;;;;OAIG;IACH,gBAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;OAGG;IACH,aAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,gBAAgB,GAAC,iBAAiB,CAQ9C;IAED;;;;;;OAMG;IACH,0BAHW,MAAM,GACJ,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,GAAC,IAAI,CAU/E;IAED;;;;;;;;OAQG;IACH,gBAPW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAsBlB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAiBlB;IAED;;;;;;;OAOG;IACH,aANW,MAAM,GAAC,MAAM,OACb,MAAM,OACN,MAAM,OACN,MAAM,GACJ,YAAY,CAsCxB;IAED;;;;;;;OAOG;IACH,cANW,MAAM,QACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,YAAY,CA2BxB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,2BA1BW,MAAM,aACN,MAAM,cACN,OAAO,GACL,MAAM,GAAC,eAAe,CAqClC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,6BAnBW,MAAM,EAAE,GAAC,MAAM,EAAE,GAGf,MAAM,CAkFlB;IAED,2DAiDC;CACD;sBA5rBqB,gBAAgB;mBALnB,8BAA8B;iCASjB,uCAAuC"}
+{"version":3,"file":"atlas.d.ts","sourceRoot":"","sources":["../../../src/video/texture/atlas.js"],"names":[],"mappings":"AAmBA;;;GAGG;AAEH;;;GAGG;AACH;;;;;;;;;;;;;;;;;;;EAoBC;AAED;;;GAGG;AACH,+FAYC;AAED;;;;;;;;;;GAUG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,qBAjCW,MAAM,GAAC,MAAM,EAAE,QACf,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,eAAe,GAAC,MAAM,GAAC,eAAe,EAAE,GAAC,gBAAgB,EAAE,GAAC,iBAAiB,EAAE,GAAC,MAAM,EAAE,YAC3I,OAAO,GAAC,MAAM,EAuOxB;IAjMA;;;OAGG;IACH,sBAAkB;IAElB;;;;OAIG;IACH,uBAAwB;IAExB;;;;;;OAMG;IACH,6BAA8B;IAE9B;;;;OAIG;IACH,uBAAwB;IAExB;;;;OAIG;IACH,2BAA4B;IAE5B;;;OAGG;IACH;;;;;;MAA6D;IAW1D,YAA8C;IAgJlD;;;;OAIG;IACH,gBAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;OAGG;IACH,aAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,gBAAgB,GAAC,iBAAiB,CAQ9C;IAED;;;;;;OAMG;IACH,0BAHW,MAAM,GACJ,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,GAAC,IAAI,CAU/E;IAED;;;;;;;;OAQG;IACH,gBAPW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAsBlB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAiBlB;IAED;;;;;;;OAOG;IACH,aANW,MAAM,GAAC,MAAM,OACb,MAAM,OACN,MAAM,OACN,MAAM,GACJ,YAAY,CAsCxB;IAED;;;;;;;OAOG;IACH,cANW,MAAM,QACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,YAAY,CA2BxB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,2BA1BW,MAAM,aACN,MAAM,cACN,OAAO,GACL,MAAM,GAAC,eAAe,CAqClC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,6BAnBW,MAAM,EAAE,GAAC,MAAM,EAAE,GAGf,MAAM,CAkFlB;IAED,2DAiDC;CACD;sBArsBqB,gBAAgB;mBANnB,8BAA8B;iCAmBjB,uCAAuC"}

package/build/video/texture/cache.d.ts

@@ -12,9 +12,26 @@ declare class TextureCache {
     cache: ArrayMultimap;
     tinted: Map<any, any>;
     units: Map<any, any>;
-    usedUnits: Set<any>;
+    slotTable: TextureSlotTable;
     reservedUnits: Map<any, any>;
-    max_size: number;
+    /**
+     * Which texture units are currently taken. This is the slot table's own
+     * occupancy set, exposed under the name it has always had — seeding or
+     * clearing it drives the allocator directly.
+     * @returns {Set<number>} the occupied units
+     * @ignore
+     */
+    get usedUnits(): Set<number>;
+    set max_size(size: number);
+    /**
+     * How many texture units this cache may hand out. Backed by the slot
+     * table's capacity, so assigning it (tests narrow it to force exhaustion,
+     * and a context restore can resolve a different device limit) re-sizes the
+     * allocator rather than leaving the two disagreeing.
+     * @returns {number} the unit count
+     * @ignore
+     */
+    get max_size(): number;
     /**
      * @ignore
      */
@@ -119,4 +136,5 @@ declare class TextureCache {
     tint(src: any, color: any): any;
 }
 import { ArrayMultimap } from "../../utils/array-multimap.js";
+import { TextureSlotTable } from "../gpu/textureslots.js";
 //# sourceMappingURL=cache.d.ts.map

package/build/video/texture/cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../src/video/texture/cache.js"],"names":[],"mappings":";AAeA;;;GAGG;AACH;IACC;;OAEG;IACH,8CA4BC;IA1BA,cAAwB;IAExB,qBAAgC;IAChC,sBAAuB;IAavB,qBAAsB;IACtB,oBAA0B;IAM1B,6BAA8B;IAC9B,iBAAwB;IAIzB;;OAEG;IACH,cAKC;IAED;;OAEG;IACH,8BA4BC;IAED;;;;;;;OAOG;IACH,kBAHW,MAAM,QAKhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,QAUhB;IAED;;;;OAIG;IACH,6BAIC;IAED;;;;;;;;;;OAUG;IACH,oCAaC;IAED;;;;;;;;OAQG;IACH,iCASC;IAED;;;;;;;;;;OAUG;IACH,+BATW,MAAM,OAuBhB;IAED;;;;;;;;OAQG;IACH,kCAIC;IAED;;;;OAIG;IACH,gCAFW,MAAM,OAShB;IAED;;;OAGG;IACH,yCAEC;IAED;;OAEG;IACH,yBAEC;IAED;;;OAGG;IACH,iCAmCC;IAED;;OAEG;IACH,yBAkBC;IAED;;OAEG;IACH,gCAcC;CACD;8BA5U6B,+BAA+B"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../src/video/texture/cache.js"],"names":[],"mappings":";AAgBA;;;GAGG;AACH;IACC;;OAEG;IACH,8CAgDC;IA9CA,cAAwB;IAExB,qBAAgC;IAChC,sBAAuB;IAavB,qBAAsB;IAOtB,4BAeE;IAMF,6BAA8B;IAI/B;;;;;;OAMG;IACH,iBAHa,GAAG,CAAC,MAAM,CAAC,CAKvB;IAcD,mBAPa,MAAM,EASlB;IAdD;;;;;;;OAOG;IACH,gBAHa,MAAM,CAKlB;IAMD;;OAEG;IACH,cAKC;IAED;;OAEG;IACH,8BAIC;IAED;;;;;;;OAOG;IACH,kBAHW,MAAM,QAKhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,QAUhB;IAED;;;;OAIG;IACH,6BAIC;IAED;;;;;;;;;;OAUG;IACH,oCAaC;IAED;;;;;;;;OAQG;IACH,iCASC;IAED;;;;;;;;;;OAUG;IACH,+BATW,MAAM,OAuBhB;IAED;;;;;;;;OAQG;IACH,kCAIC;IAED;;;;OAIG;IACH,gCAFW,MAAM,OAShB;IAED;;;OAGG;IACH,yCAEC;IAED;;OAEG;IACH,yBAEC;IAED;;;OAGG;IACH,iCAmCC;IAED;;OAEG;IACH,yBAkBC;IAED;;OAEG;IACH,gCAcC;CACD;8BApW6B,+BAA+B;iCAE5B,wBAAwB"}

package/build/video/texture/noise_texture2d.d.ts

@@ -19,8 +19,8 @@ export default NoiseTexture2d;
  * sampled in 3D (`getNoise3d`) using an internal `time` as the third axis —
  * call {@link NoiseTexture2d#update} from your update loop to evolve it. Each
  * re-bake bumps a `version` the renderer reads, so the GPU texture re-uploads
- * automatically (and only when it actually changed — the three.js
- * `Texture.needsUpdate` model).
+ * automatically (and only when it actually changed — explicit, version-based
+ * invalidation).
  *
  * Note: live re-upload is currently wired through the lit **normal-map**
  * pipeline ({@link Sprite#normalMap} + {@link Light2d}). An `animated` texture

package/build/video/utils/autodetect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"autodetect.d.ts","sourceRoot":"","sources":["../../../src/video/utils/autodetect.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH,iFASC;2BAhB0B,2BAA2B;0BAC5B,yBAAyB"}
+{"version":3,"file":"autodetect.d.ts","sourceRoot":"","sources":["../../../src/video/utils/autodetect.js"],"names":[],"mappings":"AAkCA;;;GAGG;AACH,iFAeC;2BApD0B,2BAA2B;0BAC5B,yBAAyB"}

package/build/video/video.d.ts

@@ -1,56 +1,2 @@
-/**
- * Initialize the "video" system (create a canvas based on the given arguments, and the related renderer). <br>
- * @memberof video
- * @param {number} width - The width of the canvas viewport
- * @param {number} height - The height of the canvas viewport
- * @param {ApplicationSettings} [options] - optional parameters for the renderer
- * @returns {boolean} false if initialization failed (canvas not supported)
- * @deprecated since 18.3.0 — use {@link Application} constructor instead:
- * `const app = new Application(width, height, options)`
- * @see Application
- * @example
- * // using the new Application entry point (recommended)
- * const app = new Application(640, 480, {
- *     parent : "screen",
- *     scale : "auto",
- *     scaleMethod : "fit"
- * });
- *
- * // legacy usage (still supported)
- * me.video.init(640, 480, {
- *     parent : "screen",
- *     renderer : me.video.AUTO,
- *     scale : "auto",
- *     scaleMethod : "fit"
- * });
- */
-export function init(width: number, height: number, options?: ApplicationSettings): boolean;
-/**
- * Create and return a new Canvas element.
- * @memberof video
- * @param {number} width - width
- * @param {number} height - height
- * @param {boolean} [returnOffscreenCanvas=false] - will return an OffscreenCanvas if supported
- * @returns {HTMLCanvasElement|OffscreenCanvas} a new Canvas element of the given size
- * @deprecated since 19.7.0 — use {@link Renderer.createCanvas} instead.
- * @see Renderer.createCanvas
- */
-export function createCanvas(width: number, height: number, returnOffscreenCanvas?: boolean): HTMLCanvasElement | OffscreenCanvas;
-/**
- * return a reference to the parent DOM element holding the main canvas
- * @memberof video
- * @returns {HTMLElement} the HTML parent element
- * @deprecated since 18.3.0 — use {@link Application#getParentElement app.getParentElement()} instead.
- * @see Application#getParentElement
- */
-export function getParent(): HTMLElement;
-/**
- * A reference to the active Canvas or WebGL renderer.
- * @memberof video
- * @type {CanvasRenderer|WebGLRenderer}
- * @deprecated since 18.3.0 — use {@link Application#renderer app.renderer} instead.
- * @see Application#renderer
- */
-export let renderer: CanvasRenderer | WebGLRenderer;
-export { AUTO, CANVAS, WEBGL } from "../const";
+export { AUTO, CANVAS, WEBGL, WEBGPU } from "../const";
 //# sourceMappingURL=video.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"video.d.ts","sourceRoot":"","sources":["../../src/video/video.js"],"names":[],"mappings":"AAqCA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,4BAvBW,MAAM,UACN,MAAM,YACN,mBAAmB,GACjB,OAAO,CAyCnB;AAED;;;;;;;;;GASG;AACH,oCAPW,MAAM,UACN,MAAM,0BACN,OAAO,GACL,iBAAiB,GAAC,eAAe,CAO7C;AAED;;;;;;GAMG;AACH,6BAJa,WAAW,CAMvB;AAxFD;;;;;;GAMG;AACH,qBAJU,cAAc,GAAC,aAAa,CAIX"}
+{"version":3,"file":"video.d.ts","sourceRoot":"","sources":["../../src/video/video.js"],"names":[],"mappings":""}