@woosh/meep-engine 3.0.0 → 3.0.1

package/src/engine/ecs/gui/hud/testHudEdgeStick.js

@@ -10,7 +10,7 @@ import HeadsUpDisplay from "./HeadsUpDisplay.js";
 import HeadsUpDisplaySystem from "./HeadsUpDisplaySystem.js";
 import { EngineConfiguration } from "../../../EngineConfiguration.js";
 import { AttachmentSystem } from "../../attachment/AttachmentSystem.js";
-import { CameraSystem } from "../../../graphics/ecs/camera/CameraSystem.js";
+import { camera_find_active } from "../../../graphics/ecs/camera/camera_find_active.js";
 import TopDownCameraController from "../../../graphics/ecs/camera/topdown/TopDownCameraController.js";
 
 const eh = new EngineHarness();
@@ -105,7 +105,7 @@ async function main(engine) {
         tracked.push({ entity, transform, vp, view, index: i });
     }
 
-    const active_camera = CameraSystem.getFirstActiveCamera(ecd);
+    const active_camera = camera_find_active(ecd);
     const controller = ecd.getComponent(active_camera.entity, TopDownCameraController);
 
     window.__hud_edge_stick_test = {

package/src/engine/ecs/terrain/ecs/TerrainSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TerrainSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/ecs/TerrainSystem.js"],"names":[],"mappings":";AA+BA;IAiJI;;;;;OAKG;IACH,kEAHW,OAAO,oEACiD,IAAI,QAuCtE;IAzKD;;;;;OAKG;IACH,kEAkBC;IA1CD,iCAAyB;IAEzB,mBAAe;IACf,mBAAe;IAEf;;;;OAIG;IACH,qBAAiB;IAEjB;;;OAGG;IACH,KAFU,GAAG,CAEG;IAuBZ,yBAAwB;IAExB,2BAAgC;IAGpC,kDAMC;IAED,2CAQC;IAED;;;;OAIG;IACH,gBAHW,OAAO,qBAqBjB;IAED;;;;OAIG;IACH,kBAHW,OAAO,qBAKjB;IAED,6BAaC;IAED;;;;;OAKG;IACH,gCAwBC;CA+CJ;uBAhNsB,iBAAiB;oBAEpB,cAAc;oBAbd,mCAAmC"}
+{"version":3,"file":"TerrainSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/ecs/TerrainSystem.js"],"names":[],"mappings":";AA8BA;IAiJI;;;;;OAKG;IACH,kEAHW,OAAO,oEACiD,IAAI,QA2BtE;IA7JD;;;;;OAKG;IACH,kEAkBC;IA1CD,iCAAyB;IAEzB,mBAAe;IACf,mBAAe;IAEf;;;;OAIG;IACH,qBAAiB;IAEjB;;;OAGG;IACH,KAFU,GAAG,CAEG;IAuBZ,yBAAwB;IAExB,2BAAgC;IAGpC,kDAMC;IAED,2CAQC;IAED;;;;OAIG;IACH,gBAHW,OAAO,qBAqBjB;IAED;;;;OAIG;IACH,kBAHW,OAAO,qBAKjB;IAED,6BAaC;IAED;;;;;OAKG;IACH,gCAwBC;CAmCJ;uBApMsB,iBAAiB;oBAEpB,cAAc;oBAZd,mCAAmC"}

package/src/engine/ecs/terrain/ecs/TerrainSystem.js

@@ -5,11 +5,10 @@ import {
 } from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_intersects_frustum.js";
 
 import { noop } from "../../../../core/function/noop.js";
-import { frustum3_planes_to_flat_from_three } from "../../../../core/geom/3d/frustum/frustum3_planes_to_flat_from_three.js";
 import { M4_IDENTITY } from "../../../../core/geom/3d/mat4/M4_IDENTITY.js";
 import { ImageRGBADataLoader } from "../../../asset/loaders/image/ImageRGBADataLoader.js";
 import { TextureAssetLoader } from "../../../asset/loaders/texture/TextureAssetLoader.js";
-import { CameraSystem } from '../../../graphics/ecs/camera/CameraSystem.js';
+import { camera_active_frustum } from '../../../graphics/ecs/camera/camera_active_frustum.js';
 import { System } from '../../System.js';
 import { Transform } from "../../transform/Transform.js";
 import Terrain from './Terrain.js';
