Introduce `ReflectConvert`, a generic reflection mechanism for type conversions, intended for asset BSN. by pcwalton · Pull Request #23742 · bevyengine/bevy

pcwalton · 2026-04-09T22:45:34Z

One of the important features of BSN is that supplying a value of type T where a value of type U is expected is allowed if a From conversion exists from T to U. This is what allows HandleTemplates to be automatically created from string literals. We need this feature for BSN like this to be valid:

SceneRoot("models/FlightHelmet/FlightHelmet.gltf#Scene0")

And for this to be valid:

EnvironmentMapLight {
    diffuse_map: "environment_maps/pisa_diffuse_rgb9e5_zstd.ktx2",
    specular_map: "environment_maps/pisa_specular_rgb9e5_zstd.ktx2",
    intensity: 250.0,
}

Unfortunately, the From trait isn't reflectable, and this is a problem as reflection drives asset BSN. It's not immediately clear how to make From reflectable either, as a syntax like #[reflect(From)] wouldn't work as it's a generic trait.

Instead of making From directly reflectable, this patch introduces ReflectConvert, a new TypeData that encodes a generic way to convert a value of type T to type U. You register a type conversion like this:

App::new()
    .register_type::<i32>()
    .register_type::<String>()
    .register_type_conversion::<i32, String>(|n| Ok(n.into()));

And you invoke the conversion like this:

let reflect_convert = registry
    .get_type_data::<ReflectConvert>(TypeId::of::<String>())
    .unwrap();

let converted = reflect_convert
    .try_convert_from(Box::new(12345i32))
    .unwrap()
    .downcast::<String>()
    .unwrap();

