@adatechnology/game-vehicles 0.6.2 → 0.6.3

package/dist/index.js

@@ -5471,8 +5471,20 @@ function installGlassDamage(kit) {
     if (!L || L.broken) return;
     L.broken = true;
     L.lens.forEach(function(m) {
-      m.visible = false;
+      const rim = L.lensMaterial ? glassRim(m.geometry, c.rand) : null;
+      if (!rim) {
+        m.visible = false;
+        return;
+      }
+      m.geometry.dispose();
+      m.geometry = rim;
+      m.material = MATERIALS.glassEdge;
+      m.userData.lensRim = true;
     });
+    if (L.lensMaterial)
+      (L.reflector || []).forEach(function(m) {
+        m.material = MATERIALS.broken;
+      });
     L.inner.forEach(function(m) {
       m.material = MATERIALS.bulbBroken;
     });
@@ -5480,11 +5492,38 @@ function installGlassDamage(kit) {
       h.visible = false;
     });
     const p = L.group ? L.group.position.clone() : L.inner[0] ? L.inner[0].position.clone() : new V3();
-    I.burst(c, "lens", c.toEffects(p), 10, { dir: c.dirToEffects(dir.clone().negate()), speed: 1.4, variant: L.tint === "red" ? "red" : "clear" });
-    I.burst(c, "plastic", c.toEffects(p), 2, { dir: c.dirToEffects(dir.clone().negate()), speed: 1 });
+    const glass = L.lensMaterial !== "plastic";
+    I.burst(c, "lens", c.toEffects(p), glass ? 10 : 5, { dir: c.dirToEffects(dir.clone().negate()), speed: glass ? 1.4 : 1.1, variant: L.tint === "red" ? "red" : "clear" });
+    I.burst(c, "plastic", c.toEffects(p), glass ? 2 : 5, { dir: c.dirToEffects(dir.clone().negate()), speed: 1 });
   }
   kit.breakLight = breakLight;
-  Object.assign(I, { glassUV, drawWeb, crackGlass, glassRim, shatterGlass, hitGlass, breakLight });
+  const crazedCache = /* @__PURE__ */ new Map();
+  const CRAZED_OPACITY = 0.6;
+  function crazed(material) {
+    const known = crazedCache.get(material);
+    if (known) return known;
+    const m = I.crackLens(material).clone();
+    m.opacity = Math.max(m.opacity ?? 1, CRAZED_OPACITY);
+    m.transparent = true;
+    m.userData.shared = true;
+    crazedCache.set(material, m);
+    return m;
+  }
+  function crackLight(c, L, dir, pierced) {
+    if (!L || L.broken) return;
+    if (!L.cracked) {
+      L.cracked = true;
+      for (const m of L.lens) if (m.material && !Array.isArray(m.material)) m.material = crazed(m.material);
+    }
+    const p = L.group ? L.group.position.clone() : L.inner[0] ? L.inner[0].position.clone() : new V3();
+    I.burst(c, "lens", c.toEffects(p), 3, { dir: c.dirToEffects(dir.clone().negate()), speed: 0.9, variant: L.tint === "red" ? "red" : "clear" });
+    if (!pierced || L.dark) return;
+    L.dark = true;
+    for (const m of L.inner) m.material = MATERIALS.bulbBroken;
+    for (const h of L.halo ?? []) h.visible = false;
+  }
+  kit.crackLight = crackLight;
+  Object.assign(I, { glassUV, drawWeb, crackGlass, glassRim, shatterGlass, hitGlass, breakLight, crackLight });
 }
 
 // src/impact.ts
@@ -11037,6 +11076,8 @@ var MECHANICS = {
   heli: ["battery", "alternator", "gearbox"]
 };
 var HITCH_CHANCE = { car: 30, truck: 60, bus: 0, tractor: 100, quad: 40, bike: 0, tank: 0, boat: 0, plane: 0, heli: 0 };
