mirror of
https://github.com/bevyengine/bevy.git
synced 2026-05-06 06:06:42 -04:00
andriyDev
61127f6d01
# Objective
- In 0.18, we had 10 different functions that load assets (I'm not even
counting `load_folder`).
- In 0.19, we've even added `load_erased` - but it unfortunately doesn't
support all the features that the other variants support.
- We apparently needed `load_acquire_with_settings_override` which 1)
loads the asset, 2) uses the settings provided, 3) allows reading
unapproved asset paths, and 4) drops a guard once the load completes.
- That's fine if that's necessary. But we needed to create an explicit
variant for that.
- We need fewer load paths!
## Solution
- Create a builder.
- Store all these options dynamically instead of statically handling
each case.
- Have the caller choose a particular "kind" of load when they are
ready: `load`, `load_erased`, `load_untyped`, or `load_untyped_async`.
- I intentionally didn't provide a `load_async` or `load_erased_async`,
since those can be replicated using `load`/`load_erased` +
`AssetServer::wait_for_asset_id` to get the exact same effect.
I am also intentionally leaving `NestedLoader` untouched in this PR, but
a followup will duplicate this API for `NestedLoader`, which should make
it easier to understand.
Unlike the `NestedLoader` API, we aren't doing any type-state craziness,
so the docs are much more clear: users don't need to understand how
type-state stuff works, they just call the handful of methods on the
type. The "cost" here is we now need to be careful about including the
cross product of loads between static asset type, runtime asset type, or
dynamic asset type, crossed with deferred or async. In theory, if we
added more kinds on either side, we would need to expand this cross
product a lot. In practice though, it seems unlikely there will be any
more variants there. (maybe there could be a blocking variant? I don't
think this is a popular opinion though).
A big con here is some somewhat common calls are now more verbose.
Specifically, `asset_server.load_with_settings()` has become
`asset_server.load_builder().with_settings().load()`. I am not really
concerned about this though, since it really isn't that painful.
## Testing
- Tests all pass!
---
## Showcase
Now instead of:
```rust
asset_server.load_acquire_with_settings_override("some_path", |settings: &mut GltfLoaderSettings| { ... }, my_lock_guard);
```
You can instead do:
```rust
asset_server.load_builder()
.with_guard(my_lock_guard)
.with_settings(|settings: &mut GltfLoaderSettings| { ... })
.override_unapproved()
.load("some_path");
```
We also now cover more variants! For example, you can now load an asset
untyped with a guard, or with override_unapproved, etc.
---------
Co-authored-by: Alice Cecile <alice.i.cecile@gmail.com>
103 lines
3.1 KiB
Rust
103 lines
3.1 KiB
Rust
//! This example illustrates how to create a texture for use with a
|
|
//! `texture_2d_array<f32>` shader uniform variable and then how to sample from
|
|
//! that texture in the shader by using a `MeshTag` component on the mesh
|
|
//! entity.
|
|
|
|
use bevy::{
|
|
image::{ImageArrayLayout, ImageLoaderSettings},
|
|
mesh::MeshTag,
|
|
prelude::*,
|
|
reflect::TypePath,
|
|
render::render_resource::AsBindGroup,
|
|
shader::ShaderRef,
|
|
};
|
|
|
|
/// This example uses a shader source file from the assets subdirectory.
|
|
const SHADER_ASSET_PATH: &str = "shaders/array_texture.wgsl";
|
|
|
|
/// Corresponds to the number of layers in the array texture.
|
|
const TEXTURE_COUNT: u32 = 4;
|
|
|
|
fn main() {
|
|
App::new()
|
|
.add_plugins((
|
|
DefaultPlugins,
|
|
MaterialPlugin::<ArrayTextureMaterial>::default(),
|
|
))
|
|
.add_systems(Startup, setup)
|
|
.add_systems(Update, update_mesh_tags)
|
|
.run();
|
|
}
|
|
|
|
fn setup(
|
|
mut commands: Commands,
|
|
mut meshes: ResMut<Assets<Mesh>>,
|
|
mut materials: ResMut<Assets<ArrayTextureMaterial>>,
|
|
asset_server: Res<AssetServer>,
|
|
) {
|
|
// Load the texture.
|
|
let array_texture = asset_server
|
|
.load_builder()
|
|
.with_settings(|settings: &mut ImageLoaderSettings| {
|
|
settings.array_layout = Some(ImageArrayLayout::RowCount {
|
|
rows: TEXTURE_COUNT,
|
|
});
|
|
})
|
|
.load("textures/array_texture.png");
|
|
|
|
// light
|
|
commands.spawn((
|
|
DirectionalLight::default(),
|
|
Transform::from_xyz(3.0, 2.0, 1.0).looking_at(Vec3::ZERO, Vec3::Y),
|
|
));
|
|
|
|
// camera
|
|
commands.spawn((
|
|
Camera3d::default(),
|
|
Transform::from_xyz(5.0, 5.0, 5.0).looking_at(Vec3::new(1.5, 0.0, 0.0), Vec3::Y),
|
|
));
|
|
|
|
// Spawn some cubes using the array texture.
|
|
let mesh_handle = meshes.add(Cuboid::default());
|
|
let material_handle = materials.add(ArrayTextureMaterial { array_texture });
|
|
for x in -5..=5 {
|
|
commands.spawn((
|
|
Mesh3d(mesh_handle.clone()),
|
|
MeshMaterial3d(material_handle.clone()),
|
|
// Pass a different mesh tag to allow selecting different layers of
|
|
// the array texture in the shader.
|
|
MeshTag(x as u32 % TEXTURE_COUNT),
|
|
Transform::from_xyz(x as f32 + 0.5, 0.0, 0.0),
|
|
));
|
|
}
|
|
}
|
|
|
|
fn update_mesh_tags(time: Res<Time>, mut query: Query<&mut MeshTag>, mut timer: Local<Timer>) {
|
|
// Initialize the timer on the first run.
|
|
if timer.duration().is_zero() {
|
|
*timer = Timer::from_seconds(1.5, TimerMode::Repeating);
|
|
}
|
|
|
|
timer.tick(time.delta());
|
|
if timer.just_finished() {
|
|
for mut tag in query.iter_mut() {
|
|
// Cycle through the texture layers to demonstrate that we can
|
|
// select different layers of the array texture at runtime.
|
|
tag.0 = (tag.0 + 1) % TEXTURE_COUNT;
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Asset, TypePath, AsBindGroup, Debug, Clone)]
|
|
struct ArrayTextureMaterial {
|
|
#[texture(0, dimension = "2d_array")]
|
|
#[sampler(1)]
|
|
array_texture: Handle<Image>,
|
|
}
|
|
|
|
impl Material for ArrayTextureMaterial {
|
|
fn fragment_shader() -> ShaderRef {
|
|
SHADER_ASSET_PATH.into()
|
|
}
|
|
}
|