fix gizmos during fixed update

crates/bevy_gizmos/Cargo.toml

@@ -10,6 +10,7 @@ keywords = ["bevy"]
 
 [features]
 webgl = []
+fixed_update = ["dep:bevy_time"]
 
 [dependencies]
 # Bevy
@@ -25,3 +26,4 @@ bevy_core = { path = "../bevy_core", version = "0.12.0-dev" }
 bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev" }
 bevy_core_pipeline = { path = "../bevy_core_pipeline", version = "0.12.0-dev" }
 bevy_transform = { path = "../bevy_transform", version = "0.12.0-dev" }
+bevy_time = { path = "../bevy_time", version = "0.12.0-dev", optional = true }

crates/bevy_gizmos/src/gizmos.rs

@@ -3,19 +3,28 @@
 use std::{f32::consts::TAU, iter};
 
 use bevy_ecs::{
- system::{Deferred, Resource, SystemBuffer, SystemMeta, SystemParam},
- world::World,
+ component::Tick,
+ system::{Resource, SystemBuffer, SystemMeta, SystemParam},
+ world::{unsafe_world_cell::UnsafeWorldCell, World},
 };
 use bevy_math::{Mat2, Quat, Vec2, Vec3};
 use bevy_render::color::Color;
 use bevy_transform::TransformPoint;
+use bevy_utils::default;
 
 type PositionItem = [f32; 3];
 type ColorItem = [f32; 4];
 
 const DEFAULT_CIRCLE_SEGMENTS: usize = 32;
 
 #[derive(Resource, Default)]
