Struct rhusics::collide::ecs::SpatialSortingSystem

pub struct SpatialSortingSystem<P, T, D> { /* fields omitted */ }

Spatial sorting system for use with specs.

Will perform spatial sorting of the collision world. Uses a Dynamic Bounding Volume Tree for sorting. Will update entries in the tree where the pose is dirty.

Can handle any transform component type, as long as the type implements Transform, and as long as the storage is wrapped in FlaggedStorage

Type parameters:

• P: Primitive type, needs to implement Primitive.
• T: Transform type, needs to implement Transform and have FlaggedStorage.
• D: Type of values stored in the DBVT, needs to implement TreeValue and From<(Entity, CollisionShape)>

Methods

impl<P, T, D> SpatialSortingSystem<P, T, D>

fn new() -> Self

Create a new sorting system.

Trait Implementations

impl<P: Debug, T: Debug, D: Debug> Debug for SpatialSortingSystem<P, T, D>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'a, P, T, D> System<'a> for SpatialSortingSystem<P, T, D> where
    P: Primitive + Send + Sync + 'static,
    P::Aabb: Clone + Debug + Send + Sync + Aabb<Scalar = f32> + Contains<P::Aabb> + SurfaceArea<Scalar = f32>,
    P::Point: Debug,
    <P::Point as EuclideanSpace>::Diff: Debug + Send + Sync,
    T: Component + Clone + Debug + Transform<P::Point> + Send + Sync,
    &'b T::Storage: Join<Type = &'b T>,
    D: Send + Sync + 'static + TreeValue<Bound = P::Aabb>,
    D: From<(Entity, &'c CollisionShape<P, T>)>, 

type SystemData = (Entities<'a>, ReadStorage<'a, T>, ReadStorage<'a, NextFrame<T>>, WriteStorage<'a, CollisionShape<P, T>>, FetchMut<'a, DynamicBoundingVolumeTree<D>>)

The resource bundle required to execute this system.

fn run(&mut self, (entities, poses, next_poses, shapes, tree): Self::SystemData)

Executes the system with the required system data.

fn running_time(&self) -> RunningTime

Returns a hint how long the system needs for running. This is used to optimize the way they're executed (might allow more parallelization).