@woosh/meep-engine 3.14.6 → 3.16.0

package/src/engine/graphics3/PickingSystem.js

@@ -1,273 +1,273 @@
-import { assert } from "../../core/assert.js";
-import { BVH } from "../../core/bvh2/bvh3/BVH.js";
-import {
-    aabb3_ray_segment_entry_distance
-} from "../../core/geom/3d/aabb/aabb3_ray_segment_entry_distance.js";
-import { BVHQueryIntersectsRay } from "../../core/bvh2/bvh3/query/BVHQueryIntersectsRay.js";
-import { bvh_query_leaves_generic } from "../../core/bvh2/bvh3/query/bvh_query_leaves_generic.js";
-import { System } from "../ecs/System.js";
-import { Transform } from "../ecs/transform/Transform.js";
-import { Pickable } from "./Pickable.js";
-import { PickingResult } from "./PickingResult.js";
-
-/**
- * @type {Float32Array}
- */
-const SCRATCH_BOUNDS = new Float32Array(6);
-
-/**
- * Answers "what is under this ray" for entities that asked to be pickable.
- *
- * **Asynchronous and batched from the first line, on purpose (I-9).** The backend here is a CPU
- * bounding-volume hierarchy and could answer synchronously; the API does not let it, because the
- * backend this is meant to grow into reads entity ids back off the GPU's visibility buffer, and that
- * answer is inherently a frame late and arrives for a whole batch at once. A synchronous entry point
- * would have to be broken to get there, and every caller broken with it.
- *
- * **Bounding boxes, not triangles.** A hit means the ray entered the entity's world bounding box.
- * That is the precision this can offer for free — Shade maintains those boxes as part of drawing —
- * and going finer means keeping CPU-side triangles for every pickable entity, which is the
- * duplication {@link Pickable} exists to keep small. Terrain picking, which is where the game's
- * precision actually matters, does not come through here at all: it is an exact raycast against the
- * terrain's own representation and is untouched by any of this.
- *
- * The index is refreshed **on query rather than per frame**. Nothing pays for picking on a frame where
- * nobody picks, and there is no window in which the index disagrees with the scene, so no class of
- * bug where a pick lands on where something used to be.
- */
-export class PickingSystem extends System {
-    /**
-     * @type {MeshSystem}
-     */
-    #meshes;
-
-    /**
-     * @type {BVH}
-     */
-    #bvh = new BVH();
-
-    /**
-     * The BVH leaf standing for each pickable entity.
-     *
-     * @type {Map<number, number>}
-     */
-    #leaves = new Map();
-
-    /**
-     * Entities that have opted in but have nothing in the scene yet — a model still loading, most
-     * often. They hold no leaf, and every query looks again, which is what lets one appear without
-     * anything having to notice the moment it did.
-     *
-     * @type {Set<number>}
-     */
-    #pending = new Set();
-
-    /**
-     * @param {MeshSystem} meshes what an entity looks like, which is where its bounds come from
-     */
-    constructor(meshes) {
-        super();
-
-        assert.defined(meshes, 'meshes');
-
-        this.#meshes = meshes;
-
-        this.dependencies = [Pickable, Transform];
-    }
-
-    async startup(entityManager) {
-        this.entityManager = entityManager;
-    }
-
-    async shutdown(entityManager) {
-        for (const entity of Array.from(this.#leaves.keys())) {
-            this.#drop(entity);
-        }
-
-        this.#pending.clear();
-    }
-
-    /**
-     * @param {Pickable} pickable
-     * @param {Transform} transform
-     * @param {number} entity
-     */
-    link(pickable, transform, entity) {
-        // no bounds are taken here: the model may not have arrived, and the first query is early
-        // enough to find out
-        this.#pending.add(entity);
-    }
-
-    /**
-     * @param {Pickable} pickable
-     * @param {Transform} transform
-     * @param {number} entity
-     */
-    unlink(pickable, transform, entity) {
-        this.#drop(entity);
-    }
-
-    /**
-     * How many entities the index currently stands for.
-     *
-     * The index is built on query, so this is zero until the first {@link pick} — and stays behind by
-     * however many pickable entities are still waiting on their models.
-     *
-     * @returns {number}
-     */
-    get indexed_count() {
-        return this.#leaves.size;
-    }
-
-    /**
-     * What each of these rays hits first.
-     *
-     * One result per query, in the order the queries were given. A ray that hits nothing still gets a
-     * result — `entity` is {@link PickingResult.NOTHING} — so the two arrays line up by position and a
-     * caller never has to search for the answer to its own question.
-     *
-     * @param {PickingQuery[]} queries
-     * @returns {Promise<PickingResult[]>}
-     */
-    async pick(queries) {
-        assert.isArray(queries, 'queries');
-
-        this.#refresh();
-
-        const results = [];
-
-        for (let i = 0; i < queries.length; i++) {
-            results.push(this.#pick_one(queries[i]));
-        }
-
-        return results;
-    }
-
-    /**
-     * @param {PickingQuery} query
-     * @returns {PickingResult}
-     */
-    #pick_one(query) {
-        const result = new PickingResult();
-
-        const bvh = this.#bvh;
-
-        const origin = query.origin;
-        const direction = query.direction;
-
-        const origin_x = origin.x;
-        const origin_y = origin.y;
-        const origin_z = origin.z;
-
-        const hits = [];
-
-        const hit_count = bvh_query_leaves_generic(
-            hits, 0,
-            bvh, bvh.root,
-            BVHQueryIntersectsRay.from([
-                origin_x, origin_y, origin_z,
-                direction.x, direction.y, direction.z
-            ])
-        );
-
-        // reciprocals once for the whole batch of candidates; the entry-distance test wants them, and
-        // a division component that is zero deliberately produces an infinity it handles
-        const inv_x = 1 / direction.x;
-        const inv_y = 1 / direction.y;
-        const inv_z = 1 / direction.z;
-
-        let best_distance = query.max_distance;
-        let best_entity = PickingResult.NOTHING;
-
-        for (let i = 0; i < hit_count; i++) {
-            const leaf = hits[i];
-
-            bvh.node_get_aabb(leaf, SCRATCH_BOUNDS);
-
-            const distance = aabb3_ray_segment_entry_distance(
-                SCRATCH_BOUNDS[0], SCRATCH_BOUNDS[1], SCRATCH_BOUNDS[2],
-                SCRATCH_BOUNDS[3], SCRATCH_BOUNDS[4], SCRATCH_BOUNDS[5],
-                origin_x, origin_y, origin_z,
-                inv_x, inv_y, inv_z,
-                0, query.max_distance
-            );
-
-            if (distance >= best_distance) {
-                // further than something already found, or a miss the broadphase let through
-                continue;
-            }
-
-            best_distance = distance;
-            best_entity = bvh.node_get_user_data(leaf);
-        }
-
-        if (best_entity === PickingResult.NOTHING) {
-            return result;
-        }
-
-        result.entity = best_entity;
-        result.distance = best_distance;
-
-        result.position.set(
-            origin_x + direction.x * best_distance,
-            origin_y + direction.y * best_distance,
-            origin_z + direction.z * best_distance
-        );
-
-        return result;
-    }
-
-    /**
-     * Bring every leaf in line with where its entity now is, and give a leaf to any entity whose
-     * model has arrived since the last look.
-     */
-    #refresh() {
-        const meshes = this.#meshes;
-
-        for (const [entity, leaf] of this.#leaves) {
-            if (meshes.compute_world_bounds(SCRATCH_BOUNDS, entity)) {
-                this.#bvh.node_move_aabb(leaf, SCRATCH_BOUNDS);
-
-                continue;
-            }
-
-            // the model went away under it — the entity is still pickable, so it goes back to
-            // waiting rather than losing its opt-in
-            this.#drop(entity);
-            this.#pending.add(entity);
-        }
-
-        for (const entity of Array.from(this.#pending)) {
-            if (!meshes.compute_world_bounds(SCRATCH_BOUNDS, entity)) {
-                continue;
-            }
-
-            const leaf = this.#bvh.allocate_node();
-
-            this.#bvh.node_set_aabb(leaf, SCRATCH_BOUNDS);
-            this.#bvh.node_set_user_data(leaf, entity);
-            this.#bvh.insert_leaf(leaf);
-
-            this.#leaves.set(entity, leaf);
-            this.#pending.delete(entity);
-        }
-    }
-
-    /**
-     * @param {number} entity
-     */
-    #drop(entity) {
-        this.#pending.delete(entity);
-
-        const leaf = this.#leaves.get(entity);
-
-        if (leaf === undefined) {
-            return;
-        }
-
-        this.#bvh.remove_leaf(leaf);
-        this.#bvh.release_node(leaf);
-
-        this.#leaves.delete(entity);
-    }
-}
+import { assert } from "../../core/assert.js";
+import { BVH } from "../../core/bvh2/bvh3/BVH.js";
+import {
+    aabb3_ray_segment_entry_distance
+} from "../../core/geom/3d/aabb/aabb3_ray_segment_entry_distance.js";
+import { BVHQueryIntersectsRay } from "../../core/bvh2/bvh3/query/BVHQueryIntersectsRay.js";
+import { bvh_query_leaves_generic } from "../../core/bvh2/bvh3/query/bvh_query_leaves_generic.js";
+import { System } from "../ecs/System.js";
+import { Transform64 } from "../ecs/transform/Transform64.js";
+import { Pickable } from "./Pickable.js";
+import { PickingResult } from "./PickingResult.js";
+
+/**
+ * @type {Float32Array}
+ */
+const SCRATCH_BOUNDS = new Float32Array(6);
+
+/**
+ * Answers "what is under this ray" for entities that asked to be pickable.
+ *
+ * **Asynchronous and batched from the first line, on purpose (I-9).** The backend here is a CPU
+ * bounding-volume hierarchy and could answer synchronously; the API does not let it, because the
+ * backend this is meant to grow into reads entity ids back off the GPU's visibility buffer, and that
+ * answer is inherently a frame late and arrives for a whole batch at once. A synchronous entry point
+ * would have to be broken to get there, and every caller broken with it.
+ *
+ * **Bounding boxes, not triangles.** A hit means the ray entered the entity's world bounding box.
+ * That is the precision this can offer for free — Shade maintains those boxes as part of drawing —
+ * and going finer means keeping CPU-side triangles for every pickable entity, which is the
+ * duplication {@link Pickable} exists to keep small. Terrain picking, which is where the game's
+ * precision actually matters, does not come through here at all: it is an exact raycast against the
+ * terrain's own representation and is untouched by any of this.
+ *
+ * The index is refreshed **on query rather than per frame**. Nothing pays for picking on a frame where
+ * nobody picks, and there is no window in which the index disagrees with the scene, so no class of
+ * bug where a pick lands on where something used to be.
+ */
+export class PickingSystem extends System {
+    /**
+     * @type {MeshSystem}
+     */
+    #meshes;
+
+    /**
+     * @type {BVH}
+     */
+    #bvh = new BVH();
+
+    /**
+     * The BVH leaf standing for each pickable entity.
+     *
+     * @type {Map<number, number>}
+     */
+    #leaves = new Map();
+
+    /**
+     * Entities that have opted in but have nothing in the scene yet — a model still loading, most
+     * often. They hold no leaf, and every query looks again, which is what lets one appear without
+     * anything having to notice the moment it did.
+     *
+     * @type {Set<number>}
+     */
+    #pending = new Set();
+
+    /**
+     * @param {MeshSystem} meshes what an entity looks like, which is where its bounds come from
+     */
+    constructor(meshes) {
+        super();
+
+        assert.defined(meshes, 'meshes');
+
+        this.#meshes = meshes;
+
+        this.dependencies = [Pickable, Transform64];
+    }
+
+    async startup(entityManager) {
+        this.entityManager = entityManager;
+    }
+
+    async shutdown(entityManager) {
+        for (const entity of Array.from(this.#leaves.keys())) {
+            this.#drop(entity);
+        }
+
+        this.#pending.clear();
+    }
+
+    /**
+     * @param {Pickable} pickable
+     * @param {Transform64} transform
+     * @param {number} entity
+     */
+    link(pickable, transform, entity) {
+        // no bounds are taken here: the model may not have arrived, and the first query is early
+        // enough to find out
+        this.#pending.add(entity);
+    }
+
+    /**
+     * @param {Pickable} pickable
+     * @param {Transform64} transform
+     * @param {number} entity
+     */
+    unlink(pickable, transform, entity) {
+        this.#drop(entity);
+    }
+
+    /**
+     * How many entities the index currently stands for.
+     *
+     * The index is built on query, so this is zero until the first {@link pick} — and stays behind by
+     * however many pickable entities are still waiting on their models.
+     *
+     * @returns {number}
+     */
+    get indexed_count() {
+        return this.#leaves.size;
+    }
+
+    /**
+     * What each of these rays hits first.
+     *
+     * One result per query, in the order the queries were given. A ray that hits nothing still gets a
+     * result — `entity` is {@link PickingResult.NOTHING} — so the two arrays line up by position and a
+     * caller never has to search for the answer to its own question.
+     *
+     * @param {PickingQuery[]} queries
+     * @returns {Promise<PickingResult[]>}
+     */
+    async pick(queries) {
+        assert.isArray(queries, 'queries');
+
+        this.#refresh();
+
+        const results = [];
+
+        for (let i = 0; i < queries.length; i++) {
+            results.push(this.#pick_one(queries[i]));
+        }
+
+        return results;
+    }
+
+    /**
+     * @param {PickingQuery} query
+     * @returns {PickingResult}
+     */
+    #pick_one(query) {
+        const result = new PickingResult();
+
+        const bvh = this.#bvh;
+
+        const origin = query.origin;
+        const direction = query.direction;
+
+        const origin_x = origin.x;
+        const origin_y = origin.y;
+        const origin_z = origin.z;
+
+        const hits = [];
+
+        const hit_count = bvh_query_leaves_generic(
+            hits, 0,
+            bvh, bvh.root,
+            BVHQueryIntersectsRay.from([
+                origin_x, origin_y, origin_z,
+                direction.x, direction.y, direction.z
+            ])
+        );
+
+        // reciprocals once for the whole batch of candidates; the entry-distance test wants them, and
+        // a division component that is zero deliberately produces an infinity it handles
+        const inv_x = 1 / direction.x;
+        const inv_y = 1 / direction.y;
+        const inv_z = 1 / direction.z;
+
+        let best_distance = query.max_distance;
+        let best_entity = PickingResult.NOTHING;
+
+        for (let i = 0; i < hit_count; i++) {
+            const leaf = hits[i];
+
+            bvh.node_get_aabb(leaf, SCRATCH_BOUNDS);
+
+            const distance = aabb3_ray_segment_entry_distance(
+                SCRATCH_BOUNDS[0], SCRATCH_BOUNDS[1], SCRATCH_BOUNDS[2],
+                SCRATCH_BOUNDS[3], SCRATCH_BOUNDS[4], SCRATCH_BOUNDS[5],
+                origin_x, origin_y, origin_z,
+                inv_x, inv_y, inv_z,
+                0, query.max_distance
+            );
+
+            if (distance >= best_distance) {
+                // further than something already found, or a miss the broadphase let through
+                continue;
+            }
+
+            best_distance = distance;
+            best_entity = bvh.node_get_user_data(leaf);
+        }
+
+        if (best_entity === PickingResult.NOTHING) {
+            return result;
+        }
+
+        result.entity = best_entity;
+        result.distance = best_distance;
+
+        result.position.set(
+            origin_x + direction.x * best_distance,
+            origin_y + direction.y * best_distance,
+            origin_z + direction.z * best_distance
+        );
+
+        return result;
+    }
+
+    /**
+     * Bring every leaf in line with where its entity now is, and give a leaf to any entity whose
+     * model has arrived since the last look.
+     */
+    #refresh() {
+        const meshes = this.#meshes;
+
+        for (const [entity, leaf] of this.#leaves) {
+            if (meshes.compute_world_bounds(SCRATCH_BOUNDS, entity)) {
+                this.#bvh.node_move_aabb(leaf, SCRATCH_BOUNDS);
+
+                continue;
+            }
+
+            // the model went away under it — the entity is still pickable, so it goes back to
+            // waiting rather than losing its opt-in
+            this.#drop(entity);
+            this.#pending.add(entity);
+        }
+
+        for (const entity of Array.from(this.#pending)) {
+            if (!meshes.compute_world_bounds(SCRATCH_BOUNDS, entity)) {
+                continue;
+            }
+
+            const leaf = this.#bvh.allocate_node();
+
+            this.#bvh.node_set_aabb(leaf, SCRATCH_BOUNDS);
+            this.#bvh.node_set_user_data(leaf, entity);
+            this.#bvh.insert_leaf(leaf);
+
+            this.#leaves.set(entity, leaf);
+            this.#pending.delete(entity);
+        }
+    }
+
+    /**
+     * @param {number} entity
+     */
+    #drop(entity) {
+        this.#pending.delete(entity);
+
+        const leaf = this.#leaves.get(entity);
+
+        if (leaf === undefined) {
+            return;
+        }
+
+        this.#bvh.remove_leaf(leaf);
+        this.#bvh.release_node(leaf);
+
+        this.#leaves.delete(entity);
+    }
+}

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

