modern-canvas 0.24.6 → 0.24.7

package/dist/Engine.d.ts

@@ -51,8 +51,42 @@ export declare class Engine extends SceneTree {
     nextTick(): Promise<void>;
     waitUntilLoad(): Promise<void>;
     waitAndRender(delta?: number): Promise<void>;
+    /**
+     * Like {@link waitAndRender} but without the final `_render`. Used by the
+     * export pipeline, where rendering at the full (possibly oversized) logical
+     * size would allocate a render target beyond the GPU limit; {@link toPixels}
+     * performs the actual (tiled) rendering instead.
+     */
+    waitUntilProcessed(delta?: number): Promise<void>;
+    /**
+     * Resize for an export pass. The requested size is remembered as the export
+     * output size, but the root viewport + canvas are capped at the GPU limit:
+     * the root's RenderTarget texture is reactive and re-uploads (texImage2D) on
+     * every size change, so setting it beyond MAX_TEXTURE_SIZE — even just to hold
+     * a "logical" size — throws `width or height out of range`. {@link toPixels}
+     * tiles within the cap and stitches the full image. Does not render.
+     */
+    resizeForExport(width: number, height: number): this;
     render(node?: Node, delta?: number): void;
     start(): Promise<void>;
+    /**
+     * Largest dimension (in device pixels) a single offscreen render pass can
+     * allocate. The root scene renders into a RenderTarget texture (plus a
+     * stencil renderbuffer when masks are used) sized to the canvas, so any
+     * export larger than these GPU limits throws
+     * `texImage2D: width or height out of range`. Oversized exports are tiled
+     * within this budget instead.
+     */
+    protected _maxExportPassSize(): number;
+    /** Tile budget in logical units (the GPU limit is in device pixels). */
+    protected _exportTileLimit(): number;
+    /** Resize the renderer + root viewport without triggering a render. */
+    protected _resizeSilently(width: number, height: number): void;
+    /** Full export size (set by {@link resizeForExport}); falls back to the root size. */
+    protected _exportWidth: number;
+    protected _exportHeight: number;
+    get exportWidth(): number;
+    get exportHeight(): number;
     needsChunkReadPixels(): boolean;
     toPixels(): Uint8ClampedArray<ArrayBuffer>;
     toImageData(): ImageData;

package/dist/core/shared/utils.d.ts

@@ -1,3 +1,21 @@
 export declare const PI: number;
 export declare const PI_2: number;
 export declare function isPow2(v: number): boolean;
+export interface ExportTile {
+    /** Left offset of the tile in the full image (logical units). */
+    x: number;
+    /** Top offset of the tile in the full image (logical units). */
+    y: number;
+    /** Tile width (logical units); clamped at the right edge. */
+    width: number;
+    /** Tile height (logical units); clamped at the bottom edge. */
+    height: number;
+}
+/**
+ * Split a `width × height` image into a grid of tiles no larger than `limit`
+ * on either axis. Used to export images that exceed a single GPU render pass
+ * (texture / renderbuffer / viewport limits). Tiles are returned row-major and
+ * cover the whole image with no overlap; edge tiles are clamped to the
+ * remaining size. Returns an empty array for a degenerate (zero-area) image.
+ */
+export declare function planExportTiles(width: number, height: number, limit: number): ExportTile[];