msaa

src/vulkan.rs

@@ -11,7 +11,7 @@ use vulkano::descriptor::DescriptorSet;
 use vulkano::device::{Device, DeviceExtensions, Queue};
 use vulkano::format::{ClearValue, Format};
 use vulkano::framebuffer::{Framebuffer, FramebufferAbstract, RenderPassAbstract, Subpass};
-use vulkano::image::{AttachmentImage, Dimensions, ImageUsage, ImmutableImage, SwapchainImage};
+use vulkano::image::{AttachmentImage, Dimensions, ImageUsage, ImmutableImage, SwapchainImage, ImageViewAccess};
 use vulkano::instance::{ApplicationInfo, Instance, InstanceExtensions, PhysicalDevice, Version};
 use vulkano::instance::debug::{DebugCallback, MessageSeverity, MessageType};
 use vulkano::memory::pool::{PotentialDedicatedAllocation, StdMemoryPoolAlloc};
@@ -32,8 +32,10 @@ use vs::ty::PushConstants;
 
 use crate::gameobject::{GameObject, GameObjectHandle};
 use crate::mesh::CPUMesh;
+use crate::config::RenderConfig;
 
 const VALIDATION_LAYERS: &[&str] = &[
+    "VK_LAYER_KHRONOS_validation"
 ];
 
 #[derive(Default, Debug, Clone)]
