modern-canvas 0.24.6 → 0.24.8

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/renderers/gl/shader/GlProgramData.d.ts

@@ -1,3 +1,4 @@
+import type { GlUniform } from './GlProgram';
 export declare class GlProgramData {
     native: WebGLProgram;
     /**
@@ -6,5 +7,16 @@ export declare class GlProgramData {
      * group's data is (re)uploaded to this program.
      */
     uniformDirtyGroups: Record<number, number>;
+    /**
+     * Per-context uniform metadata: introspected name/type/size plus the lazily
+     * resolved {@link GlUniform.location} and the shadow copy of the last uploaded
+     * value. Both `location` and `value` are specific to THIS linked program in
+     * THIS GL context, so they must live here — not on the shared {@link GlProgram},
+     * which a module-level (static) Material reuses across multiple renderers/contexts.
+     * Storing them on the shared program would let one context clobber another's
+     * locations/shadows (e.g. a sampler `uniform1i` silently dropped → the sampler
+     * falls back to texture unit 0).
+     */
+    uniforms: Record<string, GlUniform>;
     constructor(native: WebGLProgram);
 }

package/dist/core/renderers/gl/shader/GlShaderSystem.d.ts

@@ -36,7 +36,7 @@ export declare class GlShaderSystem extends GlSystem {
      * the group has not changed since it was last synced to this program.
      */
     updateUniformGroup(group: UniformGroup, glProgram: GlProgram): void;
-    protected _uploadUniforms(glProgram: GlProgram, glProgramData: GlProgramData, uniforms: Record<string, any>): void;
+    protected _uploadUniforms(glProgramData: GlProgramData, uniforms: Record<string, any>): void;
     reset(): void;
     destroy(): void;
 }

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[];