@woosh/meep-engine 3.14.6 → 3.16.0

package/samples/engine/first-scene/main.js

@@ -1,152 +1,152 @@
-/**
- * The smallest complete meep application: boot the engine, put something in the world, light it,
- * and read the keyboard and the mouse.
- *
- * This exists because there was no such thing. `samples/` shipped procedural-generation fixtures
- * and nothing that constructs an `Engine`; the de-facto worked example was `EngineHarness` itself,
- * found by reading a directory listing and guessing from the filename (GAP-002). Everything below
- * is deliberately boring — the interesting parts are the four notes, which are the four things that
- * cost a real port real time before it had drawn a frame.
- *
- * @see ../README.md for the Vite configuration this needs, and why.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-
-import Vector2 from "../../../src/core/geom/Vector2.js";
-import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
-import Entity from "../../../src/engine/ecs/Entity.js";
-import { EngineHarness } from "../../../src/engine/EngineHarness.js";
-import { Light } from "../../../src/engine/graphics/ecs/light/Light.js";
-import { LightType } from "../../../src/engine/graphics/ecs/light/LightType.js";
-
-/**
- * NOTE 1 — **author your scene in metres.**
- *
- * `Light.intensity` is photometric: candelas for a point or spot light, and falloff is
- * inverse-square *in scene units*. So the unit your content is authored in is part of its lighting
- * setup, and content from an engine with its own units renders essentially black at 1:1. The
- * failure does not look like a units problem — it looks like broken materials, or a missing light
- * system, and it barely responds to turning the brightness up: a port that raised every light by
- * 10,000x watched mean frame luminance go 14.7 → 25.7 and went looking for a disconnected light
- * system, because its distances were 32x too large (GAP-005).
- *
- * If your source content is not metric, scale it on the way in, once, in the asset pipeline.
- *
- * @type {number}
- */
-const ROOM_SIZE_METRES = 8;
-
-/**
- * NOTE 2 — **reference values, because physical units trade one kind of guesswork for another.**
- *
- * "Very bright" is not a number. These are, and they are worth more than a paragraph of theory:
- *
- * | source              | lumens  |
- * |---------------------|--------:|
- * | candle              |      13 |
- * | torch / flashlight  |     300 |
- * | household bulb      |     800 |
- * | office ceiling      |   1,500 |
- * | muzzle flash        |   2,500 |
- * | rocket explosion    |  12,000 |
- *
- * The last one is the instructive one. A port's first explosion used 60,000 lm on the reasoning
- * that an explosion is very bright; it saturated the whole corridor to white and hid the particle
- * effect the light existed to show. 12,000 — about eight household bulbs, which sounds far too dim
- * — is what reads as an explosion (GAP-011).
- *
- * The component takes candelas; `cd = lm / 4π` for an isotropic source.
- *
- * @param {number} lumens
- * @returns {number} candelas
- */
-function candelas(lumens) {
-    return lumens / (4 * Math.PI);
-}
-
-/**
- * Boot, build a scene, and wire input.
- *
- * @returns {Promise<Engine>}
- */
-export async function main() {
-    const engine = await EngineHarness.bootstrap();
-
-    // Sun, terrain and an orbital camera, so there is a surface for the lamp below to light.
-    // Terrain needs the worker bundle: `npm run build-module` once, before serving this.
-    await EngineHarness.buildBasics({
-        engine,
-        distance: ROOM_SIZE_METRES,
-        terrainSize: new Vector2(ROOM_SIZE_METRES, ROOM_SIZE_METRES),
-        enableWater: false,
-        showFps: true
-    });
-
-    // A ceiling light with a size. `radius` is what makes it a light FIXTURE rather than a delta
-    // source: the renderer uses it for the sphere-attenuation cap, the specular representative
-    // point, the soft terminator and the shadow penumbra. Left at 0 everything is mirror-sharp and
-    // hard-edged, which reads as "the lighting is harsh" rather than as a setting you forgot.
-    const lamp = new Light();
-    lamp.type.set(LightType.POINT);
-    lamp.color.set(1.0, 0.95, 0.88);
-    lamp.intensity.set(candelas(1500));
-    lamp.distance.set(ROOM_SIZE_METRES * 2);
-    lamp.radius.set(0.15);
-    lamp.castShadow.set(true);
-
-    const lampTransform = new Transform();
-    lampTransform.position.set(0, ROOM_SIZE_METRES * 0.5, 0);
-
-    new Entity().add(lamp).add(lampTransform).build(engine.entityManager.dataset);
-
-    /**
-     * NOTE 3 — **input arrives on the view stack's element, and the engine does not focus it for
-     * you if you replace the harness's bootstrap.**
-     *
-     * `Engine` builds `devices.pointer` and `devices.keyboard` on `viewStack.el` and focuses that
-     * element when the stack links. Only a focused element receives keyboard events, and this used
-     * to be nobody's job: the element carried `tabindex` and nothing ever called `focus()`, so WASD
-     * did nothing, the mouse did not turn the view, and there was no error anywhere — a failure
-     * identical to an application with no input code at all (GAP-017).
-     *
-     * Two things to know if you build your own view root: the devices listen for **Pointer**
-     * events (`pointermove`, `pointerdown`), not `mousemove`/`mousedown` — synthesising a
-     * `MouseEvent` to test the wiring reports "still broken" — and `pointer.on.move`'s **third**
-     * argument is the pointer-lock delta, already extracted from `movementX`/`movementY`.
-     */
-    const { keyboard, pointer } = engine.devices;
-
-    engine.ticker.onTick.add(() => {
-        const forward = keyboard.keys.w.is_down ? 1 : 0;
-        const back = keyboard.keys.s.is_down ? 1 : 0;
-
-        lampTransform.position.setY(
-            ROOM_SIZE_METRES * 0.5 + (forward - back) * 2
-        );
-    });
-
-    pointer.on.move.add((position, previous, delta) => {
-        if (!pointer.mouseButtonLeft.is_down) {
-            return;
-        }
-
-        lampTransform.position._add(delta.x * 0.01, 0, delta.y * 0.01);
-    });
-
-    return engine;
-}
-
-/**
- * NOTE 4 — **the two worker bundles live in `@woosh/meep-engine/build/`.**
- *
- * They are resolved against this package's own modules, so they need no configuration from you.
- * What you may still have to do is serve them with `Cross-Origin-Resource-Policy` if your page sets
- * `Cross-Origin-Embedder-Policy: require-corp` — which WebGPU pushes you toward. Without it,
- * `importScripts` of a same-origin script is blocked and reproduces exactly the same `NetworkError`
- * as the file not being there at all.
- */
-if (typeof document !== "undefined" && document.currentScript !== null) {
-    main();
-}
+/**
+ * The smallest complete meep application: boot the engine, put something in the world, light it,
+ * and read the keyboard and the mouse.
+ *
+ * This exists because there was no such thing. `samples/` shipped procedural-generation fixtures
+ * and nothing that constructs an `Engine`; the de-facto worked example was `EngineHarness` itself,
+ * found by reading a directory listing and guessing from the filename (GAP-002). Everything below
+ * is deliberately boring — the interesting parts are the four notes, which are the four things that
+ * cost a real port real time before it had drawn a frame.
+ *
+ * @see ../README.md for the Vite configuration this needs, and why.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+import Vector2 from "../../../src/core/geom/Vector2.js";
+import { Transform64 } from "../../../src/engine/ecs/transform/Transform64.js";
+import Entity from "../../../src/engine/ecs/Entity.js";
+import { EngineHarness } from "../../../src/engine/EngineHarness.js";
+import { Light } from "../../../src/engine/graphics/ecs/light/Light.js";
+import { LightType } from "../../../src/engine/graphics/ecs/light/LightType.js";
+
+/**
+ * NOTE 1 — **author your scene in metres.**
+ *
+ * `Light.intensity` is photometric: candelas for a point or spot light, and falloff is
+ * inverse-square *in scene units*. So the unit your content is authored in is part of its lighting
+ * setup, and content from an engine with its own units renders essentially black at 1:1. The
+ * failure does not look like a units problem — it looks like broken materials, or a missing light
+ * system, and it barely responds to turning the brightness up: a port that raised every light by
+ * 10,000x watched mean frame luminance go 14.7 → 25.7 and went looking for a disconnected light
+ * system, because its distances were 32x too large (GAP-005).
+ *
+ * If your source content is not metric, scale it on the way in, once, in the asset pipeline.
+ *
+ * @type {number}
+ */
+const ROOM_SIZE_METRES = 8;
+
+/**
+ * NOTE 2 — **reference values, because physical units trade one kind of guesswork for another.**
+ *
+ * "Very bright" is not a number. These are, and they are worth more than a paragraph of theory:
+ *
+ * | source              | lumens  |
+ * |---------------------|--------:|
+ * | candle              |      13 |
+ * | torch / flashlight  |     300 |
+ * | household bulb      |     800 |
+ * | office ceiling      |   1,500 |
+ * | muzzle flash        |   2,500 |
+ * | rocket explosion    |  12,000 |
+ *
+ * The last one is the instructive one. A port's first explosion used 60,000 lm on the reasoning
+ * that an explosion is very bright; it saturated the whole corridor to white and hid the particle
+ * effect the light existed to show. 12,000 — about eight household bulbs, which sounds far too dim
+ * — is what reads as an explosion (GAP-011).
+ *
+ * The component takes candelas; `cd = lm / 4π` for an isotropic source.
+ *
+ * @param {number} lumens
+ * @returns {number} candelas
+ */
+function candelas(lumens) {
+    return lumens / (4 * Math.PI);
+}
+
+/**
+ * Boot, build a scene, and wire input.
+ *
+ * @returns {Promise<Engine>}
+ */
+export async function main() {
+    const engine = await EngineHarness.bootstrap();
+
+    // Sun, terrain and an orbital camera, so there is a surface for the lamp below to light.
+    // Terrain needs the worker bundle: `npm run build-module` once, before serving this.
+    await EngineHarness.buildBasics({
+        engine,
+        distance: ROOM_SIZE_METRES,
+        terrainSize: new Vector2(ROOM_SIZE_METRES, ROOM_SIZE_METRES),
+        enableWater: false,
+        showFps: true
+    });
+
+    // A ceiling light with a size. `radius` is what makes it a light FIXTURE rather than a delta
+    // source: the renderer uses it for the sphere-attenuation cap, the specular representative
+    // point, the soft terminator and the shadow penumbra. Left at 0 everything is mirror-sharp and
+    // hard-edged, which reads as "the lighting is harsh" rather than as a setting you forgot.
+    const lamp = new Light();
+    lamp.type.set(LightType.POINT);
+    lamp.color.set(1.0, 0.95, 0.88);
+    lamp.intensity.set(candelas(1500));
+    lamp.distance.set(ROOM_SIZE_METRES * 2);
+    lamp.radius.set(0.15);
+    lamp.castShadow.set(true);
+
+    const lampTransform = new Transform64();
+    lampTransform.setTranslation(0, ROOM_SIZE_METRES * 0.5, 0);
+
+    new Entity().add(lamp).add(lampTransform).build(engine.entityManager.dataset);
+
+    /**
+     * NOTE 3 — **input arrives on the view stack's element, and the engine does not focus it for
+     * you if you replace the harness's bootstrap.**
+     *
+     * `Engine` builds `devices.pointer` and `devices.keyboard` on `viewStack.el` and focuses that
+     * element when the stack links. Only a focused element receives keyboard events, and this used
+     * to be nobody's job: the element carried `tabindex` and nothing ever called `focus()`, so WASD
+     * did nothing, the mouse did not turn the view, and there was no error anywhere — a failure
+     * identical to an application with no input code at all (GAP-017).
+     *
+     * Two things to know if you build your own view root: the devices listen for **Pointer**
+     * events (`pointermove`, `pointerdown`), not `mousemove`/`mousedown` — synthesising a
+     * `MouseEvent` to test the wiring reports "still broken" — and `pointer.on.move`'s **third**
+     * argument is the pointer-lock delta, already extracted from `movementX`/`movementY`.
+     */
+    const { keyboard, pointer } = engine.devices;
+
+    engine.ticker.onTick.add(() => {
+        const forward = keyboard.keys.w.is_down ? 1 : 0;
+        const back = keyboard.keys.s.is_down ? 1 : 0;
+
+        lampTransform.position.setY(
+            ROOM_SIZE_METRES * 0.5 + (forward - back) * 2
+        );
+    });
+
+    pointer.on.move.add((position, previous, delta) => {
+        if (!pointer.mouseButtonLeft.is_down) {
+            return;
+        }
+
+        lampTransform.position._add(delta.x * 0.01, 0, delta.y * 0.01);
+    });
+
+    return engine;
+}
+
+/**
+ * NOTE 4 — **the two worker bundles live in `@woosh/meep-engine/build/`.**
+ *
+ * They are resolved against this package's own modules, so they need no configuration from you.
+ * What you may still have to do is serve them with `Cross-Origin-Resource-Policy` if your page sets
+ * `Cross-Origin-Embedder-Policy: require-corp` — which WebGPU pushes you toward. Without it,
+ * `importScripts` of a same-origin script is blocked and reproduces exactly the same `NetworkError`
+ * as the file not being there at all.
+ */
+if (typeof document !== "undefined" && document.currentScript !== null) {
+    main();
+}

