melonjs 19.9.0 → 20.0.0

package/build/video/gpu/topology.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Backend-neutral primitive topologies.
+ *
+ * Names how a stream of vertices is assembled into primitives, in the GPU
+ * vocabulary rather than the GL one. Like {@link VertexFormat}, this lets a
+ * draw be described without a live rendering context, and lets a backend read
+ * the description directly instead of translating enums.
+ *
+ * This module holds no GL references, so a non-WebGL backend can import it
+ * without pulling in the WebGL layer.
+ */
+/**
+ * How vertices are assembled into primitives.
+ *
+ * Five of these are portable across backends. `"line-loop"` and
+ * `"triangle-fan"` are **engine extensions** with no modern GPU-API
+ * equivalent — they exist because the primitive batcher has always accepted
+ * them, and a future backend will have to emulate them (a line loop is a line
+ * strip plus a closing segment, which is already how the WebGL path draws it).
+ * Prefer {@link PORTABLE_TOPOLOGIES} for anything that must survive a backend
+ * change.
+ */
+export type Topology = "point-list" | "line-list" | "line-strip" | "line-loop" | "triangle-list" | "triangle-strip" | "triangle-fan";
+/**
+ * The topologies with a direct equivalent in modern GPU APIs.
+ *
+ * `"line-loop"` and `"triangle-fan"` are deliberately absent — see
+ * {@link Topology}.
+ */
+export declare const PORTABLE_TOPOLOGIES: readonly ["point-list", "line-list", "line-strip", "triangle-list", "triangle-strip"];
+/**
+ * Whether a value is a supported topology name.
+ * @param value - the value to test
+ * @returns `true` when `value` names a topology
+ */
+export declare function isTopology(value: unknown): value is Topology;
+/**
+ * Whether a topology has a direct equivalent in modern GPU APIs.
+ * @param topology - the topology to test
+ * @returns `false` for the two engine extensions, which a non-WebGL backend must emulate
+ */
+export declare function isPortableTopology(topology: Topology): boolean;
+//# sourceMappingURL=topology.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"topology.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/topology.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;;;;;;;GAUG;AACH,MAAM,MAAM,QAAQ,GACjB,YAAY,GACZ,WAAW,GACX,YAAY,GACZ,WAAW,GACX,eAAe,GACf,gBAAgB,GAChB,cAAc,CAAC;AAElB;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,uFAMQ,CAAC;AAgBzC;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAE9D"}

