@woosh/meep-engine 3.4.0 → 3.5.0

package/package.json

@@ -6,7 +6,7 @@
   "description": "Pure JavaScript game engine. Fully featured and production ready.",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.4.0",
+  "version": "3.5.0",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/engine/Engine.js

@@ -10,7 +10,7 @@ import ObservedBoolean from "../core/model/ObservedBoolean.js";
 import ConcurrentExecutor from '../core/process/executor/ConcurrentExecutor.js';
 import EmptyView from "../view/elements/EmptyView.js";
 import { ViewStack } from "../view/elements/navigation/ViewStack.js";
-import { WebGLContextFailureView } from "../view/graphics/WebGLContextFailureView.js";
+import { GraphicsContextFailureView } from "../view/graphics/GraphicsContextFailureView.js";
 
 import { AssetManager } from './asset/AssetManager.js';
 import { AssetPreloader } from "./asset/preloader/AssetPreloader.js";
@@ -416,7 +416,7 @@ class Engine {
         // Application state is left intact, which keeps a save-on-failure handler viable.
         this.#pause_simulation_for_context_loss();
 
-        this.viewStack.addChild(new WebGLContextFailureView());
+        this.viewStack.addChild(new GraphicsContextFailureView());
     }
 
     #initialize_audio() {

package/src/engine/graphics/CONTEXT_LOSS_RECOVERY_PLAN.md

