@pixerate/editor 0.275.0 → 0.276.0

package/dist/{chunk-LMG57L5A.js → chunk-CTHWXW5M.js}

@@ -1,3 +1,7 @@
+import {
+  LivePatternField,
+  moveLivePatternSnapshot
+} from "./chunk-LDZOXESA.js";
 import {
   TILE,
   TiledSurface,
@@ -852,10 +856,30 @@ var noLight = () => new TiledSurface(1, /* @__PURE__ */ new Map(), 0);
 function cloneGhost(g) {
   return g ? { pigment: [...g.pigment], remaining: g.remaining, total: g.total, linger: g.linger, ...g.trigger === "agent" ? { trigger: "agent" } : {} } : null;
 }
-function newLane(id, index, params, flow, flowStrength, base, light, ghost) {
+function newLane(id, index, params, flow, flowStrength, base, light, width, height, ghost, livePatterns) {
   const l = light ?? noLight();
   const g = cloneGhost(ghost);
-  return { id, index, params, flow, flowStrength, base, shaded: /* @__PURE__ */ new Map(), urgent: /* @__PURE__ */ new Set(), stamp: 1, display: null, shadedVersion: 0, displayKey: "", light: l, lit: !g && l.tiles.size > 0, ghost: g, lightShaded: /* @__PURE__ */ new Map(), lightDisplay: null, lightKey: "" };
+  return {
+    id,
+    index,
+    params,
+    flow,
+    flowStrength,
+    base,
+    shaded: /* @__PURE__ */ new Map(),
+    urgent: /* @__PURE__ */ new Set(),
+    stamp: 1,
+    display: null,
+    shadedVersion: 0,
+    displayKey: "",
+    light: l,
+    lit: !g && l.tiles.size > 0,
+    ghost: g,
+    lightShaded: /* @__PURE__ */ new Map(),
+    lightDisplay: null,
+    lightKey: "",
+    livePatterns: livePatterns ?? new LivePatternField(width, height)
+  };
 }
 var WetWorldError = class extends Error {
   constructor(message) {
@@ -1016,12 +1040,28 @@ var WetWorld = class {
       if (options.params) this.setParams(id, options.params);
       if (options.base) this.setBase(id, options.base);
       if (options.light) this.setLight(id, options.light);
+      if (options.livePatterns && existing.livePatterns !== options.livePatterns) {
+        existing.livePatterns = options.livePatterns;
+        this.touchAll(existing);
+      }
       if (options.ghost !== void 0) this.setGhost(id, options.ghost);
       return;
     }
     const index = this.lanes.indexOf(null);
     if (index < 0) throw new WetWorldError(`At most ${MAX_WET_LANES} layers can hold wet paint at once; dry one (dry_paint) first.`);
-    this.lanes[index] = newLane(id, index, normalizeWetParams(options.params ?? {}, DEFAULT_WET_PARAMS), options.flow ?? null, options.flow ? options.flowStrength ?? 1 : 0, options.base ?? new TiledSurface(4, /* @__PURE__ */ new Map(), 0), options.light, options.ghost);
+    this.lanes[index] = newLane(
+      id,
+      index,
+      normalizeWetParams(options.params ?? {}, DEFAULT_WET_PARAMS),
+      options.flow ?? null,
+      options.flow ? options.flowStrength ?? 1 : 0,
+      options.base ?? new TiledSurface(4, /* @__PURE__ */ new Map(), 0),
+      options.light,
+      this.width,
+      this.height,
+      options.ghost,
+      options.livePatterns
+    );
     this.pack(this.lanes[index]);
   }
   /** Drops a wet layer and its wet paint (nothing is baked). */
@@ -1041,6 +1081,52 @@ var WetWorld = class {
     this.pack(lane);
     return { ...lane.params };
   }
+  getLivePatterns(id) {
+    return { ...this.laneOf(id).livePatterns.settings };
+  }
+  hasLivePatterns(id) {
+    const lane = this.laneOf(id);
+    return lane.livePatterns.enabled;
+  }
+  livePatternField(id) {
+    return this.laneOf(id).livePatterns;
+  }
+  setLivePatterns(id, settings) {
+    this.requireIdle();
+    const lane = this.laneOf(id);
+    const next = lane.livePatterns.configure(settings);
+    this.touchAll(lane);
+    return next;
+  }
+  seedLivePatterns(id, cx, cy, radius, seed = 1, strength = 1, settings) {
+    this.requireIdle();
+    const lane = this.laneOf(id);
+    if (settings) lane.livePatterns.configure(settings);
+    const count = lane.livePatterns.seedDisc(cx, cy, radius, seed, strength);
+    if (count > 0) this.touchAll(lane);
+    return count;
+  }
+  livePatternStats(id) {
+    const lane = this.laneOf(id);
+    return lane.livePatterns.stats((tx, ty, lx, ly) => this.isPatternCellWet(lane, tx, ty, lx, ly));
+  }
+  isPatternCellWet(lane, tx, ty, lx, ly) {
+    const { tilesX, tilesY, perLane } = this.layout;
+    if (tx < 0 || ty < 0 || tx >= tilesX || ty >= tilesY) return false;
+    const slot = this.slotOf(lane.index * perLane + ty * tilesX + tx);
+    if (slot < 0) return false;
+    const cur = this.slotBase(slot) + this.parity * SET_PLANES * PLANE;
+    const x0 = lx * 2 + 1;
+    const y0 = ly * 2 + 1;
+    const c00 = y0 * S2 + x0;
+    const c10 = c00 + 1;
+    const c01 = c00 + S2;
+    const c11 = c01 + 1;
+    const rhoBase = cur + P_RHO * PLANE;
+    const swBase = cur + P_SW * PLANE;
+    const f = this.f32;
+    return f[rhoBase + c00] + f[swBase + c00] > DRY_EPS || f[rhoBase + c10] + f[swBase + c10] > DRY_EPS || f[rhoBase + c01] + f[swBase + c01] > DRY_EPS || f[rhoBase + c11] + f[swBase + c11] > DRY_EPS;
+  }
   getTilt() {
     return { ...this.tilt };
   }
@@ -1378,6 +1464,14 @@ var WetWorld = class {
     const flagsBase = l.flags >> 2;
     const lastBase = l.last >> 2;
     const { tilesX, tilesY, perLane } = l;
+    for (const lane of this.lanes) {
+      if (!lane || !lane.livePatterns.enabled || lane.livePatterns.tiles.size === 0) continue;
+      lane.livePatterns.step(
+        n,
+        (tx, ty, lx, ly) => this.isPatternCellWet(lane, tx, ty, lx, ly),
+        (tx, ty) => this.slotOf(lane.index * perLane + ty * tilesX + tx) >= 0
+      );
+    }
     const wakeups = [];
     for (const key of this.active) {
       const fl = this.u32[flagsBase + key];
@@ -2051,6 +2145,7 @@ var WetWorld = class {
     }
     const src = lane.base.tiles.get(tk)?.data ?? null;
     const out = this.shadeSlot(key, src, all ? "bake-all" : "bake");
+    if (lane.livePatterns.enabled) lane.livePatterns.markBaked(tx, ty);
     if (!out) return lightChanged;
     const tiles = new Map(lane.base.tiles);
     const t = finishTile(out, 4, 0);
@@ -2086,7 +2181,7 @@ var WetWorld = class {
     const h = Math.min(WET_TILE, this.height - ty * WET_TILE);
     const lane = this.lanes[this.laneIndexOf(key)];
     const lit = lane.lit && !lane.ghost;
-    const changed = shadeTile(
+    let changed = shadeTile(
       this.f32,
       PLANE,
       S2,
@@ -2103,6 +2198,9 @@ var WetWorld = class {
       lit ? b + P_DL * PLANE : -1,
       lit && mode !== "bake" ? cur + P_L * PLANE : -1
     );
+    if (lane.livePatterns.enabled && lane.livePatterns.tiles.size > 0) {
+      changed = lane.livePatterns.shadeTile(tx, ty, out, w, h) || changed;
+    }
     return changed ? out : null;
   }
   /** The layer's pixels with all its wet paint dried where it is (the bake of "dry on save"); changes nothing. */
@@ -2550,7 +2648,11 @@ var WetWorld = class {
       slots.set(key, { planes, last: this.u32[(this.layout.last >> 2) + key] });
       bytes += planes.byteLength;
     }
-    const lanes = this.lanes.filter((l) => Boolean(l)).map((l) => ({ id: l.id, index: l.index, params: { ...l.params }, flow: l.flow, flowStrength: l.flowStrength, base: l.base, light: l.light, lit: l.lit, ghost: cloneGhost(l.ghost) }));
+    const lanes = this.lanes.filter((l) => Boolean(l)).map((l) => {
+      const lp = l.livePatterns.snapshot();
+      bytes += lp.bytes;
+      return { id: l.id, index: l.index, params: { ...l.params }, flow: l.flow, flowStrength: l.flowStrength, base: l.base, light: l.light, lit: l.lit, ghost: cloneGhost(l.ghost), livePatterns: lp };
+    });
     return { clock: this.clock, tilt: { ...this.tilt }, lanes, slots, bytes };
   }
   /** Puts a snapshot back exactly (the simulation then continues as it would have). */
@@ -2560,8 +2662,9 @@ var WetWorld = class {
     this.lanes.fill(null);
     this.tilt = { ...snap.tilt };
     for (const l of snap.lanes) {
-      const lane = newLane(l.id, l.index, { ...l.params }, l.flow, l.flowStrength, l.base, l.light, l.ghost);
+      const lane = newLane(l.id, l.index, { ...l.params }, l.flow, l.flowStrength, l.base, l.light, this.width, this.height, l.ghost);
       lane.lit = !lane.ghost && (lane.lit || Boolean(l.lit));
+      if (l.livePatterns) lane.livePatterns.restore(l.livePatterns);
       this.lanes[l.index] = lane;
       this.pack(this.lanes[l.index]);
     }
@@ -2619,9 +2722,19 @@ function moveWetSnapshot(snap, from, to, dx, dy, lane = () => ({})) {
   }
   const lanes = snap.lanes.map((l) => {
     const moved = lane(l);
-    return { ...l, base: moved.base ?? l.base, light: moved.light ?? l.light, flow: moved.flow === void 0 ? l.flow : moved.flow };
+    const lp = l.livePatterns ? moveLivePatternSnapshot(l.livePatterns, to, tx0, ty0) : void 0;
+    if (lp) bytes += lp.bytes;
+    return { ...l, base: moved.base ?? l.base, light: moved.light ?? l.light, flow: moved.flow === void 0 ? l.flow : moved.flow, ...lp ? { livePatterns: lp } : {} };
   });
-  return { clock: snap.clock, tilt: { ...snap.tilt }, lanes, slots, bytes };
+  let patterns;
+  if (snap.patterns) {
+    patterns = /* @__PURE__ */ new Map();
+    for (const [id, p] of snap.patterns) {
+      const mp = moveLivePatternSnapshot(p, to, tx0, ty0);
+      patterns.set(id, mp);
+    }
+  }
+  return { clock: snap.clock, tilt: { ...snap.tilt }, lanes, slots, ...patterns ? { patterns } : {}, bytes };
 }
 function unionRect(a, b) {
   if (!a) return { ...b };

package/dist/{chunk-43XJC3PP.js → chunk-CVBTJVRN.js}

@@ -18,7 +18,7 @@ import {
   unionBounds,
   vectorGradientPoints,
   widthProfileAt
-} from "./chunk-Y2ISSVPH.js";
+} from "./chunk-4EM5NGCL.js";
 import {
   segmentLength,
   segmentParamAtLength,

package/dist/{chunk-RJGW3RQS.js → chunk-GHYJAMMS.js}

@@ -1,6 +1,6 @@
 import {
   PAINT_PROFILE
-} from "./chunk-ZM7IKQ4X.js";
+} from "./chunk-XVPQNX7O.js";
 import {
   brushColourHex
 } from "./chunk-DVPQFMH6.js";