Struct SpatialHash 

pub struct SpatialHash { /* private fields */ }

Flat counting-sort grid over agent positions, rebuilt every tick.

Implementations

impl SpatialHash

pub fn new(cell_size: f32, world_w: f32, world_h: f32) -> SpatialHash

Creates an empty hash over a world_w by world_h world, with cells about cell_size wide.

pub fn cell_index(&self, x: f32, y: f32) -> u32

Returns the flat index of the cell holding (x, y).

The position wraps, so a position outside the world still falls in a cell.

pub fn build(&mut self, pos_x: &[f32], pos_y: &[f32])

Sorts the agents at pos_x and pos_y into their cells.

pub fn build_where( &mut self, pos_x: &[f32], pos_y: &[f32], include: impl Fn(usize) -> bool, )

Like Self::build, but skips agents that include rejects.

Skipped agents are not returned by any query.

pub fn query_radius( &self, x: f32, y: f32, r: f32, pos_x: &[f32], pos_y: &[f32], result: &mut Vec<u32>, )

Fills result with every agent within r of (x, y), clearing it first.

Distances wrap at the world’s edges, as for Self::for_each_within.

pub fn for_each_within<F>( &self, x: f32, y: f32, r: f32, pos_x: &[f32], pos_y: &[f32], f: F, )

where F: FnMut(u32, f32, f32, f32),

Visits every agent within r of (x, y), passing the callback its index, the toroidal deltas to it and their squared length.

The deltas come out of the range test either way. A kernel that needs them uses this method and computes each delta once, whereas a list of indices makes it recompute them all.

pub fn cell_size_is(&self, cell_size: f32) -> bool

Returns whether this hash was built with cell_size.

pub fn world_is(&self, world_w: f32, world_h: f32) -> bool

Returns whether this hash was built for a world_w by world_h world.

pub fn grid_dims(&self) -> (u32, u32)

Cells along each axis, fitted to the world from the requested cell size.

pub fn cell_extents(&self) -> (f32, f32)

World distance one cell spans on each axis.

pub fn buckets(&self) -> (&[u32], &[u32])

Returns (cell_start, sorted_agents), where cell c owns sorted_agents[cell_start[c]..cell_start[c + 1]].

pub fn rebuild_with_cell_size( &mut self, new_cell_size: f32, pos_x: &[f32], pos_y: &[f32], )

Rebuilds the hash for new_cell_size and sorts the agents again, if the cell size changed.

pub fn heap_bytes(&self) -> usize

Heap memory held by the hash, in bytes.

Trait Implementations

impl Debug for SpatialHash

Prints the cell geometry and the agent count, not the sorted agents.

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl NeighborIndex for SpatialHash

const KIND: &'static str = "Spatial hash"

Name of this index in the Model panel.

fn new(extent: Extent, cell_size: f32) -> SpatialHash

Creates an empty index over extent, with cells cell_size wide.

fn rebuild(&mut self, pos_x: &[f32], pos_y: &[f32], cell_size: f32)

Rebuilds the index from agent positions, with cells cell_size wide.

fn heap_bytes(&self) -> usize

Heap memory held by the index, in bytes.