@@ -107,10 +109,12 @@ pub struct VulkanRenderer {
     pub debug_callback: Option<DebugCallback>,
     pub previous_frame_end: Option<Box<dyn GpuFuture>>,
     pub uniform_buffers: Vec<Arc<CpuAccessibleBuffer<vs::ty::ObjectUniformData>>>,
+    pub msaa_sample_count: u32,
 }
 
 impl VulkanRenderer {
-    pub fn init(line_vertices: Vec<LinePoint>, enable_validation_layers: bool) -> (VulkanRenderer, EventLoop<()>) {
+    pub fn init(line_vertices: Vec<LinePoint>, enable_validation_layers: bool, render_config: RenderConfig) -> (VulkanRenderer, EventLoop<()>) {
+        // Create empty game data struct to be filled
         let mut data = GameData {
             push_constants: PushConstants {
                 model: Matrix4::identity().into(),
@@ -131,10 +135,7 @@ impl VulkanRenderer {
             use_line_pipeline: true,
         };
 
-        if enable_validation_layers {
-            println!("Enabling validation layers...");
-        }
-
+        // Create basic vulkan instance with layers and info
         let instance = {
             let extensions = InstanceExtensions {
                 ext_debug_utils: true,
@@ -149,11 +150,13 @@ impl VulkanRenderer {
             };
 
             if enable_validation_layers {
+                println!("Enabling validation layers...");
                 let available_layers = vulkano::instance::layers_list().unwrap().map(|layer| String::from(layer.name())).collect::<Vec<String>>();
+                println!("Available layers: {:?}", available_layers);
 
                 VALIDATION_LAYERS.iter().for_each(|wanted_layer_name| {
                     if !available_layers.iter().any(|available_layer_name| available_layer_name == wanted_layer_name) {
-                        panic!("Validation layer not found: {:?}. Available layers: {:?}", wanted_layer_name, &available_layers.join(", "));
+                        panic!("Validation layer not found: {:?}", wanted_layer_name);
                     }
                 });
 
@@ -165,6 +168,8 @@ impl VulkanRenderer {
 
         // lifetime of this is important, even tho it isn't used!
         let mut debug_callback = None;
+
+        // Debug stuff
         if enable_validation_layers {
             let msg_severity = MessageSeverity {
                 verbose: false,
@@ -193,6 +198,7 @@ impl VulkanRenderer {
             }).ok();
         }
 
+        // TODO: Just get the first physical device we find, it's fiiiine...
         let physical = PhysicalDevice::enumerate(&instance).next().unwrap();
         println!("Using device: {} (type: {:?})", physical.name(), physical.ty());
 
@@ -200,17 +206,20 @@ impl VulkanRenderer {
         let surface = WindowBuilder::new().build_vk_surface(&events_loop, instance.clone()).unwrap();
         let window = surface.window();
 
+        // TODO: Tutorial says we need more queues
         // In a real-life application, we would probably use at least a graphics queue and a transfers
         // queue to handle data transfers in parallel. In this example we only use one queue.
         let queue_family = physical.queue_families().find(|&q| {
             q.supports_graphics() && surface.is_supported(q).unwrap_or(false)
         }).unwrap();
 
+        // Queue
         let device_ext = DeviceExtensions { khr_swapchain: true, ..DeviceExtensions::none() };
         let (device, mut queues) = Device::new(physical, physical.supported_features(), &device_ext,
                                                [(queue_family, 0.5)].iter().cloned()).unwrap();
         let queue = queues.next().unwrap();
 
+        // Swapchain
         let (swapchain, images) = {
             let caps = surface.capabilities(physical).unwrap();
             let usage = caps.supported_usage_flags;
@@ -227,27 +236,35 @@ impl VulkanRenderer {
         // what is host_cached
         let line_vertex_buffer = CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::vertex_buffer(), false, data.line_vertices.iter().cloned()).unwrap();
 
+        // Render pass
         let render_pass = Arc::new(vulkano::single_pass_renderpass!(
             device.clone(),
             attachments: {
                 color: {
-                    load: Clear,
+                    load: DontCare,
                     store: Store,
                     format: swapchain.format(),
                     samples: 1,
                 },
-                depth: {
+                intermediary: {
                     load: Clear,
                     store: DontCare,
+                    format: swapchain.format(),
+                    samples: render_config.msaa_samples,
+                },
+                depth: {
+                    load: Clear,
+                    store: Store,
                     format: Format::D16Unorm,
-                    samples: 1,
+                    samples: render_config.msaa_samples,
                     initial_layout: ImageLayout::Undefined,
                     final_layout: ImageLayout::DepthStencilAttachmentOptimal,
                 }
             },
             pass: {
-                color: [color],
-                depth_stencil: {depth}
+                color: [intermediary],
+                depth_stencil: {depth},
+                resolve: [color]
             }
         ).unwrap());
 
@@ -281,9 +298,11 @@ impl VulkanRenderer {
         // Otherwise we would have to recreate the whole pipeline.
         let mut dynamic_state = DynamicState { line_width: None, viewports: None, scissors: None, compare_mask: None, write_mask: None, reference: None };
 
+        let msaa_attachments = Self::create_msaa_buffers(device.clone(), data.dimensions, &swapchain, render_config.msaa_samples);
+
         // The render pass we created above only describes the layout of our framebuffers. Before we
         // can draw we also need to create the actual framebuffers.
-        let framebuffers = window_size_dependent_setup(device.clone(), &images, render_pass.clone(), &mut dynamic_state);
+        let framebuffers = window_size_dependent_setup(device.clone(), &images, &msaa_attachments, render_config.msaa_samples, render_pass.clone(), &mut dynamic_state);
 
         let mut uniform_buffers = Vec::new();
         let uniform_buffer = vs::ty::ObjectUniformData {
@@ -320,14 +339,16 @@ impl VulkanRenderer {
         (VulkanRenderer { game_data: data, device, framebuffers, sampler,
             dynamic_state, pipeline, line_pipeline, uniform_buffers,
             surface, swapchain, render_pass, queue, line_vertex_buffer,
-            recreate_swapchain: false, debug_callback, previous_frame_end }, events_loop)
+            recreate_swapchain: false, debug_callback, previous_frame_end,
+            msaa_sample_count: render_config.msaa_samples
+        }, events_loop)
     }
 
     fn create_command_buffer(self: &mut Self, fb_index: usize, uniform_buffer_data: vs::ty::ObjectUniformData) -> Arc<AutoCommandBuffer> {
         // General setup
         let mut builder = AutoCommandBufferBuilder::primary_simultaneous_use(self.device.clone(), self.queue.family()).unwrap();
         builder.update_buffer(self.uniform_buffers[fb_index].clone(), uniform_buffer_data).unwrap();
-        builder.begin_render_pass(self.framebuffers[fb_index].clone(), false, vec![ClearValue::Float([0.0, 0.0, 0.0, 1.0]), ClearValue::Depth(1.0)]).unwrap();
+        builder.begin_render_pass(self.framebuffers[fb_index].clone(), false, vec![ClearValue::None, ClearValue::Float([0.0, 0.0, 0.0, 1.0]), ClearValue::Depth(1.0)]).unwrap();
 
         // Load and draw meshes etc.
         for i in 0..self.game_data.game_objects.len() {
@@ -354,6 +375,14 @@ impl VulkanRenderer {
         Arc::new(builder.build().unwrap())
     }
 
+    fn create_msaa_buffers(device: Arc<Device>, dimensions: [u32; 2], swapchain: &Arc<Swapchain<Window>>, sample_count: u32) -> Vec<Arc<AttachmentImage>> {
+        let mut msaa_attachments = vec![];
+        for _ in 0..swapchain.num_images() {
+            msaa_attachments.push(AttachmentImage::transient_multisampled(device.clone(), dimensions, sample_count, swapchain.format()).unwrap());
+        }
+        msaa_attachments
+    }
+
     pub fn render_loop(self: &mut Self, new_ubo: vs::ty::ObjectUniformData) {
         // cleanup previous frame
         self.previous_frame_end.as_mut().unwrap().cleanup_finished();
@@ -375,10 +404,12 @@ impl VulkanRenderer {
                 Err(err) => panic!("{:?}", err),
             };
 
+            let msaa_buffers = Self::create_msaa_buffers(self.device.clone(), self.game_data.dimensions, &new_swapchain, self.msaa_sample_count);
+
             self.swapchain = new_swapchain;
             // Because framebuffers contains an Arc on the old swapchain, we need to
             // recreate framebuffers as well.
-            self.framebuffers = window_size_dependent_setup(self.device.clone(), &new_images, self.render_pass.clone(), &mut self.dynamic_state);
+            self.framebuffers = window_size_dependent_setup(self.device.clone(), &new_images, &msaa_buffers, self.msaa_sample_count, self.render_pass.clone(), &mut self.dynamic_state);
 
             self.recreate_swapchain = false;
         }
@@ -507,25 +538,34 @@ pub fn start_event_loop(mut renderer: VulkanRenderer, mut game: Box<dyn Game>, e
 }
 
 /// This method is called once during initialization, then again whenever the window is resized
-fn window_size_dependent_setup(device: Arc<Device>, images: &[Arc<SwapchainImage<Window>>], render_pass: Arc<dyn RenderPassAbstract + Send + Sync>, dynamic_state: &mut DynamicState) -> Vec<Arc<dyn FramebufferAbstract + Send + Sync>> {
+fn window_size_dependent_setup(device: Arc<Device>, images: &[Arc<SwapchainImage<Window>>], msaa_buffers: &[Arc<AttachmentImage>], msaa_sample_count: u32, render_pass: Arc<dyn RenderPassAbstract + Send + Sync>, dynamic_state: &mut DynamicState) -> Vec<Arc<dyn FramebufferAbstract + Send + Sync>> {
     let dimensions = images[0].dimensions();
+    let dim_array = [dimensions.width() as f32, dimensions.height() as f32];
+    let dim_array_u32 = [dimensions.width() as u32, dimensions.height() as u32];
 
     let viewport = Viewport {
         origin: [0.0, 0.0],
-        dimensions: [dimensions[0] as f32, dimensions[1] as f32],
+        dimensions: dim_array,
         depth_range: 0.0 .. 1.0,
     };
     dynamic_state.viewports = Some(vec!(viewport));
 
-    let depth_image = AttachmentImage::with_usage(device.clone(), dimensions, Format::D16Unorm, ImageUsage { depth_stencil_attachment: true, ..ImageUsage::none() }).unwrap();
+    let depth_image = AttachmentImage::multisampled_with_usage(device.clone(), dim_array_u32, msaa_sample_count, Format::D16Unorm, ImageUsage { depth_stencil_attachment: true, ..ImageUsage::none() }).unwrap();
 
-    images.iter().map(|image| {
-        Arc::new(Framebuffer::start(render_pass.clone())
-            .add(image.clone()).unwrap()
+    let mut framebuffers = vec![];
+    for i in 0..images.len() {
+        let image_buffer = &images[i];
+        let msaa_buffer = &msaa_buffers[i];
+
+        framebuffers.push(Arc::new(Framebuffer::start(render_pass.clone())
+            .add(image_buffer.clone()).unwrap()
+            .add(msaa_buffer.clone()).unwrap()
             .add(depth_image.clone()).unwrap()
             .build().unwrap()
-        ) as Arc<dyn FramebufferAbstract + Send + Sync>
-    }).collect::<Vec<_>>()
+        ) as Arc<dyn FramebufferAbstract + Send + Sync>);
+    }
+
+    framebuffers
 }
 
 pub mod vs {