Struct rhusics_ecs::SpatialSortingSystem

pub struct SpatialSortingSystem<P, T, D, B, Y = ()> { /* private fields */ }

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)>
• B: Bounding volume
• Y: Shape type, see Collider

System Function:

fn(Entities, T, NextFrame<T>, CollisionShape) -> (CollisionShape, DynamicBoundingVolumeTree<D>)

Implementations

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

pub fn new() -> Self

Create a new sorting system.

Trait Implementations

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

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

Formats the value using the given formatter.

impl<'a, P, T, Y, D, B> System<'a> for SpatialSortingSystem<P, T, D, B, Y>where
    P: Primitive + ComputeBound<B> + Send + Sync + 'static,
    B: Clone + Debug + Send + Sync + Union<B, Output = B> + Bound<Point = P::Point> + Contains<B> + SurfaceArea<Scalar = <P::Point as EuclideanSpace>::Scalar> + 'static,
    P::Point: Debug,
    <P::Point as EuclideanSpace>::Scalar: BaseFloat + Send + Sync + 'static,
    <P::Point as EuclideanSpace>::Diff: Debug + Send + Sync,
    T: Component + Clone + Debug + Transform<P::Point> + Send + Sync,
    T::Storage: Tracked,
    Y: Default + Send + Sync + 'static,
    D: Send + Sync + 'static + TreeValue<Bound = B> + From<(Entity, B)>,

type SystemData = (Read<'a, EntitiesRes, DefaultProvider>, Storage<'a, T, Fetch<'a, MaskedStorage<T>>>, Storage<'a, NextFrame<T>, Fetch<'a, MaskedStorage<NextFrame<T>>>>, Storage<'a, CollisionShape<P, T, B, Y>, FetchMut<'a, MaskedStorage<CollisionShape<P, T, B, Y>>>>, Write<'a, DynamicBoundingVolumeTree<D>, DefaultProvider>)

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 setup(&mut self, res: &mut Resources)

Sets up the Resources using Self::SystemData::setup.

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).

fn accessor<'b>(&'b self) -> AccessorCow<'a, 'b, Self>

Return the accessor from the SystemData.

fn dispose(self, res: &mut Resources)where
    Self: Sized,

Performs clean up that requires resources from the Resources.