get something working

Author: makspll

assets/tests/register_new_component/new_component_can_be_retrieved.lua

@@ -0,0 +1,12 @@
+local NewComponent = world.register_new_component("NewComponent")
+assert(NewComponent ~= nil, "Failed to register new component")
+assert(NewComponent:short_name() == "ScriptComponent", "Unexpected component type")
+
+
+local new_entity = world.spawn()
+
+world.add_default_component(new_entity, NewComponent)
+
+local component_intance = world.get_component(new_entity, NewComponent)
+
+assert(component_intance ~= nil, "Failed to get component instance")

crates/bevy_mod_scripting_core/src/bindings/script_component.rs

@@ -1,24 +1,23 @@
 //! Everything necessary to support scripts registering their own components
 
-use std::{alloc::Layout, mem::needs_drop, sync::Arc};
-
+use super::{ScriptComponentRegistration, ScriptTypeRegistration, ScriptValue, WorldAccessGuard};
+use crate::error::InteropError;
 use bevy::{
+    app::{App, Plugin},
     ecs::{
         component::{Component, ComponentDescriptor, StorageType},
         reflect::ReflectComponent,
+        system::Resource,
     },
-    reflect::{GetTypeRegistration, Reflect, TypeRegistration},
+    reflect::{prelude::ReflectDefault, GetTypeRegistration, Reflect},
     utils::HashMap,
 };
 use parking_lot::RwLock;
-
-use crate::error::InteropError;
-
-use super::{ScriptComponentRegistration, ScriptTypeRegistration, ScriptValue, WorldGuard};
+use std::{alloc::Layout, mem::needs_drop, sync::Arc};
 
 /// A dynamic script component, with script set
-#[derive(Reflect, Clone)]
-#[reflect(Component)]
+#[derive(Reflect, Clone, Default)]
+#[reflect(Component, Default)]
 pub struct ScriptComponent {
     data: ScriptValue,
 }
@@ -36,20 +35,40 @@ impl Component for ScriptComponent {
 }
 
 /// A registry of dynamically registered script components
+#[derive(Clone, Resource, Default)]
 pub struct AppScriptComponentRegistry(pub Arc<RwLock<ScriptComponentRegistry>>);
 
+impl AppScriptComponentRegistry {
+    /// Reads the underlying registry
+    pub fn read(&self) -> parking_lot::RwLockReadGuard<ScriptComponentRegistry> {
+        self.0.read()
+    }
+
+    /// Writes to the underlying registry
+    pub fn write(&self) -> parking_lot::RwLockWriteGuard<ScriptComponentRegistry> {
+        self.0.write()
+    }
+}
+
+#[derive(Default)]
+/// A registry of dynamically registered script components
 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()
-            })?;
+impl ScriptComponentRegistry {
+    /// Registers a dynamic script component, possibly overwriting an existing one
+    pub fn register(&mut self, info: ScriptComponentInfo) {
+        self.components.insert(info.name.clone(), info);
+    }
+
+    /// Gets a dynamic script component by name
+    pub fn get(&self, name: &str) -> Option<&ScriptComponentInfo> {
+        self.components.get(name)
     }
+}
 
+impl WorldAccessGuard<'_> {
     /// Registers a dynamic script component, and returns a reference to its registration
     pub fn register_script_component(
         &self,
@@ -59,8 +78,9 @@ impl WorldGuard<'_> {
             let descriptor = unsafe {
                 // Safety: same safety guarantees as ComponentDescriptor::new
                 // we know the type in advance
+                // we only use this method to name the component
                 ComponentDescriptor::new_with_layout(
-                    component_name,
+                    component_name.clone(),
                     ScriptComponent::STORAGE_TYPE,
                     Layout::new::<ScriptComponent>(),
                     needs_drop::<ScriptComponent>().then_some(|x| x.drop_as::<ScriptComponent>()),
@@ -69,17 +89,41 @@ impl WorldGuard<'_> {
             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();
+        let component_registry = self.component_registry();
+        let mut component_registry = component_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(
+        let registration = ScriptComponentRegistration::new(
             ScriptTypeRegistration::new(Arc::new(
                 <ScriptComponent as GetTypeRegistration>::get_type_registration(),
             )),
             component_id,
-        ))
+        );
+
+        bevy::log::debug!(
+            "Registering dynamic script component: {}, component id assigned: {:?}",
+            component_name,
+            component_id
+        );
+
+        let component_info = ScriptComponentInfo {
+            name: component_name.clone(),
+            registration: registration.clone(),
+        };
+
+        component_registry.register(component_info);
+
+        // 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(registration)
+    }
+}
+
+/// A plugin to support dynamic script components
+pub(crate) struct DynamicScriptComponentPlugin;
+
+impl Plugin for DynamicScriptComponentPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<AppScriptComponentRegistry>()
+            .register_type::<ScriptComponent>();
     }
 }

