draw the image

wow yay :)

Force-Push: yes
Change-Id: I7053ec3a7ed7b46e9c9d1260fd0f73b398b798af

1 files changed, 71 insertions, 36 deletions

diff --git a/src/graphics_window_dressing.rs b/src/graphics_window_dressing.rs
index 4dddb35..27390e4 100644
--- a/src/graphics_window_dressing.rs
+++ b/src/graphics_window_dressing.rs
@@ -48,6 +48,7 @@ pub struct WindowDressing {
 
   texture_image: vk::Image,
   texture_image_memory: vk::DeviceMemory,
+  texture_image_view: vk::ImageView,
 
   uniform_buffers: Vec<vk::Buffer>,
   pub uniform_buffer_memory: Vec<vk::DeviceMemory>,
@@ -104,6 +105,7 @@ impl WindowDressing {
     let instance = &permanent.instance;
     let surface = &permanent.surface;
     let device = &permanent.device;
+    let sampler = &permanent.sampler;
     let graphics_queue = &permanent.graphics_queue;
     let physical_device = &for_reinit.physical_device;
     let indices = &for_reinit.indices;
@@ -131,7 +133,7 @@ impl WindowDressing {
             = init_index_buffer(instance, physical_device, device,
                                 graphics_queue, &transient_command_pool)?;
 
-    let (texture_image, texture_image_memory)
+    let (texture_image, texture_image_memory, texture_image_view)
             = init_texture(instance, physical_device, device,
                            graphics_queue, &transient_command_pool)?;
 
@@ -144,7 +146,8 @@ impl WindowDressing {
     let descriptor_sets
             = init_descriptor_sets(device, descriptor_set_layout,
                                    &uniform_buffers, &descriptor_pool,
-                                   swapchain.images.len())?;
+                                   swapchain.images.len(),
+                                   &texture_image_view, sampler)?;
 
     let command_buffers = init_commands(
             device, &swapchain.extent, &framebuffers, &render_pass,
@@ -165,6 +168,7 @@ impl WindowDressing {
       index_buffer_memory,
       texture_image,
       texture_image_memory,
+      texture_image_view,
       uniform_buffers,
       uniform_buffer_memory,
       descriptor_pool,
@@ -186,6 +190,7 @@ impl WindowDressing {
     let instance = &permanent.instance;
     let surface = &permanent.surface;
     let device = &permanent.device;
+    let sampler = &permanent.sampler;
     let physical_device = &for_reinit.physical_device;
     let indices = &for_reinit.indices;
     let descriptor_set_layout = &for_reinit.descriptor_set_layout;
@@ -217,7 +222,8 @@ impl WindowDressing {
     let descriptor_sets
             = init_descriptor_sets(device, descriptor_set_layout,
                                    &uniform_buffers, &descriptor_pool,
-                                   swapchain.images.len())?;
+                                   swapchain.images.len(),
+                                   &self.texture_image_view, sampler)?;
 
     // Notice that we reused the command pool.
     let command_buffers = init_commands(
@@ -256,6 +262,7 @@ impl WindowDressing {
     unsafe { device.free_memory(self.index_buffer_memory, None) };
     unsafe { device.destroy_image(self.texture_image, None) };
     unsafe { device.free_memory(self.texture_image_memory, None) };
+    unsafe { device.destroy_image_view(self.texture_image_view, None) };
 
     for semaphore in self.concurrency.image_available_semaphores {
       unsafe { device.destroy_semaphore(semaphore, None) };
@@ -384,30 +391,7 @@ fn init_swapchain(window: &Window, instance: &Instance,
 
   let mut image_views = Vec::new();
   for image in &images {
-    let components = vk::ComponentMapping::builder()
-                         .r(vk::ComponentSwizzle::IDENTITY)
-                         .g(vk::ComponentSwizzle::IDENTITY)
-                         .b(vk::ComponentSwizzle::IDENTITY)
-                         .a(vk::ComponentSwizzle::IDENTITY);
-
-    let subresource_range = vk::ImageSubresourceRange::builder()
-                                .aspect_mask(vk::ImageAspectFlags::COLOR)
-                                .base_mip_level(0)
-                                .level_count(1)
-                                .base_array_layer(0)
-                                .layer_count(1);
-
-    let view_info = vk::ImageViewCreateInfo::builder()
-                        .image(*image)
-                        .view_type(vk::ImageViewType::_2D)
-                        .format(format.format)
-                        .components(components)
-                        .subresource_range(subresource_range);
-
-    let view = unsafe {
-      device.create_image_view(&view_info, None)
-    }?;
-
+    let view = init_image_view(device, image, format.format)?;
     image_views.push(view);
   }
 
@@ -649,7 +633,7 @@ fn init_index_buffer(instance: &Instance,
 fn init_texture(instance: &Instance,
                 physical_device: &vk::PhysicalDevice, device: &Device,
                 queue: &vk::Queue, command_pool: &vk::CommandPool)
-    -> Result<(vk::Image, vk::DeviceMemory)>
+    -> Result<(vk::Image, vk::DeviceMemory, vk::ImageView)>
 {
   let png = include_bytes!("../textures/forest_leaves_04_diff.png");
 
@@ -661,7 +645,7 @@ fn init_texture(instance: &Instance,
   let mut pixels = vec![0; reader.info().raw_bytes()];
   reader.next_frame(&mut pixels)?;
 
-  let (staging_buffer, staging_memory, byte_size)
+  let (staging_buffer, staging_memory, _byte_size)
           = stage_in_buffer(instance, physical_device, device, &pixels)?;
 
   let (image, image_memory)
@@ -685,10 +669,12 @@ fn init_texture(instance: &Instance,
                       vk::ImageLayout::TRANSFER_DST_OPTIMAL,
                       vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL)?;
 
+  let view = init_image_view(device, &image, vk::Format::R8G8B8A8_SRGB)?;
+
   unsafe { device.destroy_buffer(staging_buffer, None) };
   unsafe { device.free_memory(staging_memory, None) };
 
-  Ok((image, image_memory))
+  Ok((image, image_memory, view))
 }
 
 
@@ -750,7 +736,11 @@ fn init_descriptor_pool(device: &Device, count: usize)
           .type_(vk::DescriptorType::UNIFORM_BUFFER)
           .descriptor_count(count as u32);
 
-  let sizes = [uniform_block_size];
+  let sampler_size = vk::DescriptorPoolSize::builder()
+          .type_(vk::DescriptorType::COMBINED_IMAGE_SAMPLER)
+          .descriptor_count(count as u32);
+
+  let sizes = [uniform_block_size, sampler_size];
   let pool_info = vk::DescriptorPoolCreateInfo::builder()
           .pool_sizes(&sizes)
           .max_sets(count as u32);
@@ -763,7 +753,8 @@ fn init_descriptor_pool(device: &Device, count: usize)
 #[allow(unsafe_code)]
 fn init_descriptor_sets(device: &Device, layout: &vk::DescriptorSetLayout,
                         buffers: &Vec<vk::Buffer>, pool: &vk::DescriptorPool,
-                        count: usize)
+                        count: usize, texture_image_view: &vk::ImageView,
+                        sampler: &vk::Sampler)
     -> Result<Vec<vk::DescriptorSet>>
 {
   let layouts = vec![*layout; count];
@@ -779,13 +770,26 @@ fn init_descriptor_sets(device: &Device, layout: &vk::DescriptorSetLayout,
             .range(size_of::<UniformBlock<f32>>() as vk::DeviceSize);
 
     let buffer_info_list = [buffer_info];
-    let descriptor_write_info = vk::WriteDescriptorSet::builder()
+    let uniform_block_write_info = vk::WriteDescriptorSet::builder()
             .dst_set(sets[index])
             .dst_binding(0)
             .dst_array_element(0)
             .descriptor_type(vk::DescriptorType::UNIFORM_BUFFER)
             .buffer_info(&buffer_info_list);
-    let write_info_list = [descriptor_write_info];
+
+    let image_info = vk::DescriptorImageInfo::builder()
+            .image_layout(vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL)
+            .image_view(*texture_image_view)
+            .sampler(*sampler);
+    let image_info_list = [image_info];
+    let sampler_write_info = vk::WriteDescriptorSet::builder()
+            .dst_set(sets[index])
+            .dst_binding(1)
+            .dst_array_element(0)
+            .descriptor_type(vk::DescriptorType::COMBINED_IMAGE_SAMPLER)
+            .image_info(&image_info_list);
+
+    let write_info_list = [uniform_block_write_info, sampler_write_info];
     let copy_info_list: [vk::CopyDescriptorSet; 0] = [];
 
     unsafe {
@@ -954,6 +958,38 @@ fn init_concurrency(device: &Device,
 }
 
 
+#[allow(unsafe_code)]
+fn init_image_view(device: &Device, image: &vk::Image, format: vk::Format)
+    -> Result<vk::ImageView>
+{
+  let components = vk::ComponentMapping::builder()
+                       .r(vk::ComponentSwizzle::IDENTITY)
+                       .g(vk::ComponentSwizzle::IDENTITY)
+                       .b(vk::ComponentSwizzle::IDENTITY)
+                       .a(vk::ComponentSwizzle::IDENTITY);
+
+  let subresource_range = vk::ImageSubresourceRange::builder()
+                              .aspect_mask(vk::ImageAspectFlags::COLOR)
+                              .base_mip_level(0)
+                              .level_count(1)
+                              .base_array_layer(0)
+                              .layer_count(1);
+
+  let view_info = vk::ImageViewCreateInfo::builder()
+                      .image(*image)
+                      .view_type(vk::ImageViewType::_2D)
+                      .format(format)
+                      .components(components)
+                      .subresource_range(subresource_range);
+
+  let view = unsafe {
+    device.create_image_view(&view_info, None)
+  }?;
+
+  Ok(view)
+}
+
+
 fn pick_surface_format(available_formats: &Vec<vk::SurfaceFormatKHR>)
     -> Result<vk::SurfaceFormatKHR>
 {
@@ -1144,8 +1180,7 @@ fn allocate_image(instance: &Instance, physical_device: &vk::PhysicalDevice,
   let requirements = unsafe { device.get_image_memory_requirements(image) };
 
   let type_index = pick_memory_type(instance, physical_device,
-                                    &vk::MemoryPropertyFlags::DEVICE_LOCAL,
-                                    &requirements)?;
+                                    &memory_flags, &requirements)?;
 
   let image_memory_info = vk::MemoryAllocateInfo::builder()
           .allocation_size(requirements.size)