Use the TypePath trait for registering loaders and processors.

Author: andriyDev

crates/bevy_animation/src/graph.rs

@@ -19,7 +19,7 @@ use bevy_ecs::{
     system::{Res, ResMut},
 };
 use bevy_platform::collections::HashMap;
-use bevy_reflect::{prelude::ReflectDefault, Reflect};
+use bevy_reflect::{prelude::ReflectDefault, Reflect, TypePath};
 use derive_more::derive::From;
 use petgraph::{
     graph::{DiGraph, NodeIndex},
@@ -238,7 +238,7 @@ pub enum AnimationNodeType {
 ///
 /// The canonical extension for [`AnimationGraph`]s is `.animgraph.ron`. Plain
 /// `.animgraph` is supported as well.
-#[derive(Default)]
+#[derive(Default, TypePath)]
 pub struct AnimationGraphAssetLoader;
 
 /// Errors that can occur when serializing animation graphs to RON.

crates/bevy_asset/src/lib.rs

@@ -762,7 +762,7 @@ mod tests {
         sub_texts: Vec<String>,
     }
 
-    #[derive(Default)]
+    #[derive(Default, TypePath)]
     pub struct CoolTextLoader;
 
     #[derive(Error, Debug)]
@@ -1855,6 +1855,7 @@ mod tests {
             .init_asset::<SubText>()
             .register_asset_loader(CoolTextLoader);
 
+        #[derive(TypePath)]
         struct NestedLoadOfSubassetLoader;
 
         impl AssetLoader for NestedLoadOfSubassetLoader {

crates/bevy_asset/src/loader.rs

@@ -14,6 +14,7 @@ use alloc::{
 use atomicow::CowArc;
 use bevy_ecs::{error::BevyError, world::World};
 use bevy_platform::collections::{HashMap, HashSet};
+use bevy_reflect::TypePath;
 use bevy_tasks::{BoxedFuture, ConditionalSendFuture};
 use core::any::{Any, TypeId};
 use downcast_rs::{impl_downcast, Downcast};
@@ -28,7 +29,7 @@ use thiserror::Error;
 /// This trait is generally used in concert with [`AssetReader`](crate::io::AssetReader) to load assets from a byte source.
 ///
 /// For a complementary version of this trait that can save assets, see [`AssetSaver`](crate::saver::AssetSaver).
-pub trait AssetLoader: Send + Sync + 'static {
+pub trait AssetLoader: TypePath + Send + Sync + 'static {
     /// The top level [`Asset`] loaded by this [`AssetLoader`].
     type Asset: Asset;
     /// The settings type used by this [`AssetLoader`].

crates/bevy_asset/src/processor/mod.rs

@@ -40,6 +40,8 @@
 mod log;
 mod process;
 
+#[cfg(feature = "trace")]
+use bevy_reflect::TypePath;
 pub use log::*;
 pub use process::*;
 
@@ -113,9 +115,9 @@ pub struct AssetProcessorData {
 
 #[derive(Default)]
 struct Processors {
-    /// Maps the type name of the processor to its instance.
-    type_name_to_processor: HashMap<&'static str, Arc<dyn ErasedProcessor>>,
-    /// Maps the file extension of an asset to the type name of the processor we should use to
+    /// Maps the type path of the processor to its instance.
+    type_path_to_processor: HashMap<&'static str, Arc<dyn ErasedProcessor>>,
+    /// Maps the file extension of an asset to the type path of the processor we should use to
     /// process it by default.
     file_extension_to_default_processor: HashMap<Box<str>, &'static str>,
 }
@@ -599,8 +601,8 @@ impl AssetProcessor {
         #[cfg(feature = "trace")]
         let processor = InstrumentedAssetProcessor(processor);
         processors
-            .type_name_to_processor
-            .insert(core::any::type_name::<P>(), Arc::new(processor));
+            .type_path_to_processor
+            .insert(P::type_path(), Arc::new(processor));
     }
 
     /// Set the default processor for the given `extension`. Make sure `P` is registered with [`AssetProcessor::register_processor`].
@@ -612,7 +614,7 @@ impl AssetProcessor {
             .unwrap_or_else(PoisonError::into_inner);
         processors
             .file_extension_to_default_processor
-            .insert(extension.into(), core::any::type_name::<P>());
+            .insert(extension.into(), P::type_path());
     }
 
     /// Returns the default processor for the given `extension`, if it exists.
@@ -625,7 +627,7 @@ impl AssetProcessor {
         let key = processors
             .file_extension_to_default_processor
             .get(extension)?;
-        processors.type_name_to_processor.get(key).cloned()
+        processors.type_path_to_processor.get(key).cloned()
     }
 
     /// Returns the processor with the given `processor_type_name`, if it exists.
@@ -636,7 +638,7 @@ impl AssetProcessor {
             .read()
             .unwrap_or_else(PoisonError::into_inner);
         processors
-            .type_name_to_processor
+            .type_path_to_processor
             .get(processor_type_name)
             .cloned()
     }
@@ -1172,6 +1174,7 @@ impl AssetProcessorData {
 }
 
 #[cfg(feature = "trace")]
+#[derive(TypePath)]
 struct InstrumentedAssetProcessor<T>(T);
 
 #[cfg(feature = "trace")]
@@ -1195,7 +1198,7 @@ impl<T: Process> Process for InstrumentedAssetProcessor<T> {
         };
         let span = info_span!(
             "asset processing",
-            processor = core::any::type_name::<T>(),
+            processor = T::type_path(),
             asset = context.path().to_string(),
         );
         self.0.process(context, meta, writer).instrument(span)

crates/bevy_asset/src/processor/process.rs

@@ -15,6 +15,7 @@ use alloc::{
     boxed::Box,
     string::{String, ToString},
 };
+use bevy_reflect::TypePath;
 use bevy_tasks::{BoxedFuture, ConditionalSendFuture};
 use core::marker::PhantomData;
 use serde::{Deserialize, Serialize};
@@ -25,7 +26,7 @@ use thiserror::Error;
 ///
 /// This is a "low level", maximally flexible interface. Most use cases are better served by the [`LoadTransformAndSave`] implementation
 /// of [`Process`].
-pub trait Process: Send + Sync + Sized + 'static {
+pub trait Process: TypePath + Send + Sync + Sized + 'static {
     /// The configuration / settings used to process the asset. This will be stored in the [`AssetMeta`] and is user-configurable per-asset.
     type Settings: Settings + Default + Serialize + for<'a> Deserialize<'a>;
     /// The [`AssetLoader`] that will be used to load the final processed asset.
@@ -59,6 +60,7 @@ pub trait Process: Send + Sync + Sized + 'static {
 /// This uses [`LoadTransformAndSaveSettings`] to configure the processor.
 ///
 /// [`Asset`]: crate::Asset
+#[derive(TypePath)]
 pub struct LoadTransformAndSave<
     L: AssetLoader,
     T: AssetTransformer<AssetInput = L::Asset>,

crates/bevy_asset/src/saver.rs

@@ -5,6 +5,7 @@ use crate::{
 use alloc::boxed::Box;
 use atomicow::CowArc;
 use bevy_platform::collections::HashMap;
+use bevy_reflect::TypePath;
 use bevy_tasks::{BoxedFuture, ConditionalSendFuture};
 use core::{borrow::Borrow, hash::Hash, ops::Deref};
 use serde::{Deserialize, Serialize};
@@ -15,7 +16,7 @@ use serde::{Deserialize, Serialize};
 /// This trait is generally used in concert with [`AssetWriter`](crate::io::AssetWriter) to write assets as bytes.
 ///
 /// For a complementary version of this trait that can load assets, see [`AssetLoader`].
-pub trait AssetSaver: Send + Sync + 'static {
+pub trait AssetSaver: TypePath + Send + Sync + 'static {
     /// The top level [`Asset`] saved by this [`AssetSaver`].
     type Asset: Asset;
     /// The settings type used by this [`AssetSaver`].

crates/bevy_asset/src/server/loaders.rs

@@ -5,6 +5,8 @@ use crate::{
 use alloc::{boxed::Box, sync::Arc, vec::Vec};
 use async_broadcast::RecvError;
 use bevy_platform::collections::HashMap;
+#[cfg(feature = "trace")]
+use bevy_reflect::TypePath;
 use bevy_tasks::IoTaskPool;
 use bevy_utils::TypeIdMap;
 use core::any::TypeId;
@@ -23,8 +25,8 @@ pub(crate) struct AssetLoaders {
     loaders: Vec<MaybeAssetLoader>,
     type_id_to_loaders: TypeIdMap<Vec<usize>>,
     extension_to_loaders: HashMap<Box<str>, Vec<usize>>,
-    type_name_to_loader: HashMap<&'static str, usize>,
-    preregistered_loaders: HashMap<&'static str, usize>,
+    type_path_to_loader: HashMap<&'static str, usize>,
+    type_path_to_preregistered_loader: HashMap<&'static str, usize>,
 }
 
 impl AssetLoaders {
@@ -35,7 +37,7 @@ impl AssetLoaders {
 
     /// Registers a new [`AssetLoader`]. [`AssetLoader`]s must be registered before they can be used.
     pub(crate) fn push<L: AssetLoader>(&mut self, loader: L) {
-        let type_name = core::any::type_name::<L>();
+        let type_path = L::type_path();
         let loader_asset_type = TypeId::of::<L::Asset>();
         let loader_asset_type_name = core::any::type_name::<L::Asset>();
 
@@ -44,7 +46,7 @@ impl AssetLoaders {
         let loader = Arc::new(loader);
 
         let (loader_index, is_new) =
-            if let Some(index) = self.preregistered_loaders.remove(type_name) {
+            if let Some(index) = self.type_path_to_preregistered_loader.remove(type_path) {
                 (index, false)
             } else {
                 (self.loaders.len(), true)
@@ -75,7 +77,7 @@ impl AssetLoaders {
                 Loader must be specified in a .meta file in order to load assets of this type with these extensions.");
             }
 
-            self.type_name_to_loader.insert(type_name, loader_index);
+            self.type_path_to_loader.insert(type_path, loader_index);
 
             self.type_id_to_loaders
                 .entry(loader_asset_type)
@@ -108,12 +110,13 @@ impl AssetLoaders {
     pub(crate) fn reserve<L: AssetLoader>(&mut self, extensions: &[&str]) {
         let loader_asset_type = TypeId::of::<L::Asset>();
         let loader_asset_type_name = core::any::type_name::<L::Asset>();
-        let type_name = core::any::type_name::<L>();
+        let type_path = L::type_path();
 
         let loader_index = self.loaders.len();
 
-        self.preregistered_loaders.insert(type_name, loader_index);
-        self.type_name_to_loader.insert(type_name, loader_index);
+        self.type_path_to_preregistered_loader
+            .insert(type_path, loader_index);
+        self.type_path_to_loader.insert(type_path, loader_index);
 
         let existing_loaders_for_type_id = self.type_id_to_loaders.get(&loader_asset_type);
         let mut duplicate_extensions = Vec::new();
@@ -152,7 +155,7 @@ impl AssetLoaders {
 
     /// Get the [`AssetLoader`] by name
     pub(crate) fn get_by_name(&self, name: &str) -> Option<MaybeAssetLoader> {
-        let index = self.type_name_to_loader.get(name).copied()?;
+        let index = self.type_path_to_loader.get(name).copied()?;
 
         self.get_by_index(index)
     }
@@ -309,6 +312,7 @@ impl MaybeAssetLoader {
 }
 
 #[cfg(feature = "trace")]
+#[derive(TypePath)]
 struct InstrumentedAssetLoader<T>(T);
 
 #[cfg(feature = "trace")]
@@ -361,6 +365,7 @@ mod tests {
     #[derive(Asset, TypePath, Debug)]
     struct C;
 
+    #[derive(TypePath)]
     struct Loader<A: Asset, const N: usize, const E: usize> {
         sender: Sender<()>,
         _phantom: PhantomData<A>,
@@ -430,7 +435,7 @@ mod tests {
 
         let loader = block_on(
             loaders
-                .get_by_name(core::any::type_name::<Loader<A, 1, 0>>())
+                .get_by_name(Loader::<A, 1, 0>::type_path())
                 .unwrap()
                 .get(),
         )

crates/bevy_asset/src/transformer.rs

@@ -2,6 +2,7 @@ use crate::{meta::Settings, Asset, ErasedLoadedAsset, Handle, LabeledAsset, Unty
 use alloc::boxed::Box;
 use atomicow::CowArc;
 use bevy_platform::collections::HashMap;
+use bevy_reflect::TypePath;
 use bevy_tasks::ConditionalSendFuture;
 use core::{
     borrow::Borrow,
@@ -15,7 +16,7 @@ use serde::{Deserialize, Serialize};
 /// Transforms an [`Asset`] of a given [`AssetTransformer::AssetInput`] type to an [`Asset`] of [`AssetTransformer::AssetOutput`] type.
 ///
 /// This trait is commonly used in association with [`LoadTransformAndSave`](crate::processor::LoadTransformAndSave) to accomplish common asset pipeline workflows.
-pub trait AssetTransformer: Send + Sync + 'static {
+pub trait AssetTransformer: TypePath + Send + Sync + 'static {
     /// The [`Asset`] type which this [`AssetTransformer`] takes as and input.
     type AssetInput: Asset;
     /// The [`Asset`] type which this [`AssetTransformer`] outputs.
@@ -249,6 +250,7 @@ impl<'a, A: Asset> TransformedSubAsset<'a, A> {
 }
 
 /// An identity [`AssetTransformer`] which infallibly returns the input [`Asset`] on transformation.]
+#[derive(TypePath)]
 pub struct IdentityAssetTransformer<A: Asset> {
     _phantom: PhantomData<fn(A) -> A>,
 }

crates/bevy_audio/src/audio_source.rs

@@ -34,7 +34,7 @@ impl AsRef<[u8]> for AudioSource {
 /// `.mp3` with `bevy/mp3`
 /// `.flac` with `bevy/flac`
 /// `.wav` with `bevy/wav`
-#[derive(Default)]
+#[derive(Default, TypePath)]
 pub struct AudioLoader;
 
 impl AssetLoader for AudioLoader {

crates/bevy_gltf/src/loader/mod.rs

@@ -2,6 +2,7 @@ mod extensions;
 mod gltf_ext;
 
 use alloc::sync::Arc;
+use bevy_reflect::TypePath;
 use std::{
     io::Error,
     path::{Path, PathBuf},
@@ -136,6 +137,7 @@ pub enum GltfError {
 }
 
 /// Loads glTF files with all of their data as their corresponding bevy representations.
+#[derive(TypePath)]
 pub struct GltfLoader {
     /// List of compressed image formats handled by the loader.
     pub supported_compressed_formats: CompressedImageFormats,