start porting "query" systems from SystemBuilder to functions

crates/bevy_legion/legion_core/src/lib.rs

@@ -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},
     };
 }

crates/bevy_legion/legion_systems/src/lib.rs

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

crates/bevy_pbr/src/nodes/lights_node.rs

@@ -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()
     }
 }

crates/bevy_render/src/camera.rs

@@ -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()
 }

crates/bevy_render/src/mesh.rs

@@ -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)]

crates/bevy_wgpu/src/renderer/systems.rs

@@ -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>>()