@pixerate/editor 0.217.0 → 0.218.1

package/dist/paint-editor/index.js

@@ -32,6 +32,7 @@ import {
   SRGB_TO_LINEAR,
   WET_FLOW_KINDS,
   WET_PARAM_KEYS,
+  WET_TILE,
   WetMedium,
   WetWorld,
   createPigmentTools,
@@ -39,13 +40,14 @@ import {
   findWebGpu,
   flowField,
   linearToSrgb8,
+  moveWetSnapshot,
   normalizeFlow,
   normalizeTilt,
   normalizeWetParams,
   pigmentOf,
   pointerPressure,
   wetSupport
-} from "../chunk-WJ2RBZMM.js";
+} from "../chunk-HLBTRSQJ.js";
 import "../chunk-HVQVHUTV.js";
 import {
   writeZip
@@ -2162,15 +2164,50 @@ var PaintWetLayers = class {
       if (this.world.laneIds().length) throw new Error("The wet world is the wrong size; dry the paint before resizing the canvas.");
       this.dropWorld();
     }
-    if (!this.world) {
-      this.world = new WetWorld(width, height, wetPaperInput(this.host.paper()), { kernel: this.options.kernel, threads: this.options.threads });
-      this.world.setTilt(this.tilt);
-      this.world.gpuMinTiles = this.gpuMinTiles;
-      if (this.gpu) this.world.attachGpu(this.gpu);
-      else this.startGpu();
-    }
+    if (!this.world) this.world = this.makeWorld(width, height, this.host.paper());
     return this.world;
   }
