move the texture binding to a push descriptor

with a descriptor update template, even

yay

this also moves us to a minimum Vulkan version of 1.4, which we understand to be widely deployed. in theory, push descriptors and update templates were available via extensions in earlier versions, but it doesn't seem worth doing the work to switch out whether we use the extensions based on the version, so we don't.

Force-Push: yes
Change-Id: I26db8771abf5626d9614630c66e019ea99babcac

1 files changed, 30 insertions, 38 deletions

diff --git a/src/graphics/frame.rs b/src/graphics/frame.rs
index d8d4bcd..82e5c1c 100644
--- a/src/graphics/frame.rs
+++ b/src/graphics/frame.rs
@@ -1,6 +1,6 @@
 #![deny(unsafe_code)]
 use crate::error::*;
-use crate::graphics::{ Permanent, ForReinit, WindowDressing, Texture };
+use crate::graphics::{ Permanent, ForReinit, WindowDressing };
 use crate::graphics::util::allocate_buffer;
 use crate::shader_data::UniformBlock;
 
@@ -27,6 +27,10 @@ pub struct Frame {
   pub uniform_buffer: vk::Buffer,
   pub uniform_buffer_memory: vk::DeviceMemory,
 
+  //   Notice that our descriptor logic is split between the descriptor sets,
+  // which are per-frame and defined here, and the descriptor update template
+  // for the push descriptors, which is shared by all frames and is kept in
+  // Render.
   pub descriptor_set: vk::DescriptorSet,
 }
 
@@ -39,14 +43,16 @@ impl Frame {
   // an indidivual Frame.
   #[allow(unsafe_code)]
   pub fn new(permanent: &Permanent, for_reinit: &ForReinit,
-             window_dressing: &WindowDressing, texture: &Texture,
-             render_pass: &vk::RenderPass)
+             window_dressing: &WindowDressing, render_pass: &vk::RenderPass)
       -> Result<Vec<Self>>
   {
     let mut frames = Vec::new();
 
+    //   The amount of interesting work done in the top level methods is a bit
+    // more for Frame than it is for our various other state objects, so we
+    // consolidate the implementation details in reinit().
     Frame::reinit(&mut frames, permanent, for_reinit, window_dressing,
-                  texture, render_pass)?;
+                  render_pass)?;
 
     Ok(frames)
   }
@@ -55,7 +61,7 @@ impl Frame {
   #[allow(unsafe_code)]
   pub fn reinit(frames: &mut Vec<Self>, permanent: &Permanent,
                 for_reinit: &ForReinit, window_dressing: &WindowDressing,
-                texture: &Texture, render_pass: &vk::RenderPass)
+                render_pass: &vk::RenderPass)
       -> Result<()>
   {
     Frame::destroy_replaceable(frames, permanent);
@@ -63,7 +69,8 @@ impl Frame {
     let instance = &permanent.instance;
     let device = &permanent.device;
     let primary_command_pool = &permanent.primary_command_pool;
-    let descriptor_set_layout = &for_reinit.descriptor_set_layout;
+    let primary_descriptor_set_layout
+            = &for_reinit.primary_descriptor_set_layout;
     let swapchain = &window_dressing.swapchain;
     let color_image_view = &window_dressing.color_image_view;
     let depth_image_view = &window_dressing.depth_image_view;
@@ -79,7 +86,7 @@ impl Frame {
                                                    primary_command_pool)?;
 
     let descriptor_sets = allocate_descriptor_sets(
-            count, device, descriptor_set_layout, descriptor_pool)?;
+            count, device, primary_descriptor_set_layout, descriptor_pool)?;
 
     for (index, color_resolve_image_view)
         in swapchain.image_views.iter().enumerate()
@@ -95,7 +102,7 @@ impl Frame {
               = init_uniform_buffer(instance, device)?;
 
       configure_descriptor_set(&mut descriptor_set, device, &uniform_buffer,
-                               &texture.image_view, sampler)?;
+                               sampler)?;
 
       frames.push(Frame {
         framebuffer, command_buffer, uniform_buffer, uniform_buffer_memory,
@@ -189,6 +196,20 @@ fn allocate_command_buffers(count: usize, device: &Device,
 }
 
 
+fn init_uniform_buffer(instance: &Instance, device: &Device)
+    -> Result<(vk::Buffer, vk::DeviceMemory)>
+{
+  let (buffer, memory) = allocate_buffer(
+          instance, device,
+          size_of::<UniformBlock<f32>>() as vk::DeviceSize,
+          vk::BufferUsageFlags::UNIFORM_BUFFER,
+          vk::MemoryPropertyFlags::HOST_COHERENT
+          | vk::MemoryPropertyFlags::HOST_VISIBLE)?;
+
+  Ok((buffer, memory))
+}
+
+
 #[allow(unsafe_code)]
 fn allocate_descriptor_sets(count: usize, device: &Device,
                             descriptor_set_layout: &vk::DescriptorSetLayout,
@@ -211,7 +232,6 @@ fn allocate_descriptor_sets(count: usize, device: &Device,
 fn configure_descriptor_set(descriptor_set: &mut vk::DescriptorSet,
                             device: &Device,
                             uniform_buffer: &vk::Buffer,
-                            texture_image_view: &vk::ImageView,
                             sampler: &vk::Sampler)
     -> Result<()>
 {
@@ -238,20 +258,7 @@ fn configure_descriptor_set(descriptor_set: &mut vk::DescriptorSet,
           .descriptor_type(vk::DescriptorType::SAMPLER)
           .image_info(&sampler_image_info_list);
 
-  let texture_image_info = vk::DescriptorImageInfo::builder()
-          .image_layout(vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL)
-          .image_view(*texture_image_view);
-  let texture_image_info_list = [texture_image_info];
-  let texture_write_info = vk::WriteDescriptorSet::builder()
-          .dst_set(*descriptor_set)
-          .dst_binding(2)
-          .dst_array_element(0)
-          .descriptor_type(vk::DescriptorType::SAMPLED_IMAGE)
-          .image_info(&texture_image_info_list);
-
-  let write_info_list = [
-          uniform_block_write_info, sampler_write_info, texture_write_info
-  ];
+  let write_info_list = [ uniform_block_write_info, sampler_write_info ];
   let copy_info_list: [vk::CopyDescriptorSet; 0] = [];
 
   unsafe {
@@ -261,18 +268,3 @@ fn configure_descriptor_set(descriptor_set: &mut vk::DescriptorSet,
   Ok(())
 }
 
-
-fn init_uniform_buffer(instance: &Instance, device: &Device)
-    -> Result<(vk::Buffer, vk::DeviceMemory)>
-{
-  let (buffer, memory) = allocate_buffer(
-          instance, device,
-          size_of::<UniformBlock<f32>>() as vk::DeviceSize,
-          vk::BufferUsageFlags::UNIFORM_BUFFER,
-          vk::MemoryPropertyFlags::HOST_COHERENT
-          | vk::MemoryPropertyFlags::HOST_VISIBLE)?;
-
-  Ok((buffer, memory))
-}
-
-