@@ -186,36 +185,24 @@ class TerrainSystem extends System {
 
         const tileManager = terrain.__tiles;
 
-        const tiles = [];
-        const set = new Set();
-        let tile_count = 0;
-
-        const frustum = new Float32Array(24);
-
-        if (tileManager !== undefined) {
-            CameraSystem.getActiveFrustums(ecd, function (frustums) {
-                let found_tiles = 0;
-
-                for (let i = 0; i < frustums.length; i++) {
-
-                    frustum3_planes_to_flat_from_three(frustums[i].planes, frustum);
-
-                    found_tiles += bvh_query_user_data_intersects_frustum(tiles, tile_count, tileManager.bvh, frustum);
-                }
+        if (tileManager === undefined) {
+            return;
+        }
 
-                for (let i = 0; i < found_tiles; i++) {
-                    const tile_index = tiles[i];
+        const frustum = camera_active_frustum(ecd);
 
-                    if (!set.has(tile_index)) {
-                        const tile = tileManager.tiles[tile_index];
+        if (frustum === null) {
+            // nothing has drawn a frame, so there is no answer to what is on screen; visiting every
+            // tile would be one, and it is the wrong one
+            return;
+        }
 
-                        callback(tile, tileManager);
-                    }
+        const tiles = [];
 
-                    set.add(tile_index);
-                }
+        const found_tiles = bvh_query_user_data_intersects_frustum(tiles, 0, tileManager.bvh, frustum);
 
-            });
+        for (let i = 0; i < found_tiles; i++) {
+            callback(tileManager.tiles[tiles[i]], tileManager);
         }
     }
 }

package/src/engine/ecs/terrain/util/loadVisibleTerrainTiles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loadVisibleTerrainTiles.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/util/loadVisibleTerrainTiles.js"],"names":[],"mappings":"AAUA;;;;;;GAMG;AACH,8EAFa,IAAI,CA8GhB;iBAxHgB,uCAAuC"}
+{"version":3,"file":"loadVisibleTerrainTiles.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/util/loadVisibleTerrainTiles.js"],"names":[],"mappings":"AAUA;;;;;;GAMG;AACH,8EAFa,IAAI,CAiHhB;iBA3HgB,uCAAuC"}

package/src/engine/ecs/terrain/util/loadVisibleTerrainTiles.js

