5876352206
# Objective
The `AssetReader` trait allows customizing the behavior of fetching
bytes for an `AssetPath`, and expects implementors to return `dyn
AsyncRead + AsyncSeek`. This gives implementors of `AssetLoader` great
flexibility to tightly integrate their asset loading behavior with the
asynchronous task system.
However, almost all implementors of `AssetLoader` don't use the async
functionality at all, and just call `AsyncReadExt::read_to_end(&mut
Vec<u8>)`. This is incredibly inefficient, as this method repeatedly
calls `poll_read` on the trait object, filling the vector 32 bytes at a
time. At my work we have assets that are hundreds of megabytes which
makes this a meaningful overhead.
## Solution
Turn the `Reader` type alias into an actual trait, with a provided
method `read_to_end`. This provided method should be more efficient than
the existing extension method, as the compiler will know the underlying
type of `Reader` when generating this function, which removes the
repeated dynamic dispatches and allows the compiler to make further
optimizations after inlining. Individual implementors are able to
override the provided implementation -- for simple asset readers that
just copy bytes from one buffer to another, this allows removing a large
amount of overhead from the provided implementation.
Now that `Reader` is an actual trait, I also improved the ergonomics for
implementing `AssetReader`. Currently, implementors are expected to box
their reader and return it as a trait object, which adds unnecessary
boilerplate to implementations. This PR changes that trait method to
return a pseudo trait alias, which allows implementors to return `impl
Reader` instead of `Box<dyn Reader>`. Now, the boilerplate for boxing
occurs in `ErasedAssetReader`.
## Testing
I made identical changes to my company's fork of bevy. Our app, which
makes heavy use of `read_to_end` for asset loading, still worked
properly after this. I am not aware if we have a more systematic way of
testing asset loading for correctness.
---
## Migration Guide
The trait method `bevy_asset::io::AssetReader::read` (and `read_meta`)
now return an opaque type instead of a boxed trait object. Implementors
of these methods should change the type signatures appropriately
```rust
impl AssetReader for MyReader {
// Before
async fn read<'a>(&'a self, path: &'a Path) -> Result<Box<Reader<'a>>, AssetReaderError> {
let reader = // construct a reader
Box::new(reader) as Box<Reader<'a>>
}
// After
async fn read<'a>(&'a self, path: &'a Path) -> Result<impl Reader + 'a, AssetReaderError> {
// create a reader
}
}
```
`bevy::asset::io::Reader` is now a trait, rather than a type alias for a
trait object. Implementors of `AssetLoader::load` will need to adjust
the method signature accordingly
```rust
impl AssetLoader for MyLoader {
async fn load<'a>(
&'a self,
// Before:
reader: &'a mut bevy::asset::io::Reader,
// After:
reader: &'a mut dyn bevy::asset::io::Reader,
_: &'a Self::Settings,
load_context: &'a mut LoadContext<'_>,
) -> Result<Self::Asset, Self::Error> {
}
```
Additionally, implementors of `AssetReader` that return a type
implementing `futures_io::AsyncRead` and `AsyncSeek` might need to
explicitly implement `bevy::asset::io::Reader` for that type.
```rust
impl bevy::asset::io::Reader for MyAsyncReadAndSeek {}
```
69 lines
2.0 KiB
Rust
69 lines
2.0 KiB
Rust
use crate::ron;
|
|
#[cfg(feature = "serialize")]
|
|
use crate::serde::SceneDeserializer;
|
|
use crate::DynamicScene;
|
|
use bevy_asset::{io::Reader, AssetLoader, LoadContext};
|
|
use bevy_ecs::reflect::AppTypeRegistry;
|
|
use bevy_ecs::world::{FromWorld, World};
|
|
use bevy_reflect::TypeRegistryArc;
|
|
#[cfg(feature = "serialize")]
|
|
use serde::de::DeserializeSeed;
|
|
use thiserror::Error;
|
|
|
|
/// Asset loader for a Bevy dynamic scene (`.scn` / `.scn.ron`).
|
|
///
|
|
/// The loader handles assets serialized with [`DynamicScene::serialize`].
|
|
#[derive(Debug)]
|
|
pub struct SceneLoader {
|
|
type_registry: TypeRegistryArc,
|
|
}
|
|
|
|
impl FromWorld for SceneLoader {
|
|
fn from_world(world: &mut World) -> Self {
|
|
let type_registry = world.resource::<AppTypeRegistry>();
|
|
SceneLoader {
|
|
type_registry: type_registry.0.clone(),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Possible errors that can be produced by [`SceneLoader`]
|
|
#[non_exhaustive]
|
|
#[derive(Debug, Error)]
|
|
pub enum SceneLoaderError {
|
|
/// An [IO Error](std::io::Error)
|
|
#[error("Error while trying to read the scene file: {0}")]
|
|
Io(#[from] std::io::Error),
|
|
/// A [RON Error](ron::error::SpannedError)
|
|
#[error("Could not parse RON: {0}")]
|
|
RonSpannedError(#[from] ron::error::SpannedError),
|
|
}
|
|
|
|
#[cfg(feature = "serialize")]
|
|
impl AssetLoader for SceneLoader {
|
|
type Asset = DynamicScene;
|
|
type Settings = ();
|
|
type Error = SceneLoaderError;
|
|
|
|
async fn load<'a>(
|
|
&'a self,
|
|
reader: &'a mut dyn Reader,
|
|
_settings: &'a (),
|
|
_load_context: &'a mut LoadContext<'_>,
|
|
) -> Result<Self::Asset, Self::Error> {
|
|
let mut bytes = Vec::new();
|
|
reader.read_to_end(&mut bytes).await?;
|
|
let mut deserializer = ron::de::Deserializer::from_bytes(&bytes)?;
|
|
let scene_deserializer = SceneDeserializer {
|
|
type_registry: &self.type_registry.read(),
|
|
};
|
|
Ok(scene_deserializer
|
|
.deserialize(&mut deserializer)
|
|
.map_err(|e| deserializer.span_error(e))?)
|
|
}
|
|
|
|
fn extensions(&self) -> &[&str] {
|
|
&["scn", "scn.ron"]
|
|
}
|
|
}
|