@adatechnology/game-destruction-three 0.3.2 → 0.4.0

package/README.md

@@ -102,6 +102,9 @@ loose meshes. An invalid range (outside the geometry or empty) throws from `bind
 | `ricochet` | sparks along the reflected direction | `ricochet` |
 | `debris` | a burst of the requested kind (`sparks`, `dust`, `shards`, `splinters`, `chips`, `fibers`, `leaves`, `drips`, `ash`, `smoke`, `steam`) | |
 | `fracture` | part hidden; fragments (boxes, thin irregular prisms for shards) with gravity, ground bounce, settling, sleep and shrink-away; debris burst by style | `shatter_glass`, `crumble`, `splinter`, `impact_*` |
+| `spall` | opaque patch (disc decal) in the colour of the part's core material where a coat came off, under the holes; sits on the face of the mesh the point is nearest to (the thin axis of its world box) | |
+| `stage` (2, with `fragments`) | the unit-sized fragments of the breach fly out with the same physics as `fracture` fragments, the holes of `Fragment.marks` ride on them as dark discs, a dust burst; the part stays drawn (cutting the opening in its faces is left to the house renderer) | `crumble`, `impact_*` |
+| `expose` | the bars as instanced cylinders (radius 4 mm), one mesh per part, replaced by each new `expose`; empty `bars` removes the cage; `renderer.rebarCount()` | |
 | `detach` | with `autoSplit`, each loose group becomes its own `Group` (world transforms kept) and a `Piece` (`onPiece`) | `detach` |
 | `disassemble_progress` | | `unscrew` (throttled) |
 | `ignite` / `extinguish` / `burnout` | fire and smoke from the surface while `part.burning`; steam when put out; ash at burnout; char lerps the colour to the material `charColor`; status `ashes` hides the part and leaves an ash pile | `ignite`, `burn_loop`, `extinguish` |

package/dist/index.d.ts

@@ -114,6 +114,8 @@ interface DestructionRenderer {
         pieces: number;
         decals: number;
     };
+    /** Bars of exposed rebar drawn now (`expose` events; one instanced mesh per part). */
+    rebarCount(): number;
     dispose(): void;
 }
 interface SpecFromObjectOptions {

package/dist/index.global.js

@@ -83,6 +83,8 @@ var GameDestructionThree = (() => {
       __publicField(this, "v");
       __publicField(this, "w");
       __publicField(this, "rng", createRng(1374496523));
+      __publicField(this, "markGeometry", null);
+      __publicField(this, "markMaterial", null);
       this.box = new THREE.BoxGeometry(1, 1, 1);
       this.q = new THREE.Quaternion();
       this.dq = new THREE.Quaternion();
@@ -129,6 +131,25 @@ var GameDestructionThree = (() => {
       }
       return g;
     }
+    /**
+     * Bullet holes that stay on a fragment (`Fragment.marks`): dark discs that are children of its mesh, so they fall, spin and settle with it. The mesh is
+     * a unit box scaled to the fragment, so each disc is scaled back; exact for a mark on a face, which is where a bullet hole is.
+     */
+    addMarks(mesh, f) {
+      if (!f.marks?.length) return;
+      this.markGeometry ?? (this.markGeometry = new this.THREE.CircleGeometry(1, 10));
+      this.markMaterial ?? (this.markMaterial = new this.THREE.MeshBasicMaterial({ color: 723465, depthWrite: false, polygonOffset: true, polygonOffsetFactor: -4, polygonOffsetUnits: -4 }));
+      const sc = mesh.scale;
+      for (const mark of f.marks) {
+        const disc = new this.THREE.Mesh(this.markGeometry, this.markMaterial);
+        const radius = Math.max(4e-3, mark.diameter) * 0.6;
+        const n = this.v.set(mark.normal[0], mark.normal[1], mark.normal[2]).normalize();
+        disc.position.set(mark.point[0] / sc.x + n.x * 2e-3 / sc.x, mark.point[1] / sc.y + n.y * 2e-3 / sc.y, mark.point[2] / sc.z + n.z * 2e-3 / sc.z);
+        disc.quaternion.setFromUnitVectors(this.w.set(0, 0, 1), n);
+        disc.scale.set(radius / sc.x, radius / sc.y, radius / sc.z);
+        mesh.add(disc);
+      }
+    }
     /** Create the mesh of a fragment and start its motion. `maxAllowed` is the live budget. */
     spawn(f, material, home, maxAllowed) {
       const geo = f.shape === "shard" ? this.shardGeometry(hashString(f.id)) : this.box;
@@ -162,6 +183,8 @@ var GameDestructionThree = (() => {
           alive--;
         }
       }
+      this.addMarks(mesh, f);
+      return mesh;
     }
     /** Add velocity to every fragment within `radius` of a point (blasts). */
     blast(point, radius, speed) {
@@ -285,6 +308,8 @@ var GameDestructionThree = (() => {
     dispose() {
       this.clear();
       this.box.dispose();
+      this.markGeometry?.dispose();
+      this.markMaterial?.dispose();
       for (const g of this.shardGeos) g?.dispose();
       this.shardGeos = [];
       for (const m of this.materials.values()) m.dispose();
@@ -1036,6 +1061,78 @@ void main() {
     }
   };
 
+  // src/rebar.ts
+  var RebarCages = class {
+    constructor(THREE, scene, radius = 4e-3) {
+      __publicField(this, "THREE", THREE);
+      __publicField(this, "scene", scene);
+      __publicField(this, "cages", /* @__PURE__ */ new Map());
+      __publicField(this, "geometry");
+      __publicField(this, "material");
+      __publicField(this, "up");
+      __publicField(this, "dir");
+      __publicField(this, "mid");
+      __publicField(this, "q");
+      __publicField(this, "scale");
+      __publicField(this, "m");
+      this.geometry = new THREE.CylinderGeometry(radius, radius, 1, 6);
+      this.material = new THREE.MeshStandardMaterial({ color: 7628380, roughness: 0.55, metalness: 0.6 });
+      this.up = new THREE.Vector3(0, 1, 0);
+      this.dir = new THREE.Vector3();
+      this.mid = new THREE.Vector3();
+      this.q = new THREE.Quaternion();
+      this.scale = new THREE.Vector3();
+      this.m = new THREE.Matrix4();
+    }
+    /** Bars drawn now, over every part. */
+    get count() {
+      let n = 0;
+      for (const mesh of this.cages.values()) n += mesh.count;
+      return n;
+    }
+    /** Meshes of the live cages (tests and picking). */
+    meshes() {
+      return [...this.cages.values()];
+    }
+    /** Draw `bars` (world space) as the cage of `key`; an empty list removes it. */
+    set(key, bars) {
+      this.remove(key);
+      if (bars.length === 0) return;
+      const mesh = new this.THREE.InstancedMesh(this.geometry, this.material, bars.length);
+      bars.forEach(([a, b], i) => {
+        this.dir.set(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+        const length = this.dir.length();
+        this.mid.set((a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2);
+        this.q.setFromUnitVectors(this.up, length > 1e-9 ? this.dir.divideScalar(length) : this.up);
+        this.m.compose(this.mid, this.q, this.scale.set(1, Math.max(length, 1e-4), 1));
+        mesh.setMatrixAt(i, this.m);
+      });
+      mesh.instanceMatrix.needsUpdate = true;
+      mesh.castShadow = true;
+      this.scene.add(mesh);
+      this.cages.set(key, mesh);
+    }
+    remove(key) {
+      const mesh = this.cages.get(key);
+      if (!mesh) return;
+      this.scene.remove(mesh);
+      mesh.dispose();
+      this.cages.delete(key);
+    }
+    /** Remove the cages of every part of `object` (keys are `object|part`). */
+    removeObject(object) {
+      for (const key of [...this.cages.keys()]) if (key.startsWith(`${object}|`)) this.remove(key);
+    }
+    clear() {
+      for (const key of [...this.cages.keys()]) this.remove(key);
+    }
+    dispose() {
+      this.clear();
+      this.geometry.dispose();
+      this.material.dispose();
+    }
+  };
+
   // ../game-destruction/dist/index.js
   var EPS = 1e-9;
   var IDENTITY = [0, 0, 0, 1];
@@ -2288,6 +2385,7 @@ void main() {
       __publicField(this, "disc", null);
       __publicField(this, "discMat", null);
       __publicField(this, "lineMats", /* @__PURE__ */ new Map());
+      __publicField(this, "patchMats", /* @__PURE__ */ new Map());
     }
     discGeometry() {
       return this.disc ?? (this.disc = new this.THREE.CircleGeometry(1, 14));
@@ -2303,6 +2401,15 @@ void main() {
         polygonOffsetUnits: -4
       }));
     }
+    /** Opaque patch in the colour of what shows under a spalled coat. */
+    patchMaterial(color) {
+      let m = this.patchMats.get(color);
+      if (!m) {
+        m = new this.THREE.MeshBasicMaterial({ color, depthWrite: false, polygonOffset: true, polygonOffsetFactor: -3, polygonOffsetUnits: -3 });
+        this.patchMats.set(color, m);
+      }
+      return m;
+    }
     lineMaterial(color) {
       let m = this.lineMats.get(color);
       if (!m) {
@@ -2315,6 +2422,8 @@ void main() {
       this.disc?.dispose();
       this.discMat?.dispose();
       for (const m of this.lineMats.values()) m.dispose();
+      for (const m of this.patchMats.values()) m.dispose();
+      this.patchMats.clear();
       this.disc = null;
       this.discMat = null;
       this.lineMats.clear();
@@ -2606,6 +2715,16 @@ void main() {
       disc.renderOrder = 2;
       this.addDecal(mv, { obj: disc });
     }
+    /** A patch where a surface coat came off, in the colour of the core under it; drawn under the bullet holes. */
+    addSpall(mv, worldPoint, worldNormal, radius, color) {
+      const { s, pos, quat: quat2 } = this.decalPose(mv.mesh, worldPoint, worldNormal, 15e-4);
+      const disc = new this.THREE.Mesh(this.kit.discGeometry(), this.kit.patchMaterial(color));
+      disc.position.copy(pos);
+      disc.quaternion.copy(quat2);
+      disc.scale.setScalar(Math.max(0.01, radius) / s);
+      disc.renderOrder = 1;
+      this.addDecal(mv, { obj: disc });
+    }
     /** A star of jagged lines: `rays` rays up to `length` metres, seeded so the same event always draws the same star. */
     addCrack(mv, worldPoint, worldNormal, rays, length, color, seed) {
       const { s, pos, quat: quat2 } = this.decalPose(mv.mesh, worldPoint, worldNormal, 2e-3);
@@ -3131,6 +3250,7 @@ void main() {
       __publicField(this, "fragments");
       __publicField(this, "ground");
       __publicField(this, "pieceSys");
+      __publicField(this, "cages");
       __publicField(this, "active", /* @__PURE__ */ new Map());
       __publicField(this, "fires", /* @__PURE__ */ new Map());
       __publicField(this, "leaks", []);
@@ -3182,6 +3302,7 @@ void main() {
         max: this.maxFragments,
         life: o.fragmentLife ?? 12
       });
+      this.cages = new RebarCages(THREE, o.scene);
       this.pieceSys = new PieceSystem(THREE, {
         groundAt: this.groundAt,
         gravity: this.gravity,
@@ -3483,6 +3604,15 @@ void main() {
             this.sound("ignite", ev.point, 0.7);
           }
           break;
+        case "spall":
+          this.onSpall(ev);
+          break;
+        case "stage":
+          this.onStage(ev);
+          break;
+        case "expose":
+          this.cages.set(`${ev.object}|${ev.part}`, ev.bars);
+          break;
         case "extinguish": {
           const f = this.fires.get(`${ev.object}|${ev.part}`);
           if (f) {
@@ -3648,6 +3778,43 @@ void main() {
       }
       this.sound(impactKey(def), ev.worldPoint, 0.5);
     }
+    /** Outward normal of the face of `mv` nearest to a world point: the thin axis of its world box (right for a wall; a sloped face is left to the vertex-range binding). */
+    faceNormal(mv, point) {
+      const box = this.visuals.worldBox(mv, this.box);
+      const size = box.getSize(this.v1);
+      const axis = size.x <= size.y && size.x <= size.z ? "x" : size.y <= size.z ? "y" : "z";
+      const side = point[axis] >= (box.min[axis] + box.max[axis]) / 2 ? 1 : -1;
+      return new this.THREE.Vector3(axis === "x" ? side : 0, axis === "y" ? side : 0, axis === "z" ? side : 0);
+    }
+    /** A coat came off: a patch in the colour of the core under it, below the bullet holes and cracks. */
+    onSpall(ev) {
+      const pv = this.partVis(ev.object, ev.part);
+      if (!pv) return;
+      const wp = new this.THREE.Vector3(ev.point[0], ev.point[1], ev.point[2]);
+      const mv = this.nearestMesh(pv, wp);
+      if (!mv) return;
+      const def = this.world.materials.get(pv.material);
+      this.visuals.addSpall(mv, wp, this.faceNormal(mv, wp), Math.sqrt(ev.area / Math.PI), fallbackColor(pv.material, def));
+    }
+    /**
+     * Stage 2 of a staged part: the unit-sized fragments come out and the part stays drawn (hiding it is what `fracture` does). The opening itself
+     * (cutting the wall's faces) is not drawn yet: it needs the per-vertex binding of the house renderer.
+     */
+    onStage(ev) {
+      if (!ev.fragments || !ev.opening) return;
+      const pv = this.partVis(ev.object, ev.part);
+      const def = pv ? this.world.materials.get(pv.material) : void 0;
+      const color = (pv ? this.partColor(pv, def) : null) ?? fallbackColor(pv?.material ?? "", def);
+      const maxAlive = this.low ? Math.floor(this.maxFragments / 2) : this.maxFragments;
+      const step = this.low ? 2 : 1;
+      for (let i = 0; i < ev.fragments.length; i += step) {
+        const fr = ev.fragments[i];
+        const fdef = this.world.materials.get(fr.material);
+        this.fragments.spawn(fr, this.fragments.materialFor(fr.material, fdef === def || !fdef ? color : fallbackColor(fr.material, fdef), false), ev.object, maxAlive);
+      }
+      this.particles.burst("dust", ev.opening.center, [0, 1, 0], 14, 1.2, { color });
+      this.sound(impactKey(def), ev.opening.center, 0.8);
+    }
     onFracture(ev) {
       const b = this.bounds.get(ev.object);
       const pv = b?.parts.get(ev.part);
@@ -3958,6 +4125,7 @@ void main() {
       for (const home of homes) {
         this.fragments.removeHome(home);
         this.ground.removeHome(home);
+        this.cages.removeObject(home);
       }
     }
     restoreHome(home) {
@@ -3994,6 +4162,7 @@ void main() {
       }
       this.fragments.clear();
       this.ground.clear();
+      this.cages.clear();
       this.particles.clear();
       if (this.light) {
         this.light.intensity = 0;
@@ -4004,6 +4173,9 @@ void main() {
     stats() {
       return { fragments: this.fragments.count, particles: this.particles.live, pieces: this.pieceSys.list.length, decals: this.visuals.decalCount + this.ground.count };
     }
+    rebarCount() {
+      return this.cages.count;
+    }
     dispose() {
       if (this.disposed) return;
       this.unsubscribe();
@@ -4011,6 +4183,7 @@ void main() {
       for (const id of [...this.bounds.keys()]) this.unbind(id);
       this.fragments.dispose();
       this.ground.dispose();
+      this.cages.dispose();
       this.particles.dispose();
       this.visuals.dispose();
       this.light?.dispose?.();