Toggle msaa

src/vulkan/mod.rs

@@ -15,7 +15,7 @@ use vulkano::instance::{ApplicationInfo, Instance, InstanceExtensions, PhysicalD
 use vulkano::instance::debug::{DebugCallback, MessageSeverity, MessageType};
 use vulkano::pipeline::viewport::Viewport;
 use vulkano::sampler::{Filter, MipmapMode, Sampler, SamplerAddressMode};
-use vulkano::swapchain::{AcquireError, ColorSpace, FullscreenExclusive, PresentMode, Surface, SurfaceTransform, Swapchain, SwapchainCreationError};
+use vulkano::swapchain::{AcquireError, FullscreenExclusive, PresentMode, Surface, SurfaceTransform, Swapchain, SwapchainCreationError};
 use vulkano::swapchain;
 use vulkano::sync::{FlushError, GpuFuture};
 use vulkano::sync;
@@ -228,17 +228,18 @@ impl VulkanRenderer {
             let caps = surface.capabilities(physical).unwrap();
             let usage = caps.supported_usage_flags;
             let alpha = caps.supported_composite_alpha.iter().next().unwrap();
-            let format = caps.supported_formats[0].0;
+            let (format, color_space) = caps.supported_formats[2];
             let inner_size = window.inner_size();
             data.dimensions = [inner_size.width, inner_size.height];
 
             Swapchain::new(device.clone(), surface.clone(), caps.min_image_count, format,
                            data.dimensions, 1, usage, &queue, SurfaceTransform::Identity, alpha,
-                           PresentMode::Fifo, FullscreenExclusive::Default, true, ColorSpace::SrgbNonLinear).unwrap()
+                           PresentMode::Fifo, FullscreenExclusive::Default, true, color_space).unwrap()
         };
 
         // Render pass
-        let render_pass = Arc::new(vulkano::single_pass_renderpass!(
+        let render_pass: Arc<dyn RenderPassAbstract + Send + Sync> = if render_config.msaa_samples > 0 {
+            Arc::new(vulkano::single_pass_renderpass!(
                 device.clone(),
                 attachments: {
                     color: {
@@ -267,7 +268,32 @@ impl VulkanRenderer {
                     depth_stencil: {depth},
                     resolve: [color]
                 }
-        ).unwrap());
+            ).unwrap())
+        } else {
+            Arc::new(vulkano::single_pass_renderpass!(
+                device.clone(),
+                attachments: {
+                    color: {
+                        load: Clear,
+                        store: Store,
+                        format: swapchain.format(),
+                        samples: 1,
+                    },
+                    depth: {
+                        load: Clear,
+                        store: Store,
+                        format: Format::D16Unorm,
+                        samples: 1,
+                        initial_layout: ImageLayout::Undefined,
+                        final_layout: ImageLayout::DepthStencilAttachmentOptimal,
+                    }
+                },
+                pass: {
+                    color: [color],
+                    depth_stencil: {depth}
+                }
+            ).unwrap())
+        };
 
         let sampler = Sampler::new(device.clone(), Filter::Linear, Filter::Linear,
                                    MipmapMode::Nearest, SamplerAddressMode::Repeat, SamplerAddressMode::Repeat,
@@ -284,11 +310,15 @@ 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);
+        let msaa_attachments = if render_config.msaa_samples > 0 {
+            Some(Self::create_msaa_buffers(device.clone(), data.dimensions, &swapchain, render_config.msaa_samples))
+        } else {
+            None
+        };
 
         // 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, &msaa_attachments, render_config.msaa_samples, 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 {
@@ -330,7 +360,11 @@ impl VulkanRenderer {
         // 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();
+        if self.msaa_sample_count > 0 {
             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();
+        } else {
+            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();
+        }
 
         // Draw meshes etc.
         for pipeline in &self.pipelines {
@@ -371,12 +405,16 @@ 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);
+            let msaa_buffers = if self.msaa_sample_count > 0 {
+                Some(Self::create_msaa_buffers(self.device.clone(), self.game_data.dimensions, &new_swapchain, self.msaa_sample_count))
+            } else {
+                None
+            };
 
             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, &msaa_buffers, self.msaa_sample_count, 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;
         }
@@ -549,7 +587,7 @@ 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>>], 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>> {
+fn window_size_dependent_setup(device: Arc<Device>, images: &[Arc<SwapchainImage<Window>>], msaa_buffers: Option<Vec<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];
@@ -561,20 +599,32 @@ fn window_size_dependent_setup(device: Arc<Device>, images: &[Arc<SwapchainImage
     };
     dynamic_state.viewports = Some(vec!(viewport));
 
-    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();
+    let depth_image  = if let Some(msaa_buffers_exist) = &msaa_buffers {
+        AttachmentImage::multisampled_with_usage(device.clone(), dim_array_u32, msaa_sample_count, Format::D16Unorm, ImageUsage { depth_stencil_attachment: true, ..ImageUsage::none() }).unwrap()
+    } else {
+        AttachmentImage::with_usage(device.clone(), dim_array_u32, Format::D16Unorm, ImageUsage { depth_stencil_attachment: true, ..ImageUsage::none() }).unwrap()
+    };
 
     let mut framebuffers = vec![];
+
     for i in 0..images.len() {
         let image_buffer = &images[i];
-        let msaa_buffer = &msaa_buffers[i];
 
+        if let Some(msaa_buffers_exist) = &msaa_buffers {
+            framebuffers.push(Arc::new(Framebuffer::start(render_pass.clone())
+                .add(image_buffer.clone()).unwrap()
+                .add((&msaa_buffers_exist[i]).clone()).unwrap()
+                .add(depth_image.clone()).unwrap()
+                .build().unwrap()
+            ) as Arc<dyn FramebufferAbstract + Send + Sync>);
+        } else {
             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>);
         }
+    }
 
     framebuffers
 }