simplify drop()

Force-Push: yes
Change-Id: I52cf7db5a61899c54ceecd0f86acbef13474d929

1 files changed, 46 insertions, 66 deletions

diff --git a/src/main.rs b/src/main.rs
index 3bba33b..d23ff01 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1384,92 +1384,72 @@ impl Surreality {
 impl Drop for Surreality {
   #[allow(unsafe_code)]
   fn drop(&mut self) {
-    if let Some(device) = self.device.borrow().as_ref() {
+    if let Some(device) = self.device.replace(None) {
       unsafe { device.device_wait_idle() }.unwrap();
-    }
 
-    if let Some(concurrency) = self.concurrency.replace(None)
-       && let Some(device) = self.device.borrow().as_ref()
-    {
-      for semaphore in concurrency.image_available_semaphores {
-        unsafe { device.destroy_semaphore(semaphore, None) };
-      }
+      if let Some(concurrency) = self.concurrency.replace(None) {
+        for semaphore in concurrency.image_available_semaphores {
+          unsafe { device.destroy_semaphore(semaphore, None) };
+        }
 
-      for semaphore in concurrency.rendering_finished_semaphores {
-        unsafe { device.destroy_semaphore(semaphore, None) };
-      }
+        for semaphore in concurrency.rendering_finished_semaphores {
+          unsafe { device.destroy_semaphore(semaphore, None) };
+        }
 
-      for fence in concurrency.frame_fences {
-        unsafe { device.destroy_fence(fence, None) };
+        for fence in concurrency.frame_fences {
+          unsafe { device.destroy_fence(fence, None) };
+        }
       }
-    }
-
-    if let Some(command_pool) = self.command_pool.replace(None)
-       && let Some(device) = self.device.borrow().as_ref()
-    {
-      unsafe { device.destroy_command_pool(command_pool, None) };
-    }
 
-    if let Some(framebuffers) = self.framebuffers.replace(None)
-       && let Some(device) = self.device.borrow().as_ref()
-    {
-      for framebuffer in framebuffers {
-        unsafe { device.destroy_framebuffer(framebuffer, None) };
+      if let Some(command_pool) = self.command_pool.replace(None) {
+        unsafe { device.destroy_command_pool(command_pool, None) };
       }
-    }
 
-    if let Some(pipeline) = self.pipeline.replace(None)
-       && let Some(device) = self.device.borrow().as_ref()
-    {
-      unsafe { device.destroy_pipeline(pipeline, None) };
-    }
+      if let Some(framebuffers) = self.framebuffers.replace(None) {
+        for framebuffer in framebuffers {
+          unsafe { device.destroy_framebuffer(framebuffer, None) };
+        }
+      }
 
-    if let Some(render_pass) = self.render_pass.replace(None)
-       && let Some(device) = self.device.borrow().as_ref()
-    {
-      unsafe { device.destroy_render_pass(render_pass, None) };
-    }
+      if let Some(pipeline) = self.pipeline.replace(None) {
+        unsafe { device.destroy_pipeline(pipeline, None) };
+      }
 
-    if let Some(pipeline_layout) = self.pipeline_layout.replace(None)
-       && let Some(device) = self.device.borrow().as_ref()
-    {
-      unsafe { device.destroy_pipeline_layout(pipeline_layout, None) };
-    }
+      if let Some(render_pass) = self.render_pass.replace(None) {
+        unsafe { device.destroy_render_pass(render_pass, None) };
+      }
 
-    if let Some(swapchain) = self.swapchain.replace(None)
-       && let Some(device) = self.device.borrow().as_ref()
-    {
-      for view in swapchain.image_views {
-        unsafe { device.destroy_image_view(view, None) };
+      if let Some(pipeline_layout) = self.pipeline_layout.replace(None) {
+        unsafe { device.destroy_pipeline_layout(pipeline_layout, None) };
       }
 
-      unsafe { device.destroy_swapchain_khr(swapchain.swapchain, None) };
-    }
+      if let Some(swapchain) = self.swapchain.replace(None) {
+        for view in swapchain.image_views {
+          unsafe { device.destroy_image_view(view, None) };
+        }
 
-    if let Some(surface) = self.surface.replace(None)
-       && let Some(instance) = self.instance.borrow().as_ref()
-    {
-      unsafe { instance.destroy_surface_khr(surface, None) };
-    }
+        unsafe { device.destroy_swapchain_khr(swapchain.swapchain, None) };
+      }
 
-    if let Some(device) = self.device.replace(None) {
       unsafe { device.destroy_device(None) };
     }
 
-    //   Everything but the instance itself should already be destroyed,
-    // before we destroy the debug messager. The special hook to get debug
-    // messages while destroying the instance itself only applies to the
-    // instance and the messager, so if we were to destroy anything we
-    // shouldn't after this point, we'd miss out on diagnostics.
-    if let Some(debug_messager) = self.debug_messager.replace(None)
-       && let Some(instance) = self.instance.borrow().as_ref()
-    {
-      unsafe {
-        instance.destroy_debug_utils_messenger_ext(debug_messager, None);
+    if let Some(instance) = self.instance.replace(None) {
+      if let Some(surface) = self.surface.replace(None) {
+        unsafe { instance.destroy_surface_khr(surface, None) };
+      }
+
+      //   Everything but the instance itself should already be destroyed,
+      // before we destroy the debug messager. The special hook to get debug
+      // messages while destroying the instance itself only applies to the
+      // instance and the messager, so if we were to destroy anything we
+      // shouldn't after this point, we'd miss out on diagnostics.
+      if let Some(debug_messager) = self.debug_messager.replace(None) {
+        unsafe {
+          instance.destroy_debug_utils_messenger_ext(debug_messager, None);
+        }
       }
-    }
 
-    if let Some(instance) = self.instance.replace(None) {
       unsafe { instance.destroy_instance(None) };
     }
   }