package/build/video/gpu/vertexformat.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Backend-neutral vertex attribute formats.
+ *
+ * A vertex format names a component type and a component count in one token:
+ * `"float32x3"` is three 32-bit floats, `"unorm8x4"` is four unsigned bytes
+ * normalized to `[0, 1]`. That is everything a backend needs to interpret a
+ * slice of an interleaved vertex buffer, which is why it replaces the
+ * `size` + `type` + `normalized` triple the WebGL API works in.
+ *
+ * Naming follows the GPU vocabulary rather than the GL one, because the
+ * translation only runs one way: `"unorm8x4"` gives you `4` +
+ * `UNSIGNED_BYTE` + `normalized`, whereas `UNSIGNED_BYTE` alone cannot tell
+ * you the component count or whether it is normalized. Declaring the format
+ * also means a layout no longer needs a live rendering context to be written
+ * down — the GL enums are only resolved when a backend consumes it.
+ *
+ * This module holds no GL references at all, so a non-WebGL backend can
+ * import it without pulling in the WebGL layer.
+ * @see {@link Batcher#addAttribute}
+ */
+/**
+ * The scalar component type underlying a {@link VertexFormat}.
+ * @ignore
+ */
+export type VertexScalar = "float32" | "uint8" | "sint8" | "unorm8" | "snorm8" | "uint16" | "sint16" | "unorm16" | "snorm16" | "uint32" | "sint32";
+/**
+ * A vertex attribute format: component type and count.
+ *
+ * The set is deliberately narrower than the full GPU vocabulary — see the
+ * module notes for what is excluded and why. Layouts that cannot be spelled
+ * here (three-component 8- and 16-bit types, for instance) remain expressible
+ * with the {@link Batcher#addAttribute} GL-enum form, which is supported
+ * indefinitely.
+ */
+export type VertexFormat = "float32" | "float32x2" | "float32x3" | "float32x4" | "uint8" | "uint8x2" | "uint8x4" | "sint8" | "sint8x2" | "sint8x4" | "unorm8" | "unorm8x2" | "unorm8x4" | "snorm8" | "snorm8x2" | "snorm8x4" | "uint16" | "uint16x2" | "uint16x4" | "sint16" | "sint16x2" | "sint16x4" | "unorm16" | "unorm16x2" | "unorm16x4" | "snorm16" | "snorm16x2" | "snorm16x4" | "uint32" | "uint32x2" | "uint32x3" | "uint32x4" | "sint32" | "sint32x2" | "sint32x3" | "sint32x4";
+/**
+ * What a {@link VertexFormat} resolves to.
+ * @ignore
+ */
+export interface VertexFormatInfo {
+    /** number of components (1, 2, 3 or 4) */
+    components: 1 | 2 | 3 | 4;
+    /** total size of the attribute in bytes */
+    bytes: number;
+    /** whether integer values are scaled into `[0, 1]` / `[-1, 1]` when read by a shader */
+    normalized: boolean;
+    /** the underlying scalar type */
+    scalar: VertexScalar;
+}
+/**
+ * Every supported format, resolved.
+ *
+ * `bytes` is computed as `components × scalar size`, which is the same
+ * arithmetic the GL-enum path has always used — so a layout expressed either
+ * way produces an identical stride.
+ * @ignore
+ */
+export declare const VERTEX_FORMATS: Record<VertexFormat, VertexFormatInfo>;
+/**
+ * Whether a value is a supported vertex format name.
+ * @param value - the value to test
+ * @returns `true` when `value` names a format in {@link VERTEX_FORMATS}
+ */
+export declare function isVertexFormat(value: unknown): value is VertexFormat;
+/**
+ * Resolve a vertex format to its component count, size and normalization.
+ * @param format - the format to resolve
+ * @returns the resolved description
+ * @throws {Error} when `format` is not a supported format name
+ */
+export declare function resolveVertexFormat(format: VertexFormat): VertexFormatInfo;
+//# sourceMappingURL=vertexformat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vertexformat.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/vertexformat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;GAGG;AACH,MAAM,MAAM,YAAY,GACrB,SAAS,GACT,OAAO,GACP,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,SAAS,GACT,QAAQ,GACR,QAAQ,CAAC;AAEZ;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GAErB,SAAS,GACT,WAAW,GACX,WAAW,GACX,WAAW,GAEX,OAAO,GACP,SAAS,GACT,SAAS,GACT,OAAO,GACP,SAAS,GACT,SAAS,GAET,QAAQ,GACR,UAAU,GACV,UAAU,GACV,QAAQ,GACR,UAAU,GACV,UAAU,GAEV,QAAQ,GACR,UAAU,GACV,UAAU,GACV,QAAQ,GACR,UAAU,GACV,UAAU,GAEV,SAAS,GACT,WAAW,GACX,WAAW,GACX,SAAS,GACT,WAAW,GACX,WAAW,GAEX,QAAQ,GACR,UAAU,GACV,UAAU,GACV,UAAU,GACV,QAAQ,GACR,UAAU,GACV,UAAU,GACV,UAAU,CAAC;AAEd;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAChC,0CAA0C;IAC1C,UAAU,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC1B,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,wFAAwF;IACxF,UAAU,EAAE,OAAO,CAAC;IACpB,iCAAiC;IACjC,MAAM,EAAE,YAAY,CAAC;CACrB;AA0DD;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,YAAY,EAAE,gBAAgB,CA0CjE,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAEpE;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,GAAG,gBAAgB,CAS1E"}

package/build/video/gradient.d.ts

@@ -77,17 +77,26 @@ export class Gradient {
      */
     toCanvasGradient(context: CanvasRenderingContext2D): CanvasGradient;
     /**
-     * Render the gradient onto a canvas matching the given draw rect.
-     * Uses the original gradient coordinates so the result matches Canvas 2D behavior.
-     * @param {CanvasRenderer|WebGLRenderer} renderer - the active renderer (used to invalidate GPU texture)
+     * Render the gradient into the fixed-resolution shared bake target for
+     * the given draw rect. Uses the original gradient coordinates so the
+     * result matches Canvas 2D behavior. Rects larger than the bake target
+     * are rasterized scaled-down; the destination quad stretches them back,
+     * which is visually equivalent (linear stop interpolation × linear
+     * texture filtering). The returned `width`/`height` describe the region
+     * of the canvas the caller must use as the drawImage SOURCE rect.
+     * @param {CanvasRenderer|WebGLRenderer} renderer - the active renderer (used to invalidate the GPU texture)
      * @param {number} x - draw rect x
      * @param {number} y - draw rect y
      * @param {number} width - draw rect width
      * @param {number} height - draw rect height
-     * @returns {HTMLCanvasElement|OffscreenCanvas} the rendered gradient canvas
+     * @returns {{canvas: HTMLCanvasElement|OffscreenCanvas, width: number, height: number}} the shared gradient canvas + the used source-rect size
      * @ignore
      */
-    toCanvas(renderer: CanvasRenderer | WebGLRenderer, x: number, y: number, width: number, height: number): HTMLCanvasElement | OffscreenCanvas;
+    toCanvas(renderer: CanvasRenderer | WebGLRenderer, x: number, y: number, width: number, height: number): {
+        canvas: HTMLCanvasElement | OffscreenCanvas;
+        width: number;
+        height: number;
+    };
     /**
      * Get the interpolated color at a given position along the gradient.
      * Useful for procedural effects like trails that need per-segment colors.

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

@@ -1 +1 @@
-{"version":3,"file":"gradient.d.ts","sourceRoot":"","sources":["../../src/video/gradient.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH;IACC;;;OAGG;IACH,kBAHW,QAAQ,GAAC,QAAQ,UACjB,MAAM,EAAE,EAqDlB;IAlDA;;;OAGG;IACH,cAAc;IACd,YAA2B;IAE3B,0BAAgB;IAEhB;;;;OAIG;IACH,QAHU,MAAM,EAAE,CAGE;IAEpB;;;;OAIG;IACH,YAHU,KAAK,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAAC,CAG5B;IAEpB;;;;OAIG;IACH,iBAHU,cAAc,GAAC,SAAS,CAGF;IAEhC;;;;OAIG;IACH,eAHU,kBAAkB,GAAC,SAAS,CAGR;IAE9B;;;;OAIG;IACH,QAHU,OAAO,CAGC;IAElB;;;;OAIG;IACH,cAHU;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAC,EAAE,GAAC,IAAI,CAGvB;IAGzB;;;;;;;;;OASG;IACH,qBARW,MAAM,SACN,KAAK,GAAC,MAAM,GACV,QAAQ,CA0BpB;IAED;;;;;OAKG;IACH,0BAJW,wBAAwB,GACtB,cAAc,CAiC1B;IAED;;;;;;;;;;OAUG;IACH,mBARW,cAAc,GAAC,aAAa,KAC5B,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,GACJ,iBAAiB,GAAC,eAAe,CAwE7C;IAED;;;;;;;;;;;OAWG;IACH,qBATW,MAAM,OACN,KAAK,GACH,KAAK,CA+CjB;IAED;;;OAGG;IACH,0BAWC;IAED;;OAEG;IACH,gBAOC;CACD;+BAtT8B,sCAAsC;2BAH7C,kBAAkB"}
+{"version":3,"file":"gradient.d.ts","sourceRoot":"","sources":["../../src/video/gradient.js"],"names":[],"mappings":"AAiCA;;;;GAIG;AACH;IACC;;;OAGG;IACH,kBAHW,QAAQ,GAAC,QAAQ,UACjB,MAAM,EAAE,EAqDlB;IAlDA;;;OAGG;IACH,cAAc;IACd,YAA2B;IAE3B,0BAAgB;IAEhB;;;;OAIG;IACH,QAHU,MAAM,EAAE,CAGE;IAEpB;;;;OAIG;IACH,YAHU,KAAK,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAAC,CAG5B;IAEpB;;;;OAIG;IACH,iBAHU,cAAc,GAAC,SAAS,CAGF;IAEhC;;;;OAIG;IACH,eAHU,kBAAkB,GAAC,SAAS,CAGR;IAE9B;;;;OAIG;IACH,QAHU,OAAO,CAGC;IAElB;;;;OAIG;IACH,cAHU;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAC,EAAE,GAAC,IAAI,CAGvB;IAGzB;;;;;;;;;OASG;IACH,qBARW,MAAM,SACN,KAAK,GAAC,MAAM,GACV,QAAQ,CA0BpB;IAED;;;;;OAKG;IACH,0BAJW,wBAAwB,GACtB,cAAc,CAiC1B;IAED;;;;;;;;;;;;;;;OAeG;IACH,mBARW,cAAc,GAAC,aAAa,KAC5B,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,GACJ;QAAC,MAAM,EAAE,iBAAiB,GAAC,eAAe,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAwFtF;IAED;;;;;;;;;;;OAWG;IACH,qBATW,MAAM,OACN,KAAK,GACH,KAAK,CA+CjB;IAED;;;OAGG;IACH,0BAWC;IAED;;OAEG;IACH,gBAOC;CACD;+BA1V8B,sCAAsC;2BAF7C,kBAAkB"}

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":"AAUA;;GAEG;AAEH;;;;;;;;GAQG;AAEH;;;GAGG;AACH;IAiQC;;;;;;;;;;;;OAYG;IACH,2BANW,MAAM,UACN,MAAM,0BACN,OAAO,GAEL,iBAAiB,GAAC,eAAe,CAI7C;IAED;;;;;;;;;;;;OAYG;IACH,wBAFa,iBAAiB,GAAC,eAAe,CAgB7C;IA5SD;;OAEG;IACH,sBAFW,mBAAmB,EAsJ7B;IAnJA;;;;OAIG;IACH,cAFU,kBAAkB,CAS3B;IAED;;;;OAIG;IACH,iBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,oBAFU,MAAM,CAE6C;IAE7D;;;;OAIG;IACH,YAHU,QAAQ,CAGsD;IAExE;;;;OAIG;IACH,gBAFU,OAAO,CAES;IAE1B;;;;OAIG;IACH,aAFU,MAAM,GAAC,SAAS,CAEE;IAE5B;;;;;;OAMG;IACH,cAHU,QAAQ,GAAC,YAAY,GAAC,SAAS,CAGZ;IAE7B;;;;;OAKG;IACH,mBAHU,gBAAgB,GAAC,IAAI,CAGF;IAE7B;;;OAGG;IACH,QAFU,MAAM,CAEU;IAE1B;;;;OAIG;IACH,MAFU,MAAM,CAEK;IAErB;;;;;OAKG;IACH,iBAFU,KAAK,CAOd;IAED;;;;OAIG;IACH,aAFU,WAAW,CAEe;IAGpC,oBAAiD;IACjD,mBAA+C;IAC/C,4CAAqD;IAErD;;;;;;;;;OASG;IACH,WAHU,MAAM,CAGE;IAElB;;OAEG;IACH,kBAAkB;IAGlB,2BAAsC;IAGtC,iBAAiB;IAEjB;;;;;;;;OAQG;IACH,kBAFU,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,GAAC,IAAI,CAEjD;IAE5B;;;;;;;OAOG;IACH,kBAFU,MAAM,CAES;IAU1B,4BANU,MAAM,EAQf;IATD;;OAEG;IACH,wBAFU,MAAM,CAIf;IAoBD,wBAPU,MAAM,EASf;IAhBD;;;;;;;;;OASG;IACH,oBAHU,MAAM,CAKf;IAcD,kBANa,MAAM,EAQlB;IAVD;;;OAGG;IACH,cAFa,MAAM,CAIlB;IAcD,iBANa,MAAM,EAQlB;IAVD;;;OAGG;IACH,aAFa,MAAM,CAIlB;IAMD;;OAEG;IACH,cAAU;IAEV;;OAEG;IACH,cAAU;IAEV;;;;;;;;OAQG;IAEH,eAHW,IAAI,QAGE;IAEjB;;OAEG;IACH,cAQC;IAED;;;;OAIG;IACH,gBAAY;IAEZ;;;OAGG;IACH,aAFa,iBAAiB,CAI7B;IAgDD;;;OAGG;IACH,cAFa,wBAAwB,GAAC,qBAAqB,CAI1D;IAED;;;;;;;OAOG;IACH,wCAFa,MAAM,CAYlB;IAED;;;;OAIG;IACH,sCAHW,MAAM,GACJ,OAAO,CAgBnB;IAED;;;;;;;OAOG;IACH,4BAJW,UAAU,GACR,OAAO,CAcnB;IAED;;;;;;OAMG;IAEH,0BAJW,UAAU,QAIO;IAE5B;;;;;;;;;;;;OAYG;IAEH,mBATW,YAAY,KACZ,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,YAAY,cACZ,OAAO,QAG2C;IAE7D;;;;;;;;OAQG;IAEH,gBANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAGiB;IAElC;;;;OAIG;IACH,0BAAsB;IAEtB;;;;;;;OAOG;IAEH,iBANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAGoB;IAErC;;;OAGG;IACH,uBAAmB;IAEnB;;;;OAIG;IAEH,wBAHW,OAAO,QAGQ;IAE1B;;;OAGG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,oBAHW,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IAEH,0BANW,QAAQ,CAAC,MAAM,CAAC,YAChB,MAAM,eACN,MAAM,eACN,MAAM,QAqBhB;IAPC,wCAA8B;IAShC;;;;;;;;;;;;;;;;;;;;OAoBG;IAEH,iBAJW,MAAM,QAMhB;IAED;;;;;;;;;;;;OAYG;IACH,qBAHW,MAAM,QACN,IAAI,QA4Bd;IAED;;;;OAIG;IAEH,gBAHW,KAAK,GAAC,MAAM,GAAC,QAAQ,QAK/B;IAED;;;OAGG;IACH,YAFa,KAAK,CAIjB;IAED;;;;;;;OAOG;IACH,yBANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,QAAQ,CAIpB;IAED;;;;;;;;;OASG;IACH,yBARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,QAAQ,CAIpB;IAED;;;;;;;;;OASG;IACH,sBARW,MAAM,EAAE,QAsBlB;IAED;;;OAGG;IACH,eAFa,MAAM,EAAE,CAIpB;IAED;;;OAGG;IACH,eAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAHW,IAAI,GAAC,MAAM,GACT,OAAO,CASnB;IAED;;;;OAIG;IACH,cAHW,MAAM,UACN,MAAM,QAchB;IAED;;;OAGG;IACH,sBAFW,OAAO,QAOjB;IAED;;;;;;;;;;;OAWG;IACH,2BAFa,QAAQ,GAAC,SAAS,CAS9B;IAED;;;;;;OAMG;IACH,wBAFW,MAAM,GAAC,SAAS,GAAC,QAAQ,QAInC;IAED;;;;OAIG;IACH,sBAFW,QAAQ,QAIlB;IAED;;;;OAIG;IACH,cAHW,IAAI,GAAC,SAAS,GAAC,OAAO,GAAC,IAAI,GAAC,OAAO,GAAC,MAAM,SAC1C,OAAO,QAiFjB;IAED;;;OAGG;IACH,YAFW,IAAI,GAAC,SAAS,GAAC,OAAO,GAAC,IAAI,GAAC,OAAO,GAAC,MAAM,QAIpD;IAED;;;;;;OAMG;IACH,UALW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,SAClD,KAAK,GAAC,MAAM,SACZ,MAAM,GACJ,iBAAiB,GAAC,eAAe,CAyB7C;IAED;;;OAGG;IACH,aAAS;IAET;;;;OAIG;IACH,gBAAY;IAEZ;;;;OAIG;IAEH,aAJW,MAAM,KACN,MAAM,QAGC;IAElB;;;OAGG;IAEH,cAHW,MAAM,QAGD;IAEhB;;;;OAIG;IAEH,SAJW,MAAM,KACN,MAAM,QAGH;IAEd;;;;OAIG;IAEH,sBAHW,MAAM,QAGO;IAExB;;;;;;;OAOG;IAEH,YANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAGe;IAEhC;;;;;;;;OAQG;IAEH,cAPW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,SACN,OAAO,QAGsB;IAExC;;;;;;;OAOG;IAEH,eANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAGS;IAE1B;;;;;;;;OAQG;IAEH,iBAPW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,SACN,OAAO,QAGgB;IAElC;;;;;;;OAOG;IAEH,mBANW,MAAM,UACN,MAAM,QACN,MAAM,QACN,MAAM,QAGwB;IAEzC;;;;;;;;;;;;;;;;;;OAkBG;IAEH,iBAXW,gBAAgB,GAAC,eAAe,GAAC,gBAAgB,GAAC,iBAAiB,GAAC,WAAW,GAAC,eAAe,GAAC,UAAU,MAC1G,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAGkC;IAEnD;;;;;;OAMG;IACH,gBAAY;IAEZ;;;OAGG;IACH,kBAAc;IAEd;;;;OAIG;IACH,cAHW,KAAK,UACL,MAAM,QAMhB;IAED;;;OAGG;IACH,kBAGC;IAED;;;;;;;;;;;;;;;OAeG;IACH,gBAHW,MAAM,QAgBhB;IAED;;;;;;;OAOG;IACH,cANW,MAAM,YACN,MAAM,gBAOhB;IAED;;;;;;;;OAQG;IACH,qBANW,MAAM,YACN,MAAM,gBAOhB;IAED;;;;;;;OAOG;IACH,iBANW,MAAM,YACN,MAAM,gBAOhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IAEH,yBAfG;QAAiC,MAAM;QAIwC,MAAM;eAAlE,MAAM;eAAK,MAAM;mBAAS,MAAM;oBAAU,MAAM;;KAMnE,GAAU,SAAS,CAOrB;CACD;;;;;+BA1nC8B,sCAAsC;yBAL5C,qBAAqB;kCAQb,sCAAsC;mBAXpD,2BAA2B;sBACxB,oBAAoB;wBAMlB,kBAAkB;yBALjB,qBAAqB;0BAavB,8BAA8B;yBAT5B,eAAe;4BAcf,wBAAwB;+BAJrB,8BAA8B;6BAChC,0BAA0B;0BAC7B,yBAAyB;6BACtB,4BAA4B;0CAEf,wBAAwB"}
+{"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"}