+  makeWorld(width, height, paper) {
+    const world = new WetWorld(width, height, wetPaperInput(paper), { kernel: this.options.kernel, threads: this.options.threads });
+    world.setTilt(this.tilt);
+    world.gpuMinTiles = this.gpuMinTiles;
+    if (this.gpu) world.attachGpu(this.gpu);
+    else this.startGpu();
+    return world;
+  }
+  /**
+   * Whether `extend` can keep the wet paint when the canvas grows by `left` / `top` on those
+   * sides: the shift has to be whole wet tiles (256 px), and no wet stroke may be live.
+   */
+  canExtend(left, top) {
+    return left % WET_TILE === 0 && top % WET_TILE === 0 && !this.driver;
+  }
+  /**
+   * Keeps the wet paint while the canvas grows to `width`×`height` by `left` / `top` on those
+   * sides (`canExtend` must hold): the world is made again at the new size with every wet layer
+   * moved by (left, top), still wet, its base and flow map with it; `paper` is the new
+   * document's paper (its grain moved with the paint). Wet settings' flow centres move too. The
+   * caller shows the layers again (`syncDisplays`) once the document is the new size.
+   */
+  extend(width, height, left, top, paper) {
+    if (!this.canExtend(left, top)) throw new Error("Wet paint only moves by whole 256 px tiles, between strokes.");
+    for (const [id, s] of this.settings) if (s.flow.center) this.settings.set(id, { ...s, flow: { ...s.flow, center: { x: s.flow.center.x + left, y: s.flow.center.y + top } } });
+    const old = this.world;
+    const snap = old?.laneIds().length ? old.snapshot() : null;
+    this.dropWorld();
+    this.lastTick = null;
+    this.stepsOwed = 0;
+    if (!old || !snap) return;
+    const moved = moveWetSnapshot(snap, old, { width, height }, left, top, (l) => {
+      const flow = this.settings.get(l.id)?.flow;
+      return {
+        base: translateSurface(l.base, left, top),
+        flow: l.flow && flow && flow.kind !== "none" ? flowField(flow, width, height) : l.flow
+      };
+    });
+    this.world = this.makeWorld(width, height, paper);
+    this.world.restore(moved);
+  }
   /** Whether any layer (or `layerId`) has wet paint. */
   isWet(layerId) {
     const w = this.world;
@@ -3709,9 +3746,11 @@ var PaintEditorController = class _PaintEditorController {
    * move by (left, top) in document pixels, `document.origin` moves by (−left, −top), and the view
    * pans so the picture stays still on screen.
    *
-   * Wet paint dries first (the wet simulation is canvas-sized), as with `setCanvas`; one undo step
-   * (undo brings back the old size, origin and guides, and the wet paint). Returns the new canvas,
-   * where it sits in the previous document's pixels, and the origin.
+   * Wet paint stays wet and moves with the picture when `left` and `top` are whole 256 px tiles
+   * (so a host growing a canvas while someone paints should grow it in tile steps); otherwise it
+   * dries first (the wet simulation is canvas-sized), as with `setCanvas`. One undo step (undo
+   * brings back the old size, origin and guides, and the wet paint). Returns the new canvas, where
+   * it sits in the previous document's pixels, and the origin.
    */
   extendCanvas(by) {
     this.requireIdle("extending the canvas");
@@ -3731,14 +3770,29 @@ var PaintEditorController = class _PaintEditorController {
     if (width > MAX_CANVAS_SIDE || height > MAX_CANVAS_SIDE) {
       throw new PaintEditorError(`The canvas would be ${width}\xD7${height}; the limit is ${MAX_CANVAS_SIDE} px per side. Extend by less (it is ${was.width}\xD7${was.height} now).`);
     }
+    let keptWet = [];
     if (this.wet.world) {
       this.requireWetIdle("extending the canvas");
-      this.dryLayersFirst(this.wet.wetLayerIds());
-      const settings = [...this.wet.settings];
-      this.wet.reset();
-      for (const [id, s] of settings) this.wet.settings.set(id, s.flow.center ? { ...s, flow: { ...s.flow, center: { x: s.flow.center.x + left, y: s.flow.center.y + top } } } : s);
+      if (this.wet.canExtend(left, top)) {
+        keptWet = this.wet.wetLayerIds();
+        if (keptWet.length) this.beginWetOp();
+      } else {
+        this.dryLayersFirst(this.wet.wetLayerIds());
+      }
+    }
+    let next = { ...shiftDocument(this.withWetEvents(this.doc), left, top), canvas: { ...was, width, height } };
+    for (const id of keptWet) {
+      const l = findLayer(next.layers, id)?.layer;
+      if (isPixelLayer(l)) next = { ...next, layers: mapLayer(next.layers, id, () => ({ ...l, surface: translateSurface(l.surface, l.offset.x, l.offset.y), offset: { x: 0, y: 0 } })) };
+    }
+    if (this.wet.world) {
+      if (keptWet.length) this.wet.extend(width, height, left, top, next.paper);
+      else {
+        const settings = [...this.wet.settings];
+        this.wet.reset();
+        for (const [id, s] of settings) this.wet.settings.set(id, s.flow.center ? { ...s, flow: { ...s.flow, center: { x: s.flow.center.x + left, y: s.flow.center.y + top } } } : s);
+      }
     }
-    const next = { ...shiftDocument(this.withWetEvents(this.doc), left, top), canvas: { ...was, width, height } };
     const m = viewMatrix(this.view, was, { width: 0, height: 0 });
     const dx = (right - left) / 2;
     const dy = (bottom - top) / 2;
@@ -3746,6 +3800,7 @@ var PaintEditorController = class _PaintEditorController {
     const guidesBefore = this.guides;
     if (left || top) this.restoreGuides(shiftGuides(this.guides, left, top));
     this.commit("Extend canvas", next);
+    if (keptWet.length) this.wet.syncDisplays();
     if (this.guides !== guidesBefore) this.undoStack[this.undoStack.length - 1].guides = { before: guidesBefore, after: this.guides };
     const origin = { ...next.origin ?? { x: 0, y: 0 } };
     return { canvas: { ...next.canvas }, rect: { x: 0 - left, y: 0 - top, width, height }, origin };
@@ -7433,7 +7488,7 @@ function createPaintEditorToolProvider(controller, options = {}) {
   add({
     name: "extend_canvas",
     title: "Extend the canvas",
-    description: "Grows the canvas by adding pixels on any side, keeping everything painted. Adding on the left or top moves the whole picture (layers, paper grain, guides, stencils, recorded strokes) right or down by that much in document pixels, so coordinates you read before change by (+left, +top). Wet paint dries first. One undo step. Returns the canvas, rect (the new canvas in the previous coordinates: x -left, y -top) and origin.",
+    description: "Grows the canvas by adding pixels on any side, keeping everything painted. Adding on the left or top moves the whole picture (layers, paper grain, guides, stencils, recorded strokes) right or down by that much in document pixels, so coordinates you read before change by (+left, +top). Wet paint stays wet and moves with it when left and top are multiples of 256; otherwise it dries first. One undo step. Returns the canvas, rect (the new canvas in the previous coordinates: x -left, y -top) and origin.",
     inputSchema: {
       type: "object",
       properties: { left: EXTEND_SIDE("left"), top: EXTEND_SIDE("top"), right: EXTEND_SIDE("right"), bottom: EXTEND_SIDE("bottom") },

package/dist/paint-editor/wet.d.cts

@@ -214,6 +214,20 @@ export declare class PaintWetLayers {
     engineInfo(): WetEngineInfo;
     /** The world (made on first use, at the canvas size). */
     ensureWorld(): WetWorld;
+    private makeWorld;
+    /**
+     * Whether `extend` can keep the wet paint when the canvas grows by `left` / `top` on those
+     * sides: the shift has to be whole wet tiles (256 px), and no wet stroke may be live.
+     */
+    canExtend(left: number, top: number): boolean;
+    /**
+     * Keeps the wet paint while the canvas grows to `width`×`height` by `left` / `top` on those
+     * sides (`canExtend` must hold): the world is made again at the new size with every wet layer
+     * moved by (left, top), still wet, its base and flow map with it; `paper` is the new
+     * document's paper (its grain moved with the paint). Wet settings' flow centres move too. The
+     * caller shows the layers again (`syncDisplays`) once the document is the new size.
+     */
+    extend(width: number, height: number, left: number, top: number, paper: PaperSettings): void;
     /** Whether any layer (or `layerId`) has wet paint. */
     isWet(layerId?: string): boolean;
     /** Layers holding a wet layer (wet or drying). */

package/dist/paint-editor/wet.d.ts

@@ -214,6 +214,20 @@ export declare class PaintWetLayers {
     engineInfo(): WetEngineInfo;
     /** The world (made on first use, at the canvas size). */
     ensureWorld(): WetWorld;
+    private makeWorld;
+    /**
+     * Whether `extend` can keep the wet paint when the canvas grows by `left` / `top` on those
+     * sides: the shift has to be whole wet tiles (256 px), and no wet stroke may be live.
+     */
+    canExtend(left: number, top: number): boolean;
+    /**
+     * Keeps the wet paint while the canvas grows to `width`×`height` by `left` / `top` on those
+     * sides (`canExtend` must hold): the world is made again at the new size with every wet layer
+     * moved by (left, top), still wet, its base and flow map with it; `paper` is the new
+     * document's paper (its grain moved with the paint). Wet settings' flow centres move too. The
+     * caller shows the layers again (`syncDisplays`) once the document is the new size.
+     */
+    extend(width: number, height: number, left: number, top: number, paper: PaperSettings): void;
     /** Whether any layer (or `layerId`) has wet paint. */
     isWet(layerId?: string): boolean;
     /** Layers holding a wet layer (wet or drying). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pixerate/editor",
-  "version": "0.217.0",
+  "version": "0.218.1",
   "description": "UI-agnostic rich text and media editing core library",
   "author": "Pixerate",
   "license": "MIT",

package/skills/pixerate-paint-editor/SKILL.md

@@ -283,7 +283,7 @@ view), so work with the tools you are given.
 | `get_canvas_info` | Read the canvas size and dpi, its `origin` (moved by `extend_canvas`), paper (preset, colour, depth), active layer, layer count, active brush id, colours, view, hand, number of recorded strokes, undo / redo labels and the blend modes. Call first. |
 | `new_canvas` | Start over with a blank canvas: one empty layer over the paper. `width`, `height` (1..16384 px), `dpi`, `paper` preset id; missing ones keep the current values. Undo brings the old painting back. Returns the size, paper and layer id. |
 | `set_canvas` | Resize the canvas (pixels stay put, anchored top-left) or change its `dpi`. Returns the canvas. |
-| `extend_canvas` | Add pixels on any side (`left`, `top`, `right`, `bottom`, default 0) keeping everything painted, the paper grain and the guides in place relative to each other. `left` / `top` move all document coordinates by that much. Wet paint dries first; one undo step. Returns `canvas`, `rect` (the new canvas in the previous coordinates) and `origin` (also in `get_canvas_info`). |
+| `extend_canvas` | Add pixels on any side (`left`, `top`, `right`, `bottom`, default 0) keeping everything painted, the paper grain and the guides in place relative to each other. `left` / `top` move all document coordinates by that much. Wet paint stays wet and moves with it when `left` and `top` are multiples of 256; otherwise it dries first. One undo step. Returns `canvas`, `rect` (the new canvas in the previous coordinates) and `origin` (also in `get_canvas_info`). |
 | `list_papers` | Read the paper library: id, name, family, grain pattern, colour, depth and the wet-media properties (absorption, permeability, roughness, stored for later wet media). Call before `set_paper`. |
 | `get_paper` | Read every setting of the current paper (pattern, seed, scale, tiling, depth, shading, dry and wet tuning). |
 | `set_paper` | Change the paper: `preset`, then any of `color`, `depth` (0..1), `scale` (0.25..8), `seed` (another sheet), `pattern`, `tiling`, `shading`, `dry` / `wet` tuning (`contrast` 0..3, `invert`). Affects new strokes' grain and how the paper shows; strokes already painted keep their pixels. Returns the paper. |