Merge pull request #27 from lambda-sh/vmarcella/repo-cleanup

Refactor the renderer & lambda-platform to include a surface implementation for rendering.

Author: vmarcella

.vscode/launch.json

@@ -0,0 +1 @@
+struct Adapter;

.vscode/tasks.json

@@ -50,7 +50,10 @@ use gfx_hal::{
   },
 };
 
-use super::pipeline::GraphicsPipeline;
+use super::{
+  pipeline::GraphicsPipeline,
+  surface,
+};
 
 ///
 /// Commands oriented around creating resources on & for the GPU.
@@ -70,47 +73,18 @@ pub enum RenderQueueType {
   Transfer,
 }
 
-/// Checks if queue_family is capable of supporting the requested queue type &
-/// Optional surface.
-fn is_queue_family_supported<B: gfx_hal::Backend>(
-  queue_family: &B::QueueFamily,
-  queue_type: RenderQueueType,
-  surface: Option<&B::Surface>,
-) -> bool {
-  match queue_type {
-    RenderQueueType::Compute => queue_family.queue_type().supports_compute(),
-    RenderQueueType::Graphical => match surface {
-      Some(surface) => {
-        surface.supports_queue_family(queue_family)
-          && queue_family.queue_type().supports_graphics()
-      }
-      None => false,
-    },
-    // TODO(vmarcella): These arms should be filled out to support the other kinds of queue types.
-    RenderQueueType::GraphicalCompute => {
-      todo!("GraphicalCompute RenderQueue's are not currently implemented.")
-    }
-    RenderQueueType::Transfer => {
-      todo!("Transfer RenderQueues are not currently implemented.")
-    }
-  }
-}
-
 impl<B: gfx_hal::Backend> GfxGpu<B> {
   /// Instantiates a new GPU given an adapter that is implemented by the GPUs
   /// current rendering backend B. A new GPU does not come with a command pool unless specified.
   pub fn new(
     adapter: Adapter<B>,
-    queue_type: RenderQueueType,
-    surface: Option<&B::Surface>,
+    queue_family: gfx_hal::queue::QueueFamilyId,
   ) -> Self {
     let queue_family = adapter
       .queue_families
       .iter()
-      .find(|family| {
-        return is_queue_family_supported::<B>(family, queue_type, surface);
-      })
-      .expect("No compatible queue family found.");
+      .find(|family| family.id() == queue_family)
+      .expect("Failed to find the queue family requested for the GPU.");
 
     let mut gpu = unsafe {
       adapter
@@ -171,6 +145,14 @@ impl<B: gfx_hal::Backend> GfxGpu<B> {
     }
   }
 
+  pub fn get_logical_device(&self) -> &B::Device {
+    return &self.gpu.device;
+  }
+
+  pub fn get_physical_device(&self) -> &B::PhysicalDevice {
+    return &self.adapter.physical_device;
+  }
+
   /// Render to the surface and return the result from the GPU.
   pub fn render_to_surface(
     &mut self,
@@ -186,40 +168,6 @@ impl<B: gfx_hal::Backend> GfxGpu<B> {
     }
   }
 
-  pub fn configure_swapchain_and_update_extent(
-    &mut self,
-    surface: &mut B::Surface,
-    color_format: gfx_hal::format::Format,
-    size: [u32; 2],
-  ) -> (Extent2D, gfx_hal::image::FramebufferAttachment) {
-    let caps = surface.capabilities(&self.adapter.physical_device);
-    let mut swapchain_config = SwapchainConfig::from_caps(
-      &caps,
-      color_format,
-      Extent2D {
-        width: size[0],
-        height: size[1],
-      },
-    );
-
-    // TODO(vmarcella) Profile the performance on MacOS to see if this slows
-    // down frame times.
-    if caps.image_count.contains(&3) {
-      swapchain_config.image_count = 3;
-    }
-
-    let surface_extent = swapchain_config.extent;
-    let fba = swapchain_config.framebuffer_attachment();
-
-    unsafe {
-      surface
-        .configure_swapchain(&self.gpu.device, swapchain_config)
-        .expect("Failed to configure the swapchain");
-    }
-
-    return (surface_extent, fba);
-  }
-
   /// Allocate's a command buffer through the GPU
   pub fn allocate_command_buffer(&mut self) -> B::CommandBuffer {
     // TODO(vmarcella): This function should probably not just panic and instead
@@ -237,10 +185,13 @@ impl<B: gfx_hal::Backend> GfxGpu<B> {
 
   pub fn destroy_command_pool(&mut self) {
     unsafe {
-      self
-        .gpu
-        .device
-        .destroy_command_pool(self.command_pool.take().unwrap());
+      match self.command_pool {
+        Some(_) => self
+          .gpu
+          .device
+          .destroy_command_pool(self.command_pool.take().unwrap()),
+        None => {}
+      }
     }
   }
 
@@ -364,11 +315,6 @@ impl<B: gfx_hal::Backend> GfxGpu<B> {
     }
   }
 
-  /// Unconfigure the swapchain for a surface created from this GPU.
-  pub fn unconfigure_swapchain(&mut self, surface: &mut B::Surface) {
-    unsafe { surface.unconfigure_swapchain(&self.gpu.device) }
-  }
-
   pub fn create_shader_module(&mut self, binary: &Vec<u32>) -> B::ShaderModule {
     unsafe {
       let module = self
@@ -455,24 +401,4 @@ impl<B: gfx_hal::Backend> GfxGpu<B> {
       self.gpu.device.destroy_fence(submission_complete_fence);
     }
   }
-
-  /// Finds the first supported color format or default to Rgba8Srgb.
-  pub fn find_supported_color_format(
-    &mut self,
-    surface: &B::Surface,
-  ) -> Format {
-    // Define a surface color format compatible with the graphics device &
-    // surface
-    let supported_formats = surface
-      .supported_formats(&self.adapter.physical_device)
-      .unwrap_or(vec![]);
-
-    let default_format =
-      *supported_formats.get(0).unwrap_or(&Format::Rgba8Srgb);
-
-    return supported_formats
-      .into_iter()
-      .find(|format| -> bool { format.base_format().1 == ChannelType::Srgb })
-      .unwrap_or(default_format);
-  }
 }

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

@@ -1,10 +1,15 @@
-use gfx_hal::Instance;
+use gfx_hal::{
+  queue::QueueFamily,
+  Instance,
+};
 
+use self::gpu::RenderQueueType;
 use super::winit::WindowHandle;
 
 pub mod api;
 pub mod gpu;
 pub mod pipeline;
+pub mod surface;
 
 use api::RenderingAPI;
 
@@ -39,52 +44,87 @@ pub mod gfx_hal_exports {
   };
 }
 
-pub struct GfxInstance<B: gfx_hal::Backend> {
-  instance: B::Instance,
+pub struct GfxInstance<RenderBackend: gfx_hal::Backend> {
+  instance: RenderBackend::Instance,
 }
 
-impl<B: gfx_hal::Backend> GfxInstance<B> {
+impl<RenderBackend: gfx_hal::Backend> GfxInstance<RenderBackend> {
   /// Create a new GfxInstance connected to the platforms primary backend.
   pub fn new(name: &str) -> Self {
-    let instance = B::Instance::create(name, 1)
+    let instance = RenderBackend::Instance::create(name, 1)
       .expect("gfx backend not supported by the current platform");
 
     return Self { instance };
   }
 
   /// Create a surface for a given lambda window using it's underlying
   /// winit window handle.
-  /// TODO(vmarcella): Wrap up the B::Surface type to a custom type of our own.
-  pub fn create_surface(&self, window_handle: &WindowHandle) -> B::Surface {
-    return unsafe {
-      self
+  pub fn create_surface(
+    &self,
+    window_handle: &WindowHandle,
+  ) -> surface::Surface<RenderBackend> {
+    unsafe {
+      let surface = self
         .instance
         .create_surface(&window_handle.window_handle)
-        .unwrap()
+        .unwrap();
+
+      return surface::Surface::new(surface);
     };
   }
 
-  /// Destroy a surface created by this graphical instance.
-  pub fn destroy_surface(&self, mut surface: B::Surface) {
+  pub fn destroy_surface(&self, surface: RenderBackend::Surface) {
     unsafe {
       self.instance.destroy_surface(surface);
     }
   }
+}
 
-  /// Open a connection to the primary GPU with an optional surface that the GPU
-  /// can access for rendering.
-  // TODO(vmarcella): This function should allow the RenderQueueType to be
-  // optionally passed in with the default type being Graphical.
-  pub fn open_primary_gpu(
-    &self,
-    surface: Option<&B::Surface>,
-  ) -> gpu::GfxGpu<B> {
-    let adapter = self.instance.enumerate_adapters().remove(0);
-    return gpu::GfxGpu::<B>::new(
+/// GpuBuilder for constructing a GPU
+pub struct GpuBuilder<RenderBackend: gfx_hal_exports::Backend> {
+  adapter: gfx_hal::adapter::Adapter<RenderBackend>,
+  render_queue_type: RenderQueueType,
+}
+
+impl<RenderBackend: gfx_hal_exports::Backend> GpuBuilder<RenderBackend> {
+  pub fn new(instance: &mut GfxInstance<RenderBackend>) -> Self {
+    let adapter = instance.instance.enumerate_adapters().remove(0);
+    return Self {
       adapter,
-      gpu::RenderQueueType::Graphical,
-      surface,
-    );
+      render_queue_type: RenderQueueType::Graphical,
+    };
+  }
+
+  pub fn with_render_queue_type(mut self, queue_type: RenderQueueType) -> Self {
+    self.render_queue_type = queue_type;
+    return self;
+  }
+
+  /// Builds a GPU
+  pub fn build(
+    self,
+    surface: Option<&surface::Surface<RenderBackend>>,
+  ) -> Result<gpu::GfxGpu<RenderBackend>, String> {
+    match (surface, self.render_queue_type) {
+      (Some(surface), RenderQueueType::Graphical) => {
+        let adapter = self.adapter;
+        let queue_family = adapter
+          .queue_families
+          .iter()
+          .find(|family| {
+            return surface.can_support_queue_family(family)
+              && family.queue_type().supports_graphics();
+          })
+          .expect("No compatible queue family found.")
+          .id();
+
+        let formats =
+          surface.get_first_supported_format(&adapter.physical_device);
+
+        return Ok(gpu::GfxGpu::new(adapter, queue_family));
+      }
+      (_, _) => return Err("Failed to build GPU.".to_string()),
+    }
   }
 }