Merge branch 'main' into 22485_observer_gizmos

Author: kfc35

Cargo.toml

@@ -4557,6 +4557,54 @@ description = "A scene showcasing light gizmos"
 category = "Gizmos"
 wasm = true
 
+[[example]]
+name = "2d_text_gizmos"
+path = "examples/gizmos/2d_text_gizmos.rs"
+# Causes an ICE on docs.rs
+doc-scrape-examples = false
+
+[package.metadata.example.2d_text_gizmos]
+name = "Text Gizmos 2d"
+description = "A scene showcasing 2d text gizmos"
+category = "Gizmos"
+wasm = true
+
+[[example]]
+name = "anchored_text_gizmos"
+path = "examples/gizmos/anchored_text_gizmos.rs"
+# Causes an ICE on docs.rs
+doc-scrape-examples = false
+
+[package.metadata.example.anchored_text_gizmos]
+name = "Anchored Text Gizmos"
+description = "Demonstrates anchored text gizmos"
+category = "Gizmos"
+wasm = true
+
+[[example]]
+name = "3d_text_gizmos"
+path = "examples/gizmos/3d_text_gizmos.rs"
+# Causes an ICE on docs.rs
+doc-scrape-examples = false
+
+[package.metadata.example.3d_text_gizmos]
+name = "Text Gizmos 3d"
+description = "A scene showcasing 3d text gizmos"
+category = "Gizmos"
+wasm = true
+
+[[example]]
+name = "text_gizmos_font"
+path = "examples/gizmos/text_gizmos_font.rs"
+# Causes an ICE on docs.rs
+doc-scrape-examples = false
+
+[package.metadata.example.text_gizmos_font]
+name = "Text Gizmos Font"
+description = "Example displaying the font used by text gizmos"
+category = "Gizmos"
+wasm = true
+
 [[example]]
 name = "custom_gltf_vertex_attribute"
 path = "examples/gltf/custom_gltf_vertex_attribute.rs"

crates/bevy_dev_tools/src/easy_screenshot.rs

@@ -153,6 +153,21 @@ pub enum RecordScreen {
     Stop,
 }
 
+#[cfg(feature = "screenrecording")]
+/// The [`Update`] systems that the [`EasyScreenRecordPlugin`] runs
+/// to start and stop recording on user command and
+/// to send frames to the thread that manages video file creation.
+/// These systems manipulate [`virtual`](bevy_time::Virtual)
+/// [`time`](bevy_time::Time) in order to capture frames for video.
+///
+/// If any application [`Update`] systems have behavior that depend
+/// on virtual time and must be recorded, ensure that these systems run
+/// [`after(EasyScreenRecordSystems)`](bevy_ecs::schedule::IntoScheduleConfigs::after).
+/// The application may run slower on screen during recording,
+/// but the video playback will be at normal speed.
+#[derive(SystemSet, Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct EasyScreenRecordSystems;
+
 #[cfg(feature = "screenrecording")]
 impl Plugin for EasyScreenRecordPlugin {
     #[cfg_attr(
@@ -199,7 +214,6 @@ impl Plugin for EasyScreenRecordPlugin {
                             setup = Some(Setup::preset(preset, tune, false, true).high());
                         }
                         RecordCommand::Stop => {
-                            info!("stopping recording");
                             if let Some(encoder) = encoder.take() {
                                 let mut flush = encoder.flush();
                                 let mut file = file.take().unwrap();
@@ -208,6 +222,7 @@ impl Plugin for EasyScreenRecordPlugin {
                                     file.write_all(data.entirety()).unwrap();
                                 }
                             }
+                            info!("finished processing video");
                         }
                         RecordCommand::Frame(image) => {
                             if let Some(setup) = setup.take() {
@@ -291,6 +306,7 @@ impl Plugin for EasyScreenRecordPlugin {
                                 tx.send(RecordCommand::Stop).unwrap();
                                 *recording = false;
                                 virtual_time.unpause();
+                                info!("stopped recording. still processing video");
                             }
                             _ => {}
                         }
@@ -310,7 +326,8 @@ impl Plugin for EasyScreenRecordPlugin {
                     }
                     },
                 )
