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

Examples found in repository

examples/spatial3d.rs (line 37)

pub fn main() {
    let mut world = World::new();
    let mut sort = SpatialSortingSystem3::<f32, BodyPose3<f32>, ()>::new();
    let mut collide =
        SpatialCollisionSystem3::<f32, BodyPose3<f32>, ()>::new().with_narrow_phase(GJK3::new());
    let mut raycast = RayCastSystem;
    let mut impulse_solver = CurrentFrameUpdateSystem3::<f32, BodyPose3<f32>>::new();
    let mut next_frame = NextFrameSetupSystem3::<f32, BodyPose3<f32>>::new();
    let mut contact_resolution = ContactResolutionSystem3::<f32, BodyPose3<f32>>::new();

    sort.setup(&mut world.res);
    collide.setup(&mut world.res);
    raycast.setup(&mut world.res);
    impulse_solver.setup(&mut world.res);
    next_frame.setup(&mut world.res);
    contact_resolution.setup(&mut world.res);

    world
        .create_entity()
        .with_static_physical_entity(
            CollisionShape3::<f32, BodyPose3<f32>, ()>::new_simple(
                CollisionStrategy::FullResolution,
                CollisionMode::Discrete,
                Cuboid::new(10., 10., 10.).into(),
            ),
            BodyPose3::one(),
            PhysicalEntity::default(),
            Mass3::new(1.),
        ).build();

    world
        .create_entity()
        .with_static_physical_entity(
            CollisionShape3::<f32, BodyPose3<f32>, ()>::new_simple(
                CollisionStrategy::FullResolution,
                CollisionMode::Discrete,
                Cuboid::new(10., 10., 10.).into(),
            ),
            BodyPose3::new(Point3::new(3., 2., 0.), Quaternion::from_angle_z(Rad(0.))),
            PhysicalEntity::default(),
            Mass3::new(1.),
        ).build();

    let mut reader_1 = world
        .write_resource::<EventChannel<ContactEvent3<f32>>>()
        .register_reader();
    {
        use specs::prelude::RunNow;
        sort.run_now(&world.res);
        collide.run_now(&world.res);
        println!(
            "Contacts: {:?}",
            world
                .read_resource::<EventChannel<ContactEvent3<f32>>>()
                .read(&mut reader_1)
                .collect::<Vec<_>>()
        );
        raycast.run_now(&world.res);

        impulse_solver.run_now(&world.res);
        next_frame.run_now(&world.res);
        contact_resolution.run_now(&world.res);
    }
}

examples/spatial2d.rs (line 38)

pub fn main() {
    let mut world = World::new();
    let mut sort = SpatialSortingSystem2::<f32, BodyPose2<f32>, ()>::new();
    let mut collide =
        SpatialCollisionSystem2::<f32, BodyPose2<f32>, ()>::new().with_narrow_phase(GJK2::new());
    let mut raycast = RayCastSystem;
    let mut impulse_solver = CurrentFrameUpdateSystem2::<f32, BodyPose2<f32>>::new();
    let mut next_frame = NextFrameSetupSystem2::<f32, BodyPose2<f32>>::new();
    let mut contact_resolution = ContactResolutionSystem2::<f32, BodyPose2<f32>>::new();

    sort.setup(&mut world.res);
    collide.setup(&mut world.res);
    raycast.setup(&mut world.res);
    impulse_solver.setup(&mut world.res);
    next_frame.setup(&mut world.res);
    contact_resolution.setup(&mut world.res);

    world
        .create_entity()
        .with_static_physical_entity(
            CollisionShape2::<f32, BodyPose2<f32>, ()>::new_simple(
                CollisionStrategy::FullResolution,
                CollisionMode::Discrete,
                Rectangle::new(10., 10.).into(),
            ),
            BodyPose2::<f32>::one(),
            PhysicalEntity::default(),
            Mass2::new(1.),
        ).build();

    world
        .create_entity()
        .with_static_physical_entity(
            CollisionShape2::<f32, BodyPose2<f32>, ()>::new_simple(
                CollisionStrategy::FullResolution,
                CollisionMode::Discrete,
                Rectangle::new(10., 10.).into(),
            ),
            BodyPose2::<f32>::new(Point2::new(2., 2.), Rotation2::from_angle(Rad(0.))),
            PhysicalEntity::default(),
            Mass2::new(1.),
        ).build();

    let mut reader_1 = world
        .write_resource::<EventChannel<ContactEvent2<f32>>>()
        .register_reader();

    {
        use specs::prelude::RunNow;
        sort.run_now(&world.res);
        collide.run_now(&world.res);

        println!(
            "Contacts: {:?}",
            world
                .read_resource::<EventChannel<ContactEvent2<f32>>>()
                .read(&mut reader_1)
                .collect::<Vec<_>>()
        );

        raycast.run_now(&world.res);
        impulse_solver.run_now(&world.res);
        next_frame.run_now(&world.res);
        contact_resolution.run_now(&world.res);
    }
}

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

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.