paperlab 0.7.0 → 0.7.1

package/dist/index.cjs

@@ -3718,6 +3718,8 @@ var ClothSim = class {
   height;
   positions;
   prev;
+  /** Where the constructor laid every particle out — what {@link restore} puts back. */
+  laidOut;
   pinned;
   pinTargets;
   /**
@@ -3851,6 +3853,7 @@ var ClothSim = class {
       }
     }
     this.prev.set(this.positions);
+    this.laidOut = this.positions.slice();
     const idx = (r2, c2) => r2 * cols + c2;
     const links = [];
     const link = (a, b2, kind) => {
@@ -3968,6 +3971,22 @@ var ClothSim = class {
     this.asleep = false;
     this.stillFrames = 0;
   }
+  /**
+   * Back to the sheet as it was laid out: flat, still, every particle where
+   * the constructor put it. Pins, a grab and every lever are left alone.
+   *
+   * For a history that has been rewound — a burn played back from an earlier
+   * moment, say, which hands back paper that had burnt away and paper that
+   * had FALLEN, lying on the floor with its springs to the sheet suddenly
+   * whole again. Solved from there, the solve hauls it up through the sheet
+   * in a tangle. Laid out afresh, it is simply the sheet it is again.
+   */
+  restore() {
+    this.positions.set(this.laidOut);
+    this.prev.set(this.laidOut);
+    this.accumulator = 0;
+    this.wake();
+  }
   /**
    * Take hold of the sheet at one particle.
    *
@@ -4338,6 +4357,7 @@ var CHAR_SHRINK = 0.12;
 var CHAR_CURL = 6;
 var FRONT_GRADIENT = 16 * 16;
 var WET_MASS = 2;
+var TEAR_STRETCH = 1.5;
 var DamageCoupling = class {
   sim;
   source = null;
@@ -4347,8 +4367,24 @@ var DamageCoupling = class {
   particleTexel = new Int32Array(0);
   /** Gone, per particle, as of the last read. */
   gone;
+  /** Whether any particle has ever been gone since the last reset — nothing can tear before. */
+  holed = false;
   /** The gone particles with live paper beside them. See {@link follow}. */
   followers = [];
+  /**
+   * Which piece of paper each particle belongs to, named by the lowest index
+   * in it — or -1 in the middle of a hole.
+   *
+   * A piece is whatever the sim's unbroken springs still hold together, which
+   * is exactly what moves as one: two pieces are two things the solve lets
+   * part. A gone particle on a cut takes the piece it borders MOST — a cut a
+   * single particle wide borders two, and a particle averaged between them
+   * would be dragged across the gap as one piece fell, stretching both edges
+   * into it.
+   */
+  piece;
+  /** Union-find over the particles, reused on every read. */
+  parent;
   /**
    * Per bend spring, how squarely it lies ACROSS the burn front, 0..1 — and
    * remembered once it has been.
@@ -4366,9 +4402,20 @@ var DamageCoupling = class {
    * but the paper stays rolled the way it rolled.
    */
   curlWeight;
+  /** The mesh's index as it was built — what {@link tear} hides triangles from and mends them back to. */
+  original = null;
+  /** Per triangle of that index: torn, and hidden until the history is rewound. */
+  torn = new Uint8Array(0);
+  /** The triangles with a gone corner — the only ones that can tear. */
+  rim = [];
+  rimStale = true;
+  /** Every torn triangle has to be put back: the history was rewound, or the source went. */
+  mend = false;
   constructor(sim) {
     this.sim = sim;
     this.gone = new Uint8Array(sim.count);
+    this.piece = new Int32Array(sim.count);
+    this.parent = new Int32Array(sim.count);
     this.curlWeight = new Float32Array(sim.constraintCount);
   }
   /**
@@ -4380,7 +4427,13 @@ var DamageCoupling = class {
   update(source) {
     const next = source ?? null;
     if (next === this.source && (next === null || next.version === this.version)) return false;
-    if (next !== this.source) this.curlWeight.fill(0);
+    if (next !== this.source) {
+      this.curlWeight.fill(0);
+      if (next && this.holed) {
+        this.rewind();
+        this.gone.fill(0);
+      }
+    }
     this.source = next;
     if (!next) {
       this.reset();
@@ -4400,12 +4453,13 @@ var DamageCoupling = class {
    * laid out flat around them — their positions plus its rest offset from
    * each, averaged. The triangles that straddle the burnt edge then keep
    * roughly their shape instead of stretching back to wherever the particle
-   * was when it burnt. Only a band of a single particle's width, with live
-   * paper pulling it both ways, is left averaging between them.
+   * was when it burnt. Only the neighbours in its own {@link piece} count, so
+   * on a cut between two pieces it leaves with one of them.
    */
   follow() {
     if (this.followers.length === 0) return;
     const { gone, sim } = this;
+    const piece = this.piece;
     const p2 = sim.positions;
     const { cols, rows } = sim;
     const cellX = cols > 1 ? sim.width / (cols - 1) : 0;
@@ -4413,6 +4467,7 @@ var DamageCoupling = class {
     for (const g of this.followers) {
       const r2 = g / cols | 0;
       const c2 = g % cols;
+      const own = piece[g];
       let sx = 0;
       let sy = 0;
       let sz = 0;
@@ -4424,7 +4479,7 @@ var DamageCoupling = class {
           const nc = c2 + dc;
           if (dr === 0 && dc === 0 || nc < 0 || nc >= cols) continue;
           const j3 = nr * cols + nc;
-          if (gone[j3]) continue;
+          if (gone[j3] || piece[j3] !== own) continue;
           const j32 = j3 * 3;
           sx += p2[j32] - dc * cellX;
           sy += p2[j32 + 1] + dr * cellY;
@@ -4439,6 +4494,70 @@ var DamageCoupling = class {
       p2[g3 + 2] = sz / n;
     }
   }
+  /**
+   * Hide the triangles a piece has torn away from. Call after {@link follow},
+   * with the sheet's index buffer: it is rewritten in place, and the return
+   * says whether it changed, so the caller knows to upload it.
+   *
+   * A triangle tears when one of its edges has stretched past
+   * {@link TEAR_STRETCH} — which, among triangles with a burnt-away corner,
+   * only ever happens across a gap that is opening. It is then collapsed to a
+   * point, which draws nothing, casts no shadow and adds nothing to its
+   * corners' normals, and it stays hidden: torn paper does not mend because
+   * the two sides swing close again. Only a rewound history puts it back.
+   *
+   * A sheet in one piece, held, never stretches one that far — so a burn that
+   * cuts nothing loose leaves this index exactly as it was built.
+   */
+  tear(index) {
+    if (!this.holed && !this.mend) return false;
+    if (!this.original || this.original.length !== index.length) {
+      this.original = index.slice();
+      this.torn = new Uint8Array(index.length / 3);
+      this.rimStale = true;
+    }
+    const { original, torn, gone, sim } = this;
+    let changed = false;
+    if (this.mend) {
+      this.mend = false;
+      index.set(original);
+      changed = true;
+    }
+    if (this.rimStale) {
+      this.rimStale = false;
+      const rim = [];
+      for (let t = 0; t < torn.length; t++) {
+        if (gone[original[t * 3]] || gone[original[t * 3 + 1]] || gone[original[t * 3 + 2]]) rim.push(t);
+      }
+      this.rim = rim;
+    }
+    const p2 = sim.positions;
+    const { cols, rows } = sim;
+    const cellX = cols > 1 ? sim.width / (cols - 1) : 0;
+    const cellY = rows > 1 ? sim.height / (rows - 1) : 0;
+    const limit = TEAR_STRETCH * TEAR_STRETCH;
+    const stretched = (i, j3) => {
+      const dc = i % cols - j3 % cols;
+      const dr = (i / cols | 0) - (j3 / cols | 0);
+      const rest = (dc * cellX) ** 2 + (dr * cellY) ** 2;
+      const i3 = i * 3;
+      const j32 = j3 * 3;
+      const now = (p2[i3] - p2[j32]) ** 2 + (p2[i3 + 1] - p2[j32 + 1]) ** 2 + (p2[i3 + 2] - p2[j32 + 2]) ** 2;
+      return now > rest * limit;
+    };
+    for (const t of this.rim) {
+      if (torn[t]) continue;
+      const a = original[t * 3];
+      const b2 = original[t * 3 + 1];
+      const c2 = original[t * 3 + 2];
+      if (!stretched(a, b2) && !stretched(b2, c2) && !stretched(c2, a)) continue;
+      torn[t] = 1;
+      index[t * 3 + 1] = a;
+      index[t * 3 + 2] = a;
+      changed = true;
+    }
+    return changed;
+  }
   /** Map each particle to its texel. The damage grid's row 0 is v = 0, the sheet's BOTTOM. */
   layout(size) {
     const { cols, rows, count } = this.sim;
@@ -4466,12 +4585,19 @@ var DamageCoupling = class {
       constraintKind,
       constraintMiddle
     } = sim;
+    let rewound = false;
+    let holed = false;
     for (let i = 0; i < sim.count; i++) {
       const t = particleTexel[i] * 4;
       const isGone = pixels[t + PRESENCE] < GONE_BELOW;
+      if (gone[i] && !isGone) rewound = true;
+      if (isGone) holed = true;
       gone[i] = isGone ? 1 : 0;
       invMass[i] = isGone ? 0 : 1 / (1 + WET_MASS * pixels[t + SATURATION] / 255);
     }
+    if (rewound) this.rewind();
+    this.holed = holed;
+    this.rimStale = true;
     for (let k2 = 0; k2 < sim.constraintCount; k2++) {
       const a = constraintA[k2];
       const b2 = constraintB[k2];
@@ -4504,31 +4630,95 @@ var DamageCoupling = class {
         restBend[k2] = CHAR_CURL * char * curlWeight[k2] * span * span / 8;
       }
     }
+    this.findPieces();
+  }
+  /**
+   * Which piece each particle is in ({@link piece}), and which gone ones
+   * follow a piece at all ({@link followers}).
+   *
+   * Pieces by union-find over the springs that still hold, rooted at the
+   * lowest index so the same burn names the same pieces every time. Then each
+   * gone particle with live paper beside it joins the piece it has the most
+   * neighbours in, the lower-named on a tie.
+   */
+  findPieces() {
+    const { sim, gone } = this;
+    const parent = this.parent;
+    const piece = this.piece;
+    const { broken, constraintA, constraintB } = sim;
+    for (let i = 0; i < sim.count; i++) parent[i] = i;
+    const find = (i) => {
+      let r2 = i;
+      while (parent[r2] !== r2) r2 = parent[r2];
+      while (parent[i] !== r2) {
+        const up = parent[i];
+        parent[i] = r2;
+        i = up;
+      }
+      return r2;
+    };
+    for (let k2 = 0; k2 < sim.constraintCount; k2++) {
+      if (broken[k2]) continue;
+      const ra = find(constraintA[k2]);
+      const rb = find(constraintB[k2]);
+      if (ra < rb) parent[rb] = ra;
+      else if (rb < ra) parent[ra] = rb;
+    }
+    for (let i = 0; i < sim.count; i++) piece[i] = gone[i] ? -1 : find(i);
     const followers = [];
     const { cols, rows } = sim;
+    const seen = [];
+    const votes = [];
     for (let i = 0; i < sim.count; i++) {
       if (!gone[i]) continue;
       const r2 = i / cols | 0;
       const c2 = i % cols;
-      let beside = false;
-      for (let dr = -1; dr <= 1 && !beside; dr++) {
+      seen.length = 0;
+      votes.length = 0;
+      for (let dr = -1; dr <= 1; dr++) {
         const nr = r2 + dr;
         if (nr < 0 || nr >= rows) continue;
         for (let dc = -1; dc <= 1; dc++) {
           const nc = c2 + dc;
           if (nc < 0 || nc >= cols) continue;
-          if (!gone[nr * cols + nc]) {
-            beside = true;
-            break;
+          const j3 = nr * cols + nc;
+          if (gone[j3]) continue;
+          const at = seen.indexOf(piece[j3]);
+          if (at < 0) {
+            seen.push(piece[j3]);
+            votes.push(1);
+          } else {
+            votes[at]++;
           }
         }
       }
-      if (beside) followers.push(i);
+      if (seen.length === 0) continue;
+      let best = 0;
+      for (let k2 = 1; k2 < seen.length; k2++) {
+        if (votes[k2] > votes[best] || votes[k2] === votes[best] && seen[k2] < seen[best]) best = k2;
+      }
+      piece[i] = seen[best];
+      followers.push(i);
     }
     this.followers = followers;
   }
+  /**
+   * A rewound history: the sheet starts over.
+   *
+   * Paper that had fallen away is paper again, with every spring back to the
+   * sheet it was cut from — solved from where it lies, the solve would haul it
+   * up off the floor through the sheet in a tangle. And the curl it rolled
+   * into belonged to a front that has not passed yet.
+   */
+  rewind() {
+    this.sim.restore();
+    this.curlWeight.fill(0);
+    this.torn.fill(0);
+    this.mend = true;
+  }
   reset() {
     const { sim } = this;
+    if (this.holed) this.rewind();
     sim.invMass.fill(1);
     sim.restBend.fill(0);
     sim.broken.fill(0);
@@ -4536,6 +4726,7 @@ var DamageCoupling = class {
     this.gone.fill(0);
     this.curlWeight.fill(0);
     this.followers = [];
+    this.holed = false;
     this.version = -1;
     sim.wake();
   }
@@ -8188,7 +8379,11 @@ var PaperMesh = (0, import_react8.forwardRef)(function PaperMesh2(props, ref) {
       coupling?.update(props.damage);
       sim.step(delta);
       const moved = !sim.asleep;
-      if (moved) coupling?.follow();
+      if (moved && coupling) {
+        coupling.follow();
+        const index = geometry.index;
+        if (index && coupling.tear(index.array)) index.needsUpdate = true;
+      }
       if (!applyShape(sim.positions, moved) && moved) {
         const position = geometry.attributes.position;
         position.array.set(sim.positions);