Stop automatically generating meta files for assets while using asset processing. (#17216)

# Objective

- Today, enabling asset processing can generate many meta files. This
makes it a painful transition for users as they get a "mega commit"
containing tons of meta files.

## Solution

- Stop automatically generating meta files! Users can just leave the
meta files defaulted.
- Add a function `AssetServer::write_default_meta_file_for_path`

## Testing

- Tested this manually on the asset_processing example (by removing the
meta files for the assets that had default meta files).
- I did not add a unit test for the `write_default_meta_file_for_path`
since we don't have an in-memory asset writer. Writing one could be
useful in the future.

---

## Showcase

Asset processing no longer automatically generates meta files! This
makes it much easier to transition to using asset processing since you
don't suddenly get many meta files when turning it on.

You can still manually generate meta files using the new
`AssetServer::write_default_meta_file_for_path` function.

crates/bevy_asset/src/processor/mod.rs

@@ -54,7 +54,7 @@ use crate::{
         AssetMetaDyn, AssetMetaMinimal, ProcessedInfo, ProcessedInfoMinimal,
     },
     AssetLoadError, AssetMetaCheck, AssetPath, AssetServer, AssetServerMode, DeserializeMetaError,
-    MissingAssetLoaderForExtensionError,
+    MissingAssetLoaderForExtensionError, WriteDefaultMetaError,
 };
 use alloc::{borrow::ToOwned, boxed::Box, collections::VecDeque, sync::Arc, vec, vec::Vec};
 use bevy_ecs::prelude::*;
@@ -261,6 +261,58 @@ impl AssetProcessor {
         }
     }
 
+    /// Writes the default meta file for the provided `path`.
+    ///
+    /// This function generates the appropriate meta file to process `path` with the default
+    /// processor. If there is no default processor, it falls back to the default loader.
+    ///
+    /// Note if there is already a meta file for `path`, this function returns
+    /// `Err(WriteDefaultMetaError::MetaAlreadyExists)`.
+    pub async fn write_default_meta_file_for_path(
+        &self,
+        path: impl Into<AssetPath<'_>>,
+    ) -> Result<(), WriteDefaultMetaError> {
+        let path = path.into();
+        let Some(processor) = path
+            .get_full_extension()
+            .and_then(|extension| self.get_default_processor(&extension))
+        else {
+            return self
+                .server
+                .write_default_loader_meta_file_for_path(path)
+                .await;
+        };
+
+        let meta = processor.default_meta();
+        let serialized_meta = meta.serialize();
+
+        let source = self.get_source(path.source())?;
+
+        // Note: we get the reader rather than the processed reader, since we want to write the meta
+        // file for the unprocessed version of that asset (so it will be processed by the default
+        // processor).
+        let reader = source.reader();
+        match reader.read_meta_bytes(path.path()).await {
+            Ok(_) => return Err(WriteDefaultMetaError::MetaAlreadyExists),
+            Err(AssetReaderError::NotFound(_)) => {
+                // The meta file couldn't be found so just fall through.
+            }
+            Err(AssetReaderError::Io(err)) => {
+                return Err(WriteDefaultMetaError::IoErrorFromExistingMetaCheck(err))
+            }
+            Err(AssetReaderError::HttpError(err)) => {
+                return Err(WriteDefaultMetaError::HttpErrorFromExistingMetaCheck(err))
+            }
+        }
+
+        let writer = source.writer()?;
+        writer
+            .write_meta_bytes(path.path(), &serialized_meta)
+            .await?;
+
+        Ok(())
+    }
+
     async fn handle_asset_source_event(&self, source: &AssetSource, event: AssetSourceEvent) {
         trace!("{event:?}");
         match event {
@@ -803,12 +855,6 @@ impl AssetProcessor {
                     }
                 };
                 let meta_bytes = meta.serialize();
-                // write meta to source location if it doesn't already exist
-                source
-                    .writer()?
-                    .write_meta_bytes(path, &meta_bytes)
-                    .await
-                    .map_err(writer_err)?;
                 (meta, meta_bytes, processor)
             }
             Err(err) => {

crates/bevy_asset/src/server/mod.rs

@@ -5,7 +5,8 @@ use crate::{
     folder::LoadedFolder,
     io::{
         AssetReaderError, AssetSource, AssetSourceEvent, AssetSourceId, AssetSources,
-        ErasedAssetReader, MissingAssetSourceError, MissingProcessedAssetReaderError, Reader,
+        AssetWriterError, ErasedAssetReader, MissingAssetSourceError, MissingAssetWriterError,
+        MissingProcessedAssetReaderError, Reader,
     },
     loader::{AssetLoader, ErasedAssetLoader, LoadContext, LoadedAsset},
     meta::{
@@ -1479,6 +1480,50 @@ impl AssetServer {
             }
         }
     }
+
+    /// Writes the default loader meta file for the provided `path`.
+    ///
+    /// This function only generates meta files that simply load the path directly. To generate a
+    /// meta file that will use the default asset processor for the path, see
+    /// [`AssetProcessor::write_default_meta_file_for_path`].
+    ///
+    /// Note if there is already a meta file for `path`, this function returns
+    /// `Err(WriteDefaultMetaError::MetaAlreadyExists)`.
+    ///
+    /// [`AssetProcessor::write_default_meta_file_for_path`]:  crate::AssetProcessor::write_default_meta_file_for_path
+    pub async fn write_default_loader_meta_file_for_path(
+        &self,
+        path: impl Into<AssetPath<'_>>,
+    ) -> Result<(), WriteDefaultMetaError> {
+        let path = path.into();
+        let loader = self.get_path_asset_loader(&path).await?;
+
+        let meta = loader.default_meta();
+        let serialized_meta = meta.serialize();
+
+        let source = self.get_source(path.source())?;
+
+        let reader = source.reader();
+        match reader.read_meta_bytes(path.path()).await {
+            Ok(_) => return Err(WriteDefaultMetaError::MetaAlreadyExists),
+            Err(AssetReaderError::NotFound(_)) => {
+                // The meta file couldn't be found so just fall through.
+            }
+            Err(AssetReaderError::Io(err)) => {
+                return Err(WriteDefaultMetaError::IoErrorFromExistingMetaCheck(err))
+            }
+            Err(AssetReaderError::HttpError(err)) => {
+                return Err(WriteDefaultMetaError::HttpErrorFromExistingMetaCheck(err))
+            }
+        }
+
+        let writer = source.writer()?;
+        writer
+            .write_meta_bytes(path.path(), &serialized_meta)
+            .await?;
+
+        Ok(())
+    }
 }
 
 /// A system that manages internal [`AssetServer`] events, such as finalizing asset loads.
