[update] Instance implementation.

Author: vmarcella

crates/lambda-platform/src/gfx/gpu.rs

@@ -49,7 +49,7 @@ impl GpuBuilder {
   ) -> Result<Gpu<RenderBackend>, String> {
     match (surface, self.render_queue_type) {
       (Some(surface), RenderQueueType::Graphical) => {
-        let adapter = super::internal::get_adapter(instance, 0);
+        let adapter = instance.first_adapter();
 
         let queue_family = adapter
           .queue_families

crates/lambda-platform/src/gfx/mod.rs

@@ -54,55 +54,45 @@ impl<RenderBackend: internal::Backend> Instance<RenderBackend> {
   }
 }
 
-// ----------------------- INTERNAL INSTANCE OPERATIONS ------------------------
-
-pub mod internal {
-  use gfx_hal::{
-    adapter::Adapter,
-    Instance as _,
-  };
+impl<RenderBackend: internal::Backend> Instance<RenderBackend> {
+  /// Returns a list of all available adapters.
+  pub(super) fn enumerate_adapters(
+    &self,
+  ) -> Vec<gfx_hal::adapter::Adapter<RenderBackend>> {
+    return self.gfx_hal_instance.enumerate_adapters();
+  }
 
-  pub use super::{
-    pipeline::internal::*,
-    shader::internal::*,
-    Instance,
-  };
+  pub(super) fn first_adapter(
+    &self,
+  ) -> gfx_hal::adapter::Adapter<RenderBackend> {
+    return self.gfx_hal_instance.enumerate_adapters().remove(0);
+  }
 
-  /// Helper function to create a low level gfx_hal surface. Not meant to be
-  /// used outside of lambda-platform.
-  #[inline]
-  pub fn create_surface<RenderBackend: gfx_hal::Backend>(
-    instance: &Instance<RenderBackend>,
+  pub(super) fn create_surface(
+    &self,
     window_handle: &crate::winit::WindowHandle,
   ) -> RenderBackend::Surface {
-    unsafe {
-      let surface = instance
+    return unsafe {
+      self
         .gfx_hal_instance
         .create_surface(&window_handle.window_handle)
-        .expect("Failed to create a surface using the current instance and window handle.");
-
-      return surface;
+        .expect("Failed to create a surface using the current instance and window handle.")
     };
   }
 
-  /// Destroy a low level gfx_hal surface using the instance abstraction.
-  pub fn destroy_surface<RenderBackend: gfx_hal::Backend>(
-    instance: &Instance<RenderBackend>,
-    surface: RenderBackend::Surface,
-  ) {
+  pub(super) fn destroy_surface(&self, surface: RenderBackend::Surface) {
     unsafe {
-      instance.gfx_hal_instance.destroy_surface(surface);
+      self.gfx_hal_instance.destroy_surface(surface);
     }
   }
+}
 
-  /// Returns a graphical adapter from an instance.
-  pub fn get_adapter<RenderBackend: gfx_hal::Backend>(
-    instance: &mut Instance<RenderBackend>,
-    adapter_num: usize,
-  ) -> Adapter<RenderBackend> {
-    return instance
-      .gfx_hal_instance
-      .enumerate_adapters()
-      .remove(adapter_num);
-  }
+// ----------------------- INTERNAL INSTANCE OPERATIONS ------------------------
+
+pub mod internal {
+
+  pub use super::{
+    pipeline::internal::*,
+    shader::internal::*,
+  };
 }

crates/lambda-platform/src/gfx/surface.rs

@@ -36,7 +36,7 @@ impl SurfaceBuilder {
     instance: &super::Instance<RenderBackend>,
     window: &crate::winit::WindowHandle,
   ) -> Surface<RenderBackend> {
-    let gfx_hal_surface = super::internal::create_surface(instance, window);
+    let gfx_hal_surface = instance.create_surface(window);
     let name = match self.name {
       Some(name) => name,
       None => "RenderSurface".to_string(),
@@ -137,7 +137,7 @@ impl<RenderBackend: gfx_hal::Backend> Surface<RenderBackend> {
   pub fn destroy(self, instance: &Instance<RenderBackend>) {
     println!("Destroying the surface: {}", self.name);
 
-    super::internal::destroy_surface(&instance, self.gfx_hal_surface);
+    instance.destroy_surface(self.gfx_hal_surface);
   }
 
   /// Get the size of the surface's extent. Will only return a size if a