Improvements to rendering & event processing

crates/lambda-platform/Cargo.toml

@@ -12,6 +12,7 @@ gfx-hal = "=0.9.0"
 winit = "=0.27.5"
 shaderc = "=0.7"
 cfg-if = "=1.0.0"
+rand = "=0.8.5"
 
 # GFX-RS backends
 gfx-backend-gl = { version="=0.9.0", optional = true }
@@ -33,6 +34,10 @@ gfx-with-metal=["dep:gfx-backend-metal"]
 gfx-with-dx11=["dep:gfx-backend-dx11"]
 gfx-with-dx12=["dep:gfx-backend-dx12"]
 
+[profile.dev]
+crate-type = ["cdylib", "rlib"]
+incremental = true
+
 [target.'cfg(all(unix, not(target_os = "macos")))'.dependencies.gfx-platform-backend]
 package = "gfx-backend-gl"
 version = "=0.9.0"

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

@@ -14,6 +14,5 @@ cfg_if::cfg_if! {
     pub use gfx_backend_dx12 as RenderingAPI;
   } else if #[cfg(feature = "detect-platform")] {
       pub use gfx_platform_backend as RenderingAPI;
-  } else {
-  }
+  } else {}
 }

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

@@ -1,25 +1,81 @@
 //! Primitive assembly for the graphics pipeline.
 
-use gfx_hal::pso;
+pub use gfx_hal::pso::Element as VertexElement;
+use gfx_hal::pso::{
+  self,
+  AttributeDesc,
+  VertexBufferDesc,
+};
+
+use super::{
+  buffer::Buffer,
+  surface::ColorFormat,
+};
+
+/// Attributes for a vertex.
+#[derive(Debug, Clone)]
+pub struct VertexAttribute {
+  pub location: u32,
+  pub offset: u32,
+  pub element: VertexElement<ColorFormat>,
+}
 
 /// PrimitiveAssemblerBuilder for preparing PrimitiveAssemblers to use in the
 /// lambda-platform Rendering pipeline.
-pub struct PrimitiveAssemblerBuilder {}
+pub struct PrimitiveAssemblerBuilder {
+  buffer_descriptions: Vec<VertexBufferDesc>,
+  attribute_descriptions: Vec<AttributeDesc>,
+}
 
 impl PrimitiveAssemblerBuilder {
   pub fn new() -> Self {
-    return Self {};
+    return Self {
+      buffer_descriptions: Vec::new(),
+      attribute_descriptions: Vec::new(),
+    };
   }
 
   /// Build a primitive assembler given the lambda-platform vertex shader
-  /// module.
+  /// module. Buffers & attributes do not have to be tied to
   pub fn build<'shader, RenderBackend: gfx_hal::Backend>(
-    self,
+    &'shader mut self,
     vertex_shader: &'shader super::shader::ShaderModule<RenderBackend>,
+    buffers: Option<&Vec<&Buffer<RenderBackend>>>,
+    attributes: Option<&[VertexAttribute]>,
   ) -> PrimitiveAssembler<'shader, RenderBackend> {
+    let binding = self.buffer_descriptions.len() as u32;
+
+    match (buffers, attributes) {
+      (Some(buffers), Some(attributes)) => {
+        println!(
+          "[DEBUG] Building primitive assembler with buffers and attributes"
+        );
+        self.buffer_descriptions = buffers
+          .iter()
+          .map(|buffer| VertexBufferDesc {
+            binding,
+            stride: buffer.stride() as u32,
+            rate: pso::VertexInputRate::Vertex,
+          })
+          .collect();
+
+        self.attribute_descriptions = attributes
+          .iter()
+          .map(|attribute| {
+            return AttributeDesc {
+              location: attribute.location,
+              binding,
+              element: attribute.element,
+            };
+          })
+          .collect();
+      }
+      _ => {}
+    }
+
     let primitive_assembler = pso::PrimitiveAssemblerDesc::Vertex {
-      buffers: &[],
-      attributes: &[],
+      buffers: self.buffer_descriptions.as_slice(),
+      attributes: self.attribute_descriptions.as_slice(),
       input_assembler: pso::InputAssemblerDesc::new(
         pso::Primitive::TriangleList,
       ),
@@ -52,7 +108,7 @@ impl<'shader, RenderBackend: gfx_hal::Backend>
 
 /// Internal functions for the primitive assembler. User applications most
 /// likely should not use these functions directly nor should they need to.
-pub mod internal {
+pub(crate) mod internal {
   #[inline]
   pub fn into_primitive_assembler<'shader, RenderBackend: gfx_hal::Backend>(
     primitive_assembler: super::PrimitiveAssembler<'shader, RenderBackend>,