Implement hot reloading for prototypes

Cargo.toml

@@ -18,6 +18,8 @@ typetag = "0.2"
 serde_yaml = "0.9"
 dyn-clone = "1.0"
 indexmap = "1.9"
+crossbeam-channel = { version = "0.5", optional = true }
+notify = { version = "=5.0.0-pre.15", optional = true }
 
 [dev-dependencies]
 bevy = "0.8"
@@ -28,6 +30,8 @@ default = ["analysis"]
 analysis = []
 # If enabled, panics when a dependency cycle is found, otherwise logs a warning
 no_cycles = ["analysis"]
+# If enabled, allows for hot reloading
+hot_reloading = ["dep:crossbeam-channel", "dep:notify"]
 
 [[example]]
 name = "basic"

src/data.rs

@@ -46,7 +46,7 @@ pub struct ProtoData {
             HashMap<HandleId, UuidHandleMap>,
         >,
     >,
-    prototypes: HashMap<String, Box<dyn Prototypical>>,
+    pub(crate) prototypes: HashMap<String, Box<dyn Prototypical>>,
 }
 
 impl ProtoData {

src/hot_reload.rs

@@ -0,0 +1,81 @@
+use bevy::prelude::{App, Plugin, Res, ResMut};
+use crossbeam_channel::Receiver;
+use notify::{Event, RecommendedWatcher, RecursiveMode, Result, Watcher};
+
+use crate::prelude::{ProtoData, ProtoDataOptions};
+
+// Copied from bevy_asset's implementation
+// https://github.com/bevyengine/bevy/blob/main/crates/bevy_asset/src/filesystem_watcher.rs
+struct FilesystemWatcher {
+    watcher: RecommendedWatcher,
+    receiver: Receiver<Result<Event>>,
+}
+
+impl FilesystemWatcher {
+    /// Watch for changes recursively at the provided path.
+    fn watch<P: AsRef<std::path::Path>>(&mut self, path: P) -> Result<()> {
+        self.watcher.watch(path.as_ref(), RecursiveMode::Recursive)
+    }
+}
+
+impl Default for FilesystemWatcher {
+    fn default() -> Self {
+        let (sender, receiver) = crossbeam_channel::unbounded();
+        let watcher: RecommendedWatcher = RecommendedWatcher::new(move |res| {
+            sender.send(res).expect("Watch event send failure.");
+        })
+        .expect("Failed to create filesystem watcher.");
+        FilesystemWatcher { watcher, receiver }
+    }
+}
+
+// Copied from bevy_asset's filesystem watching implementation:
+// https://github.com/bevyengine/bevy/blob/main/crates/bevy_asset/src/io/file_asset_io.rs#L167-L199
+fn watch_for_changes(
+    watcher: Res<FilesystemWatcher>,
+    mut proto_data: ResMut<ProtoData>,
+    options: Res<ProtoDataOptions>,
+) {
+    let mut changed = bevy::utils::HashSet::default();
+    loop {
+        let event = match watcher.receiver.try_recv() {
+            Ok(result) => result.unwrap(),
+            Err(crossbeam_channel::TryRecvError::Empty) => break,
+            Err(crossbeam_channel::TryRecvError::Disconnected) => {
+                panic!("FilesystemWatcher disconnected.")
+            }
+        };
+        if let notify::event::Event {
+            kind: notify::event::EventKind::Modify(_),
+            paths,
+            ..
+        } = event
+        {
+            for path in &paths {
+                if !changed.contains(path) {
+                    if let Ok(data) = std::fs::read_to_string(path) {
+                        if let Some(proto) = options.deserializer.deserialize(&data) {
+                            proto_data
+                                .prototypes
+                                .insert(proto.name().to_string(), proto);
+                        }
+                    }
+                }
+            }
+            changed.extend(paths);
+        }
+    }
+}
+
+pub(crate) struct HotReloadPlugin {
+    pub(crate) path: String,
+}
+
+impl Plugin for HotReloadPlugin {
+    fn build(&self, app: &mut App) {
+        let mut watcher = FilesystemWatcher::default();
+        watcher.watch(self.path.clone()).unwrap();
+
+        app.insert_resource(watcher).add_system(watch_for_changes);
+    }
+}

src/lib.rs

@@ -82,6 +82,9 @@ pub use plugin::ProtoPlugin;
 mod prototype;
 pub use prototype::{deserialize_templates_list, Prototype, Prototypical};
 
+#[cfg(feature = "hot_reloading")]
+mod hot_reload;
+
 pub mod data;
 #[macro_use]
 mod utils;

src/plugin.rs

@@ -121,19 +121,22 @@ impl ProtoPlugin {
 
 impl Plugin for ProtoPlugin {
     fn build(&self, app: &mut App) {
-        if let Some(opts) = &self.options {
-            // Insert custom prototype options
-            app.insert_resource(opts.clone());
-        } else {
-            // Insert default options
-            app.insert_resource(ProtoDataOptions {
+        let opts = self.options.clone();
+        let opts = opts.unwrap_or(
+            ProtoDataOptions {
                 directories: vec![String::from("assets/prototypes")],
                 recursive_loading: false,
                 deserializer: Box::new(DefaultProtoDeserializer),
                 extensions: Some(vec!["yaml", "json"]),
-            });
-        }
+            }
+        );
+
+        #[cfg(feature = "hot_reloading")]
+        app.add_plugin(crate::hot_reload::HotReloadPlugin {
+            path: opts.directories[0].clone()
+        });
 
+        app.insert_resource(opts);
         // Initialize prototypes
         app.init_resource::<ProtoData>();
     }