@@ -1,126 +1,129 @@
-import TopDownCameraControllerSystem from "../../../graphics/ecs/camera/topdown/TopDownCameraControllerSystem.js";
-import { Camera } from "../../../graphics/ecs/camera/Camera.js";
-import { obtainTerrain } from "./obtainTerrain.js";
-import { assert } from "../../../../core/assert.js";
-import TerrainSystem from "../ecs/TerrainSystem.js";
-import Task from "../../../../core/process/task/Task.js";
-import { TaskSignal } from "../../../../core/process/task/TaskSignal.js";
-import { max2 } from "../../../../core/math/max2.js";
-import { clamp01 } from "../../../../core/math/clamp01.js";
-
-/**
- *
- * @param {EntityManager} em
- * @param {EntityComponentDataset} ecd
- * @param {number} [timeout] in seconds
- * @returns {Task}
- */
-export function loadVisibleTerrainTiles({
-                                            em,
-                                            ecd,
-                                            timeout = 10
-                                        }) {
-
-    let totalTiles = 0;
-    let loadedTiles = 0;
-    let failedTiles = 0;
-
-    let attempt = 0;
-
-    let failureFlag = false;
-
-    const timeout_milliseconds = timeout * 1000;
-
-    let start_time = 0;
-
-    function init() {
-
-        start_time = Date.now();
-
-        const attemptId = attempt;
-
-        //force update by camera controller, to ensure correct focus is set
-        em.getSystem(TopDownCameraControllerSystem).update(0);
-
-        ecd.traverseComponents(Camera, function (c) {
-            c.updateMatrices();
-        });
-
-        const tiles = [];
-
-        const terrain = obtainTerrain(ecd);
-
-        assert.notEqual(terrain, null, 'terrain not found');
-
-        TerrainSystem.traverseVisibleTiles(ecd, terrain, function (tile) {
-            tiles.push(tile);
-        });
-
-        totalTiles = tiles.length;
-        const tileManager = terrain.__tiles;
-
-        function handleObtainedTile(t) {
-            if (attemptId !== attempt) {
-                return;
-            }
-
-            loadedTiles++;
-        }
-
-        function handleFailedTile(t) {
-            if (attemptId !== attempt) {
-                return;
-            }
-
-            attempt++;
-
-            failedTiles++;
-
-            if (attempt < 10) {
-                init();
-            } else {
-                failureFlag = true;
-            }
-        }
-
-        if (totalTiles !== 0) {
-            tiles.forEach(function (tile) {
-                tileManager.obtain(tile.gridPosition.x, tile.gridPosition.y).then(handleObtainedTile, handleFailedTile);
-            });
-        }
-    }
-
-    const task = new Task({
-        name: "Building visible terrain tiles",
-
-        initializer: init,
-
-        cycleFunction() {
-            if (Date.now() > start_time + timeout_milliseconds) {
-                // timed out
-                return TaskSignal.EndFailure;
-            }
-
-            if (failureFlag) {
-                return TaskSignal.EndFailure;
-            }
-
-            if (loadedTiles >= totalTiles) {
-                return TaskSignal.EndSuccess;
-            } else {
-                return TaskSignal.Yield;
-            }
-        },
-
-        computeProgress() {
-
-            const loaded_fraction = totalTiles === 0 ? 0 : loadedTiles / totalTiles;
-
-            const timeout_fraction = (Date.now() - start_time) / timeout_milliseconds;
-
-            return clamp01(max2(loaded_fraction, timeout_fraction));
-        }
-    });
-
-    return task;
-}
+import TopDownCameraControllerSystem from "../../../graphics/ecs/camera/topdown/TopDownCameraControllerSystem.js";
+import { CameraSystem3 } from "../../../graphics3/CameraSystem3.js";
+import { obtainTerrain } from "./obtainTerrain.js";
+import { assert } from "../../../../core/assert.js";
+import TerrainSystem from "../ecs/TerrainSystem.js";
+import Task from "../../../../core/process/task/Task.js";
+import { TaskSignal } from "../../../../core/process/task/TaskSignal.js";
+import { max2 } from "../../../../core/math/max2.js";
+import { clamp01 } from "../../../../core/math/clamp01.js";
+
+/**
+ *
+ * @param {EntityManager} em
+ * @param {EntityComponentDataset} ecd
+ * @param {number} [timeout] in seconds
+ * @returns {Task}
+ */
+export function loadVisibleTerrainTiles({
+                                            em,
+                                            ecd,
+                                            timeout = 10
+                                        }) {
+
+    let totalTiles = 0;
+    let loadedTiles = 0;
+    let failedTiles = 0;
+
+    let attempt = 0;
+
+    let failureFlag = false;
+
+    const timeout_milliseconds = timeout * 1000;
+
+    let start_time = 0;
+
+    function init() {
+
+        start_time = Date.now();
+
+        const attemptId = attempt;
+
+        //force update by camera controller, to ensure correct focus is set
+        em.getSystem(TopDownCameraControllerSystem).update(0);
+
+        /*
+         And push that pose through to the renderer's camera, which is where the frustum the tile
+         query reads is computed. Without it the tiles waited for are the ones the previous scene
+         could see.
+        */
+        em.getSystem(CameraSystem3).update(0);
+
+        const tiles = [];
+
+        const terrain = obtainTerrain(ecd);
+
+        assert.notEqual(terrain, null, 'terrain not found');
+
+        TerrainSystem.traverseVisibleTiles(ecd, terrain, function (tile) {
+            tiles.push(tile);
+        });
+
+        totalTiles = tiles.length;
+        const tileManager = terrain.__tiles;
+
+        function handleObtainedTile(t) {
+            if (attemptId !== attempt) {
+                return;
+            }
+
+            loadedTiles++;
+        }
+
+        function handleFailedTile(t) {
+            if (attemptId !== attempt) {
+                return;
+            }
+
+            attempt++;
+
+            failedTiles++;
+
+            if (attempt < 10) {
+                init();
+            } else {
+                failureFlag = true;
+            }
+        }
+
+        if (totalTiles !== 0) {
+            tiles.forEach(function (tile) {
+                tileManager.obtain(tile.gridPosition.x, tile.gridPosition.y).then(handleObtainedTile, handleFailedTile);
+            });
+        }
+    }
+
+    const task = new Task({
+        name: "Building visible terrain tiles",
+
+        initializer: init,
+
+        cycleFunction() {
+            if (Date.now() > start_time + timeout_milliseconds) {
+                // timed out
+                return TaskSignal.EndFailure;
+            }
+
+            if (failureFlag) {
+                return TaskSignal.EndFailure;
+            }
+
+            if (loadedTiles >= totalTiles) {
+                return TaskSignal.EndSuccess;
+            } else {
+                return TaskSignal.Yield;
+            }
+        },
+
+        computeProgress() {
+
+            const loaded_fraction = totalTiles === 0 ? 0 : loadedTiles / totalTiles;
+
+            const timeout_fraction = (Date.now() - start_time) / timeout_milliseconds;
+
+            return clamp01(max2(loaded_fraction, timeout_fraction));
+        }
+    });
+
+    return task;
+}

