cyborg/src/lib.rs

//! Cyborg is a high-performance, modern, experimental rendering engine written
//! in Rust.

use rayon::prelude::*;
use std::sync::{Arc, RwLock};
use strum::IntoEnumIterator;

pub mod mesh;
pub mod pass;
pub mod phase;
pub mod staging;

use pass::*;
use phase::*;

pub struct Renderer {
    device: Arc<wgpu::Device>,
    queue: wgpu::Queue,
    frames_in_flight: usize,
    render_passes: Vec<Box<dyn RenderPassBoxTrait>>,
}

impl Renderer {
    pub fn new(device: wgpu::Device, queue: wgpu::Queue) -> Self {
        Self {
            device: Arc::new(device),
            queue,
            frames_in_flight: 2,
            render_passes: Vec::new(),
        }
    }

    pub fn get_device(&self) -> &Arc<wgpu::Device> {
        &self.device
    }

    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;

        let phase_passes = multimap::MultiMap::<Phase, usize>::new();
        let phase_passes = std::sync::Mutex::new(phase_passes);

        self.render_passes
            .par_iter_mut()
            .enumerate()
            .for_each(|(pass_index, rp)| {
                let mut phases_buf = Vec::new();
                phases_buf.clear();
                rp.begin_frame(frame_index, &mut phases_buf);

                let mut passes = phase_passes.lock().unwrap();
                for phase in phases_buf.into_iter() {
                    passes.insert(phase, pass_index);
                }
            });

        let phase_passes = phase_passes.into_inner().unwrap();
        let viewport = ViewportData;

        // Up next is actual rendering to a surface!
    }
}