Struct NextFrameSetupSystem 

pub struct NextFrameSetupSystem<P, R, I, A, T, D> { /* private fields */ }

Setup the next frames positions and velocities.

Type parameters:

• P: Positional quantity, usually Point2 or Point3
• R: Rotational quantity, usually Basis2 or Quaternion
• I: Inertia, usually Scalar or Matrix3
• A: Angular velocity, usually Scalar or Vector3
• T: Transform type (BodyPose2 or similar)

System function

fn(DeltaTime, Mass, T, ForceAccumulator) -> (ForceAccumulator, NextFrame<Velocity>, NextFrame<T>)

Implementations

impl<P, R, I, A, T, D> NextFrameSetupSystem<P, R, I, A, T, D>

where T: Pose<P, R>, P: EuclideanSpace, P::Scalar: BaseFloat, P::Diff: VectorSpace + InnerSpace + Debug, R: Rotation<P> + ApplyAngular<P::Scalar, A>, I: Inertia<Orientation = R> + Mul<A, Output = A>, A: Mul<P::Scalar, Output = A> + Zero + Clone + Copy, D: PhysicsTime<P::Scalar> + Default,

pub fn new() -> Self

Create system.

Examples found in repository

examples/spatial3d.rs (line 42)

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

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<'a, P, R, I, A, T, D> System<'a> for NextFrameSetupSystem<P, R, I, A, T, D>

where T: Pose<P, R> + Component + Send + Sync + 'static, P: EuclideanSpace + Send + Sync + 'static, P::Scalar: BaseFloat + Send + Sync + 'static, P::Diff: VectorSpace + InnerSpace + Debug + Send + Sync + 'static, R: Rotation<P> + ApplyAngular<P::Scalar, A> + Send + Sync + 'static, I: Inertia<Orientation = R> + Mul<A, Output = A> + Send + Sync + 'static, A: Mul<P::Scalar, Output = A> + Zero + Clone + Copy + Send + Sync + 'static, D: PhysicsTime<P::Scalar> + Default + Send + Sync + 'static,

type SystemData = (Read<'a, D>, Read<'a, WorldParameters<<P as EuclideanSpace>::Diff, <P as EuclideanSpace>::Scalar>>, Storage<'a, PhysicalEntity<<P as EuclideanSpace>::Scalar>, Fetch<'a, MaskedStorage<PhysicalEntity<<P as EuclideanSpace>::Scalar>>>>, Storage<'a, Mass<<P as EuclideanSpace>::Scalar, I>, Fetch<'a, MaskedStorage<Mass<<P as EuclideanSpace>::Scalar, I>>>>, Storage<'a, NextFrame<Velocity<<P as EuclideanSpace>::Diff, A>>, FetchMut<'a, MaskedStorage<NextFrame<Velocity<<P as EuclideanSpace>::Diff, A>>>>>, Storage<'a, T, Fetch<'a, MaskedStorage<T>>>, Storage<'a, NextFrame<T>, FetchMut<'a, MaskedStorage<NextFrame<T>>>>, Storage<'a, ForceAccumulator<<P as EuclideanSpace>::Diff, A>, FetchMut<'a, MaskedStorage<ForceAccumulator<<P as EuclideanSpace>::Diff, A>>>>)

The resource bundle required to execute this system.

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