@adatechnology/game-vehicles 0.1.12 → 0.2.0

package/README.md

@@ -266,3 +266,7 @@ scene.add(c.root)
 ### Contrato de destruição
 
 `createVehicleDestructible(kit, c, opções)` faz um veículo construído seguir o `DestructibleImpl` de `@adatechnology/game-contracts`: cada zona de dano vira uma peça com material, as peças mecânicas (bateria, alternador, câmbio, freios, direção, amortecedores, pneus, retrovisores, engate) são acrescentadas, as juntas (dobradiça, parafuso, solda) se desfazem por desgaste ou com a chave inglesa, e as peças saem do veículo e caem. `status()` diz o que a mecânica faz (freios, direção, bateria, câmbio). Os nomes em português estão em `locales/pt-BR.json` (`mechanics.*`).
+
+## Light mode and damageable parts
+
+`createVehicleKit({ lod })` takes the settings of the light mode (`defaultLodSettings`: every number can be overridden). `kit.build(key, state, zones, { lod: true })` builds the same vehicle with fewer triangles (rounded boxes with one ring, coarser lofts, grilles and generators, interiors tagged `userData.skipLite`) and puts the switch back; with it off nothing changes. `kit.damageables(c, matrix?)` lists the metal, glass, rubber and fuel parts of a built vehicle as `Box3` boxes (`kit.damageableKinds` maps zone types to parts and can be extended).

package/dist/index.d.ts

@@ -1,5 +1,59 @@
 import { ToolKind, JointKind, Vec3, MaterialId, DestructibleImpl, AnimationClipSpec } from '@adatechnology/game-contracts';
 
+/**
+ * Light mode ("lite"): the same vehicles with fewer triangles, for a whole street of them. Port of the `[LOD]` hooks of the team's Frota Leve
+ * (frota-leve.js lines 21-65, 232-257, 1205-1221, 14155-14170). Every number is a setting; with `on` false nothing changes, so every golden
+ * of the full-detail build stays byte for byte the same.
+ */
+
+interface LodSettings {
+    /** Light mode is active for the builds that run now. Set by `kit.build(key, state, zones, { lod: true })`. */
+    on: boolean;
+    /** Fraction of the segments three's own generators keep (cylinders, spheres, tori, lathes, tubes, extrusions, circles, rings). */
+    segmentFraction: number;
+    /** Rounding rings of a rounded box (the full build uses 3). */
+    roundingRings: number;
+    /** Multiplier of the maximum edge length when subdividing a mesh (bigger triangles). */
+    subdivisionFactor: number;
+    /** A box with an edge under this, or a rounding radius under 1.2 cm, is drawn as a plain 12-triangle box. */
+    flatBoxEdge: number;
+    /** Fewest segments of a superellipse loft. */
+    minLoftSegments: number;
+    /** Fraction of a loft's segments. */
+    loftSegmentFraction: number;
+    /** Fewest stations of a resampled loft. */
+    minStations: number;
+    /** Fraction of the stations of a resampled loft. */
+    stationFraction: number;
+    /** Multiplier of the grid cell size of grilles and side grilles. */
+    gridFactor: number;
+    /** Materials (by name in `kit.materials`) whose meshes are never seen from outside and are left out in light mode. */
+    hiddenMaterials: readonly string[];
+}
+declare const defaultLodSettings: LodSettings;
+/** The settings the kit starts with: the defaults, overridden by the options. */
+declare function createLod(options?: Partial<LodSettings>): LodSettings;
+/**
+ * A copy of the three.js namespace whose geometry generators take fewer segments while `lod.on` is true (and whose canvas textures come out in
+ * sRGB when three has colour management). With `lod.on` false every generator passes its arguments through untouched.
+ */
+declare function wrapThreeForLod(TH: any, lod: LodSettings): any;
+
+/**
+ * Damageable parts: what a bullet, a bat or a crash can hurt on a built vehicle, as boxes. Port of `coletarDanificaveis` and `tipoDaZona`
+ * (frota-leve.js 14391-14405), driven by the zones the kit already derives, so it works for any vehicle of any pack.
+ */
+
+type DamageableMaterial = 'metal' | 'glass' | 'rubber' | 'fuel';
+type DamageableSide = 'center' | 'left' | 'right';
+/** What a zone is, by type: the material it is made of and the part name a game shows. */
+interface DamageableKind {
+    material: DamageableMaterial;
+    part: string;
+}
+/** Zone type (and, for some, `fxKey` or `sub`) to material and part. A game replaces or adds entries with `kit.damageableKinds`. */
+declare const defaultDamageableKinds: Record<string, DamageableKind>;
+
 var plate = {
 	band: "BRAZIL"
 };