@@ -203,7 +203,7 @@ already paused is left alone, and never resumed by us — hence the new `Ticker.
 accessors, since `pause()`/`resume()` throw when the loop is not cycling.
 
 On `Failed`: the simulation is paused, application state is left intact (so a save-on-failure handler
-stays viable), and `WebGLContextFailureView` explains the situation with a reload button, instead of
+stays viable), and `GraphicsContextFailureView` explains the situation with a reload button, instead of
 leaving the player looking at a black canvas.
 
 ---

package/src/engine/graphics3/GraphicsEngine3.d.ts

@@ -31,6 +31,12 @@ export class GraphicsEngine3 {
      * @returns {boolean}
      */
     get isGraphicsEngine(): boolean;
+    /**
+     * Danger zone.
+     * Be careful with what you do, with great Renderer comes great responsibility.
+     * @returns {Renderer|null}
+     */
+    get renderer(): Renderer;
     /**
      * The camera, in the shape the engine's existing consumers read it — `projectionMatrix` and
      * `matrixWorldInverse`, which is what `HeadsUpDisplaySystem` multiplies together. The real
@@ -317,6 +323,7 @@ export class GraphicsEngine3 {
     render(time_delta_seconds?: number): boolean;
     #private;
 }
+import { Renderer } from "../../shade/renderer/Renderer.js";
 import { ShadeCameraAdapter } from "./ShadeCameraAdapter.js";
 import Signal from "../../core/events/signal/Signal.js";
 import Vector1 from "../../core/geom/Vector1.js";

package/src/engine/graphics3/GraphicsEngine3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GraphicsEngine3.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GraphicsEngine3.js"],"names":[],"mappings":"AAkDA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IACI;;;;;OAKG;IACH,gCAEC;IAkEG;;;;;;OAMG;IACH,QAFU,kBAAkB,CAEsB;IAElD;QACI;;;;;;;;WAQG;mBADO,MAAM;QAIhB;;;;;WAKG;oBADO,MAAM;QAIhB;;;;WAIG;qBADO,MAAM;QAIhB;;;;;;;WAOG;;QAGH;;;;;WAKG;;MAEN;IAED;;OAEG;IACH,YAFU,OAAO,CAEe;IAEhC;;;;;OAKG;IACH,4BAFU,OAAO,CAEyB;IAE1C;;;;;;OAMG;IACH,UAFU,SAAS,CAEY;IAG/B;;OAEG;IACH,YAFU,iBAAiB,GAAC,IAAI,CAEV;IAEtB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;OAEG;IACH,YAFU,MAAM,CAEG;IAoBvB;;;;;;;;;;;;OAYG;IACH,mDAEC;IAED;;;;;;;;OAQG;IACH,iBAFW,KAAK,QAoBf;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,iDAOC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,2DAWC;IAED;;;;;;;;;;OAUG;IACH,oCAFa,MAAM,CAclB;IAED;;;;;;OAMG;IACH,8CAFa,OAAO,CAgBnB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,qBALW,KAAK,GACH,kBAAgB,IAAI,CAehC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,yBARW,KAAK,yBAEL,MAAM,UACN,MAAM,GACJ,QAAQ,SAAS,CAAC,CAwD9B;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;;;;;;OAUG;IACH,SAFa,QAAQ,IAAI,CAAC,CA4DzB;IAED;;;;;OAKG;IACH,aAiBC;IASD;;;;;;;;OAQG;IACH,8BAHW,OAAO,UAAQ,UACf,OAAO,UAAQ,QAQzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,yBALW,MAAM,KACN,MAAM,6CAMhB;IAED;;;;;;;OAOG;IACH,mBA0BC;IAED;;;;;OAKG;IACH,4BAHW,MAAM,GACJ,OAAO,CAoDnB;;CACJ;mCAzvBkC,yBAAyB;mBAbzC,oCAAoC;oBACnC,4BAA4B;wBACxB,4BAA4B;sBAQ9B,kCAAkC;yCAJf,kDAAkD;sBAErE,qCAAqC;0BACjC,0CAA0C"}
+{"version":3,"file":"GraphicsEngine3.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GraphicsEngine3.js"],"names":[],"mappings":"AAkDA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IACI;;;;;OAKG;IACH,gCAEC;IAUD;;;;OAIG;IACH,yBAEC;IA0DG;;;;;;OAMG;IACH,QAFU,kBAAkB,CAEsB;IAElD;QACI;;;;;;;;WAQG;mBADO,MAAM;QAIhB;;;;;WAKG;oBADO,MAAM;QAIhB;;;;WAIG;qBADO,MAAM;QAIhB;;;;;;;WAOG;;QAGH;;;;;WAKG;;MAEN;IAED;;OAEG;IACH,YAFU,OAAO,CAEe;IAEhC;;;;;OAKG;IACH,4BAFU,OAAO,CAEyB;IAE1C;;;;;;OAMG;IACH,UAFU,SAAS,CAEY;IAG/B;;OAEG;IACH,YAFU,iBAAiB,GAAC,IAAI,CAEV;IAEtB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;OAEG;IACH,YAFU,MAAM,CAEG;IAoBvB;;;;;;;;;;;;OAYG;IACH,mDAEC;IAED;;;;;;;;OAQG;IACH,iBAFW,KAAK,QAoBf;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,iDAOC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,2DAWC;IAED;;;;;;;;;;OAUG;IACH,oCAFa,MAAM,CAclB;IAED;;;;;;OAMG;IACH,8CAFa,OAAO,CAgBnB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,qBALW,KAAK,GACH,kBAAgB,IAAI,CAehC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,yBARW,KAAK,yBAEL,MAAM,UACN,MAAM,GACJ,QAAQ,SAAS,CAAC,CAwD9B;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;;;;;;OAUG;IACH,SAFa,QAAQ,IAAI,CAAC,CA4DzB;IAED;;;;;OAKG;IACH,aAiBC;IASD;;;;;;;;OAQG;IACH,8BAHW,OAAO,UAAQ,UACf,OAAO,UAAQ,QAQzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,yBALW,MAAM,KACN,MAAM,6CAMhB;IAED;;;;;;;OAOG;IACH,mBA0BC;IAED;;;;;OAKG;IACH,4BAHW,MAAM,GACJ,OAAO,CAoDnB;;CACJ;yBAxwBwB,kCAAkC;mCAMxB,yBAAyB;mBAbzC,oCAAoC;oBACnC,4BAA4B;wBACxB,4BAA4B;sBAQ9B,kCAAkC;yCAJf,kDAAkD;sBAErE,qCAAqC;0BACjC,0CAA0C"}

package/src/engine/graphics3/GraphicsEngine3.js

@@ -92,6 +92,15 @@ export class GraphicsEngine3 {
      */
     #renderer = null;
 
+    /**
+     * Danger zone.
+     * Be careful with what you do, with great Renderer comes great responsibility.
+     * @returns {Renderer|null}
+     */
+    get renderer(){
+        return this.#renderer;
+    }
+
     /**
      * Trades internal resolution for frame time — see {@link dynamic_resolution}.
      *

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.d.ts

@@ -64,11 +64,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#350@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#349@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#350@#clear_field"(fluid: FluidComponent): void;
+    static "__#349@#clear_field"(fluid: FluidComponent): void;
     /**
      * Mark every cell of `fluid` whose centre lies within `inflation` of the
      * posed shape as solid. Iteration is clipped to the shape's world AABB
@@ -80,7 +80,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#350@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#349@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
     /**
      * Write the obstacle's translation velocity onto every face of every cell
      * it voxelized — the moving-wall boundary condition. Runs AFTER the mask
@@ -100,7 +100,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#350@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#349@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
     constructor();
     dependencies: (typeof FluidObstacle)[];
     components_used: (ResourceAccessSpecification<typeof Transform> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof FluidComponent> | ResourceAccessSpecification<typeof FluidObstacle>)[];

package/src/shade/playground/skinned_blas_refit/README.md

@@ -68,36 +68,59 @@ union, and each clone at its own arena address on a uniform stride.
 ## Assets
 
 `/test_assets/Michelle.glb`, which is gitignored and unpublished — see `test_assets/README.md`.
-
-## What the floor disagreement turned out to be
-
-For a while the two images disagreed about where the floor ends: a smooth band along its far edge
-that the rasterizer drew and the tracer did not, several thousand pixels at an ordinary camera and
-growing as the camera approached the edge. It read like a hole in a tree, and it was not one.
-
-The slab was placed by writing `Node3D.transform_global`, which is **derived** — the doc comment on
-it says so. Its two consumers take placement from opposite ends: `Mesh.updateBoundsBasic` reads
-`transform_global` and publishes the result as the mesh's `meshes` row, and the GPU's `transforms`
-row carries the node's *local* TRS for the hierarchy pass to compose `node.global` from. Writing
-only the first left the second at identity, 0.208 m away:
-
-- the rasterizer multiplied positions by `node.global` and drew the slab at the geometry's own
-  origin, its far edge ten rows higher up the screen than the floor actually ends;
-- the tracer tested each ray against the *translated* published box before traversing the
-  *untranslated* geometry, so rays that would have struck the slab near its far edge were turned
-  away by a box that was not around it.
-
-Neither renderer was wrong about the data it was given. Padding the published box shrank the band
-because it widened the interval the TLAS test allows — not because anything was tangent, which is
-why a few per cent of pad did what a rounding-scale slack could not.
-
-The invariant is in `add_floor.spec.js` and needs no device: published bounds must survive
-`updateMatrices`, because that is the walk which recomputes `transform_global` from the local
-transform. `chunk_ray_query_nearest.spec.js` holds the traversal itself against closed-form slab
-arithmetic in the emulator, including the case where the instance box and the node transform
-disagree.
-
-**`?count=N` still places its dancers the old way**, so they stack at the origin rather than
-spreading over a grid. That one is self-consistent — box and transform both say "at the origin" —
-so the two renderers agree about it, and unpicking it means separating the grid offset from the
-transform the glTF gave the mesh node.
+
+## What the floor disagreement turned out to be
+
+For a while the two images disagreed about where the floor ends: a smooth band along its far edge
+that the rasterizer drew and the tracer did not, several thousand pixels at an ordinary camera and
+growing as the camera approached the edge. It read like a hole in a tree, and it was not one.
+
+The slab was placed by writing `Node3D.transform_global`, which is **derived** — the doc comment on
+it says so. Its two consumers take placement from opposite ends: `Mesh.updateBoundsBasic` reads
+`transform_global` and publishes the result as the mesh's `meshes` row, and the GPU's `transforms`
+row carries the node's *local* TRS for the hierarchy pass to compose `node.global` from. Writing
+only the first left the second at identity, 0.208 m away:
+
+- the rasterizer multiplied positions by `node.global` and drew the slab at the geometry's own
+  origin, its far edge ten rows higher up the screen than the floor actually ends;
+- the tracer tested each ray against the *translated* published box before traversing the
+  *untranslated* geometry, so rays that would have struck the slab near its far edge were turned
+  away by a box that was not around it.
+
+Neither renderer was wrong about the data it was given. Padding the published box shrank the band
+because it widened the interval the TLAS test allows — not because anything was tangent, which is
+why a few per cent of pad did what a rounding-scale slack could not.
+
+The invariant is in `add_floor.spec.js` and needs no device: published bounds must survive
+`updateMatrices`, because that is the walk which recomputes `transform_global` from the local
+transform. `chunk_ray_query_nearest.spec.js` holds the traversal itself against closed-form slab
+arithmetic in the emulator, including the case where the instance box and the node transform
+disagree.
+
+## The quieter version of the same bug: `?count=N`
+
+The dancers were placed the same way — by writing `transform_global` — and stacked at the origin
+rather than spreading over a grid. Both renderers agreed about it, so there was no picture to look
+at; the only symptom was that the characters did not go where they were put.
+
+They also could not have been fixed by copying the floor's fix, because a skinned mesh's own node
+is not its placement point at all. A skinned vertex lands at
+
+```
+mesh.global × inverse(mesh.global) × joint.global × inverse_bind × v
+```
+
+— `chunk_skin_blend_mesh_local` folds the leftmost inverse into each joint matrix and the rasterizer
+re-applies `mesh.global`, so the mesh node's transform **cancels exactly**, and
+`compute_skin_world_bounds` composes the published box out of joints without reading it either.
+Michelle's file makes the point structurally: her mesh node `Ch03` carries no local transform, the
+0.01 centimetre scale and the up-axis rotation sit on the root above it, and the joint root
+`mixamorig:Hips` is the mesh node's *sibling*. Nothing under `Ch03` drives a joint.
+
+`place_character` therefore hangs each character's roots under a fresh parent whose whole transform
+is the grid offset. That reaches the joints, leaves the file's own transform untouched below it, and
+— because the offset is a *local* transform — survives the walk that recomputes `transform_global`.
+
+`place_character.spec.js` holds the invariant the floor's cannot see: **published bounds must move
+by the offset the character was placed at.** Its negative control is the bug itself — writing either
+transform on the mesh node and watching the box not move.

package/src/shade/playground/skinned_blas_refit/place_character.d.ts

@@ -19,7 +19,8 @@
  * actually sit under.
  *
  * Michelle is the shape that makes this concrete. Her file is one root carrying the centimetre
- * scale and the Z-up rotation, with the mesh node and the joint root as *siblings* beneath it:
+ * scale and the up-axis rotation (+90° about x, the file's Z-up into the renderer's Y-up), with the
+ * mesh node and the joint root as *siblings* beneath it:
  *
  * ```
  * "Character"            R=(0.70711, 0, 0, 0.70711)  S=(0.01, 0.01, 0.01)

