WIP

Author: makspll

crates/bevy_mod_scripting_core/src/bindings/mod.rs

@@ -12,4 +12,5 @@ crate::private::export_all_in_modules! {
     script_system,
     script_value,
     world,
+    script_component,
 }

crates/bevy_mod_scripting_core/src/bindings/script_component.rs

@@ -0,0 +1,85 @@
+//! Everything necessary to support scripts registering their own components
+
+use std::{alloc::Layout, mem::needs_drop, sync::Arc};
+
+use bevy::{
+    ecs::{
+        component::{Component, ComponentDescriptor, StorageType},
+        reflect::ReflectComponent,
+    },
+    reflect::{GetTypeRegistration, Reflect, TypeRegistration},
+    utils::HashMap,
+};
+use parking_lot::RwLock;
+
+use crate::error::InteropError;
+
+use super::{ScriptComponentRegistration, ScriptTypeRegistration, ScriptValue, WorldGuard};
+
+/// A dynamic script component, with script set
+#[derive(Reflect, Clone)]
+#[reflect(Component)]
+pub struct ScriptComponent {
+    data: ScriptValue,
+}
+
+/// Some metadata about dynamic script components
+pub struct ScriptComponentInfo {
+    /// The name of the component
+    pub name: String,
+    /// The type registration for the component
+    pub registration: ScriptComponentRegistration,
+}
+
+impl Component for ScriptComponent {
+    const STORAGE_TYPE: StorageType = StorageType::Table;
+}
+
+/// A registry of dynamically registered script components
+pub struct AppScriptComponentRegistry(pub Arc<RwLock<ScriptComponentRegistry>>);
+
+pub struct ScriptComponentRegistry {
+    components: HashMap<String, ScriptComponentInfo>,
+}
+
+impl WorldGuard<'_> {
+    pub fn script_component_registry(&self) -> AppScriptComponentRegistry {
+        let component_registry =
+            self.with_resource(|app_component_registry: &AppScriptComponentRegistry| {
+                app_component_registry.clone()
+            })?;
+    }
+
+    /// Registers a dynamic script component, and returns a reference to its registration
+    pub fn register_script_component(
+        &self,
+        component_name: String,
+    ) -> Result<ScriptComponentRegistration, InteropError> {
+        let component_id = self.with_global_access(|w| {
+            let descriptor = unsafe {
+                // Safety: same safety guarantees as ComponentDescriptor::new
+                // we know the type in advance
+                ComponentDescriptor::new_with_layout(
+                    component_name,
+                    ScriptComponent::STORAGE_TYPE,
+                    Layout::new::<ScriptComponent>(),
+                    needs_drop::<ScriptComponent>().then_some(|x| x.drop_as::<ScriptComponent>()),
+                )
+            };
+            w.register_component_with_descriptor(descriptor)
+        })?;
+
+        // we need to register this as a type in the type registry with this name so its retrievable as any other type
+        let type_registry = self.type_registry();
+        let mut type_registry = type_registry.write();
+
+        // TODO: we should probably retrieve this from the registry, but I don't see what people would want to register on this type
+        // in addition to the existing registrations.
+        Ok(ScriptComponentRegistration::new(
+            ScriptTypeRegistration::new(Arc::new(
+                <ScriptComponent as GetTypeRegistration>::get_type_registration(),
+            )),
+            component_id,
+        ))
+    }
+}

crates/bevy_mod_scripting_core/src/bindings/world.rs