@@ -487,9 +541,25 @@ interface Plugin {
     configure?: KitConfiguration;
     install?(kit: VehicleKit): void;
 }
+interface BuildOptions {
+    /** Build this vehicle in light mode (fewer triangles; interiors tagged `skipLite`). */
+    lod?: boolean;
+}
+interface Damageable {
+    material: DamageableMaterial;
+    /** Id of the zone. */
+    zone: string;
+    /** `door`, `hood`, `lid`, `bumper`, `window`, `windshield`, `headlight`, `taillight`, `wheel`, `fuel_tank`. */
+    part: string;
+    side: DamageableSide;
+    /** A `THREE.Box3`. */
+    box: ThreeObject;
+}
 interface VehicleKitOptions extends KitConfiguration {
     /** The three.js namespace (`import * as THREE from 'three'` or `window.THREE`). */
     THREE: any;
+    /** Light mode settings (every number of `defaultLodSettings` can be overridden). */
+    lod?: Partial<LodSettings>;
     /** A registered locale code (`'en'`, `'pt-BR'`), or a partial string table overriding English. Default `'en'`. */
     locale?: string | PartialLocaleStrings;
     /** Document used for canvas textures and the UI. Defaults to the global `document`. */
@@ -552,6 +622,10 @@ interface KitInternals {
 type Builder = (...args: any[]) => any;
 interface VehicleKit {
     readonly THREE: any;
+    /** The light mode settings (live: change a number and the next build uses it). */
+    readonly lod: LodSettings;
+    /** Zone type to material and part of `damageables`; add or replace entries. */
+    readonly damageableKinds: Record<string, DamageableKind>;
     /** Translated strings in use. */
     readonly strings: LocaleStrings;
     /** Looks up a locale key (`'zones.hood'`) and fills variables. */
@@ -588,7 +662,9 @@ interface VehicleKit {
     defineFluid(key: string, def: FluidDefinition): FluidDefinition;
     on(event: string, fn: (...args: any[]) => void): VehicleKit;
     hook(event: string, ...args: any[]): void;
-    build(key: string, state?: BuildState, zoneState?: Partial<ZoneState>): VehicleContext;
+    build(key: string, state?: BuildState, zoneState?: Partial<ZoneState>, options?: BuildOptions): VehicleContext;
+    /** The damageable parts of a built vehicle as boxes (optionally in the frame of `matrix`). */
+    damageables(c: VehicleContext, matrix?: ThreeObject): Damageable[];
     dispose(c: VehicleContext): void;
     /** Advances particles, fluids, hood, blast and rollover animations by `dt` seconds. */
     tick(c: VehicleContext, dt: number): void;
@@ -807,6 +883,8 @@ declare function createVehicleDestructible(kit: VehicleKit, vehicleCtx: VehicleC
 
 interface VehicleItemOptions {
     state?: BuildState;
+    /** Build in the light mode of the kit (`kit.lod`): fewer segments and no interior, for crowds and for budgets. Default off. */
+    lod?: boolean;
 }
 interface VehicleItem {
     /** Add this to the scene: origin at the centre of the footprint on the floor, front facing +z. */
@@ -821,4 +899,4 @@ interface VehicleItem {
  */
 declare function buildVehicleItem(kit: VehicleKit, key: string, options?: VehicleItemOptions): VehicleItem;
 
-export { type Band, type BandId, type BandIndex, type BandOverride, type BuildFunction, type BuildState, type DamageMapOptions, type DamageZone, type ExplodeOptions, type FlagEffect, type FluidDefinition, type ImpactOptions, JOINT_RULES, type JointDef, type KitConfiguration, type KitInternals, type KitTexts, LEGACY_STATES, LEGACY_ZONE_IDS, type LocalBox, type LocaleStrings, type OverallHealth, type PartDef, type PartLabel, type PartRole, type PartialLocaleStrings, type Plugin, type ResolvedConfiguration, SEED_SALTS, type ScenarioContext, type ScenarioDefinition, type ScenarioResult, type SplatOptions, type ThreeObject, type ThreeVector, type Translate, type UiHelpers, type VehicleContext, type VehicleDestructible, type VehicleDestructibleOptions, type VehicleItem, type VehicleItemOptions, type VehicleKit, type VehicleKitOptions, type VehicleMeta, type VehicleModel, type VehiclePart, type VehicleSpec, type VehicleStatus, type ZoneDamageEntry, type ZoneEffect, type ZoneState, buildVehicleItem, buildVehicleModel, clamp, createTranslate, createVehicleDestructible, createVehicleKit, format, hash, legacyGlassId, legacyLightId, legacyZoneId, listLocales, registerLegacySeeds, registerLocale, resolveStrings, rng, smooth, strHash };
+export { type Band, type BandId, type BandIndex, type BandOverride, type BuildFunction, type BuildOptions, type BuildState, type DamageMapOptions, type DamageZone, type Damageable, type DamageableKind, type DamageableMaterial, type DamageableSide, type ExplodeOptions, type FlagEffect, type FluidDefinition, type ImpactOptions, JOINT_RULES, type JointDef, type KitConfiguration, type KitInternals, type KitTexts, LEGACY_STATES, LEGACY_ZONE_IDS, type LocalBox, type LocaleStrings, type LodSettings, type OverallHealth, type PartDef, type PartLabel, type PartRole, type PartialLocaleStrings, type Plugin, type ResolvedConfiguration, SEED_SALTS, type ScenarioContext, type ScenarioDefinition, type ScenarioResult, type SplatOptions, type ThreeObject, type ThreeVector, type Translate, type UiHelpers, type VehicleContext, type VehicleDestructible, type VehicleDestructibleOptions, type VehicleItem, type VehicleItemOptions, type VehicleKit, type VehicleKitOptions, type VehicleMeta, type VehicleModel, type VehiclePart, type VehicleSpec, type VehicleStatus, type ZoneDamageEntry, type ZoneEffect, type ZoneState, buildVehicleItem, buildVehicleModel, clamp, createLod, createTranslate, createVehicleDestructible, createVehicleKit, defaultDamageableKinds, defaultLodSettings, format, hash, legacyGlassId, legacyLightId, legacyZoneId, listLocales, registerLegacySeeds, registerLocale, resolveStrings, rng, smooth, strHash, wrapThreeForLod };

package/dist/index.global.js

@@ -30,9 +30,12 @@ var GameVehicles = (() => {
     buildVehicleItem: () => buildVehicleItem,
     buildVehicleModel: () => buildVehicleModel,
     clamp: () => clamp,
+    createLod: () => createLod,
     createTranslate: () => createTranslate,
     createVehicleDestructible: () => createVehicleDestructible,
     createVehicleKit: () => createVehicleKit,
+    defaultDamageableKinds: () => defaultDamageableKinds,
+    defaultLodSettings: () => defaultLodSettings,
     format: () => format,
     hash: () => hash,
     legacyGlassId: () => legacyGlassId,
@@ -44,7 +47,8 @@ var GameVehicles = (() => {
     resolveStrings: () => resolveStrings,
     rng: () => rng,
     smooth: () => smooth,
-    strHash: () => strHash
+    strHash: () => strHash,
+    wrapThreeForLod: () => wrapThreeForLod
   });
 
   // src/locales/en.json
@@ -882,9 +886,11 @@ var GameVehicles = (() => {
     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;
@@ -929,6 +935,7 @@ var GameVehicles = (() => {
       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 = [];
@@ -1658,6 +1665,7 @@ var GameVehicles = (() => {
     const V3 = THREE.Vector3;
     const PI = Math.PI;
     const I = kit._;
+    const lod = kit.lod;
     const { crease } = I;
     function makeWarp(o) {
       function sec(y) {
@@ -1755,6 +1763,7 @@ var GameVehicles = (() => {
       });
     }
     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) {
@@ -1786,6 +1795,7 @@ var GameVehicles = (() => {
     }
     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 = [];
@@ -9800,16 +9810,167 @@ var GameVehicles = (() => {
     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,
@@ -9881,6 +10042,8 @@ var GameVehicles = (() => {
     installZoneApply(kit);
     installScenarios(kit);
     installUi(kit);
+    installLod(kit);
+    installDamageables(kit);
     const I = kit._;
     const HOOKS = {};
     kit.on = function(ev, fn) {
@@ -9975,9 +10138,18 @@ var GameVehicles = (() => {
       }
     }
     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)));
@@ -10026,7 +10198,7 @@ var GameVehicles = (() => {
         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) {
@@ -10043,8 +10215,9 @@ var GameVehicles = (() => {
       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);
@@ -11998,7 +12171,7 @@ var GameVehicles = (() => {
   // 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;