@adatechnology/game-destruction-three 0.3.2 → 0.4.0

package/dist/index.js

@@ -57,6 +57,8 @@ var FragmentSystem = class {
     __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();
@@ -103,6 +105,25 @@ var FragmentSystem = class {
     }
     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;
@@ -136,6 +157,8 @@ var FragmentSystem = class {
         alive--;
       }
     }
+    this.addMarks(mesh, f);
+    return mesh;
   }
   /** Add velocity to every fragment within `radius` of a point (blasts). */
   blast(point, radius, speed) {
@@ -259,6 +282,8 @@ var FragmentSystem = class {
   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();
@@ -1010,6 +1035,78 @@ var PieceSystem = class {
   }
 };
 
+// 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();
+  }
+};
+
 // src/spec.ts
 import { guessMaterial, inferJoints } from "@adatechnology/game-destruction";
 function partHintOf(value) {
@@ -1214,6 +1311,7 @@ var DecalKit = class {
     __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));
@@ -1229,6 +1327,15 @@ var DecalKit = class {
       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) {
@@ -1241,6 +1348,8 @@ var DecalKit = class {
     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();
@@ -1532,6 +1641,16 @@ var Visuals = class {
     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 } = 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(quat);
+    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 } = this.decalPose(mv.mesh, worldPoint, worldNormal, 2e-3);
@@ -2057,6 +2176,7 @@ var Renderer = class {
     __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", []);
@@ -2108,6 +2228,7 @@ var Renderer = class {
       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,
@@ -2409,6 +2530,15 @@ var Renderer = class {
           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) {
@@ -2574,6 +2704,43 @@ var Renderer = class {
     }
     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);
@@ -2884,6 +3051,7 @@ var Renderer = class {
     for (const home of homes) {
       this.fragments.removeHome(home);
       this.ground.removeHome(home);
+      this.cages.removeObject(home);
     }
   }
   restoreHome(home) {
@@ -2920,6 +3088,7 @@ var Renderer = class {
     }
     this.fragments.clear();
     this.ground.clear();
+    this.cages.clear();
     this.particles.clear();
     if (this.light) {
       this.light.intensity = 0;
@@ -2930,6 +3099,9 @@ var Renderer = class {
   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();
@@ -2937,6 +3109,7 @@ var Renderer = class {
     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?.();