Record overlay phase

src/lib.rs

@@ -230,19 +230,25 @@ impl Renderer {
             });
         }
 
-        let opaque_cmds = Mutex::new(Vec::new());
+        let record_render = |phase| {
-        if let Some(opaque) = phase_passes.get_vec(&Phase::Opaque) {
+            let cmds = Mutex::new(Vec::new());
-            opaque.par_iter().for_each(|pass_index| {
+            if let Some(passes) = phase_passes.get_vec(&phase) {
-                let phase_data = frame_data.make_phase_data(Phase::Opaque, &viewport);
+                passes.par_iter().for_each(|pass_index| {
-                let pass = &self.render_passes[*pass_index];
+                    let phase_data = frame_data.make_phase_data(phase, &viewport);
+                    let pass = &self.render_passes[*pass_index];
 
-                if let Some(cmd) = pass.record_render(phase_data) {
+                    if let Some(cmd) = pass.record_render(phase_data) {
-                    opaque_cmds.lock().unwrap().push(cmd);
+                        cmds.lock().unwrap().push(cmd);
-                }
+                    }
-            })
+                })
-        }
+            }
 
-        let opaque_cmds = opaque_cmds.into_inner().unwrap();
+            cmds.into_inner().unwrap()
+        };
+
+        // TODO: parallelize each phase's record_render
+        let opaque_cmds = record_render(Phase::Opaque);
+        let overlay_cmds = record_render(Phase::Overlay);
 
         {
             let mut rp = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
@@ -264,6 +270,7 @@ impl Renderer {
             });
 
             rp.execute_bundles(opaque_cmds.iter());
+            rp.execute_bundles(overlay_cmds.iter());
         }
 
         self.queue.submit(std::iter::once(encoder.finish()));

src/phase.rs

@@ -9,6 +9,7 @@ pub enum Phase {
     Depth,
     Opaque,
     Transparent,
+    Overlay,
 }
 
 impl Phase {
@@ -16,7 +17,7 @@ impl Phase {
         use Phase::*;
         match self {
             Upload => PhaseKind::Command,
-            Depth | Opaque | Transparent => PhaseKind::Render,
+            Depth | Opaque | Transparent | Overlay => PhaseKind::Render,
         }
     }
 }