move models into their own struct and file

Force-Push: yes
Change-Id: Ic6aa38b7d069825beadeb144eace5a9d23f0d21b

1 files changed, 13 insertions, 82 deletions

diff --git a/src/graphics/render_state.rs b/src/graphics/render_state.rs
index d8a607c..d918e9a 100644
--- a/src/graphics/render_state.rs
+++ b/src/graphics/render_state.rs
@@ -3,16 +3,13 @@ use crate::error::*;
 use crate::graphics::permanent::{
   PermanentGraphicsState, GraphicsStateForReinit
 };
-use crate::graphics::util::{
-  allocate_buffer, copy_buffer, stage_in_buffer
-};
-use crate::model_loader::load_model;
+use crate::graphics::model::Model;
 use crate::graphics::window_dressing::WindowDressing;
 use crate::shader_data::{ Vertex, UniformBlock, VertexPushBlock };
 
 use std::mem::size_of;
 
-use vulkanalia::{ Device, Instance };
+use vulkanalia::Device;
 use vulkanalia::vk::{ self, Handle, HasBuilder, DeviceV1_0 };
 
 
@@ -26,12 +23,7 @@ pub struct RenderState {
   pub pipeline: vk::Pipeline,
   pub pipeline_layout: vk::PipelineLayout,
 
-  pub vertex_buffer: vk::Buffer,
-  vertex_buffer_memory: vk::DeviceMemory,
-
-  pub index_buffer: vk::Buffer,
-  index_buffer_memory: vk::DeviceMemory,
-  pub index_count: usize,
+  pub model: Option<Model>,
 
   pub framebuffers: Vec<vk::Framebuffer>,
   pub command_buffers: Vec<vk::CommandBuffer>,
@@ -46,13 +38,9 @@ impl RenderState {
       -> Result<Self>
   {
     let device = &permanent.device;
-    let instance = &permanent.instance;
-    let graphics_queue = &permanent.graphics_queue;
-    let physical_device = &for_reinit.physical_device;
     let sample_count = for_reinit.sample_count;
     let descriptor_set_layout = &for_reinit.descriptor_set_layout;
     let primary_command_pool = &window_dressing.primary_command_pool;
-    let transient_command_pool = &window_dressing.transient_command_pool;
     let swapchain = &window_dressing.swapchain;
     let depth_format = &window_dressing.depth_format;
     let color_image_view = &window_dressing.color_image_view;
@@ -73,34 +61,22 @@ impl RenderState {
             device, &swapchain.extent, &swapchain.image_views,
             &color_image_view, &depth_image_view, &render_pass)?;
 
-    let (vertices, indices) = load_model()?;
-    let index_count = indices.len();
-
     let command_buffers = init_command_buffers(device, &framebuffers,
                                                primary_command_pool)?;
 
-    let (vertex_buffer, vertex_buffer_memory)
-            = init_vertex_buffer(vertices, instance, physical_device, device,
-                                 graphics_queue, &transient_command_pool)?;
-    let (index_buffer, index_buffer_memory)
-            = init_index_buffer(indices, instance, physical_device, device,
-                                graphics_queue, &transient_command_pool)?;
-
     let descriptor_sets
             = init_descriptor_sets(device, descriptor_set_layout,
                                    &uniform_buffers, &descriptor_pool,
                                    swapchain.images.len(),
                                    &texture_image_view, &sampler)?;
 
+    let model = None;
+
     Ok(RenderState {
       render_pass,
       pipeline,
       pipeline_layout,
-      vertex_buffer,
-      vertex_buffer_memory,
-      index_buffer,
-      index_buffer_memory,
-      index_count,
+      model,
       framebuffers,
       command_buffers,
       descriptor_sets,
@@ -168,11 +144,9 @@ impl RenderState {
   {
     self.destroy_replaceable(device, &window_dressing.primary_command_pool);
 
-    unsafe { device.destroy_buffer(self.vertex_buffer, None) };
-    unsafe { device.free_memory(self.vertex_buffer_memory, None) };
-
-    unsafe { device.destroy_buffer(self.index_buffer, None) };
-    unsafe { device.free_memory(self.index_buffer_memory, None) };
+    if let Some(model) = self.model {
+      model.destroy(device);
+    }
   }
 
   #[allow(unsafe_code)]
@@ -197,6 +171,10 @@ impl RenderState {
     unsafe { device.destroy_pipeline_layout(self.pipeline_layout, None) };
     unsafe { device.destroy_render_pass(self.render_pass, None) };
   }
+
+  pub fn set_model(&mut self, model: Model) {
+    self.model = Some(model);
+  }
 }
 
 
@@ -476,53 +454,6 @@ fn init_command_buffers(device: &Device,
 }
 
 
-fn init_vertex_buffer(vertices: Vec<Vertex<f32>>, instance: &Instance,
-                      physical_device: &vk::PhysicalDevice, device: &Device,
-                      queue: &vk::Queue, command_pool: &vk::CommandPool)
-    -> Result<(vk::Buffer, vk::DeviceMemory)>
-{
-  init_buffer(instance, physical_device, device, queue, command_pool,
-              vk::BufferUsageFlags::VERTEX_BUFFER, &vertices)
-}
-
-
-fn init_index_buffer(indices: Vec<u32>, instance: &Instance,
-                     physical_device: &vk::PhysicalDevice, device: &Device,
-                     queue: &vk::Queue, command_pool: &vk::CommandPool)
-    -> Result<(vk::Buffer, vk::DeviceMemory)>
-{
-  init_buffer(instance, physical_device, device, queue, command_pool,
-              vk::BufferUsageFlags::INDEX_BUFFER, &indices)
-}
-
-
-#[allow(unsafe_code)]
-fn init_buffer<T>(instance: &Instance,
-                  physical_device: &vk::PhysicalDevice, device: &Device,
-                  queue: &vk::Queue, command_pool: &vk::CommandPool,
-                  usage: vk::BufferUsageFlags, contents: &[T])
-    -> Result<(vk::Buffer, vk::DeviceMemory)>
-{
-  let (staging_buffer, staging_memory, size)
-          = stage_in_buffer(instance, physical_device, device, contents)?;
-
-  let final_usage = vk::BufferUsageFlags::TRANSFER_DST | usage;
-  let final_memory_flags = vk::MemoryPropertyFlags::DEVICE_LOCAL;
-  let (final_buffer, device_memory)
-          = allocate_buffer(instance, physical_device, device,
-                            size as vk::DeviceSize, final_usage,
-                            final_memory_flags)?;
-
-  copy_buffer(device, queue, command_pool, &staging_buffer, &final_buffer,
-              size as vk::DeviceSize)?;
-
-  unsafe { device.destroy_buffer(staging_buffer, None) };
-  unsafe { device.free_memory(staging_memory, None) };
-
-  Ok((final_buffer, device_memory))
-}
-
-
 #[allow(unsafe_code)]
 fn init_descriptor_sets(device: &Device, layout: &vk::DescriptorSetLayout,
                         buffers: &Vec<vk::Buffer>, pool: &vk::DescriptorPool,