@adatechnology/game-destruction-three 0.1.0 → 0.1.1

package/dist/index.js

@@ -690,6 +690,8 @@ var MU = 0.7;
 var SLEEP_AFTER = 0.5;
 var HARD_LANDING = 3;
 var SLOP = 2e-3;
+var NARROW = 0.3;
+var TOPPLE = 3;
 var PieceSystem = class {
   constructor(THREE, o) {
     __publicField(this, "THREE", THREE);
@@ -821,6 +823,7 @@ var PieceSystem = class {
     let landPoint = [pos[0], pos[1], pos[2]];
     let contactedLast = false;
     let touched = false;
+    let unstable = false;
     for (let s = 0; s < steps; s++) {
       v[1] -= this.o.gravity * h;
       pos[0] += v[0] * h;
@@ -909,6 +912,25 @@ var PieceSystem = class {
           }
         }
       }
+      let x0 = Infinity, x1 = -Infinity, z0 = Infinity, z1 = -Infinity, low = 0;
+      for (const r of rs) {
+        x0 = Math.min(x0, r[0]);
+        x1 = Math.max(x1, r[0]);
+        z0 = Math.min(z0, r[2]);
+        z1 = Math.max(z1, r[2]);
+        low = Math.min(low, r[1]);
+      }
+      const height = -low;
+      const wx = x1 - x0;
+      const wz = z1 - z0;
+      unstable = Math.min(wx, wz) < NARROW * height || x0 > 0 || x1 < 0 || z0 > 0 || z1 < 0;
+      if (unstable) {
+        const dirX = x0 + x1 > 0 ? -1 : 1;
+        const dirZ = z0 + z1 > 0 ? -1 : 1;
+        const k = TOPPLE * Math.min(height, 1) * h;
+        if (wx <= wz) w[2] -= dirX * k;
+        else w[0] += dirZ * k;
+      }
       const rd = Math.exp((rs.length >= 3 ? -3 : -1.5) * h);
       w[0] *= rd;
       w[1] *= rd;
@@ -926,7 +948,7 @@ var PieceSystem = class {
       b.lastHit = this.time;
       this.o.onHardLanding(b, landPoint, landing);
     }
-    const still = touched && Math.hypot(v[0], v[1], v[2]) < 0.12 && Math.hypot(w[0], w[1], w[2]) < 0.45;
+    const still = touched && !unstable && Math.hypot(v[0], v[1], v[2]) < 0.12 && Math.hypot(w[0], w[1], w[2]) < 0.45;
     if (still) {
       b.still += dt;
       if (b.still >= SLEEP_AFTER) {
@@ -986,6 +1008,166 @@ var PieceSystem = class {
   }
 };
 
+// src/spec.ts
+import { guessMaterial, inferJoints } from "@adatechnology/game-destruction";
+function partHintOf(value) {
+  if (typeof value === "string") return value ? { id: value } : null;
+  if (!value || typeof value !== "object") return null;
+  const v = value;
+  if (typeof v.id !== "string" || !v.id) return null;
+  const str = (x) => typeof x === "string" && x ? x : void 0;
+  return { id: v.id, material: str(v.material), parent: str(v.parent), kind: str(v.kind) };
+}
+var METAL = /steel|iron|metal|alumin|copper|brass|bronze|tin|titan|chrome|zinc|lead/i;
+function sanitizeId(name) {
+  let id = name.trim().replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  if (id && /^[0-9]/.test(id)) id = `p_${id}`;
+  return id;
+}
+function isMesh(o) {
+  return o.isMesh === true;
+}
+function sizeOf(box) {
+  return [box.max.x - box.min.x, box.max.y - box.min.y, box.max.z - box.min.z];
+}
+function specFromObject3D(THREE, root, options = {}) {
+  const fallback = options.fallback ?? "plastic";
+  const minSize = options.minSize ?? 0.015;
+  root.updateMatrixWorld(true);
+  const inv = root.matrixWorld.clone().invert();
+  const entries = [];
+  const byKey = /* @__PURE__ */ new Map();
+  const visit = (o) => {
+    if (!o.visible || o.userData?.destructionIgnore) return;
+    if (isMesh(o) && o.geometry) {
+      const geom = o.geometry;
+      if (!geom.boundingBox) geom.computeBoundingBox();
+      if (geom.boundingBox && !geom.boundingBox.isEmpty()) {
+        const box = geom.boundingBox.clone().applyMatrix4(new THREE.Matrix4().multiplyMatrices(inv, o.matrixWorld));
+        const mats = Array.isArray(o.material) ? o.material : [o.material];
+        const matName = mats[0]?.name ?? "";
+        const ud = o.userData ?? {};
+        const hint = partHintOf(ud.destructionPart);
+        const material = options.materialOf?.(o) ?? (typeof ud.destructionMaterial === "string" ? ud.destructionMaterial : void 0) ?? hint?.material ?? guessMaterial(`${o.name} ${matName} ${typeof ud.material === "string" ? ud.material : ""}`) ?? fallback;
+        const explicit = hint?.id ?? null;
+        const hollow = ud.hollow === true || /hollow/i.test(o.name);
+        const fill = options.fillOf?.(o, material);
+        const tags = Array.isArray(ud.destructionTags) ? ud.destructionTags : void 0;
+        const existing = explicit ? byKey.get(explicit) : void 0;
+        if (existing) {
+          const before = sizeOf(existing.box);
+          const bv = before[0] * before[1] * before[2];
+          const ns = sizeOf(box);
+          existing.box.union(box);
+          existing.meshes.push(o);
+          if (ns[0] * ns[1] * ns[2] > bv) existing.material = material;
+          existing.hollow = existing.hollow || hollow;
+          if (fill !== void 0) existing.fill = fill;
+        } else {
+          const e = { key: explicit ?? `m${entries.length}`, meshes: [o], box, material, explicitId: explicit, fill, hollow, tags, fixedId: !!explicit, name: o.name, parent: hint?.parent, jointKind: hint?.kind };
+          entries.push(e);
+          if (explicit) byKey.set(explicit, e);
+        }
+      }
+    }
+    for (const c of o.children) visit(c);
+  };
+  visit(root);
+  const eps = 5e-3;
+  const overlapVolume = (a, b) => {
+    const x = Math.min(a.max.x, b.max.x) - Math.max(a.min.x, b.min.x) + eps;
+    const y = Math.min(a.max.y, b.max.y) - Math.max(a.min.y, b.min.y) + eps;
+    const z = Math.min(a.max.z, b.max.z) - Math.max(a.min.z, b.min.z) + eps;
+    return x > 0 && y > 0 && z > 0 ? x * y * z : 0;
+  };
+  const largest = (e) => Math.max(...sizeOf(e.box));
+  const kept = [];
+  const tiny = [];
+  for (const e of entries) (!e.fixedId && largest(e) < minSize ? tiny : kept).push(e);
+  for (const t of tiny) {
+    let best = null;
+    let bestV = 0;
+    for (const k of kept) {
+      const v = overlapVolume(t.box, k.box);
+      if (v > bestV) {
+        bestV = v;
+        best = k;
+      }
+    }
+    if (!best) {
+      let bd = 0.05;
+      for (const k of kept) {
+        const d = k.box.distanceToPoint(t.box.getCenter(new THREE.Vector3()));
+        if (d < bd) {
+          bd = d;
+          best = k;
+        }
+      }
+    }
+    if (best) {
+      best.meshes.push(...t.meshes);
+    } else {
+      kept.push(t);
+    }
+  }
+  const used = /* @__PURE__ */ new Set();
+  const parts = [];
+  const meshesOf = {};
+  let counter = 0;
+  for (const e of kept) {
+    counter++;
+    let base = (e.explicitId ? sanitizeId(e.explicitId) : "") || sanitizeId(e.name) || `part_${counter}`;
+    let id = base;
+    for (let n = 2; used.has(id); n++) id = `${base}_${n}`;
+    used.add(id);
+    base = id;
+    const size = sizeOf(e.box);
+    const center = e.box.getCenter(new THREE.Vector3());
+    const part = {
+      id,
+      material: e.material,
+      shape: { kind: "box", size: [Math.max(size[0], 2e-3), Math.max(size[1], 2e-3), Math.max(size[2], 2e-3)] },
+      position: [center.x, center.y, center.z]
+    };
+    const minSide = Math.min(...size);
+    if (e.fill !== void 0) part.fill = e.fill;
+    else if (e.hollow) part.fill = 0.05;
+    if (minSide < 0.01 && METAL.test(e.material)) {
+      part.fill = e.fill ?? 1;
+      part.thickness = Math.max(minSide, 5e-4);
+    }
+    if (e.tags) part.tags = [...e.tags];
+    const ao = options.anchorBelow ?? -1;
+    if (ao >= 0 && e.box.min.y <= ao) part.anchored = true;
+    parts.push(part);
+    meshesOf[id] = e.meshes;
+  }
+  const spec = { parts };
+  if (options.name !== void 0) spec.name = options.name;
+  else if (root.name) spec.name = root.name;
+  if (options.tags) spec.tags = [...options.tags];
+  spec.joints = options.joints === false ? [] : inferJoints(parts);
+  if (options.joints !== false) {
+    const finalId = /* @__PURE__ */ new Map();
+    kept.forEach((e, i) => finalId.set(e, parts[i].id));
+    const idOf = /* @__PURE__ */ new Map();
+    for (const e of kept) if (e.explicitId) idOf.set(e.explicitId, finalId.get(e));
+    const joints = spec.joints;
+    for (const e of kept) {
+      if (!e.parent) continue;
+      const id = finalId.get(e);
+      const parent = idOf.get(e.parent) ?? (used.has(sanitizeId(e.parent)) ? sanitizeId(e.parent) : null);
+      if (!parent || parent === id) continue;
+      const at = joints.findIndex((j) => j.a === parent && j.b === id || j.a === id && j.b === parent);
+      const kind = e.jointKind ?? (at >= 0 ? joints[at].kind : "resting");
+      const joint = { id: `${parent}~${id}`, a: parent, b: id, kind };
+      if (at >= 0) joints[at] = joint;
+      else joints.push(joint);
+    }
+  }
+  return { spec, parts: meshesOf };
+}
+
 // src/heat.ts
 var STOPS = [
   [450, 0],
@@ -1075,6 +1257,7 @@ var Visuals = class {
     __publicField(this, "box");
     /** Total live decals across meshes (kept in sync by add/remove). */
     __publicField(this, "decalCount", 0);
+    __publicField(this, "tints", /* @__PURE__ */ new WeakMap());
     this.kit = new DecalKit(THREE);
     this.a = tmpV(THREE);
     this.b = tmpV(THREE);
@@ -1105,10 +1288,33 @@ var Visuals = class {
   vertexCount(mv) {
     return mv.mesh.geometry.getAttribute(POS_ATTR)?.count ?? 0;
   }
-  /** Colour of the original material (before any char), `0xRRGGBB`, or -1. */
+  /**
+   * Average vertex colour of a mesh whose material uses `vertexColors` (computed once per mesh, from its original geometry), else null. Fragments
+   * and debris of such a mesh multiply it by `material.color`; without it they come out white.
+   */
+  vertexTint(mv) {
+    if (this.tints.has(mv.mesh)) return this.tints.get(mv.mesh) ?? null;
+    let tint = null;
+    const used = materialsOf(mv.origMaterial).some((m) => m.vertexColors === true);
+    const attr = used ? mv.origGeometry.getAttribute("color") : void 0;
+    if (attr && attr.count > 0 && attr.itemSize >= 3) {
+      let r = 0, g = 0, b = 0;
+      for (let i = 0; i < attr.count; i++) {
+        r += attr.getX(i);
+        g += attr.getY(i);
+        b += attr.getZ(i);
+      }
+      tint = new this.THREE.Color(r / attr.count, g / attr.count, b / attr.count);
+    }
+    this.tints.set(mv.mesh, tint);
+    return tint;
+  }
+  /** Colour of the original material (before any char) times the vertex tint, `0xRRGGBB`, or -1. */
   baseColorHex(mv) {
     const c = mv.baseColors?.[0] ?? colorOf(materialsOf(mv.origMaterial)[0]);
-    return c ? c.getHex() : -1;
+    if (!c) return -1;
+    const tint = this.vertexTint(mv);
+    return tint ? c.clone().multiply(tint).getHex() : c.getHex();
   }
   /** Is the original material transparent? */
   isTransparent(mv) {
@@ -1579,8 +1785,8 @@ var Renderer = class {
     } else {
       const leftovers = [];
       for (const m of meshesIn(root)) {
-        const ud = m.userData?.destructionPart;
-        if (typeof ud === "string" && partIds.has(ud)) add(ud, m);
+        const ud = partHintOf(m.userData?.destructionPart)?.id;
+        if (ud !== void 0 && partIds.has(ud)) add(ud, m);
         else if (partIds.has(m.name)) add(m.name, m);
         else leftovers.push(m);
       }
@@ -1890,7 +2096,10 @@ var Renderer = class {
     if (!mv) return null;
     const mat = materialsOf2(mv.mesh.material)[0];
     const c = mat?.color;
-    if (c && c.isColor) return c.getHex();
+    if (c && c.isColor) {
+      const tint = this.visuals.vertexTint(mv);
+      return tint ? c.clone().multiply(tint).getHex() : c.getHex();
+    }
     return def ? fallbackColor(def.id, def) : null;
   }
   debrisOptions(kind, objectId, partId) {
@@ -2334,139 +2543,6 @@ var Renderer = class {
     this.disposed = true;
   }
 };
-
-// src/spec.ts
-import { guessMaterial, inferJoints } from "@adatechnology/game-destruction";
-var METAL = /steel|iron|metal|alumin|copper|brass|bronze|tin|titan|chrome|zinc|lead/i;
-function sanitizeId(name) {
-  let id = name.trim().replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
-  if (id && /^[0-9]/.test(id)) id = `p_${id}`;
-  return id;
-}
-function isMesh(o) {
-  return o.isMesh === true;
-}
-function sizeOf(box) {
-  return [box.max.x - box.min.x, box.max.y - box.min.y, box.max.z - box.min.z];
-}
-function specFromObject3D(THREE, root, options = {}) {
-  const fallback = options.fallback ?? "plastic";
-  const minSize = options.minSize ?? 0.015;
-  root.updateMatrixWorld(true);
-  const inv = root.matrixWorld.clone().invert();
-  const entries = [];
-  const byKey = /* @__PURE__ */ new Map();
-  const visit = (o) => {
-    if (!o.visible || o.userData?.destructionIgnore) return;
-    if (isMesh(o) && o.geometry) {
-      const geom = o.geometry;
-      if (!geom.boundingBox) geom.computeBoundingBox();
-      if (geom.boundingBox && !geom.boundingBox.isEmpty()) {
-        const box = geom.boundingBox.clone().applyMatrix4(new THREE.Matrix4().multiplyMatrices(inv, o.matrixWorld));
-        const mats = Array.isArray(o.material) ? o.material : [o.material];
-        const matName = mats[0]?.name ?? "";
-        const ud = o.userData ?? {};
-        const material = options.materialOf?.(o) ?? (typeof ud.destructionMaterial === "string" ? ud.destructionMaterial : void 0) ?? guessMaterial(`${o.name} ${matName} ${typeof ud.material === "string" ? ud.material : ""}`) ?? fallback;
-        const explicit = typeof ud.destructionPart === "string" && ud.destructionPart ? ud.destructionPart : null;
-        const hollow = ud.hollow === true || /hollow/i.test(o.name);
-        const fill = options.fillOf?.(o, material);
-        const tags = Array.isArray(ud.destructionTags) ? ud.destructionTags : void 0;
-        const existing = explicit ? byKey.get(explicit) : void 0;
-        if (existing) {
-          const before = sizeOf(existing.box);
-          const bv = before[0] * before[1] * before[2];
-          const ns = sizeOf(box);
-          existing.box.union(box);
-          existing.meshes.push(o);
-          if (ns[0] * ns[1] * ns[2] > bv) existing.material = material;
-          existing.hollow = existing.hollow || hollow;
-          if (fill !== void 0) existing.fill = fill;
-        } else {
-          const e = { key: explicit ?? `m${entries.length}`, meshes: [o], box, material, explicitId: explicit, fill, hollow, tags, fixedId: !!explicit, name: o.name };
-          entries.push(e);
-          if (explicit) byKey.set(explicit, e);
-        }
-      }
-    }
-    for (const c of o.children) visit(c);
-  };
-  visit(root);
-  const eps = 5e-3;
-  const overlapVolume = (a, b) => {
-    const x = Math.min(a.max.x, b.max.x) - Math.max(a.min.x, b.min.x) + eps;
-    const y = Math.min(a.max.y, b.max.y) - Math.max(a.min.y, b.min.y) + eps;
-    const z = Math.min(a.max.z, b.max.z) - Math.max(a.min.z, b.min.z) + eps;
-    return x > 0 && y > 0 && z > 0 ? x * y * z : 0;
-  };
-  const largest = (e) => Math.max(...sizeOf(e.box));
-  const kept = [];
-  const tiny = [];
-  for (const e of entries) (!e.fixedId && largest(e) < minSize ? tiny : kept).push(e);
-  for (const t of tiny) {
-    let best = null;
-    let bestV = 0;
-    for (const k of kept) {
-      const v = overlapVolume(t.box, k.box);
-      if (v > bestV) {
-        bestV = v;
-        best = k;
-      }
-    }
-    if (!best) {
-      let bd = 0.05;
-      for (const k of kept) {
-        const d = k.box.distanceToPoint(t.box.getCenter(new THREE.Vector3()));
-        if (d < bd) {
-          bd = d;
-          best = k;
-        }
-      }
-    }
-    if (best) {
-      best.meshes.push(...t.meshes);
-    } else {
-      kept.push(t);
-    }
-  }
-  const used = /* @__PURE__ */ new Set();
-  const parts = [];
-  const meshesOf = {};
-  let counter = 0;
-  for (const e of kept) {
-    counter++;
-    let base = (e.explicitId ? sanitizeId(e.explicitId) : "") || sanitizeId(e.name) || `part_${counter}`;
-    let id = base;
-    for (let n = 2; used.has(id); n++) id = `${base}_${n}`;
-    used.add(id);
-    base = id;
-    const size = sizeOf(e.box);
-    const center = e.box.getCenter(new THREE.Vector3());
-    const part = {
-      id,
-      material: e.material,
-      shape: { kind: "box", size: [Math.max(size[0], 2e-3), Math.max(size[1], 2e-3), Math.max(size[2], 2e-3)] },
-      position: [center.x, center.y, center.z]
-    };
-    const minSide = Math.min(...size);
-    if (e.fill !== void 0) part.fill = e.fill;
-    else if (e.hollow) part.fill = 0.05;
-    if (minSide < 0.01 && METAL.test(e.material)) {
-      part.fill = e.fill ?? 1;
-      part.thickness = Math.max(minSide, 5e-4);
-    }
-    if (e.tags) part.tags = [...e.tags];
-    const ao = options.anchorBelow ?? -1;
-    if (ao >= 0 && e.box.min.y <= ao) part.anchored = true;
-    parts.push(part);
-    meshesOf[id] = e.meshes;
-  }
-  const spec = { parts };
-  if (options.name !== void 0) spec.name = options.name;
-  else if (root.name) spec.name = root.name;
-  if (options.tags) spec.tags = [...options.tags];
-  spec.joints = options.joints === false ? [] : inferJoints(parts);
-  return { spec, parts: meshesOf };
-}
 export {
   createDestructionRenderer,
   heatColor,