melonjs 19.9.0 → 20.0.0

package/build/video/webgpu/webgpu_renderer.d.ts

@@ -0,0 +1,536 @@
+
+/**
+ * The **experimental** WebGPU renderer.
+ *
+ * The asynchronous bootstrap — `getContext("webgpu")` at construction, then
+ * adapter/device negotiation and canvas configuration in
+ * {@link WebGPURenderer#init} (the reason {@link Application#init} is
+ * asynchronous at all) — plus the core 2D frame pipeline: one command
+ * encoder and one render pass per frame, opened by {@link
+ * WebGPURenderer#clear} and submitted by {@link WebGPURenderer#flush}, with
+ * a `depth24plus-stencil8` attachment carried from day one (the stencil
+ * half serves masks; the depth half is reserved for the mesh path).
+ *
+ * It is **opt-in only**: `renderer: video.WEBGPU` (or the `#webgpu` URI
+ * fragment). `video.AUTO` never selects it, and will not until it reaches
+ * feature parity with the WebGL backend.
+ * @augments Renderer
+ * @category Rendering
+ */
+export default class WebGPURenderer extends Renderer {
+    /**
+     * @param {ApplicationSettings} options - The renderer parameters
+     */
+    constructor(options: ApplicationSettings);
+    /**
+     * The WebGPU adapter, set once {@link WebGPURenderer#init} resolves.
+     * @type {GPUAdapter|undefined}
+     * @readonly
+     */
+    readonly adapter: GPUAdapter | undefined;
+    /**
+     * The WebGPU device, set once {@link WebGPURenderer#init} resolves.
+     * @name device
+     * @type {GPUDevice|undefined}
+     * @readonly
+     */
+    readonly device: GPUDevice | undefined;
+    /**
+     * The WebGPU canvas context
+     * @name context
+     * @type {GPUCanvasContext}
+     */
+    context: GPUCanvasContext;
+    /**
+     * The preferred canvas texture format reported by the platform,
+     * set once {@link WebGPURenderer#init} resolves.
+     * @type {string|undefined}
+     * @readonly
+     */
+    readonly preferredFormat: string | undefined;
+    cache: TextureCache;
+    currentTransform: Matrix3d;
+    onGameReset: () => void;
+    onCanvasResize: () => void;
+    GPUVendor: string | undefined;
+    stubTextureView: GPUTextureView | null | undefined;
+    /**
+     * Restrict rendering to a sub-rectangle of the canvas — the split-screen
+     * camera surface (`Camera2d`/`Camera3d._setupNonDefaultProjection`).
+     * Callers pass GL-convention rects with a BOTTOM-left origin (the flip is
+     * baked into the camera code, which the GL backend depends on); WebGPU
+     * viewports are top-left, so it is un-flipped here. The rect applies to
+     * canvas passes only — offscreen post-effect targets always render full
+     * size, like the GL pool path re-viewporting per target.
+     * @param {number} x - viewport x (pixels)
+     * @param {number} y - viewport y, bottom-left origin (pixels)
+     * @param {number} width - viewport width (pixels)
+     * @param {number} height - viewport height (pixels)
+     * @override
+     */
+    override setViewport(x: number, y: number, width: number, height: number): void;
+    /**
+     * Capture the current frame — everything drawn to the active target so
+     * far — into a {@link Texture2d}, entirely on the GPU (an encoder-ordered
+     * `copyTextureToTexture`; no readback round-trip). Same contract as the
+     * WebGL backend's `toFrameTexture`: a shared, renderer-owned slot by
+     * default, `target: null` for a fresh caller-owned capture, or a prior
+     * capture as `target` to refresh it in place; `options.region` captures
+     * a sub-region (framebuffer pixels, bottom-left origin — converted to
+     * this backend's top-left copy origin internally).
+     *
+     * Two documented divergences from the GL capture:
+     * - alpha is preserved (the GL path captures into an opaque RGB texture)
+     * - row 0 of the capture is the TOP of the frame (matching `screen_uv`),
+     *   where the GL capture is bottom-up — GLSL bodies sampling a capture
+     *   flip with `1.0 - uv.y`; their WGSL twins must not.
+     * @param {object} [options]
+     * @param {Texture2d|null} [options.target] - omit for the shared renderer
+     *   slot; a prior capture to refresh it in place; `null` to mint a fresh,
+     *   caller-owned capture (`destroy()` it yourself when done)
+     * @param {Bounds|{x: number, y: number, width: number, height: number}} [options.region] - capture
+     *   only this sub-region; defaults to the whole frame
+     * @returns {Texture2d|null} a GPU-resident texture holding the captured
+     *   frame, or null when no device is available
+     */
+    toFrameTexture(options?: {
+        target?: Texture2d | null;
+        region?: Bounds | {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        } | undefined;
+    }): Texture2d | null;
+    /**
+     * Draw a pooled render target through an effect's pipeline as a
+     * screen-space quad — the compositing primitive of the post-effect
+     * chain. Blending is disabled for camera blits (the target is fully
+     * composited) and kept for per-sprite blits (transparent texels must
+     * not overwrite the scene).
+     * @param {import("../rendertarget/webgpurendertarget.js").default} source - the target to sample
+     * @param {number} x - destination x
+     * @param {number} y - destination y
+     * @param {number} width - destination width
+     * @param {number} height - destination height
+     * @param {ShaderEffect} effect - the effect to composite with
+     * @param {boolean} [keepBlend=false] - keep the current blend mode
+     * @override
+     */
+    override blitEffect(source: import("../rendertarget/webgpurendertarget.js").default, x: number, y: number, width: number, height: number, effect: ShaderEffect, keepBlend?: boolean): void;
+    /**
+     * Clear the current clip region with the given color — a full-viewport
+     * triangle clipped by the active scissor, drawn with blending replaced
+     * (WebGPU has no scissored clear operation). Used mid-frame by
+     * ColorLayer and Container backgrounds.
+     *
+     * Deliberate divergence from the GL backend: because this is a draw,
+     * it honors an active stencil mask (GL's `gl.clear` ignores stencil and
+     * clears the whole scissor region) — under a mask, the clear fills the
+     * mask window only, which is the behavior masks actually promise.
+     * @param {Color|string} [color="#000000"] - css color
+     * @param {boolean} [opaque=false] - allow transparency or not
+     * @override
+     */
+    override clearColor(color?: Color | string, opaque?: boolean): void;
+    /**
+     * Erase the pixels in the given rectangular area by setting them to
+     * transparent black (rgba(0,0,0,0)).
+     * @param {number} x - x axis of the coordinate for the rectangle starting point.
+     * @param {number} y - y axis of the coordinate for the rectangle starting point.
+     * @param {number} width - The rectangle's width.
+     * @param {number} height - The rectangle's height.
+     * @override
+     */
+    override clearRect(x: number, y: number, width: number, height: number): void;
+    /**
+     * Draw a TMX tile layer: WGSL-eligible layers (`renderMode ===
+     * "shader"`) draw through the GPU tile path — one quad per tileset,
+     * GID lookup in a per-layer index texture; everything else falls
+     * through to the base per-tile loop.
+     * @param {object} layer - the TMXLayer to draw
+     * @param {object} rect - the visible region in world coords
+     * @override
+     */
+    override drawTileLayer(layer: object, rect: object): void;
+    /**
+     * Add a batcher to this renderer.
+     * @param {WebGPUBatcher} batcher - a batcher instance
+     * @param {string} [name="default"] - the batcher name
+     * @param {boolean} [activate=false] - true to set this batcher as the active one
+     */
+    addBatcher(batcher: WebGPUBatcher, name?: string, activate?: boolean): void;
+    /**
+     * Set the active batcher for this renderer — flush + unbind the
+     * outgoing one, bind the incoming. Unlike the GL backend there is no
+     * projection re-sync: the projection lives in the shared frame-globals
+     * bind group, not in per-program uniforms.
+     * @param {string} [name="default"] - a batcher name
+     * @returns {WebGPUBatcher} the now-active batcher
+     */
+    setBatcher(name?: string): WebGPUBatcher;
+    /**
+     * Draw a textured triangle mesh — the mesh-path contract of the base
+     * renderer, on this backend's pipeline-state model. Unlike GL there is
+     * no device state to toggle: depth testing (write + LEQUAL) and the
+     * per-mesh face culling are axes of the pipeline the mesh batcher
+     * looks up per flush, and the once-per-target depth clear is the
+     * pass's `depthLoadOp` (armed by `clear()`/`setRenderTarget`).
+     * @param {object} mesh - a Mesh object with vertices, uvs, indices, and texture properties
+     * @param {Matrix3d} [modelMatrix] - the mesh's model matrix. When given,
+     *   the mesh is drawn from persistent model-space geometry and placed
+     *   entirely by uniforms; when omitted, its vertices are taken as
+     *   already positioned and accumulated through the batcher (the
+     *   2D-camera path).
+     * @override
+     */
+    /**
+     * Draw one ground shadow per instance of an `InstancedMesh` (#1515), in a
+     * single recorded call over the mesh's own instance buffer.
+     * @param {InstancedMesh} mesh - the mesh casting the shadows
+     * @param {Matrix3d} shadowMatrix - the group matrix flattened onto the ground
+     * @param {object} quad - the shared shadow quad
+     * @ignore
+     */
+    drawInstancedShadow(mesh: InstancedMesh, shadowMatrix: Matrix3d, quad: object): void;
+    drawMesh(mesh: any, modelMatrix: any): void;
+    /**
+     * Release any retained geometry held for the given mesh (called from
+     * `Mesh.onDeactivateEvent` / `Mesh.destroy`).
+     * @param {object} mesh - the mesh whose GPU geometry should be freed
+     */
+    deleteMeshGeometry(mesh: object): void;
+    /**
+     * Multiply the given matrix (or 2D affine components) into the current
+     * transformation matrix
+     * @param {Matrix2d|Matrix3d|number} a - a matrix, or the a component
+     * @param {number} [b] - the b component
+     * @param {number} [c] - the c component
+     * @param {number} [d] - the d component
+     * @param {number} [e] - the e component
+     * @param {number} [f] - the f component
+     */
+    transform(a: Matrix2d | Matrix3d | number, b?: number, c?: number, d?: number, e?: number, f?: number): void;
+    /**
+     * Reset then multiply the transformation matrix
+     * @param {Matrix2d|Matrix3d|number} a - a matrix, or the a component
+     * @param {number} [b] - the b component
+     * @param {number} [c] - the c component
+     * @param {number} [d] - the d component
+     * @param {number} [e] - the e component
+     * @param {number} [f] - the f component
+     */
+    setTransform(a: Matrix2d | Matrix3d | number, b?: number, c?: number, d?: number, e?: number, f?: number): void;
+    /**
+     * Return the global alpha
+     * @returns {number} global alpha value
+     */
+    getGlobalAlpha(): number;
+    /**
+     * Set the blend mode for subsequent draws. Under WebGPU blending is
+     * pipeline state: the change is recorded (after draining vertices
+     * queued under the previous mode) and the next batcher flush picks the
+     * matching pipeline variant.
+     * @param {string} [mode="normal"] - blend mode ("normal", "multiply", "additive"/"lighter", "screen", "darken", "lighten", "none")
+     * @param {boolean} [premultipliedAlpha=true] - whether textures use premultiplied alpha (affects the source blend factor)
+     * @returns {string} the blend mode actually applied
+     */
+    setBlendMode(mode?: string, premultipliedAlpha?: boolean): string;
+    /**
+     * Draw an image onto the frame (Canvas-compatible 3/5/9-argument forms).
+     * @param {HTMLImageElement|HTMLCanvasElement|HTMLVideoElement|ImageBitmap|OffscreenCanvas|VideoFrame} image - the source image
+     * @param {number} sx - source x (or destination x in the 3/5-arg forms)
+     * @param {number} sy - source y (or destination y in the 3/5-arg forms)
+     * @param {number} [sw] - source width
+     * @param {number} [sh] - source height
+     * @param {number} [dx] - destination x
+     * @param {number} [dy] - destination y
+     * @param {number} [dw] - destination width
+     * @param {number} [dh] - destination height
+     */
+    drawImage(image: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | ImageBitmap | OffscreenCanvas | VideoFrame, sx: number, sy: number, sw?: number, sh?: number, dx?: number, dy?: number, dw?: number, dh?: number): void;
+    /**
+     * The compressed-texture families this device supports, in the same
+     * shape as the GL backend (one key per family; supported families hold
+     * an object of WebGL format constants — the values the loader parsers
+     * emit — unsupported ones are null, so the shared
+     * hasSupportedCompressedFormats works unchanged). PVRTC has no WebGPU
+     * equivalent and stays null.
+     * @returns {object} one key per extension family
+     * @override
+     */
+    override getSupportedCompressedTextureFormats(): object;
+    supportedCompressedFormats: {
+        astc: {
+            COMPRESSED_RGBA_ASTC_4x4_KHR: number;
+            COMPRESSED_RGBA_ASTC_5x4_KHR: number;
+            COMPRESSED_RGBA_ASTC_5x5_KHR: number;
+            COMPRESSED_RGBA_ASTC_6x5_KHR: number;
+            COMPRESSED_RGBA_ASTC_6x6_KHR: number;
+            COMPRESSED_RGBA_ASTC_8x5_KHR: number;
+            COMPRESSED_RGBA_ASTC_8x6_KHR: number;
+            COMPRESSED_RGBA_ASTC_8x8_KHR: number;
+            COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: number;
+            COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: number;
+            COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: number;
+            COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: number;
+            COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: number;
+            COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: number;
+            COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: number;
+            COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: number;
+        } | null;
+        bptc: {
+            COMPRESSED_RGBA_BPTC_UNORM_EXT: number;
+        } | null;
+        s3tc: {
+            COMPRESSED_RGB_S3TC_DXT1_EXT: number;
+            COMPRESSED_RGBA_S3TC_DXT3_EXT: number;
+            COMPRESSED_RGBA_S3TC_DXT5_EXT: number;
+        } | null;
+        s3tc_srgb: {
+            COMPRESSED_SRGB_S3TC_DXT1_EXT: number;
+            COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: number;
+            COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: number;
+            COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: number;
+        } | null;
+        pvrtc: null;
+        etc1: {
+            COMPRESSED_RGB_ETC1_WEBGL: number;
+        } | null;
+        etc2: {
+            COMPRESSED_RGB8_ETC2: number;
+            COMPRESSED_SRGB8_ETC2: number;
+            COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: number;
+            COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: number;
+            COMPRESSED_RGBA8_ETC2_EAC: number;
+            COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: number;
+            COMPRESSED_R11_EAC: number;
+            COMPRESSED_SIGNED_R11_EAC: number;
+            COMPRESSED_RG11_EAC: number;
+            COMPRESSED_SIGNED_RG11_EAC: number;
+        } | null;
+    } | undefined;
+    /**
+     * Pack the active 2D lights and hand the std140 block to the lit
+     * batcher — the WebGPU realization of the backend-neutral lighting
+     * contract (Camera2d calls this once per camera per frame).
+     * @param {Set<Light2d>|Array<Light2d>} lights - active lights
+     * @param {Color} ambient - the ambient lighting floor
+     * @param {number} [translateX=0] - camera translate x
+     * @param {number} [translateY=0] - camera translate y
+     * @override
+     */
+    override setLightUniforms(lights: Set<Light2d> | Array<Light2d>, ambient: Color, translateX?: number, translateY?: number): void;
+    lightUniformsScratch: import("../webgl/lighting/pack.ts").LightUniformScratch | undefined;
+    /**
+     * Draw a Light2d glow quad through the radial-gradient effect's
+     * single-effect fast path — the light's color and intensity ride the
+     * per-vertex tint, so back-to-back lights share the same pipeline.
+     * @param {Light2d} light - the light to draw
+     * @override
+     */
+    override drawLight(light: Light2d): void;
+    lightShader: RadialGradientEffect | undefined;
+    lightAtlas: TextureAtlas | undefined;
+    /**
+     * Draw a pattern within the given rectangle.
+     * @param {TextureAtlas} pattern - pattern object returned by {@link WebGPURenderer#createPattern}
+     * @param {number} x - x position where to draw the pattern
+     * @param {number} y - y position where to draw the pattern
+     * @param {number} width - width of the pattern
+     * @param {number} height - height of the pattern
+     */
+    drawPattern(pattern: TextureAtlas, x: number, y: number, width: number, height: number): void;
+    /**
+     * Create a pattern with the specified repetition
+     * @param {HTMLImageElement|SVGImageElement|HTMLVideoElement|HTMLCanvasElement|ImageBitmap|OffscreenCanvas|VideoFrame} image - source image
+     * @param {string} [repeat="no-repeat"] - one of `"repeat"` / `"repeat-x"` / `"repeat-y"` / `"no-repeat"`
+     * @returns {TextureAtlas} the patterned texture created
+     */
+    createPattern(image: HTMLImageElement | SVGImageElement | HTMLVideoElement | HTMLCanvasElement | ImageBitmap | OffscreenCanvas | VideoFrame, repeat?: string): TextureAtlas;
+    savedBlendMode: string | undefined;
+    /**
+     * A mask limits rendering elements to the shape and position of the
+     * given mask object — realized on the stencil half of the pass's
+     * depth-stencil attachment, exactly like the GL backend: a write
+     * phase increments the stencil under the mask shape (color writes
+     * off), then the render phase only passes fragments where the stencil
+     * equals the current mask level (or 0 when inverted).
+     *
+     * Entering the first mask level clears the stencil, which WebGPU can
+     * only do at a pass boundary — the frame's pass is broken and
+     * restarted with `stencilLoadOp: "clear"` (color preserved).
+     * (Note: masks are not preserved through save/restore and need to be
+     * manually cleared, same as the other backends.)
+     * @param {Rect|RoundRect|Polygon|Line|Ellipse} [mask] - the shape defining the mask to be applied
+     * @param {boolean} [invert=false] - either the given shape should define what is visible (default) or the opposite
+     */
+    setMask(mask?: Rect | RoundRect | Polygon | Line | Ellipse, invert?: boolean): void;
+    maskDepthWarned: boolean | undefined;
+    /**
+     * Stroke an arc at the specified coordinates with given radius, start and end points
+     * @param {number} x - arc center point x-axis
+     * @param {number} y - arc center point y-axis
+     * @param {number} radius - arc radius
+     * @param {number} start - start angle in radians
+     * @param {number} end - end angle in radians
+     * @param {boolean} [antiClockwise=false] - draw arc anti-clockwise
+     * @param {boolean} [fill=false] - also fill the shape with the current color if true
+     */
+    strokeArc(x: number, y: number, radius: number, start: number, end: number, antiClockwise?: boolean, fill?: boolean): void;
+    /**
+     * Fill an arc at the specified coordinates with given radius, start and end points
+     * @param {number} x - arc center point x-axis
+     * @param {number} y - arc center point y-axis
+     * @param {number} radius - arc radius
+     * @param {number} start - start angle in radians
+     * @param {number} end - end angle in radians
+     * @param {boolean} [antiClockwise=false] - draw arc anti-clockwise
+     */
+    fillArc(x: number, y: number, radius: number, start: number, end: number, antiClockwise?: boolean): void;
+    /**
+     * Fill a line between the given two points
+     * @param {number} startX - the start x coordinate
+     * @param {number} startY - the start y coordinate
+     * @param {number} endX - the end x coordinate
+     * @param {number} endY - the end y coordinate
+     */
+    fillLine(startX: number, startY: number, endX: number, endY: number): void;
+    /**
+     * Stroke a Polygon on the screen with the current color
+     * @param {Polygon} poly - the shape to draw
+     * @param {boolean} [fill=false] - also fill the shape with the current color if true
+     */
+    strokePolygon(poly: Polygon, fill?: boolean): void;
+    /**
+     * Fill a Polygon on the screen
+     * @param {Polygon} poly - the shape to draw
+     */
+    fillPolygon(poly: Polygon): void;
+    /**
+     * Stroke a rounded rectangle at the specified coordinates
+     * @param {number} x - x axis of the coordinate for the rounded rectangle starting point
+     * @param {number} y - y axis of the coordinate for the rounded rectangle starting point
+     * @param {number} width - the rounded rectangle's width
+     * @param {number} height - the rounded rectangle's height
+     * @param {number} radius - the rounded corner's radius
+     * @param {boolean} [fill=false] - also fill the shape with the current color if true
+     */
+    strokeRoundRect(x: number, y: number, width: number, height: number, radius: number, fill?: boolean): void;
+    /**
+     * Draw a rounded filled rectangle at the specified coordinates
+     * @param {number} x - x axis of the coordinate for the rounded rectangle starting point
+     * @param {number} y - y axis of the coordinate for the rounded rectangle starting point
+     * @param {number} width - the rounded rectangle's width
+     * @param {number} height - the rounded rectangle's height
+     * @param {number} radius - the rounded corner's radius
+     */
+    fillRoundRect(x: number, y: number, width: number, height: number, radius: number): void;
+    /**
+     * Stroke a Point at the specified coordinates
+     * @param {number} x - x axis of the coordinate for the point
+     * @param {number} y - y axis of the coordinate for the point
+     */
+    strokePoint(x: number, y: number): void;
+    /**
+     * Draw a point at the specified coordinates
+     * @param {number} x - x axis of the coordinate for the point
+     * @param {number} y - y axis of the coordinate for the point
+     */
+    fillPoint(x: number, y: number): void;
+    /**
+     * starts a new path by emptying the list of sub-paths
+     */
+    beginPath(): void;
+    /**
+     * begins a new sub-path at the point specified by the given (x, y) coordinates
+     * @param {number} x - the x axis of the point
+     * @param {number} y - the y axis of the point
+     */
+    moveTo(x: number, y: number): void;
+    /**
+     * adds a straight line to the current sub-path
+     * @param {number} x - the x axis of the point
+     * @param {number} y - the y axis of the point
+     */
+    lineTo(x: number, y: number): void;
+    /**
+     * Adds a quadratic Bezier curve to the current sub-path.
+     * @param {number} cpx - the x-axis coordinate of the control point
+     * @param {number} cpy - the y-axis coordinate of the control point
+     * @param {number} x - the x-axis coordinate of the end point
+     * @param {number} y - the y-axis coordinate of the end point
+     */
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+    /**
+     * Adds a cubic Bezier curve to the current sub-path.
+     * @param {number} cp1x - the x-axis coordinate of the first control point
+     * @param {number} cp1y - the y-axis coordinate of the first control point
+     * @param {number} cp2x - the x-axis coordinate of the second control point
+     * @param {number} cp2y - the y-axis coordinate of the second control point
+     * @param {number} x - the x-axis coordinate of the end point
+     * @param {number} y - the y-axis coordinate of the end point
+     */
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
+    /**
+     * Adds a circular arc to the current sub-path, using the given control points and radius.
+     * @param {number} x1 - the x-axis coordinate of the first control point
+     * @param {number} y1 - the y-axis coordinate of the first control point
+     * @param {number} x2 - the x-axis coordinate of the second control point
+     * @param {number} y2 - the y-axis coordinate of the second control point
+     * @param {number} radius - the arc's radius; must be non-negative
+     */
+    arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
+    /**
+     * creates a rectangular path whose starting point is at (x, y)
+     * @param {number} x - the x axis of the coordinate for the rectangle starting point
+     * @param {number} y - the y axis of the coordinate for the rectangle starting point
+     * @param {number} width - the rectangle's width
+     * @param {number} height - the rectangle's height
+     */
+    rect(x: number, y: number, width: number, height: number): void;
+    /**
+     * adds a rounded rectangle to the current path
+     * @param {number} x - the x axis of the coordinate for the rectangle starting point
+     * @param {number} y - the y axis of the coordinate for the rectangle starting point
+     * @param {number} width - the rectangle's width
+     * @param {number} height - the rectangle's height
+     * @param {number} radii - the corner radius
+     */
+    roundRect(x: number, y: number, width: number, height: number, radii: number): void;
+    /**
+     * add a straight line from the current point to the start of the current sub-path
+     */
+    closePath(): void;
+    /**
+     * stroke the given shape or the current defined path
+     * @param {Rect|RoundRect|Polygon|Line|Ellipse|Bounds} [shape] - a shape object to stroke
+     * @param {boolean} [fill=false] - fill the shape with the current color if true
+     */
+    stroke(shape?: Rect | RoundRect | Polygon | Line | Ellipse | Bounds, fill?: boolean): void;
+    /**
+     * fill the given shape or the current defined path
+     * @param {Rect|RoundRect|Polygon|Line|Ellipse|Bounds} [shape] - a shape object to fill
+     */
+    fill(shape?: Rect | RoundRect | Polygon | Line | Ellipse | Bounds): void;
+    /**
+     * Returns the WebGPU canvas context
+     * @returns {GPUCanvasContext} the WebGPU canvas context
+     */
+    getContext(): GPUCanvasContext;
+}
+import Renderer from "../renderer.js";
+import OrthogonalTMXLayerGPURenderer from "./renderers/tmxlayer/orthogonal.js";
+import TextureCache from "../texture/cache.js";
+import { Matrix3d } from "../../math/matrix3d.ts";
+import { Bounds } from "../../physics/bounds.ts";
+import WebGPUPipelineCache from "./pipeline/cache.js";
+import WebGPUBufferArena from "./buffer/arena.js";
+import WebGPUUniformRing from "./buffer/uniformring.js";
+import WebGPUTextureStore from "./texture/store.js";
+import WebGPURenderTarget from "../rendertarget/webgpurendertarget.js";
+import { Color } from "../../math/color.ts";
+import WebGPUBatcher from "./batchers/webgpu_batcher.js";
+import RadialGradientEffect from "../effects/radialGradient.js";
+import { TextureAtlas } from "../texture/atlas.js";
+//# sourceMappingURL=webgpu_renderer.d.ts.map

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "melonjs",
-	"version": "19.9.0",
+	"version": "20.0.0",
 	"description": "melonJS Game Engine",
 	"homepage": "http://www.melonjs.org/",
 	"type": "module",
