[Merged by Bors] - add `ReflectAsset` and `ReflectHandle` #5923

jakobhellermann · 2022-09-09T12:52:38Z

Objective

^ enable this

Concretely, I need to

list all handle ids for an asset type
fetch the asset as dyn Reflect, given a HandleUntyped
when encountering a Handle<T>, find out what asset type that handle refers to (T's type id) and turn the handle into a HandleUntyped

Solution

add ReflectAsset type containing function pointers for working with assets

pub struct ReflectAsset {
    type_uuid: Uuid,
    assets_resource_type_id: TypeId, // TypeId of the `Assets<T>` resource

    get: fn(&World, HandleUntyped) -> Option<&dyn Reflect>,
    get_mut: fn(&mut World, HandleUntyped) -> Option<&mut dyn Reflect>,
    get_unchecked_mut: unsafe fn(&World, HandleUntyped) -> Option<&mut dyn Reflect>,
    add: fn(&mut World, &dyn Reflect) -> HandleUntyped,
    set: fn(&mut World, HandleUntyped, &dyn Reflect) -> HandleUntyped,
    len: fn(&World) -> usize,
    ids: for<'w> fn(&'w World) -> Box<dyn Iterator<Item = HandleId> + 'w>,
    remove: fn(&mut World, HandleUntyped) -> Option<Box<dyn Reflect>>,
}

add ReflectHandle type relating the handle back to the asset type and providing a way to create a HandleUntyped

pub struct ReflectHandle {
    type_uuid: Uuid,
    asset_type_id: TypeId,
    downcast_handle_untyped: fn(&dyn Any) -> Option<HandleUntyped>,
}

add the corresponding FromType impls
add a function app.register_asset_reflect which is supposed to be called after .add_asset and registers ReflectAsset and ReflectHandle in the type registry

Changelog

add ReflectAsset and ReflectHandle types, which allow code to use reflection to manipulate arbitrary assets without knowing their types at compile time

crates/bevy_asset/src/assets.rs

crates/bevy_asset/src/reflect.rs

crates/bevy_pbr/src/pbr_material.rs

alice-i-cecile · 2022-09-09T13:19:48Z

crates/bevy_pbr/src/pbr_material.rs

