Reflect auto registration

Cargo.toml

@@ -28,6 +28,8 @@ members = [
   "examples/mobile",
   # Examples of using Bevy on no_std platforms.
   "examples/no_std/*",
+  # Examples of compiling Bevy with automatic reflect type registration for platforms without `inventory` support.
+  "examples/reflection/auto_register_static",
   # Benchmarks
   "benches",
   # Internal tools that are not published.
@@ -157,6 +159,7 @@ default = [
   "hdr",
   "multi_threaded",
   "png",
+  "reflect_auto_register",
   "smaa_luts",
   "sysinfo_plugin",
   "tonemapping_luts",
@@ -516,6 +519,12 @@ reflect_functions = ["bevy_internal/reflect_functions"]
 # Enable documentation reflection
 reflect_documentation = ["bevy_internal/reflect_documentation"]
 
+# Enable automatic reflect registration
+reflect_auto_register = ["bevy_internal/reflect_auto_register"]
+
+# Enable automatic reflect registration without inventory. See `reflect::load_type_registrations` for more info.
+reflect_auto_register_static = ["bevy_internal/reflect_auto_register_static"]
+
 # Enable winit custom cursor support
 custom_cursor = ["bevy_internal/custom_cursor"]
 
@@ -2664,6 +2673,17 @@ description = "Demonstrates how to create and use type data"
 category = "Reflection"
 wasm = false
 
+[[example]]
+name = "auto_register_static"
+path = "examples/reflection/auto_register_static/src/lib.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.auto_register_static]
+name = "Automatic types registration"
+description = "Demonstrates how to set up automatic reflect types registration for platforms without `inventory` support"
+category = "Reflection"
+wasm = false
+
 # Scene
 [[example]]
 name = "scene"

crates/bevy_app/Cargo.toml

@@ -22,6 +22,11 @@ reflect_functions = [
   "bevy_reflect/functions",
   "bevy_ecs/reflect_functions",
 ]
+reflect_auto_register = [
+  "bevy_reflect",
+  "bevy_reflect/auto_register",
+  "bevy_ecs/reflect_auto_register",
+]
 
 # Debugging Features
 

crates/bevy_app/src/app.rs

@@ -104,7 +104,12 @@ impl Default for App {
 
         #[cfg(feature = "bevy_reflect")]
         {
+            #[cfg(not(feature = "reflect_auto_register"))]
             app.init_resource::<AppTypeRegistry>();
+
+            #[cfg(feature = "reflect_auto_register")]
+            app.insert_resource(AppTypeRegistry::new_with_derived_types());
+
             app.register_type::<Name>();
             app.register_type::<ChildOf>();
             app.register_type::<Children>();

crates/bevy_ecs/Cargo.toml

@@ -32,6 +32,7 @@ bevy_reflect = ["dep:bevy_reflect"]
 
 ## Extends reflection support to functions.
 reflect_functions = ["bevy_reflect", "bevy_reflect/functions"]
+reflect_auto_register = ["bevy_reflect", "bevy_reflect/auto_register"]
 
 ## Use the configurable global error handler as the default error handler.
 ##

crates/bevy_ecs/src/reflect/mod.rs

@@ -46,6 +46,18 @@ impl DerefMut for AppTypeRegistry {
     }
 }
 
+impl AppTypeRegistry {
+    /// Creates [`AppTypeRegistry`] and automatically registers all types deriving [`Reflect`].
+    ///
+    /// See [`TypeRegistry::register_derived_types`] for more details.
+    #[cfg(feature = "reflect_auto_register")]
+    pub fn new_with_derived_types() -> Self {
+        let app_registry = AppTypeRegistry::default();
+        app_registry.write().register_derived_types();
+        app_registry
+    }
+}
+
 /// A [`Resource`] storing [`FunctionRegistry`] for
 /// function registrations relevant to a whole app.
 ///

crates/bevy_internal/Cargo.toml

@@ -270,6 +270,20 @@ reflect_functions = [
   "bevy_ecs/reflect_functions",
 ]
 
+# Enable automatic reflect registration using inventory.
+reflect_auto_register = [
+  "bevy_reflect/auto_register_inventory",
+  "bevy_app/reflect_auto_register",
+  "bevy_ecs/reflect_auto_register",
+]
+
+# Enable automatic reflect registration without inventory. See `reflect::load_type_registrations` for more info.
+reflect_auto_register_static = [
+  "bevy_reflect/auto_register_static",
+  "bevy_app/reflect_auto_register",
+  "bevy_ecs/reflect_auto_register",
+]
+
 # Enable documentation reflection
 reflect_documentation = ["bevy_reflect/documentation"]
 

crates/bevy_reflect/Cargo.toml

@@ -10,7 +10,7 @@ keywords = ["bevy"]
 rust-version = "1.85.0"
 
 [features]
-default = ["std", "smallvec", "debug"]
+default = ["std", "smallvec", "debug", "auto_register_inventory"]
 
 # Features
 
@@ -69,6 +69,22 @@ critical-section = [
   "bevy_utils/critical-section",
 ]
 
+# Enables automatic reflect registration. Does nothing by itself, 
+# must select `auto_register_inventory` or `auto_register_static` to make it work.
+auto_register = []
+## Enables automatic reflect registration using inventory. Not supported on all platforms.
+auto_register_inventory = [
+  "auto_register",
+  "bevy_reflect_derive/auto_register_inventory",
+  "dep:inventory",
+]
+## Enable automatic reflect registration without inventory. This feature has precedence over `auto_register_inventory`.
+## See `load_type_registrations` for more info.
+auto_register_static = [
+  "auto_register",
+  "bevy_reflect_derive/auto_register_static",
+]
+
 ## Enables use of browser APIs.
 ## Note this is currently only applicable on `wasm32` architectures.
 web = ["bevy_platform/web", "uuid?/js"]
@@ -115,6 +131,9 @@ wgpu-types = { version = "24", features = [
   "serde",
 ], optional = true, default-features = false }
 
+# deps for automatic type registration
+inventory = { version = "0.3", optional = true }
+
 [dev-dependencies]
 ron = "0.8.0"
 rmp-serde = "1.1"

crates/bevy_reflect/derive/Cargo.toml

@@ -17,6 +17,13 @@ default = []
 documentation = []
 # Enables macro logic related to function reflection
 functions = []
+# Enables automatic reflect registration. Does nothing by itself, 
+# must select `auto_register_inventory` or `auto_register_static` to make it work.
+auto_register = []
+# Enables automatic reflection using inventory. Not supported on all platforms.
+auto_register_inventory = ["auto_register"]
+# Enables automatic reflection on platforms not supported by inventory. See `load_type_registrations` for more info.
+auto_register_static = ["auto_register"]
 
 [dependencies]
 bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.16.0-dev" }

crates/bevy_reflect/derive/src/container_attributes.rs

@@ -25,6 +25,7 @@ mod kw {
     syn::custom_keyword!(Hash);
     syn::custom_keyword!(Clone);
     syn::custom_keyword!(no_field_bounds);
+    syn::custom_keyword!(no_auto_register);
     syn::custom_keyword!(opaque);
 }
 
@@ -184,6 +185,7 @@ pub(crate) struct ContainerAttributes {
     type_path_attrs: TypePathAttrs,
     custom_where: Option<WhereClause>,
     no_field_bounds: bool,
+    no_auto_register: bool,
     custom_attributes: CustomAttributes,
     is_opaque: bool,
     idents: Vec<Ident>,
@@ -240,6 +242,8 @@ impl ContainerAttributes {
             self.parse_no_field_bounds(input)
         } else if lookahead.peek(kw::Clone) {
             self.parse_clone(input)
+        } else if lookahead.peek(kw::no_auto_register) {
+            self.parse_no_auto_register(input)
         } else if lookahead.peek(kw::Debug) {
             self.parse_debug(input)
         } else if lookahead.peek(kw::Hash) {
@@ -378,6 +382,16 @@ impl ContainerAttributes {
         Ok(())
     }
 
+    /// Parse `no_auto_register` attribute.
+    ///
+    /// Examples:
+    /// - `#[reflect(no_auto_register)]`
+    fn parse_no_auto_register(&mut self, input: ParseStream) -> syn::Result<()> {
+        input.parse::<kw::no_auto_register>()?;
+        self.no_auto_register = true;
+        Ok(())
+    }
+
     /// Parse `where` attribute.
     ///
     /// Examples:
@@ -583,6 +597,12 @@ impl ContainerAttributes {
         self.no_field_bounds
     }
 
+    /// Returns true if the `no_auto_register` attribute was found on this type.
+    #[cfg(feature = "auto_register")]
+    pub fn no_auto_register(&self) -> bool {
+        self.no_auto_register
+    }
+
     /// Returns true if the `opaque` attribute was found on this type.
     pub fn is_opaque(&self) -> bool {
         self.is_opaque

crates/bevy_reflect/derive/src/impls/common.rs

@@ -156,3 +156,72 @@ pub fn common_partial_reflect_methods(
         #debug_fn
     }
 }
+
+#[cfg(feature = "auto_register")]
+pub fn reflect_auto_registration(meta: &ReflectMeta) -> Option<proc_macro2::TokenStream> {
+    if meta.attrs().no_auto_register() {
+        return None;
+    }
+
+    let bevy_reflect_path = meta.bevy_reflect_path();
+    let type_path = meta.type_path();
+
+    if type_path.impl_is_generic() {
+        return None;
+    };
+
+    if cfg!(feature = "auto_register_static") {
+        use std::{env, fs, io::Write, path::PathBuf, sync::LazyLock, sync::Mutex};
+
+        // Names of registrations functions will be stored in this file.
+        // To allow writing to this file from multiple threads during compilation it is protected by mutex.
+        // This static is valid for the duration of compilation of one crate and we have one file per crate,
+        // so it is enough to protect compilation threads from overwriting each other.
+        // This file is reset on every recompilation.
+        static REGISTRATION_FNS_EXPORT: LazyLock<Mutex<fs::File>> = LazyLock::new(|| {
+            let path = PathBuf::from("target").join("type_registrations");
+            fs::DirBuilder::new()
+                .recursive(true)
+                .create(&path)
+                .unwrap_or_else(|_| panic!("Failed to create {:?}", path));
+            let file_path = path.join(
+                env::var("CARGO_CRATE_NAME")
+                    .expect("Expected cargo to set CARGO_CRATE_NAME env var"),
+            );
+            let file = fs::OpenOptions::new()
+                .create(true)
+                .write(true)
+                .truncate(true)
+                .open(&file_path)
+                .unwrap_or_else(|_| panic!("Failed to create {:?}", file_path));
+            Mutex::new(file)
+        });
+
+        let export_name = format!("_bevy_reflect_register_{}", uuid::Uuid::new_v4().as_u128());
+        if env::var("BEVY_REFLECT_AUTO_REGISTER_STATIC").is_ok_and(|v| v != "0") {
+            let mut file = REGISTRATION_FNS_EXPORT.lock().unwrap();
+            writeln!(file, "{}", export_name)
+                .unwrap_or_else(|_| panic!("Failed to write registration function"));
+            // We must sync_data to ensure all content is written before releasing the mutex.
+            file.sync_data().unwrap();
+        };
+        Some(quote! {
+            /// # Safety
+            /// This function must only be used by the `load_type_registrations` macro.
+            #[unsafe(export_name=#export_name)]
+            pub unsafe extern "Rust" fn bevy_register_type(registry: &mut #bevy_reflect_path::TypeRegistry) {
+                <#type_path as #bevy_reflect_path::__macro_exports::RegisterForReflection>::__register(registry);
+            }
+        })
+    } else if cfg!(feature = "auto_register_inventory") {
+        Some(quote! {
+            #bevy_reflect_path::__macro_exports::auto_register::inventory::submit!{
+                #bevy_reflect_path::__macro_exports::auto_register::AutomaticReflectRegistrations(
+                    <#type_path as #bevy_reflect_path::__macro_exports::auto_register::RegisterForReflection>::__register
+                )
+            }
+        })
+    } else {
+        None
+    }
+}

crates/bevy_reflect/derive/src/impls/enums.rs

@@ -83,6 +83,11 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
     let (impl_generics, ty_generics, where_clause) =
         reflect_enum.meta().type_path().generics().split_for_impl();
 
+    #[cfg(not(feature = "auto_register"))]
+    let auto_register = None::<proc_macro2::TokenStream>;
+    #[cfg(feature = "auto_register")]
+    let auto_register = crate::impls::reflect_auto_registration(reflect_enum.meta());
+
     let where_reflect_clause = where_clause_options.extend_where_clause(where_clause);
 
     quote! {
@@ -96,6 +101,8 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> proc_macro2::TokenStream
 
         #function_impls
 
+        #auto_register
+
         impl #impl_generics #bevy_reflect_path::Enum for #enum_path #ty_generics #where_reflect_clause {
             fn field(&self, #ref_name: &str) -> #FQOption<&dyn #bevy_reflect_path::PartialReflect> {
                  match #match_this {

crates/bevy_reflect/derive/src/impls/mod.rs

@@ -9,6 +9,8 @@ mod tuple_structs;
 mod typed;
 
 pub(crate) use assertions::impl_assertions;
+#[cfg(feature = "auto_register")]
+pub(crate) use common::reflect_auto_registration;
 pub(crate) use common::{common_partial_reflect_methods, impl_full_reflect};
 pub(crate) use enums::impl_enum;
 #[cfg(feature = "functions")]

crates/bevy_reflect/derive/src/impls/opaque.rs

@@ -56,6 +56,11 @@ pub(crate) fn impl_opaque(meta: &ReflectMeta) -> proc_macro2::TokenStream {
     #[cfg(feature = "functions")]
     let function_impls = crate::impls::impl_function_traits(meta, &where_clause_options);
 
+    #[cfg(not(feature = "auto_register"))]
+    let auto_register = None::<proc_macro2::TokenStream>;
+    #[cfg(feature = "auto_register")]
+    let auto_register = crate::impls::reflect_auto_registration(meta);
+
     let (impl_generics, ty_generics, where_clause) = type_path.generics().split_for_impl();
     let where_reflect_clause = where_clause_options.extend_where_clause(where_clause);
     let get_type_registration_impl = meta.get_type_registration(&where_clause_options);
@@ -71,6 +76,8 @@ pub(crate) fn impl_opaque(meta: &ReflectMeta) -> proc_macro2::TokenStream {
 
         #function_impls
 
+        #auto_register
+
         impl #impl_generics #bevy_reflect_path::PartialReflect for #type_path #ty_generics #where_reflect_clause  {
             #[inline]
             fn get_represented_type_info(&self) -> #FQOption<&'static #bevy_reflect_path::TypeInfo> {

crates/bevy_reflect/derive/src/impls/structs.rs

@@ -63,6 +63,11 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> proc_macro2::TokenS
         .generics()
         .split_for_impl();
 
+    #[cfg(not(feature = "auto_register"))]
+    let auto_register = None::<proc_macro2::TokenStream>;
+    #[cfg(feature = "auto_register")]
+    let auto_register = crate::impls::reflect_auto_registration(reflect_struct.meta());
+
     let where_reflect_clause = where_clause_options.extend_where_clause(where_clause);
 
     quote! {
@@ -76,6 +81,8 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> proc_macro2::TokenS
 
         #function_impls
 
+        #auto_register
+
         impl #impl_generics #bevy_reflect_path::Struct for #struct_path #ty_generics #where_reflect_clause {
             fn field(&self, name: &str) -> #FQOption<&dyn #bevy_reflect_path::PartialReflect> {
                 match name {

crates/bevy_reflect/derive/src/impls/tuple_structs.rs

@@ -51,6 +51,11 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> proc_macro2::
         .generics()
         .split_for_impl();
 
+    #[cfg(not(feature = "auto_register"))]
+    let auto_register = None::<proc_macro2::TokenStream>;
+    #[cfg(feature = "auto_register")]
+    let auto_register = crate::impls::reflect_auto_registration(reflect_struct.meta());
+
     let where_reflect_clause = where_clause_options.extend_where_clause(where_clause);
 
     quote! {
@@ -64,6 +69,8 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> proc_macro2::
 
         #function_impls
 
+        #auto_register
+
         impl #impl_generics #bevy_reflect_path::TupleStruct for #struct_path #ty_generics #where_reflect_clause {
             fn field(&self, index: usize) -> #FQOption<&dyn #bevy_reflect_path::PartialReflect> {
                 match index {