[remove] internal dependencies.

Author: vmarcella

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

@@ -4,6 +4,7 @@ use gfx_hal::{
     SparseFlags,
   },
   prelude::Device,
+  Backend,
 };
 
 use super::gpu::Gpu;
@@ -24,14 +25,14 @@ pub enum BufferType {
 /// A buffer is a block of memory that can be used to store data that can be
 /// accessed by the GPU.
 #[derive(Debug, Clone, Copy)]
-pub struct Buffer<RenderBackend: super::internal::Backend> {
+pub struct Buffer<RenderBackend: Backend> {
   buffer: RenderBackend::Buffer,
   memory: RenderBackend::Memory,
   stride: usize,
   buffer_type: BufferType,
 }
 
-impl<RenderBackend: super::internal::Backend> Buffer<RenderBackend> {
+impl<RenderBackend: Backend> Buffer<RenderBackend> {
   /// Destroy the buffer and all it's resources with the GPU that
   /// created it.
   pub fn destroy(self, gpu: &Gpu<RenderBackend>) {
@@ -47,7 +48,7 @@ impl<RenderBackend: super::internal::Backend> Buffer<RenderBackend> {
   }
 }
 
-impl<RenderBackend: super::internal::Backend> Buffer<RenderBackend> {
+impl<RenderBackend: Backend> Buffer<RenderBackend> {
   /// Retrieve a reference to the internal buffer.
   pub(super) fn internal_buffer(&self) -> &RenderBackend::Buffer {
     return &self.buffer;
@@ -95,7 +96,7 @@ impl BufferBuilder {
   /// bound to the GPU, the buffer memory is freed before the error is returned.
   /// Data must represent the data that will be stored in the buffer, meaning
   /// it must repr C and be the same size as the buffer length.
-  pub fn build<RenderBackend: super::internal::Backend, Data: Sized>(
+  pub fn build<RenderBackend: Backend, Data: Sized>(
     &self,
     gpu: &mut Gpu<RenderBackend>,
     data: Vec<Data>,

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

@@ -171,19 +171,17 @@ impl<'command_pool, RenderBackend: gfx_hal::Backend>
           .into_iter(),
           gfx_hal::command::SubpassContents::Inline,
         ),
-        Command::AttachGraphicsPipeline { pipeline } => {
-          self.command_buffer.bind_graphics_pipeline(
-            super::pipeline::internal::pipeline_for(pipeline.as_ref()),
-          )
-        }
+        Command::AttachGraphicsPipeline { pipeline } => self
+          .command_buffer
+          .bind_graphics_pipeline(pipeline.internal_pipeline()),
         Command::EndRenderPass => self.command_buffer.end_render_pass(),
         Command::PushConstants {
           pipeline,
           stage,
           offset,
           bytes,
         } => self.command_buffer.push_graphics_constants(
-          super::pipeline::internal::pipeline_layout_for(pipeline.as_ref()),
+          pipeline.internal_pipeline_layout(),
           stage,
           offset,
           bytes.as_slice(),

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

@@ -14,7 +14,10 @@ pub mod shader;
 pub mod surface;
 pub mod viewport;
 
-use gfx_hal::Instance as _;
+use gfx_hal::{
+  Backend,
+  Instance as _,
+};
 
 // ----------------------- INSTANCE BUILDER AND INSTANCE -------------------------------
 
@@ -30,19 +33,19 @@ impl InstanceBuilder {
   }
 
   /// Builds a graphical instance for the current platform.
-  pub fn build<RenderBackend: internal::Backend>(
+  pub fn build<RenderBackend: Backend>(
     self,
     name: &str,
   ) -> Instance<RenderBackend> {
     return Instance::new(name);
   }
 }
 
-pub struct Instance<RenderBackend: internal::Backend> {
+pub struct Instance<RenderBackend: Backend> {
   gfx_hal_instance: RenderBackend::Instance,
 }
 
-impl<RenderBackend: internal::Backend> Instance<RenderBackend> {
+impl<RenderBackend: Backend> Instance<RenderBackend> {
   /// Create a new GfxInstance connected to the current platforms primary backend.
   fn new(name: &str) -> Self {
     let instance = RenderBackend::Instance::create(name, 1)
@@ -54,7 +57,7 @@ impl<RenderBackend: internal::Backend> Instance<RenderBackend> {
   }
 }
 
-impl<RenderBackend: internal::Backend> Instance<RenderBackend> {
+impl<RenderBackend: Backend> Instance<RenderBackend> {
   /// Returns a list of all available adapters.
   pub(super) fn enumerate_adapters(
     &self,
@@ -90,9 +93,5 @@ impl<RenderBackend: internal::Backend> Instance<RenderBackend> {
 // ----------------------- INTERNAL INSTANCE OPERATIONS ------------------------
 
 pub mod internal {
-
-  pub use super::{
-    pipeline::internal::*,
-    shader::internal::*,
-  };
+  pub use super::shader::internal::*;
 }

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

@@ -1,39 +1,21 @@
-pub mod internal {
-
-  /// gfx-hal imports for pipeline.rs
-  pub use gfx_hal::{
-    device::Device,
-    pass::Subpass,
-    pso::{
-      BlendState,
-      ColorBlendDesc,
-      ColorMask,
-      EntryPoint,
-      Face,
-      GraphicsPipelineDesc,
-      PrimitiveAssemblerDesc,
-      Rasterizer,
-    },
-    Backend,
-  };
-
-  /// Retrieves the underlying gfx_hal pipeline for internal use.
-  pub fn pipeline_for<RenderBackend: gfx_hal::Backend>(
-    pipeline: &super::RenderPipeline<RenderBackend>,
-  ) -> &RenderBackend::GraphicsPipeline {
-    return &pipeline.pipeline;
-  }
-
-  pub fn pipeline_layout_for<RenderBackend: gfx_hal::Backend>(
-    pipeline: &super::RenderPipeline<RenderBackend>,
-  ) -> &RenderBackend::PipelineLayout {
-    return &pipeline.pipeline_layout;
-  }
-}
-
 use std::ops::Range;
 
-use gfx_hal::device::Device;
+/// gfx-hal imports for pipeline.rs
+use gfx_hal::{
+  device::Device,
+  pass::Subpass,
+  pso::{
+    BlendState,
+    ColorBlendDesc,
+    ColorMask,
+    EntryPoint,
+    Face,
+    GraphicsPipelineDesc,
+    PrimitiveAssemblerDesc,
+    Rasterizer,
+  },
+  Backend,
+};
 
 use super::{
   assembler::{
@@ -46,7 +28,7 @@ use super::{
 };
 
 /// Builder for a gfx-hal backed render pipeline.
-pub struct RenderPipelineBuilder<RenderBackend: internal::Backend> {
+pub struct RenderPipelineBuilder<RenderBackend: Backend> {
   pipeline_layout: Option<RenderBackend::PipelineLayout>,
   push_constants: Vec<PushConstantUpload>,
   buffers: Vec<Buffer<RenderBackend>>,
@@ -57,7 +39,7 @@ pub type PipelineStage = gfx_hal::pso::ShaderStageFlags;
 
 pub type PushConstantUpload = (PipelineStage, Range<u32>);
 
-impl<RenderBackend: internal::Backend> RenderPipelineBuilder<RenderBackend> {
+impl<RenderBackend: Backend> RenderPipelineBuilder<RenderBackend> {
   pub fn new() -> Self {
     return Self {
       pipeline_layout: None,
@@ -128,35 +110,32 @@ impl<RenderBackend: internal::Backend> RenderPipelineBuilder<RenderBackend> {
       builder.build(vertex_shader, Some(buffers), Some(attributes));
 
     let fragment_entry = match fragment_shader {
-      Some(shader) => Some(internal::EntryPoint::<RenderBackend> {
+      Some(shader) => Some(EntryPoint::<RenderBackend> {
         entry: shader.entry(),
         module: super::internal::module_for(shader),
         specialization: shader.specializations().clone(),
       }),
       None => None,
     };
 
-    let mut pipeline_desc = internal::GraphicsPipelineDesc::new(
+    let mut pipeline_desc = GraphicsPipelineDesc::new(
       primitive_assembler.internal_primitive_assembler(),
-      internal::Rasterizer {
-        cull_face: internal::Face::BACK,
-        ..internal::Rasterizer::FILL
+      Rasterizer {
+        cull_face: Face::BACK,
+        ..Rasterizer::FILL
       },
       fragment_entry,
       &pipeline_layout,
-      internal::Subpass {
+      Subpass {
         index: 0,
         main_pass: render_pass.internal_render_pass(),
       },
     );
 
-    pipeline_desc
-      .blender
-      .targets
-      .push(internal::ColorBlendDesc {
-        mask: internal::ColorMask::ALL,
-        blend: Some(internal::BlendState::ALPHA),
-      });
+    pipeline_desc.blender.targets.push(ColorBlendDesc {
+      mask: ColorMask::ALL,
+      blend: Some(BlendState::ALPHA),
+    });
 
     let pipeline = unsafe {
       let pipeline_build_result = gpu
@@ -179,13 +158,13 @@ impl<RenderBackend: internal::Backend> RenderPipelineBuilder<RenderBackend> {
 
 /// Represents a render capable pipeline for graphical
 #[derive(Debug)]
-pub struct RenderPipeline<RenderBackend: internal::Backend> {
+pub struct RenderPipeline<RenderBackend: Backend> {
   pipeline_layout: RenderBackend::PipelineLayout,
   pipeline: RenderBackend::GraphicsPipeline,
   buffers: Vec<Buffer<RenderBackend>>,
 }
 
-impl<RenderBackend: internal::Backend> RenderPipeline<RenderBackend> {
+impl<RenderBackend: Backend> RenderPipeline<RenderBackend> {
   /// Destroys the pipeline layout and graphical pipeline
   pub fn destroy(self, gpu: &super::gpu::Gpu<RenderBackend>) {
     println!("Destroying render pipeline");
@@ -204,3 +183,15 @@ impl<RenderBackend: internal::Backend> RenderPipeline<RenderBackend> {
     }
   }
 }
+
+impl<RenderBackend: Backend> RenderPipeline<RenderBackend> {
+  pub(super) fn internal_pipeline_layout(
+    &self,
+  ) -> &RenderBackend::PipelineLayout {
+    return &self.pipeline_layout;
+  }
+
+  pub(super) fn internal_pipeline(&self) -> &RenderBackend::GraphicsPipeline {
+    return &self.pipeline;
+  }
+}

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

@@ -1,8 +1,11 @@
 /// ColorFormat for the surface.
 pub use gfx_hal::format::Format as ColorFormat;
-use gfx_hal::window::{
-  PresentationSurface,
-  Surface as _,
+use gfx_hal::{
+  window::{
+    PresentationSurface,
+    Surface as _,
+  },
+  Backend,
 };
 #[cfg(test)]
 use mockall::automock;
@@ -167,7 +170,7 @@ impl SwapchainBuilder {
     return self;
   }
 
-  pub fn build<RenderBackend: super::internal::Backend>(
+  pub fn build<RenderBackend: Backend>(
     self,
     gpu: &Gpu<RenderBackend>,
     surface: &Surface<RenderBackend>,