@@ -1886,3 +1931,21 @@ pub enum WaitForAssetError {
     #[error(transparent)]
     DependencyFailed(Arc<AssetLoadError>),
 }
+
+#[derive(Error, Debug)]
+pub enum WriteDefaultMetaError {
+    #[error(transparent)]
+    MissingAssetLoader(#[from] MissingAssetLoaderForExtensionError),
+    #[error(transparent)]
+    MissingAssetSource(#[from] MissingAssetSourceError),
+    #[error(transparent)]
+    MissingAssetWriter(#[from] MissingAssetWriterError),
+    #[error("failed to write default asset meta file: {0}")]
+    FailedToWriteMeta(#[from] AssetWriterError),
+    #[error("asset meta file already exists, so avoiding overwrite")]
+    MetaAlreadyExists,
+    #[error("encountered an I/O error while reading the existing meta file: {0}")]
+    IoErrorFromExistingMetaCheck(Arc<std::io::Error>),
+    #[error("encountered HTTP status {0} when reading the existing meta file")]
+    HttpErrorFromExistingMetaCheck(u16),
+}

examples/asset/processing/assets/d.cool.ron.meta

@@ -1,13 +0,0 @@
-(
-    meta_format_version: "1.0",
-    asset: Process(
-        processor: "bevy_asset::processor::process::LoadTransformAndSave<asset_processing::CoolTextLoader, asset_processing::CoolTextTransformer, asset_processing::CoolTextSaver>",
-        settings: (
-            loader_settings: (),
-            transformer_settings: (
-                appended: "",
-            ),
-            saver_settings: (),
-        ),
-    ),
-)

examples/asset/processing/assets/foo/b.cool.ron.meta

@@ -1,13 +0,0 @@
-(
-    meta_format_version: "1.0",
-    asset: Process(
-        processor: "bevy_asset::processor::process::LoadTransformAndSave<asset_processing::CoolTextLoader, asset_processing::CoolTextTransformer, asset_processing::CoolTextSaver>",
-        settings: (
-            loader_settings: (),
-            transformer_settings: (
-                appended: "",
-            ),
-            saver_settings: (),
-        ),
-    ),
-)

examples/asset/processing/assets/foo/c.cool.ron.meta

@@ -1,13 +0,0 @@
-(
-    meta_format_version: "1.0",
-    asset: Process(
-        processor: "bevy_asset::processor::process::LoadTransformAndSave<asset_processing::CoolTextLoader, asset_processing::CoolTextTransformer, asset_processing::CoolTextSaver>",
-        settings: (
-            loader_settings: (),
-            transformer_settings: (
-                appended: "",
-            ),
-            saver_settings: (),
-        ),
-    ),
-)