antialiasing

yay

less fuzz

or more fuzz

depending on what you think of as fuzz

Force-Push: yes
Change-Id: I207c040805d97baaa8be887a463a37863159056e

1 files changed, 31 insertions, 16 deletions

diff --git a/src/graphics_permanent.rs b/src/graphics_permanent.rs
index c19bacd..5282e21 100644
--- a/src/graphics_permanent.rs
+++ b/src/graphics_permanent.rs
@@ -123,9 +123,8 @@ impl PermanentGraphicsState {
       vulkanalia::window::create_surface(&instance, &window, &window)
     }?;
 
-    let (physical_device, device,
-         indices, graphics_queue, presentation_queue,
-         enable_anisotropy, enable_swapchain)
+    let (physical_device, device, indices, sample_count, graphics_queue,
+         presentation_queue, enable_anisotropy, enable_swapchain)
         = init_vulkan_device(&instance, &surface,
                              enable_validation, enable_portability)?;
 
@@ -135,7 +134,7 @@ impl PermanentGraphicsState {
       window, entry, instance, debug_messager, surface, device,
       graphics_queue, presentation_queue
     }, GraphicsStateForReinit {
-      physical_device, indices, descriptor_set_layout,
+      physical_device, indices, sample_count, descriptor_set_layout,
     }, enable_anisotropy, enable_swapchain))
   }
 
@@ -218,6 +217,7 @@ impl PermanentGraphicsState {
 pub struct GraphicsStateForReinit {
   pub physical_device: vk::PhysicalDevice,
   pub indices: QueueFamilyIndices,
+  pub sample_count: vk::SampleCountFlags,
   pub descriptor_set_layout: vk::DescriptorSetLayout,
 }
 
@@ -416,10 +416,12 @@ fn init_vulkan(window: &Window)
 fn init_vulkan_device(instance: &Instance, surface: &vk::SurfaceKHR,
                       enable_validation: EnableValidation,
                       enable_portability: EnablePortability)
-    -> Result<(vk::PhysicalDevice, Device, QueueFamilyIndices, vk::Queue,
-               vk::Queue, EnableAnisotropy, EnableSwapchain)>
+    -> Result<(vk::PhysicalDevice, Device, QueueFamilyIndices,
+               vk::SampleCountFlags, vk::Queue, vk::Queue, EnableAnisotropy,
+               EnableSwapchain)>
 {
-  let (physical_device, indices) = pick_vulkan_device(instance, surface)?;
+  let (physical_device, indices, sample_count)
+          = pick_vulkan_device(instance, surface)?;
 
   //   We enumerate the device extensions here so they can inform
   // configuration. We already did this in score_vulkan_device(), but here
@@ -539,9 +541,8 @@ fn init_vulkan_device(instance: &Instance, surface: &vk::SurfaceKHR,
     device.get_device_queue(indices.presentation, 0)
   };
 
-  Ok((physical_device, device,
-      indices, graphics_queue, presentation_queue,
-      enable_anisotropy, enable_swapchain))
+  Ok((physical_device, device, indices, sample_count, graphics_queue,
+      presentation_queue, enable_anisotropy, enable_swapchain))
 }
 
 
@@ -580,26 +581,29 @@ fn init_descriptor_set_layout(device: &Device)
 // device to connect it to.
 #[allow(unsafe_code)]
 fn pick_vulkan_device(instance: &Instance, surface: &vk::SurfaceKHR)
-    -> Result<(vk::PhysicalDevice, QueueFamilyIndices)>
+    -> Result<(vk::PhysicalDevice, QueueFamilyIndices, vk::SampleCountFlags)>
 {
   let mut best_device = None;
   let mut best_score = None;
   let mut best_indices = None;
+  let mut best_sample_count = None;
   let mut rejected = BTreeMap::new();
 
   for device in unsafe { instance.enumerate_physical_devices() }? {
     match score_vulkan_device(instance, surface, &device)? {
-      Acceptable::Accepted((new_score, new_indices)) => {
+      Acceptable::Accepted((new_score, new_indices, new_sample_count)) => {
         if let Some(old_score) = best_score {
           if new_score > old_score {
             best_device = Some(device);
             best_score = Some(new_score);
             best_indices = Some(new_indices);
+            best_sample_count = Some(new_sample_count);
           }
         } else {
           best_device = Some(device);
           best_score = Some(new_score);
           best_indices = Some(new_indices);
+          best_sample_count = Some(new_sample_count);
         }
       }
       Acceptable::Rejected(reason) => {
@@ -614,8 +618,10 @@ fn pick_vulkan_device(instance: &Instance, surface: &vk::SurfaceKHR)
     }
   }
 
-  if let (Some(device), Some(indices)) = (best_device, best_indices) {
-    Ok((device, indices))
+  if let (Some(device), Some(indices), Some(sample_count))
+             = (best_device, best_indices, best_sample_count)
+  {
+    Ok((device, indices, sample_count))
   } else if rejected.is_empty() {
     Err(Error {
       message: "The system has no GPUs of any kind.".to_string()
@@ -647,7 +653,7 @@ fn pick_vulkan_device(instance: &Instance, surface: &vk::SurfaceKHR)
 #[allow(unsafe_code)]
 fn score_vulkan_device(instance: &Instance, surface: &vk::SurfaceKHR,
                        physical_device: &vk::PhysicalDevice)
-    -> Result<Acceptable<(u64, QueueFamilyIndices)>>
+    -> Result<Acceptable<(u64, QueueFamilyIndices, vk::SampleCountFlags)>>
 {
   //   Not all devices support graphics, and not all devices support
   // presenting to any given surface. We check whether this one is suitable
@@ -726,7 +732,16 @@ fn score_vulkan_device(instance: &Instance, surface: &vk::SurfaceKHR,
     score += 1;
   }
 
-  Ok(Acceptable::Accepted((score, indices)))
+  let sample_count = properties.limits.framebuffer_color_sample_counts
+                     & properties.limits.framebuffer_depth_sample_counts;
+  //   Happily, these bit flags are arranged in the obvious way, which lets us
+  // do some math on them. The max sample count is 64, so the max score bonus
+  // we give is 4.
+  let shift = sample_count.bits().ilog2() as u64;
+  score += shift;
+  let sample_count = vk::SampleCountFlags::from_bits(1 << shift).unwrap();
+
+  Ok(Acceptable::Accepted((score, indices, sample_count)))
 }