Fix #11111 by making asset settings part of AssetPath

crates/bevy_asset/src/assets.rs

@@ -387,10 +387,7 @@ impl<A: Asset> Assets<A> {
     pub fn add(&mut self, asset: impl Into<A>) -> Handle<A> {
         let index = self.dense_storage.allocator.reserve();
         self.insert_with_index(index, asset.into()).unwrap();
-        Handle::Strong(
-            self.handle_provider
-                .get_handle(index.into(), false, None, None),
-        )
+        Handle::Strong(self.handle_provider.get_handle(index.into(), false, None))
     }
 
     /// Upgrade an `AssetId` into a strong `Handle` that will prevent asset drop.
@@ -408,7 +405,7 @@ impl<A: Asset> Assets<A> {
             AssetId::Uuid { uuid } => uuid.into(),
         };
         Some(Handle::Strong(
-            self.handle_provider.get_handle(index, false, None, None),
+            self.handle_provider.get_handle(index, false, None),
         ))
     }
 

crates/bevy_asset/src/direct_access_ext.rs

@@ -14,10 +14,10 @@ pub trait DirectAssetAccessExt {
     fn load_asset<'a, A: Asset>(&self, path: impl Into<AssetPath<'a>>) -> Handle<A>;
 
     /// Load an asset with settings, similarly to [`AssetServer::load_with_settings`].
-    fn load_asset_with_settings<'a, A: Asset, S: Settings>(
+    fn load_asset_with_settings<'a, A: Asset, S: Settings + serde::Serialize + Default>(
         &self,
         path: impl Into<AssetPath<'a>>,
