[update] internal surface implementations.

Author: vmarcella

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

@@ -157,11 +157,10 @@ impl<'command_pool, RenderBackend: gfx_hal::Backend>
           frame_buffer.internal_frame_buffer(),
           viewport.internal_viewport().rect,
           vec![gfx_hal::command::RenderAttachmentInfo::<RenderBackend> {
-            image_view: super::surface::internal::borrow_surface_image_for(
-              &surface,
-            )
-            .unwrap()
-            .borrow(),
+            image_view: surface
+              .internal_surface_image()
+              .expect("No internal surface set when beginning the render pass.")
+              .borrow(),
             clear_value: ClearValue {
               color: gfx_hal::command::ClearColor {
                 float32: [0.0, 0.0, 0.0, 1.0],

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

@@ -46,10 +46,10 @@ impl FramebufferBuilder {
     render_pass: &RenderPass<RenderBackend>,
     surface: &Surface<RenderBackend>,
   ) -> Framebuffer<RenderBackend> {
-    use super::surface::internal::frame_buffer_attachment_from;
-
     let (width, height) = surface.size().expect("A surface without a swapchain cannot be used in a framebeen configured with a swapchain");
-    let image = frame_buffer_attachment_from(surface).unwrap();
+    let image = surface
+      .internal_frame_buffer_attachment()
+      .expect("A surface without a swapchain cannot be used in a frame.");
 
     let frame_buffer = unsafe {
       gpu

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

@@ -152,8 +152,7 @@ impl<RenderBackend: gfx_hal::Backend> Gpu<RenderBackend> {
     surface: &mut surface::Surface<RenderBackend>,
     semaphore: &mut RenderSemaphore<RenderBackend>,
   ) -> Result<(), &str> {
-    let (render_surface, render_image) =
-      super::surface::internal::borrow_surface_and_take_image(surface);
+    let (render_surface, render_image) = surface.internal_surface_and_image();
 
     let result = unsafe {
       self.queue_group.queues[0].present(

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

@@ -264,64 +264,28 @@ impl<RenderBackend: Backend> Surface<RenderBackend> {
       .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 = surface.get_supported_formats(physical_device);
-
-    let default_format = *supported_formats
-      .get(0)
-      .unwrap_or(&gfx_hal::format::Format::Rgba8Srgb);
-
-    return supported_formats
-      .into_iter()
-      .find(|format| -> bool {
-        format.base_format().1 == gfx_hal::format::ChannelType::Srgb
-      })
-      .unwrap_or(default_format);
-  }
-
-  /// Acquires a surface image for attaching to a framebuffer.
-  pub fn take_surface_image_for<RenderBackend: gfx_hal::Backend>(
-    surface: &mut super::Surface<RenderBackend>,
-  ) -> Option<<RenderBackend::Surface as PresentationSurface<RenderBackend>>::SwapchainImage>{
-    return surface.image.take();
-  }
-
-  /// Acquires a surface image for attaching to a framebuffer.
-  pub fn borrow_surface_image_for<RenderBackend: gfx_hal::Backend>(
-    surface: &super::Surface<RenderBackend>,
+  pub(super) fn internal_surface_image(
+    &self,
   ) -> Option<&<RenderBackend::Surface as PresentationSurface<RenderBackend>>::SwapchainImage>{
-    return surface.image.as_ref();
+    return self.image.as_ref();
   }
 
-  /// FrameBuffer Attachment
-  pub fn frame_buffer_attachment_from<RenderBackend: gfx_hal::Backend>(
-    surface: &super::Surface<RenderBackend>,
+  pub(super) fn internal_frame_buffer_attachment(
+    &self,
   ) -> Option<gfx_hal::image::FramebufferAttachment> {
-    return surface.frame_buffer_attachment.clone();
+    return self.frame_buffer_attachment.clone();
   }
 
-  /// Borrow the surface and take the image. This internal function is used for
-  /// rendering and composes surface_for + take image.
-  pub fn borrow_surface_and_take_image<RenderBackend: gfx_hal::Backend>(
-    surface: &mut super::Surface<RenderBackend>,
-  ) -> (&mut RenderBackend::Surface, <RenderBackend::Surface as PresentationSurface<RenderBackend>>::SwapchainImage){
+  pub(super) fn internal_surface_and_image(
+    &mut self,
+  ) -> (
+    &mut RenderBackend::Surface,
+    <RenderBackend::Surface as PresentationSurface<RenderBackend>>::SwapchainImage,
+  ){
     return (
-      &mut surface.gfx_hal_surface,
-      surface.image.take().expect("Surface image is not present"),
+      &mut self.gfx_hal_surface,
+      self.image.take().expect("Surface image is not present"),
     );
   }
 }