@@ -66,12 +66,12 @@
 		"esbuild": "^0.27.3",
 		"serve": "^14.2.6",
 		"tsconfig": "workspace:^",
-		"tsx": "^4.23.0",
+		"tsx": "^4.23.1",
 		"type-fest": "^5.8.0",
 		"typedoc": "^0.28.20",
 		"typescript": "^6.0.2",
-		"vite": "8.0.16",
-		"vite-plugin-glsl": "^1.6.0"
+		"vite": "8.1.5",
+		"vite-plugin-glsl": "^1.6.1"
 	},
 	"scripts": {
 		"dev": "concurrently --raw \"pnpm build:watch\" \"pnpm tsc:watch\" \"pnpm doc:watch\"",
@@ -86,7 +86,7 @@
 		"serve": "serve docs",
 		"prepublishOnly": "pnpm dist:publish",
 		"clean": "tsx scripts/clean.ts",
-		"types": "tsc --project tsconfig.build.json",
+		"types": "tsc --project tsconfig.build.json && tsx scripts/strip-internal.ts",
 		"test:types": "tsc"
 	}
 }

package/build/video/webgl/effects/blur.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"blur.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/blur.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH;IACC;;;;;OAKG;IACH,sBALW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,QAAQ;QACN,WAAW;KACxC,EA8BA;IALA,iBAAuC;IAOxC;;;OAGG;IACH,sBAFW,MAAM,QAKhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBAnEwB,oBAAoB"}

