@adatechnology/game-destruction-three 0.12.1 → 0.13.0

package/dist/index.js

@@ -3,7 +3,7 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/renderer.ts
-import { blastShove } from "@adatechnology/game-contracts";
+import { DEFERRED_QUEUE_ID, blastShove, warnOnce } from "@adatechnology/game-contracts";
 import { createVfx, effectForEvent, EVENT_EFFECTS_MAP } from "@adatechnology/game-vfx";
 import { createVfxRenderer } from "@adatechnology/game-vfx-three";
 
@@ -92,6 +92,7 @@ var SHEET_SWAY = 3;
 var BIG_LENGTH = 0.2;
 var BIG_WIDTH = 0.03;
 var FRAGMENT_SEED = 1374496523;
+var SHARD_SHAPES = 6;
 var isBig = (size) => {
   const [, middle, longest] = [...size].sort((a, b) => a - b);
   return longest >= BIG_LENGTH && middle >= BIG_WIDTH;
@@ -141,7 +142,7 @@ var FragmentSystem = class {
     return m;
   }
   shardGeometry(seed) {
-    const idx = seed % 6;
+    const idx = seed % SHARD_SHAPES;
     let g = this.shardGeos[idx];
     if (!g) {
       const r = createRng(1e3 + idx);
@@ -162,17 +163,32 @@ var FragmentSystem = class {
     }
     return g;
   }
+  markParts() {
+    this.markGeometry ?? (this.markGeometry = new this.THREE.CircleGeometry(1, 10));
+    this.markMaterial ?? (this.markMaterial = new this.THREE.MeshBasicMaterial({ color: 723465, depthWrite: false, polygonOffset: true, polygonOffsetFactor: -4, polygonOffsetUnits: -4 }));
+    return { geometry: this.markGeometry, material: this.markMaterial };
+  }
+  /**
+   * Meshes, never put in a scene by this class, that draw every shared piece of a fragment once: the box, the six shards, the bullet-hole disc, and the opaque and
+   * glass materials. A host draws them at load so the first blast does not upload these buffers in the middle of a frame.
+   */
+  warmMeshes() {
+    const opaque = this.materialFor("warm", 8421504, false);
+    const glass = this.materialFor("warm", 8421504, true);
+    const geometries = [this.box, ...Array.from({ length: SHARD_SHAPES }, (_, index) => this.shardGeometry(index))];
+    const { geometry, material } = this.markParts();
+    return [...geometries.flatMap((shared) => [new this.THREE.Mesh(shared, opaque), new this.THREE.Mesh(shared, glass)]), new this.THREE.Mesh(geometry, material)];
+  }
   /**
    * Bullet holes that stay on a fragment (`Fragment.marks`): dark discs that are children of its mesh, so they fall, spin and settle with it. The mesh is
    * a unit box scaled to the fragment, so each disc is scaled back; exact for a mark on a face, which is where a bullet hole is.
    */
   addMarks(mesh, f) {
     if (!f.marks?.length) return;
-    this.markGeometry ?? (this.markGeometry = new this.THREE.CircleGeometry(1, 10));
-    this.markMaterial ?? (this.markMaterial = new this.THREE.MeshBasicMaterial({ color: 723465, depthWrite: false, polygonOffset: true, polygonOffsetFactor: -4, polygonOffsetUnits: -4 }));
+    const { geometry, material } = this.markParts();
     const sc = mesh.scale;
     for (const mark of f.marks) {
-      const disc = new this.THREE.Mesh(this.markGeometry, this.markMaterial);
+      const disc = new this.THREE.Mesh(geometry, material);
       const radius = Math.max(4e-3, mark.diameter) * 0.6;
       const n = this.v.set(mark.normal[0], mark.normal[1], mark.normal[2]).normalize();
       disc.position.set(mark.point[0] / sc.x + n.x * 2e-3 / sc.x, mark.point[1] / sc.y + n.y * 2e-3 / sc.y, mark.point[2] / sc.z + n.z * 2e-3 / sc.z);
@@ -1517,6 +1533,7 @@ var Visuals = class {
     this.b = tmpV(THREE);
     this.m4 = new THREE.Matrix4();
     this.ray = new THREE.Raycaster();
+    this.ray.layers.enableAll();
     this.box = new THREE.Box3();
     this.t = tmpV(THREE);
     this.lbox = new THREE.Box3();
@@ -2507,8 +2524,26 @@ var Renderer = class {
     __publicField(this, "queue", []);
     /** Presentation work an event left for later frames (fragments still to spawn, loose groups still to split), run in order within the frame budget. */
     __publicField(this, "slices", []);
-    /** When the work of this frame must stop; `Infinity` outside `drainQueue`, where a call finishes what it started. */
+    /** When the work of this frame must stop; `Infinity` outside a drain, where a call finishes what it started. */
     __publicField(this, "sliceDeadline", Infinity);
+    /** The clock the drain reads; a budget lends its own while it runs the queue. */
+    __publicField(this, "drainClock", () => performance.now());
+    /** true once a frame budget owns the draining: `update` no longer drains by itself. */
+    __publicField(this, "attached", false);
+    __publicField(this, "eventQueue", {
+      id: DEFERRED_QUEUE_ID.DESTRUCTION_EVENTS,
+      pending: () => this.queue.length + this.slices.length,
+      run: (deadline, clock) => this.runBudgeted(deadline, clock),
+      flush: () => {
+        for (let guard = 0; guard < 16 && this.queue.length + this.slices.length > 0; guard++) this.runBudgeted(Infinity, () => 0);
+      },
+      attach: () => {
+        this.attached = true;
+      },
+      detach: () => {
+        this.attached = false;
+      }
+    });
     __publicField(this, "unsubscribe");
     __publicField(this, "visuals");
     __publicField(this, "fragments");
@@ -2554,6 +2589,7 @@ var Renderer = class {
     const maxParticles = Math.max(8, Math.floor((o.maxParticles ?? 2500) * (this.low ? 0.5 : 1)));
     this.visuals = new Visuals(THREE, this.low, 600);
     this.ground = new GroundSpots(THREE, o.scene, this.groundAt, 48);
+    if (!o.vfx) warnOnce("game-destruction-three.own-effects-world", "game-destruction-three made an effects world of its own because the host lent none (options.vfx); pass the host effects so the effects share one budget");
     this.vfx = o.vfx ?? createVfx({ profile: this.quality, gravity: this.gravity, groundAt: this.groundAt, sprites: { capacity: maxParticles, density: this.low ? 0.6 : 1 } });
     this.ownVfx = o.vfx ? void 0 : createVfxRenderer(THREE, { scene: o.scene, camera: o.camera ?? new THREE.PerspectiveCamera(), vfx: this.vfx, pointScale: o.pointScale ?? 700 });
     this.stopLanding = this.vfx.onLand(this.owner, (x, _y, z, color, tag) => {
@@ -2791,7 +2827,7 @@ var Renderer = class {
     if (this.disposed) return;
     dt = clamp(dt, 0, 0.1);
     this.time += dt;
-    this.drainQueue();
+    if (!this.attached) this.drainQueue();
     for (const b of this.bounds.values()) b.onFrame?.(dt);
     for (const b of this.bounds.values()) if (b.soilNode && this.world.state(b.id)?.soil?.status === "yielding") this.onSettle(b.id);
     this.updateActive(dt);
@@ -2802,36 +2838,50 @@ var Renderer = class {
     this.ownVfx?.update(dt);
     this.syncTransforms();
   }
+  deferredQueue() {
+    return this.eventQueue;
+  }
   drainQueue() {
+    this.runBudgeted(performance.now() + this.eventBudgetMs, () => performance.now());
+  }
+  /** Applies the waiting events in order until the deadline, after the slices earlier events left; always at least one unit when something waits. Returns the units run. */
+  runBudgeted(deadline, clock) {
     const batch = this.queue.splice(0, this.queue.length);
-    const deadline = performance.now() + this.eventBudgetMs;
+    const outerClock = this.drainClock;
+    this.drainClock = clock;
     this.sliceDeadline = deadline;
+    let ran = 0;
     try {
-      this.runSlices(deadline);
+      ran = this.runSlices(deadline);
       for (let i = 0; i < batch.length; i++) {
-        if (i > 0 && performance.now() >= deadline) {
+        if ((i > 0 || ran > 0 && this.attached) && clock() >= deadline) {
           this.queue.unshift(...batch.slice(i));
-          return;
+          return ran;
         }
         try {
           this.apply(batch[i]);
         } catch (err) {
           if (typeof console !== "undefined") console.error("game-destruction-three: failed to apply", batch[i].type, err);
         }
+        ran++;
       }
     } finally {
       this.sliceDeadline = Infinity;
+      this.drainClock = outerClock;
     }
+    return ran;
   }
   /** Runs the work left by earlier frames until the deadline; at least one piece per frame, so it always finishes. */
   runSlices(deadline) {
-    for (let ran = 0; this.slices.length > 0 && (ran === 0 || performance.now() < deadline); ran++) {
+    let ran = 0;
+    for (; this.slices.length > 0 && (ran === 0 || this.drainClock() < deadline); ran++) {
       try {
         this.slices.shift()();
       } catch (err) {
         if (typeof console !== "undefined") console.error("game-destruction-three: failed to run deferred work", err);
       }
     }
+    return ran;
   }
   /**
    * The ground under an object settled or tilted: its parts are drawn under a node with the soil's offset (`ObjectState.soil.offset`), so the host's
@@ -3389,7 +3439,7 @@ var Renderer = class {
     const maxAlive = this.low ? Math.floor(this.maxFragments / 2) : this.maxFragments;
     const step = this.low ? 2 : 1;
     for (let i = from; i < ev.fragments.length; i += step) {
-      if (i - from >= MIN_FRAGMENTS_PER_SLICE * step && performance.now() >= this.sliceDeadline) {
+      if (i - from >= MIN_FRAGMENTS_PER_SLICE * step && this.drainClock() >= this.sliceDeadline) {
         this.slices.push(() => this.spawnFragments(ev, i, look));
         return;
       }
@@ -3413,7 +3463,7 @@ var Renderer = class {
     if (!st || st.groups.length < 2) return;
     const loose = st.groups.length - 1;
     for (let i = 0; i < loose; i++) {
-      if (i > 0 && performance.now() >= this.sliceDeadline) {
+      if (i > 0 && this.drainClock() >= this.sliceDeadline) {
         this.slices.push(() => {
           this.staticDirty.add(objectId);
           this.splitLoose(objectId);
@@ -3792,6 +3842,7 @@ var Renderer = class {
     const materials = [kit.discMaterial().clone(), kit.patchMaterial(8421504).clone(), kit.lineMaterial(0).clone()];
     const group = new T.Group();
     group.add(new T.Mesh(kit.discGeometry(), materials[0]), new T.Mesh(kit.discGeometry(), materials[1]), new T.LineSegments(geometry, materials[2]));
+    group.add(...this.fragments.warmMeshes());
     for (const probe of group.children) probe.frustumCulled = false;
     this.warmProbes = { group, geometry, materials };
     return { group, dispose: () => {