[update] some internal surface functions.

Author: vmarcella

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

@@ -55,18 +55,12 @@ impl GpuBuilder {
           .queue_families
           .iter()
           .find(|family| {
-            return surface::internal::can_support_queue_family(
-              surface, family,
-            ) && family.queue_type().supports_graphics();
+            return surface.can_support_queue_family(family)
+              && family.queue_type().supports_graphics();
           })
           .expect("No compatible queue family found.")
           .id();
 
-        let _formats = surface::internal::get_first_supported_format(
-          surface,
-          &adapter.physical_device,
-        );
-
         return Ok(Gpu::new(adapter, queue_family));
       }
       (Some(_surface), RenderQueueType::Compute) => {

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

@@ -177,7 +177,7 @@ impl SwapchainBuilder {
   ) -> Swapchain {
     let physical_device = gpu.internal_physical_device();
     let caps = surface.gfx_hal_surface.capabilities(physical_device);
-    let format = internal::get_first_supported_format(surface, physical_device);
+    let format = surface.get_first_supported_format(physical_device);
     let (width, height) = self.size;
 
     let mut swapchain_config = gfx_hal::window::SwapchainConfig::from_caps(
@@ -235,39 +235,51 @@ mod tests {
   }
 }
 
-/// Internal functions to work with the gfx-hal surface components
-pub mod internal {
-  use gfx_hal::window::{
-    PresentationSurface,
-    Surface as _,
-  };
-
+impl<RenderBackend: Backend> Surface<RenderBackend> {
   /// Checks the queue family if the current Surface can support the GPU.
-  pub fn can_support_queue_family<RenderBackend: gfx_hal::Backend>(
-    surface: &super::Surface<RenderBackend>,
+  pub(super) fn can_support_queue_family(
+    &self,
     queue_family: &RenderBackend::QueueFamily,
   ) -> bool {
-    return surface.gfx_hal_surface.supports_queue_family(queue_family);
+    return self.gfx_hal_surface.supports_queue_family(queue_family);
   }
 
-  /// Get the supported gfx_hal color formats for a given format.
-  pub fn get_supported_formats<RenderBackend: gfx_hal::Backend>(
-    surface: &super::Surface<RenderBackend>,
+  pub(super) fn get_supported_formats(
+    &self,
     physical_device: &RenderBackend::PhysicalDevice,
   ) -> Vec<gfx_hal::format::Format> {
-    return surface
+    return self
       .gfx_hal_surface
       .supported_formats(physical_device)
       .unwrap_or(vec![]);
   }
 
+  pub(super) fn get_first_supported_format(
+    &self,
+    physical_device: &RenderBackend::PhysicalDevice,
+  ) -> gfx_hal::format::Format {
+    return self
+      .get_supported_formats(physical_device)
+      .get(0)
+      .unwrap_or(&gfx_hal::format::Format::Rgba8Srgb)
+      .clone();
+  }
+}
+
+/// Internal functions to work with the gfx-hal surface components
+pub mod internal {
+  use gfx_hal::window::{
+    PresentationSurface,
+    Surface as _,
+  };
+
   /// Helper function to retrieve the first supported format given a physical
   /// GPU device.
   pub fn get_first_supported_format<RenderBackend: gfx_hal::Backend>(
     surface: &super::Surface<RenderBackend>,
     physical_device: &RenderBackend::PhysicalDevice,
   ) -> gfx_hal::format::Format {
-    let supported_formats = get_supported_formats(&surface, physical_device);
+    let supported_formats = surface.get_supported_formats(physical_device);
 
     let default_format = *supported_formats
       .get(0)