package/src/engine/graphics/ecs/camera/Camera.d.ts

@@ -3,25 +3,23 @@
  */
 export class Camera {
     /**
+     * Whether clipping planes should be automatically calculated or not.
+     *
+     * **Nothing reads this.** The pass that tightened the planes measured the depth range of the
+     * renderer's own layers, which no renderer has offered since the three path was removed; the
+     * field stays because it is on the wire and a level carries it.
      *
-     * @param {Camera|THREE.PerspectiveCamera|THREE.OrthographicCamera} camera
-     * @param {number} x
-     * @param {number} y
-     * @param {Vector3} out_source
-     * @param {Vector3} out_direction
-     */
-    static projectRay(camera: Camera | THREE.PerspectiveCamera | THREE.OrthographicCamera, x: number, y: number, out_source: Vector3, out_direction: Vector3): void;
-    /**
-     * Whether clipping planes should be automatically calculated or not
      * @type {boolean}
      */
     autoClip: boolean;
     /**
      * Tunable parameter to prevent clipping planes from thrashing. Clipping planes must move by a certain portion of the current span before frustum gets shrunken
+     *
+     * Inert for the same reason as {@link autoClip}, and kept for the same one.
+     *
      * @type {number}
      */
     autoClipHysteresis: number;
-    object: any;
     /**
      *
      * @type {Vector1}
@@ -38,29 +36,44 @@ export class Camera {
      */
     active: ObservedBoolean;
     /**
-     * Near clipping plane
+     * Far clipping plane
      * @type {number}
-     * @private
      */
-    private __clip_far;
+    clip_far: number;
     /**
-     * Far clipping plane
+     * Near clipping plane
      * @type {number}
-     * @private
      */
-    private __clip_near;
+    clip_near: number;
+    /**
+     * The planes of the frame this camera last drew — six
+     * `[normal_x, normal_y, normal_z, constant]` tuples, the layout every frustum query in the tree
+     * reads — or `null` when it has not drawn one.
+     *
+     * A method rather than a property because it is not one: the inspector draws a row for every
+     * readable property a component has, and this is an answer the renderer gave, not a field
+     * anybody authors. The planes are rewritten under the caller every tick.
+     *
+     * @returns {Float32Array|null}
+     */
+    getFrustumPlanes(): Float32Array | null;
+    /**
+     * Record the planes the frame was drawn with.
+     *
+     * The renderer's camera is what computes them, because the frustum a gameplay query wants is
+     * the one the picture was actually drawn with; deriving a second one from the field of view
+     * here would need the aspect ratio, which belongs to whatever surface the frame is going out at
+     * and not to a camera entity.
+     *
+     * @param {Float32Array|number[]} planes six `[normal_x, normal_y, normal_z, constant]` tuples
+     */
+    publishFrustum(planes: Float32Array | number[]): void;
     /**
      *
      * @param {Quaternion} output
      * @param {Quaternion} input
      */
     getReciprocalRotation(output: Quaternion, input: Quaternion): void;
-    set clip_far(arg: number);
-    get clip_far(): number;
-    set clip_near(arg: number);
-    get clip_near(): number;
-    updateMatrices(): void;
-    projectRay(x: any, y: any, source: any, target: any): void;
     /**
      *
      * @param {Camera} other
@@ -76,31 +89,7 @@ export class Camera {
         active: boolean;
     };
     fromJSON(json: any): void;
-    /**
-     *
-     * @param {Matrix4} result
-     */
-    computeProjectionMatrix(result: Matrix4): boolean;
-    /**
-     *
-     * @param {Vector3} out
-     * @param {number} origin_x
-     * @param {number} origin_y
-     * @param {number} origin_z
-     * @param {number} direction_x
-     * @param {number} direction_y
-     * @param {number} direction_z
-     * @param {number} plane_index
-     */
-    rayPlaneIntersection(out: Vector3, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, plane_index: number): void;
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     * @param {Vector3} result
-     */
-    projectWorldPointOntoNearPlane(x: number, y: number, z: number, result: Vector3): void;
+    #private;
 }
 export namespace Camera {
     export let typeName: string;
@@ -108,6 +97,5 @@ export namespace Camera {
 }
 import Vector1 from "../../../../core/geom/Vector1.js";
 import ObservedBoolean from "../../../../core/model/ObservedBoolean.js";
-import Vector3 from "../../../../core/geom/Vector3.js";
 import { ProjectionType } from "./ProjectionType.js";
 //# sourceMappingURL=Camera.d.ts.map

package/src/engine/graphics/ecs/camera/Camera.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Camera.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/camera/Camera.js"],"names":[],"mappings":"AAaA;;GAEG;AACH;IA8II;;;;;;;OAOG;IACH,0BANW,MAAM,GAAC,MAAM,iBAAiB,GAAC,MAAM,kBAAkB,KACvD,MAAM,KACN,MAAM,cACN,OAAO,iBACP,OAAO,QA+CjB;IAlMD;;;OAGG;IACH,UAFU,OAAO,CAEA;IAEjB;;;OAGG;IACH,oBAFU,MAAM,CAEU;IAE1B,YAAc;IAEd;;;OAGG;IACH,KAFU,OAAO,CAEK;IAEtB;;;OAGG;IACH,oBAA8E;IAE9E;;;OAGG;IACH,QAFU,eAAe,CAEU;IAEnC;;;;OAIG;IACH,mBAAiB;IAEjB;;;;OAIG;IACH,oBAAkB;IAElB;;;;OAIG;IACH,mEAEC;IAMD,0BAMC;IAVD,uBAEC;IAcD,2BAMC;IAVD,wBAEC;IAUD,uBAaC;IAED,2DAEC;IAED;;;OAGG;IACH,YAFW,MAAM,QAUhB;IAED;;;OAGG;IACH,SAFa,MAAM,CAQlB;IAED;;;MAKC;IAED,0BAQC;IAyDD;;;OAGG;IACH,kDAUC;IAED;;;;;;;;;;OAUG;IACH,0BATW,OAAO,YACP,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,QAyBhB;IAED;;;;;;OAMG;IACH,kCALW,MAAM,KACN,MAAM,KACN,MAAM,UACN,OAAO,QAqBjB;CACJ;;;;;oBAhSmB,kCAAkC;4BAE1B,2CAA2C;oBADnD,kCAAkC;+BAIvB,qBAAqB"}
+{"version":3,"file":"Camera.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/camera/Camera.js"],"names":[],"mappings":"AAMA;;GAEG;AACH;IACI;;;;;;;;OAQG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;;;OAMG;IACH,oBAFU,MAAM,CAEU;IAY1B;;;OAGG;IACH,KAFU,OAAO,CAEK;IAEtB;;;OAGG;IACH,oBAA8E;IAE9E;;;OAGG;IACH,QAFU,eAAe,CAEU;IAEnC;;;OAGG;IACH,UAFU,MAAM,CAED;IAEf;;;OAGG;IACH,WAFU,MAAM,CAEA;IAEhB;;;;;;;;;;OAUG;IACH,oBAFa,YAAY,GAAC,IAAI,CAQ7B;IAED;;;;;;;;;OASG;IACH,uBAFW,YAAY,GAAC,MAAM,EAAE,QAM/B;IAED;;;;OAIG;IACH,mEAEC;IAED;;;OAGG;IACH,YAFW,MAAM,QAUhB;IAED;;;OAGG;IACH,SAFa,MAAM,CAQlB;IAED;;;MAKC;IAED,0BAQC;;CAEJ;;;;;oBA7JmB,kCAAkC;4BAC1B,2CAA2C;+BAExC,qBAAqB"}