bring back the queue for attachments

Author: makspll

crates/bevy_mod_scripting_core/src/pipeline/mod.rs

@@ -1,9 +1,9 @@
 //! Everything to do with the script lifetime management pipeline
 
-use std::{any::Any, marker::PhantomData, sync::Arc};
+use std::{any::Any, collections::VecDeque, marker::PhantomData, sync::Arc};
 
 use bevy_app::{App, Plugin, PostUpdate};
-use bevy_asset::{Assets, Handle};
+use bevy_asset::{AssetServer, Assets, Handle, LoadState};
 use bevy_ecs::{
     event::{Event, EventCursor, EventReader, EventWriter, Events},
     resource::Resource,
@@ -109,6 +109,59 @@ impl<P: IntoScriptPluginParams> ScriptLoadingPipeline<P> {
     }
 }
 
+/// A trait describing things containing script handles
+pub trait GetScriptHandle {
+    /// Retrieve the contained script handle
+    fn get_script_handle(&self) -> Handle<ScriptAsset>;
+}
+
+#[derive(SystemParam)]
+/// A system param which operates over types implementing [`GetScriptHandle`].
+/// Captures incoming "handle" like types, and waits until their asset is in a final state before proceeding, if that final state
+/// is loaded, will also guarantee a strong handle, otherwise the whole thing is skipped.
+///
+/// Think of this as a proxy for "baby'ing" asset handles
+pub struct LoadedWithHandles<'w, 's, T: GetScriptHandle + Event + Clone> {
+    assets: ResMut<'w, Assets<ScriptAsset>>,
+    asset_server: Res<'w, AssetServer>,
+    fresh_events: EventReader<'w, 's, T>,
+    loaded_with_handles: Local<'s, VecDeque<(T, StrongScriptHandle)>>,
+    loading: Local<'s, VecDeque<T>>,
+}
+
+impl<T: GetScriptHandle + Event + Clone> LoadedWithHandles<'_, '_, T> {
+    /// Retrieves all of the events of type `T`, which have finished loading and have a strong handle,
+    /// the rest will be discarded.
+    ///
+    /// This uses a [`EventReader<T>`] underneath, meaning if you don't call this method once every frame (or every other frame).
+    /// You may miss events.
+    pub fn get_loaded(&mut self) -> impl Iterator<Item = (T, StrongScriptHandle)> {
+        // first get all of the fresh_events
+        self.loading.extend(self.fresh_events.read().cloned());
+        // now process the loading queue
+        self.loading.retain(|e| {
+            let handle = e.get_script_handle();
+            match self.asset_server.get_load_state(&handle) {
+                Some(LoadState::Loaded) => {
+                    let strong = StrongScriptHandle::from_assets(handle, &mut self.assets);
+                    if let Some(strong) = strong {
+                        self.loaded_with_handles.push_front((e.clone(), strong));
+                        true
+                    } else {
+                        false
+                    }
+                }
+                Some(LoadState::Loading) => true,
+                Some(_) => false,
+                None => false,
+            }
+        });
+
+        // now return loaded with handles elements by draining
+        self.loaded_with_handles.drain(..)
+    }
+}
+
 // struct StateBuilder<'a, P: IntoScriptPluginParams, M, S> {
 //     plugin: &'a ScriptLoadingPipeline<P>,
 //     app: &'a mut App,

crates/bevy_mod_scripting_core/src/pipeline/start.rs

@@ -18,6 +18,24 @@ pub struct ScriptAssetModifiedEvent(pub ScriptId);
 #[derive(Clone, Debug)]
 pub struct StrongScriptHandle(Handle<ScriptAsset>);
 