package/src/shade/playground/skinned_blas_refit/place_character.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"place_character.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/place_character.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,sEAJW,MAAM,KACN,MAAM,GACJ,MAAM,CA+BlB;AAED;;;;;;;;;;;;GAYG;AACH,qCALW,MAAM,SACN,MAAM,WACN,MAAM,GACJ;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,CAUlC;uBAnHsB,gCAAgC"}
+{"version":3,"file":"place_character.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/place_character.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,sEAJW,MAAM,KACN,MAAM,GACJ,MAAM,CA+BlB;AAED;;;;;;;;;;;;GAYG;AACH,qCALW,MAAM,SACN,MAAM,WACN,MAAM,GACJ;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,CAUlC;uBApHsB,gCAAgC"}

package/src/shade/playground/skinned_blas_refit/place_character.js

@@ -21,7 +21,8 @@ import { Node3D } from "../../renderer/scene/Node3D.js";
  * actually sit under.
  *
  * Michelle is the shape that makes this concrete. Her file is one root carrying the centimetre
- * scale and the Z-up rotation, with the mesh node and the joint root as *siblings* beneath it:
+ * scale and the up-axis rotation (+90° about x, the file's Z-up into the renderer's Y-up), with the
+ * mesh node and the joint root as *siblings* beneath it:
  *
  * ```
  * "Character"            R=(0.70711, 0, 0, 0.70711)  S=(0.01, 0.01, 0.01)

package/src/view/graphics/{WebGLContextFailureView.d.ts → GraphicsContextFailureView.d.ts}

@@ -6,7 +6,7 @@
  * case where the renderer is dead, which is not a good moment to depend on the localization pipeline
  * having the keys; an application that has them should pass localized strings in.
  */
-export class WebGLContextFailureView extends EmptyView {
+export class GraphicsContextFailureView extends EmptyView {
     /**
      * @param {string} [title]
      * @param {string} [text]
@@ -16,4 +16,4 @@ export class WebGLContextFailureView extends EmptyView {
     constructor({ title, text, action_label, action }?: string);
 }
 import EmptyView from "../elements/EmptyView.js";
-//# sourceMappingURL=WebGLContextFailureView.d.ts.map
+//# sourceMappingURL=GraphicsContextFailureView.d.ts.map

package/src/view/graphics/GraphicsContextFailureView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphicsContextFailureView.d.ts","sourceRoot":"","sources":["../../../../src/view/graphics/GraphicsContextFailureView.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH;IACI;;;;;OAKG;IACH,oDALW,MAAM,EA4DhB;CACJ;sBA1EqB,0BAA0B"}

package/src/view/graphics/{WebGLContextFailureView.js → GraphicsContextFailureView.js}

@@ -10,7 +10,7 @@ import LabelView from "../common/LabelView.js";
  * case where the renderer is dead, which is not a good moment to depend on the localization pipeline
  * having the keys; an application that has them should pass localized strings in.
  */
-export class WebGLContextFailureView extends EmptyView {
+export class GraphicsContextFailureView extends EmptyView {
     /**
      * @param {string} [title]
      * @param {string} [text]

package/src/core/geom/3d/aabb/aabb3_from_three_geometry.d.ts

@@ -1,7 +0,0 @@
-/**
- *
- * @param {number[]|ArrayLike<number>|Float32Array} result
- * @param {BufferGeometry} geometry
- */
-export function aabb3_from_three_geometry(result: number[] | ArrayLike<number> | Float32Array, geometry: BufferGeometry): void;
-//# sourceMappingURL=aabb3_from_three_geometry.d.ts.map

package/src/core/geom/3d/aabb/aabb3_from_three_geometry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"aabb3_from_three_geometry.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_from_three_geometry.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,kDAHW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,kCAYjD"}

package/src/core/geom/3d/aabb/aabb3_from_three_geometry.js

@@ -1,18 +0,0 @@
-import { assert } from "../../../assert.js";
-import { aabb3_from_min_max } from "./aabb3_from_min_max.js";
-
-/**
- *
- * @param {number[]|ArrayLike<number>|Float32Array} result
- * @param {BufferGeometry} geometry
- */
-export function aabb3_from_three_geometry(result, geometry) {
-    const gbb = geometry.boundingBox;
-
-    assert.notNull(gbb, 'boundingBox');
-
-    const min = gbb.min;
-    const max = gbb.max;
-
-    aabb3_from_min_max(result, min, max);
-}

package/src/core/geom/3d/aabb/aabb3_from_threejs_geometry.d.ts

@@ -1,7 +0,0 @@
-/**
- * @deprecated Renamed to {@link aabb3_from_three_geometry}. This re-export is kept for backward
- * compatibility (meep is a library; old names are public surface).
- */
-export const aabb3_from_threejs_geometry: typeof aabb3_from_three_geometry;
-import { aabb3_from_three_geometry } from "./aabb3_from_three_geometry.js";
-//# sourceMappingURL=aabb3_from_threejs_geometry.d.ts.map

package/src/core/geom/3d/aabb/aabb3_from_threejs_geometry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"aabb3_from_threejs_geometry.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_from_threejs_geometry.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,2EAAqE;0CAN3B,gCAAgC"}

package/src/core/geom/3d/aabb/aabb3_from_threejs_geometry.js

@@ -1,7 +0,0 @@
-import { aabb3_from_three_geometry } from "./aabb3_from_three_geometry.js";
-
-/**
- * @deprecated Renamed to {@link aabb3_from_three_geometry}. This re-export is kept for backward
- * compatibility (meep is a library; old names are public surface).
- */
-export const aabb3_from_threejs_geometry = aabb3_from_three_geometry;

package/src/engine/ecs/transform/copy_three_transform.d.ts

@@ -1,7 +0,0 @@
-/**
- *
- * @param {Transform} transform
- * @param {THREE.Object3D} three_object
- */
-export function copy_three_transform(transform: Transform, three_object: THREE.Object3D): void;
-//# sourceMappingURL=copy_three_transform.d.ts.map

package/src/engine/ecs/transform/copy_three_transform.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"copy_three_transform.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform/copy_three_transform.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,+FASC"}

package/src/engine/ecs/transform/copy_three_transform.js

@@ -1,15 +0,0 @@
-/**
- *
- * @param {Transform} transform
- * @param {THREE.Object3D} three_object
- */
-export function copy_three_transform(transform, three_object) {
-
-    // copy object transform
-    transform.position.copy(three_object.position);
-    transform.scale.copy(three_object.scale);
-    transform.rotation.copy(three_object.quaternion);
-
-    //
-    transform.matrix.set(three_object.matrix.elements);
-}

package/src/engine/graphics/ecs/mesh-v2/DeferredBoundsQueue.d.ts

@@ -1,48 +0,0 @@
-/**
- * Collects {@link ShadedGeometry} components whose bounding box has gone stale under
- * {@link ShadedGeometryFlags.DeferredBoundsUpdate}, until the owner of the BVH is ready
- * to take the updates.
- *
- * WHY THIS EXISTS
- *
- * A {@link Transform} signals `position`, `rotation` and `scale` separately, so one
- * logical move produces several change notifications: two when a caller sets position
- * and rotation, three when the transform is written as a matrix (which is what
- * {@link TransformAttachmentSystem} does for every entity in a hierarchy, and what
- * `Transform.copy` does). Updating bounds on each of those recomputes the same box and
- * walks the same path to the BVH root several times over. Parking the component here
- * instead collapses the batch into one update per component per flush.
- *
- * Entries are appended without a membership test; {@link ShadedGeometry} carries the
- * "already queued" bit so enqueueing stays O(1) and a component appears at most once.
- */
-export class DeferredBoundsQueue {
-    /**
-     * Number of components waiting for their bounds to be applied.
-     * @returns {number}
-     */
-    get size(): number;
-    /**
-     * Park a component whose bounds have gone stale.
-     *
-     * The caller must not add a component that is already queued — see
-     * {@link ShadedGeometry.updateTransform}, which owns that bit.
-     * @param {ShadedGeometry} sg
-     * @returns {void}
-     */
-    add(sg: ShadedGeometry): void;
-    /**
-     * Apply every parked update, leaving the BVH consistent with the current transforms.
-     *
-     * Components that were unlinked while queued, or whose bounds were already settled by
-     * a read, are skipped.
-     *
-     * Must not be re-entered: nothing reached from here writes to a {@link Transform},
-     * so no component can go dirty while the batch is being applied.
-     * @returns {number} how many components actually had an update applied, which is a
-     * useful profiling signal — it is the number of BVH refits the batch cost
-     */
-    flush(): number;
-    #private;
-}
-//# sourceMappingURL=DeferredBoundsQueue.d.ts.map

package/src/engine/graphics/ecs/mesh-v2/DeferredBoundsQueue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DeferredBoundsQueue.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/mesh-v2/DeferredBoundsQueue.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH;IAaI;;;OAGG;IACH,mBAEC;IAED;;;;;;;OAOG;IACH,yBAFa,IAAI,CAIhB;IAED;;;;;;;;;;OAUG;IACH,SAHa,MAAM,CA2BlB;;CACJ"}

package/src/engine/graphics/ecs/mesh-v2/DeferredBoundsQueue.js

@@ -1,88 +0,0 @@
-/**
- * Collects {@link ShadedGeometry} components whose bounding box has gone stale under
- * {@link ShadedGeometryFlags.DeferredBoundsUpdate}, until the owner of the BVH is ready
- * to take the updates.
- *
- * WHY THIS EXISTS
- *
- * A {@link Transform} signals `position`, `rotation` and `scale` separately, so one
- * logical move produces several change notifications: two when a caller sets position
- * and rotation, three when the transform is written as a matrix (which is what
- * {@link TransformAttachmentSystem} does for every entity in a hierarchy, and what
- * `Transform.copy` does). Updating bounds on each of those recomputes the same box and
- * walks the same path to the BVH root several times over. Parking the component here
- * instead collapses the batch into one update per component per flush.
- *
- * Entries are appended without a membership test; {@link ShadedGeometry} carries the
- * "already queued" bit so enqueueing stays O(1) and a component appears at most once.
- */
-export class DeferredBoundsQueue {
-    /**
-     * Retained between flushes and overwritten in place rather than re-allocated.
-     * Only the first {@link #size} entries are live.
-     * @type {ShadedGeometry[]}
-     */
-    #items = [];
-
-    /**
-     * @type {number}
-     */
-    #size = 0;
-
-    /**
-     * Number of components waiting for their bounds to be applied.
-     * @returns {number}
-     */
-    get size() {
-        return this.#size;
-    }
-
-    /**
-     * Park a component whose bounds have gone stale.
-     *
-     * The caller must not add a component that is already queued — see
-     * {@link ShadedGeometry.updateTransform}, which owns that bit.
-     * @param {ShadedGeometry} sg
-     * @returns {void}
-     */
-    add(sg) {
-        this.#items[this.#size++] = sg;
-    }
-
-    /**
-     * Apply every parked update, leaving the BVH consistent with the current transforms.
-     *
-     * Components that were unlinked while queued, or whose bounds were already settled by
-     * a read, are skipped.
-     *
-     * Must not be re-entered: nothing reached from here writes to a {@link Transform},
-     * so no component can go dirty while the batch is being applied.
-     * @returns {number} how many components actually had an update applied, which is a
-     * useful profiling signal — it is the number of BVH refits the batch cost
-     */
-    flush() {
-        const items = this.#items;
-        const size = this.#size;
-
-        let applied = 0;
-
-        for (let i = 0; i < size; i++) {
-            if (items[i].applyDeferredBoundsUpdate()) {
-                applied++;
-            }
-        }
-
-        // Drop the references so components unlinked while queued are not held alive
-        // until their slot happens to be overwritten — after a teardown the slots may
-        // never be reused, and each entry retains a geometry and a material.
-        //
-        // Done in one sweep rather than per entry inside the loop above: clearing each
-        // slot as it was consumed measured ~25% slower per tick on a 2000-mover scene,
-        // the store into the object array carrying a GC write barrier each time.
-        items.fill(null, 0, size);
-
-        this.#size = 0;
-
-        return applied;
-    }
-}

package/src/engine/graphics/ecs/mesh-v2/aggregate/SGMeshSystem.d.ts

@@ -1,63 +0,0 @@
-export class SGMeshSystem extends System<any> {
-    /**
-     *
-     * @param {Engine} engine
-     */
-    constructor(engine: Engine);
-    dependencies: (typeof Transform | typeof SGMesh)[];
-    components_used: (ResourceAccessSpecification<typeof Transform> | ResourceAccessSpecification<typeof TransformAttachment> | ResourceAccessSpecification<typeof SGMesh> | ResourceAccessSpecification<typeof ShadedGeometry>)[];
-    /**
-     *
-     * @type {number[]}
-     * @private
-     */
-    private __wait_queue;
-    /**
-     *
-     * @type {number}
-     * @private
-     */
-    private __wait_queue_process_index;
-    /**
-     *
-     * @type {Engine}
-     * @private
-     */
-    private __engine;
-    /**
-     *
-     * @type {AssetManager}
-     * @private
-     */
-    private __assetManager;
-    startup(em: any): Promise<void>;
-    /**
-     *
-     * @param {number} entity
-     * @param {SGMesh} mesh
-     * @param {Transform} transform
-     */
-    process(entity: number, mesh: SGMesh, transform: Transform): Promise<void>;
-    /**
-     *
-     * @param {SGMesh} mesh
-     * @param {Transform} transform
-     * @param {number} entity
-     */
-    link(mesh: SGMesh, transform: Transform, entity: number): void;
-    /**
-     *
-     * @param {SGMesh} mesh
-     * @param {Transform} transform
-     * @param {number} entity
-     */
-    unlink(mesh: SGMesh, transform: Transform, entity: number): void;
-    update(time_delta: any): void;
-}
-import { System } from "../../../../ecs/System.js";
-import { Transform } from "../../../../ecs/transform/Transform.js";
-import { SGMesh } from "./SGMesh.js";
-import { ResourceAccessSpecification } from "../../../../../core/model/ResourceAccessSpecification.js";
-import { TransformAttachment } from "../../../../ecs/transform-attachment/TransformAttachment.js";
-import { ShadedGeometry } from "../ShadedGeometry.js";
-//# sourceMappingURL=SGMeshSystem.d.ts.map

package/src/engine/graphics/ecs/mesh-v2/aggregate/SGMeshSystem.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SGMeshSystem.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/mesh-v2/aggregate/SGMeshSystem.js"],"names":[],"mappings":"AA8CA;IAuBI;;;OAGG;IACH,4BAgBC;IA1CD,mDAAmC;IACnC,+NAKE;IAEF;;;;OAIG;IACH,qBAAkB;IAElB;;;;OAIG;IACH,mCAA+B;IAS3B;;;;OAIG;IACH,iBAAsB;IAEtB;;;;OAIG;IACH,uBAAyC;IAG7C,gCAMC;IAED;;;;;OAKG;IACH,gBAJW,MAAM,QACN,MAAM,aACN,SAAS,iBA8GnB;IAED;;;;;OAKG;IACH,WAJW,MAAM,aACN,SAAS,UACT,MAAM,QAiBhB;IAED;;;;;OAKG;IACH,aAJW,MAAM,aACN,SAAS,UACT,MAAM,QAehB;IAED,8BAqDC;CACJ;uBAnTsB,2BAA2B;0BAGxB,wCAAwC;uBAK3C,aAAa;4CAZQ,0DAA0D;oCAKlE,6DAA6D;+BAIlE,sBAAsB"}