@adatechnology/game-vehicles 0.1.12 → 0.2.0

package/dist/index.js

@@ -837,9 +837,11 @@ function installGeometry(kit) {
   const V3 = THREE.Vector3;
   const PI = Math.PI;
   const I = kit._;
+  const lod = kit.lod;
   function roundedBoxGeometry(w, h, d, r) {
     r = Math.max(2e-3, Math.min(r, w * 0.45, h * 0.45, d * 0.45));
-    const nb = 3;
+    if (lod.on && (r < 0.012 || Math.max(w, h, d) < lod.flatBoxEdge || Math.min(w, h, d) < 0.08)) return new THREE.BoxGeometry(w, h, d);
+    const nb = lod.on ? lod.roundingRings : 3;
     const n = 2 * nb + 1;
     const g = new THREE.BoxGeometry(1, 1, 1, n, n, n);
     const p = g.attributes.position;
@@ -884,6 +886,7 @@ function installGeometry(kit) {
     geo.computeVertexNormals();
   }
   function subdivide(geo, maxLen) {
+    if (lod.on) maxLen = maxLen * lod.subdivisionFactor;
     const src = geo.index ? geo.toNonIndexed() : geo;
     const a = src.attributes.position.array;
     const out = [];
@@ -1613,6 +1616,7 @@ function installWarp(kit) {
   const V3 = THREE.Vector3;
   const PI = Math.PI;
   const I = kit._;
+  const lod = kit.lod;
   const { crease } = I;
   function makeWarp(o) {
     function sec(y) {
@@ -1710,6 +1714,7 @@ function installWarp(kit) {
     });
   }
   function resample(st, n) {
+    if (lod.on) n = Math.max(lod.minStations, Math.round(n * lod.stationFraction));
     const out = [];
     const L = st.length;
     function P(i) {
@@ -1741,6 +1746,7 @@ function installWarp(kit) {
   }
   function smoothLoft(st, o) {
     o = o || {};
+    if (lod.on) o = Object.assign({}, o, { seg: Math.max(lod.minLoftSegments, Math.round((o.seg || 24) * lod.loftSegmentFraction)) });
     if (o.smooth) st = resample(st, o.smooth);
     const seg = o.seg || 24;
     const pos = [];
@@ -9755,16 +9761,167 @@ function installUi(kit) {
   kit.ui = { damageMap, bandButtons, legend, healthBar, scenarioButtons, zoneLabel, bandRange, css, injectStyles };
 }
 
+// src/lod.ts
+var defaultLodSettings = {
+  on: false,
+  segmentFraction: 0.5,
+  roundingRings: 1,
+  subdivisionFactor: 2.2,
+  flatBoxEdge: 0.22,
+  minLoftSegments: 14,
+  loftSegmentFraction: 0.45,
+  minStations: 20,
+  stationFraction: 0.55,
+  gridFactor: 2.6,
+  hiddenMaterials: ["seat", "carpet", "headliner", "gauge", "screen", "bay", "hoodLiner", "block", "cover", "radiator", "coolant", "coolantLiq", "washer", "hv", "hose", "leather"]
+};
+function createLod(options) {
+  return { ...defaultLodSettings, ...options || {}, on: false };
+}
+var fewer = (lod, n, min) => Math.max(min, Math.round(n * lod.segmentFraction));
+function wrapThreeForLod(TH, lod) {
+  const T = Object.assign({}, TH);
+  if (TH.SRGBColorSpace) {
+    T.CanvasTexture = class extends TH.CanvasTexture {
+      constructor(a, b, c, d, e, f, g, h, i) {
+        super(a, b, c, d, e, f, g, h, i);
+        this.colorSpace = TH.SRGBColorSpace;
+      }
+    };
+  }
+  T.CylinderGeometry = class extends TH.CylinderGeometry {
+    constructor(rt, rb, h, rs, hs, open, ts, tl) {
+      super(rt, rb, h, lod.on && rs != null ? fewer(lod, rs, 6) : rs, lod.on ? 1 : hs, open, ts, tl);
+    }
+  };
+  T.SphereGeometry = class extends TH.SphereGeometry {
+    constructor(r, ws, hs, ps, pl, ts, tl) {
+      super(r, lod.on && ws != null ? fewer(lod, ws, 8) : ws, lod.on && hs != null ? fewer(lod, hs, 5) : hs, ps, pl, ts, tl);
+    }
+  };
+  T.TorusGeometry = class extends TH.TorusGeometry {
+    constructor(r, tube, rs, ts, arc) {
+      super(r, tube, lod.on && rs != null ? fewer(lod, rs, 4) : rs, lod.on && ts != null ? fewer(lod, ts, 8) : ts, arc);
+    }
+  };
+  T.LatheGeometry = class extends TH.LatheGeometry {
+    constructor(pts, seg, a, b) {
+      super(pts, lod.on && seg != null ? fewer(lod, seg, 10) : seg, a, b);
+    }
+  };
+  T.TubeGeometry = class extends TH.TubeGeometry {
+    constructor(path, ts, r, rs, closed) {
+      if (lod.on) {
+        let len = 1;
+        try {
+          len = path.getLength();
+        } catch (e) {
+        }
+        ts = Math.max(6, Math.min(ts == null ? 64 : ts, Math.ceil(len / 0.14)));
+        rs = r < 0.025 ? 3 : Math.max(4, fewer(lod, rs == null ? 8 : rs, 4));
+      }
+      super(path, ts, r, rs, closed);
+    }
+  };
+  T.ExtrudeGeometry = class extends TH.ExtrudeGeometry {
+    constructor(shape, o) {
+      if (lod.on && o) {
+        o = Object.assign({}, o);
+        if (o.curveSegments) o.curveSegments = fewer(lod, o.curveSegments, 5);
+        if (o.bevelSegments) o.bevelSegments = Math.max(1, Math.round(o.bevelSegments * 0.5));
+      }
+      super(shape, o);
+    }
+  };
+  T.CircleGeometry = class extends TH.CircleGeometry {
+    constructor(r, seg, a, b) {
+      super(r, lod.on && seg != null ? fewer(lod, seg, 8) : seg, a, b);
+    }
+  };
+  T.RingGeometry = class extends TH.RingGeometry {
+    constructor(a, b, ts, ps, c, d) {
+      super(a, b, lod.on && ts != null ? fewer(lod, ts, 8) : ts, ps, c, d);
+    }
+  };
+  return T;
+}
+var INTERIOR_FUNCTIONS = ["interior", "engineBay", "seat", "dashboard", "steeringWheel", "yoke", "busRows"];
+function installLod(kit) {
+  const lod = kit.lod;
+  const meshesOf = (c) => {
+    const set = /* @__PURE__ */ new Set();
+    c.vehicle.traverse((o) => {
+      if (o.isMesh) set.add(o);
+    });
+    return set;
+  };
+  for (const name of INTERIOR_FUNCTIONS) {
+    const original = kit[name];
+    if (typeof original !== "function") continue;
+    kit[name] = function(...args) {
+      const c = args[0];
+      if (!lod.on || !c || !c.vehicle) return original.apply(this, args);
+      const before = meshesOf(c);
+      const result = original.apply(this, args);
+      c.vehicle.traverse((o) => {
+        if (o.isMesh && !before.has(o)) o.userData.skipLite = true;
+      });
+      return result;
+    };
+  }
+  kit.lodHiddenMaterials = function() {
+    const materials = kit.materials;
+    return new Set(lod.hiddenMaterials.map((name) => materials[name]).filter(Boolean));
+  };
+}
+
+// src/damageables.ts
+var defaultDamageableKinds = {
+  door: { material: "metal", part: "door" },
+  hood: { material: "metal", part: "hood" },
+  lid: { material: "metal", part: "lid" },
+  bumper: { material: "metal", part: "bumper" },
+  glass: { material: "glass", part: "window" },
+  "glass:windshield": { material: "glass", part: "windshield" },
+  light: { material: "glass", part: "headlight" },
+  "light:taillight": { material: "glass", part: "taillight" },
+  wheel: { material: "rubber", part: "wheel" },
+  "internal:fuel_tank": { material: "fuel", part: "fuel_tank" }
+};
+function installDamageables(kit) {
+  const THREE = kit.THREE;
+  kit.damageableKinds = { ...defaultDamageableKinds };
+  const kindOf2 = (zone) => {
+    const kinds = kit.damageableKinds;
+    if (zone.type === "internal") return zone.sub ? kinds[`internal:${zone.sub}`] || null : null;
+    return kinds[`${zone.type}:${zone.fxKey}`] || kinds[zone.type] || null;
+  };
+  kit.damageables = function(c, matrix) {
+    const out = [];
+    for (const zone of c.zones || []) {
+      const kind = kindOf2(zone);
+      if (!kind || !zone.box) continue;
+      const b = zone.box;
+      const box = new THREE.Box3(new THREE.Vector3(b.x0, b.y0, b.z0), new THREE.Vector3(b.x1, b.y1, b.z1));
+      if (matrix) box.applyMatrix4(matrix);
+      out.push({ material: kind.material, zone: zone.id, part: kind.part, side: zone.side === 0 ? "center" : zone.side < 0 ? "left" : "right", box });
+    }
+    return out;
+  };
+}
+
 // src/kit.ts
 function createVehicleKit(options) {
   const opts = options || {};
-  const THREE = opts.THREE;
-  if (!THREE || !THREE.Vector3) throw new Error("createVehicleKit: options.THREE (the three.js namespace) is required");
+  if (!opts.THREE || !opts.THREE.Vector3) throw new Error("createVehicleKit: options.THREE (the three.js namespace) is required");
+  const lod = createLod(opts.lod);
+  const THREE = wrapThreeForLod(opts.THREE, lod);
   const strings = resolveStrings(opts.locale);
   const t = createTranslate(strings);
   const doc = opts.document || (typeof document !== "undefined" ? document : void 0);
   const kit = {
     THREE,
+    lod,
     V3: THREE.Vector3,
     PI: Math.PI,
     document: doc,
@@ -9836,6 +9993,8 @@ function createVehicleKit(options) {
   installZoneApply(kit);
   installScenarios(kit);
   installUi(kit);
+  installLod(kit);
+  installDamageables(kit);
   const I = kit._;
   const HOOKS = {};
   kit.on = function(ev, fn) {
@@ -9930,9 +10089,18 @@ function createVehicleKit(options) {
     }
   }
   kit.defaultDamage = defaultDamage;
-  kit.build = function(key, state, zoneState) {
+  kit.build = function(key, state, zoneState, options2) {
     const spec = kit.find(key);
     if (!spec) throw new Error("Unknown vehicle: " + key);
+    const lodBefore = lod.on;
+    if (options2 && options2.lod != null) lod.on = !!options2.lod;
+    try {
+      return buildVehicle(spec, key, state, zoneState);
+    } finally {
+      lod.on = lodBefore;
+    }
+  };
+  function buildVehicle(spec, key, state, zoneState) {
     const st = state || "intact";
     const seedKey = spec.seedKey || key;
     const c = new kit.BuildContext(st, strHash(seedKey + (LEGACY_STATES[st] || st)));
@@ -9981,7 +10149,7 @@ function createVehicleKit(options) {
       if (o.isMesh && !(o.material && o.material.transparent)) o.receiveShadow = true;
     });
     return c;
-  };
+  }
   kit.dispose = function(c) {
     const shared = Object.values(I.PARTICLE_GEOMETRIES);
     c.root.traverse(function(o) {
@@ -9998,8 +10166,9 @@ function createVehicleKit(options) {
     assignDeep(strings, resolveStrings(opts.locale));
     return kit;
   };
-  const { THREE: _three, locale: _locale, document: _document, plugins, ...config } = opts;
+  const { THREE: _three, lod: _lod, locale: _locale, document: _document, plugins, ...config } = opts;
   void _three;
+  void _lod;
   void _locale;
   void _document;
   kit.configure(config);
@@ -11953,7 +12122,7 @@ function createVehicleDestructible(kit, vehicleCtx, options = {}) {
 // src/destructible/item.ts
 function buildVehicleItem(kit, key, options = {}) {
   const THREE = kit.THREE;
-  const vehicle = kit.build(key, options.state ?? "intact");
+  const vehicle = options.lod ? kit.build(key, options.state ?? "intact", void 0, { lod: true }) : kit.build(key, options.state ?? "intact");
   const m = vehicle.meta;
   const root = new THREE.Group();
   root.name = key;
@@ -11973,9 +12142,12 @@ export {
   buildVehicleItem,
   buildVehicleModel,
   clamp,
+  createLod,
   createTranslate,
   createVehicleDestructible,
   createVehicleKit,
+  defaultDamageableKinds,
+  defaultLodSettings,
   format,
   hash,
   legacyGlassId,
@@ -11987,6 +12159,7 @@ export {
   resolveStrings,
   rng,
   smooth,
-  strHash
+  strHash,
+  wrapThreeForLod
 };
 //# sourceMappingURL=index.js.map