forestia/bevy
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

start porting "query" systems from SystemBuilder to functions

Browse Source
This commit is contained in:
Carter Anderson 2020-05-28 17:32:51 -07:00
parent 83d5275e10
commit 0472cbfc7c
7 changed files with 226 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
crates/bevy_legion/legion_core/src/lib.rs
View File

@ -28,7 +28,7 @@ pub mod prelude {
entity::Entity,
event::Event,
filter::filter_fns::*,
query::{IntoQuery, Query, Read, Tagged, TryRead, TryWrite, Write},
query::{IntoQuery, Query as FilteredQuery, Read, Tagged, TryRead, TryWrite, Write},
world::{Universe, World},
};
}

2
crates/bevy_legion/legion_systems/src/lib.rs
View File

@ -21,5 +21,7 @@ pub mod prelude {
ResMut,
System,
SystemBuilder,
Query,
SubWorld
};
}

21
crates/bevy_pbr/src/nodes/lights_node.rs
View File

@ -54,21 +54,16 @@ impl SystemNode for LightsNode {
let mut tmp_light_buffer = None;
let mut command_queue = self.command_queue.clone();
let max_lights = self.max_lights;
SystemBuilder::new("light_node")
.read_resource::<RenderResources>()
(move |world: &mut SubWorld,
render_resources: Res<RenderResources>,
// TODO: this write on RenderResourceAssignments will prevent this system from running in parallel with other systems that do the same
.write_resource::<RenderResourceAssignments>()
.with_query(<(Read<Light>, Read<LocalToWorld>, Read<Translation>)>::query())
.build(
move |_,
world,
(render_resource_context, ref mut render_resource_assignments),
query| {
mut render_resource_assignments: ResMut<RenderResourceAssignments>,
query: &mut Query<(Read<Light>, Read<LocalToWorld>, Read<Translation>)>| {
if !lights_are_dirty {
return;
}
let render_resources = &render_resource_context.context;
let render_resources = &render_resources.context;
if light_buffer.is_none() {
let light_uniform_size = std::mem::size_of::<LightCount>()
+ max_lights * std::mem::size_of::<LightRaw>();
@ -121,8 +116,7 @@ impl SystemNode for LightsNode {
query.iter(world).zip(data.chunks_exact_mut(size))
{
slot.copy_from_slice(
LightRaw::from(&light, &local_to_world.0, &translation)
.as_bytes(),
LightRaw::from(&light, &local_to_world.0, &translation).as_bytes(),
);
}
},
@ -153,7 +147,6 @@ impl SystemNode for LightsNode {
light_count_size as u64,
total_size as u64,
);
},
)
}).system()
}
}

12
crates/bevy_render/src/camera.rs
View File

@ -1,9 +1,9 @@
use bevy_app::{Events, GetEventReader};
use bevy_window::WindowResized;
use bevy_property::{Properties, Property};
use bevy_window::WindowResized;
use glam::Mat4;
use legion::prelude::*;
use serde::{Serialize, Deserialize};
use serde::{Deserialize, Serialize};
#[derive(Default, Properties)]
pub struct ActiveCamera;
@ -127,10 +127,9 @@ impl Camera {
pub fn camera_update_system(resources: &mut Resources) -> Box<dyn Schedulable> {
let mut window_resized_event_reader = resources.get_event_reader::<WindowResized>();
SystemBuilder::new("camera_update")
.read_resource::<Events<WindowResized>>()
.with_query(<Write<Camera>>::query())
.build(move |_, world, window_resized_events, query| {
(move |world: &mut SubWorld,
window_resized_events: Res<Events<WindowResized>>,
query: &mut Query<Write<Camera>>| {
let primary_window_resized_event = window_resized_event_reader
.find_latest(&window_resized_events, |event| event.is_primary);
if let Some(primary_window_resized_event) = primary_window_resized_event {
@ -142,4 +141,5 @@ pub fn camera_update_system(resources: &mut Resources) -> Box<dyn Schedulable> {
}
}
})
.system()
}

16
crates/bevy_render/src/mesh.rs
View File

@ -341,13 +341,11 @@ pub fn mesh_resource_provider_system(resources: &mut Resources) -> Box<dyn Sched
// TODO: allow pipelines to specialize on vertex_buffer_descriptor and index_format
let vertex_buffer_descriptor = Vertex::get_vertex_buffer_descriptor().unwrap();
vertex_buffer_descriptors.set(vertex_buffer_descriptor.clone());
SystemBuilder::new("mesh_resource_provider")
.read_resource::<RenderResources>()
.read_resource::<Assets<Mesh>>()
.read_resource::<Events<AssetEvent<Mesh>>>()
.with_query(<(Read<Handle<Mesh>>, Write<Renderable>)>::query())
.build(
move |_, world, (render_resources, meshes, mesh_events), query| {
(move |world: &mut SubWorld,
render_resources: Res<RenderResources>,
meshes: Res<Assets<Mesh>>,
mesh_events: Res<Events<AssetEvent<Mesh>>>,
query: &mut Query<(Read<Handle<Mesh>>, Write<Renderable>)>| {
let render_resources = &*render_resources.context;
let mut changed_meshes = HashSet::new();
for event in mesh_event_reader.iter(&mesh_events) {
@ -426,8 +424,8 @@ pub fn mesh_resource_provider_system(resources: &mut Resources) -> Box<dyn Sched
);
}
}
},
)
})
.system()
}
#[cfg(test)]

39
crates/bevy_wgpu/src/renderer/systems.rs
View File

@ -6,6 +6,45 @@ use bevy_render::{
};
use legion::prelude::*;
// TODO: replace with system_fn once configurable "archetype access" is sorted out
// pub fn render_resource_sets_system(
// world: &mut SubWorld,
// pipelines: Res<Assets<PipelineDescriptor>>,
// pipeline_compiler: Res<PipelineCompiler>,
// pipeline_assignments: Res<PipelineAssignments>,
// entity_render_resource_assignments: Res<EntityRenderResourceAssignments>,
// query: &mut Query<Write<Renderable>>, // gives SubWorld write access to Renderable
// ) {
// // PERF: consider doing a par-iter over all renderable components so this can be parallelized
// for compiled_pipeline_handle in pipeline_compiler.iter_all_compiled_pipelines() {
// if let Some(compiled_pipeline_assignments) = pipeline_assignments
// .assignments
// .get(compiled_pipeline_handle)
// {
// let compiled_pipeline = pipelines.get(compiled_pipeline_handle).unwrap();
// let pipeline_layout = compiled_pipeline.get_layout().unwrap();
// for assignment_id in compiled_pipeline_assignments.iter() {
// let entity = entity_render_resource_assignments
// .get(*assignment_id)
// .unwrap();
// let mut renderable = world.get_component_mut::<Renderable>(*entity).unwrap();
// if !renderable.is_visible || renderable.is_instanced {
// continue;
// }
// for bind_group in pipeline_layout.bind_groups.iter() {
// renderable
// .render_resource_assignments
// .update_render_resource_set_id(bind_group);
// }
// }
// }
// }
// }
pub fn render_resource_sets_system() -> Box<dyn Schedulable> {
SystemBuilder::new("update_render_resource_sets")
.read_resource::<Assets<PipelineDescriptor>>()