mirror of
https://github.com/bevyengine/bevy
synced 2024-09-20 06:22:01 +00:00
599e5e4e76
# Objective - As part of the migration process we need to a) see the end effect of the migration on user ergonomics b) check for serious perf regressions c) actually migrate the code - To accomplish this, I'm going to attempt to migrate all of the remaining user-facing usages of `LegacyColor` in one PR, being careful to keep a clean commit history. - Fixes #12056. ## Solution I've chosen to use the polymorphic `Color` type as our standard user-facing API. - [x] Migrate `bevy_gizmos`. - [x] Take `impl Into<Color>` in all `bevy_gizmos` APIs - [x] Migrate sprites - [x] Migrate UI - [x] Migrate `ColorMaterial` - [x] Migrate `MaterialMesh2D` - [x] Migrate fog - [x] Migrate lights - [x] Migrate StandardMaterial - [x] Migrate wireframes - [x] Migrate clear color - [x] Migrate text - [x] Migrate gltf loader - [x] Register color types for reflection - [x] Remove `LegacyColor` - [x] Make sure CI passes Incidental improvements to ease migration: - added `Color::srgba_u8`, `Color::srgba_from_array` and friends - added `set_alpha`, `is_fully_transparent` and `is_fully_opaque` to the `Alpha` trait - add and immediately deprecate (lol) `Color::rgb` and friends in favor of more explicit and consistent `Color::srgb` - standardized on white and black for most example text colors - added vector field traits to `LinearRgba`: ~~`Add`, `Sub`, `AddAssign`, `SubAssign`,~~ `Mul<f32>` and `Div<f32>`. Multiplications and divisions do not scale alpha. `Add` and `Sub` have been cut from this PR. - added `LinearRgba` and `Srgba` `RED/GREEN/BLUE` - added `LinearRgba_to_f32_array` and `LinearRgba::to_u32` ## Migration Guide Bevy's color types have changed! Wherever you used a `bevy::render::Color`, a `bevy::color::Color` is used instead. These are quite similar! Both are enums storing a color in a specific color space (or to be more precise, using a specific color model). However, each of the different color models now has its own type. TODO... - `Color::rgba`, `Color::rgb`, `Color::rbga_u8`, `Color::rgb_u8`, `Color::rgb_from_array` are now `Color::srgba`, `Color::srgb`, `Color::srgba_u8`, `Color::srgb_u8` and `Color::srgb_from_array`. - `Color::set_a` and `Color::a` is now `Color::set_alpha` and `Color::alpha`. These are part of the `Alpha` trait in `bevy_color`. - `Color::is_fully_transparent` is now part of the `Alpha` trait in `bevy_color` - `Color::r`, `Color::set_r`, `Color::with_r` and the equivalents for `g`, `b` `h`, `s` and `l` have been removed due to causing silent relatively expensive conversions. Convert your `Color` into the desired color space, perform your operations there, and then convert it back into a polymorphic `Color` enum. - `Color::hex` is now `Srgba::hex`. Call `.into` or construct a `Color::Srgba` variant manually to convert it. - `WireframeMaterial`, `ExtractedUiNode`, `ExtractedDirectionalLight`, `ExtractedPointLight`, `ExtractedSpotLight` and `ExtractedSprite` now store a `LinearRgba`, rather than a polymorphic `Color` - `Color::rgb_linear` and `Color::rgba_linear` are now `Color::linear_rgb` and `Color::linear_rgba` - The various CSS color constants are no longer stored directly on `Color`. Instead, they're defined in the `Srgba` color space, and accessed via `bevy::color::palettes::css`. Call `.into()` on them to convert them into a `Color` for quick debugging use, and consider using the much prettier `tailwind` palette for prototyping. - The `LIME_GREEN` color has been renamed to `LIMEGREEN` to comply with the standard naming. - Vector field arithmetic operations on `Color` (add, subtract, multiply and divide by a f32) have been removed. Instead, convert your colors into `LinearRgba` space, and perform your operations explicitly there. This is particularly relevant when working with emissive or HDR colors, whose color channel values are routinely outside of the ordinary 0 to 1 range. - `Color::as_linear_rgba_f32` has been removed. Call `LinearRgba::to_f32_array` instead, converting if needed. - `Color::as_linear_rgba_u32` has been removed. Call `LinearRgba::to_u32` instead, converting if needed. - Several other color conversion methods to transform LCH or HSL colors into float arrays or `Vec` types have been removed. Please reimplement these externally or open a PR to re-add them if you found them particularly useful. - Various methods on `Color` such as `rgb` or `hsl` to convert the color into a specific color space have been removed. Convert into `LinearRgba`, then to the color space of your choice. - Various implicitly-converting color value methods on `Color` such as `r`, `g`, `b` or `h` have been removed. Please convert it into the color space of your choice, then check these properties. - `Color` no longer implements `AsBindGroup`. Store a `LinearRgba` internally instead to avoid conversion costs. --------- Co-authored-by: Alice Cecile <alice.i.cecil@gmail.com> Co-authored-by: Afonso Lage <lage.afonso@gmail.com> Co-authored-by: Rob Parrett <robparrett@gmail.com> Co-authored-by: Zachary Harrold <zac@harrold.com.au>
144 lines
5.5 KiB
Rust
144 lines
5.5 KiB
Rust
//! This example shows how to use the ECS and the [`AsyncComputeTaskPool`]
|
|
//! to spawn, poll, and complete tasks across systems and system ticks.
|
|
|
|
use bevy::{
|
|
ecs::system::{CommandQueue, SystemState},
|
|
prelude::*,
|
|
tasks::{block_on, futures_lite::future, AsyncComputeTaskPool, Task},
|
|
};
|
|
use rand::Rng;
|
|
use std::{thread, time::Duration};
|
|
|
|
fn main() {
|
|
App::new()
|
|
.add_plugins(DefaultPlugins)
|
|
.add_systems(Startup, (setup_env, add_assets, spawn_tasks))
|
|
.add_systems(Update, handle_tasks)
|
|
.run();
|
|
}
|
|
|
|
// Number of cubes to spawn across the x, y, and z axis
|
|
const NUM_CUBES: u32 = 6;
|
|
|
|
#[derive(Resource, Deref)]
|
|
struct BoxMeshHandle(Handle<Mesh>);
|
|
|
|
#[derive(Resource, Deref)]
|
|
struct BoxMaterialHandle(Handle<StandardMaterial>);
|
|
|
|
/// Startup system which runs only once and generates our Box Mesh
|
|
/// and Box Material assets, adds them to their respective Asset
|
|
/// Resources, and stores their handles as resources so we can access
|
|
/// them later when we're ready to render our Boxes
|
|
fn add_assets(
|
|
mut commands: Commands,
|
|
mut meshes: ResMut<Assets<Mesh>>,
|
|
mut materials: ResMut<Assets<StandardMaterial>>,
|
|
) {
|
|
let box_mesh_handle = meshes.add(Cuboid::new(0.25, 0.25, 0.25));
|
|
commands.insert_resource(BoxMeshHandle(box_mesh_handle));
|
|
|
|
let box_material_handle = materials.add(Color::srgb(1.0, 0.2, 0.3));
|
|
commands.insert_resource(BoxMaterialHandle(box_material_handle));
|
|
}
|
|
|
|
#[derive(Component)]
|
|
struct ComputeTransform(Task<CommandQueue>);
|
|
|
|
/// This system generates tasks simulating computationally intensive
|
|
/// work that potentially spans multiple frames/ticks. A separate
|
|
/// system, [`handle_tasks`], will poll the spawned tasks on subsequent
|
|
/// frames/ticks, and use the results to spawn cubes
|
|
fn spawn_tasks(mut commands: Commands) {
|
|
let thread_pool = AsyncComputeTaskPool::get();
|
|
for x in 0..NUM_CUBES {
|
|
for y in 0..NUM_CUBES {
|
|
for z in 0..NUM_CUBES {
|
|
// Spawn new task on the AsyncComputeTaskPool; the task will be
|
|
// executed in the background, and the Task future returned by
|
|
// spawn() can be used to poll for the result
|
|
let entity = commands.spawn_empty().id();
|
|
let task = thread_pool.spawn(async move {
|
|
let mut rng = rand::thread_rng();
|
|
|
|
let duration = Duration::from_secs_f32(rng.gen_range(0.05..0.2));
|
|
|
|
// Pretend this is a time-intensive function. :)
|
|
thread::sleep(duration);
|
|
|
|
// Such hard work, all done!
|
|
let transform = Transform::from_xyz(x as f32, y as f32, z as f32);
|
|
let mut command_queue = CommandQueue::default();
|
|
|
|
// we use a raw command queue to pass a FnOne(&mut World) back to be
|
|
// applied in a deferred manner.
|
|
command_queue.push(move |world: &mut World| {
|
|
let (box_mesh_handle, box_material_handle) = {
|
|
let mut system_state = SystemState::<(
|
|
Res<BoxMeshHandle>,
|
|
Res<BoxMaterialHandle>,
|
|
)>::new(world);
|
|
let (box_mesh_handle, box_material_handle) =
|
|
system_state.get_mut(world);
|
|
|
|
(box_mesh_handle.clone(), box_material_handle.clone())
|
|
};
|
|
|
|
world
|
|
.entity_mut(entity)
|
|
// Add our new PbrBundle of components to our tagged entity
|
|
.insert(PbrBundle {
|
|
mesh: box_mesh_handle,
|
|
material: box_material_handle,
|
|
transform,
|
|
..default()
|
|
})
|
|
// Task is complete, so remove task component from entity
|
|
.remove::<ComputeTransform>();
|
|
});
|
|
|
|
command_queue
|
|
});
|
|
|
|
// Spawn new entity and add our new task as a component
|
|
commands.entity(entity).insert(ComputeTransform(task));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// This system queries for entities that have our Task<Transform> component. It polls the
|
|
/// tasks to see if they're complete. If the task is complete it takes the result, adds a
|
|
/// new [`PbrBundle`] of components to the entity using the result from the task's work, and
|
|
/// removes the task component from the entity.
|
|
fn handle_tasks(mut commands: Commands, mut transform_tasks: Query<&mut ComputeTransform>) {
|
|
for mut task in &mut transform_tasks {
|
|
if let Some(mut commands_queue) = block_on(future::poll_once(&mut task.0)) {
|
|
// append the returned command queue to have it execute later
|
|
commands.append(&mut commands_queue);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// This system is only used to setup light and camera for the environment
|
|
fn setup_env(mut commands: Commands) {
|
|
// Used to center camera on spawned cubes
|
|
let offset = if NUM_CUBES % 2 == 0 {
|
|
(NUM_CUBES / 2) as f32 - 0.5
|
|
} else {
|
|
(NUM_CUBES / 2) as f32
|
|
};
|
|
|
|
// lights
|
|
commands.spawn(PointLightBundle {
|
|
transform: Transform::from_xyz(4.0, 12.0, 15.0),
|
|
..default()
|
|
});
|
|
|
|
// camera
|
|
commands.spawn(Camera3dBundle {
|
|
transform: Transform::from_xyz(offset, offset, 15.0)
|
|
.looking_at(Vec3::new(offset, offset, 0.0), Vec3::Y),
|
|
..default()
|
|
});
|
|
}
|