[update] Buffer & Mesh API, refactor internal api calls, implement vertex attributes & mesh into demo.

Author: vmarcella

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

@@ -1,9 +1,9 @@
 //! Primitive assembly for the graphics pipeline.
 
+pub use gfx_hal::pso::Element as VertexElement;
 use gfx_hal::pso::{
   self,
   AttributeDesc,
-  Element,
   VertexBufferDesc,
 };
 
@@ -17,7 +17,7 @@ use super::{
 pub struct VertexAttribute {
   pub location: u32,
   pub offset: u32,
-  pub element: Element<ColorFormat>,
+  pub element: VertexElement<ColorFormat>,
 }
 
 /// PrimitiveAssemblerBuilder for preparing PrimitiveAssemblers to use in the

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

@@ -1,6 +1,9 @@
-use gfx_hal::memory::{
-  Segment,
-  SparseFlags,
+use gfx_hal::{
+  memory::{
+    Segment,
+    SparseFlags,
+  },
+  prelude::Device,
 };
 
 use super::gpu::Gpu;
@@ -29,6 +32,14 @@ pub struct Buffer<RenderBackend: super::internal::Backend> {
 }
 
 impl<RenderBackend: super::internal::Backend> Buffer<RenderBackend> {
+  /// Destroy the buffer and all it's resources with the GPU that
+  /// created it.
+  pub fn destroy(self, gpu: &Gpu<RenderBackend>) {
+    unsafe {
+      gpu.internal_logical_device().destroy_buffer(self.buffer);
+      gpu.internal_logical_device().free_memory(self.memory);
+    }
+  }
   pub fn stride(&self) -> usize {
     return self.stride;
   }
@@ -82,10 +93,9 @@ impl BufferBuilder {
   ) -> Result<Buffer<RenderBackend>, &'static str> {
     use gfx_hal::{
       adapter::PhysicalDevice,
-      device::Device,
       MemoryTypeId,
     };
-    let logical_device = super::internal::logical_device_for(gpu);
+    let logical_device = gpu.internal_logical_device();
     let physical_device = super::internal::physical_device_for(gpu);
 
     // TODO(vmarcella): Add the ability for the user to specify the memory

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

@@ -183,7 +183,7 @@ impl<RenderBackend: gfx_hal::Backend> Gpu<RenderBackend> {
     return Ok(());
   }
 
-  pub(super) fn logical_device(&self) -> &RenderBackend::Device {
+  pub(super) fn internal_logical_device(&self) -> &RenderBackend::Device {
     return &self.gpu.device;
   }
 }

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

@@ -158,7 +158,7 @@ impl<RenderBackend: internal::Backend> RenderPipelineBuilder<RenderBackend> {
 
     let pipeline = unsafe {
       gpu
-        .logical_device()
+        .internal_logical_device()
         .create_graphics_pipeline(&pipeline_desc, None)
         .expect("Failed to create graphics pipeline")
     };
@@ -184,11 +184,11 @@ impl<RenderBackend: internal::Backend> RenderPipeline<RenderBackend> {
   pub fn destroy(self, gpu: &super::gpu::Gpu<RenderBackend>) {
     unsafe {
       gpu
-        .logical_device()
+        .internal_logical_device()
         .destroy_pipeline_layout(self.pipeline_layout);
 
       gpu
-        .logical_device()
+        .internal_logical_device()
         .destroy_graphics_pipeline(self.pipeline);
     }
   }

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

@@ -85,7 +85,7 @@ impl<RenderBackend: gfx_hal::Backend> Surface<RenderBackend> {
     swapchain: Swapchain,
     timeout_in_nanoseconds: u64,
   ) -> Result<(), &'surface str> {
-    let device = super::gpu::internal::logical_device_for(gpu);
+    let device = gpu.internal_logical_device();
     self.extent = Some(swapchain.config.extent);
 
     unsafe {

lambda/examples/push_constants.rs

@@ -2,6 +2,7 @@ use lambda::{
   core::{
     component::Component,
     render::{
+      buffer::BufferBuilder,
       command::RenderCommand,
       mesh::MeshBuilder,
       pipeline::RenderPipelineBuilder,
@@ -10,7 +11,11 @@ use lambda::{
         Shader,
         ShaderBuilder,
       },
-      vertex::VertexBuilder,
+      vertex::{
+        VertexAttribute,
+        VertexBuilder,
+        VertexElement,
+      },
       viewport,
       ResourceId,
     },
@@ -24,7 +29,10 @@ use lambda::{
   runtimes::GenericRuntimeBuilder,
 };
 use lambda_platform::{
-  gfx::pipeline::PipelineStage,
+  gfx::{
+    pipeline::PipelineStage,
+    surface::ColorFormat,
+  },
   shaderc::{
     ShaderKind,
     VirtualShader,
@@ -82,14 +90,8 @@ impl Component for PushConstantsExample {
     &mut self,
     render_context: &mut lambda::core::render::RenderContext,
   ) {
-    let render_pass = RenderPassBuilder::new().build(&render_context);
+    let render_pass = RenderPassBuilder::new().build(render_context);
     let push_constant_size = std::mem::size_of::<PushConstant>() as u32;
-    let pipeline = RenderPipelineBuilder::new()
-      .with_push_constant(PipelineStage::VERTEX, push_constant_size)
-      .build(render_context, &render_pass, &self.shader, None);
-
-    self.render_pass = Some(render_context.attach_render_pass(render_pass));
-    self.render_pipeline = Some(render_context.attach_pipeline(pipeline));
 
     // Create triangle mesh.
     let vertices = [
@@ -114,6 +116,39 @@ impl Component for PushConstantsExample {
     vertices.iter().for_each(|vertex| {
       mesh_builder.with_vertex(vertex.clone());
     });
+
+    let mesh = mesh_builder
+      .with_attributes(vec![
+        VertexAttribute {
+          location: 0,
+          offset: 0,
+          element: VertexElement {
+            format: ColorFormat::Rgb32Sfloat,
+            offset: 0,
+          },
+        },
+        VertexAttribute {
+          location: 1,
+          offset: 0,
+          element: VertexElement {
+            format: ColorFormat::Rgb32Sfloat,
+            offset: 12,
+          },
+        },
+      ])
+      .build();
+
+    let pipeline = RenderPipelineBuilder::new()
+      .with_push_constant(PipelineStage::VERTEX, push_constant_size)
+      .with_buffer(
+        BufferBuilder::build_from_mesh(&mesh, render_context)
+          .expect("Failed to create buffer"),
+        mesh.attributes().to_vec(),
+      )
+      .build(render_context, &render_pass, &self.shader, None);
+
+    self.render_pass = Some(render_context.attach_render_pass(render_pass));
+    self.render_pipeline = Some(render_context.attach_pipeline(pipeline));
   }
 
   fn on_detach(

lambda/src/core/render/buffer.rs

@@ -15,7 +15,7 @@ pub use lambda_platform::gfx::buffer::{
 };
 
 use super::{
-  internal::mut_gpu_from_context,
+  mesh::Mesh,
   RenderContext,
 };
 
@@ -25,6 +25,16 @@ pub struct Buffer {
   buffer_type: BufferType,
 }
 
+/// Public interface for a buffer.
+impl Buffer {
+  /// Destroy the buffer and all it's resources with the render context that
+  /// created it.
+  pub fn destroy(self, render_context: &RenderContext) {
+    self.buffer.destroy(render_context.internal_gpu());
+  }
+}
+
+/// Internal interface for working with buffers.
 impl Buffer {
   /// Retrieve a reference to the internal buffer.
   pub(super) fn internal_buffer(
@@ -50,6 +60,34 @@ impl BufferBuilder {
     };
   }
 
+  pub fn build_from_mesh(
+    mesh: &Mesh,
+    render_context: &mut RenderContext,
+  ) -> Result<Buffer, &'static str> {
+    let mut buffer_builder = Self::new();
+    let internal_buffer = buffer_builder
+      .buffer_builder
+      .with_length(mesh.vertices().len())
+      .with_usage(Usage::VERTEX)
+      .with_properties(Properties::CPU_VISIBLE | Properties::COHERENT)
+      .build(
+        render_context.internal_mutable_gpu(),
+        mesh.vertices().to_vec(),
+      );
+
+    match internal_buffer {
+      Ok(internal_buffer) => {
+        return Ok(Buffer {
+          buffer: internal_buffer,
+          buffer_type: BufferType::Vertex,
+        });
+      }
+      Err(_) => {
+        return Err("Failed to create buffer from mesh.");
+      }
+    }
+  }
+
   /// Sets the length of the buffer (In bytes).
   pub fn with_length(&mut self, size: usize) -> &mut Self {
     self.buffer_builder.with_length(size);
@@ -83,7 +121,7 @@ impl BufferBuilder {
   ) -> Result<Buffer, &'static str> {
     let buffer_allocation = self
       .buffer_builder
-      .build(&mut mut_gpu_from_context(render_context), data);
+      .build(render_context.internal_mutable_gpu(), data);
 
     match buffer_allocation {
       Ok(buffer) => {

lambda/src/core/render/mesh.rs

@@ -1,11 +1,8 @@
 use super::{
-  buffer::{
-    Buffer,
-    BufferBuilder,
-    Properties,
-    Usage,
+  vertex::{
+    Vertex,
+    VertexAttribute,
   },
-  vertex::Vertex,
   RenderContext,
 };
 
@@ -15,12 +12,16 @@ use super::{
 #[derive(Debug)]
 pub struct Mesh {
   vertices: Vec<Vertex>,
-  buffer: Buffer,
+  attributes: Vec<VertexAttribute>,
 }
 
 impl Mesh {
-  pub(super) fn buffer(&self) -> &Buffer {
-    return &self.buffer;
+  pub fn vertices(&self) -> &[Vertex] {
+    &self.vertices
+  }
+
+  pub fn attributes(&self) -> &[VertexAttribute] {
+    &self.attributes
   }
 }
 
@@ -31,13 +32,15 @@ impl Mesh {
 pub struct MeshBuilder {
   capacity: usize,
   vertices: Vec<Vertex>,
+  attributes: Vec<VertexAttribute>,
 }
 
 impl MeshBuilder {
   pub fn new() -> Self {
     return Self {
       capacity: 0,
-      vertices: vec![],
+      vertices: Vec::new(),
+      attributes: Vec::new(),
     };
   }
 
@@ -51,37 +54,21 @@ impl MeshBuilder {
     return self;
   }
 
+  pub fn with_attributes(
+    &mut self,
+    attributes: Vec<VertexAttribute>,
+  ) -> &mut Self {
+    self.attributes = attributes;
+    return self;
+  }
+
   /// Builds a mesh from the vertices and indices that have been added to the
   /// builder and allocates the memory for the mesh on the GPU.
-  pub fn build(
-    &self,
-    render_context: &mut RenderContext,
-  ) -> Result<Mesh, &'static str> {
-    let gpu_memory_required =
-      self.vertices.len() * std::mem::size_of::<Vertex>();
-    println!(
-      "Allocating {} bytes of GPU memory for mesh.",
-      gpu_memory_required
-    );
-
-    // Allocate memory for the mesh on the GPU.
-    let buffer_allocation = BufferBuilder::new()
-      .with_length(gpu_memory_required)
-      .with_usage(Usage::VERTEX)
-      .with_properties(Properties::CPU_VISIBLE | Properties::COHERENT)
-      .build(render_context, self.vertices.clone());
-
-    match buffer_allocation {
-      Ok(buffer) => {
-        return Ok(Mesh {
-          vertices: self.vertices.clone(),
-          buffer,
-        });
-      }
-      Err(error) => {
-        return Err(error);
-      }
-    }
+  pub fn build(&self) -> Mesh {
+    return Mesh {
+      vertices: self.vertices.clone(),
+      attributes: self.attributes.clone(),
+    };
   }
 }
 
@@ -93,8 +80,4 @@ mod tests {
 
     assert_eq!(mesh.vertices.len(), 0);
   }
-
-  // TODO(vmarcella): Add more tests for mesh building once the render context
-  // is mockable. As of right now, testing would require the creation of a real
-  // render context to perform the GPU memory allocation & binding for the mesh.
 }