package/build/video/webgl/effects/chromaticAberration.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chromaticAberration.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/chromaticAberration.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH;IACC;;;;;OAKG;IACH,sBALW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,MAAM;QACJ,WAAW;KACxC,EAuBA;IALA,eAAmC;IAOpC;;;OAGG;IACH,kBAFW,MAAM,QAKhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBA/DwB,oBAAoB"}

package/build/video/webgl/effects/colorMatrix.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"colorMatrix.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/colorMatrix.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAA8B,MAAM;KACtC,EAkBA;IANA;;;OAGG;IACH,qBAAkD;IAInD;;;OAGG;IACH,qBAEC;IAED;;;OAGG;IACH,SAFa,IAAI,CAMhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,WAAW,GACT,IAAI,CAMhB;IAED;;;;;OAKG;IACH,mBAHc,MAAM,EAAA,GACP,IAAI,CAMhB;CACD;yBApJwB,oBAAoB;4BADjB,+BAA+B"}

package/build/video/webgl/effects/desaturate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"desaturate.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/desaturate.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,SAAS;KACpC,EAMA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;8BAnC6B,kBAAkB"}

package/build/video/webgl/effects/dissolve.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dissolve.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/dissolve.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;;;OAMG;IACH,sBANW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,QAAQ;QACN,SAAS;QACX,SAAS;KACpC,EA0DA;IAPA,iBAAuC;IASxC;;;OAGG;IACH,mBAFW,MAAM,QAKhB;IAED;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAIlB;CACD;yBApGwB,oBAAoB"}