@@ -9,13 +9,23 @@ use super::{
     access_map::{
         AccessCount, AccessMapKey, AnyAccessMap, DynamicSystemMeta, ReflectAccessId,
         ReflectAccessKind, SubsetAccessMap,
-    }, function::{
+    },
+    function::{
         namespace::Namespace,
         script_function::{AppScriptFunctionRegistry, DynamicScriptFunction, FunctionCallContext},
-    }, pretty_print::DisplayWithWorld, schedule::AppScheduleRegistry, script_value::ScriptValue, with_global_access, AppReflectAllocator, ReflectBase, ReflectBaseType, ReflectReference, ScriptComponentRegistration, ScriptResourceRegistration, ScriptTypeRegistration, Union
+    },
+    pretty_print::DisplayWithWorld,
+    schedule::AppScheduleRegistry,
+    script_value::ScriptValue,
+    with_global_access, AppReflectAllocator, AppScriptComponentRegistry, ReflectBase,
+    ReflectBaseType, ReflectReference, ScriptComponentRegistration, ScriptResourceRegistration,
+    ScriptTypeRegistration, Union,
 };
 use crate::{
-    bindings::{function::{from::FromScript, from_ref::FromScriptRef}, with_access_read, with_access_write},
+    bindings::{
+        function::{from::FromScript, from_ref::FromScriptRef},
+        with_access_read, with_access_write,
+    },
     error::InteropError,
     reflection_extensions::PartialReflectExt,
 };
@@ -73,6 +83,8 @@ pub(crate) struct WorldAccessGuardInner<'w> {
     function_registry: AppScriptFunctionRegistry,
     /// The schedule registry for the world
     schedule_registry: AppScheduleRegistry,
+    /// The registry of script registered components
+    script_component_registry: AppScriptComponentRegistry,
 }
 
 impl std::fmt::Debug for WorldAccessGuardInner<'_> {
@@ -542,7 +554,6 @@ impl<'w> WorldAccessGuard<'w> {
 /// Impl block for higher level world methods
 #[profiling::all_functions]
 impl WorldAccessGuard<'_> {
-    
     fn construct_from_script_value(
         &self,
         descriptor: impl Into<Cow<'static, str>>,
@@ -812,8 +823,16 @@ impl WorldAccessGuard<'_> {
     }
 
     /// get a type erased type registration for the type including information about whether it's a component or resource
-    pub(crate) fn get_type_registration(&self, registration: ScriptTypeRegistration) -> Result<Union<ScriptTypeRegistration, Union<ScriptComponentRegistration, ScriptResourceRegistration>>, InteropError> {
-
+    pub(crate) fn get_type_registration(
+        &self,
+        registration: ScriptTypeRegistration,
+    ) -> Result<
+        Union<
+            ScriptTypeRegistration,
+            Union<ScriptComponentRegistration, ScriptResourceRegistration>,
+        >,
+        InteropError,
+    > {
         let registration = match self.get_resource_type(registration)? {
             Ok(res) => {
                 return Ok(Union::new_right(Union::new_right(res)));
@@ -831,14 +850,23 @@ impl WorldAccessGuard<'_> {
         Ok(Union::new_left(registration))
     }
 
-    /// Similar to [`Self::get_type_by_name`] but returns a type erased [`ScriptTypeRegistration`], [`ScriptComponentRegistration`] or [`ScriptResourceRegistration`] 
+    /// Similar to [`Self::get_type_by_name`] but returns a type erased [`ScriptTypeRegistration`], [`ScriptComponentRegistration`] or [`ScriptResourceRegistration`]
     /// depending on the underlying type and state of the world.
-    pub fn get_type_registration_by_name(&self, type_name: String) -> Result<Option<Union<ScriptTypeRegistration, Union<ScriptComponentRegistration, ScriptResourceRegistration>>>, InteropError> {
+    pub fn get_type_registration_by_name(
+        &self,
+        type_name: String,
+    ) -> Result<
+        Option<
+            Union<
+                ScriptTypeRegistration,
+                Union<ScriptComponentRegistration, ScriptResourceRegistration>,
+            >,
+        >,
+        InteropError,
+    > {
         let val = self.get_type_by_name(type_name);
         Ok(match val {
-            Some(registration) => {
-                Some(self.get_type_registration(registration)?)
-            }
+            Some(registration) => Some(self.get_type_registration(registration)?),
             None => None,
         })
     }