@pixerate/editor 0.275.0 → 0.276.0

package/dist/{chunk-DHC4E2DU.cjs → chunk-MITQGHN3.cjs}

@@ -1,6 +1,10 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;
 
 
+var _chunkIFWLZZCWcjs = require('./chunk-IFWLZZCW.cjs');
+
+
+
 
 
 var _chunk474IQG74cjs = require('./chunk-474IQG74.cjs');
@@ -852,10 +856,30 @@ var noLight = () => new (0, _chunk474IQG74cjs.TiledSurface)(1, /* @__PURE__ */ n
 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 = _nullishCoalesce(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: _nullishCoalesce(livePatterns, () => ( new (0, _chunkIFWLZZCWcjs.LivePatternField)(width, height)))
+  };
 }
 var WetWorldError = class extends Error {
   constructor(message) {
@@ -1016,12 +1040,28 @@ var WetWorld = (_class = 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(_nullishCoalesce(options.params, () => ( {})), DEFAULT_WET_PARAMS), _nullishCoalesce(options.flow, () => ( null)), options.flow ? _nullishCoalesce(options.flowStrength, () => ( 1)) : 0, _nullishCoalesce(options.base, () => ( new (0, _chunk474IQG74cjs.TiledSurface)(4, /* @__PURE__ */ new Map(), 0))), options.light, options.ghost);
+    this.lanes[index] = newLane(
+      id,
+      index,
+      normalizeWetParams(_nullishCoalesce(options.params, () => ( {})), DEFAULT_WET_PARAMS),
+      _nullishCoalesce(options.flow, () => ( null)),
+      options.flow ? _nullishCoalesce(options.flowStrength, () => ( 1)) : 0,
+      _nullishCoalesce(options.base, () => ( new (0, _chunk474IQG74cjs.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 = 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 = 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 = class {
     }
     const src = _nullishCoalesce(_optionalChain([lane, 'access', _22 => _22.base, 'access', _23 => _23.tiles, 'access', _24 => _24.get, 'call', _25 => _25(tk), 'optionalAccess', _26 => _26.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 = _chunk474IQG74cjs.finishTile.call(void 0, out, 4, 0);
@@ -2086,7 +2181,7 @@ var WetWorld = (_class = 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 = 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 = 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 = 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: _nullishCoalesce(moved.base, () => ( l.base)), light: _nullishCoalesce(moved.light, () => ( l.light)), flow: moved.flow === void 0 ? l.flow : moved.flow };
+    const lp = l.livePatterns ? _chunkIFWLZZCWcjs.moveLivePatternSnapshot.call(void 0, l.livePatterns, to, tx0, ty0) : void 0;
+    if (lp) bytes += lp.bytes;
+    return { ...l, base: _nullishCoalesce(moved.base, () => ( l.base)), light: _nullishCoalesce(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 = _chunkIFWLZZCWcjs.moveLivePatternSnapshot.call(void 0, 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-STLTOISW.cjs → chunk-NPPMKMCU.cjs}

@@ -12,7 +12,7 @@
 
 
 
-var _chunkNIBFKXMDcjs = require('./chunk-NIBFKXMD.cjs');
+var _chunkIFWLZZCWcjs = require('./chunk-IFWLZZCW.cjs');
 
 
 var _chunk3K6HWEXZcjs = require('./chunk-3K6HWEXZ.cjs');
@@ -54,7 +54,7 @@ function lean(s) {
   return null;
 }
 function pathStrokeDabs(samples, options) {
-  const brush = _chunkNIBFKXMDcjs.normalizeBrush.call(void 0, options.brush);
+  const brush = _chunkIFWLZZCWcjs.normalizeBrush.call(void 0, options.brush);
   const pts = options.closed && samples.length > 2 ? [...samples, samples[0]] : [...samples];
   if (!pts.length) return [];
   const tilt = _nullishCoalesce(options.tilt, () => ( {}));
@@ -127,24 +127,24 @@ function pathStrokeDabs(samples, options) {
   return out;
 }
 function pathStrokeCoverage(samples, options) {
-  const brush = _chunkNIBFKXMDcjs.normalizeBrush.call(void 0, options.brush);
-  const coverage = new (0, _chunkNIBFKXMDcjs.CoverageMap)();
+  const brush = _chunkIFWLZZCWcjs.normalizeBrush.call(void 0, options.brush);
+  const coverage = new (0, _chunkIFWLZZCWcjs.CoverageMap)();
   const dabs = pathStrokeDabs(samples, options);
   const g = _optionalChain([options, 'access', _5 => _5.gradient, 'optionalAccess', _6 => _6.paint, 'access', _7 => _7.type]) === "gradient" ? options.gradient : null;
-  const sampler = g ? new (0, _chunkNIBFKXMDcjs.PaintGradientSampler)(_chunkNIBFKXMDcjs.resolvePaintGradient.call(void 0, g.paint, _nullishCoalesce(g.colors, () => ( { paint: "#000000", secondary: "#ffffff" }))), _nullishCoalesce(g.seed, () => ( 0))) : null;
-  const tipTable = _optionalChain([sampler, 'optionalAccess', _8 => _8.acrossTip]) ? sampler.tipTable(_chunkNIBFKXMDcjs.TIP_GRADIENT_STEPS) : null;
+  const sampler = g ? new (0, _chunkIFWLZZCWcjs.PaintGradientSampler)(_chunkIFWLZZCWcjs.resolvePaintGradient.call(void 0, g.paint, _nullishCoalesce(g.colors, () => ( { paint: "#000000", secondary: "#ffffff" }))), _nullishCoalesce(g.seed, () => ( 0))) : null;
+  const tipTable = _optionalChain([sampler, 'optionalAccess', _8 => _8.acrossTip]) ? sampler.tipTable(_chunkIFWLZZCWcjs.TIP_GRADIENT_STEPS) : null;
   const scratch = { field: new Float32Array(0), sample: { rgb: [0, 0, 0], alpha: 1 } };
   let buf = new Float32Array(0);
   let bounds = null;
   for (const d of dabs) {
-    const rect = _chunkNIBFKXMDcjs.dabRect.call(void 0, d, brush.hardness);
+    const rect = _chunkIFWLZZCWcjs.dabRect.call(void 0, d, brush.hardness);
     const n = rect.width * rect.height;
     if (n <= 0) continue;
     if (buf.length < n) buf = new Float32Array(n);
     const vals = buf.subarray(0, n);
-    _chunkNIBFKXMDcjs.rasterizeDab.call(void 0, d, brush.hardness, rect, vals);
+    _chunkIFWLZZCWcjs.rasterizeDab.call(void 0, d, brush.hardness, rect, vals);
     if (sampler) {
-      const { color, field } = _chunkNIBFKXMDcjs.gradientDabColor.call(void 0, sampler, tipTable, d, d.params, rect, vals, scratch);
+      const { color, field } = _chunkIFWLZZCWcjs.gradientDabColor.call(void 0, sampler, tipTable, d, d.params, rect, vals, scratch);
       coverage.accumulate(rect, vals, d.opacity, color, field);
     } else coverage.accumulate(rect, vals, d.opacity);
     if (!bounds) bounds = { ...rect };
@@ -161,7 +161,7 @@ function pathStrokeCoverage(samples, options) {
       const { tx, ty } = _chunk474IQG74cjs.tileCoord.call(void 0, key);
       for (let y = 0, k = 0; y < _chunk474IQG74cjs.TILE; y++) {
         const gy = ty * _chunk474IQG74cjs.TILE + y + 0.5;
-        for (let x = 0; x < _chunk474IQG74cjs.TILE; x++, k++) if (t[k] > 0) t[k] *= _chunkNIBFKXMDcjs.strokeGrainCatch.call(void 0, grain.at(tx * _chunk474IQG74cjs.TILE + x + 0.5, gy), grain.depth, pressure);
+        for (let x = 0; x < _chunk474IQG74cjs.TILE; x++, k++) if (t[k] > 0) t[k] *= _chunkIFWLZZCWcjs.strokeGrainCatch.call(void 0, grain.at(tx * _chunk474IQG74cjs.TILE + x + 0.5, gy), grain.depth, pressure);
       }
     }
   }
@@ -169,11 +169,11 @@ function pathStrokeCoverage(samples, options) {
 }
 function paintPathStroke(surface, samples, options) {
   if (surface.channels !== 4) throw new Error("paintPathStroke paints RGBA surfaces (4 channels).");
-  const brush = _chunkNIBFKXMDcjs.normalizeBrush.call(void 0, options.brush);
+  const brush = _chunkIFWLZZCWcjs.normalizeBrush.call(void 0, options.brush);
   const hex = (c) => "#" + [0, 1, 2].map((i) => Math.round(Math.min(255, Math.max(0, c[i]))).toString(16).padStart(2, "0")).join("");
   let color = options.color;
   if (_optionalChain([options, 'access', _11 => _11.paint, 'optionalAccess', _12 => _12.paint, 'access', _13 => _13.type]) === "color") {
-    const rgb = _chunkNIBFKXMDcjs.hexToPaintRgb.call(void 0, options.paint.paint.color).map((v) => Math.round(v * 255));
+    const rgb = _chunkIFWLZZCWcjs.hexToPaintRgb.call(void 0, options.paint.paint.color).map((v) => Math.round(v * 255));
     color = [rgb[0], rgb[1], rgb[2], color[3]];
   }
   const gradient = _optionalChain([options, 'access', _14 => _14.paint, 'optionalAccess', _15 => _15.paint, 'access', _16 => _16.type]) === "gradient" ? { ...options.paint, colors: _nullishCoalesce(options.paint.colors, () => ( { paint: hex(color), secondary: "#ffffff" })) } : null;
@@ -195,7 +195,7 @@ function paintPathStroke(surface, samples, options) {
     const key = _chunk474IQG74cjs.tileKey.call(void 0, tx, ty);
     const src = _optionalChain([surface, 'access', _17 => _17.tiles, 'access', _18 => _18.get, 'call', _19 => _19(key), 'optionalAccess', _20 => _20.data]);
     const base = src && src.length === _chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * 4 ? src : new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * 4);
-    const t = _chunk474IQG74cjs.finishTile.call(void 0, _chunkNIBFKXMDcjs.applyStrokeToTile.call(void 0, coverage, base, 4, tx, ty, apply), 4, surface.defaultValue);
+    const t = _chunk474IQG74cjs.finishTile.call(void 0, _chunkIFWLZZCWcjs.applyStrokeToTile.call(void 0, coverage, base, 4, tx, ty, apply), 4, surface.defaultValue);
     if (t) tiles.set(key, t);
     else tiles.delete(key);
   }
@@ -239,7 +239,7 @@ var REFUSED_ENGINES = {
 };
 function brushstrokeStrokeOptions(brush) {
   if (!brush || typeof brush !== "object") throw new Error("A brushstroke needs a brush: tip settings ({ size, hardness, \u2026 }) or a paint brush preset.");
-  if (!("tip" in brush) || !brush.tip) return { brush: _chunkNIBFKXMDcjs.normalizeBrush.call(void 0, brush) };
+  if (!("tip" in brush) || !brush.tip) return { brush: _chunkIFWLZZCWcjs.normalizeBrush.call(void 0, brush) };
   const engine = _nullishCoalesce(brush.engine, () => ( "dab"));
   if (engine !== "dab") {
     const label = _nullishCoalesce(_nullishCoalesce(brush.name, () => ( brush.id)), () => ( "This brush"));
@@ -249,7 +249,7 @@ function brushstrokeStrokeOptions(brush) {
   const d = _nullishCoalesce(brush.dynamics, () => ( {}));
   const tilt = { size: _nullishCoalesce(d.tiltSize, () => ( 0)), roundness: _nullishCoalesce(d.tiltRoundness, () => ( 0)) };
   return {
-    brush: _chunkNIBFKXMDcjs.normalizeBrush.call(void 0, brush.tip),
+    brush: _chunkIFWLZZCWcjs.normalizeBrush.call(void 0, brush.tip),
     followPath: brush.rotation === "stroke",
     minSize: _nullishCoalesce(d.minSize, () => ( 0)),
     ...tilt.size || tilt.roundness ? { tilt } : {}
@@ -273,7 +273,7 @@ function paperGrain(paper) {
   const key = `${pattern}:${seed}:${scale}`;
   let g = papers.get(key);
   if (!g) {
-    g = new (0, _chunkNIBFKXMDcjs.PaperGrain)({ pattern, seed, scale, tiling: "mirror", dry: { contrast: 1, invert: false }, wet: { contrast: 1, invert: false } });
+    g = new (0, _chunkIFWLZZCWcjs.PaperGrain)({ pattern, seed, scale, tiling: "mirror", dry: { contrast: 1, invert: false }, wet: { contrast: 1, invert: false } });
     if (papers.size > 16) papers.delete(papers.keys().next().value);
     papers.set(key, g);
   }
@@ -326,7 +326,7 @@ function renderBrushstroke(input, brush, options = {}) {
     closed: _nullishCoalesce(options.closed, () => ( strokeOptions.closed)),
     color,
     // Gradient lengths are in path units: scale them with the image.
-    ...source ? { paint: { paint: source.type === "gradient" ? _chunkNIBFKXMDcjs.scalePaintGradient.call(void 0, source, scale) : source, seed: _nullishCoalesce(options.seed, () => ( 0)) } } : {}
+    ...source ? { paint: { paint: source.type === "gradient" ? _chunkIFWLZZCWcjs.scalePaintGradient.call(void 0, source, scale) : source, seed: _nullishCoalesce(options.seed, () => ( 0)) } } : {}
   });
   if (!bounds) return { image: { width: 0, height: 0, data: new Uint8ClampedArray(0) }, bounds: null, scale, dabs };
   const rect = bounds;

package/dist/{chunk-75SYKUOT.js → chunk-OS6OG7DN.js}

@@ -5,7 +5,7 @@ import {
   moveAnchorHandle,
   subpathSegment,
   subpathSegmentCount
-} from "./chunk-Y2ISSVPH.js";
+} from "./chunk-4EM5NGCL.js";
 import {
   segmentPoint
 } from "./chunk-WEIK3UYB.js";