package/build/video/webgl/effects/dropShadow.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dropShadow.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/dropShadow.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;;;;;OAQG;IACH,sBARW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,OAAO;QACP,OAAO;QACL,KAAK;QACP,OAAO;QACL,WAAW;KACxC,EAmCA;IAED;;;;OAIG;IACH,aAHW,MAAM,KACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBAhFwB,oBAAoB"}

package/build/video/webgl/effects/flash.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flash.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/flash.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IACC;;;;;OAKG;IACH,sBALW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAA2B,KAAK;QACP,SAAS;KACpC,EAkBA;IAJA,kBAAyC;IAM1C;;;OAGG;IACH,oBAFW,MAAM,QAKhB;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;CACD;yBAjEwB,oBAAoB"}

package/build/video/webgl/effects/glow.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"glow.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/glow.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH;IACC;;;;;;;OAOG;IACH,sBAPW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAA2B,KAAK;QACP,KAAK;QACL,SAAS;QACP,WAAW;KACxC,EAsCA;IANA,kBAAyC;IAQ1C;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;IAED;;;OAGG;IACH,oBAFW,MAAM,QAKhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBAxFwB,oBAAoB"}

package/build/video/webgl/effects/hologram.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hologram.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/hologram.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH;IACC;;;;;OAKG;IACH,sBALW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAA2B,KAAK;QACP,SAAS;KACpC,EAyBA;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;CACD;yBAvDwB,oBAAoB"}

