Improve BSN macros and add ICBINBSN-like scene retention (#181)

* Simplify Scene to get rid of SceneTuple. Tuples of Scene now implements Scene

* Add construct_from_patch extension for EntityWorldMut

* Clean up bounds

* Improve DynamicScene to handle concrete/typed component construction without reflection

* Use new spawn API's PR as bevy version temporarily + migrate ConstructTuple bundle impl

* Revert spawn apis for now

* Add RetainScene partially implementing ICBINBSN receipts equivalent

* Replace ICBINBSN hot example with RetainScene version

* Clean up/improve Scene and DynamicPatch traits and impls

* Adjust patch fn bounds, add retain_child_scenes, and port ICBINBSN scene tree example

* WIP work MAYBE REVERT

* Cleanup

* Consume scenes instead of cloning them

* Add spread operator

* Add no_reflect attribute for non reflectable construct derives

* Add On utility for bsn observers

* Clean up examples

* Update docs/examples + rename stuff

* Avoid props ident conflicts in patch closures

* Clean up required components properly when retaining scenes

Author: villor

crates/bevy_bsn/Cargo.toml

@@ -11,12 +11,9 @@ bevy = { workspace = true }
 thiserror = { workspace = true }
 variadics_please = { workspace = true }
 
-[dev-dependencies]
-bevy_i-cant-believe-its-not-bsn.workspace = true
-
 [lints]
 workspace = true
 
 [[example]]
-name = "bsn_icbinbsn_hot"
+name = "bsn_asset_hot"
 required-features = ["bevy/file_watcher"]

crates/bevy_bsn/examples/bsn_asset.rs

@@ -39,12 +39,7 @@ fn spawn_scene_on_load(
                 .reflect_dynamic_scene()
                 .unwrap();
 
-            commands.queue(move |world: &mut World| {
-                let id = world.spawn_empty().id();
-                dynamic_scene
-                    .construct(&mut ConstructContext::new(id, world))
-                    .unwrap();
-            });
+            commands.spawn_scene(dynamic_scene);
         };
     }
 }

crates/bevy_bsn/examples/bsn_asset_hot.rs

@@ -0,0 +1,49 @@
+//! Simple non-destructive .bsn-hot-reloading utilizing [`RetainScene`].
+//!
+//! Run with `--features="bevy/file_watcher"` to enable hot-reloading.
+use bevy::prelude::*;
+use bevy_bsn::*;
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_plugins(BsnPlugin)
+        .add_systems(
+            Startup,
+            |mut commands: Commands, assets: Res<AssetServer>| {
+                commands.spawn(Camera2d);
+
+                let bsn = assets.load::<Bsn>("hello.bsn");
+                commands.spawn(SceneRoot(bsn));
+            },
+        )
+        .add_systems(Update, spawn_and_reload_scene)
+        .run();
+}
+
+#[derive(Component)]
+struct SceneRoot(Handle<Bsn>);
+
+fn spawn_and_reload_scene(
+    scene_root: Single<Entity, With<SceneRoot>>,
+    mut events: EventReader<AssetEvent<Bsn>>,
+    bsn_assets: Res<Assets<Bsn>>,
+    app_registry: Res<AppTypeRegistry>,
+    mut commands: Commands,
+) {
+    for event in events.read() {
+        match event {
+            AssetEvent::Added { id } | AssetEvent::Modified { id } => {
+                let bsn = bsn_assets.get(*id).unwrap();
+
+                let registry = app_registry.read();
+                let dynamic_scene = BsnReflector::new(bsn, &registry)
+                    .reflect_dynamic_scene()
+                    .unwrap();
+
+                commands.entity(*scene_root).retain_scene(dynamic_scene);
+            }
+            _ => {}
+        }
+    }
+}

crates/bevy_bsn/examples/bsn_icbinbsn_hot.rs

@@ -23,7 +23,7 @@ fn ui() -> impl Scene {
             flex_direction: FlexDirection::Column,
             row_gap: px(5.0),
         } [
-            (Node, :button("Basic")),
+            (Node, {Name::new("BasicButton")}, :button("Basic")),
             (Node, :button("Rounded"), rounded),
             (Node { border: px_all(5.0) }, BorderColor(RED_500) :button("Thick red"), rounded),
             (Node, :button("Merged children"), rounded) [(
@@ -34,6 +34,18 @@ fn ui() -> impl Scene {
                 BackgroundColor(BLUE_500),
                 {BorderRadius::MAX}
             )],
+
+            (:button("Click me!")) [
+                // Observing parent entity
+                On(|_: Trigger<Pointer<Click>>| {
+                    info!("Clicked me!");
+                })
+            ],
+
+            // Observing entity "BasicButton" by name
+            On(|_: Trigger<Pointer<Click>>| {
+                info!("Clicked Basic!");
+            }, @"BasicButton"),
         ]
     }
 }

crates/bevy_bsn/examples/bsn_macro.rs

@@ -0,0 +1,94 @@
+//! Super Sheep-Counter 2000
+//!
+//! An all-in-one numerical ruminant package.
+//!
+//! This example is originally from `i-cant-believe-its-not-bsn` and shows the differences between using `bsn!` and `template!`.
+use bevy::{color::palettes::css, prelude::*};
+
+use bevy_bsn::{Scene, *};
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_plugins(BsnPlugin)
+        .add_plugins(sheep_plugin)
+        .run();
+}
+
+fn sheep_plugin(app: &mut App) {
+    app.add_systems(Startup, setup)
+        .add_systems(Update, sheep_system);
+}
+
+fn setup(mut commands: Commands) {
+    commands.spawn(Camera2d);
+    commands.spawn(UiRoot);
+}
+
+#[derive(Component)]
+struct UiRoot;
+
+#[derive(Component)]
+struct Sheep;
+
+// A query that pulls data from the ecs and then updates it using a template.
+fn sheep_system(mut commands: Commands, sheep: Query<&Sheep>, root: Single<Entity, With<UiRoot>>) {
+    let num_sheep = sheep.iter().len();
+
+    let template = bsn! {
+        Node {
+            position_type: PositionType::Absolute,
+            bottom: Val::Px(5.0),
+            right: Val::Px(5.0),
+        } [
+            ..counter(num_sheep, "sheep"),
+        ]
+    };
+
+    commands.entity(*root).retain_scene(template);
+}
+
+// A function that returns an ecs template.
+fn counter(num: usize, name: &'static str) -> impl Scene {
+    bsn! {
+        Node [
+            Text("You have ") [
+                TextSpan(format!("{num}")),
+                TextSpan(format!(" {name}!")),
+            ],
+            (
+                Button,
+                Text("Increase"),
+                TextColor(css::GREEN),
+                {visible_if(num < 100)}
+            ) [
+                // Observes parent entity.
+                On(|_: Trigger<Pointer<Released>>, mut commands: Commands| {
+                    commands.spawn(Sheep);
+                })
+            ],
+            (
+                {Name::new("DecreaseButton")},
+                Button,
+                Text("Decrease"),
+                TextColor(css::RED),
+                {visible_if(num > 0)},
+            ),
+            // Observes named entity "DecreaseButton"
+            On(|_: Trigger<Pointer<Released>>, sheep: Query<Entity, With<Sheep>>, mut commands: Commands| {
+                if let Some(sheep) = sheep.iter().next() {
+                    commands.entity(sheep).despawn();
+                }
+            }, @"DecreaseButton"),
+        ]
+    }
+}
+
+// A component helper function for computing visibility.
+fn visible_if(condition: bool) -> Visibility {
+    if condition {
+        Visibility::Visible
+    } else {
+        Visibility::Hidden
+    }
+}