crates/bevy_mod_scripting_core/src/bindings/script_system.rs

@@ -5,8 +5,9 @@ use super::{
     function::{from::Val, into::IntoScript, script_function::AppScriptFunctionRegistry},
     schedule::AppScheduleRegistry,
     script_value::ScriptValue,
-    AppReflectAllocator, ReflectBaseType, ReflectReference, ScriptQueryBuilder, ScriptQueryResult,
-    ScriptResourceRegistration, WorldAccessGuard, WorldGuard,
+    AppReflectAllocator, AppScriptComponentRegistry, ReflectBaseType, ReflectReference,
+    ScriptQueryBuilder, ScriptQueryResult, ScriptResourceRegistration, WorldAccessGuard,
+    WorldGuard,
 };
 use crate::{
     bindings::pretty_print::DisplayWithWorld,
@@ -288,6 +289,7 @@ struct ScriptSystemState {
     type_registry: AppTypeRegistry,
     function_registry: AppScriptFunctionRegistry,
     schedule_registry: AppScheduleRegistry,
+    component_registry: AppScriptComponentRegistry,
     allocator: AppReflectAllocator,
     subset: HashSet<ReflectAccessId>,
     callback_label: CallbackLabel,
@@ -424,6 +426,7 @@ impl<P: IntoScriptPluginParams> System for DynamicScriptSystem<P> {
                 state.allocator.clone(),
                 state.function_registry.clone(),
                 state.schedule_registry.clone(),
+                state.component_registry.clone(),
             )
         };
 
@@ -577,6 +580,9 @@ impl<P: IntoScriptPluginParams> System for DynamicScriptSystem<P> {
                 .clone(),
             schedule_registry: world.get_resource_or_init::<AppScheduleRegistry>().clone(),
             allocator: world.get_resource_or_init::<AppReflectAllocator>().clone(),
+            component_registry: world
+                .get_resource_or_init::<AppScriptComponentRegistry>()
+                .clone(),
             subset,
             callback_label: self.name.to_string().into(),
             system_params,

crates/bevy_mod_scripting_core/src/bindings/script_value.rs

@@ -13,10 +13,11 @@ use super::{
 
 /// An abstraction of values that can be passed to and from scripts.
 /// This allows us to re-use logic between scripting languages.
-#[derive(Debug, Clone, PartialEq, Reflect)]
+#[derive(Debug, Clone, PartialEq, Reflect, Default)]
 #[reflect(opaque)]
 pub enum ScriptValue {
     /// Represents the absence of a value.
+    #[default]
     Unit,
     /// Represents a boolean value.
     Bool(bool),

crates/bevy_mod_scripting_core/src/bindings/world.rs

@@ -171,6 +171,7 @@ impl<'w> WorldAccessGuard<'w> {
         allocator: AppReflectAllocator,
         function_registry: AppScriptFunctionRegistry,
         schedule_registry: AppScheduleRegistry,
+        script_component_registry: AppScriptComponentRegistry,
     ) -> Self {
         Self {
             inner: Rc::new(WorldAccessGuardInner {
@@ -184,6 +185,7 @@ impl<'w> WorldAccessGuard<'w> {
                 allocator,
                 function_registry,
                 schedule_registry,
+                script_component_registry,
             }),
             invalid: Rc::new(false.into()),
         }
@@ -206,6 +208,10 @@ impl<'w> WorldAccessGuard<'w> {
             .get_resource_or_init::<AppScriptFunctionRegistry>()
             .clone();
 
+        let script_component_registry = world
+            .get_resource_or_init::<AppScriptComponentRegistry>()
+            .clone();
+
         let schedule_registry = world.get_resource_or_init::<AppScheduleRegistry>().clone();
         Self {
             inner: Rc::new(WorldAccessGuardInner {
@@ -215,6 +221,7 @@ impl<'w> WorldAccessGuard<'w> {
                 type_registry,
                 function_registry,
                 schedule_registry,
+                script_component_registry,
             }),
             invalid: Rc::new(false.into()),
         }
@@ -330,6 +337,11 @@ impl<'w> WorldAccessGuard<'w> {
         self.inner.schedule_registry.clone()
     }
 
+    /// Returns the component registry for the world
+    pub fn component_registry(&self) -> AppScriptComponentRegistry {
+        self.inner.script_component_registry.clone()
+    }
+
     /// Returns the script allocator for the world
     pub fn allocator(&self) -> AppReflectAllocator {
         self.inner.allocator.clone()
@@ -813,12 +825,12 @@ impl WorldAccessGuard<'_> {
     }
 
     /// get a type registration for the type, without checking if it's a component or resource
-    pub fn get_type_by_name(&self, type_name: String) -> Option<ScriptTypeRegistration> {
+    pub fn get_type_by_name(&self, type_name: &str) -> Option<ScriptTypeRegistration> {
         let type_registry = self.type_registry();
         let type_registry = type_registry.read();
         type_registry
-            .get_with_short_type_path(&type_name)
-            .or_else(|| type_registry.get_with_type_path(&type_name))
+            .get_with_short_type_path(type_name)
+            .or_else(|| type_registry.get_with_type_path(type_name))
             .map(|registration| ScriptTypeRegistration::new(Arc::new(registration.clone())))
     }
 
@@ -864,10 +876,17 @@ impl WorldAccessGuard<'_> {
         >,
         InteropError,
     > {
-        let val = self.get_type_by_name(type_name);
+        let val = self.get_type_by_name(&type_name);
         Ok(match val {
             Some(registration) => Some(self.get_type_registration(registration)?),
-            None => None,
+            None => {
+                // try the component registry
+                let components = self.component_registry();
+                let components = components.read();
+                components
+                    .get(&type_name)
+                    .map(|c| Union::new_right(Union::new_left(c.registration.clone())))
+            }
         })
     }
 
@@ -921,20 +940,25 @@ impl WorldAccessGuard<'_> {
                 )
             })?;
 
+        bevy::log::debug!("found component data");
+
         // we look for ReflectDefault or ReflectFromWorld data then a ReflectComponent data
         let instance = if let Some(default_td) = registration
             .type_registration()
             .type_registration()
             .data::<ReflectDefault>()
         {
+            bevy::log::debug!("found default data");
             default_td.default()
         } else if let Some(from_world_td) = registration
             .type_registration()
             .type_registration()
             .data::<ReflectFromWorld>()
         {
+            bevy::log::debug!("found reflect from world");
             self.with_global_access(|world| from_world_td.from_world(world))?
         } else {
+            bevy::log::debug!("found neither");
             return Err(InteropError::missing_type_data(
                 registration.registration.type_id(),
                 "ReflectDefault or ReflectFromWorld".to_owned(),
@@ -950,6 +974,7 @@ impl WorldAccessGuard<'_> {
                 .map_err(|_| InteropError::missing_entity(entity))?;
             {
                 let registry = type_registry.read();
+                bevy::log::debug!("inserting component instance using component data");
                 component_data.insert(&mut entity, instance.as_partial_reflect(), &registry);
             }
             Ok(())
@@ -1001,12 +1026,23 @@ impl WorldAccessGuard<'_> {
             .get_entity(entity)
             .ok_or_else(|| InteropError::missing_entity(entity))?;
 
+        bevy::log::debug!("Retrieving component with component id: {:?}", component_id);
+
         let component_info = cell
             .components()
             .get_info(component_id)
             .ok_or_else(|| InteropError::invalid_component(component_id))?;
 
-        if entity.contains_id(component_id) {
+        bevy::log::debug!(
+            "Retrieved component with component info: {:?}",
+            component_info
+        );
+
+        if entity.contains_id(component_id)
+            || component_info
+                .type_id()
+                .is_some_and(|t| entity.contains_type_id(t))
+        {
             Ok(Some(ReflectReference {
                 base: ReflectBaseType {
                     type_id: component_info.type_id().ok_or_else(|| {

crates/bevy_mod_scripting_core/src/lib.rs

@@ -14,7 +14,8 @@ use bindings::{
     globals::{core::CoreScriptGlobalsPlugin, AppScriptGlobalsRegistry},
     schedule::AppScheduleRegistry,
     script_value::ScriptValue,
-    AppReflectAllocator, ReflectAllocator, ReflectReference, ScriptTypeRegistration,
+    AppReflectAllocator, DynamicScriptComponentPlugin, ReflectAllocator, ReflectReference,
+    ScriptTypeRegistration,
 };
 use commands::{AddStaticScript, RemoveStaticScript};
 use context::{
@@ -312,7 +313,7 @@ fn once_per_app_init(app: &mut App) {
         ((garbage_collector).in_set(ScriptingSystemSet::GarbageCollection),),
     );
 
-    app.add_plugins(CoreScriptGlobalsPlugin);
+    app.add_plugins((CoreScriptGlobalsPlugin, DynamicScriptComponentPlugin));
 
     configure_asset_systems(app);
 }

crates/bevy_mod_scripting_functions/src/core.rs

@@ -445,6 +445,21 @@ impl World {
         let world = ctxt.world()?;
         world.exit()
     }
+
+    /// Registers a new component type with the world.
+    /// Arguments:
+    /// * `ctxt`: The function call context.
+    /// * `name`: The name of the component type.
+    /// Returns:
+    /// * `registration`: The registration of the new component type if successful.
+    fn register_new_component(
+        ctxt: FunctionCallContext,
+        name: String,
+    ) -> Result<Val<ScriptComponentRegistration>, InteropError> {
+        profiling::function_scope!("register_new_component");
+        let world = ctxt.world()?;
+        world.register_script_component(name).map(Val)
+    }
 }
 
 #[script_bindings(