package/build/video/webgl/effects/invert.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"invert.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/invert.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,SAAS;KACpC,EAMA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;8BAlC6B,kBAAkB"}

package/build/video/webgl/effects/outline.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"outline.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/outline.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH;IACC;;;;;;OAMG;IACH,sBANW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAA2B,KAAK;QACP,KAAK;QACH,WAAW;KACxC,EAsCA;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBA1FwB,oBAAoB"}

package/build/video/webgl/effects/pixelate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pixelate.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/pixelate.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH;IACC;;;;;OAKG;IACH,sBALW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,IAAI;QACF,WAAW;KACxC,EAoBA;IALA,aAA+B;IAOhC;;;OAGG;IACH,cAFW,MAAM,QAKhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBA3DwB,oBAAoB"}

package/build/video/webgl/effects/radialGradient.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"radialGradient.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/radialGradient.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH;IACC;;;;;OAKG;IACH,sBALW,aAAa,YAErB;QAAwB,KAAK;QACJ,SAAS;KACpC,EA0CA;IAZA,qCAAoC;IAcrC;;;;OAIG;IACH,gBAFW,KAAK,QAOf;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAIhB;CACD;yBArJwB,oBAAoB;2BAInB,wBAAwB;8CACL,sBAAsB"}

package/build/video/webgl/effects/scanline.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scanline.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/scanline.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH;IACC;;;;;;OAMG;IACH,sBANW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,OAAO;QACP,SAAS;QACT,gBAAgB;KAC3C,EAyCA;IAED;;;OAGG;IACH,oBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,8BAFW,MAAM,QAIhB;CACD;yBA3FwB,oBAAoB"}