+impl GetScriptHandle for ScriptAssetModifiedEvent {
+    fn get_script_handle(&self) -> Handle<ScriptAsset> {
+        Handle::Weak(self.0)
+    }
+}
+
+impl GetScriptHandle for ScriptAttachedEvent {
+    fn get_script_handle(&self) -> Handle<ScriptAsset> {
+        self.0.script()
+    }
+}
+
+impl GetScriptHandle for ScriptDetachedEvent {
+    fn get_script_handle(&self) -> Handle<ScriptAsset> {
+        self.0.script()
+    }
+}
+
 impl StrongScriptHandle {
     /// Creates a new strong script handle, only if the given handle is strong itself.
     pub fn new(handle: Handle<ScriptAsset>) -> Option<Self> {
@@ -28,6 +46,14 @@ impl StrongScriptHandle {
         }
     }
 
+    /// create a strong script handle using the assets resource and the possibly weak handle.
+    pub fn from_assets(
+        handle: Handle<ScriptAsset>,
+        assets: &mut Assets<ScriptAsset>,
+    ) -> Option<Self> {
+        assets.get_strong_handle(handle.id()).map(Self)
+    }
+
     /// Upgrades an asset Id pointing to a script to a strong handle if the asset hasn't been dropped
     pub fn upgrade(id: ScriptId, assets: &mut Assets<ScriptAsset>) -> Option<Self> {
         assets.get_strong_handle(id).map(Self)
@@ -70,41 +96,32 @@ pub fn filter_script_modifications<P: IntoScriptPluginParams>(
 
 /// Filters incoming [`ScriptAttachedEvent`]'s leaving only those which match the plugin's language
 pub fn filter_script_attachments<P: IntoScriptPluginParams>(
-    mut events: EventReader<ScriptAttachedEvent>,
+    mut events: LoadedWithHandles<ScriptAttachedEvent>,
     mut filtered: EventWriter<ForPlugin<ScriptAttachedEvent, P>>,
-    assets: Res<Assets<ScriptAsset>>,
     mut requests: ResMut<RequestProcessingPipelineRun<P>>,
 ) {
-    let mut batch = events
-        .read()
-        .filter(|e| {
-            assets
-                .get(&e.0.script())
-                .is_some_and(|asset| asset.language == P::LANGUAGE)
-        })
-        .cloned()
-        .map(ForPlugin::new);
+    let mut batch = events.get_loaded().map(|(mut a, b)| {
+        *a.0.script_mut() = b.0;
+        ForPlugin::new(a)
+    });
 
     if let Some(next) = batch.next() {
         requests.request_run();
         filtered.write_batch(std::iter::once(next).chain(batch));
     }
 }
 
-/// Filters incoming [`ScriptDetachedEvent`]'s leaving only those which match the plugin's language
+/// Filters incoming [`ScriptDetachedEvent`]'s leaving only those which are currently attached
 pub fn filter_script_detachments<P: IntoScriptPluginParams>(
     mut events: EventReader<ScriptDetachedEvent>,
     mut filtered: EventWriter<ForPlugin<ScriptDetachedEvent, P>>,
-    assets: Res<Assets<ScriptAsset>>,
+    contexts: Res<ScriptContext<P>>,
     mut requests: ResMut<RequestProcessingPipelineRun<P>>,
 ) {
+    let contexts_guard = contexts.read();
     let mut batch = events
         .read()
-        .filter(|e| {
-            assets
-                .get(&e.0.script())
-                .is_some_and(|asset| asset.language == P::LANGUAGE)
-        })
+        .filter(|e| contexts_guard.contains(&e.0))
         .cloned()
         .map(ForPlugin::new);
 

crates/bevy_mod_scripting_core/src/script/context_key.rs

@@ -33,14 +33,22 @@ impl std::fmt::Display for ScriptAttachment {
 }
 
 impl ScriptAttachment {
-    /// Returns the script handle if it exists.
+    /// Returns the script handle.
     pub fn script(&self) -> Handle<ScriptAsset> {
         match self {
             ScriptAttachment::EntityScript(_, script) => script.clone(),
             ScriptAttachment::StaticScript(script) => script.clone(),
         }
     }
 
+    /// Returns a mutable reference to the underlying script handle.
+    pub fn script_mut(&mut self) -> &mut Handle<ScriptAsset> {
+        match self {
+            ScriptAttachment::EntityScript(_, script) => script,
+            ScriptAttachment::StaticScript(script) => script,
+        }
+    }
+
     /// Returns the entity if it exists.
     pub fn entity(&self) -> Option<Entity> {
         match self {