Add initial MeshPass

src/lib.rs

@@ -2,6 +2,7 @@
 //! in Rust.
 
 use rayon::prelude::*;
+use std::sync::{Arc, RwLock};
 use strum::IntoEnumIterator;
 
 pub mod pass;
@@ -11,10 +12,34 @@ use pass::*;
 use phase::*;
 
 pub struct Renderer {
+    pub frames_in_flight: usize,
     pub render_passes: Vec<Box<dyn RenderPassBoxTrait>>,
 }
 
+impl Default for Renderer {
+    fn default() -> Self {
+        Self {
+            frames_in_flight: 2,
+            render_passes: Vec::new(),
+        }
+    }
+}
+
 impl Renderer {
+    pub fn add_pass<T: 'static + RenderPass>(&mut self, pass: T) {
+        let pass = Arc::new(RwLock::new(pass));
+        self.add_pass_arc(pass);
+    }
+
+    pub fn add_pass_arc<T: 'static + RenderPass>(&mut self, pass: Arc<RwLock<T>>) {
+        let pass = RenderPassBox::new(pass, self.frames_in_flight);
+        self.add_pass_box(pass);
+    }
+
+    pub fn add_pass_box(&mut self, pass: Box<dyn RenderPassBoxTrait>) {
+        self.render_passes.push(pass);
+    }
+
     pub fn render(&mut self) {
         let frame_index = 0;
 
@@ -65,68 +90,3 @@ pub mod gpu {
     /// - secondary command buffer in Vulkan
     pub struct RenderBundleEncoder;
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[derive(Copy, Clone)]
-    struct DummyPass;
-
-    impl RenderPass for DummyPass {
-        type FrameData = usize;
-
-        fn create_frame_data(&mut self) -> usize {
-            0
-        }
-
-        fn begin_frame(&mut self, data: &mut Self::FrameData, phases: &mut PhaseList) {
-            println!("begin_frame()");
-
-            for phase in PrePhase::iter() {
-                phases.insert_pre(phase);
-            }
-
-            for phase in ViewportPhase::iter() {
-                phases.insert_viewport(phase);
-            }
-        }
-
-        fn render_pre(
-            &self,
-            phase: PrePhase,
-            data: &Self::FrameData,
-            cmds: &mut gpu::RenderBundleEncoder,
-        ) {
-            println!("render_pre(phase: {:?})", phase);
-        }
-
-        fn render_viewport(
-            &self,
-            phase: ViewportPhase,
-            data: &Self::FrameData,
-            viewport: &ViewportData,
-            cmds: &mut gpu::RenderBundleEncoder,
-        ) {
-            println!("render_viewport(phase: {:?})", phase);
-        }
-    }
-
-    #[test]
-    fn dummy_pass() {
-        use std::sync::{Arc, RwLock};
-        let render_passes = (0..10)
-            .map(|_| {
-                let dummy_pass = DummyPass;
-                let dummy_pass = Arc::new(RwLock::new(dummy_pass));
-                RenderPassBox::new(dummy_pass, 1)
-            })
-            .collect();
-        let mut renderer = Renderer { render_passes };
-
-        for n in 0..10 {
-            println!("Frame #{}", n);
-            renderer.render();
-        }
-    }
-}

src/main.rs

@@ -0,0 +1,9 @@
+use cyborg::{pass, Renderer};
+
+fn main() {
+    let mut renderer = Renderer::default();
+    let mesh_pass = pass::mesh::MeshPass::new();
+    renderer.add_pass(mesh_pass);
+
+    renderer.render();
+}

src/pass.rs

@@ -4,6 +4,8 @@ use crate::gpu;
 use crate::phase::*;
 use std::sync::{Arc, RwLock};
 
+pub mod mesh;
+
 /// Viewport data shared by all passes, once the [ViewportPhase] group is
 /// entered.
 pub struct ViewportData;

src/pass/mesh.rs

@@ -0,0 +1,43 @@
+use super::*;
+
+pub struct FrameData {}
+
+pub struct MeshPass {}
+
+impl MeshPass {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl RenderPass for MeshPass {
+    type FrameData = FrameData;
+
+    fn create_frame_data(&mut self) -> FrameData {
+        FrameData {}
+    }
+
+    fn begin_frame(&mut self, data: &mut FrameData, phases: &mut PhaseList) {
+        println!("MeshPass::begin_frame()");
+
+        phases.insert_pre(PrePhase::VertexSkinning);
+
+        phases.insert_viewport(ViewportPhase::Depth);
+        phases.insert_viewport(ViewportPhase::Opaque);
+        phases.insert_viewport(ViewportPhase::Transparent);
+    }
+
+    fn render_pre(&self, phase: PrePhase, data: &FrameData, cmds: &mut gpu::RenderBundleEncoder) {
+        println!("MeshPass::render_pre(phase: {:?})", phase);
+    }
+
+    fn render_viewport(
+        &self,
+        phase: ViewportPhase,
+        data: &FrameData,
+        viewport: &ViewportData,
+        cmds: &mut gpu::RenderBundleEncoder,
+    ) {
+        println!("MeshPass::render_viewport(phase: {:?})", phase);
+    }
+}

src/phase.rs

@@ -35,7 +35,7 @@ pub enum ViewportPhase {
     Transparent,
     Bloom,
     Overlay,
-    Composite
+    Composite,
 }
 
 /// A container of phases of each group.