@@ -111,6 +112,8 @@ pub struct StandardMaterial {
    pub double_sided: bool,
    /// Whether to cull the "front", "back" or neither side of a mesh
    /// defaults to `Face::Back`
+    // TODO: include this in reflection somehow (maybe via remote types like serde https://serde.rs/remote-derive.html)


Can we use a blanket impl for Option in bevy_reflect? Or do we not own the Face type either :(

Face is the problem, because it is defined in wgpu-types, not in bevy.

We can

add a feature to bevy_reflect to implement Reflect for wgpu-types

add a feature to wgpu-types to implement Reflect (if the maintainers agree that this is worth it)

solve this similar to what serde does, and what @MrGVSV experimented with in https://discordapp.com/channels/691052431525675048/1002362493634629796/1016608961224511538

crates/bevy_render/src/texture/mod.rs

alice-i-cecile · 2022-09-09T13:21:02Z

I'm in favor of this! Just some small comments around ergonomics and docs.

MrGVSV

Looking really good! Just some comments/questions/suggestions.

MrGVSV · 2022-09-14T01:54:40Z

crates/bevy_asset/src/assets.rs

+    /// and adds [`ReflectAsset`] type data to `T` and [`ReflectHandle`] type data to `Handle<T>` in the type registry.
+    ///
+    /// This enables reflection code to access assets. For detailed information, see the docs on [`ReflectAsset`] and [`ReflectHandle`].
+    fn register_asset_reflect<T>(&mut self) -> &mut Self


I wonder if this should also perform the add_asset call internally. Then users only need to write one or the other, not both. In that case, I might also recommend bikeshedding this to add_reflectable_asset or something similar.

Any thoughts on this?

Hm. I think my preference is to have these two methods separately, because then you can search for add_asset globally and easily find all asset registration. Registering reflect also feels like something that is done "additionally", not like a completely different way of adding an asset.

Ah, true. I guess it also means you can quickly comment out the line if you need to test it without the reflection. Save on those keystrokes haha

I think I lean more towards keeping it as is now, but if anyone else has any thoughts, I'd love to hear it!

crates/bevy_asset/src/assets.rs

crates/bevy_asset/src/reflect.rs

crates/bevy_pbr/src/alpha.rs

crates/bevy_pbr/src/pbr_material.rs

crates/bevy_sprite/src/mesh2d/color_material.rs

crates/bevy_sprite/src/texture_atlas.rs

jakobhellermann · 2022-10-06T20:56:40Z

One question I just thought of is if we want to represent owned values in these kinds of APIs as &Reflect with the expectation that we will just call FromReflect on it, or as Box<dyn Reflect> which we assume to be containing exactly the wanted type.
If the later, we probably need ReflectFromReflect for people who want to use FromReflect dynamically (part of #6056).

zicklag · 2022-10-06T21:00:06Z

Big 👍 to this! This is exactly what I was needing for asset management in scripts.

zicklag · 2022-10-06T21:56:36Z

One question I just thought of is if we want to represent owned values in these kinds of APIs as &Reflect with the expectation that we will just call FromReflect on it, or as Box which we assume to be containing exactly the wanted type.

My instinct is that I should have a Box<dyn Reflect> for owned values, and ReflectFromReflect was another thing I ran into the need for earlier.

To work around not having ReflectFromReflect I ended up trying to combine ReflectDefault to create the value and Reflect.apply() to patch the value.

MrGVSV · 2022-10-25T20:44:33Z

@jakobhellermann I think this PR needs to be rebased

…nClip

Co-authored-by: Gino Valente <49806985+MrGVSV@users.noreply.github.com>

… = false

cart

Great work! Definitely in line with the patterns we've already established. A bit unfortunate that we need to revert to reflect_value and reflect(ignore) in some cases, but thats not your fault and the solutions are pretty clear at this point (and we can punt that until later).

cart · 2022-10-28T20:42:15Z

bors r+

# Objective ![image](https://user-images.githubusercontent.com/22177966/189350194-639a0211-e984-4f73-ae62-0ede44891eb9.png) ^ enable this Concretely, I need to - list all handle ids for an asset type - fetch the asset as `dyn Reflect`, given a `HandleUntyped` - when encountering a `Handle<T>`, find out what asset type that handle refers to (`T`'s type id) and turn the handle into a `HandleUntyped` ## Solution - add `ReflectAsset` type containing function pointers for working with assets ```rust pub struct ReflectAsset { type_uuid: Uuid, assets_resource_type_id: TypeId, // TypeId of the `Assets<T>` resource get: fn(&World, HandleUntyped) -> Option<&dyn Reflect>, get_mut: fn(&mut World, HandleUntyped) -> Option<&mut dyn Reflect>, get_unchecked_mut: unsafe fn(&World, HandleUntyped) -> Option<&mut dyn Reflect>, add: fn(&mut World, &dyn Reflect) -> HandleUntyped, set: fn(&mut World, HandleUntyped, &dyn Reflect) -> HandleUntyped, len: fn(&World) -> usize, ids: for<'w> fn(&'w World) -> Box<dyn Iterator<Item = HandleId> + 'w>, remove: fn(&mut World, HandleUntyped) -> Option<Box<dyn Reflect>>, } ``` - add `ReflectHandle` type relating the handle back to the asset type and providing a way to create a `HandleUntyped` ```rust pub struct ReflectHandle { type_uuid: Uuid, asset_type_id: TypeId, downcast_handle_untyped: fn(&dyn Any) -> Option<HandleUntyped>, } ``` - add the corresponding `FromType` impls - add a function `app.register_asset_reflect` which is supposed to be called after `.add_asset` and registers `ReflectAsset` and `ReflectHandle` in the type registry --- ## Changelog - add `ReflectAsset` and `ReflectHandle` types, which allow code to use reflection to manipulate arbitrary assets without knowing their types at compile time

bors · 2022-10-28T21:02:51Z

Pull request successfully merged into main.

Build succeeded:

# Objective ![image](https://user-images.githubusercontent.com/22177966/189350194-639a0211-e984-4f73-ae62-0ede44891eb9.png) ^ enable this Concretely, I need to - list all handle ids for an asset type - fetch the asset as `dyn Reflect`, given a `HandleUntyped` - when encountering a `Handle<T>`, find out what asset type that handle refers to (`T`'s type id) and turn the handle into a `HandleUntyped` ## Solution - add `ReflectAsset` type containing function pointers for working with assets ```rust pub struct ReflectAsset { type_uuid: Uuid, assets_resource_type_id: TypeId, // TypeId of the `Assets<T>` resource get: fn(&World, HandleUntyped) -> Option<&dyn Reflect>, get_mut: fn(&mut World, HandleUntyped) -> Option<&mut dyn Reflect>, get_unchecked_mut: unsafe fn(&World, HandleUntyped) -> Option<&mut dyn Reflect>, add: fn(&mut World, &dyn Reflect) -> HandleUntyped, set: fn(&mut World, HandleUntyped, &dyn Reflect) -> HandleUntyped, len: fn(&World) -> usize, ids: for<'w> fn(&'w World) -> Box<dyn Iterator<Item = HandleId> + 'w>, remove: fn(&mut World, HandleUntyped) -> Option<Box<dyn Reflect>>, } ``` - add `ReflectHandle` type relating the handle back to the asset type and providing a way to create a `HandleUntyped` ```rust pub struct ReflectHandle { type_uuid: Uuid, asset_type_id: TypeId, downcast_handle_untyped: fn(&dyn Any) -> Option<HandleUntyped>, } ``` - add the corresponding `FromType` impls - add a function `app.register_asset_reflect` which is supposed to be called after `.add_asset` and registers `ReflectAsset` and `ReflectHandle` in the type registry --- ## Changelog - add `ReflectAsset` and `ReflectHandle` types, which allow code to use reflection to manipulate arbitrary assets without knowing their types at compile time

jakobhellermann added C-Feature A new feature, making something new possible A-Assets Load files from disk to use for things like images, models, and sounds A-Reflection Runtime information about types labels Sep 9, 2022

alice-i-cecile added this to the Bevy 0.9 milestone Sep 9, 2022