Enum RunFixedMainLoopSystem

pub enum RunFixedMainLoopSystem {
    BeforeFixedMainLoop,
    FixedMainLoop,
    AfterFixedMainLoop,
}

Set enum for the systems that want to run inside RunFixedMainLoop, but before or after the fixed update logic. Systems in this set will run exactly once per frame, regardless of the number of fixed updates. They will also run under a variable timestep.

This is useful for handling things that need to run every frame, but also need to be read by the fixed update logic. See the individual variants for examples of what kind of systems should be placed in each.

Note that in contrast to most other Bevy schedules, systems added directly to RunFixedMainLoop will not be parallelized between each other.

Variants

BeforeFixedMainLoop

Runs before the fixed update logic.

A good example of a system that fits here is camera movement, which needs to be updated in a variable timestep, as you want the camera to move with as much precision and updates as the frame rate allows. A physics system that needs to read the camera position and orientation, however, should run in the fixed update logic, as it needs to be deterministic and run at a fixed rate for better stability. Note that we are not placing the camera movement system in Update, as that would mean that the physics system already ran at that point.

Example

App::new()
  .add_systems(
    RunFixedMainLoop,
    update_camera_rotation.in_set(RunFixedMainLoopSystem::BeforeFixedMainLoop))
  .add_systems(FixedUpdate, update_physics);

FixedMainLoop

Contains the fixed update logic. Runs FixedMain zero or more times based on delta of Time<Virtual> and Time::overstep.

Don’t place systems here, use FixedUpdate and friends instead. Use this system instead to order your systems to run specifically inbetween the fixed update logic and all other systems that run in RunFixedMainLoopSystem::BeforeFixedMainLoop or RunFixedMainLoopSystem::AfterFixedMainLoop.

Example

App::new()
  .add_systems(FixedUpdate, update_physics)
  .add_systems(
    RunFixedMainLoop,
    (
      // This system will be called before all interpolation systems
      // that third-party plugins might add.
      prepare_for_interpolation
        .after(RunFixedMainLoopSystem::FixedMainLoop)
        .before(RunFixedMainLoopSystem::AfterFixedMainLoop),
    )
  );

AfterFixedMainLoop

Runs after the fixed update logic.

A good example of a system that fits here is a system that interpolates the transform of an entity between the last and current fixed update. See the fixed timestep example for more details.

Example

App::new()
  .add_systems(FixedUpdate, update_physics)
  .add_systems(
    RunFixedMainLoop,
    interpolate_transforms.in_set(RunFixedMainLoopSystem::AfterFixedMainLoop));

Trait Implementations

impl Clone for RunFixedMainLoopSystem

fn clone(&self) -> RunFixedMainLoopSystem

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RunFixedMainLoopSystem

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

Formats the value using the given formatter.

impl Hash for RunFixedMainLoopSystem

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RunFixedMainLoopSystem

fn eq(&self, other: &RunFixedMainLoopSystem) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl SystemSet for RunFixedMainLoopSystem

where RunFixedMainLoopSystem: 'static + Send + Sync + Clone + Eq + Debug + Hash,

fn dyn_clone(&self) -> Box<dyn SystemSet>

Clones this SystemSet.

fn as_dyn_eq(&self) -> &(dyn DynEq + 'static)

Casts this value to a form where it can be compared with other type-erased values.

fn dyn_hash(&self, state: &mut dyn Hasher)

Feeds this value into the given Hasher.

fn system_type(&self) -> Option<TypeId>

Returns Some if this system set is a SystemTypeSet.

fn is_anonymous(&self) -> bool

Returns true if this system set is an AnonymousSet.

fn intern(&self) -> Interned<dyn SystemSet>

where Self: Sized,

Returns an Interned value corresponding to self.

impl Copy for RunFixedMainLoopSystem

impl Eq for RunFixedMainLoopSystem

impl StructuralPartialEq for RunFixedMainLoopSystem