mirror of
https://github.com/bevyengine/bevy
synced 2024-09-20 22:42:08 +00:00
7b2cf98896
# Objective - Currently, the `Extract` `RenderStage` is executed on the main world, with the render world available as a resource. - However, when needing access to resources in the render world (e.g. to mutate them), the only way to do so was to get exclusive access to the whole `RenderWorld` resource. - This meant that effectively only one extract which wrote to resources could run at a time. - We didn't previously make `Extract`ing writing to the world a non-happy path, even though we want to discourage that. ## Solution - Move the extract stage to run on the render world. - Add the main world as a `MainWorld` resource. - Add an `Extract` `SystemParam` as a convenience to access a (read only) `SystemParam` in the main world during `Extract`. ## Future work It should be possible to avoid needing to use `get_or_spawn` for the render commands, since now the `Commands`' `Entities` matches up with the world being executed on. We need to determine how this interacts with https://github.com/bevyengine/bevy/pull/3519 It's theoretically possible to remove the need for the `value` method on `Extract`. However, that requires slightly changing the `SystemParam` interface, which would make it more complicated. That would probably mess up the `SystemState` api too. ## Todo I still need to add doc comments to `Extract`. --- ## Changelog ### Changed - The `Extract` `RenderStage` now runs on the render world (instead of the main world as before). You must use the `Extract` `SystemParam` to access the main world during the extract phase. Resources on the render world can now be accessed using `ResMut` during extract. ### Removed - `Commands::spawn_and_forget`. Use `Commands::get_or_spawn(e).insert_bundle(bundle)` instead ## Migration Guide The `Extract` `RenderStage` now runs on the render world (instead of the main world as before). You must use the `Extract` `SystemParam` to access the main world during the extract phase. `Extract` takes a single type parameter, which is any system parameter (such as `Res`, `Query` etc.). It will extract this from the main world, and returns the result of this extraction when `value` is called on it. For example, if previously your extract system looked like: ```rust fn extract_clouds(mut commands: Commands, clouds: Query<Entity, With<Cloud>>) { for cloud in clouds.iter() { commands.get_or_spawn(cloud).insert(Cloud); } } ``` the new version would be: ```rust fn extract_clouds(mut commands: Commands, mut clouds: Extract<Query<Entity, With<Cloud>>>) { for cloud in clouds.value().iter() { commands.get_or_spawn(cloud).insert(Cloud); } } ``` The diff is: ```diff --- a/src/clouds.rs +++ b/src/clouds.rs @@ -1,5 +1,5 @@ -fn extract_clouds(mut commands: Commands, clouds: Query<Entity, With<Cloud>>) { - for cloud in clouds.iter() { +fn extract_clouds(mut commands: Commands, mut clouds: Extract<Query<Entity, With<Cloud>>>) { + for cloud in clouds.value().iter() { commands.get_or_spawn(cloud).insert(Cloud); } } ``` You can now also access resources from the render world using the normal system parameters during `Extract`: ```rust fn extract_assets(mut render_assets: ResMut<MyAssets>, source_assets: Extract<Res<MyAssets>>) { *render_assets = source_assets.clone(); } ``` Please note that all existing extract systems need to be updated to match this new style; even if they currently compile they will not run as expected. A warning will be emitted on a best-effort basis if this is not met. Co-authored-by: Carter Anderson <mcanders1@gmail.com>
188 lines
6.1 KiB
Rust
188 lines
6.1 KiB
Rust
//! Simple benchmark to test rendering many point lights.
|
|
//! Run with `WGPU_SETTINGS_PRIO=webgl2` to restrict to uniform buffers and max 256 lights.
|
|
|
|
use bevy::{
|
|
diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
|
|
math::{DVec2, DVec3},
|
|
pbr::{ExtractedPointLight, GlobalLightMeta},
|
|
prelude::*,
|
|
render::{camera::ScalingMode, Extract, RenderApp, RenderStage},
|
|
window::PresentMode,
|
|
};
|
|
use rand::{thread_rng, Rng};
|
|
|
|
fn main() {
|
|
App::new()
|
|
.insert_resource(WindowDescriptor {
|
|
width: 1024.0,
|
|
height: 768.0,
|
|
title: "many_lights".to_string(),
|
|
present_mode: PresentMode::Immediate,
|
|
..default()
|
|
})
|
|
.add_plugins(DefaultPlugins)
|
|
.add_plugin(FrameTimeDiagnosticsPlugin::default())
|
|
.add_plugin(LogDiagnosticsPlugin::default())
|
|
.add_startup_system(setup)
|
|
.add_system(move_camera)
|
|
.add_system(print_light_count)
|
|
.add_plugin(LogVisibleLights)
|
|
.run();
|
|
}
|
|
|
|
fn setup(
|
|
mut commands: Commands,
|
|
mut meshes: ResMut<Assets<Mesh>>,
|
|
mut materials: ResMut<Assets<StandardMaterial>>,
|
|
) {
|
|
const LIGHT_RADIUS: f32 = 0.3;
|
|
const LIGHT_INTENSITY: f32 = 5.0;
|
|
const RADIUS: f32 = 50.0;
|
|
const N_LIGHTS: usize = 100_000;
|
|
|
|
commands.spawn_bundle(PbrBundle {
|
|
mesh: meshes.add(Mesh::from(shape::Icosphere {
|
|
radius: RADIUS,
|
|
subdivisions: 9,
|
|
})),
|
|
material: materials.add(StandardMaterial::from(Color::WHITE)),
|
|
transform: Transform::from_scale(Vec3::NEG_ONE),
|
|
..default()
|
|
});
|
|
|
|
let mesh = meshes.add(Mesh::from(shape::Cube { size: 1.0 }));
|
|
let material = materials.add(StandardMaterial {
|
|
base_color: Color::PINK,
|
|
..default()
|
|
});
|
|
|
|
// NOTE: This pattern is good for testing performance of culling as it provides roughly
|
|
// the same number of visible meshes regardless of the viewing angle.
|
|
// NOTE: f64 is used to avoid precision issues that produce visual artifacts in the distribution
|
|
let golden_ratio = 0.5f64 * (1.0f64 + 5.0f64.sqrt());
|
|
let mut rng = thread_rng();
|
|
for i in 0..N_LIGHTS {
|
|
let spherical_polar_theta_phi = fibonacci_spiral_on_sphere(golden_ratio, i, N_LIGHTS);
|
|
let unit_sphere_p = spherical_polar_to_cartesian(spherical_polar_theta_phi);
|
|
commands.spawn_bundle(PointLightBundle {
|
|
point_light: PointLight {
|
|
range: LIGHT_RADIUS,
|
|
intensity: LIGHT_INTENSITY,
|
|
color: Color::hsl(rng.gen_range(0.0..360.0), 1.0, 0.5),
|
|
..default()
|
|
},
|
|
transform: Transform::from_translation((RADIUS as f64 * unit_sphere_p).as_vec3()),
|
|
..default()
|
|
});
|
|
}
|
|
|
|
// camera
|
|
match std::env::args().nth(1).as_deref() {
|
|
Some("orthographic") => commands.spawn_bundle(Camera3dBundle {
|
|
projection: OrthographicProjection {
|
|
scale: 20.0,
|
|
scaling_mode: ScalingMode::FixedHorizontal(1.0),
|
|
..default()
|
|
}
|
|
.into(),
|
|
..default()
|
|
}),
|
|
_ => commands.spawn_bundle(Camera3dBundle::default()),
|
|
};
|
|
|
|
// add one cube, the only one with strong handles
|
|
// also serves as a reference point during rotation
|
|
commands.spawn_bundle(PbrBundle {
|
|
mesh,
|
|
material,
|
|
transform: Transform {
|
|
translation: Vec3::new(0.0, RADIUS as f32, 0.0),
|
|
scale: Vec3::splat(5.0),
|
|
..default()
|
|
},
|
|
..default()
|
|
});
|
|
}
|
|
|
|
// NOTE: This epsilon value is apparently optimal for optimizing for the average
|
|
// nearest-neighbor distance. See:
|
|
// http://extremelearning.com.au/how-to-evenly-distribute-points-on-a-sphere-more-effectively-than-the-canonical-fibonacci-lattice/
|
|
// for details.
|
|
const EPSILON: f64 = 0.36;
|
|
fn fibonacci_spiral_on_sphere(golden_ratio: f64, i: usize, n: usize) -> DVec2 {
|
|
DVec2::new(
|
|
2.0 * std::f64::consts::PI * (i as f64 / golden_ratio),
|
|
(1.0 - 2.0 * (i as f64 + EPSILON) / (n as f64 - 1.0 + 2.0 * EPSILON)).acos(),
|
|
)
|
|
}
|
|
|
|
fn spherical_polar_to_cartesian(p: DVec2) -> DVec3 {
|
|
let (sin_theta, cos_theta) = p.x.sin_cos();
|
|
let (sin_phi, cos_phi) = p.y.sin_cos();
|
|
DVec3::new(cos_theta * sin_phi, sin_theta * sin_phi, cos_phi)
|
|
}
|
|
|
|
// System for rotating the camera
|
|
fn move_camera(time: Res<Time>, mut camera_query: Query<&mut Transform, With<Camera>>) {
|
|
let mut camera_transform = camera_query.single_mut();
|
|
let delta = time.delta_seconds() * 0.15;
|
|
camera_transform.rotate_z(delta);
|
|
camera_transform.rotate_x(delta);
|
|
}
|
|
|
|
// System for printing the number of meshes on every tick of the timer
|
|
fn print_light_count(time: Res<Time>, mut timer: Local<PrintingTimer>, lights: Query<&PointLight>) {
|
|
timer.0.tick(time.delta());
|
|
|
|
if timer.0.just_finished() {
|
|
info!("Lights: {}", lights.iter().len(),);
|
|
}
|
|
}
|
|
|
|
struct LogVisibleLights;
|
|
|
|
impl Plugin for LogVisibleLights {
|
|
fn build(&self, app: &mut App) {
|
|
let render_app = match app.get_sub_app_mut(RenderApp) {
|
|
Ok(render_app) => render_app,
|
|
Err(_) => return,
|
|
};
|
|
|
|
render_app
|
|
.add_system_to_stage(RenderStage::Extract, extract_time)
|
|
.add_system_to_stage(RenderStage::Prepare, print_visible_light_count);
|
|
}
|
|
}
|
|
|
|
// System for printing the number of meshes on every tick of the timer
|
|
fn print_visible_light_count(
|
|
time: Res<ExtractedTime>,
|
|
mut timer: Local<PrintingTimer>,
|
|
visible: Query<&ExtractedPointLight>,
|
|
global_light_meta: Res<GlobalLightMeta>,
|
|
) {
|
|
timer.0.tick(time.delta());
|
|
|
|
if timer.0.just_finished() {
|
|
info!(
|
|
"Visible Lights: {}, Rendered Lights: {}",
|
|
visible.iter().len(),
|
|
global_light_meta.entity_to_index.len()
|
|
);
|
|
}
|
|
}
|
|
|
|
#[derive(Deref, DerefMut)]
|
|
pub struct ExtractedTime(Time);
|
|
|
|
fn extract_time(mut commands: Commands, time: Extract<Res<Time>>) {
|
|
commands.insert_resource(ExtractedTime(time.clone()));
|
|
}
|
|
|
|
struct PrintingTimer(Timer);
|
|
|
|
impl Default for PrintingTimer {
|
|
fn default() -> Self {
|
|
Self(Timer::from_seconds(1.0, true))
|
|
}
|
|
}
|