@@ -24,24 +24,24 @@ export class ShadedGeometrySystem extends System<any> {
      * @param {Scene} scene
      */
     constructor(graphics: GraphicsEngine, scene: Scene);
-    dependencies: (typeof Transform | typeof ShadedGeometry)[];
+    dependencies: (typeof Transform64 | typeof ShadedGeometry)[];
     startup(entityManager: any): Promise<void>;
     shutdown(entityManager: any): Promise<void>;
     /**
      * @param {ShadedGeometry} geometry
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
-    link(geometry: ShadedGeometry, transform: Transform, entity: number): void;
+    link(geometry: ShadedGeometry, transform: Transform64, entity: number): void;
     /**
      * @param {ShadedGeometry} geometry
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
-    unlink(geometry: ShadedGeometry, transform: Transform, entity: number): void;
+    unlink(geometry: ShadedGeometry, transform: Transform64, entity: number): void;
     #private;
 }
 import { System } from "../ecs/System.js";
-import { Transform } from "../ecs/transform/Transform.js";
+import { Transform64 } from "../ecs/transform/Transform64.js";
 import { ShadedGeometry } from "../graphics/ecs/mesh-v2/ShadedGeometry.js";
 //# sourceMappingURL=ShadedGeometrySystem.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ShadedGeometrySystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ShadedGeometrySystem.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAkBI;;;OAGG;IACH,oDAUC;IADG,2DAA+C;IAGnD,2CAEC;IAED,4CAIC;IAED;;;;OAIG;IACH,eAJW,cAAc,aACd,SAAS,UACT,MAAM,QA2ChB;IAED;;;;OAIG;IACH,iBAJW,cAAc,aACd,SAAS,UACT,MAAM,QAMhB;;CAsCJ;uBApKsB,kBAAkB;0BACf,+BAA+B;+BAE1B,2CAA2C"}
+{"version":3,"file":"ShadedGeometrySystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ShadedGeometrySystem.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAkBI;;;OAGG;IACH,oDAUC;IADG,6DAAiD;IAGrD,2CAEC;IAED,4CAIC;IAED;;;;OAIG;IACH,eAJW,cAAc,aACd,WAAW,UACX,MAAM,QAgDhB;IAED;;;;OAIG;IACH,iBAJW,cAAc,aACd,WAAW,UACX,MAAM,QAMhB;;CA4CJ;uBA/KsB,kBAAkB;4BACb,iCAAiC;+BAC9B,2CAA2C"}