@woosh/meep-engine 2.87.6 → 2.88.0

package/build/meep.module.js

@@ -50994,7 +50994,7 @@ function computeStringHash(string) {
 class ObservedString extends String {
     /**
      *
-     * @param {String} [value]
+     * @param {string} [value]
      * @constructor
      */
     constructor(value = "") {
@@ -52622,8 +52622,10 @@ class BVH {
         let index = this.__root;
 
         while (this.node_is_leaf(index) === false) {
-            const child1 = uint32[index * ELEMENT_WORD_COUNT + COLUMN_CHILD_1];
-            const child2 = uint32[index * ELEMENT_WORD_COUNT + COLUMN_CHILD_2];
+            const node_address = index * ELEMENT_WORD_COUNT;
+
+            const child1 = uint32[node_address + COLUMN_CHILD_1];
+            const child2 = uint32[node_address + COLUMN_CHILD_2];
 
             const area = this.node_get_surface_area(index);
 
@@ -73701,6 +73703,10 @@ function assetTypeByPath(url) {
 }
 
 class Name extends ObservedString {
+    /**
+     *
+     * @param {string} [value]
+     */
     constructor(value = "") {
         super(value);
     }

package/editor/view/ecs/HierarchicalEntityListView.js

@@ -1,8 +1,8 @@
-import Name from "../../../../model/game/ecs/component/Name.js";
 import { arraySetSortingDiff } from "../../../src/core/collection/array/arraySetSortingDiff.js";
 import List from "../../../src/core/collection/list/List.js";
 import Signal from "../../../src/core/events/signal/Signal.js";
 import { number_compare_ascending } from "../../../src/core/primitives/numbers/number_compare_ascending.js";
+import Name from "../../../src/engine/ecs/name/Name.js";
 import { ParentEntity } from "../../../src/engine/ecs/parent/ParentEntity.js";
 import { MouseEvents } from "../../../src/engine/input/devices/events/MouseEvents.js";
 import LabelView from "../../../src/view/common/LabelView.js";

package/editor/view/v2/prototypeEditor.js

@@ -1,9 +1,9 @@
-import Name from "../../../../model/game/ecs/component/Name.js";
 import { initializeEditor } from "../../../../model/game/initializeEditor.js";
 import { randomFromArray } from "../../../src/core/math/random/randomFromArray.js";
 import { randomIntegerBetween } from "../../../src/core/math/random/randomIntegerBetween.js";
 import { seededRandom } from "../../../src/core/math/random/seededRandom.js";
 import { TextureAssetLoader } from "../../../src/engine/asset/loaders/texture/TextureAssetLoader.js";
+import Name from "../../../src/engine/ecs/name/Name.js";
 import { EntityNode } from "../../../src/engine/ecs/parent/EntityNode.js";
 import { Transform } from "../../../src/engine/ecs/transform/Transform.js";
 import { EngineHarness } from "../../../src/engine/EngineHarness.js";

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.87.6",
+  "version": "2.88.0",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/bvh2/bvh3/BVH.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BVH.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/BVH.js"],"names":[],"mappings":"AAQA,8BAA+B;AAC/B,+BAAgC;AAChC,+BAAgC;AAChC,8BAA+B;AAU/B;;;GAGG;AACH,wBAFU,MAAM,CAEoB;AAcpC;;;;;GAKG;AACH,iCAFU,MAAM,CAEqB;AAgBrC;;;;;;GAMG;AACH;IAEI;;;;OAIG;IACH,sBAA2E;IAE3E;;;;OAIG;IACH,uBAAsD;IAEtD;;;;OAIG;IACH,sBAAoD;IAEpD;;;;OAIG;IACH,mBAA8B;IAE9B;;;;OAIG;IACH,eAAW;IAEX;;;;OAIG;IACH,eAAY;IAEZ;;;;OAIG;IACH,uBAAmB;IAEnB;;;;OAIG;IACH,eAAmB;IAEnB;;;OAGG;IACH,mBAEC;IAUD;;;OAGG;IACH,+BAMC;IAlBD;;;OAGG;IACH,4BAEC;IAcD,wBAgBC;IAED;;;;OAIG;IACH,uBAqBC;IAED;;OAEG;IACH,aAIC;IAED;;;OAGG;IACH,iBAFa,MAAM,CAqDlB;IAED;;;;OAIG;IACH,iBAFW,MAAM,QAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,OAAO,CAOnB;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,uBAHW,MAAM,SACN,MAAM,QAOhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAGD;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,oBAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;OAIG;IACH,kBAHW,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,QAe/B;IAED;;;;OAIG;IACH,kBAHW,MAAM,QACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,QAsBpC;IAED;;;;OAIG;IACH,mBAHW,MAAM,QACN,MAAM,EAAE,QAWlB;IAED;;;;;;;;;OASG;IACH,4BARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAmBhB;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,MAAM,CAoBlB;IAED;;;;;OAKG;IACH,wCAJW,MAAM,WACN,MAAM,GACJ,MAAM,CAoClB;IAED;;;;;OAKG;IACH,oCAJW,MAAM,WACN,MAAM,WACN,MAAM,QAyChB;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,IAAI,CAwGhB;IAED;;;;;OAKG;IACH,wBAuBC;IAED;;;;OAIG;IACH,yBA4BC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,IAAI,CA6ChB;IAED;;;;;;OAMG;IACH,gBAoMC;IAED;;;OAGG;IACH,oBAIC;IAED;;;;OAIG;IACH,yCA8BC;IAED;;;;;OAKG;IACH,+BAJW,MAAM,EAAE,sBACR,MAAM,GACJ,MAAM,CAWlB;IAED;;;;;OAKG;IACH,0BA6BC;IAED;;;;;OAKG;IACH,cAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAsCnB;CACJ"}
+{"version":3,"file":"BVH.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/BVH.js"],"names":[],"mappings":"AAQA,8BAA+B;AAC/B,+BAAgC;AAChC,+BAAgC;AAChC,8BAA+B;AAU/B;;;GAGG;AACH,wBAFU,MAAM,CAEoB;AAcpC;;;;;GAKG;AACH,iCAFU,MAAM,CAEqB;AAgBrC;;;;;;GAMG;AACH;IAEI;;;;OAIG;IACH,sBAA2E;IAE3E;;;;OAIG;IACH,uBAAsD;IAEtD;;;;OAIG;IACH,sBAAoD;IAEpD;;;;OAIG;IACH,mBAA8B;IAE9B;;;;OAIG;IACH,eAAW;IAEX;;;;OAIG;IACH,eAAY;IAEZ;;;;OAIG;IACH,uBAAmB;IAEnB;;;;OAIG;IACH,eAAmB;IAEnB;;;OAGG;IACH,mBAEC;IAUD;;;OAGG;IACH,+BAMC;IAlBD;;;OAGG;IACH,4BAEC;IAcD,wBAgBC;IAED;;;;OAIG;IACH,uBAqBC;IAED;;OAEG;IACH,aAIC;IAED;;;OAGG;IACH,iBAFa,MAAM,CAqDlB;IAED;;;;OAIG;IACH,iBAFW,MAAM,QAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,OAAO,CAOnB;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,uBAHW,MAAM,SACN,MAAM,QAOhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAGD;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,oBAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;OAIG;IACH,kBAHW,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,QAe/B;IAED;;;;OAIG;IACH,kBAHW,MAAM,QACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,QAsBpC;IAED;;;;OAIG;IACH,mBAHW,MAAM,QACN,MAAM,EAAE,QAWlB;IAED;;;;;;;;;OASG;IACH,4BARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAmBhB;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,MAAM,CAoBlB;IAED;;;;;OAKG;IACH,wCAJW,MAAM,WACN,MAAM,GACJ,MAAM,CAoClB;IAED;;;;;OAKG;IACH,oCAJW,MAAM,WACN,MAAM,WACN,MAAM,QAyChB;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,IAAI,CA0GhB;IAED;;;;;OAKG;IACH,wBAuBC;IAED;;;;OAIG;IACH,yBA4BC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,IAAI,CA6ChB;IAED;;;;;;OAMG;IACH,gBAoMC;IAED;;;OAGG;IACH,oBAIC;IAED;;;;OAIG;IACH,yCA8BC;IAED;;;;;OAKG;IACH,+BAJW,MAAM,EAAE,sBACR,MAAM,GACJ,MAAM,CAWlB;IAED;;;;;OAKG;IACH,0BA6BC;IAED;;;;;OAKG;IACH,cAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAsCnB;CACJ"}

package/src/core/bvh2/bvh3/BVH.js

@@ -617,8 +617,10 @@ export class BVH {
         let index = this.__root;
 
         while (this.node_is_leaf(index) === false) {
-            const child1 = uint32[index * ELEMENT_WORD_COUNT + COLUMN_CHILD_1];
-            const child2 = uint32[index * ELEMENT_WORD_COUNT + COLUMN_CHILD_2];
+            const node_address = index * ELEMENT_WORD_COUNT;
+
+            const child1 = uint32[node_address + COLUMN_CHILD_1];
+            const child2 = uint32[node_address + COLUMN_CHILD_2];
 
             const area = this.node_get_surface_area(index);
 

package/src/core/bvh2/bvh3/BVH.spec.js

@@ -305,7 +305,7 @@ test("move leaf node", () => {
     expect(actual_bounds).toEqual(a_new_bounds);
 });
 
-test.skip("performance, insert 10k random nodes", () => {
+test.skip("performance, insert 100k random nodes", () => {
 
     const random = seededRandom(1);
 
@@ -314,9 +314,9 @@ test.skip("performance, insert 10k random nodes", () => {
     const min_bound = -1000;
     const max_bound = 1000;
 
-    const OBJECT_COUNT = 1000000;
-
+    const OBJECT_COUNT = 100000;
 
+    const leaves = new Uint32Array(OBJECT_COUNT);
     for (let i = 0; i < OBJECT_COUNT; i++) {
         const node = bvh.allocate_node();
 
@@ -343,7 +343,19 @@ test.skip("performance, insert 10k random nodes", () => {
             x0, y0, z0,
             x1, y1, z1
         );
+    }
+
+    const t0 = performance.now();
+    for (let i = 0; i < OBJECT_COUNT; i++) {
+        const node = leaves[i];
 
         bvh.insert_leaf(node);
     }
+
+    const duration = performance.now() - t0;
+
+    const duration_seconds = duration * 1e-3;
+
+    console.log(`Duration ${duration_seconds}s, ${(OBJECT_COUNT / duration_seconds).toFixed(2)} records per second`);
+
 });

package/src/core/geom/2d/aabb/aabb2_clip_line_cohen_sutherland.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Implements Cohen–Sutherland algorithm
+ * @param {number[]|Float32Array|Float64Array} result
+ * @param {number} result_offset
+ * @param {number} box_x0
+ * @param {number} box_y0
+ * @param {number} box_x1
+ * @param {number} box_y1
+ * @param {number} line_x0
+ * @param {number} line_y0
+ * @param {number} line_x1
+ * @param {number} line_y1
+ * @returns {boolean}
+ */
+export function aabb2_clip_line_cohen_sutherland(result: number[] | Float32Array | Float64Array, result_offset: number, box_x0: number, box_y0: number, box_x1: number, box_y1: number, line_x0: number, line_y0: number, line_x1: number, line_y1: number): boolean;
+//# sourceMappingURL=aabb2_clip_line_cohen_sutherland.d.ts.map

package/src/core/geom/2d/aabb/aabb2_clip_line_cohen_sutherland.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aabb2_clip_line_cohen_sutherland.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/aabb/aabb2_clip_line_cohen_sutherland.js"],"names":[],"mappings":"AA0CA;;;;;;;;;;;;;GAaG;AACH,yDAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,GACJ,OAAO,CA8FnB"}

package/src/core/geom/2d/aabb/aabb2_clip_line_cohen_sutherland.js

@@ -0,0 +1,149 @@
+const INSIDE = 0; // 0000
+const LEFT = 1;   // 0001
+const RIGHT = 2;  // 0010
+const BOTTOM = 4; // 0100
+const TOP = 8;    // 1000
+
+/**
+ * Compute the bit code for a point (x, y) using the clip rectangle
+ * @param {number} box_x0
+ * @param {number} box_y0
+ * @param {number} box_x1
+ * @param {number} box_y1
+ * @param {number} x
+ * @param {number} y
+ * @return {number}
+ */
+function compute_out_code(
+    box_x0, box_y0,
+    box_x1, box_y1,
+    x, y
+) {
+    let code = INSIDE;  // initialised as being inside of clip window
+
+    if (x < box_x0) {
+        // to the left of clip window
+        code |= LEFT;
+    } else if (x > box_x1) {
+        // to the right of clip window
+        code |= RIGHT;
+    }
+
+    if (y < box_y0) {
+        // below the clip window
+        code |= BOTTOM;
+    } else if (y > box_y1) {
+        // above the clip window
+        code |= TOP;
+    }
+
+    return code;
+}
+
+/**
+ * Implements Cohen–Sutherland algorithm
+ * @param {number[]|Float32Array|Float64Array} result
+ * @param {number} result_offset
+ * @param {number} box_x0
+ * @param {number} box_y0
+ * @param {number} box_x1
+ * @param {number} box_y1
+ * @param {number} line_x0
+ * @param {number} line_y0
+ * @param {number} line_x1
+ * @param {number} line_y1
+ * @returns {boolean}
+ */
+export function aabb2_clip_line_cohen_sutherland(
+    result, result_offset,
+    box_x0, box_y0,
+    box_x1, box_y1,
+    line_x0, line_y0,
+    line_x1, line_y1
+) {
+    let x0 = line_x0;
+    let y0 = line_y0;
+    let x1 = line_x1;
+    let y1 = line_y1;
+
+    // compute out codes for P0, P1, and whatever point lies outside the clip rectangle
+    let out_code_0 = compute_out_code(
+        box_x0, box_y0,
+        box_x1, box_y1,
+        x0, y0
+    );
+    let out_code_1 = compute_out_code(
+        box_x0, box_y0,
+        box_x1, box_y1,
+        x1, y1
+    );
+
+    let x, y;
+
+    while (true) {
+        if ((out_code_0 | out_code_1) === 0) {
+            // bitwise OR is 0: both points inside window; trivially accept and exit loop
+
+            result[result_offset] = x0;
+            result[result_offset + 1] = y0;
+            result[result_offset + 2] = x1;
+            result[result_offset + 3] = y1;
+
+            return true;
+        } else if ((out_code_0 & out_code_1) !== 0) {
+            // bitwise AND is not 0: both points share an outside zone (LEFT, RIGHT, TOP,
+            // or BOTTOM), so both must be outside window; exit loop (accept is false)
+            return false;
+        } else {
+            // failed both tests, so calculate the line segment to clip
+            // from an outside point to an intersection with clip edge
+
+            // At least one endpoint is outside the clip rectangle; pick it.
+            const outcodeOut = out_code_1 > out_code_0 ? out_code_1 : out_code_0;
+
+            // Now find the intersection point;
+            // use formulas:
+            //   slope = (y1 - y0) / (x1 - x0)
+            //   x = x0 + (1 / slope) * (ym - y0), where ym is ymin or ymax
+            //   y = y0 + slope * (xm - x0), where xm is xmin or xmax
+            // No need to worry about divide-by-zero because, in each case, the
+            // outcode bit being tested guarantees the denominator is non-zero
+            if (outcodeOut & TOP) {
+                // point is above the clip window
+                x = x0 + (x1 - x0) * (box_y1 - y0) / (y1 - y0);
+                y = box_y1;
+            } else if (outcodeOut & BOTTOM) {
+                // point is below the clip window
+                x = x0 + (x1 - x0) * (box_y0 - y0) / (y1 - y0);
+                y = box_y0;
+            } else if (outcodeOut & RIGHT) {
+                // point is to the right of clip window
+                y = y0 + (y1 - y0) * (box_x1 - x0) / (x1 - x0);
+                x = box_x1;
+            } else if (outcodeOut & LEFT) {
+                // point is to the left of clip window
+                y = y0 + (y1 - y0) * (box_x0 - x0) / (x1 - x0);
+                x = box_x0;
+            }
+
+            // Now we move outside point to intersection point to clip
+            // and get ready for next pass.
+            if (outcodeOut === out_code_0) {
+                x0 = x;
+                y0 = y;
+                out_code_0 = compute_out_code(
+                    box_x0, box_y0,
+                    box_x1, box_y1, x0, y0
+                );
+            } else {
+                x1 = x;
+                y1 = y;
+                out_code_1 = compute_out_code(
+                    box_x0, box_y0,
+                    box_x1, box_y1,
+                    x1, y1
+                );
+            }
+        }
+    }
+}

package/src/core/geom/2d/aabb/aabb2_intersects_circle.d.ts

@@ -0,0 +1,13 @@
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} center_x
+ * @param {number} center_y
+ * @param {number} radius
+ * @return {boolean}
+ */
+export function aabb2_intersects_circle(x0: number, y0: number, x1: number, y1: number, center_x: number, center_y: number, radius: number): boolean;
+//# sourceMappingURL=aabb2_intersects_circle.d.ts.map

package/src/core/geom/2d/aabb/aabb2_intersects_circle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aabb2_intersects_circle.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/aabb/aabb2_intersects_circle.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,4CATW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,YACN,MAAM,YACN,MAAM,UACN,MAAM,GACL,OAAO,CAelB"}

package/src/core/geom/2d/aabb/aabb2_intersects_circle.js

@@ -0,0 +1,27 @@
+import { aabb2_distance_sqr_to_point } from "./aabb2_distance_sqr_to_point.js";
+
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} center_x
+ * @param {number} center_y
+ * @param {number} radius
+ * @return {boolean}
+ */
+export function aabb2_intersects_circle(
+    x0, y0,
+    x1, y1,
+    center_x, center_y, radius
+) {
+
+    const distance_to_center = aabb2_distance_sqr_to_point(
+        x0, y0,
+        x1, y1,
+        center_x, center_y
+    );
+
+    return distance_to_center < radius * radius;
+}

package/src/core/geom/2d/hash-grid/SpatialHashGrid.d.ts

@@ -1,7 +1,23 @@
+export const NULL_POINTER: number;
+export const COLUMN_ELEMENT_X0: 2;
+export const COLUMN_ELEMENT_Y0: 3;
+export const COLUMN_ELEMENT_X1: 4;
+export const COLUMN_ELEMENT_Y1: 5;
 export class SpatialHashGrid {
     constructor(size_x?: number, size_y?: number, scale?: number);
+    get size_x(): number;
+    get size_y(): number;
+    get node_pool(): BinaryElementPool;
+    /**
+     *
+     * @return {BinaryElementPool}
+     */
+    get element_pool(): BinaryElementPool;
+    get scale(): number;
+    get scale_inverse(): number;
     element_allocate(): number;
     element_set_user_data(element: any, user_data: any): void;
+    element_get_user_data(element: any): number;
     /**
      * You have to remove the element from the grid before changing its bounds
      * @param {number} element
@@ -21,20 +37,38 @@ export class SpatialHashGrid {
      * @param {number} element
      */
     element_insert(element: number): void;
+    /**
+     *
+     * @param {number} node
+     * @return {number}
+     */
+    node_get_element(node: number): number;
+    /**
+     * Next element in the linked list of cell's nodes
+     * @param {number} node
+     * @return {number}
+     */
+    node_get_same_cell_next_node(node: number): number;
+    /**
+     *
+     * @param {number} cell_index
+     * @return {number}
+     */
+    cell_get_first_node(cell_index: number): number;
     /**
      *
      * @param {number} x
      * @param {number} y
-     * @returns {number}
+     * @return {number}
      */
-    cell_position_to_index(x: number, y: number): number;
+    world_position_to_cell_index(x: number, y: number): number;
     /**
      *
-     * @param {number[]} out
-     * @param {number} out_offset
-     * @param {number} index
+     * @param {number} x
+     * @param {number} y
+     * @returns {number}
      */
-    cell_index_to_position(out: number[], out_offset: number, index: number): void;
+    cell_position_to_index(x: number, y: number): number;
     /**
      *
      * @param {number} cell_x
@@ -49,4 +83,5 @@ export class SpatialHashGrid {
     element_remove(element: number): void;
     #private;
 }
+import { BinaryElementPool } from "../../3d/topology/struct/binary/BinaryElementPool.js";
 //# sourceMappingURL=SpatialHashGrid.d.ts.map

package/src/core/geom/2d/hash-grid/SpatialHashGrid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpatialHashGrid.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/hash-grid/SpatialHashGrid.js"],"names":[],"mappings":"AAsCA;IAWI,8DAYC;IAQD,2BAIC;IAED,0DAKC;IAED;;;;;;;OAOG;IACH,sCANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAYhB;IAED;;;OAGG;IACH,yBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,wBAFW,MAAM,QA8BhB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAalB;IAED;;;;;OAKG;IACH,4BAJW,MAAM,EAAE,cACR,MAAM,SACN,MAAM,QAOhB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,UACN,MAAM,GACL,OAAO,CAclB;IA0FD;;;OAGG;IACH,wBAFW,MAAM,QA6BhB;;CACJ"}
+{"version":3,"file":"SpatialHashGrid.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/hash-grid/SpatialHashGrid.js"],"names":[],"mappings":"AAMA,kCAAuC;AA2BvC,kCAAmC;AACnC,kCAAmC;AACnC,kCAAmC;AACnC,kCAAmC;AAEnC;IAuCI,8DAYC;IAxCD,qBAEC;IAED,qBAEC;IAED,mCAEC;IAED;;;OAGG;IACH,sCAEC;IAED,oBAEC;IAED,4BAEC;IAsBD,2BAIC;IAED,0DAKC;IAED,4CAKC;IAED;;;;;;;OAOG;IACH,sCANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAYhB;IAED;;;OAGG;IACH,yBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,wBAFW,MAAM,QA8BhB;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACL,MAAM,CAKjB;IAED;;;;OAIG;IACH,mCAHW,MAAM,GACL,MAAM,CAMjB;IAED;;;;OAIG;IACH,gCAHW,MAAM,GACL,MAAM,CAMjB;IAED;;;;;OAKG;IACH,gCAJW,MAAM,KACN,MAAM,GACL,MAAM,CAOjB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAgBlB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,UACN,MAAM,GACL,OAAO,CAclB;IA0FD;;;OAGG;IACH,wBAFW,MAAM,QA6BhB;;CACJ;kCA/XiC,sDAAsD"}

package/src/core/geom/2d/hash-grid/SpatialHashGrid.js

@@ -1,10 +1,10 @@
 import { assert } from "../../../assert.js";
 import { UINT32_MAX } from "../../../binary/UINT32_MAX.js";
-import { de_interleave_2_bits } from "../../3d/morton/de_interleave_bits_by_2.js";
+import { clamp } from "../../../math/clamp.js";
 import { BinaryElementPool } from "../../3d/topology/struct/binary/BinaryElementPool.js";
 
 
-const NULL_POINTER = UINT32_MAX;
+export const NULL_POINTER = UINT32_MAX;
 /**
  * Single-linked list
  * Pointer to next NODE in the same grid cell
@@ -31,10 +31,10 @@ const COLUMN_NODE_GRID_INDEX = 3;
 
 const COLUMN_ELEMENT_DATA = 0;
 const COLUMN_ELEMENT_NODE_FIRST = 1;
-const COLUMN_ELEMENT_X0 = 2;
-const COLUMN_ELEMENT_Y0 = 3;
-const COLUMN_ELEMENT_X1 = 4;
-const COLUMN_ELEMENT_Y1 = 5;
+export const COLUMN_ELEMENT_X0 = 2;
+export const COLUMN_ELEMENT_Y0 = 3;
+export const COLUMN_ELEMENT_X1 = 4;
+export const COLUMN_ELEMENT_Y1 = 5;
 
 export class SpatialHashGrid {
     #element_pool = new BinaryElementPool(24)
@@ -47,6 +47,34 @@ export class SpatialHashGrid {
     #scale = 1;
     #scale_inverse = 1;
 
+    get size_x() {
+        return this.#size_x;
+    }
+
+    get size_y() {
+        return this.#size_y;
+    }
+
+    get node_pool() {
+        return this.#node_pool;
+    }
+
+    /**
+     *
+     * @return {BinaryElementPool}
+     */
+    get element_pool() {
+        return this.#element_pool;
+    }
+
+    get scale() {
+        return this.#scale;
+    }
+
+    get scale_inverse() {
+        return this.#scale_inverse;
+    }
+
     constructor(size_x = 1, size_y = 1, scale = 8) {
 
         assert.notNaN(scale, "scale");
@@ -80,6 +108,13 @@ export class SpatialHashGrid {
         pool.data_uint32[address + COLUMN_ELEMENT_DATA] = user_data;
     }
 
+    element_get_user_data(element) {
+        const pool = this.#element_pool;
+        const address = pool.element_word(element);
+
+        return pool.data_uint32[address + COLUMN_ELEMENT_DATA];
+    }
+
     /**
      * You have to remove the element from the grid before changing its bounds
      * @param {number} element
@@ -142,6 +177,51 @@ export class SpatialHashGrid {
         }
     }
 
+    /**
+     *
+     * @param {number} node
+     * @return {number}
+     */
+    node_get_element(node) {
+        const address = this.#node_pool.element_word(node);
+        return this.#node_pool.data_uint32[address + COLUMN_NODE_ELEMENT];
+    }
+
+    /**
+     * Next element in the linked list of cell's nodes
+     * @param {number} node
+     * @return {number}
+     */
+    node_get_same_cell_next_node(node) {
+        const address = this.#node_pool.element_word(node);
+
+        return this.#node_pool.data_uint32[address + COLUMN_NODE_SAME_NODE_NEXT];
+    }
+
+    /**
+     *
+     * @param {number} cell_index
+     * @return {number}
+     */
+    cell_get_first_node(cell_index) {
+        assert.lessThan(cell_index, this.#size_x * this.#size_y);
+
+        return this.#grid_data[cell_index]
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @return {number}
+     */
+    world_position_to_cell_index(x, y) {
+        const grid_x = clamp(Math.floor(x * this.#scale_inverse), 0, this.#size_x - 1);
+        const grid_y = clamp(Math.floor(y * this.#scale_inverse), 0, this.#size_y - 1);
+
+        return this.cell_position_to_index(grid_x, grid_y);
+    }
+
     /**
      *
      * @param {number} x
@@ -152,26 +232,16 @@ export class SpatialHashGrid {
         assert.isNonNegativeInteger(x, 'x');
         assert.isNonNegativeInteger(y, 'y');
 
-        return  y* this.#size_x + x;
-
+        return y * this.#size_x + x;
 
+        // const cell_count = this.#size_x * this.#size_y;
+        //
         // const _x = split_by_2(x);
         // const _y = split_by_2(y);
         //
-        // return _x | (_y << 1);
-    }
-
-    /**
-     *
-     * @param {number[]} out
-     * @param {number} out_offset
-     * @param {number} index
-     */
-    cell_index_to_position(out, out_offset, index) {
-
-        out[out_offset] = de_interleave_2_bits(index)
-        out[out_offset + 1] = de_interleave_2_bits(index >> 1)
-
+        // const hash = _x | (_y << 1);
+        //
+        // return hash % cell_count;
     }
 
     /**