-                    .chain(),
+                    .chain()
+                    .in_set(EasyScreenRecordSystems),
             );
         }
     }

crates/bevy_ecs/src/system/query.rs

@@ -2730,6 +2730,8 @@ impl<'w, 'q, Q: QueryData, F: QueryFilter> From<&'q mut Query<'w, '_, Q, F>>
 ///
 /// Use [`Option<Single<D, F>>`] instead if zero or one matching entities can exist.
 ///
+/// Note that [`Single`] is not used as a search optimization. It is used as a validation with slight overhead compared to [`Query`].
+///
 /// See [`Query`] for more details.
 ///
 /// [System parameter]: crate::system::SystemParam

crates/bevy_ecs/src/world/mod.rs

@@ -74,7 +74,7 @@ use bevy_ptr::{move_as_ptr, MovingPtr, OwningPtr, Ptr};
 use bevy_utils::prelude::DebugName;
 use core::{any::TypeId, fmt, mem::ManuallyDrop};
 use log::warn;
-use unsafe_world_cell::UnsafeWorldCell;
+use unsafe_world_cell::{UnsafeEntityCell, UnsafeWorldCell};
 
 /// Stores and exposes operations on [entities](Entity), [components](Component), resources,
 /// and their associated metadata.
@@ -984,6 +984,31 @@ impl World {
         unsafe { entities.fetch_mut(cell) }
     }
 
+    /// Returns an [`Entity`] iterator of current entities.
+    ///
+    /// This is useful in contexts where you only have immutable access to the [`World`].
+    /// If you have mutable access to the [`World`], use
+    /// [`query()::<EntityRef>().iter(&world)`](World::query()) instead.
+    #[inline]
+    pub fn iter_entities(&self) -> impl Iterator<Item = EntityRef<'_>> + '_ {
+        self.archetypes.iter().flat_map(|archetype| {
+            archetype
+                .entities_with_location()
+                .map(|(entity, location)| {
+                    // SAFETY: entity exists and location accurately specifies the archetype where the entity is stored.
+                    let cell = UnsafeEntityCell::new(
+                        self.as_unsafe_world_cell_readonly(),
+                        entity,
+                        location,
+                        self.last_change_tick,
+                        self.read_change_tick(),
+                    );
+                    // SAFETY: `&self` gives read access to the entire world.
+                    unsafe { EntityRef::new(cell) }
+                })
+        })
+    }
+
     /// Simultaneously provides access to entity data and a command queue, which
     /// will be applied when the world is next flushed.
     ///
@@ -3852,7 +3877,7 @@ mod tests {
         vec::Vec,
     };
     use bevy_ecs_macros::Component;
-    use bevy_platform::collections::HashSet;
+    use bevy_platform::collections::{HashMap, HashSet};
     use bevy_utils::prelude::DebugName;
     use core::{
         any::TypeId,
@@ -4266,6 +4291,75 @@ mod tests {
         );
     }
 
