mirror of
https://github.com/bevyengine/bevy
synced 2024-11-26 22:50:19 +00:00
c9e1fcdb35
# Objective This adds events for assets that fail to load along with minor utility methods to make them useful. This paves the way for users writing their own error handling and retry systems, plus Bevy including robust retry handling: #11349. * Addresses #11288 * Needed for #11349 # Solution ```rust /// An event emitted when a specific [`Asset`] fails to load. #[derive(Event, Clone, Debug)] pub struct AssetLoadFailedEvent<A: Asset> { pub id: AssetId<A>, /// The original handle returned when the asset load was requested. pub handle: Option<Handle<A>>, /// The asset path that was attempted. pub path: AssetPath<'static>, /// Why the asset failed to load. pub error: AssetLoadError, } ``` I started implementing `AssetEvent::Failed` like suggested in #11288, but decided it was better as its own type because: * I think it makes sense for `AssetEvent` to only refer to assets that actually exist. * In order to return `AssetLoadError` in the event (which is useful information for error handlers that might attempt a retry) we would have to remove `Copy` from `AssetEvent`. * There are numerous places in the render app that match against `AssetEvent`, and I don't think it's worth introducing extra noise about assets that don't exist. I also introduced `UntypedAssetLoadErrorEvent`, which is very useful in places that need to support type flexibility, like an Asset-agnostic retry plugin. # Changelog * **Added:** `AssetLoadFailedEvent<A>` * **Added**: `UntypedAssetLoadFailedEvent` * **Added:** `AssetReaderError::Http` for status code information on HTTP errors. Before this, status codes were only available by parsing the error message of generic `Io` errors. * **Added:** `asset_server.get_path_id(path)`. This method simply gets the asset id for the path. Without this, one was left using `get_path_handle(path)`, which has the overhead of returning a strong handle. * **Fixed**: Made `AssetServer` loads return the same handle for assets that already exist in a failed state. Now, when you attempt a `load` that's in a `LoadState::Failed` state, it'll re-use the original asset id. The advantage of this is that any dependent assets created using the original handle will "unbreak" if a retry succeeds. --------- Co-authored-by: Alice Cecile <alice.i.cecile@gmail.com> |
||
|---|---|---|
| .. | ||
| macros | ||
| src | ||
| Cargo.toml | ||