make the generics more tenable, and update docs

Author: makspll

crates/bevy_mod_scripting_core/src/commands.rs

@@ -8,15 +8,16 @@ use crate::{
     prelude::{Runtime, RuntimeContainer},
     script::{Script, ScriptId, Scripts},
     systems::handle_script_errors,
+    IntoScriptPluginParams,
 };
 
-pub struct DeleteScript<C: Context, R: Runtime> {
+pub struct DeleteScript<P: IntoScriptPluginParams> {
     pub id: ScriptId,
     // hack to make this Send, C does not need to be Send since it is not stored in the command
-    pub _ph: PhantomData<fn(C, R)>,
+    pub _ph: PhantomData<fn(P::C, P::R)>,
 }
 
-impl<C: Context, R: Runtime> DeleteScript<C, R> {
+impl<P: IntoScriptPluginParams> DeleteScript<P> {
     pub fn new(id: ScriptId) -> Self {
         Self {
             id,
@@ -25,17 +26,17 @@ impl<C: Context, R: Runtime> DeleteScript<C, R> {
     }
 }
 
-impl<C: Context, R: Runtime> Command for DeleteScript<C, R> {
+impl<P: IntoScriptPluginParams> Command for DeleteScript<P> {
     fn apply(self, world: &mut bevy::prelude::World) {
         let settings = world
-            .get_resource::<ContextLoadingSettings<C, R>>()
+            .get_resource::<ContextLoadingSettings<P>>()
             .expect("No ScriptLoadingSettings resource found")
             .clone();
 
         world.resource_scope(|world, mut scripts: Mut<Scripts>| {
             if let Some(script) = scripts.scripts.remove(&self.id) {
                 debug!("Deleting script with id: {}", self.id);
-                let mut ctxts = world.get_non_send_resource_mut::<ScriptContexts<C>>();
+                let mut ctxts = world.get_non_send_resource_mut::<ScriptContexts<P>>();
                 let ctxts = ctxts.as_deref_mut().unwrap();
                 let assigner = settings
                     .assigner
@@ -58,15 +59,15 @@ impl<C: Context, R: Runtime> Command for DeleteScript<C, R> {
 /// Creates new script with the given ID, if a script with the given ID already exists, this is treated as an update
 ///
 /// If script comes from an asset, expects it to be loaded, otherwise this command will fail to process the script.
-pub struct CreateOrUpdateScript<C: Context, R: Runtime> {
+pub struct CreateOrUpdateScript<P: IntoScriptPluginParams> {
     id: ScriptId,
     content: Box<[u8]>,
     asset: Option<Handle<ScriptAsset>>,
     // Hack to make this Send, C does not need to be Send since it is not stored in the command
-    _ph: std::marker::PhantomData<fn(R, C)>,
+    _ph: std::marker::PhantomData<fn(P::R, P::C)>,
 }
 
-impl<C: Context, R: Runtime> CreateOrUpdateScript<C, R> {
+impl<P: IntoScriptPluginParams> CreateOrUpdateScript<P> {
     pub fn new(id: ScriptId, content: Box<[u8]>, asset: Option<Handle<ScriptAsset>>) -> Self {
         Self {
             id,
@@ -77,17 +78,17 @@ impl<C: Context, R: Runtime> CreateOrUpdateScript<C, R> {
     }
 }
 
-impl<C: Context, R: Runtime> Command for CreateOrUpdateScript<C, R> {
+impl<P: IntoScriptPluginParams> Command for CreateOrUpdateScript<P> {
     fn apply(self, world: &mut bevy::prelude::World) {
         let settings = world
-            .get_resource::<ContextLoadingSettings<C, R>>()
+            .get_resource::<ContextLoadingSettings<P>>()
             .unwrap()
             .clone();
         let mut contexts = world
-            .remove_non_send_resource::<ScriptContexts<C>>()
+            .remove_non_send_resource::<ScriptContexts<P>>()
             .unwrap();
         let mut runtime = world
-            .remove_non_send_resource::<RuntimeContainer<R>>()
+            .remove_non_send_resource::<RuntimeContainer<P>>()
             .unwrap();
         // assign context
         let assigner = settings.assigner.clone().expect("No context assigner set");
@@ -116,7 +117,7 @@ impl<C: Context, R: Runtime> Command for CreateOrUpdateScript<C, R> {
                 match ctxt {
                     Ok(ctxt) => contexts.insert(ctxt),
                     Err(e) => {
-                        handle_script_errors(world, [e.with_context(format!("Loading context for script with id: {}. With runtime type: {} and context type: {}", self.id, type_name::<R>(), type_name::<C>()))].into_iter());
+                        handle_script_errors(world, [e.with_context(format!("Loading context for script with id: {}. With runtime type: {} and context type: {}", self.id, type_name::<P::R>(), type_name::<P::C>()))].into_iter());
                         return;
                     }
                 }

crates/bevy_mod_scripting_core/src/context.rs

@@ -5,6 +5,7 @@ use bevy::ecs::{entity::Entity, system::Resource, world::World};
 use crate::{
     prelude::{Runtime, ScriptError},
     script::{Script, ScriptId},
+    IntoScriptPluginParams,
 };
 
 pub trait Context: 'static {}
@@ -13,11 +14,11 @@ impl<T: 'static> Context for T {}
 pub type ContextId = u32;
 
 #[derive(Resource)]
-pub struct ScriptContexts<T: Context> {
-    pub(crate) contexts: HashMap<ContextId, T>,
+pub struct ScriptContexts<P: IntoScriptPluginParams> {
+    pub(crate) contexts: HashMap<ContextId, P::C>,
 }
 
-impl<T: Context> Default for ScriptContexts<T> {
+impl<P: IntoScriptPluginParams> Default for ScriptContexts<P> {
     fn default() -> Self {
         Self {
             contexts: Default::default(),
@@ -26,15 +27,15 @@ impl<T: Context> Default for ScriptContexts<T> {
 }
 
 static CONTEXT_ID_COUNTER: AtomicU32 = AtomicU32::new(0);
-impl<T: Context> ScriptContexts<T> {
+impl<P: IntoScriptPluginParams> ScriptContexts<P> {
     pub fn new() -> Self {
         Self {
             contexts: HashMap::new(),
         }
     }
 
     /// Allocates a new ContextId and inserts the context into the map
-    pub fn insert(&mut self, ctxt: T) -> ContextId {
+    pub fn insert(&mut self, ctxt: P::C) -> ContextId {
         let id = CONTEXT_ID_COUNTER.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
         self.contexts.insert(id, ctxt);
         id
@@ -45,26 +46,27 @@ impl<T: Context> ScriptContexts<T> {
         CONTEXT_ID_COUNTER.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
     }
 
-    pub fn remove(&mut self, id: ContextId) -> Option<T> {
+    pub fn remove(&mut self, id: ContextId) -> Option<P::C> {
         self.contexts.remove(&id)
     }
 }
 
 /// Initializer run once after creating a context but before executing it for the first time
-pub type ContextInitializer<C> = fn(&ScriptId, &mut C) -> Result<(), ScriptError>;
+pub type ContextInitializer<P: IntoScriptPluginParams> =
+    fn(&ScriptId, &mut P::C) -> Result<(), ScriptError>;
 /// Initializer run every time before executing or loading a script
-pub type ContextPreHandlingInitializer<C> =
-    fn(&ScriptId, Entity, &mut C) -> Result<(), ScriptError>;
+pub type ContextPreHandlingInitializer<P: IntoScriptPluginParams> =
+    fn(&ScriptId, Entity, &mut P::C) -> Result<(), ScriptError>;
 
 #[derive(Resource)]
-pub struct ContextLoadingSettings<C: Context, R: Runtime> {
-    pub loader: Option<ContextBuilder<C, R>>,
-    pub assigner: Option<ContextAssigner<C>>,
-    pub context_initializers: Vec<ContextInitializer<C>>,
-    pub context_pre_handling_initializers: Vec<ContextPreHandlingInitializer<C>>,
+pub struct ContextLoadingSettings<P: IntoScriptPluginParams> {
+    pub loader: Option<ContextBuilder<P>>,
+    pub assigner: Option<ContextAssigner<P>>,
+    pub context_initializers: Vec<ContextInitializer<P>>,
+    pub context_pre_handling_initializers: Vec<ContextPreHandlingInitializer<P>>,
 }
 
-impl<C: Context, R: Runtime> Default for ContextLoadingSettings<C, R> {
+impl<P: IntoScriptPluginParams> Default for ContextLoadingSettings<P> {
     fn default() -> Self {
         Self {
             loader: None,
@@ -75,7 +77,7 @@ impl<C: Context, R: Runtime> Default for ContextLoadingSettings<C, R> {
     }
 }
 
-impl<C: Context, R: Runtime> Clone for ContextLoadingSettings<C, R> {
+impl<P: IntoScriptPluginParams> Clone for ContextLoadingSettings<P> {
     fn clone(&self) -> Self {
         Self {
             loader: self.loader.clone(),
@@ -87,27 +89,27 @@ impl<C: Context, R: Runtime> Clone for ContextLoadingSettings<C, R> {
 }
 
 /// A strategy for loading and reloading contexts
-pub struct ContextBuilder<C: Context, R: Runtime> {
+pub struct ContextBuilder<P: IntoScriptPluginParams> {
     pub load: fn(
         script: &ScriptId,
         content: &[u8],
-        &[ContextInitializer<C>],
-        &[ContextPreHandlingInitializer<C>],
+        &[ContextInitializer<P>],
+        &[ContextPreHandlingInitializer<P>],
         &mut World,
-        runtime: &mut R,
-    ) -> Result<C, ScriptError>,
+        runtime: &mut P::R,
+    ) -> Result<P::C, ScriptError>,
     pub reload: fn(
         script: &ScriptId,
         new_content: &[u8],
-        context: &mut C,
-        &[ContextInitializer<C>],
-        &[ContextPreHandlingInitializer<C>],
+        context: &mut P::C,
+        &[ContextInitializer<P>],
+        &[ContextPreHandlingInitializer<P>],
         &mut World,
-        &mut R,
+        &mut P::R,
     ) -> Result<(), ScriptError>,
 }
 
-impl<C: Context, R: Runtime> Clone for ContextBuilder<C, R> {
+impl<P: IntoScriptPluginParams> Clone for ContextBuilder<P> {
     fn clone(&self) -> Self {
         Self {
             load: self.load,
@@ -117,23 +119,23 @@ impl<C: Context, R: Runtime> Clone for ContextBuilder<C, R> {
 }
 
 /// A strategy for assigning contexts to new and existing but re-loaded scripts as well as for managing old contexts
-pub struct ContextAssigner<C: Context> {
+pub struct ContextAssigner<P: IntoScriptPluginParams> {
     /// Assign a context to the script, if script is `None`, this is a new script, otherwise it is an existing script with a context inside `contexts`.
     /// Returning None means the script should be assigned a new context
     pub assign: fn(
         old_script: Option<&Script>,
         script_id: &ScriptId,
         new_content: &[u8],
-        contexts: &ScriptContexts<C>,
+        contexts: &ScriptContexts<P>,
     ) -> Option<ContextId>,
 
     /// Handle the removal of the script, if any clean up in contexts is necessary perform it here.
     /// This will also be called, when a script is assigned a contextId on reload different from the previous one
     /// the context_id in that case will be the old context_id and the one stored in the script will be the old one
-    pub remove: fn(context_id: ContextId, script: &Script, contexts: &mut ScriptContexts<C>),
+    pub remove: fn(context_id: ContextId, script: &Script, contexts: &mut ScriptContexts<P>),
 }
 
-impl<C: Context> Default for ContextAssigner<C> {
+impl<P: IntoScriptPluginParams> Default for ContextAssigner<P> {
     fn default() -> Self {
         Self {
             assign: |old, _, _, _| old.map(|s| s.context_id),
@@ -142,7 +144,7 @@ impl<C: Context> Default for ContextAssigner<C> {
     }
 }
 
-impl<C: Context> Clone for ContextAssigner<C> {
+impl<P: IntoScriptPluginParams> Clone for ContextAssigner<P> {
     fn clone(&self) -> Self {
         Self {
             assign: self.assign,

crates/bevy_mod_scripting_core/src/event.rs

@@ -53,29 +53,34 @@ impl CallbackLabel {
 #[macro_export]
 macro_rules! callback_labels {
     ($($name:ident => $label:expr),*) => {
-        pub enum CallbackLabels {
-            $($name),*
-        }
 
-        impl IntoCallbackLabel for CallbackLabels {
-            fn into_callback_label() -> CallbackLabel {
-                match self {
-                    $(CallbackLabels::$name => $label.into()),*
+        $(
+            pub struct $name;
+            impl IntoCallbackLabel for $name {
+                fn into_callback_label() -> CallbackLabel {
+                    $label.into()
                 }
             }
-        }
+        )*
     };
 }
 
 pub trait IntoCallbackLabel {
     fn into_callback_label() -> CallbackLabel;
 }
 
+impl<T: IntoCallbackLabel> From<T> for CallbackLabel {
+    fn from(_: T) -> Self {
+        T::into_callback_label()
+    }
+}
+
 impl From<&str> for CallbackLabel {
     fn from(s: &str) -> Self {
         Self::new_lossy(s)
     }
 }
+
 impl From<String> for CallbackLabel {
     fn from(s: String) -> Self {
         Self::from(s.as_str())

crates/bevy_mod_scripting_core/src/handler.rs

@@ -6,29 +6,30 @@ use crate::{
     prelude::{ScriptError, ScriptValue},
     runtime::Runtime,
     script::ScriptId,
+    IntoScriptPluginParams,
 };
 
 pub trait Args: Clone + Send + Sync + 'static {}
 impl<T: Clone + Send + Sync + 'static> Args for T {}
 
-pub type HandlerFn<C, R> = fn(
+pub type HandlerFn<P: IntoScriptPluginParams> = fn(
     args: Vec<ScriptValue>,
     entity: Entity,
     script_id: &ScriptId,
     callback: &CallbackLabel,
-    context: &mut C,
-    pre_handling_initializers: &[ContextPreHandlingInitializer<C>],
-    runtime: &mut R,
+    context: &mut P::C,
+    pre_handling_initializers: &[ContextPreHandlingInitializer<P>],
+    runtime: &mut P::R,
     world: &mut World,
 ) -> Result<(), ScriptError>;
 
 /// A resource that holds the settings for the callback handler for a specific combination of type parameters
 #[derive(Resource)]
-pub struct CallbackSettings<C: Context, R: Runtime> {
-    pub callback_handler: Option<HandlerFn<C, R>>,
+pub struct CallbackSettings<P: IntoScriptPluginParams> {
+    pub callback_handler: Option<HandlerFn<P>>,
 }
 
-impl<C: Context, R: Runtime> Default for CallbackSettings<C, R> {
+impl<P: IntoScriptPluginParams> Default for CallbackSettings<P> {
     fn default() -> Self {
         Self {
             callback_handler: None,