+    #[test]
+    fn iterate_entities() {
+        let mut world = World::new();
+        let mut entity_counters = <HashMap<_, _>>::default();
+
+        let iterate_and_count_entities = |world: &World, entity_counters: &mut HashMap<_, _>| {
+            entity_counters.clear();
+            for entity in world.iter_entities() {
+                let counter = entity_counters.entry(entity.id()).or_insert(0);
+                *counter += 1;
+            }
+        };
+
+        // Adding one entity and validating iteration
+        let ent0 = world.spawn((Foo, Bar, Baz)).id();
+
+        iterate_and_count_entities(&world, &mut entity_counters);
+        assert_eq!(entity_counters[&ent0], 1);
+        assert_eq!(entity_counters.len(), 1);
+
+        // Spawning three more entities and then validating iteration
+        let ent1 = world.spawn((Foo, Bar)).id();
+        let ent2 = world.spawn((Bar, Baz)).id();
+        let ent3 = world.spawn((Foo, Baz)).id();
+
+        iterate_and_count_entities(&world, &mut entity_counters);
+
+        assert_eq!(entity_counters[&ent0], 1);
+        assert_eq!(entity_counters[&ent1], 1);
+        assert_eq!(entity_counters[&ent2], 1);
+        assert_eq!(entity_counters[&ent3], 1);
+        assert_eq!(entity_counters.len(), 4);
+
+        // Despawning first entity and then validating the iteration
+        assert!(world.despawn(ent0));
+
+        iterate_and_count_entities(&world, &mut entity_counters);
+
+        assert_eq!(entity_counters[&ent1], 1);
+        assert_eq!(entity_counters[&ent2], 1);
+        assert_eq!(entity_counters[&ent3], 1);
+        assert_eq!(entity_counters.len(), 3);
+
+        // Spawning three more entities, despawning three and then validating the iteration
+        let ent4 = world.spawn(Foo).id();
+        let ent5 = world.spawn(Bar).id();
+        let ent6 = world.spawn(Baz).id();
+
+        assert!(world.despawn(ent2));
+        assert!(world.despawn(ent3));
+        assert!(world.despawn(ent4));
+
+        iterate_and_count_entities(&world, &mut entity_counters);
+
+        assert_eq!(entity_counters[&ent1], 1);
+        assert_eq!(entity_counters[&ent5], 1);
+        assert_eq!(entity_counters[&ent6], 1);
+        assert_eq!(entity_counters.len(), 3);
+
+        // Despawning remaining entities and then validating the iteration
+        assert!(world.despawn(ent1));
+        assert!(world.despawn(ent5));
+        assert!(world.despawn(ent6));
+
+        iterate_and_count_entities(&world, &mut entity_counters);
+
+        assert_eq!(entity_counters.len(), 0);
+    }
+
     #[test]
     fn spawn_empty_bundle() {
         let mut world = World::new();

crates/bevy_gizmos/src/config.rs

@@ -110,13 +110,31 @@ impl GizmoConfigStore {
     }
 
     /// Returns [`GizmoConfig`] and [`GizmoConfigGroup`] associated with [`GizmoConfigGroup`] `T`
+    ///
+    /// # Panics
+    /// If the config does not exist for [`GizmoConfigGroup`] `T`
+    ///
+    /// For a non-panicking version, see [`get_config`].
+    ///
+    /// [`get_config`]: Self::get_config
     pub fn config<T: GizmoConfigGroup>(&self) -> (&GizmoConfig, &T) {
-        let Some((config, ext)) = self.get_config_dyn(&TypeId::of::<T>()) else {
+        let Some(configs) = self.get_config() else {
             panic!("Requested config {} does not exist in `GizmoConfigStore`! Did you forget to add it using `app.init_gizmo_group<T>()`?", T::type_path());
         };
+        configs
+    }
+
+    /// Returns Some([`GizmoConfig`] and [`GizmoConfigGroup`] associated with [`GizmoConfigGroup`] `T` if they exist,
+    /// else None.
+    ///
+    /// If the configs will always be present, use [`config`].
+    ///
+    /// [`config`]: Self::config
+    pub fn get_config<T: GizmoConfigGroup>(&self) -> Option<(&GizmoConfig, &T)> {
+        let (config, ext) = self.get_config_dyn(&TypeId::of::<T>())?;
         // hash map invariant guarantees that &dyn Reflect is of correct type T
         let ext = ext.as_any().downcast_ref().unwrap();
-        (config, ext)
+        Some((config, ext))
     }
 
     /// Returns mutable [`GizmoConfig`] and [`GizmoConfigGroup`] associated with [`TypeId`] of a [`GizmoConfigGroup`]
@@ -129,13 +147,31 @@ impl GizmoConfigStore {
     }
 
     /// Returns mutable [`GizmoConfig`] and [`GizmoConfigGroup`] associated with [`GizmoConfigGroup`] `T`
+    ///
+    /// # Panics
+    /// If the config does not exist for [`GizmoConfigGroup`] `T`
+    ///
+    /// For a non-panicking version, see [`get_config_mut`].
+    ///
+    /// [`get_config_mut`]: Self::get_config_mut
     pub fn config_mut<T: GizmoConfigGroup>(&mut self) -> (&mut GizmoConfig, &mut T) {
-        let Some((config, ext)) = self.get_config_mut_dyn(&TypeId::of::<T>()) else {
+        let Some(configs) = self.get_config_mut() else {
             panic!("Requested config {} does not exist in `GizmoConfigStore`! Did you forget to add it using `app.init_gizmo_group<T>()`?", T::type_path());
         };
+        configs
+    }
+
+    /// Returns mutable Some([`GizmoConfig`] and [`GizmoConfigGroup`]) associated with [`GizmoConfigGroup`] `T` if they exist,
+    /// else None
+    ///
+    /// If the configs will always be present, use [`config_mut`].
+    ///
+    /// [`config_mut`]: Self::config_mut
+    pub fn get_config_mut<T: GizmoConfigGroup>(&mut self) -> Option<(&mut GizmoConfig, &mut T)> {
+        let (config, ext) = self.get_config_mut_dyn(&TypeId::of::<T>())?;
         // hash map invariant guarantees that &dyn Reflect is of correct type T
         let ext = ext.as_any_mut().downcast_mut().unwrap();
-        (config, ext)
+        Some((config, ext))
     }
 
     /// Returns an iterator over all [`GizmoConfig`]s.

crates/bevy_gizmos/src/gizmos.rs

@@ -234,9 +234,28 @@ where
         system_meta: &SystemMeta,
         world: UnsafeWorldCell,
     ) -> Result<(), SystemParamValidationError> {
-        // SAFETY: Delegated to existing `SystemParam` implementations.
+        // SAFETY: Delegated to existing `SystemParam` implementation.
         unsafe {
-            GizmosState::<Config, Clear>::validate_param(&mut state.state, system_meta, world)
+            GizmosState::<Config, Clear>::validate_param(&mut state.state, system_meta, world)?;
+        }
+
+        // SAFETY: Delegated to existing `SystemParam` implementation.
+        let (_, f1) = unsafe {
+            GizmosState::<Config, Clear>::get_param(
+                &mut state.state,
+                system_meta,
+                world,
+                world.change_tick(),
+            )
+        };
+        // This if-block is to accommodate an Option<Gizmos> SystemParam.
+        // The user may decide not to initialize a gizmo group, so its config will not exist.
+        if f1.get_config::<Config>().is_none() {
+            Err(SystemParamValidationError::invalid::<Self>(
+                format!("Requested config {} does not exist in `GizmoConfigStore`! Did you forget to add it using `app.init_gizmo_group<T>()`?", 
+                Config::type_path())))
+        } else {
+            Ok(())
         }
     }
 
@@ -352,11 +371,19 @@ where
     Clear: 'static + Send + Sync,
 {
     fn queue(&mut self, _system_meta: &SystemMeta, mut world: DeferredWorld) {
-        let mut storage = world.resource_mut::<GizmoStorage<Config, Clear>>();
-        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);
+        if let Some(mut storage) = world.get_resource_mut::<GizmoStorage<Config, Clear>>() {
+            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);
+        } else {
+            // Prevent the buffer from growing indefinitely if GizmoStorage
+            // for the config group has not been initialized
+            self.list_positions.clear();
+            self.list_colors.clear();
+            self.strip_positions.clear();
+            self.strip_colors.clear();
+        }
     }
 }
 

crates/bevy_gizmos/src/lib.rs

@@ -36,6 +36,8 @@ pub mod grid;
 pub mod primitives;
 pub mod retained;
 pub mod rounded_box;
+mod simplex_stroke_font;
+pub mod stroke_text;
 
 #[cfg(feature = "bevy_mesh")]
 pub mod skinned_mesh_bounds;