+var GLASS_LENS_HP = 320;
+var PLASTIC_LENS_HP = 900;
 var STEEL_KG_M2 = 7;
 var ALU_KG_M2 = 3.2;
 var kindOf = (c) => {
@@ -11194,7 +11235,9 @@ function buildVehicleModel(kit, c, options = {}) {
       continue;
     }
     if (role === "light") {
-      add({ id, role, name: label, material: "glass", box, mass: 1.2 + 4 * area, hp: 320, zoneId: id, visual: true, tags: ["light", ...tags] });
+      const lens = /^head/.test(id) ? spec.headlightLens ?? "polycarbonate" : "acrylic";
+      const glassLens = lens === "glass";
+      add({ id, role, name: label, material: glassLens ? "glass" : "plastic", box, mass: 1.2 + 4 * area, hp: glassLens ? GLASS_LENS_HP : PLASTIC_LENS_HP, zoneId: id, visual: true, tags: ["light", `lens_${lens}`, ...tags] });
       continue;
     }
     if (role === "bumper") {
@@ -11651,21 +11694,188 @@ function subdivideNear(THREE, params) {
   mesh.geometry = g;
 }
 
+// src/destructible/door-open.ts
+var STRIP_SMOOTH_DEG = 180;
+var SKIN_BAND = 0.05;
+var BODY_FACING = 0.5;
+var FIELDS = 4;
+var SEAM_THIN = 0.03;
+var SEAM_AT_EDGE = 0.04;
+var SEAM_TALL = 0.4;
+var SLIVER_AREA = 1e-10;
+function cutStripOverDoor(vehicleKit, params) {
+  const kit = vehicleKit;
+  const strip = params.strip;
+  const toVehicle = params.toVehicle;
+  const { x0, x1 } = params;
+  const THREE = kit.THREE;
+  const at = new THREE.Vector3();
+  const along = (x, y, z) => at.set(x, y, z).applyMatrix4(toVehicle).x;
+  const piece = (tests) => {
+    const mesh = new THREE.Mesh(strip.geometry.clone(), strip.material);
+    kit.cutMesh(mesh, tests, STRIP_SMOOTH_DEG, {});
+    return mesh;
+  };
+  const over = piece([{ sdf: (x, y, z) => along(x, y, z) - x0 }, { sdf: (x, y, z) => x1 - along(x, y, z) }]);
+  const after = piece([{ sdf: (x, y, z) => along(x, y, z) - x1 }]);
+  kit.cutMesh(strip, [{ sdf: (x, y, z) => x0 - along(x, y, z) }], STRIP_SMOOTH_DEG, {});
+  const joined = joinTriangles(THREE, strip.geometry, after.geometry);
+  strip.geometry.dispose();
+  after.geometry.dispose();
+  strip.geometry = joined;
+  return over;
+}
+function joinTriangles(THREE, first, second) {
+  const a = first.index ? first.toNonIndexed() : first;
+  const b = second.index ? second.toNonIndexed() : second;
+  const flags = [...solidTriangles(THREE, a), ...solidTriangles(THREE, b)];
+  const both = new THREE.BufferGeometry();
+  for (const name of Object.keys(a.attributes)) {
+    const p = a.getAttribute(name);
+    const q = b.getAttribute(name);
+    if (!q || q.itemSize !== p.itemSize) continue;
+    const array = new Float32Array(p.array.length + q.array.length);
+    array.set(p.array, 0);
+    array.set(q.array, p.array.length);
+    both.setAttribute(name, new THREE.Float32BufferAttribute(array, p.itemSize));
+  }
+  if (a !== first) a.dispose();
+  if (b !== second) b.dispose();
+  const out = pickTriangles(THREE, both, flags, true) ?? new THREE.BufferGeometry();
+  both.dispose();
+  return out;
+}
+function solidTriangles(THREE, geometry) {
+  const pos = geometry.getAttribute("position");
+  const triangle = new THREE.Triangle();
+  const flags = [];
+  for (let t = 0; t * 3 + 2 < pos.count; t++) {
+    triangle.a.fromBufferAttribute(pos, t * 3);
+    triangle.b.fromBufferAttribute(pos, t * 3 + 1);
+    triangle.c.fromBufferAttribute(pos, t * 3 + 2);
+    flags.push(triangle.getArea() > SLIVER_AREA);
+  }
+  return flags;
+}
+function splitDoorSkin(three, meshes, toVehicleOf, side2, depth) {
+  const THREE = three;
+  const pieces = meshes;
+  const toVehicle = toVehicleOf;
+  const v = new THREE.Vector3();
+  const corners = [new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3()];
+  const triangle = new THREE.Triangle();
+  const centres = pieces.map((mesh) => {
+    const geometry = mesh.geometry.index ? mesh.geometry.toNonIndexed() : mesh.geometry;
+    const matrix = toVehicle(mesh);
+    const pos = geometry.getAttribute("position");
+    const out = new Float32Array(pos.count / 3 * FIELDS);
+    for (let t = 0; t * 3 + 2 < pos.count; t++) {
+      let y = 0;
+      let across = 0;
+      for (let k = 0; k < 3; k++) {
+        corners[k].fromBufferAttribute(pos, t * 3 + k).applyMatrix4(matrix);
+        y += corners[k].y / 3;
+        across += side2 * corners[k].z / 3;
+      }
+      out[t * FIELDS] = y;
+      out[t * FIELDS + 1] = across;
+      triangle.set(corners[0], corners[1], corners[2]).getNormal(v);
+      out[t * FIELDS + 2] = v.y;
+      out[t * FIELDS + 3] = v.x;
+    }
+    return { geometry, out };
+  });
+  const outer = /* @__PURE__ */ new Map();
+  for (const { out } of centres)
+    for (let t = 0; t * FIELDS < out.length; t++) {
+      const band = Math.floor(out[t * FIELDS] / SKIN_BAND);
+      outer.set(band, Math.max(outer.get(band) ?? -Infinity, out[t * FIELDS + 1]));
+    }
+  const surfaceAt = (y) => {
+    const band = Math.floor(y / SKIN_BAND);
+    return Math.max(outer.get(band - 1) ?? -Infinity, outer.get(band) ?? -Infinity, outer.get(band + 1) ?? -Infinity);
+  };
+  return centres.map(({ geometry, out }, i) => {
+    const near = [];
+    for (let t = 0; t * FIELDS < out.length; t++) {
+      const f = t * FIELDS;
+      const body = out[f + 1] < surfaceAt(out[f]) - depth && (out[f + 2] < -BODY_FACING || Math.abs(out[f + 3]) > BODY_FACING);
+      near.push(!body);
+    }
+    const result = { skin: pickTriangles(THREE, geometry, near, true), deep: pickTriangles(THREE, geometry, near, false) };
+    if (geometry !== pieces[i].geometry) geometry.dispose();
+    return result;
+  });
+}
+function leaveDeepSkinOnBody(three, meshes, params) {
+  const THREE = three;
+  const pieces = meshes;
+  const toVehicle = params.toVehicle;
+  const { side: side2, depth } = params;
+  const split = splitDoorSkin(THREE, pieces, (mesh) => new THREE.Matrix4().multiplyMatrices(toVehicle, mesh.matrixWorld), side2, depth);
+  split.forEach(({ skin, deep }, i) => {
+    const piece = pieces[i];
+    if (!deep || !skin || !piece.parent) return;
+    const body = new THREE.Mesh(deep, piece.material);
+    body.position.copy(piece.position);
+    body.quaternion.copy(piece.quaternion);
+    body.scale.copy(piece.scale);
+    body.castShadow = piece.castShadow;
+    body.receiveShadow = piece.receiveShadow;
+    piece.parent.add(body);
+    piece.geometry.dispose();
+    piece.geometry = skin;
+  });
+}
+function pickTriangles(THREE, geometry, flags, wanted) {
+  const count = flags.filter((flag) => flag === wanted).length;
+  if (!count) return null;
+  const out = new THREE.BufferGeometry();
+  for (const name of Object.keys(geometry.attributes)) {
+    const attribute = geometry.getAttribute(name);
+    const size = attribute.itemSize;
+    const source = attribute.array;
+    const array = new Float32Array(count * 3 * size);
+    let w = 0;
+    flags.forEach((flag, t) => {
+      if (flag !== wanted) return;
+      array.set(source.subarray(t * 3 * size, (t + 1) * 3 * size), w);
+      w += 3 * size;
+    });
+    out.setAttribute(name, new THREE.Float32BufferAttribute(array, size));
+  }
+  out.computeBoundingBox();
+  out.computeBoundingSphere();
+  return out;
+}
+function isDoorSeam(three, params) {
+  const THREE = three;
+  const box = params.box;
+  const { zone, side: side2, dark } = params;
+  if (!dark || box.isEmpty()) return false;
+  const size = box.getSize(new THREE.Vector3());
+  const centre = box.getCenter(new THREE.Vector3());
+  if (Math.sign(centre.z) !== Math.sign(side2) || size.x > SEAM_THIN || size.z > SEAM_THIN || size.y < (zone.y1 - zone.y0) * SEAM_TALL) return false;
+  if (centre.y < zone.y0 || centre.y > zone.y1) return false;
+  return Math.abs(centre.x - zone.x0) < SEAM_AT_EDGE || Math.abs(centre.x - zone.x1) < SEAM_AT_EDGE;
+}
+
 // src/destructible/visual.ts
 var HOLE_DECAL_SCALE = 2.4;
 var DOOR_DEPTH = 0.07;
+var DOOR_SKIN_DEPTH = 0.09;
+var DOOR_FLOOR_DEPTH = 0.2;
 var DOOR_EDGE_PIECES = 8;
 var DOOR_EDGE_REACH = 0.08;
 var DOOR_CARD_COLOR = "#3b3e42";
 var DOOR_LINER_COLOR = "#5a5e64";
 var DOOR_LINER_DARK = 0.15;
-var DOOR_STRIP_THIN = 0.08;
+var DOOR_STRIP_THIN = 0.13;
 var DOOR_STRIP_NEAR = 0.04;
 var DOOR_STRIP_TALL = 0.22;
-var STRIP_SMOOTH_DEG = 180;
-var DOOR_STRIP_VERTICES = 2e4;
+var DOOR_STRIP_VERTICES = 6e4;
 var DOOR_SILL = 0.25;
-var DOOR_STRIP_OVER = 0.3;
+var DOOR_STRIP_OVER = 0.05;
 var DOOR_TOP_OVER_PANE = 0.03;
 var HOLE_TEXTURE_SIZE = 64;
 var LAMINATED_HP = 1e3;
@@ -11774,6 +11984,10 @@ var VehicleVisuals = class {
     __publicField(this, "skins", /* @__PURE__ */ new Map());
     /** How high each door's cut reaches. */
     __publicField(this, "doorTops", /* @__PURE__ */ new Map());
+    /** The shut lines drawn on the body at a door's edges, by line: the doors whose edge it marks. Shown only while all of them are closed. */
+    __publicField(this, "seams", /* @__PURE__ */ new Map());
+    /** Doors and lids standing open now. */
+    __publicField(this, "openNow", /* @__PURE__ */ new Set());
     __publicField(this, "lightsOn", true);
     /** Heavy body meshes whose triangle index is still to build (null once done). */
     __publicField(this, "warming");
@@ -11955,6 +12169,11 @@ var VehicleVisuals = class {
       }
       panel.visible = open && !this.skins.get(id);
       recess.visible = open && !this.skins.get(id);
+      if (open) this.openNow.add(id);
+      else this.openNow.delete(id);
+      this.seams.forEach((doors, seam) => {
+        if (doors.has(id)) seam.visible = ![...doors].some((door) => this.openNow.has(door));
+      });
     };
     const euler = piv.rotation;
     const quaternion = piv.quaternion;
@@ -11997,11 +12216,13 @@ var VehicleVisuals = class {
         const pcs = I.cutPanel(this.c, z, rect, true, dirty, { anyN: true }).map((x) => x.mesh).filter((m) => !!m);
         this.mend(dirty);
         if (pcs.length) {
+          leaveDeepSkinOnBody(this.THREE, pcs, { toVehicle: inv, side: z.side < 0 ? -1 : 1, depth: DOOR_SKIN_DEPTH });
           const panes = I.windowsOver(this.c, z, inv);
           const seals = panes.map((g) => I.paneSeals.get(g)).filter((s) => !!s);
           const mirrors = this.mirrorsOn(z);
           const frames = this.framesAround(panes, inv);
-          objs = [...pcs, ...I.followersIn(this.c, z, inv), ...panes, ...seals, ...mirrors, ...frames];
+          const followers = I.followersIn(this.c, z, inv).filter((o) => !this.takeSeam(o, id, z, inv) && !this.inFloor(o, piv, z, inv));
+          objs = [...pcs, ...followers, ...panes, ...seals, ...mirrors, ...frames];
         }
       } else {
         const pcs = this.cutZone(z);
@@ -12029,6 +12250,25 @@ var VehicleVisuals = class {
     this.c.root.updateMatrixWorld(true);
     return objs.length > 0;
   }
+  /** A thin part at the foot of the opening, well inside the skin (a step, a sill trim, a rail on the floor), is the floor's: it does not swing with the door. */
+  inFloor(o, piv, z, inv) {
+    const side2 = z.side < 0 ? -1 : 1;
+    const centre = this.I.localBox(this.c, o, inv).getCenter(new this.THREE.Vector3());
+    const skin = side2 * (piv.position.z - side2 * 0.016);
+    return centre.y < z.box.y0 + DOOR_SILL && side2 * centre.z < skin - DOOR_FLOOR_DEPTH;
+  }
+  /** A shut line drawn at the door's edge stays on the body, hidden while a door it marks stands open; answers whether `o` is one. */
+  takeSeam(o, id, z, inv) {
+    const B = z.box;
+    const box = this.I.localBox(this.c, o, inv);
+    const color = o.material?.color;
+    const dark = !!color && color.getHSL({ h: 0, s: 0, l: 0 }).l < DOOR_LINER_DARK;
+    if (!o.isMesh || !isDoorSeam(this.THREE, { box, zone: { x0: B.x0, x1: B.x1, y0: B.y0, y1: B.y1 }, side: z.side, dark })) return false;
+    const doors = this.seams.get(o) ?? /* @__PURE__ */ new Set();
+    doors.add(id);
+    this.seams.set(o, doors);
+    return true;
+  }
   /** A door has edges: a band that follows the skin all round closes it to its card and hides where the cut followed the triangles of the shell; the same band, in the same paint as on a real car, lines the opening. */
   doorEdges(piv, z, y1) {
     const THREE = this.THREE;
@@ -12050,13 +12290,15 @@ var VehicleVisuals = class {
       const at = this.surface("z", side2, B, [[x, y]]);
       return at != null && Math.abs(at - flat) < DOOR_EDGE_REACH ? at : flat;
     });
-    const band = (lift) => {
+    const band = (lift, path, closed) => {
       const position = [];
       const index = [];
-      loop.forEach(([x, y], i) => {
-        position.push(x, y, heights[i] + side2 * lift, x, y, heights[i] + side2 * (lift - DOOR_DEPTH));
+      path.forEach((at, i) => {
+        const [x, y] = loop[at];
+        position.push(x, y, heights[at] + side2 * lift, x, y, heights[at] + side2 * (lift - DOOR_DEPTH));
+        if (!closed && i === path.length - 1) return;
         const a = i * 2;
-        const b = (i + 1) % loop.length * 2;
+        const b = (i + 1) % path.length * 2;
         index.push(a, a + 1, b, b, a + 1, b + 1);
       });
       const g = new THREE.BufferGeometry();
@@ -12084,8 +12326,11 @@ var VehicleVisuals = class {
     card.castShadow = false;
     this.c.vehicle.add(card);
     piv.attach(card);
-    const edges = new THREE.Mesh(band(2e-3), paint);
-    const lining = new THREE.Mesh(band(2e-3), paint);
+    const all = loop.map((_, i) => i);
+    const top = 2 * DOOR_EDGE_PIECES;
+    const sides = [...all.slice(3 * DOOR_EDGE_PIECES), ...all.slice(0, top + 1)];
+    const edges = new THREE.Mesh(band(2e-3, all, true), paint);
+    const lining = new THREE.Mesh(band(2e-3, sides, false), paint);
     for (const m of [edges, lining]) {
       m.userData.noFollow = true;
       m.castShadow = false;
@@ -12142,26 +12387,14 @@ var VehicleVisuals = class {
       const box = this.I.localBox(this.c, o, inv);
       const size = box.getSize(new THREE.Vector3());
       const mid = box.getCenter(new THREE.Vector3());
-      if (Math.sign(mid.z) !== Math.sign(z.side) || size.z > DOOR_STRIP_THIN || size.y > DOOR_STRIP_TALL || Math.min(box.max.x, x1) - Math.max(box.min.x, x0) < (x1 - x0) * DOOR_STRIP_OVER || mid.y < y0 || mid.y > y1) continue;
+      if (Math.sign(mid.z) !== Math.sign(z.side) || size.z > DOOR_STRIP_THIN || size.y > DOOR_STRIP_TALL || Math.min(box.max.x, x1) - Math.max(box.min.x, x0) < DOOR_STRIP_OVER || mid.y < y0 || mid.y > y1) continue;
       const toVehicle = new THREE.Matrix4().multiplyMatrices(inv, o.matrixWorld);
-      const v = new THREE.Vector3();
-      const sdf = (x, y, zz) => {
-        v.set(x, y, zz).applyMatrix4(toVehicle);
-        return Math.max(x0 - v.x, v.x - x1);
-      };
-      const over = new THREE.Mesh(o.geometry.clone(), o.material);
+      const over = cutStripOverDoor(this.kit, { strip: o, toVehicle, x0, x1 });
       over.position.copy(o.position);
       over.quaternion.copy(o.quaternion);
       over.scale.copy(o.scale);
       this.c.vehicle.add(over);
       over.updateMatrixWorld(true);
-      const overToVehicle = new THREE.Matrix4().multiplyMatrices(inv, over.matrixWorld);
-      const w = new THREE.Vector3();
-      this.kit.cutMesh(over, [{ sdf: (x, y, zz) => {
-        w.set(x, y, zz).applyMatrix4(overToVehicle);
-        return -Math.max(x0 - w.x, w.x - x1);
-      } }], STRIP_SMOOTH_DEG, {});
-      this.kit.cutMesh(o, [{ sdf }], STRIP_SMOOTH_DEG, {});
       over.userData.noFollow = true;
       piv.attach(over);
     }
@@ -12742,11 +12975,18 @@ var VehicleVisuals = class {
       }
     }
   }
+  /** The lens of a light is holed or cracked and stays; `pierced`: a round went through it to the bulb, and the lamp goes dark. */
+  crackLight(p, pierced) {
+    const z = this.zone(p);
+    if (!z) return;
+    for (const L of z.lights) this.kit.crackLight(this.c, L, new this.THREE.Vector3(p.box.center[0] > 0 ? -1 : 1, 0, 0), pierced);
+  }
   /** The lens of a light breaks and its unit stays (damaged) or goes (destroyed). */
   breakLight(p, gone) {
     const z = this.zone(p);
     if (!z) return;
     for (const L of z.lights) {
+      L.lensMaterial = p.material;
       this.kit.breakLight(this.c, L, new this.THREE.Vector3(p.box.center[0] > 0 ? -1 : 1, 0, 0));
       if (gone) {
         if (L.group) L.group.visible = false;
@@ -13392,6 +13632,7 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
     wear(p, amount, out);
     syncZone(p);
     if (p.hp <= 0) lose(p, "broken", out, cause);
+    else if (p.def.role === "light") vis?.crackLight(p.def, dtype === "ballistic");
     if (p.def.role === "tyre" && !p.flat && p.hp < p.def.hp * 0.6 && !p.lost) {
       p.flat = true;
       vis?.tyreFlat(p.def, 0.24);
@@ -14204,7 +14445,7 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
         if (!list.length) return 1;
         return Math.min(...list.map((p) => p.lost || !attached(p.def.id) ? 0 : p.hp / p.def.hp));
       };
-      const tyres = [...ps.values()].filter((p) => p.def.role === "tyre").map((p) => ({ x: p.def.box.center[0], z: p.def.box.center[2], health: tyreHealth(p) }));
+      const tyres = [...ps.values()].filter((p) => p.def.role === "tyre").map((p) => ({ x: p.def.box.center[0], z: p.def.box.center[2], health: tyreHealth(p), rim: p.lost }));
       const status = computeStatus();
       const brakeSystem = [...ps.values()].find((p) => p.def.role === "brakes" && p.def.contains);
       const fluidLeft = brakeSystem ? clamp((brakeSystem.liters ?? 0) / brakeSystem.def.contains.liters / BRAKE_FLUID_NEEDED, 0, 1) : 1;