@woosh/meep-engine 2.87.3 → 2.87.5

package/build/meep.module.js

@@ -54997,7 +54997,7 @@ function aabb3_compute_half_surface_area(x0, y0, z0, x1, y1, z1) {
  * method to separate bits from a given integer 3 positions apart
  * we only look at the first 10 bits
  *
- * @example when input is ABC, output bits are A00B00C
+ * @example when input is ABC, output bits are 00A00B00C
  * @param {number} a
  * @returns {number}
  */
@@ -105806,8 +105806,8 @@ class QuadTreeNode extends AABB2 {
                 }
             }
 
-            const xm = (x0 + x1) / 2;
-            const ym = (y0 + y1) / 2;
+            const xm = (x0 + x1) *0.5;
+            const ym = (y0 + y1) *0.5;
 
             if (datum.y1 < ym) {
                 //top
@@ -105821,7 +105821,7 @@ class QuadTreeNode extends AABB2 {
                     this.addDatum(datum);
                 }
             } else if (datum.y0 >= ym) {
-                //top
+                //bottom
                 if (datum.x1 < xm) {
                     //left
                     this.bottomLeft.insertDatum(datum);

package/package.json

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

package/src/core/binary/align_4.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Align on 4 byte boundary
+ * @param {number} n
+ * @return {number}
+ */
+export function align_4(n: number): number;
+//# sourceMappingURL=align_4.d.ts.map

package/src/core/binary/align_4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"align_4.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/align_4.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,2BAHW,MAAM,GACL,MAAM,CAQjB"}

package/src/core/binary/align_4.js

@@ -0,0 +1,14 @@
+import { assert } from "../assert.js";
+
+/**
+ * Align on 4 byte boundary
+ * @param {number} n
+ * @return {number}
+ */
+export function align_4(n) {
+    const result = ((n + 0x3) >> 2) << 2;
+
+    assert.greaterThanOrEqual(result, n, 'aligned result must be >= input');
+
+    return result;
+}

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

@@ -0,0 +1,14 @@
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @return {boolean} true if hit found and false otherwise
+ */
+export function aabb2_intersects_ray(x0: number, y0: number, x1: number, y1: number, origin_x: number, origin_y: number, direction_x: number, direction_y: number): boolean;
+//# sourceMappingURL=aabb2_intersects_ray.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aabb2_intersects_ray.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/aabb/aabb2_intersects_ray.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,yCAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,GACL,OAAO,CAqClB"}

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

@@ -0,0 +1,50 @@
+import { fabsf } from "../../../math/fabsf.js";
+
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @return {boolean} true if hit found and false otherwise
+ */
+export function aabb2_intersects_ray(
+    x0, y0,
+    x1, y1,
+    origin_x, origin_y,
+    direction_x, direction_y
+) {
+    // Z Projection
+    const extents_x = (x1 - x0) * 0.5;
+
+    const center_x = x0 + extents_x;
+
+    const diff_x = origin_x - center_x;
+
+    if (diff_x * direction_x >= 0.0 && fabsf(diff_x) > extents_x) {
+        return false;
+    }
+
+    // Y projection
+    const extents_y = (y1 - y0) * 0.5;
+
+    const center_y = y0 + extents_y;
+
+    const diff_y = origin_y - center_y;
+
+    if (diff_y * direction_y >= 0.0 && fabsf(diff_y) > extents_y) {
+        return false;
+    }
+
+    const abs_direction_y = fabsf(direction_y);
+
+    const abs_direction_x = fabsf(direction_x);
+
+    const f2 = fabsf(direction_x * diff_y - direction_y * diff_x);
+
+    return f2 <= extents_x * abs_direction_y + extents_y * abs_direction_x;
+}

package/src/core/geom/2d/aabb/aabb2_intersects_ray.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=aabb2_intersects_ray.spec.d.ts.map

package/src/core/geom/2d/aabb/aabb2_intersects_ray.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aabb2_intersects_ray.spec.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/aabb/aabb2_intersects_ray.spec.js"],"names":[],"mappings":""}

package/src/core/geom/2d/aabb/aabb2_intersects_ray.spec.js

@@ -0,0 +1,28 @@
+import { aabb2_intersects_ray } from "./aabb2_intersects_ray.js";
+
+test("diagonal ray hit", () => {
+
+    expect(
+        aabb2_intersects_ray(
+            1, 1, 2, 2, 0, 0,
+            Math.SQRT2, Math.SQRT2
+        )
+    ).toBe(true);
+
+
+    expect(
+        aabb2_intersects_ray(
+            1, 1, 2, 2, 3, 3,
+            -Math.SQRT2, -Math.SQRT2
+        )
+    ).toBe(true);
+
+    expect(
+        aabb2_intersects_ray(
+            1, 1, 2, 2, 3, 0,
+            -Math.SQRT2, Math.SQRT2
+        )
+    ).toBe(true);
+
+
+});

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

@@ -0,0 +1,52 @@
+export class SpatialHashGrid {
+    constructor(size_x?: number, size_y?: number, scale?: number);
+    element_allocate(): number;
+    element_set_user_data(element: any, user_data: any): void;
+    /**
+     * You have to remove the element from the grid before changing its bounds
+     * @param {number} element
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} x1
+     * @param {number} y1
+     */
+    element_set_bounds_primitive(element: number, x0: number, y0: number, x1: number, y1: number): void;
+    /**
+     *
+     * @param {number} element
+     */
+    element_release(element: number): void;
+    /**
+     *
+     * @param {number} element
+     */
+    element_insert(element: number): void;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @returns {number}
+     */
+    cell_position_to_index(x: number, y: number): number;
+    /**
+     *
+     * @param {number[]} out
+     * @param {number} out_offset
+     * @param {number} index
+     */
+    cell_index_to_position(out: number[], out_offset: number, index: number): void;
+    /**
+     *
+     * @param {number} cell_x
+     * @param {number} cell_y
+     * @return {boolean}
+     */
+    is_cell_empty(cell_x: number, cell_y: number): boolean;
+    /**
+     *
+     * @param {number} element
+     */
+    element_remove(element: number): void;
+    #private;
+}
+//# sourceMappingURL=SpatialHashGrid.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,317 @@
+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 { BinaryElementPool } from "../../3d/topology/struct/binary/BinaryElementPool.js";
+
+
+const NULL_POINTER = UINT32_MAX;
+/**
+ * Single-linked list
+ * Pointer to next NODE in the same grid cell
+ * @type {number}
+ */
+const COLUMN_NODE_SAME_NODE_NEXT = 0;
+/**
+ * Single-linked list
+ * Pointer to next NODE containing the same element
+ * @type {number}
+ */
+const COLUMN_NODE_SAME_ELEMENT_NEXT = 1;
+/**
+ * Pointer to ELEMENT
+ * @type {number}
+ */
+const COLUMN_NODE_ELEMENT = 2;
+
+/**
+ * Points to grid cell that stores this node
+ * @type {number}
+ */
+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 class SpatialHashGrid {
+    #element_pool = new BinaryElementPool(24)
+    #node_pool = new BinaryElementPool(16);
+    #grid_data = new Uint32Array(0);
+
+    #size_x = 0;
+    #size_y = 0;
+
+    #scale = 1;
+    #scale_inverse = 1;
+
+    constructor(size_x = 1, size_y = 1, scale = 8) {
+
+        assert.notNaN(scale, "scale");
+        assert.isFiniteNumber(scale, 'scale');
+        assert.greaterThan(scale, 0, 'scale must be greater than 0');
+
+        this.#size_x = size_x;
+        this.#size_y = size_y;
+        this.#scale = scale;
+        this.#scale_inverse = 1 / scale;
+
+        this.#build();
+    }
+
+    #build() {
+        this.#grid_data = new Uint32Array(this.#size_x * this.#size_y);
+
+        this.#grid_data.fill(NULL_POINTER);
+    }
+
+    element_allocate() {
+        const element = this.#element_pool.allocate();
+
+        return element;
+    }
+
+    element_set_user_data(element, user_data) {
+        const pool = this.#element_pool;
+        const address = pool.element_word(element);
+
+        pool.data_uint32[address + COLUMN_ELEMENT_DATA] = user_data;
+    }
+
+    /**
+     * You have to remove the element from the grid before changing its bounds
+     * @param {number} element
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} x1
+     * @param {number} y1
+     */
+    element_set_bounds_primitive(element, x0, y0, x1, y1) {
+        const pool = this.#element_pool;
+        const address = pool.element_word(element);
+
+        const float32 = pool.data_float32;
+
+        float32[address + COLUMN_ELEMENT_X0] = x0;
+        float32[address + COLUMN_ELEMENT_Y0] = y0;
+        float32[address + COLUMN_ELEMENT_X1] = x1;
+        float32[address + COLUMN_ELEMENT_Y1] = y1;
+    }
+
+    /**
+     *
+     * @param {number} element
+     */
+    element_release(element) {
+        this.#element_pool.release(element);
+    }
+
+    /**
+     *
+     * @param {number} element
+     */
+    element_insert(element) {
+        const pool = this.#element_pool;
+        const address = pool.element_word(element);
+
+        const uint32 = pool.data_uint32;
+
+        // make sure that we don't point at anything yet
+        uint32[address + COLUMN_ELEMENT_NODE_FIRST] = NULL_POINTER;
+
+        const float32 = pool.data_float32;
+
+        const x0 = float32[address + COLUMN_ELEMENT_X0];
+        const y0 = float32[address + COLUMN_ELEMENT_Y0];
+        const x1 = float32[address + COLUMN_ELEMENT_X1];
+        const y1 = float32[address + COLUMN_ELEMENT_Y1];
+
+        // convert to grid coordinates
+        const grid_x0 = Math.floor(x0 * this.#scale_inverse);
+        const grid_y0 = Math.floor(y0 * this.#scale_inverse);
+
+        const grid_x1 = Math.floor(x1 * this.#scale_inverse);
+        const grid_y1 = Math.floor(y1 * this.#scale_inverse);
+
+        for (let y = grid_y0; y <= grid_y1; y++) {
+            for (let x = grid_x0; x <= grid_x1; x++) {
+                this.#element_insert_into_cell(element, x, y);
+            }
+        }
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @returns {number}
+     */
+    cell_position_to_index(x, y) {
+        assert.isNonNegativeInteger(x, 'x');
+        assert.isNonNegativeInteger(y, 'y');
+
+        return  y* this.#size_x + x;
+
+
+        // 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)
+
+    }
+
+    /**
+     *
+     * @param {number} cell_x
+     * @param {number} cell_y
+     * @return {boolean}
+     */
+    is_cell_empty(cell_x, cell_y) {
+        assert.isNonNegativeInteger(cell_x, 'cell_x');
+        assert.lessThan(cell_x, this.#size_x, 'cell_x overflow');
+
+        assert.isNonNegativeInteger(cell_y, 'cell_y');
+        assert.lessThan(cell_y, this.#size_y, 'cell_y overflow');
+
+        const index = this.cell_position_to_index(cell_x, cell_y);
+
+        const grid = this.#grid_data;
+
+        return grid[index] === NULL_POINTER;
+    }
+
+    /**
+     *
+     * @param {number} element
+     * @param {number} grid_x
+     * @param {number} grid_y
+     */
+    #element_insert_into_cell(element, grid_x, grid_y) {
+
+        // create a node
+        const node_pool = this.#node_pool;
+        const node = node_pool.allocate();
+
+        const node_address = node_pool.element_word(node);
+        const node_data_uint32 = node_pool.data_uint32;
+
+        node_data_uint32[node_address + COLUMN_NODE_ELEMENT] = element;
+
+        // link node to the element
+        const element_pool = this.#element_pool;
+        const element_address = element_pool.element_word(element);
+
+        const element_data_uint32 = element_pool.data_uint32;
+
+        const element_first_node = element_data_uint32[element_address + COLUMN_ELEMENT_NODE_FIRST];
+
+        // point to previous first
+        node_data_uint32[node_address + COLUMN_NODE_SAME_ELEMENT_NEXT] = element_first_node;
+
+
+        element_data_uint32[element_address + COLUMN_ELEMENT_NODE_FIRST] = node;
+
+        // link node to the cell
+        const cell_index = this.cell_position_to_index(grid_x, grid_y);
+
+        node_data_uint32[node_address + COLUMN_NODE_GRID_INDEX] = cell_index;
+
+        const grid_data = this.#grid_data;
+
+        const cell_first_node = grid_data[cell_index];
+
+        node_data_uint32[node_address + COLUMN_NODE_SAME_NODE_NEXT] = cell_first_node;
+
+        grid_data[cell_index] = node;
+    }
+
+    /**
+     *
+     * @param {number} cell_index
+     * @param {number} node
+     * @returns {boolean}
+     */
+    #grid_cell_remove_node(cell_index, node) {
+        assert.isNonNegativeInteger(cell_index, 'cell_index');
+        assert.isNonNegativeInteger(node, 'node');
+
+        const pool = this.#node_pool;
+        const node_data_uint32 = pool.data_uint32;
+
+        const grid_data = this.#grid_data;
+        let n = grid_data[cell_index]
+        let previous = NULL_POINTER;
+
+        while (n !== NULL_POINTER) {
+            const address = pool.element_word(n);
+            const next = node_data_uint32[address + COLUMN_NODE_SAME_NODE_NEXT];
+
+            if (n === node) {
+                // found the node to cut
+
+                if (previous === NULL_POINTER) {
+                    // first element in the list
+                    grid_data[cell_index] = next;
+                } else {
+                    const previous_address = pool.element_word(previous);
+
+                    node_data_uint32[previous_address + COLUMN_NODE_SAME_NODE_NEXT] = next;
+                }
+
+                return true;
+            }
+
+            previous = n;
+            n = next;
+        }
+
+        return false;
+    }
+
+    /**
+     *
+     * @param {number} element
+     */
+    element_remove(element) {
+        assert.isNonNegativeInteger(element, 'element');
+
+        const element_pool = this.#element_pool;
+        const address = element_pool.element_word(element);
+
+        let node = element_pool.data_uint32[address + COLUMN_ELEMENT_NODE_FIRST];
+
+        const node_pool = this.#node_pool;
+        const node_data_uint32 = node_pool.data_uint32;
+
+        do {
+
+            const node_address = node_pool.element_word(node);
+
+            const next = node_data_uint32[node_address + COLUMN_NODE_SAME_ELEMENT_NEXT];
+
+            const grid_index = node_data_uint32[node_address + COLUMN_NODE_GRID_INDEX];
+
+            // cut this node from CELL list
+            this.#grid_cell_remove_node(grid_index, node);
+
+
+            // advance onto next
+            node = next;
+        } while (node !== NULL_POINTER)
+
+    }
+}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=SpatialHashGrid.spec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SpatialHashGrid.spec.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/hash-grid/SpatialHashGrid.spec.js"],"names":[],"mappings":""}