Next Generation Bevy Scenes

Cargo.toml

@@ -145,6 +145,7 @@ default = [
   "bevy_picking",
   "bevy_render",
   "bevy_scene",
+  "bevy_scene2",
   "bevy_sprite",
   "bevy_sprite_picking_backend",
   "bevy_state",
@@ -167,6 +168,7 @@ default = [
   "x11",
   "debug",
   "zstd_rust",
+  "experimental_bevy_feathers",
 ]
 
 # Recommended defaults for no_std applications
@@ -249,6 +251,9 @@ bevy_render = ["bevy_internal/bevy_render", "bevy_color"]
 # Provides scene functionality
 bevy_scene = ["bevy_internal/bevy_scene", "bevy_asset"]
 
+# Provides scene functionality
+bevy_scene2 = ["bevy_internal/bevy_scene2", "bevy_asset"]
+
 # Provides raytraced lighting (experimental)
 bevy_solari = [
   "bevy_internal/bevy_solari",
@@ -598,8 +603,9 @@ flate2 = "1.0"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1.0.140"
 bytemuck = "1"
-bevy_render = { path = "crates/bevy_render", version = "0.17.0-dev", default-features = false }
 # The following explicit dependencies are needed for proc macros to work inside of examples as they are part of the bevy crate itself.
+bevy_render = { path = "crates/bevy_render", version = "0.17.0-dev", default-features = false }
+bevy_scene2 = { path = "crates/bevy_scene2", version = "0.17.0-dev", default-features = false }
 bevy_ecs = { path = "crates/bevy_ecs", version = "0.17.0-dev", default-features = false }
 bevy_state = { path = "crates/bevy_state", version = "0.17.0-dev", default-features = false }
 bevy_asset = { path = "crates/bevy_asset", version = "0.17.0-dev", default-features = false }
@@ -619,6 +625,7 @@ anyhow = "1"
 macro_rules_attribute = "0.2"
 accesskit = "0.19"
 nonmax = "0.5"
+variadics_please = "1"
 
 [target.'cfg(not(target_family = "wasm"))'.dev-dependencies]
 smol = "2"
@@ -2788,6 +2795,14 @@ description = "Demonstrates loading from and saving scenes to files"
 category = "Scene"
 wasm = false
 
+[[example]]
+name = "bsn"
+path = "examples/scene/bsn.rs"
+
+[[example]]
+name = "ui_scene"
+path = "examples/scene/ui_scene.rs"
+
 # Shaders
 [[package.metadata.example_category]]
 name = "Shaders"

crates/bevy_a11y/src/lib.rs

@@ -120,7 +120,7 @@ impl ManageAccessibilityUpdates {
 ///
 /// If the entity doesn't have a parent, or if the immediate parent doesn't have
 /// an `AccessibilityNode`, its node will be an immediate child of the primary window.
-#[derive(Component, Clone, Deref, DerefMut)]
+#[derive(Component, Clone, Deref, DerefMut, Default)]
 #[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
 pub struct AccessibilityNode(pub Node);
 

crates/bevy_animation/src/graph.rs

@@ -131,10 +131,16 @@ pub struct AnimationGraph {
 }
 
 /// A [`Handle`] to the [`AnimationGraph`] to be used by the [`AnimationPlayer`](crate::AnimationPlayer) on the same entity.
-#[derive(Component, Clone, Debug, Default, Deref, DerefMut, Reflect, PartialEq, Eq, From)]
+#[derive(Component, Clone, Debug, Deref, DerefMut, Reflect, PartialEq, Eq, From)]
 #[reflect(Component, Default, Clone)]
 pub struct AnimationGraphHandle(pub Handle<AnimationGraph>);
 
+impl Default for AnimationGraphHandle {
+    fn default() -> Self {
+        Self(Handle::default())
+    }
+}
+
 impl From<AnimationGraphHandle> for AssetId<AnimationGraph> {
     fn from(handle: AnimationGraphHandle) -> Self {
         handle.id()

crates/bevy_asset/src/handle.rs

@@ -1,9 +1,14 @@
 use crate::{
-    meta::MetaTransform, Asset, AssetId, AssetIndexAllocator, AssetPath, InternalAssetId,
-    UntypedAssetId,
+    meta::MetaTransform, Asset, AssetId, AssetIndexAllocator, AssetPath, AssetServer,
+    InternalAssetId, UntypedAssetId,
 };
 use alloc::sync::Arc;
-use bevy_reflect::{std_traits::ReflectDefault, Reflect, TypePath};
+use bevy_ecs::{
+    error::Result,
+    template::{GetTemplate, Template},
+    world::EntityWorldMut,
+};
+use bevy_reflect::{Reflect, TypePath};
 use core::{
     any::TypeId,
     hash::{Hash, Hasher},
@@ -130,7 +135,7 @@ impl core::fmt::Debug for StrongHandle {
 ///
 /// [`Handle::Strong`], via [`StrongHandle`] also provides access to useful [`Asset`] metadata, such as the [`AssetPath`] (if it exists).
 #[derive(Reflect)]
-#[reflect(Default, Debug, Hash, PartialEq, Clone)]
+#[reflect(Debug, Hash, PartialEq, Clone)]
 pub enum Handle<A: Asset> {
     /// A "strong" reference to a live (or loading) [`Asset`]. If a [`Handle`] is [`Handle::Strong`], the [`Asset`] will be kept
     /// alive until the [`Handle`] is dropped. Strong handles also provide access to additional asset metadata.
@@ -150,6 +155,9 @@ impl<T: Asset> Clone for Handle<T> {
 }
 
 impl<A: Asset> Handle<A> {
+    pub fn default() -> Self {
+        Handle::Uuid(AssetId::<A>::DEFAULT_UUID, PhantomData)
+    }
     /// Returns the [`AssetId`] of this [`Asset`].
     #[inline]
     pub fn id(&self) -> AssetId<A> {
@@ -189,9 +197,37 @@ impl<A: Asset> Handle<A> {
     }
 }
 
-impl<A: Asset> Default for Handle<A> {
+impl<T: Asset> GetTemplate for Handle<T> {
+    type Template = HandleTemplate<T>;
+}
+
+pub struct HandleTemplate<T> {
+    path: AssetPath<'static>,
+    marker: PhantomData<T>,
+}
+
+impl<T> Default for HandleTemplate<T> {
     fn default() -> Self {
-        Handle::Uuid(AssetId::<A>::DEFAULT_UUID, PhantomData)
+        Self {
+            path: Default::default(),
+            marker: Default::default(),
+        }
+    }
+}
+
+impl<I: Into<AssetPath<'static>>, T> From<I> for HandleTemplate<T> {
+    fn from(value: I) -> Self {
+        Self {
+            path: value.into(),
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<T: Asset> Template for HandleTemplate<T> {
+    type Output = Handle<T>;
+    fn build(&mut self, entity: &mut EntityWorldMut) -> Result<Handle<T>> {
+        Ok(entity.resource::<AssetServer>().load(&self.path))
     }
 }
 

crates/bevy_asset/src/lib.rs

@@ -472,6 +472,12 @@ impl<A: Asset> VisitAssetDependencies for Option<Handle<A>> {
     }
 }
 
+impl VisitAssetDependencies for UntypedAssetId {
+    fn visit_dependencies(&self, visit: &mut impl FnMut(UntypedAssetId)) {
+        visit(*self);
+    }
+}
+
 impl VisitAssetDependencies for UntypedHandle {
     fn visit_dependencies(&self, visit: &mut impl FnMut(UntypedAssetId)) {
         visit(self.id());
@@ -486,18 +492,18 @@ impl VisitAssetDependencies for Option<UntypedHandle> {
     }
 }
 
-impl<A: Asset> VisitAssetDependencies for Vec<Handle<A>> {
+impl<V: VisitAssetDependencies> VisitAssetDependencies for Vec<V> {
     fn visit_dependencies(&self, visit: &mut impl FnMut(UntypedAssetId)) {
         for dependency in self {
-            visit(dependency.id().untyped());
+            dependency.visit_dependencies(visit);
         }
     }
 }
 
-impl VisitAssetDependencies for Vec<UntypedHandle> {
+impl<A: Asset, S> VisitAssetDependencies for HashSet<Handle<A>, S> {
     fn visit_dependencies(&self, visit: &mut impl FnMut(UntypedAssetId)) {
         for dependency in self {
-            visit(dependency.id());
+            visit(dependency.id().untyped());
         }
     }
 }

crates/bevy_asset/src/server/mod.rs

@@ -864,6 +864,20 @@ impl AssetServer {
         self.load_asset(LoadedAsset::new_with_dependencies(asset))
     }
 
+    // TODO: this is a hack: this allows the asset to pretend to be from the path, but this will cause issues in practice
+    #[must_use = "not using the returned strong handle may result in the unexpected release of the asset"]
+    pub fn load_with_path<'a, A: Asset>(
+        &self,
+        path: impl Into<AssetPath<'a>>,
+        asset: A,
+    ) -> Handle<A> {
+        let loaded_asset: LoadedAsset<A> = asset.into();
+        let erased_loaded_asset: ErasedLoadedAsset = loaded_asset.into();
+        let path: AssetPath = path.into();
+        self.load_asset_untyped(Some(path.into_owned()), erased_loaded_asset)
+            .typed_debug_checked()
+    }
+
     pub(crate) fn load_asset<A: Asset>(&self, asset: impl Into<LoadedAsset<A>>) -> Handle<A> {
         let loaded_asset: LoadedAsset<A> = asset.into();
         let erased_loaded_asset: ErasedLoadedAsset = loaded_asset.into();

crates/bevy_core_pipeline/src/auto_exposure/settings.rs

@@ -6,7 +6,6 @@ use bevy_ecs::{prelude::Component, reflect::ReflectComponent};
 use bevy_image::Image;
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_render::{extract_component::ExtractComponent, view::Hdr};
-use bevy_utils::default;
 
 /// Component that enables auto exposure for an HDR-enabled 2d or 3d camera.
 ///
@@ -97,8 +96,8 @@ impl Default for AutoExposure {
             speed_brighten: 3.0,
             speed_darken: 1.0,
             exponential_transition_distance: 1.5,
-            metering_mask: default(),
-            compensation_curve: default(),
+            metering_mask: Handle::default(),
+            compensation_curve: Handle::default(),
         }
     }
 }

crates/bevy_core_widgets/src/callback.rs

@@ -1,5 +1,7 @@
-use bevy_ecs::system::{Commands, SystemId, SystemInput};
+use bevy_ecs::system::{Commands, IntoSystem, SystemId, SystemInput};
+use bevy_ecs::template::{GetTemplate, Template};
 use bevy_ecs::world::{DeferredWorld, World};
+use std::marker::PhantomData;
 
 /// A callback defines how we want to be notified when a widget changes state. Unlike an event
 /// or observer, callbacks are intended for "point-to-point" communication that cuts across the
@@ -27,15 +29,119 @@ use bevy_ecs::world::{DeferredWorld, World};
 /// // Later, when we want to execute the callback:
 /// app.world_mut().commands().notify(&callback);
 /// ```
-#[derive(Default, Debug)]
+#[derive(Debug)]
 pub enum Callback<I: SystemInput = ()> {
     /// Invoke a one-shot system
     System(SystemId<I>),
     /// Ignore this notification
+    Ignore,
+}
+
+impl<I: SystemInput> Copy for Callback<I> {}
+impl<I: SystemInput> Clone for Callback<I> {
+    fn clone(&self) -> Self {
+        match self {
+            Self::System(arg0) => Self::System(arg0.clone()),
+            Self::Ignore => Self::Ignore,
+        }
+    }
+}
+
+impl<In: SystemInput + 'static> GetTemplate for Callback<In> {
+    type Template = CallbackTemplate<In>;
+}
+
+#[derive(Default)]
+pub enum CallbackTemplate<In: SystemInput = ()> {
+    System(Box<dyn RegisterSystem<In>>),
+    SystemId(SystemId<In>),
     #[default]
     Ignore,
 }
 
+impl<In: SystemInput + 'static> CallbackTemplate<In> {
+    pub fn clone(&self) -> CallbackTemplate<In> {
+        match self {
+            CallbackTemplate::System(register_system) => {
+                CallbackTemplate::System(register_system.box_clone())
+            }
+            CallbackTemplate::SystemId(system_id) => CallbackTemplate::SystemId(*system_id),
+            CallbackTemplate::Ignore => CallbackTemplate::Ignore,
+        }
+    }
+}
+
+pub trait RegisterSystem<In: SystemInput>: Send + Sync + 'static {
+    fn register_system(&mut self, world: &mut World) -> SystemId<In>;
+    fn box_clone(&self) -> Box<dyn RegisterSystem<In>>;
+}
+
+pub struct IntoWrapper<I, In, Marker> {
+    into_system: Option<I>,
+    marker: PhantomData<fn() -> (In, Marker)>,
+}
+
+pub fn callback<
+    I: IntoSystem<In, (), Marker> + Send + Sync + Clone + 'static,
+    In: SystemInput + 'static,
+    Marker: 'static,
+>(
+    system: I,
+) -> CallbackTemplate<In> {
+    CallbackTemplate::from(IntoWrapper {
+        into_system: Some(system),
+        marker: PhantomData,
+    })
+}
+
+impl<
+        I: IntoSystem<In, (), Marker> + Clone + Send + Sync + 'static,
+        In: SystemInput + 'static,
+        Marker: 'static,
+    > RegisterSystem<In> for IntoWrapper<I, In, Marker>
+{
+    fn register_system(&mut self, world: &mut World) -> SystemId<In> {
+        world.register_system(self.into_system.take().unwrap())
+    }
+
+    fn box_clone(&self) -> Box<dyn RegisterSystem<In>> {
+        Box::new(IntoWrapper {
+            into_system: self.into_system.clone(),
+            marker: PhantomData,
+        })
+    }
+}
+
+impl<
+        I: IntoSystem<In, (), Marker> + Clone + Send + Sync + 'static,
+        In: SystemInput + 'static,
+        Marker: 'static,
+    > From<IntoWrapper<I, In, Marker>> for CallbackTemplate<In>
+{
+    fn from(value: IntoWrapper<I, In, Marker>) -> Self {
+        CallbackTemplate::System(Box::new(value))
+    }
+}
+
+impl<In: SystemInput + 'static> Template for CallbackTemplate<In> {
+    type Output = Callback<In>;
+
+    fn build(
+        &mut self,
+        entity: &mut bevy_ecs::world::EntityWorldMut,
+    ) -> bevy_ecs::error::Result<Self::Output> {
+        Ok(match self {
+            CallbackTemplate::System(register) => {
+                let id = entity.world_scope(move |world| register.register_system(world));
+                *self = CallbackTemplate::SystemId(id);
+                Callback::System(id)
+            }
+            CallbackTemplate::SystemId(id) => Callback::System(*id),
+            CallbackTemplate::Ignore => Callback::Ignore,
+        })
+    }
+}
+
 /// Trait used to invoke a [`Callback`], unifying the API across callers.
 pub trait Notify {
     /// Invoke the callback with no arguments.

crates/bevy_core_widgets/src/core_button.rs

@@ -17,11 +17,12 @@ use bevy_picking::events::{Cancel, Click, DragEnd, Pointer, Press, Release};
 use bevy_ui::{InteractionDisabled, Pressed};
 
 use crate::{Activate, Callback, Notify};
+use bevy_ecs::template::GetTemplate;
 
 /// Headless button widget. This widget maintains a "pressed" state, which is used to
 /// indicate whether the button is currently being pressed by the user. It emits a `ButtonClicked`
 /// event when the button is un-pressed.
-#[derive(Component, Default, Debug)]
+#[derive(Component, Clone, Debug, GetTemplate)]
 #[require(AccessibilityNode(accesskit::Node::new(Role::Button)))]
 pub struct CoreButton {
     /// Callback to invoke when the button is clicked, or when the `Enter` or `Space` key