package/samples/generation/generators/mir_generator_place_bases.js

@@ -1,7 +1,7 @@
 import { MirMarkerTags } from "../../../../generator/MirMarkerTags.js";
 import { MirMarkerTypes } from "../../../../generator/MirMarkerTypes.js";
 import { bitwiseAnd } from "../../../src/core/binary/operations/bitwiseAnd.js";
-import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
+import { Transform64 } from "../../../src/engine/ecs/transform/Transform64.js";
 import { CellFilterLiteralFloat } from "../../../src/generation/filtering/numeric/CellFilterLiteralFloat.js";
 import { GridTaskActionRuleSet } from "../../../src/generation/grid/generation/discrete/GridTaskActionRuleSet.js";
 import { MarkerNodeEmitterFromAction } from "../../../src/generation/markers/emitter/MarkerNodeEmitterFromAction.js";
@@ -105,8 +105,8 @@ const rule = GridCellPlacementRule.from({
                             // assign to enemy team
                             team: 1
                         },
-                        transform: Transform.fromJSON({
-                            position: {
+                        transform: Transform64.fromJSON({
+                            translation: {
                                 x: 0.5,
                                 y: 0,
                                 z: 0.5

package/src/core/assert.d.ts

@@ -35,18 +35,8 @@ export namespace assert {
      * @param {string} [class_name]
      */
     export function isInstanceOf(value: any, klass: Class, value_name?: string, class_name?: string): void;
-    /**
-     *
-     * @param {number|*} value
-     * @param {string} [name]
-     */
-    export function isNumber(value: any, name?: string): void;
-    /**
-     *
-     * @param {string|*} value
-     * @param {string} [name]
-     */
-    export function isString(value: any, name?: string): void;
+    export { isNumber };
+    export { isString };
     /**
      *
      * @param {boolean|*} value
@@ -65,12 +55,7 @@ export namespace assert {
      * @param {string} [name]
      */
     export function isObject(value: any, name?: string): void;
-    /**
-     *
-     * @param {number|*} value
-     * @param {string} [name]
-     */
-    export function isInteger(value: any, name?: string): void;
+    export { isInteger };
     /**
      *
      * @param {number|*} value
@@ -95,12 +80,7 @@ export namespace assert {
      * @param {string} name
      */
     export function isArrayLike<T>(value: Float32Array | Uint32Array | ArrayLike<T> | T[], name?: string): void;
-    /**
-     * Check for value !== undefined, throws exception if value is undefined
-     * @param {*} value
-     * @param {String} [name]
-     */
-    export function defined(value: any, name?: string): void;
+    export { defined };
     /**
      * Checks for value === undefined, throws exception if value is NOT undefined
      * @param {*} value
@@ -239,5 +219,29 @@ declare function arrayEqual<T>(a: Float32Array | Int32Array | ArrayLike<T> | T[]
  * @param {string} [name] optional name for a better error message
  */
 declare function isOneOf<T>(value: T, options: T[], name?: string): void;
+/**
+ *
+ * @param {number|*} value
+ * @param {string} [name]
+ */
+declare function isNumber(value: number | any, name?: string): void;
+/**
+ *
+ * @param {string|*} value
+ * @param {string} [name]
+ */
+declare function isString(value: string | any, name?: string): void;
+/**
+ *
+ * @param {number|*} value
+ * @param {string} [name]
+ */
+declare function isInteger(value: number | any, name?: string): void;
+/**
+ * Check for value !== undefined, throws exception if value is undefined
+ * @param {*} value
+ * @param {String} [name]
+ */
+declare function defined(value: any, name?: string): void;
 export {};
 //# sourceMappingURL=assert.d.ts.map

package/src/core/assert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../src/core/assert.js"],"names":[],"mappings":"AAgDA;;;;GAIG;AACH,0BAHW,OAAO,MACP,MAAM,QAMhB;;IAoKD;;;;;OAKG;IACH,kEAQC;;;;;;;;;;;;;;;;IAoBD;;;;;;OAMG;IACH,uGAKC;IAGD;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,2DAMC;IAED;;;;OAIG;IACH,4DAMC;IAED;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,2DAMC;IAED;;;;OAIG;IACH,sEAMC;IAED;;;;OAIG;IACH,mEAMC;IAED;;;;OAIG;IACH,4DAKC;IAED;;;;OAIG;IACH,4GAKC;IAGD;;;;OAIG;IACH,yDAMC;IAED;;;;OAIG;IACH,2DAMC;IAGD;;;;OAIG;IACH,wDAIC;IAED;;;;OAIG;IACH,yDAMC;IAED;;;;OAIG;IACH,2DAIC;IAED;;;;;OAKG;IACH,6DAIC;IAED;;;;;;;;;;;;;OAaG;IACH,2EAsBC;;AA1eD;;;;;GAKG;AACH,6CAFW,MAAM,QAIhB;AAED;;;;GAIG;AACH,0BAHW,OAAO,MACP,MAAM,QAIhB;AAhCD;;;;;GAKG;AACH,0CAFW,MAAM,QAShB;AAqBD;;;;;GAKG;AACH,kCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAIhB;AAaD;;;;;GAKG;AACH,gCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAyBD;;;;;GAKG;AACH,uCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AA5CD;;;;;GAKG;AACH,6BAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAyBD;;;;;GAKG;AACH,oCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAkBD;;;;;;GAMG;AACH,0CAHW,MAAM,cACN,MAAM,QAehB;AAED;;;;;GAKG;AACH,iEAFW,MAAM,QAIhB;AAED;;;;;GAKG;AACH,mEAFW,MAAM,QAIhB;AAED;;;;;GAKG;AACH,+IAFW,MAAM,QAMhB;AApED;;;;;GAKG;AACH,2DAFW,MAAM,QAQhB"}
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../src/core/assert.js"],"names":[],"mappings":"AAgDA;;;;GAIG;AACH,0BAHW,OAAO,MACP,MAAM,QAMhB;;IAoKD;;;;;OAKG;IACH,kEAQC;;;;;;;;;;;;;;;;IAoBD;;;;;;OAMG;IACH,uGAKC;;;IAiCD;;;;OAIG;IACH,2DAMC;IAED;;;;OAIG;IACH,4DAMC;IAED;;;;OAIG;IACH,0DAMC;;IAiBD;;;;OAIG;IACH,sEAMC;IAED;;;;OAIG;IACH,mEAMC;IAED;;;;OAIG;IACH,4DAKC;IAED;;;;OAIG;IACH,4GAKC;;IAkBD;;;;OAIG;IACH,2DAMC;IAGD;;;;OAIG;IACH,wDAIC;IAED;;;;OAIG;IACH,yDAMC;IAED;;;;OAIG;IACH,2DAIC;IAED;;;;;OAKG;IACH,6DAIC;IAED;;;;;;;;;;;;;OAaG;IACH,2EAsBC;;AAlfD;;;;;GAKG;AACH,6CAFW,MAAM,QAIhB;AAED;;;;GAIG;AACH,0BAHW,OAAO,MACP,MAAM,QAIhB;AAhCD;;;;;GAKG;AACH,0CAFW,MAAM,QAShB;AAqBD;;;;;GAKG;AACH,kCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAIhB;AAaD;;;;;GAKG;AACH,gCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAyBD;;;;;GAKG;AACH,uCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AA5CD;;;;;GAKG;AACH,6BAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAyBD;;;;;GAKG;AACH,oCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAkBD;;;;;;GAMG;AACH,0CAHW,MAAM,cACN,MAAM,QAehB;AAED;;;;;GAKG;AACH,iEAFW,MAAM,QAIhB;AAED;;;;;GAKG;AACH,mEAFW,MAAM,QAIhB;AAED;;;;;GAKG;AACH,+IAFW,MAAM,QAMhB;AApED;;;;;GAKG;AACH,2DAFW,MAAM,QAQhB;AA2GD;;;;GAIG;AACH,iCAHW,MAAM,MAAE,SACR,MAAM,QAQhB;AAID;;;;GAIG;AACH,iCAHW,MAAM,MAAE,SACR,MAAM,QAQhB;AA2CD;;;;GAIG;AACH,kCAHW,MAAM,MAAE,SACR,MAAM,QAQhB;AAuDD;;;;GAIG;AACH,0DAMC"}

package/src/core/assert.js

@@ -43,7 +43,7 @@ function notOk(t, m) {
  * @param {string} [m]
  */
 function logicalEquals(a, b, m) {
-    assert.ok(a.equals(b), m);
+    assert(a.equals(b), m);
 }
 
 /**
@@ -64,8 +64,8 @@ function assert(t, m) {
  * @param {string} [m]
  */
 function greaterThan(a, b, m) {
-    assert.equal(typeof a, 'number');
-    assert.equal(typeof b, 'number');
+    equal(typeof a, 'number');
+    equal(typeof b, 'number');
 
     if (!(a > b)) {
         let message = '';
@@ -87,8 +87,8 @@ function greaterThan(a, b, m) {
  * @param {string} [m]
  */
 function lessThan(a, b, m) {
-    assert.equal(typeof a, 'number');
-    assert.equal(typeof b, 'number');
+    equal(typeof a, 'number');
+    equal(typeof b, 'number');
 
     if (!(a < b)) {
         let message = '';
@@ -110,8 +110,8 @@ function lessThan(a, b, m) {
  * @param {string} [m]
  */
 function greaterThanOrEqual(a, b, m) {
-    assert.equal(typeof a, 'number');
-    assert.equal(typeof b, 'number');
+    equal(typeof a, 'number');
+    equal(typeof b, 'number');
 
     if (!(a >= b)) {
         let message = '';
@@ -133,8 +133,8 @@ function greaterThanOrEqual(a, b, m) {
  * @param {string} [m]
  */
 function lessThanOrEqual(a, b, m) {
-    assert.equal(typeof a, 'number');
-    assert.equal(typeof b, 'number');
+    equal(typeof a, 'number');
+    equal(typeof b, 'number');
 
     if (!(a <= b)) {
         let message = '';
@@ -178,7 +178,7 @@ function typeOf(value, type, valueName = 'value') {
 
     const typeofValueName = typeof valueName;
 
-    assert.equal(typeofValueName, 'string', `valueName must be a string, instead was '${typeofValueName}'`);
+    equal(typeofValueName, 'string', `valueName must be a string, instead was '${typeofValueName}'`);
 
     const typeofValue = typeof value;
 
@@ -194,7 +194,7 @@ function typeOf(value, type, valueName = 'value') {
  * @param {string} [message]
  */
 function arrayHas(haystack, needle, message = 'Array does not contain the item') {
-    assert.notEqual(haystack.indexOf(needle), -1, message);
+    notEqual(haystack.indexOf(needle), -1, message);
 }
 
 /**
@@ -204,7 +204,7 @@ function arrayHas(haystack, needle, message = 'Array does not contain the item')
  * @param {string} [message]
  */
 function arrayHasNo(haystack, needle, message = 'Array contains the item') {
-    assert.equal(haystack.indexOf(needle), -1, message);
+    equal(haystack.indexOf(needle), -1, message);
 }
 
 /**
@@ -263,8 +263,8 @@ assert.isOneOf = isOneOf;
 assert.isInstanceOf = function (
     value,
     klass, value_name = "value", class_name = klass.name) {
-    assert.defined(klass, 'klass');
-    assert.ok(value instanceof klass, `expected ${value_name} to be instance of class '${class_name}'`);
+    defined(klass, 'klass');
+    assert(value instanceof klass, `expected ${value_name} to be instance of class '${class_name}'`);
 }
 
 
@@ -273,26 +273,30 @@ assert.isInstanceOf = function (
  * @param {number|*} value
  * @param {string} [name]
  */
-assert.isNumber = function (value, name = 'value') {
+function isNumber(value, name = 'value') {
     const typeofValue = typeof value;
 
     if (typeofValue !== 'number') {
         throw new Error(`expected ${name} to be a number, instead was '${typeofValue}'(=${value})`);
     }
-};
+}
+
+assert.isNumber = isNumber;
 
 /**
  *
  * @param {string|*} value
  * @param {string} [name]
  */
-assert.isString = function (value, name = 'value') {
+function isString(value, name = 'value') {
     const typeofValue = typeof value;
 
     if (typeofValue !== 'string') {
         throw new Error(`expected ${name} to be a string, instead was '${typeofValue}'(=${value})`);
     }
-};
+}
+
+assert.isString = isString;
 
 /**
  *
@@ -338,21 +342,23 @@ assert.isObject = function (value, name = 'value') {
  * @param {number|*} value
  * @param {string} [name]
  */
-assert.isInteger = function (value, name = 'value') {
-    assert.isNumber(value, name);
+function isInteger(value, name = 'value') {
+    isNumber(value, name);
 
     if (!Number.isInteger(value)) {
         throw new Error(`${name} must be an integer, instead was ${value}`);
     }
 }
 
+assert.isInteger = isInteger;
+
 /**
  *
  * @param {number|*} value
  * @param {string} [name]
  */
 assert.isNonNegativeInteger = function (value, name = 'value') {
-    assert.isInteger(value, name);
+    isInteger(value, name);
 
     if (value < 0) {
         throw new Error(`${name} must be >= 0, instead was ${value}`);
@@ -365,7 +371,7 @@ assert.isNonNegativeInteger = function (value, name = 'value') {
  * @param {string} name
  */
 assert.isPositiveInteger = function (value, name = 'value') {
-    assert.isInteger(value, name);
+    isInteger(value, name);
 
     if (value <= 0) {
         throw new Error(`${name} must be > 0, instead was ${value}`);
@@ -402,13 +408,15 @@ assert.isArrayLike = function (value, name = 'value') {
  * @param {*} value
  * @param {String} [name]
  */
-assert.defined = function (value, name = "value") {
+function defined(value, name = "value") {
 
     if (value === undefined) {
         throw new Error(`${name} is undefined`);
     }
 
-};
+}
+
+assert.defined = defined;
 
 /**
  * Checks for value === undefined, throws exception if value is NOT undefined
@@ -486,8 +494,8 @@ assert.isFinite = function (value, name = "value") {
  * @param {Matcher<T>} matcher
  */
 assert.that = function (value, name, matcher) {
-    assert.isString(name, 'name');
-    assert.defined(matcher, 'matcher');
+    isString(name, 'name');
+    defined(matcher, 'matcher');
 
     if (matcher.matches(value)) {
         return;

package/src/core/geom/3d/shape/PosedShape3D.d.ts

@@ -46,6 +46,23 @@ export class PosedShape3D extends AbstractShape3D {
         z: number;
         w: number;
     }): void;
+    /**
+     * The same, from loose components.
+     *
+     * A pose does not always arrive as a pair of objects: a `Transform64` keeps its translation and
+     * rotation as numbers inside one buffer, and reading them through its view accessors would build
+     * two throwaway arrays per call, in a loop that runs per collider per step.
+     *
+     * @param {AbstractShape3D} shape
+     * @param {number} px
+     * @param {number} py
+     * @param {number} pz
+     * @param {number} qx
+     * @param {number} qy
+     * @param {number} qz
+     * @param {number} qw
+     */
+    setup_components(shape: AbstractShape3D, px: number, py: number, pz: number, qx: number, qy: number, qz: number, qw: number): void;
     compute_bounding_box(result: any): void;
     /**
      * Signed distance from a WORLD-space point to the posed shape's boundary.

package/src/core/geom/3d/shape/PosedShape3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PosedShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/PosedShape3D.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAEI,mCAAmC;IACnC,OADW,eAAe,GAAC,IAAI,CAClB;IAEb,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IAEP;;;;;;;OAOG;IACH,aAJW,eAAe,YACf,UAAQ;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,YACpC,aAAW;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAM1D;IAyED,wCASC;IA4BD;;;;;;;OAOG;IACH,gCAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,MAAM,CAKlB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,OAAO,CAKnB;IAGL;;;;OAIG;IACH,yBAFU,OAAO,CAEoB;;CAPpC;gCAvL+B,sBAAsB"}
+{"version":3,"file":"PosedShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/PosedShape3D.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAEI,mCAAmC;IACnC,OADW,eAAe,GAAC,IAAI,CAClB;IAEb,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IAEP;;;;;;;OAOG;IACH,aAJW,eAAe,YACf,UAAQ;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,YACpC,aAAW;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAe1D;IAED;;;;;;;;;;;;;;;OAeG;IACH,wBATW,eAAe,MACf,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAMhB;IAyED,wCASC;IA4BD;;;;;;;OAOG;IACH,gCAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,MAAM,CAKlB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,OAAO,CAKnB;IAGL;;;;OAIG;IACH,yBAFU,OAAO,CAEoB;;CAPpC;gCAtN+B,sBAAsB"}