@woosh/meep-engine 2.119.17 → 2.119.19

package/src/core/geom/2d/lt-grid/LooseTightGrid.js

@@ -1,221 +0,0 @@
-import { assert } from "../../../assert.js";
-import { de_interleave_2_bits } from "../../../binary/de_interleave_2_bits.js";
-import { split_by_2 } from "../../../binary/split_by_2.js";
-import { UINT32_MAX } from "../../../binary/UINT32_MAX.js";
-import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
-import { BinaryElementPool } from "../../3d/topology/struct/binary/BinaryElementPool.js";
-
-const NULL_POINTER = UINT32_MAX;
-
-const COLUMN_PARENT = 0;
-const COLUMN_CHILD_1 = 1;
-const COLUMN_CHILD_2 = 2;
-const COLUMN_HEIGHT = 3;
-const COLUMN_AABB_OFFSET = 4;
-
-const COLUMN_USER_DATA = COLUMN_CHILD_2;
-
-/**
- *
- *  NOTE: THIS CODE IS UNFINISHED, IT IS ONLY A SKETCH
- *  TODO finish implementation
- *
- * Inspired by Makyen's post on stackoverflow: https://stackoverflow.com/a/48384354
- * Core idea is to have dynamically-sized bounding volumes that contain our AABBs, and then have a grid-aligned index that stores pointers to these volumes
- * Makyren called it "Loose/Tight Double-Grid", where "loose" refers to dynamic bounding volumes and tight refers to the grid
- *
- * Invariants:
- *  - An element inserted into the structure will belong to exactly one "loose" cell
- *
- */
-export class LooseTightGrid {
-
-    #resolution_x = 0
-    #resolution_y = 0
-
-    // amount of space covered by a single grid cell
-    #grid_scale = 1
-
-    #node_pool = new BinaryElementPool(10 * 4)
-    #grid_data = new Uint32Array(0);
-
-    constructor() {
-    }
-
-    /**
-     *
-     * @param {number} v
-     */
-    set grid_scale(v) {
-        assert.isNumber(v, 'v');
-        assert.greaterThan(v, 0, 'v');
-
-        if (this.#grid_scale === v) {
-            // no change
-            return;
-        }
-
-        this.#grid_scale = v;
-
-        this.rebuild();
-    }
-
-    /**
-     *
-     * @returns {number}
-     */
-    get grid_scale() {
-        return this.#grid_scale;
-    }
-
-    /**
-     *
-     * @param {number} size_x
-     * @param {number} size_y
-     */
-    resize(size_x, size_y) {
-        assert.isNonNegativeInteger(size_x, 'size_x');
-        assert.isNonNegativeInteger(size_y, 'size_y');
-
-        if (this.#resolution_x === size_x && this.#resolution_y === size_y) {
-            // no change
-            return;
-        }
-
-        this.#resolution_x = size_x;
-        this.#resolution_y = size_y;
-
-        this.rebuild();
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @returns {number}
-     */
-    cell_position_to_index(x, y) {
-        assert.isNonNegativeInteger(x, 'x');
-        assert.isNonNegativeInteger(y, '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)
-
-    }
-
-    allocate_datum() {
-
-    }
-
-    insert() {
-
-    }
-
-    /**
-     *
-     * @param {number} node
-     */
-    #node_is_leaf(node) {
-        const address = this.#node_pool.element_word(node);
-
-        return this.#node_pool.data_uint32[address + COLUMN_CHILD_1] === NULL_POINTER;
-    }
-
-    /**
-     * Collect leaves and de-allocate all intermediate nodes
-     * @param {number[]} output
-     * @param {number} output_offset
-     * @param {number} node
-     */
-    #erase_tree_structure(output, output_offset, node) {
-        const pool = this.#node_pool;
-
-        const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
-        const top = SCRATCH_UINT32_TRAVERSAL_STACK.pointer;
-
-        stack[stack.pointer++] = node;
-
-        let result_count = 0;
-
-        while (stack.pointer > top) {
-
-            stack.pointer--;
-
-            const n = stack[stack.pointer];
-
-            const node_address = pool.element_word(n);
-
-            const child_1 = pool.data_uint32[node_address + COLUMN_CHILD_1];
-            const child_2 = pool.data_uint32[node_address + COLUMN_CHILD_2];
-
-            if (child_1 === NULL_POINTER) {
-                // leaf node
-                output[output_offset + result_count] = n;
-                result_count++;
-            } else {
-                // binary node
-                stack[stack.pointer++] = child_2;
-                stack[stack.pointer++] = child_1;
-
-                // de-allocate node
-                pool.release(n);
-            }
-        }
-
-        return result_count;
-    }
-
-    /**
-     * Rebuild structure from ground-up
-     * This is an expensive operation
-     * Generally you'll never want to call it explicitly, it is used internally when underlying structure changes
-     */
-    rebuild() {
-        //TODO implement
-
-        let leaf_count = 0;
-        const leaf_nodes = [];
-        // traverse previous grid
-        for (let i = 0; i < this.#grid_data.length; i++) {
-            const node = this.#grid_data[i];
-
-            if (node === NULL_POINTER) {
-                // empty grid cell
-                continue;
-            }
-
-            leaf_count += this.#erase_tree_structure(leaf_nodes, leaf_count, node);
-        }
-
-
-        const resolution_y = this.#resolution_y;
-        const resolution_x = this.#resolution_x;
-
-        const grid_cell_count = resolution_x * resolution_y;
-
-        if (grid_cell_count !== this.#grid_data.length) {
-            this.#grid_data = new Uint32Array(grid_cell_count);
-        }
-
-        // drop all roots
-        this.#grid_data.fill(NULL_POINTER);
-
-        // re-insert all leaves
-
-    }
-
-}