@adatechnology/game-vehicles 0.3.0 → 0.4.0

package/dist/index.js

@@ -938,46 +938,79 @@ function installGeometry(kit) {
     }
     const p = geo.attributes.position;
     const n = p.count;
-    const FN = [];
-    const map = {};
-    const A = new V3();
-    const B = new V3();
-    const C = new V3();
-    const e1 = new V3();
-    const e2 = new V3();
+    const faces = n / 3;
+    const FN = new Float64Array(faces * 3);
+    const map = /* @__PURE__ */ new Map();
+    const RANGE = 65536;
     function key(i) {
-      return Math.round(p.getX(i) * 2e3) + "," + Math.round(p.getY(i) * 2e3) + "," + Math.round(p.getZ(i) * 2e3);
+      const x = Math.round(p.getX(i) * 2e3);
+      const y = Math.round(p.getY(i) * 2e3);
+      const z = Math.round(p.getZ(i) * 2e3);
+      if (Math.abs(x) < RANGE && Math.abs(y) < RANGE && Math.abs(z) < RANGE) return ((x + RANGE) * 131072 + (y + RANGE)) * 131072 + (z + RANGE);
+      return x + "," + y + "," + z;
     }
     const keys = new Array(n);
-    for (let f = 0; f < n / 3; f++) {
-      A.fromBufferAttribute(p, 3 * f);
-      B.fromBufferAttribute(p, 3 * f + 1);
-      C.fromBufferAttribute(p, 3 * f + 2);
-      const nn = new V3().crossVectors(e1.subVectors(C, B), e2.subVectors(A, B));
-      if (nn.lengthSq() > 1e-20) nn.normalize();
-      FN.push(nn);
+    for (let f = 0; f < faces; f++) {
+      const ax = p.getX(3 * f);
+      const ay = p.getY(3 * f);
+      const az = p.getZ(3 * f);
+      const bx = p.getX(3 * f + 1);
+      const by = p.getY(3 * f + 1);
+      const bz = p.getZ(3 * f + 1);
+      const cx = p.getX(3 * f + 2);
+      const cy = p.getY(3 * f + 2);
+      const cz = p.getZ(3 * f + 2);
+      const e1x = cx - bx;
+      const e1y = cy - by;
+      const e1z = cz - bz;
+      const e2x = ax - bx;
+      const e2y = ay - by;
+      const e2z = az - bz;
+      let nx = e1y * e2z - e1z * e2y;
+      let ny = e1z * e2x - e1x * e2z;
+      let nz = e1x * e2y - e1y * e2x;
+      if (nx * nx + ny * ny + nz * nz > 1e-20) {
+        const inv = 1 / (Math.sqrt(nx * nx + ny * ny + nz * nz) || 1);
+        nx *= inv;
+        ny *= inv;
+        nz *= inv;
+      }
+      FN[3 * f] = nx;
+      FN[3 * f + 1] = ny;
+      FN[3 * f + 2] = nz;
       for (let k = 0; k < 3; k++) {
         const kk = key(3 * f + k);
         keys[3 * f + k] = kk;
-        (map[kk] || (map[kk] = [])).push(f);
+        const list = map.get(kk);
+        if (list) list.push(f);
+        else map.set(kk, [f]);
       }
     }
     const cs = Math.cos(deg * PI / 180);
     const out = new Float32Array(n * 3);
-    const s = new V3();
     for (let i = 0; i < n; i++) {
-      const fi = i / 3 | 0;
-      const list = map[keys[i]];
-      s.set(0, 0, 0);
+      const fi = (i / 3 | 0) * 3;
+      const list = map.get(keys[i]);
+      let sx = 0;
+      let sy = 0;
+      let sz = 0;
       for (let j = 0; j < list.length; j++) {
-        const g = FN[list[j]];
-        if (g.dot(FN[fi]) >= cs) s.add(g);
+        const g = list[j] * 3;
+        if (FN[g] * FN[fi] + FN[g + 1] * FN[fi + 1] + FN[g + 2] * FN[fi + 2] >= cs) {
+          sx += FN[g];
+          sy += FN[g + 1];
+          sz += FN[g + 2];
+        }
       }
-      if (s.lengthSq() < 1e-20) s.copy(FN[fi]);
-      s.normalize();
-      out[3 * i] = s.x;
-      out[3 * i + 1] = s.y;
-      out[3 * i + 2] = s.z;
+      if (sx * sx + sy * sy + sz * sz < 1e-20) {
+        sx = FN[fi];
+        sy = FN[fi + 1];
+        sz = FN[fi + 2];
+      }
+      const inv = 1 / (Math.sqrt(sx * sx + sy * sy + sz * sz) || 1);
+      out[3 * i] = sx * inv;
+      out[3 * i + 1] = sy * inv;
+      out[3 * i + 2] = sz * inv;
     }
     geo.setAttribute("normal", new THREE.BufferAttribute(out, 3));
     geo.userData.crease = true;
@@ -6635,6 +6668,153 @@ function installZoneDecals(kit) {
     return hole;
   }
   const _zr = new THREE.Raycaster();
+  const PROXY_MIN_TRIANGLES = 500;
+  const STROKE_REACH = 0.6;
+  const _pv = new V3();
+  const _pm = new THREE.Matrix4();
+  function decalRegion(c, z) {
+    const B = z.box;
+    const lo = [0, 1, 2].map(function(k) {
+      return I.boxLo(B, k) - STROKE_REACH;
+    });
+    const hi = [0, 1, 2].map(function(k) {
+      return I.boxHi(B, k) + STROKE_REACH;
+    });
+    const a = axisOf(z.dir);
+    const dn = z.dir.clone().normalize();
+    const sg = z.dir.getComponent(a) > 0 ? 1 : -1;
+    const outer = sg > 0 ? I.boxLo(B, a) - 0.6 : I.boxHi(B, a) + 0.6;
+    const far = 0.6 + (I.boxHi(B, a) - I.boxLo(B, a)) + 0.05;
+    for (let i = 0; i < 8; i++) {
+      const p = new V3();
+      p.setComponent(a, outer);
+      [0, 1, 2].filter(function(k) {
+        return k !== a;
+      }).forEach(function(k, j) {
+        p.setComponent(k, i >> j & 1 ? I.boxHi(B, k) : I.boxLo(B, k));
+      });
+      for (let e = 0; e < 2; e++) {
+        const q = e ? p.clone().addScaledVector(dn, far) : p;
+        for (let k = 0; k < 3; k++) {
+          lo[k] = Math.min(lo[k], q.getComponent(k) - 0.05);
+          hi[k] = Math.max(hi[k], q.getComponent(k) + 0.05);
+        }
+      }
+    }
+    return { lo, hi };
+  }
+  function regionCands(c, z, cands) {
+    if (!cands.some(heavy)) return cands;
+    const R = decalRegion(c, z);
+    const Mw = c.vehicle.matrixWorld;
+    return cands.map(function(o) {
+      if (!heavy(o)) return o;
+      if (!o.geometry.boundingSphere) o.geometry.computeBoundingSphere();
+      if (!o.geometry.boundingBox) o.geometry.computeBoundingBox();
+      return proxyIn(o, Mw, R);
+    });
+  }
+  function heavy(o) {
+    const g = o.geometry;
+    const pos = g && g.attributes && g.attributes.position;
+    return o.raycast === THREE.Mesh.prototype.raycast && !o.isSkinnedMesh && !Array.isArray(o.material) && pos && !pos.isInterleavedBufferAttribute && pos.itemSize === 3 && !g.groups.length && !(g.morphAttributes && g.morphAttributes.position) && (g.index ? g.index.count : pos.count) / 3 >= PROXY_MIN_TRIANGLES;
+  }
+  function proxyIn(o, Mw, R) {
+    _pm.copy(o.matrixWorld).invert().multiply(Mw);
+    const lo = [Infinity, Infinity, Infinity];
+    const hi = [-Infinity, -Infinity, -Infinity];
+    for (let i = 0; i < 8; i++) {
+      _pv.set(i & 1 ? R.hi[0] : R.lo[0], i & 2 ? R.hi[1] : R.lo[1], i & 4 ? R.hi[2] : R.lo[2]).applyMatrix4(_pm);
+      for (let k = 0; k < 3; k++) {
+        lo[k] = Math.min(lo[k], _pv.getComponent(k));
+        hi[k] = Math.max(hi[k], _pv.getComponent(k));
+      }
+    }
+    const g = o.geometry;
+    const P = g.attributes.position.array;
+    const ix = g.index ? g.index.array : null;
+    const n = ix ? ix.length : P.length / 3;
+    const keep = new Uint32Array(n - n % 3);
+    let nk = 0;
+    for (let t = 0; t + 2 < n; t += 3) {
+      const a = (ix ? ix[t] : t) * 3;
+      const b = (ix ? ix[t + 1] : t + 1) * 3;
+      const d = (ix ? ix[t + 2] : t + 2) * 3;
+      let out = false;
+      for (let k = 0; k < 3 && !out; k++) {
+        const u = P[a + k];
+        const v = P[b + k];
+        const w = P[d + k];
+        out = Math.max(u, v, w) < lo[k] || Math.min(u, v, w) > hi[k];
+      }
+      if (!out) {
+        keep[nk++] = ix ? ix[t] : t;
+        keep[nk++] = ix ? ix[t + 1] : t + 1;
+        keep[nk++] = ix ? ix[t + 2] : t + 2;
+      }
+    }
+    if (!nk) return null;
+    const kept = keep.slice(0, nk);
+    const box = new Float32Array(kept.length / 3 * 6);
+    for (let t = 0, j = 0; t < kept.length; t += 3, j += 6) {
+      const a = kept[t] * 3;
+      const b = kept[t + 1] * 3;
+      const d = kept[t + 2] * 3;
+      for (let k = 0; k < 3; k++) {
+        box[j + k] = Math.min(P[a + k], P[b + k], P[d + k]);
+        box[j + 3 + k] = Math.max(P[a + k], P[b + k], P[d + k]);
+      }
+    }
+    const pg = new THREE.BufferGeometry();
+    pg.setAttribute("position", g.attributes.position);
+    pg.setIndex(new THREE.BufferAttribute(new Uint32Array(kept.length), 1));
+    pg.boundingSphere = g.boundingSphere;
+    pg.boundingBox = g.boundingBox;
+    const proxy = new THREE.Mesh(pg, o.material);
+    proxy.layers.mask = o.layers.mask;
+    proxy.proxyOf = o;
+    proxy.kept = kept;
+    proxy.keptBox = box;
+    return proxy;
+  }
+  function narrowTo(rc, proxy) {
+    const o = proxy.proxyOf;
+    const ray = rc.ray;
+    _pm.copy(o.matrixWorld).invert();
+    _pv.copy(ray.origin).applyMatrix4(_pm);
+    const x0 = _pv.x;
+    const y0 = _pv.y;
+    const z0 = _pv.z;
+    _pv.copy(ray.direction).multiplyScalar(rc.far).add(ray.origin).applyMatrix4(_pm);
+    const lo0 = Math.min(x0, _pv.x) - 1e-4;
+    const lo1 = Math.min(y0, _pv.y) - 1e-4;
+    const lo2 = Math.min(z0, _pv.z) - 1e-4;
+    const hi0 = Math.max(x0, _pv.x) + 1e-4;
+    const hi1 = Math.max(y0, _pv.y) + 1e-4;
+    const hi2 = Math.max(z0, _pv.z) + 1e-4;
+    const K = proxy.kept;
+    const X = proxy.keptBox;
+    const dst = proxy.geometry.index.array;
+    let m = 0;
+    for (let t = 0, j = 0; t < K.length; t += 3, j += 6) {
+      if (X[j + 3] < lo0 || X[j] > hi0 || X[j + 4] < lo1 || X[j + 1] > hi1 || X[j + 5] < lo2 || X[j + 2] > hi2) continue;
+      dst[m++] = K[t];
+      dst[m++] = K[t + 1];
+      dst[m++] = K[t + 2];
+    }
+    proxy.geometry.setDrawRange(0, m);
+  }
+  function castAt(rc, cands) {
+    for (let i = 0; i < cands.length; i++) {
+      const q = cands[i];
+      if (!q.proxyOf) continue;
+      q.matrixWorld.copy(q.proxyOf.matrixWorld);
+      narrowTo(rc, q);
+    }
+    const hits = rc.intersectObjects(cands, false);
+    for (let i = 0; i < hits.length; i++) if (hits[i].object.proxyOf) hits[i].object = hits[i].object.proxyOf;
+    return hits;
+  }
   function zoneCands(c, z, inv, glassToo) {
     const out = [];
     c.vehicle.traverse(function(o) {
@@ -6687,7 +6867,7 @@ function installZoneDecals(kit) {
       });
       _zr.set(org.clone().applyMatrix4(Mw), d.clone().transformDirection(Mw));
       _zr.far = 0.6 + (I.boxHi(B, a) - I.boxLo(B, a)) + 0.05;
-      const hits = _zr.intersectObjects(cands, false);
+      const hits = castAt(_zr, cands);
       for (let i = 0; i < hits.length; i++) {
         const h = hits[i];
         if (!h.face) continue;
@@ -6715,7 +6895,7 @@ function installZoneDecals(kit) {
       const q = s.p.clone().addScaledVector(t, len * 0.5 * k / M);
       _rt.set(q.clone().addScaledVector(n, 0.08).applyMatrix4(Mw), n.clone().negate().transformDirection(Mw));
       _rt.far = 0.2;
-      const h = _rt.intersectObjects(cands, false).find(function(x) {
+      const h = castAt(_rt, cands).find(function(x) {
         return x.face;
       });
       if (!h) return null;
@@ -6786,6 +6966,7 @@ function installZoneDecals(kit) {
     const R = c.rand;
     const need = (spec.fine || 0) + (spec.deep || 0) + (spec.chip || 0) + (spec.rust || 0) + (spec.tear || 0) + (spec.ding || 0) + (spec.soot || 0) + (spec.crater || 0);
     if (!need) return [];
+    cands = regionCands(c, z, cands).filter(Boolean);
     const S = zoneSurf(c, z, need + 2, R, cands);
     let k = 0;
     const ang0 = R() * PI;
@@ -6866,8 +7047,25 @@ function installZoneDent(kit) {
   }
   function subdivIn(geo, rel, B, maxLen) {
     const a = geo.attributes.position.array;
-    const out = [];
-    const v = new V3();
+    let out = new Float32Array(a.length + 4096);
+    let used = 0;
+    const push = function(a0, a1, a2, b0, b1, b2, c0, c1, c2) {
+      if (used + 9 > out.length) {
+        const bigger = new Float32Array(out.length * 2);
+        bigger.set(out);
+        out = bigger;
+      }
+      out[used] = a0;
+      out[used + 1] = a1;
+      out[used + 2] = a2;
+      out[used + 3] = b0;
+      out[used + 4] = b1;
+      out[used + 5] = b2;
+      out[used + 6] = c0;
+      out[used + 7] = c1;
+      out[used + 8] = c2;
+      used += 9;
+    };
     const e = 0.15;
     function d(p, q) {
       return Math.hypot(p[0] - q[0], p[1] - q[1], p[2] - q[2]);
@@ -6881,7 +7079,7 @@ function installZoneDent(kit) {
       const ca = d(C, A);
       const mx = Math.max(ab, bc, ca);
       if (mx <= maxLen || depth > 9) {
-        out.push(A[0], A[1], A[2], Bv[0], Bv[1], Bv[2], C[0], C[1], C[2]);
+        push(A[0], A[1], A[2], Bv[0], Bv[1], Bv[2], C[0], C[1], C[2]);
         return;
       }
       if (mx === ab) {
@@ -6898,31 +7096,26 @@ function installZoneDent(kit) {
         tri(F2, Bv, C, depth + 1);
       }
     }
+    const M = rel.elements;
+    const at = function(x, y, z, k) {
+      const w = 1 / (M[3] * x + M[7] * y + M[11] * z + M[15]);
+      return k === 0 ? (M[0] * x + M[4] * y + M[8] * z + M[12]) * w : k === 1 ? (M[1] * x + M[5] * y + M[9] * z + M[13]) * w : (M[2] * x + M[6] * y + M[10] * z + M[14]) * w;
+    };
+    const lo = [B.x0 - e, B.y0 - e, B.z0 - e];
+    const hi = [B.x1 + e, B.y1 + e, B.z1 + e];
     for (let i = 0; i < a.length; i += 9) {
-      const A = [a[i], a[i + 1], a[i + 2]];
-      const Bv = [a[i + 3], a[i + 4], a[i + 5]];
-      const C = [a[i + 6], a[i + 7], a[i + 8]];
-      let x0 = 1e9;
-      let x1 = -1e9;
-      let y0 = 1e9;
-      let y1 = -1e9;
-      let z0 = 1e9;
-      let z1 = -1e9;
-      [A, Bv, C].forEach(function(p) {
-        v.set(p[0], p[1], p[2]).applyMatrix4(rel);
-        x0 = Math.min(x0, v.x);
-        x1 = Math.max(x1, v.x);
-        y0 = Math.min(y0, v.y);
-        y1 = Math.max(y1, v.y);
-        z0 = Math.min(z0, v.z);
-        z1 = Math.max(z1, v.z);
-      });
-      if (x1 < B.x0 - e || x0 > B.x1 + e || y1 < B.y0 - e || y0 > B.y1 + e || z1 < B.z0 - e || z0 > B.z1 + e)
-        out.push(A[0], A[1], A[2], Bv[0], Bv[1], Bv[2], C[0], C[1], C[2]);
-      else tri(A, Bv, C, 0);
+      let outside = false;
+      for (let k = 0; k < 3 && !outside; k++) {
+        const p = at(a[i], a[i + 1], a[i + 2], k);
+        const q = at(a[i + 3], a[i + 4], a[i + 5], k);
+        const r = at(a[i + 6], a[i + 7], a[i + 8], k);
+        outside = Math.max(p, q, r) < lo[k] || Math.min(p, q, r) > hi[k];
+      }
+      if (outside) push(a[i], a[i + 1], a[i + 2], a[i + 3], a[i + 4], a[i + 5], a[i + 6], a[i + 7], a[i + 8]);
+      else tri([a[i], a[i + 1], a[i + 2]], [a[i + 3], a[i + 4], a[i + 5]], [a[i + 6], a[i + 7], a[i + 8]], 0);
     }
     const g = new THREE.BufferGeometry();
-    g.setAttribute("position", new THREE.Float32BufferAttribute(out, 3));
+    g.setAttribute("position", new THREE.BufferAttribute(out.slice(0, used), 3));
     g.userData.crease = true;
     g.userData.p0 = null;
     return g;
@@ -6945,6 +7138,17 @@ function installZoneDent(kit) {
     });
     return out;
   }
+  function boxInFrame(B, m, tmp) {
+    const r = [Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity];
+    for (let i = 0; i < 8; i++) {
+      tmp.set(i & 1 ? B.x1 : B.x0, i & 2 ? B.y1 : B.y0, i & 4 ? B.z1 : B.z0).applyMatrix4(m);
+      for (let k = 0; k < 3; k++) {
+        r[k] = Math.min(r[k], tmp.getComponent(k) - 1e-4);
+        r[k + 3] = Math.max(r[k + 3], tmp.getComponent(k) + 1e-4);
+      }
+    }
+    return r;
+  }
   function zoneDent(c, z, dents, dirty, opt) {
     opt = opt || {};
     const B = z.box;
@@ -6999,6 +7203,7 @@ function installZoneDent(kit) {
         g = msh.geometry = g.clone();
         msh.userData.zCloned = true;
       }
+      let boundsDue = false;
       const nonIdx = !g.index;
       const onlyPos = Object.keys(g.attributes).every(function(k) {
         return k === "position" || k === "normal";
@@ -7007,15 +7212,17 @@ function installZoneDent(kit) {
         const ng = subdivIn(g, rel, B, opt.sub || 0.075);
         g.dispose();
         g = msh.geometry = ng;
-        ng.computeBoundingSphere();
-        ng.computeBoundingBox();
+        boundsDue = true;
         dirty.add(msh);
       }
       irel.copy(rel).invert();
       const pos = g.attributes.position;
       let changed = false;
+      const near = boxInFrame(B, irel, v);
       for (let i = 0; i < pos.count; i++) {
-        v.fromBufferAttribute(pos, i).applyMatrix4(rel);
+        v.fromBufferAttribute(pos, i);
+        if (v.x < near[0] || v.x > near[3] || v.y < near[1] || v.y > near[4] || v.z < near[2] || v.z > near[5]) continue;
+        v.applyMatrix4(rel);
         const f = field(v);
         if (f <= 1e-5) continue;
         v.addScaledVector(d, f);
@@ -7036,9 +7243,11 @@ function installZoneDent(kit) {
       }
       if (changed) {
         pos.needsUpdate = true;
+        dirty.add(msh);
+      }
+      if (changed || boundsDue) {
         g.computeBoundingSphere();
         g.computeBoundingBox();
-        dirty.add(msh);
       }
     });
     const dset = new Set(c.deform);
@@ -10141,6 +10350,20 @@ function createVehicleKit(options) {
       else kit.applyArmor(c);
     }
     if (zoneState == null && st === "damaged" && kit.config.damagedScenario) zoneState = kit.zoneScenario(c, kit.config.damagedScenario);
+    else if (zoneState && zoneState.scenario != null) {
+      c.scenario = zoneState.scenario;
+      let fromScenario = { health: {}, flags: {} };
+      try {
+        fromScenario = kit.zoneScenario(c, zoneState.scenario);
+      } catch (e) {
+        ;
+        (c.zoneErrors = c.zoneErrors || []).push("scenario: " + (e && e.message));
+      }
+      zoneState = {
+        health: Object.assign({}, fromScenario.health, zoneState.health),
+        flags: Object.assign({}, fromScenario.flags, zoneState.flags)
+      };
+    }
     if (zoneState) kit.applyZones(c, zoneState);
     else {
       c.zoneState = { health: {}, flags: {} };
@@ -12097,7 +12320,7 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
   const reset = () => {
     const old = c;
     const parent = old.root.parent;
-    const next = kit.build(old.key, old.state);
+    const next = kit.build(old.key, old.state, old.scenario != null ? { scenario: old.scenario } : void 0);
     if (parent) {
       next.root.position.copy(old.root.position);
       next.root.quaternion.copy(old.root.quaternion);
@@ -12154,7 +12377,8 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
 // src/destructible/item.ts
 function buildVehicleItem(kit, key, options = {}) {
   const THREE = kit.THREE;
-  const vehicle = options.lod ? kit.build(key, options.state ?? "intact", void 0, { lod: true }) : kit.build(key, options.state ?? "intact");
+  const zoneState = options.scenario != null ? { scenario: options.scenario } : void 0;
+  const vehicle = options.lod ? kit.build(key, options.state ?? "intact", zoneState, { lod: true }) : kit.build(key, options.state ?? "intact", zoneState);
   const m = vehicle.meta;
   const root = new THREE.Group();
   root.name = key;