I tested ReflectConvert with asset BSN (PR #23576). The ReflectConvert trait as implemented in this patch successfully enables HandleTemplates to be created from strings, without hard-coding HandleTemplate anywhere in the patch generation logic.

conversions, intended for asset BSN. One of the important features of BSN is that supplying a value of type T where a value of type U is expected is allowed if a `From` conversion exists from T to U. This is what allows `HandleTemplate`s to be automatically created from string literals. We need this feature for BSN like this to be valid: ```rust SceneRoot("models/FlightHelmet/FlightHelmet.gltf#Scene0") ``` And for this to be valid: ```rust EnvironmentMapLight { diffuse_map: "environment_maps/pisa_diffuse_rgb9e5_zstd.ktx2", specular_map: "environment_maps/pisa_specular_rgb9e5_zstd.ktx2", intensity: 250.0, } ``` Unfortunately, the `From` trait isn't reflectable, and this is a problem as reflection drives asset BSN. It's not immediately clear how to make `From` reflectable either, as a syntax like `#[reflect(From)]` wouldn't work as it's a generic trait. Instead of making `From` directly reflectable, this patch introduces `ReflectConvert`, a new `TypeData` that encodes a generic way to convert a value of type T to type U. You register a type conversion like this: ```rust App::new() .register_type::<i32>() .register_type::<String>() .register_type_conversion::<i32, String>(|n| Ok(n.into())); ``` And you invoke the conversion like this: ```rust let reflect_convert = registry .get_type_data::<ReflectConvert>(TypeId::of::<String>()) .unwrap(); let converted = reflect_convert .try_convert_from(Box::new(12345i32)) .unwrap() .downcast::<String>() .unwrap(); ``` I tested `ReflectConvert` with asset BSN (PR bevyengine#23576). The `ReflectConvert` trait as implemented in this patch successfully enables `HandleTemplate`s to be created from strings, without hard-coding `HandleTemplate` anywhere in the patch generation logic.

andriyDev · 2026-04-09T23:04:40Z

+    ///
+    /// See [`bevy_reflect::TypeRegistry::register_type_conversion`].
+    #[cfg(feature = "bevy_reflect")]
+    pub fn register_type_conversion<T, U>(&mut self, function: fn(T) -> Result<U, T>) -> &mut Self


I wonder if we should have a register_into_type_conversion that just does the into for you? I suspect most calls to this will just be into.

Yeah, I was considering that too. In an earlier version you were just able to write .register_type_conversion::<T,U>(Into::into) but I realized that was incompatible with fallible conversions, and I'm pretty sure we do want fallible conversions.

To clarify: I meant provide both: the into is just a convenience for calling the more general TryInto

I added register_into_type_conversion as requested.

SkiFire13 · 2026-04-10T12:05:31Z

+    /// If the conversion succeeds, the function should return the converted
+    /// value. If the conversion fails, the function should return the original
+    /// input value.
+    pub fn register_type_conversion<T, U>(&mut self, function: fn(T) -> Result<U, T>)


Is there a reason this take a fn pointer? It is both more limiting (as it doesn't allow captures) and more expensive (as it always forces the Box below to allocate, while ZST closures can avoid that; it also forces two dynamic dispatch calls instead of just one)

Because it needs to be Cloneable. I can't write:

struct TypedConverter<T, U>(Box<dyn (FnMut(T) -> Result<U, T>) + Clone>) where T: Reflect + TypePath, U: Reflect + TypePath;

Since Clone isn't an auto trait. I could write trait Convert<T, U>: FnMut(T) -> Result<U,T> + Clone but then the closure you pass in wouldn't implement Convert, defeating the ergonomic advantages of taking a function in register_type_conversion.

What's the pattern you're thinking of specifically?

TypedConverter could store a generic F though, no? You end up type erasing it anyway to a Box<dyn Converter> so there's no need to do another type erasure here.

Ah yes, makes sense. I made that change.

SkiFire13 · 2026-04-13T07:32:11Z

+        match (self.function)(input.take()?) {
+            Ok(value) => Ok(Box::new(value)),
+            Err(value) => Err(Box::new(value)),
+        }


Nit: I wonder if we could use Reflect::downcast instead of Reflect::take to get a Box<T> which we can reuse in the Err path to avoid allocating again. This would make a series of conversions that all fail much cheaper. Something like this:

Suggested change

match (self.function)(input.take()?) {

Ok(value) => Ok(Box::new(value)),

Err(value) => Err(Box::new(value)),

}

let mut input = input.downcast::<T>()?;

match (self.function)(*input) {

Ok(value) => Ok(Box::new(value)),

Err(value) => {

*input = value;

Err(input)

}

}

cart

We need this, and the feature is about as straightforward as it gets.

appropriate places

…onversions, intended for asset BSN. (bevyengine#23742) One of the important features of BSN is that supplying a value of type T where a value of type U is expected is allowed if a `From` conversion exists from T to U. This is what allows `HandleTemplate`s to be automatically created from string literals. We need this feature for BSN like this to be valid: ```rust SceneRoot("models/FlightHelmet/FlightHelmet.gltf#Scene0") ``` And for this to be valid: ```rust EnvironmentMapLight { diffuse_map: "environment_maps/pisa_diffuse_rgb9e5_zstd.ktx2", specular_map: "environment_maps/pisa_specular_rgb9e5_zstd.ktx2", intensity: 250.0, } ``` Unfortunately, the `From` trait isn't reflectable, and this is a problem as reflection drives asset BSN. It's not immediately clear how to make `From` reflectable either, as a syntax like `#[reflect(From)]` wouldn't work as it's a generic trait. Instead of making `From` directly reflectable, this patch introduces `ReflectConvert`, a new `TypeData` that encodes a generic way to convert a value of type T to type U. You register a type conversion like this: ```rust App::new() .register_type::<i32>() .register_type::<String>() .register_type_conversion::<i32, String>(|n| Ok(n.into())); ``` And you invoke the conversion like this: ```rust let reflect_convert = registry .get_type_data::<ReflectConvert>(TypeId::of::<String>()) .unwrap(); let converted = reflect_convert .try_convert_from(Box::new(12345i32)) .unwrap() .downcast::<String>() .unwrap(); ``` I tested `ReflectConvert` with asset BSN (PR bevyengine#23576). The `ReflectConvert` trait as implemented in this patch successfully enables `HandleTemplate`s to be created from strings, without hard-coding `HandleTemplate` anywhere in the patch generation logic. --------- Co-authored-by: Carter Anderson <mcanders1@gmail.com>

pcwalton requested review from alice-i-cecile, andriyDev and cart April 9, 2026 22:45

pcwalton added the A-Reflection Runtime information about types label Apr 9, 2026

github-project-automation Bot added this to Reflection Apr 9, 2026

github-project-automation Bot moved this to Needs SME Triage in Reflection Apr 9, 2026

pcwalton added C-Feature A new feature, making something new possible D-Modest A "normal" level of difficulty; suitable for simple features or challenging fixes S-Needs-Review Needs reviewer attention (from anyone!) to move forward labels Apr 9, 2026

pcwalton mentioned this pull request Apr 9, 2026

Implement dynamic BSN (.bsn asset format) #23576

Draft

andriyDev approved these changes Apr 9, 2026

View reviewed changes

pcwalton added 5 commits April 9, 2026 20:24

Doc check police

865fa70

Doc check police

5534917

Add register_into_type_conversion and fix tests

d66e05f

Make sure HandleTemplate is registered

5b89b14

Merge remote-tracking branch 'origin/main' into reflect-convert

d6659c0

SkiFire13 reviewed Apr 10, 2026

View reviewed changes

pcwalton added 3 commits April 11, 2026 23:26

Merge remote-tracking branch 'origin/main' into reflect-convert

3395263

Add a test for multiple conversions to the same type

3a5871e

Use a Fn instead of a fn

5951964

pcwalton requested a review from SkiFire13 April 12, 2026 19:36

Doc check police

1e17659

SkiFire13 reviewed Apr 13, 2026

View reviewed changes

Address review comments

008aefe

pcwalton requested a review from SkiFire13 April 13, 2026 19:37

SkiFire13 approved these changes Apr 13, 2026

View reviewed changes

cart added this to @cart's attention Apr 13, 2026

cart approved these changes Apr 13, 2026

View reviewed changes

Comment thread crates/bevy_reflect/src/type_registry.rs Outdated

Add TypeRegistration::get_or_insert_data_with and use it in the

0cf1e95

appropriate places

alice-i-cecile added S-Ready-For-Final-Review This PR has been approved by the community. It's ready for a maintainer to consider merging it and removed S-Needs-Review Needs reviewer attention (from anyone!) to move forward labels Apr 13, 2026

alice-i-cecile approved these changes Apr 13, 2026

View reviewed changes

alice-i-cecile added this pull request to the merge queue Apr 13, 2026

Merged via the queue into bevyengine:main with commit 02aef14 Apr 13, 2026
40 checks passed

github-project-automation Bot moved this to Done in @cart's attention Apr 13, 2026

github-project-automation Bot moved this from Needs SME Triage to Done in Reflection Apr 13, 2026

-        match (self.function)(input.take()?) {
-            Ok(value) => Ok(Box::new(value)),
-            Err(value) => Err(Box::new(value)),
-        }
+        let mut input = input.downcast::<T>()?;
+        match (self.function)(*input) {
+            Ok(value) => Ok(Box::new(value)),
+            Err(value) => {
+                *input = value;
+                Err(input)
+            }
+        }

Uh oh!

Conversation

pcwalton commented Apr 9, 2026

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cart left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

5 participants