package/build/video/webgl/effects/sepia.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sepia.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/sepia.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,SAAS;KACpC,EAMA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;8BAjC6B,kBAAkB"}

package/build/video/webgl/effects/shine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shine.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/shine.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH;IACC;;;;;;;;;;;OAWG;IACH,sBAXW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAA2B,KAAK;QACP,KAAK;QACL,KAAK;QACL,SAAS;QACT,KAAK;QACL,KAAK;QACL,UAAU;QACV,UAAU;KACrC,EAuDA;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,oBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAIhB;CACD;yBA1IwB,oBAAoB"}

package/build/video/webgl/effects/tintPulse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tintPulse.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/tintPulse.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH;IACC;;;;;;OAMG;IACH,sBANW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAA2B,KAAK;QACP,KAAK;QACL,SAAS;KACpC,EAqBA;IAED;;;OAGG;IACH,cAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;CACD;yBAhEwB,oBAAoB"}

package/build/video/webgl/effects/vignette.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vignette.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/vignette.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH;IACC;;;;;OAKG;IACH,sBALW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,QAAQ;QACR,IAAI;KAC/B,EAoBA;IALA,iBAAwC;IACxC,aAAgC;IAMjC;;;OAGG;IACH,sBAFW,MAAM,QAKhB;IAED;;;OAGG;IACH,cAFW,MAAM,QAKhB;CACD;yBA/DwB,oBAAoB"}