-        settings: impl Fn(&mut S) + Send + Sync + 'static,
+        settings: impl FnOnce(&mut S) + Send + Sync + 'static,
     ) -> Handle<A>;
 }
 impl DirectAssetAccessExt for World {
@@ -40,10 +40,10 @@ impl DirectAssetAccessExt for World {
     ///
     /// # Panics
     /// If `self` doesn't have an [`AssetServer`] resource initialized yet.
-    fn load_asset_with_settings<'a, A: Asset, S: Settings>(
+    fn load_asset_with_settings<'a, A: Asset, S: Settings + serde::Serialize + Default>(
         &self,
         path: impl Into<AssetPath<'a>>,
-        settings: impl Fn(&mut S) + Send + Sync + 'static,
+        settings: impl FnOnce(&mut S) + Send + Sync + 'static,
     ) -> Handle<A> {
         self.resource::<AssetServer>()
             .load_with_settings(path, settings)

crates/bevy_asset/src/handle.rs

@@ -1,7 +1,4 @@
-use crate::{
-    meta::MetaTransform, Asset, AssetId, AssetIndexAllocator, AssetPath, InternalAssetId,
-    UntypedAssetId,
-};
+use crate::{Asset, AssetId, AssetIndexAllocator, AssetPath, InternalAssetId, UntypedAssetId};
 use alloc::sync::Arc;
 use bevy_reflect::{std_traits::ReflectDefault, Reflect, TypePath};
 use core::{
@@ -44,20 +41,18 @@ impl AssetHandleProvider {
     /// [`UntypedHandle`] will match the [`Asset`] [`TypeId`] assigned to this [`AssetHandleProvider`].
     pub fn reserve_handle(&self) -> UntypedHandle {
         let index = self.allocator.reserve();
-        UntypedHandle::Strong(self.get_handle(InternalAssetId::Index(index), false, None, None))
+        UntypedHandle::Strong(self.get_handle(InternalAssetId::Index(index), false, None))
     }
 
     pub(crate) fn get_handle(
         &self,
         id: InternalAssetId,
         asset_server_managed: bool,
         path: Option<AssetPath<'static>>,
-        meta_transform: Option<MetaTransform>,
     ) -> Arc<StrongHandle> {
         Arc::new(StrongHandle {
             id: id.untyped(self.type_id),
             drop_sender: self.drop_sender.clone(),
-            meta_transform,
             path,
             asset_server_managed,
         })
@@ -67,15 +62,9 @@ impl AssetHandleProvider {
         &self,
         asset_server_managed: bool,
         path: Option<AssetPath<'static>>,
-        meta_transform: Option<MetaTransform>,
     ) -> Arc<StrongHandle> {
         let index = self.allocator.reserve();
-        self.get_handle(
-            InternalAssetId::Index(index),
-            asset_server_managed,
-            path,
-            meta_transform,
-        )
+        self.get_handle(InternalAssetId::Index(index), asset_server_managed, path)
     }
 }
 
@@ -86,10 +75,6 @@ pub struct StrongHandle {
     pub(crate) id: UntypedAssetId,
     pub(crate) asset_server_managed: bool,
     pub(crate) path: Option<AssetPath<'static>>,
-    /// Modifies asset meta. This is stored on the handle because it is:
-    /// 1. configuration tied to the lifetime of a specific asset load
-    /// 2. configuration that must be repeatable when the asset is hot-reloaded
-    pub(crate) meta_transform: Option<MetaTransform>,
     pub(crate) drop_sender: Sender<DropEvent>,
 }
 
@@ -381,16 +366,6 @@ impl UntypedHandle {
     pub fn try_typed<A: Asset>(self) -> Result<Handle<A>, UntypedAssetConversionError> {
         Handle::try_from(self)
     }
-
-    /// The "meta transform" for the strong handle. This will only be [`Some`] if the handle is strong and there is a meta transform
-    /// associated with it.
-    #[inline]
-    pub fn meta_transform(&self) -> Option<&MetaTransform> {
-        match self {
-            UntypedHandle::Strong(handle) => handle.meta_transform.as_ref(),
-            UntypedHandle::Weak(_) => None,
-        }
-    }
 }
 
 impl PartialEq for UntypedHandle {

crates/bevy_asset/src/loader.rs

@@ -32,7 +32,7 @@ pub trait AssetLoader: Send + Sync + 'static {
     /// The top level [`Asset`] loaded by this [`AssetLoader`].
     type Asset: Asset;
     /// The settings type used by this [`AssetLoader`].
-    type Settings: Settings + Default + Serialize + for<'a> Deserialize<'a>;
+    type Settings: Settings + Default + Serialize + for<'a> Deserialize<'a> + Clone;
     /// The type of [error](`std::error::Error`) which could be encountered by this loader.
     type Error: Into<Box<dyn core::error::Error + Send + Sync + 'static>>;
     /// Asynchronously loads [`AssetLoader::Asset`] (and any other labeled assets) from the bytes provided by [`Reader`].
@@ -432,9 +432,7 @@ impl<'a> LoadContext<'a> {
         let label = label.into();
         let loaded_asset: ErasedLoadedAsset = loaded_asset.into();
         let labeled_path = self.asset_path.clone().with_label(label.clone());
-        let handle = self
-            .asset_server
-            .get_or_create_path_handle(labeled_path, None);
+        let handle = self.asset_server.get_or_create_path_handle(labeled_path);
         self.labeled_assets.insert(
             label,
             LabeledAsset {
@@ -518,7 +516,7 @@ impl<'a> LoadContext<'a> {
         label: impl Into<CowArc<'b, str>>,
     ) -> Handle<A> {
         let path = self.asset_path.clone().with_label(label);
-        let handle = self.asset_server.get_or_create_path_handle::<A>(path, None);
+        let handle = self.asset_server.get_or_create_path_handle::<A>(path);
         self.dependencies.insert(handle.id().untyped());
         handle
     }

crates/bevy_asset/src/loader_builders.rs

@@ -2,10 +2,8 @@
 //! [`LoadContext::loader`].
 
 use crate::{
-    io::Reader,
-    meta::{meta_transform_settings, AssetMetaDyn, MetaTransform, Settings},
-    Asset, AssetLoadError, AssetPath, ErasedAssetLoader, ErasedLoadedAsset, Handle, LoadContext,
-    LoadDirectError, LoadedAsset, LoadedUntypedAsset, UntypedHandle,
+    io::Reader, Asset, AssetLoadError, AssetPath, ErasedAssetLoader, ErasedLoadedAsset, Handle,
+    LoadContext, LoadDirectError, LoadedAsset, LoadedUntypedAsset, UntypedHandle,
 };
 use alloc::{borrow::ToOwned, boxed::Box, sync::Arc};
 use core::any::TypeId;
@@ -117,7 +115,6 @@ impl ReaderRef<'_> {
 /// [`LoadTransformAndSave`]: crate::processor::LoadTransformAndSave
 pub struct NestedLoader<'ctx, 'builder, T, M> {
     load_context: &'builder mut LoadContext<'ctx>,
-    meta_transform: Option<MetaTransform>,
     typing: T,
     mode: M,
 }
@@ -168,41 +165,13 @@ impl<'ctx, 'builder> NestedLoader<'ctx, 'builder, StaticTyped, Deferred> {
     pub(crate) fn new(load_context: &'builder mut LoadContext<'ctx>) -> Self {
         NestedLoader {
             load_context,
-            meta_transform: None,
             typing: StaticTyped(()),
             mode: Deferred(()),
         }
     }
 }
 
 impl<'ctx, 'builder, T: sealed::Typing, M: sealed::Mode> NestedLoader<'ctx, 'builder, T, M> {
-    fn with_transform(
-        mut self,
-        transform: impl Fn(&mut dyn AssetMetaDyn) + Send + Sync + 'static,
-    ) -> Self {
-        if let Some(prev_transform) = self.meta_transform {
-            self.meta_transform = Some(Box::new(move |meta| {
-                prev_transform(meta);
-                transform(meta);
-            }));
-        } else {
-            self.meta_transform = Some(Box::new(transform));
-        }
-        self
-    }
-
-    /// Configure the settings used to load the asset.
-    ///
-    /// If the settings type `S` does not match the settings expected by `A`'s asset loader, an error will be printed to the log
-    /// and the asset load will fail.
-    #[must_use]
-    pub fn with_settings<S: Settings>(
-        self,
-        settings: impl Fn(&mut S) + Send + Sync + 'static,
-    ) -> Self {
-        self.with_transform(move |meta| meta_transform_settings(meta, &settings))
-    }
-
     // convert between `T`s
 
     /// When [`load`]ing, you must pass in the asset type as a type parameter
@@ -218,7 +187,6 @@ impl<'ctx, 'builder, T: sealed::Typing, M: sealed::Mode> NestedLoader<'ctx, 'bui
     pub fn with_static_type(self) -> NestedLoader<'ctx, 'builder, StaticTyped, M> {
         NestedLoader {
             load_context: self.load_context,
-            meta_transform: self.meta_transform,
             typing: StaticTyped(()),
             mode: self.mode,
         }
@@ -235,7 +203,6 @@ impl<'ctx, 'builder, T: sealed::Typing, M: sealed::Mode> NestedLoader<'ctx, 'bui
     ) -> NestedLoader<'ctx, 'builder, DynamicTyped, M> {
         NestedLoader {
             load_context: self.load_context,
-            meta_transform: self.meta_transform,
             typing: DynamicTyped { asset_type_id },
             mode: self.mode,
         }
@@ -249,7 +216,6 @@ impl<'ctx, 'builder, T: sealed::Typing, M: sealed::Mode> NestedLoader<'ctx, 'bui
     pub fn with_unknown_type(self) -> NestedLoader<'ctx, 'builder, UnknownTyped, M> {
         NestedLoader {
             load_context: self.load_context,
-            meta_transform: self.meta_transform,
             typing: UnknownTyped(()),
             mode: self.mode,
         }
@@ -264,7 +230,6 @@ impl<'ctx, 'builder, T: sealed::Typing, M: sealed::Mode> NestedLoader<'ctx, 'bui
     pub fn deferred(self) -> NestedLoader<'ctx, 'builder, T, Deferred> {
         NestedLoader {
             load_context: self.load_context,
-            meta_transform: self.meta_transform,
             typing: self.typing,
             mode: Deferred(()),
         }
@@ -281,7 +246,6 @@ impl<'ctx, 'builder, T: sealed::Typing, M: sealed::Mode> NestedLoader<'ctx, 'bui
     pub fn immediate<'c>(self) -> NestedLoader<'ctx, 'builder, T, Immediate<'builder, 'c>> {
         NestedLoader {
             load_context: self.load_context,
-            meta_transform: self.meta_transform,
             typing: self.typing,
             mode: Immediate { reader: None },
         }
@@ -305,16 +269,13 @@ impl NestedLoader<'_, '_, StaticTyped, Deferred> {
     pub fn load<'c, A: Asset>(self, path: impl Into<AssetPath<'c>>) -> Handle<A> {
         let path = path.into().to_owned();
         let handle = if self.load_context.should_load_dependencies {
-            self.load_context.asset_server.load_with_meta_transform(
-                path,
-                self.meta_transform,
-                (),
-                true,
-            )
+            self.load_context
+                .asset_server
+                .load_with_meta_transform(path, (), true)
         } else {
             self.load_context
                 .asset_server
-                .get_or_create_path_handle(path, None)
+                .get_or_create_path_handle(path)
         };
         self.load_context.dependencies.insert(handle.id().untyped());
         handle
@@ -334,20 +295,11 @@ impl NestedLoader<'_, '_, DynamicTyped, Deferred> {
         let handle = if self.load_context.should_load_dependencies {
             self.load_context
                 .asset_server
-                .load_erased_with_meta_transform(
-                    path,
-                    self.typing.asset_type_id,
-                    self.meta_transform,
-                    (),
-                )
+                .load_erased_with_meta_transform(path, self.typing.asset_type_id, ())
         } else {
             self.load_context
                 .asset_server
-                .get_or_create_path_handle_erased(
-                    path,
-                    self.typing.asset_type_id,
-                    self.meta_transform,
-                )
+                .get_or_create_path_handle_erased(path, self.typing.asset_type_id)
         };
         self.load_context.dependencies.insert(handle.id());
         handle
@@ -364,11 +316,11 @@ impl NestedLoader<'_, '_, UnknownTyped, Deferred> {
         let handle = if self.load_context.should_load_dependencies {
             self.load_context
                 .asset_server
-                .load_unknown_type_with_meta_transform(path, self.meta_transform)
+                .load_unknown_type_with_meta_transform(path)
         } else {
             self.load_context
                 .asset_server
-                .get_or_create_path_handle(path, self.meta_transform)
+                .get_or_create_path_handle(path)
         };
         self.load_context.dependencies.insert(handle.id().untyped());
         handle
@@ -428,8 +380,8 @@ impl<'builder, 'reader, T> NestedLoader<'_, '_, T, Immediate<'builder, 'reader>>
             (meta, loader, ReaderRef::Boxed(reader))
         };
 
-        if let Some(meta_transform) = self.meta_transform {
-            meta_transform(&mut *meta);
+        if let Some(settings) = path.settings() {
+            meta.apply_settings(settings.value());
         }
 
         let asset = self