+pub(crate) struct GizmoStorages {
+ pub frame: GizmoStorage,
+ pub fixed_update_tick: u64,
+ pub fixed_update: GizmoStorage,
+}
+
+#[derive(Default)]
 pub(crate) struct GizmoStorage {
  pub list_positions: Vec<PositionItem>,
  pub list_colors: Vec<ColorItem>,
@@ -24,13 +33,14 @@ pub(crate) struct GizmoStorage {
 }
 
 /// A [`SystemParam`](bevy_ecs::system::SystemParam) for drawing gizmos.
-#[derive(SystemParam)]
 pub struct Gizmos<'s> {
- buffer: Deferred<'s, GizmoBuffer>,
+ buffer: &'s mut GizmoBuffer,
 }
 
 #[derive(Default)]
 struct GizmoBuffer {
+ /// Which fixed update tick this belongs to, `None` if this isn't from a fixed update.
+ fixed_time_update: Option<u64>,
  list_positions: Vec<PositionItem>,
  list_colors: Vec<ColorItem>,
  strip_positions: Vec<PositionItem>,
@@ -39,14 +49,76 @@ struct GizmoBuffer {
 
 impl SystemBuffer for GizmoBuffer {
  fn apply(&mut self, _system_meta: &SystemMeta, world: &mut World) {
- let mut storage = world.resource_mut::<GizmoStorage>();
+ let mut storages = world.resource_mut::<GizmoStorages>();
+
+ let storage = if let Some(tick) = self.fixed_time_update {
+ // If a new fixed update has begun, clear gizmos from previous fixed update
+ if storages.fixed_update_tick < tick {
+ storages.fixed_update_tick = tick;
+ storages.fixed_update.list_positions.clear();
+ storages.fixed_update.list_colors.clear();
+ storages.fixed_update.strip_positions.clear();
+ storages.fixed_update.strip_colors.clear();
+ }
+ &mut storages.fixed_update
+ } else {
+ &mut storages.frame
+ };
+
  storage.list_positions.append(&mut self.list_positions);
  storage.list_colors.append(&mut self.list_colors);
  storage.strip_positions.append(&mut self.strip_positions);
  storage.strip_colors.append(&mut self.strip_colors);
  }
 }
 
+// Wrap to keep GizmoBuffer hidden
+const _: () = {
+ pub struct Wrap(GizmoBuffer);
+
+ // SAFETY: Only local state is accessed.
+ unsafe impl SystemParam for Gizmos<'_> {
+ type State = Wrap;
+ type Item<'w, 's> = Gizmos<'s>;
+
+ fn init_state(world: &mut World, _system_meta: &mut SystemMeta) -> Self::State {
+ #[cfg(not(feature = "fixed_update"))]
+ let fixed_time_tick = None;
+ #[cfg(feature = "fixed_update")]
+ let fixed_time_update =
+ if world.contains_resource::<bevy_time::fixed_timestep::FixedUpdateScheduleIsCurrentlyRunning>() {
+ world
+ .get_resource::<bevy_time::prelude::FixedTime>()
+ .map(|time| time.times_expended())
+ } else {
+ None
+ };
+ Wrap(GizmoBuffer {
+ fixed_time_update,
+ list_positions: default(),
+ list_colors: default(),
+ strip_positions: default(),
+ strip_colors: default(),
+ })
+ }
+
+ fn apply(state: &mut Self::State, system_meta: &SystemMeta, world: &mut World) {
+ state.0.apply(system_meta, world);
+ }
+
+ unsafe fn get_param<'w, 's>(
+ state: &'s mut Self::State,
+ _system_meta: &SystemMeta,
+ _world: UnsafeWorldCell<'w>,
+ _change_tick: Tick,
+ ) -> Self::Item<'w, 's> {
+ Gizmos {
+ buffer: &mut state.0,
+ }
+ }
+ }
+};
+
 impl<'s> Gizmos<'s> {
  /// Draw a line from `start` to `end`.
  ///

crates/bevy_gizmos/src/lib.rs

@@ -14,6 +14,9 @@
 //! # bevy_ecs::system::assert_is_system(system);
 //! ```
 //!
+//! With the `fixed_update` feature (enabled by default by the bevy main crate),
+//! gizmos drawn during `FixedUpdate` last until the next fixed update.
+//!
 //! See the documentation on [`Gizmos`](crate::gizmos::Gizmos) for more examples.
 
 use std::mem;
@@ -59,7 +62,7 @@ mod pipeline_2d;
 #[cfg(feature = "bevy_pbr")]
 mod pipeline_3d;
 
-use gizmos::{GizmoStorage, Gizmos};
+use gizmos::{GizmoStorages, Gizmos};
 
 /// The `bevy_gizmos` prelude.
 pub mod prelude {
@@ -82,7 +85,7 @@ impl Plugin for GizmoPlugin {
  .add_plugins(RenderAssetPlugin::<LineGizmo>::default())
  .init_resource::<LineGizmoHandles>()
  .init_resource::<GizmoConfig>()
- .init_resource::<GizmoStorage>()
+ .init_resource::<GizmoStorages>()
  .add_systems(Last, update_gizmo_meshes)
  .add_systems(
  Update,
@@ -92,6 +95,11 @@ impl Plugin for GizmoPlugin {
  ),
  );
 
+ // Ensure gizmos from prefious fixed update are cleaned up if no other system
+ // accesses gizmos during fixed update any more
+ #[cfg(feature = "fixed_update")]
+ app.add_systems(bevy_app::FixedUpdate, |_: Gizmos| ());
+
  let Ok(render_app) = app.get_sub_app_mut(RenderApp) else { return; };
 
  render_app
@@ -260,8 +268,23 @@ struct LineGizmoHandles {
 fn update_gizmo_meshes(
  mut line_gizmos: ResMut<Assets<LineGizmo>>,
  mut handles: ResMut<LineGizmoHandles>,
- mut storage: ResMut<GizmoStorage>,
+ mut storages: ResMut<GizmoStorages>,
 ) {
+ // Combine gizmos for this frame (which get cleared here) with the ones from the last fixed update (which get cleared during system buffer application)
+ let mut storage = mem::take(&mut storages.frame);
+ storage
+ .list_positions
+ .extend_from_slice(&storages.fixed_update.list_positions);
+ storage
+ .list_colors
+ .extend_from_slice(&storages.fixed_update.list_colors);
+ storage
+ .strip_positions
+ .extend_from_slice(&storages.fixed_update.strip_positions);
+ storage
+ .strip_colors
+ .extend_from_slice(&storages.fixed_update.strip_colors);
+
  if storage.list_positions.is_empty() {
  handles.list = None;
  } else if let Some(handle) = handles.list.as_ref() {

crates/bevy_internal/Cargo.toml

@@ -139,4 +139,4 @@ bevy_text = { path = "../bevy_text", optional = true, version = "0.12.0-dev" }
 bevy_ui = { path = "../bevy_ui", optional = true, version = "0.12.0-dev" }
 bevy_winit = { path = "../bevy_winit", optional = true, version = "0.12.0-dev" }
 bevy_gilrs = { path = "../bevy_gilrs", optional = true, version = "0.12.0-dev" }
-bevy_gizmos = { path = "../bevy_gizmos", optional = true, version = "0.12.0-dev", default-features = false }
+bevy_gizmos = { path = "../bevy_gizmos", optional = true, version = "0.12.0-dev", default-features = false, features = ["fixed_update"] }

crates/bevy_time/src/fixed_timestep.rs

@@ -31,6 +31,7 @@ use thiserror::Error;
 #[derive(Resource, Debug)]
 pub struct FixedTime {
  accumulated: Duration,
+ total_ticks: u64,
  /// Defaults to 1/60th of a second.
  /// To configure this value, simply mutate or overwrite this resource.
  pub period: Duration,
@@ -42,6 +43,7 @@ impl FixedTime {
  FixedTime {
  accumulated: Duration::ZERO,
  period,
+ total_ticks: 0,
  }
  }
 
@@ -50,6 +52,7 @@ impl FixedTime {
  FixedTime {
  accumulated: Duration::ZERO,
  period: Duration::from_secs_f32(period),
+ total_ticks: 0,
  }
  }
 
@@ -63,13 +66,19 @@ impl FixedTime {
  self.accumulated
  }
 
+ /// Returns how often this has expended a period of time.
+ pub fn times_expended(&self) -> u64 {
+ self.total_ticks
+ }
+
  /// Expends one `period` of accumulated time.
  ///
  /// [`Err(FixedUpdateError`)] will be returned if there is
  /// not enough accumulated time to span an entire period.
  pub fn expend(&mut self) -> Result<(), FixedUpdateError> {
  if let Some(new_value) = self.accumulated.checked_sub(self.period) {
  self.accumulated = new_value;
+ self.total_ticks += 1;
  Ok(())
  } else {
  Err(FixedUpdateError::NotEnoughTime {
@@ -85,10 +94,15 @@ impl Default for FixedTime {
  FixedTime {
  accumulated: Duration::ZERO,
  period: Duration::from_secs_f32(1. / 60.),
+ total_ticks: 0,
  }
  }
 }
 
+/// Indicates that [`run_fixed_update_schedule`] is currently active.
+#[derive(Resource)]
+pub struct FixedUpdateScheduleIsCurrentlyRunning;
+
 /// An error returned when working with [`FixedTime`].
 #[derive(Debug, Error)]
 pub enum FixedUpdateError {
@@ -101,6 +115,8 @@ pub enum FixedUpdateError {
 
 /// Ticks the [`FixedTime`] resource then runs the [`FixedUpdate`].
 pub fn run_fixed_update_schedule(world: &mut World) {
+ world.insert_resource(FixedUpdateScheduleIsCurrentlyRunning);
+
  // Tick the time
  let delta_time = world.resource::<Time>().delta();
  let mut fixed_time = world.resource_mut::<FixedTime>();
@@ -112,6 +128,8 @@ pub fn run_fixed_update_schedule(world: &mut World) {
  schedule.run(world);
  }
  });
+
+ world.remove_resource::<FixedUpdateScheduleIsCurrentlyRunning>();
 }
 
 #[cfg(test)]