Struct BasicCollisionSystem 

pub struct BasicCollisionSystem<P, T, D, B, Y = ()>
where
    P: Primitive,
    B: Bound,
{ /* private fields */ }

Collision detection system for use with specs.

Has support for both broad phase and narrow phase collision detection. Will only do narrow phase if both broad and narrow phase is activated.

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

Type parameters:

• P: Shape primitive
• T: Transform
• D: Data accepted by broad phase
• B: Bounding volume
• Y: Shape type, see Collider

System Function:

fn(Entities, T, NextFrame<T>, CollisionShape) -> (CollisionShape, EventChannel<ContactEvent>)

Implementations

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

where P: Primitive + ComputeBound<B> + Send + Sync + 'static, P::Point: Debug + Send + Sync + 'static, <P::Point as EuclideanSpace>::Scalar: Send + Sync + 'static, <P::Point as EuclideanSpace>::Diff: Debug + Send + Sync + 'static, T: Component + Transform<P::Point> + Send + Sync + Clone + 'static, Y: Default + Send + Sync + 'static, B: Bound<Point = P::Point> + Send + Sync + 'static + Union<B, Output = B> + Clone, D: HasBound<Bound = B> + From<(Entity, B)> + GetId<Entity>,

pub fn new() -> Self

Create a new collision detection system, with no broad or narrow phase activated.

Examples found in repository

examples/basic2d.rs (line 20)

pub fn main() {
    let mut world = World::new();

    let mut system = BasicCollisionSystem2::<f32, BodyPose2<f32>, ()>::new()
        .with_broad_phase(BroadBruteForce2::default())
        .with_narrow_phase(GJK2::new());
    system.setup(&mut world.res);

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

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

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

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

examples/basic3d.rs (line 19)

pub fn main() {
    let mut world = World::new();
    let mut system = BasicCollisionSystem3::<f32, BodyPose3<f32>, ()>::new()
        .with_broad_phase(BroadBruteForce3::default())
        .with_narrow_phase(GJK3::new());
    system.setup(&mut world.res);

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

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

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

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

pub fn with_narrow_phase<N: NarrowPhase<P, T, B, Y> + 'static>( self, narrow: N, ) -> Self

Specify what narrow phase algorithm to use

Examples found in repository

examples/basic2d.rs (line 22)

pub fn main() {
    let mut world = World::new();

    let mut system = BasicCollisionSystem2::<f32, BodyPose2<f32>, ()>::new()
        .with_broad_phase(BroadBruteForce2::default())
        .with_narrow_phase(GJK2::new());
    system.setup(&mut world.res);

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

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

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

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

examples/basic3d.rs (line 21)

pub fn main() {
    let mut world = World::new();
    let mut system = BasicCollisionSystem3::<f32, BodyPose3<f32>, ()>::new()
        .with_broad_phase(BroadBruteForce3::default())
        .with_narrow_phase(GJK3::new());
    system.setup(&mut world.res);

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

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

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

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

pub fn with_broad_phase<V: BroadPhase<D> + 'static>(self, broad: V) -> Self

Specify what broad phase algorithm to use

Examples found in repository

examples/basic2d.rs (line 21)

pub fn main() {
    let mut world = World::new();

    let mut system = BasicCollisionSystem2::<f32, BodyPose2<f32>, ()>::new()
        .with_broad_phase(BroadBruteForce2::default())
        .with_narrow_phase(GJK2::new());
    system.setup(&mut world.res);

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

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

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

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

examples/basic3d.rs (line 20)

pub fn main() {
    let mut world = World::new();
    let mut system = BasicCollisionSystem3::<f32, BodyPose3<f32>, ()>::new()
        .with_broad_phase(BroadBruteForce3::default())
        .with_narrow_phase(GJK3::new());
    system.setup(&mut world.res);

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

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

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

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

Trait Implementations

impl<'a, P, T, Y, D, B> System<'a> for BasicCollisionSystem<P, T, D, B, Y>

where P: Primitive + ComputeBound<B> + Send + Sync + 'static, P::Point: Debug + Send + Sync + 'static, <P::Point as EuclideanSpace>::Scalar: Send + Sync + 'static, <P::Point as EuclideanSpace>::Diff: Debug + Send + Sync + 'static, T: Component + Transform<P::Point> + Send + Sync + Clone + 'static, Y: Default + Send + Sync + 'static, B: Bound<Point = P::Point> + Send + Sync + 'static + Union<B, Output = B> + Clone, D: HasBound<Bound = B> + From<(Entity, B)> + GetId<Entity>,

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, EventChannel<ContactEvent<Entity, <P as Primitive>::Point>>>)

The resource bundle required to execute this system.

fn run(&mut self, system_data: 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).

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

Return the accessor from the SystemData.

fn setup(&mut self, res: &mut Resources)

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

fn dispose(self, res: &mut Resources)

where Self: Sized,

Performs clean up that requires resources from the Resources.