@adatechnology/game-vehicles-three 0.3.7 → 0.4.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Damageable, VehicleContext, VehicleKit } from '@adatechnology/game-vehicles';
+import { Damageable, VehicleContext, VehicleKit, CabinSource } from '@adatechnology/game-vehicles';
 import { FleetDims } from '@adatechnology/game-vehicles-fleet';
 import { EffectSink, Vec3, TestableModule } from '@adatechnology/game-contracts';
 
@@ -53,6 +53,27 @@ interface VehiclesThreeOptions {
  */
 declare function createVehiclesThree(THREE: any, options: VehiclesThreeOptions): VehiclesThree;
 
+/**
+ * Keeps the host's effects told where the cabins of the vehicles are and how open they are (`EffectSink.enclose`), so the smoke, dust and steam
+ * do not pass through a shut car: they go round it and get in only through an open door, a broken window or a bullet hole. `sync` every frame;
+ * a vehicle whose object left the scene is forgotten and its cabin ended.
+ */
+interface CabinSmoke {
+    /** Follows the cabin of a vehicle by its object id; `frame` is the object the host placed it in (the destructible's `frame`). */
+    track(id: string, source: CabinSource, frame: {
+        readonly parent: unknown | null;
+    }): void;
+    /** Ends the cabin of one vehicle now. */
+    untrack(id: string, effects: EffectSink | undefined): void;
+    /** Tells `effects` where every cabin is now. A host without `enclose` lets the smoke through, as before. */
+    sync(effects: EffectSink | undefined): void;
+    /** Ends every cabin (the module leaves). */
+    clear(effects: EffectSink | undefined): void;
+    /** The ids followed now. */
+    ids(): string[];
+}
+declare function createCabinSmoke(): CabinSmoke;
+
 /**
  * The light mode of the team's Frota Leve (frota-leve.js 14202-14310): a built vehicle fused into six meshes, one per class of material,
  * with the meshes nobody sees from outside left out. A literal port: the classes, the thresholds (3 cm prune, 0.99 opacity, 0.5 metalness,
@@ -223,4 +244,4 @@ declare const VEHICLE_SCENARIO_IDS: readonly string[];
 declare const PAGE_SCENARIO_ALIASES: Readonly<Record<string, string>>;
 declare const PAGE_ITEM_ALIASES: Readonly<Record<string, string>>;
 
-export { type BuildVehicleOptions, type BuiltVehicle, DEFAULT_TEST_VEHICLES, DEFAULT_TEST_WRECKS, type DocumentLike, type EffectsLike, LITE_CLASSES, type LiteClass, type LiteFusion, type ModuleRoomLike, PAGE_ITEM_ALIASES, PAGE_SCENARIO_ALIASES, PRUNE_BELOW, VEHICLES_AREA_ID, VEHICLE_SCENARIO_IDS, type VehicleEffectIds, type VehicleQuality, type VehicleSoundIds, type VehicleWreck, type VehiclesContext, type VehiclesRoom, type VehiclesTestOptions, type VehiclesThree, type VehiclesThreeOptions, classColor, classify, createVehiclesTestModule, createVehiclesThree, defaultEffectIds, defaultSoundIds, fuse, liteMaterials, liteMeshes, loadVehiclesTestModule };
+export { type BuildVehicleOptions, type BuiltVehicle, type CabinSmoke, DEFAULT_TEST_VEHICLES, DEFAULT_TEST_WRECKS, type DocumentLike, type EffectsLike, LITE_CLASSES, type LiteClass, type LiteFusion, type ModuleRoomLike, PAGE_ITEM_ALIASES, PAGE_SCENARIO_ALIASES, PRUNE_BELOW, VEHICLES_AREA_ID, VEHICLE_SCENARIO_IDS, type VehicleEffectIds, type VehicleQuality, type VehicleSoundIds, type VehicleWreck, type VehiclesContext, type VehiclesRoom, type VehiclesTestOptions, type VehiclesThree, type VehiclesThreeOptions, classColor, classify, createCabinSmoke, createVehiclesTestModule, createVehiclesThree, defaultEffectIds, defaultSoundIds, fuse, liteMaterials, liteMeshes, loadVehiclesTestModule };

package/dist/index.global.js

@@ -31,6 +31,7 @@ var GameVehiclesThree = (() => {
     VEHICLE_SCENARIO_IDS: () => VEHICLE_SCENARIO_IDS,
     classColor: () => classColor,
     classify: () => classify,
+    createCabinSmoke: () => createCabinSmoke,
     createVehiclesTestModule: () => createVehiclesTestModule,
     createVehiclesThree: () => createVehiclesThree,
     defaultEffectIds: () => defaultEffectIds,
@@ -42395,6 +42396,123 @@ var GameVehiclesThree = (() => {
     root.userData.vehicle = vehicle;
     return { root, vehicle };
   }
+  var CABIN_LEAK = 0.02;
+  var HOLE_RATE_PER_AREA = 3e3;
+  var CRACK_GAP_PER_METRE = 0.5;
+  var THROUGH = 0.18;
+  var HOLE_PATCH = 0.12;
+  var FULL_SWING = 1.15;
+  var SHELL_ROLES = /* @__PURE__ */ new Set(["door", "glass", "roof", "lid", "panel", "pillar"]);
+  var GONE = /* @__PURE__ */ new Set(["broken", "melted", "ashes"]);
+  function cabinBoxOf(vehicle) {
+    const cabin = vehicle.meta.cabin;
+    if (!cabin || !(cabin.x1 > cabin.x0) || !(cabin.y1 > cabin.y0) || !(cabin.z > 0)) return null;
+    return cabin;
+  }
+  function swingOf(vehicle, partId) {
+    const pivot = vehicle.vehicle?.getObjectByName?.(partId);
+    const q = pivot?.quaternion;
+    if (!q) return 0;
+    const angle = 2 * Math.acos(Math.min(1, Math.abs(q.w)));
+    return Math.min(1, angle / FULL_SWING);
+  }
+  var overlaps = (b, c, margin) => Math.abs(b.center[0] - (c.x0 + c.x1) / 2) <= b.size[0] / 2 + (c.x1 - c.x0) / 2 + margin && Math.abs(b.center[1] - (c.y0 + c.y1) / 2) <= b.size[1] / 2 + (c.y1 - c.y0) / 2 + margin && Math.abs(b.center[2]) <= b.size[2] / 2 + c.z + margin;
+  function cabinEnclosure(source, options = {}) {
+    const c = source.vehicle;
+    const cabin = cabinBoxOf(c);
+    const node = c.vehicle;
+    if (!cabin || !node?.localToWorld) return null;
+    const state = source.state();
+    if (state.destroyed) return null;
+    const V3 = node.position.constructor;
+    const Quat = node.quaternion.constructor;
+    const mid = [(cabin.x0 + cabin.x1) / 2, (cabin.y0 + cabin.y1) / 2, 0];
+    const half = [(cabin.x1 - cabin.x0) / 2, (cabin.y1 - cabin.y0) / 2, cabin.z];
+    const ajar = options.ajar ?? 0.06;
+    const byId = new Map(state.parts.map((p) => [p.id, p]));
+    const mainGroup = state.groups[0] ? new Set(state.groups[0]) : null;
+    const openings = [];
+    let crackLength = 0;
+    const toCabin = (b) => ({
+      center: [b.center[0] - mid[0], b.center[1] - mid[1], b.center[2] - mid[2]],
+      halfSize: [b.size[0] / 2 + THROUGH, b.size[1] / 2 + THROUGH, b.size[2] / 2 + THROUGH]
+    });
+    node.updateWorldMatrix?.(true, false);
+    const frame = options.frame ?? c.root;
+    frame?.updateWorldMatrix?.(true, false);
+    const inverse = node.matrixWorld.clone().invert();
+    for (const def of source.model.parts) {
+      if (!SHELL_ROLES.has(def.role) || !overlaps(def.box, cabin, 0.12)) continue;
+      const part = byId.get(def.id);
+      if (!part) continue;
+      const gone = GONE.has(part.status) || mainGroup !== null && !mainGroup.has(def.id);
+      const swung = (def.role === "door" || def.role === "lid") && swingOf(c, def.id) > ajar;
+      if (gone || swung) {
+        openings.push(toCabin(def.box));
+        continue;
+      }
+      for (const hole of part.holes) {
+        if (!hole.through && def.material !== "glass") continue;
+        const area3 = Math.PI * (hole.diameter / 2) ** 2;
+        const p = new V3(hole.point[0], hole.point[1], hole.point[2]);
+        if (frame?.localToWorld) frame.localToWorld(p);
+        p.applyMatrix4(inverse);
+        openings.push({
+          center: [p.x - mid[0], p.y - mid[1], p.z - mid[2]],
+          halfSize: [HOLE_PATCH, HOLE_PATCH, HOLE_PATCH],
+          // the patch is far bigger than the hole: only a share of what crosses it passes, more for a bigger hole
+          rate: Math.min(4, area3 * HOLE_RATE_PER_AREA)
+        });
+      }
+      for (const crack of part.cracks) crackLength += crack.length;
+    }
+    const center = node.localToWorld(new V3(mid[0], mid[1], mid[2]));
+    const q = node.getWorldQuaternion(new Quat());
+    const scale = node.getWorldScale(new V3());
+    const leak = (options.leak ?? CABIN_LEAK) * (1 + crackLength * CRACK_GAP_PER_METRE);
+    return {
+      center: [center.x, center.y, center.z],
+      halfSize: [half[0] * Math.abs(scale.x), half[1] * Math.abs(scale.y), half[2] * Math.abs(scale.z)],
+      orientation: [q.x, q.y, q.z, q.w],
+      openings: openings.map((o) => ({ ...o, center: [o.center[0] * scale.x, o.center[1] * scale.y, o.center[2] * scale.z], halfSize: [o.halfSize[0] * Math.abs(scale.x), o.halfSize[1] * Math.abs(scale.y), o.halfSize[2] * Math.abs(scale.z)] })),
+      leak
+    };
+  }
+
+  // src/cabin-smoke.ts
+  function createCabinSmoke() {
+    const tracked = /* @__PURE__ */ new Map();
+    const end = (id, entry, effects) => {
+      if (entry.declared) effects?.enclose?.(id, null);
+      tracked.delete(id);
+    };
+    return {
+      track(id, source, frame) {
+        tracked.set(id, { source, frame, declared: false, placed: false });
+      },
+      untrack(id, effects) {
+        const entry = tracked.get(id);
+        if (entry) end(id, entry, effects);
+      },
+      sync(effects) {
+        if (!effects?.enclose) return;
+        for (const [id, entry] of tracked) {
+          if (!entry.frame.parent) {
+            if (entry.placed) end(id, entry, effects);
+            continue;
+          }
+          entry.placed = true;
+          const enclosure = cabinEnclosure(entry.source, { frame: entry.frame });
+          if (enclosure || entry.declared) effects.enclose(id, enclosure);
+          entry.declared = enclosure !== null;
+        }
+      },
+      clear(effects) {
+        for (const [id, entry] of [...tracked]) end(id, entry, effects);
+      },
+      ids: () => [...tracked.keys()]
+    };
+  }
 
   // ../game-vehicles-driving/dist/index.js
   var defaultArcadeSpec = {
@@ -43456,6 +43574,7 @@ var GameVehiclesThree = (() => {
     const settings = { quality: "high", paint: false, seed: 1, palette: "auto", driving: "arcade", surface: "dry_asphalt" };
     const kits = /* @__PURE__ */ new WeakMap();
     const placed = /* @__PURE__ */ new Map();
+    const cabins = createCabinSmoke();
     let host = null;
     let three = null;
     let counter = 0;
@@ -43520,6 +43639,7 @@ var GameVehiclesThree = (() => {
         const kit = r.userData.kit;
         const d = createVehicleDestructible(kit, r.userData.vehicle, { id, frame: root, name: text.items[itemKey] ?? key });
         tapEffects(d);
+        cabins.track(id, d, root);
         r.userData.destructible = d;
         return d;
       },
@@ -43775,6 +43895,7 @@ var GameVehiclesThree = (() => {
       }
       if (host?.bench && boxKey() !== helpersShown && (host.bench.layer("damageables") || host.bench.layer("zones") || helpersShown !== "")) refreshLayers();
       lane?.step(dt);
+      cabins.sync(effects());
     };
     const count2 = () => {
       let drawCalls = 0;
@@ -43875,6 +43996,7 @@ var GameVehiclesThree = (() => {
           stopChange?.();
           stopFrame();
           stopBlocker?.();
+          cabins.clear(effects());
           clearHelpers();
           clearLane();
           host = null;