@woosh/meep-engine/src/core/geom/2d/bvh/BVH2D.d.ts

Pure JavaScript game engine. Fully featured and production ready.

export const COLUMN_PARENT: 4;
export const COLUMN_CHILD_1: 5;
export const COLUMN_CHILD_2: 6;
export const COLUMN_HEIGHT: 7;
/**
 * A non-leaf node have both CHILD_1 and CHILD_2 set, when CHILD_1 is not set - it's a leaf node
 * So we can utilize space of CHILD_2 to store USER_DATA, hence there is overlap in schema
 * @readonly
 * @type {number}
 */
export const COLUMN_USER_DATA: number;
/**
 *
 * @type {number}
 */
export const NULL_NODE: number;
/**
 * How many words are used for a single NODE in the tree
 * One "word" is 4 bytes for the sake of alignment
 * @readonly
 * @type {number}
 */
export const ELEMENT_WORD_COUNT: number;
/**
 * 2D Bounding Volume Hierarchy implementation.
 * Based on BVH (3D) implementation
 * @class
 */
export class BVH2D {
    /**
     *
     * @type {ArrayBuffer}
     * @private
     */
    private __data_buffer;
    /**
     *
     * @type {Float32Array}
     * @private
     */
    private __data_float32;
    /**
     *
     * @type {Uint32Array}
     * @private
     */
    private __data_uint32;
    /**
     * How many nodes are currently reserved, this will grow automatically through {@link #allocate_node} method usage
     * @type {number}
     * @private
     */
    private __capacity;
    /**
     * Number of used nodes. These are either live nodes, or node sitting in the {@link #__free} pool
     * @type {number}
     * @private
     */
    private __size;
    /**
     * Indices of released nodes. Nodes are pulled from here first if available, before the whole tree gets resized
     * @type {number[]}
     * @private
     */
    private __free;
    /**
     * Pointer into __free array that's used as a stack, so this pointer represents top of the stack
     * @type {number}
     * @private
     */
    private __free_pointer;
    /**
     * Root node of the hierarchy
     * @type {number}
     * @private
     */
    private __root;
    /**
     *
     * @returns {number}
     */
    get root(): number;
    /**
     *
     * @param {number} v
     */
    set node_capacity(v: number);
    /**
     *
     * @returns {number}
     */
    get node_capacity(): number;
    __grow_capacity(): void;
    /**
     *
     * @param {number} new_capacity in number of nodes
     * @private
     */
    private __set_capacity;
    /**
     * Trim allocated memory region to only contain allocated nodes
     */
    trim(): void;
    /**
     *
     * @returns {number}
     */
    allocate_node(): number;
    /**
     * Release memory used by the node back into the pool
     * NOTE: Make sure that the node is not "live" (not attached to the hierarchy), otherwise this operation may corrupt the tree
     * @param {number} id
     */
    release_node(id: number): void;
    /**
     *
     * @param {number} id
     * @returns {boolean}
     */
    node_is_leaf(id: number): boolean;
    /**
     *
     * @param {number} id
     * @returns {number}
     */
    node_get_user_data(id: number): number;
    /**
     *
     * @param {number} id
     * @param {number} value
     */
    node_set_user_data(id: number, value: number): void;
    /**
     *
     * @param {number} id
     * @returns {number}
     */
    node_get_child1(id: number): number;
    /**
     *
     * @param {number} node
     * @param {number} child1
     */
    node_set_child1(node: number, child1: number): void;
    /**
     *
     * @param {number} id
     * @returns {number}
     */
    node_get_child2(id: number): number;
    /**
     *
     * @param {number} node
     * @param {number} child2
     */
    node_set_child2(node: number, child2: number): void;
    /**
     *
     * @param {number} id
     * @returns {number}
     */
    node_get_parent(id: number): number;
    /**
     *
     * @param {number} node
     * @param {number} parent
     */
    node_set_parent(node: number, parent: number): void;
    /**
     *
     * @param {number} id
     * @returns {number}
     */
    node_get_height(id: number): number;
    /**
     *
     * @param {number} id
     * @param {number} height
     */
    node_set_height(id: number, height: number): void;
    /**
     *
     * @param {number} id
     * @param {number[]|Float32Array} result
     */
    node_get_aabb(id: number, result: number[] | Float32Array): void;
    /**
     *
     * @param {number} id
     * @param {number[]|ArrayLike<number>} aabb
     */
    node_set_aabb(id: number, aabb: number[] | ArrayLike<number>): void;
    /**
     *
     * @param {number} id
     * @param {number[]} aabb
     */
    node_move_aabb(id: number, aabb: number[]): void;
    /**
     *
     * @param {number} id
     * @param {number} x0
     * @param {number} y0
     * @param {number} z0
     * @param {number} x1
     * @param {number} y1
     * @param {number} z1
     */
    node_set_aabb_primitive(id: number, x0: number, y0: number, x1: number, y1: number): void;
    /**
     *
     * @param {number} id
     * @returns {number}
     */
    node_get_surface_area(id: number): number;
    /**
     *
     * @param {number} index_a
     * @param {number} index_b
     * @returns {number}
     */
    node_get_combined_surface_area(index_a: number, index_b: number): number;
    /**
     *
     * @param {number} destination
     * @param {number} index_a
     * @param {number} index_b
     */
    node_set_combined_aabb(destination: number, index_a: number, index_b: number): void;
    /**
     *
     * @param {number} leaf
     * @returns {void}
     */
    insert_leaf(leaf: number): void;
    /**
     * refit and update nodes up the tree. Only updates bounds
     * NOTE: Does not update "height"
     * @param {number} parent
     * @private
     */
    private bubble_up_refit;
    /**
     * refit and update nodes up the tree
     * @param {number} parent
     * @private
     */
    private bubble_up_update;
    /**
     * NOTE: Leaf node is not released, make sure to call {@link #release_node} separately when you no longer need the leaf node
     * @param {number} leaf
     * @returns {void}
     */
    remove_leaf(leaf: number): void;
    /**
     * Perform a left or right rotation if node A is imbalanced.
     * Returns the new root index.
     * @param {number} iA
     * @returns {number}
     * @private
     */
    private balance;
    /**
     * Release all nodes, this essentially resets the tree to empty state
     * NOTE: For performance reasons, released memory is not reset, this means that attempting to access cleared nodes' memory will yield garbage data
     */
    release_all(): void;
    /**
     *
     * @param {function(node:number, tree:BVH):void} callback
     * @param {*} [ctx]
     */
    traverse(callback: any, ctx?: any): void;
    /**
     *
     * @param {number[]} destination
     * @param {number} destination_offset
     * @returns {number}
     */
    collect_nodes_all(destination: number[], destination_offset: number): number;
    /**
     * Update parent and child links of a given node to point to a new location, useful for re-locating nodes
     * @param {number} node node to update
     * @param {number} destination Where updated links should point to
     * @private
     */
    private __move_node_links;
    /**
     * Swap two nodes in memory
     * @param {number} a
     * @param {number} b
     * @returns {boolean}
     */
    swap_nodes(a: number, b: number): boolean;
}
//# sourceMappingURL=BVH2D.d.ts.map