1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67


use std::sync::Arc;

use vulkano::{command_buffer::{AutoCommandBufferBuilder, SubpassContents, pool::standard::StandardCommandPoolBuilder}, framebuffer::FramebufferAbstract, sync::GpuFuture};
use feo_math::{linear_algebra::matrix4::Matrix4, utils::space::Space};
use super::frame_system::FrameSystem;

/// Represents the active process of rendering a frame.
///
/// This struct mutably borrows the `FrameSystem`.
pub struct PassBuilder<'p> {
    pub(crate) system: &'p mut FrameSystem,

    // Future to wait upon before the main rendering.
    pub(crate) before_main_cb_future: Option<Box<dyn GpuFuture>>,
    // Framebuffer that was used when starting the render pass.
    pub(crate) framebuffer: Arc<dyn FramebufferAbstract + Send + Sync>,
    // The command buffer builder that will be built during the lifetime of this object.
    pub(crate) command_buffer_builder: Option<AutoCommandBufferBuilder<StandardCommandPoolBuilder>>,
    // Matrix that converts screen coordinates and depth buffer values to coordinates in camera space
    pub(crate) screen_to_camera: Matrix4<f32>,
    // Matrix that converts ident to camera space
    pub(crate) to_camera_space: Space,
}

impl<'p> PassBuilder<'p>{
    /// Returns an enumeration containing the next pass of the rendering.
    pub fn build/*<'b>*/(&/*'b*/ mut self) -> Box<dyn GpuFuture> {
        // passes
    //     self.draw_pass();
    //     self.lighting_pass();
    //     self.render_pass()
    // }

    // #[inline]
    // fn draw_pass<'b>(&'b mut self) {
        let command_buffer = self.system.draw_pass_manager.draw();
        self.command_buffer_builder.as_mut().unwrap()
            .execute_commands(command_buffer).unwrap();
    // }
    
    // #[inline]
    // fn lighting_pass<'b>(&'b mut self) {
        self.command_buffer_builder.as_mut().unwrap()
            .next_subpass(SubpassContents::SecondaryCommandBuffers).unwrap();
        
        let lighting_pass_manager = self.system.lighting_pass_manager.clone();
        lighting_pass_manager.draw(self);
    // }
    
    // #[inline]
    // fn render_pass<'b>(&'b mut self) -> Box<dyn GpuFuture> {
        self.command_buffer_builder
            .as_mut()
            .unwrap()
            .end_render_pass()
            .unwrap();
        let command_buffer = self.command_buffer_builder.take().unwrap().build().unwrap();
        
        // Extract `before_main_cb_future` and append the command buffer execution to it.
        let after_main_cb = self
            .before_main_cb_future.take().unwrap()
            .then_execute(self.system.gfx_queue.clone(), command_buffer).unwrap();
        // We obtain `after_main_cb`, which we give to the user.
        Box::new(after_main_cb)
    }
}