[fix] 3D demo to load the color to the correct location.

Author: vmarcella

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

@@ -47,6 +47,9 @@ impl PrimitiveAssemblerBuilder {
 
     match (buffers, attributes) {
       (Some(buffers), Some(attributes)) => {
+        println!(
+          "[DEBUG] Building primitive assembler with buffers and attributes"
+        );
         self.buffer_descriptions = buffers
           .iter()
           .map(|buffer| VertexBufferDesc {

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

@@ -109,6 +109,7 @@ impl BufferBuilder {
 
     // TODO(vmarcella): Add the ability for the user to specify the memory
     // properties (I.E. SparseFlags::SPARSE_MEMORY).
+    println!("[DEBUG] Creating buffer of length: {}", self.buffer_length);
     let buffer_result = unsafe {
       logical_device.create_buffer(
         self.buffer_length as u64,
@@ -127,6 +128,7 @@ impl BufferBuilder {
       unsafe { logical_device.get_buffer_requirements(&buffer) };
     let memory_types = physical_device.memory_properties().memory_types;
 
+    println!("[DEBUG] Buffer requirements: {:?}", requirements);
     // Find a memory type that supports the requirements of the buffer.
     let memory_type = memory_types
       .iter()
@@ -138,6 +140,7 @@ impl BufferBuilder {
       .map(|(id, _)| MemoryTypeId(id))
       .unwrap();
 
+    println!("Allocating memory for buffer.");
     // Allocates the memory on the GPU for the buffer.
     let buffer_memory_allocation =
       unsafe { logical_device.allocate_memory(memory_type, requirements.size) };

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

@@ -36,7 +36,10 @@ use std::ops::Range;
 use gfx_hal::device::Device;
 
 use super::{
-  assembler::VertexAttribute,
+  assembler::{
+    PrimitiveAssemblerBuilder,
+    VertexAttribute,
+  },
   buffer::Buffer,
   gpu::Gpu,
   shader::ShaderModule,
@@ -110,9 +113,8 @@ impl<RenderBackend: internal::Backend> RenderPipelineBuilder<RenderBackend> {
     let push_constants = self.push_constants.into_iter();
 
     let pipeline_layout = unsafe {
-      use internal::Device;
-
-      super::internal::logical_device_for(gpu)
+      gpu
+        .internal_logical_device()
         .create_pipeline_layout(vec![].into_iter(), push_constants)
         .expect(
           "The GPU does not have enough memory to allocate a pipeline layout",
@@ -121,15 +123,15 @@ impl<RenderBackend: internal::Backend> RenderPipelineBuilder<RenderBackend> {
 
     // TODO(vmarcella): The primitive assembler should be configurable through
     // the RenderPipelineBuilder so that buffers & attributes can be bound.
-    let mut builder = super::assembler::PrimitiveAssemblerBuilder::new();
+    let mut builder = PrimitiveAssemblerBuilder::new();
     let primitive_assembler =
       builder.build(vertex_shader, Some(buffers), Some(attributes));
 
     let fragment_entry = match fragment_shader {
       Some(shader) => Some(internal::EntryPoint::<RenderBackend> {
         entry: shader.entry(),
         module: super::internal::module_for(shader),
-        specialization: gfx_hal::pso::Specialization::default(),
+        specialization: shader.specializations().clone(),
       }),
       None => None,
     };
@@ -157,10 +159,14 @@ impl<RenderBackend: internal::Backend> RenderPipelineBuilder<RenderBackend> {
       });
 
     let pipeline = unsafe {
-      gpu
+      let pipeline_build_result = gpu
         .internal_logical_device()
-        .create_graphics_pipeline(&pipeline_desc, None)
-        .expect("Failed to create graphics pipeline")
+        .create_graphics_pipeline(&pipeline_desc, None);
+
+      match pipeline_build_result {
+        Ok(pipeline) => pipeline,
+        Err(e) => panic!("Failed to create graphics pipeline: {:?}", e),
+      }
     };
 
     return RenderPipeline {
@@ -182,7 +188,12 @@ pub struct RenderPipeline<RenderBackend: internal::Backend> {
 impl<RenderBackend: internal::Backend> RenderPipeline<RenderBackend> {
   /// Destroys the pipeline layout and graphical pipeline
   pub fn destroy(self, gpu: &super::gpu::Gpu<RenderBackend>) {
+    println!("Destroying render pipeline");
     unsafe {
+      for buffer in self.buffers {
+        buffer.destroy(gpu);
+      }
+
       gpu
         .internal_logical_device()
         .destroy_pipeline_layout(self.pipeline_layout);

lambda/examples/push_constants.rs

@@ -1,6 +1,7 @@
 use lambda::{
   core::{
     component::Component,
+    events::WindowEvent,
     render::{
       buffer::BufferBuilder,
       command::RenderCommand,
@@ -47,7 +48,7 @@ use lambda_platform::{
 const VERTEX_SHADER_SOURCE: &str = r#"
 #version 450
 
-layout (location = 0) in vec2 vertex_position;
+layout (location = 0) in vec3 vertex_position;
 layout (location = 1) in vec3 vertex_normal;
 layout (location = 2) in vec3 vertex_color;
 
@@ -59,7 +60,7 @@ layout ( push_constant ) uniform PushConstant {
 } push_constants;
 
 void main() {
-  gl_Position = push_constants.render_matrix * vec4(vertex_position, 0.0, 1.0);
+  gl_Position = push_constants.render_matrix * vec4(vertex_position, 1.0);
   frag_color = vertex_color;
 }
 
@@ -103,9 +104,13 @@ pub fn push_constants_to_bytes(push_constants: &PushConstant) -> &[u32] {
 pub struct PushConstantsExample {
   frame_number: u64,
   shader: Shader,
+  fs: Shader,
   mesh: Option<Mesh>,
   render_pipeline: Option<ResourceId>,
   render_pass: Option<ResourceId>,
+  last_frame: std::time::Duration,
+  width: u32,
+  height: u32,
 }
 
 impl Component for PushConstantsExample {
@@ -119,17 +124,17 @@ impl Component for PushConstantsExample {
     // Create triangle mesh.
     let vertices = [
       VertexBuilder::new()
-        .with_position([0.0, 0.5, 0.0])
+        .with_position([1.0, 1.0, 0.0])
         .with_normal([0.0, 0.0, 0.0])
         .with_color([1.0, 0.0, 0.0])
         .build(),
       VertexBuilder::new()
-        .with_position([-0.5, -0.5, 0.0])
+        .with_position([-1.0, 1.0, 0.0])
         .with_normal([0.0, 0.0, 0.0])
         .with_color([0.0, 1.0, 0.0])
         .build(),
       VertexBuilder::new()
-        .with_position([0.5, -0.5, 0.0])
+        .with_position([0.0, -1.0, 0.0])
         .with_normal([0.0, 0.0, 0.0])
         .with_color([0.0, 0.0, 1.0])
         .build(),
@@ -151,24 +156,26 @@ impl Component for PushConstantsExample {
           },
         },
         VertexAttribute {
-          location: 1,
+          location: 2,
           offset: 0,
           element: VertexElement {
             format: ColorFormat::Rgb32Sfloat,
-            offset: 12,
+            offset: 24,
           },
         },
       ])
       .build();
 
+    println!("mesh: {:?}", mesh);
+
     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);
+      .build(render_context, &render_pass, &self.shader, Some(&self.fs));
 
     self.render_pass = Some(render_context.attach_render_pass(render_pass));
     self.render_pipeline = Some(render_context.attach_pipeline(pipeline));
@@ -183,11 +190,26 @@ impl Component for PushConstantsExample {
   }
 
   fn on_event(&mut self, event: lambda::core::events::Events) {
-    println!("Event: {:?}", event);
+    match event {
+      lambda::core::events::Events::Window { event, issued_at } => {
+        match event {
+          WindowEvent::Resize { width, height } => {
+            self.width = width;
+            self.height = height;
+            println!("Window resized to {}x{}", width, height);
+          }
+          _ => {}
+        }
+      }
+      _ => {}
+    }
   }
 
   /// Update the frame number every frame.
-  fn on_update(&mut self, last_frame: &std::time::Duration) {}
+  fn on_update(&mut self, last_frame: &std::time::Duration) {
+    self.last_frame = *last_frame;
+    self.frame_number += 1;
+  }
 
   fn on_render(
     &mut self,
@@ -198,22 +220,26 @@ impl Component for PushConstantsExample {
     let view: [[f32; 4]; 4] = matrix::translation_matrix(camera);
 
     // Create a projection matrix.
-    let mut projection: [[f32; 4]; 4] =
-      matrix::perspective_matrix(0.25, 1700.0 / 900.0, 0.1, 200.0);
-    projection.as_mut()[1].as_mut()[1] *= -1.0;
+    let mut projection: [[f32; 4]; 4] = matrix::perspective_matrix(
+      0.25,
+      (self.width / self.height) as f32,
+      0.1,
+      200.0,
+    );
 
     // Rotate model.
     let model: [[f32; 4]; 4] = matrix::rotate_matrix(
-      matrix::filled_matrix(4, 4, 1.0),
+      matrix::identity_matrix(4, 4),
       [0.0, 1.0, 0.0],
-      0.4 * self.frame_number as f32,
+      0.001 * self.frame_number as f32,
     );
 
     // Create render matrix.
     let mesh_matrix = projection.multiply(&view).multiply(&model);
 
     // Create viewport.
-    let viewport = viewport::ViewportBuilder::new().build(800, 600);
+    let viewport =
+      viewport::ViewportBuilder::new().build(self.width, self.height);
 
     let render_pipeline = self
       .render_pipeline
@@ -271,15 +297,27 @@ impl Default for PushConstantsExample {
       name: "push_constants".to_string(),
     };
 
+    let triangle_fragment_shader = VirtualShader::Source {
+      source: FRAGMENT_SHADER_SOURCE.to_string(),
+      kind: ShaderKind::Fragment,
+      entry_point: "main".to_string(),
+      name: "push_constants".to_string(),
+    };
+
     let mut builder = ShaderBuilder::new();
     let shader = builder.build(triangle_in_3d);
+    let fs = builder.build(triangle_fragment_shader);
 
     return Self {
       frame_number: 0,
       shader,
+      fs,
+      last_frame: std::time::Duration::from_secs(0),
       mesh: None,
       render_pipeline: None,
       render_pass: None,
+      width: 800,
+      height: 600,
     };
   }
 }
@@ -291,6 +329,9 @@ fn main() {
         .with_dimensions(800, 600)
         .with_name("3D Push Constants Example");
     })
+    .with_renderer_configured_as(|renderer_builder| {
+      return renderer_builder.with_render_timeout(1_000_000_000);
+    })
     .with_component(move |runtime, triangles: PushConstantsExample| {
       return (runtime, triangles);
     })

lambda/src/core/render/buffer.rs

@@ -18,6 +18,7 @@ pub use lambda_platform::gfx::buffer::{
 
 use super::{
   mesh::Mesh,
+  vertex::Vertex,
   RenderContext,
 };
 
@@ -77,7 +78,7 @@ impl BufferBuilder {
     let mut buffer_builder = Self::new();
     let internal_buffer = buffer_builder
       .buffer_builder
-      .with_length(mesh.vertices().len())
+      .with_length(mesh.vertices().len() * std::mem::size_of::<Vertex>())
       .with_usage(Usage::VERTEX)
       .with_properties(Properties::CPU_VISIBLE)
       .build(

lambda/src/core/render/pipeline.rs

@@ -108,12 +108,21 @@ impl RenderPipelineBuilder {
     vertex_shader: &Shader,
     fragment_shader: Option<&Shader>,
   ) -> RenderPipeline {
+    println!("[DEBUG] Building render pipeline...");
+
+    print!("[DEBUG] Building vertex shader... ");
     let vertex_shader_module = ShaderModuleBuilder::new().build(
       render_context.internal_mutable_gpu(),
       &vertex_shader.as_binary(),
       ShaderModuleType::Vertex,
     );
 
+    println!(
+      " Done. (Vertex shader: {} bytes)",
+      vertex_shader.as_binary().len()
+    );
+
+    print!("[DEBUG] Building fragment shader... ");
     let fragment_shader_module = match fragment_shader {
       Some(shader) => Some(ShaderModuleBuilder::new().build(
         render_context.internal_mutable_gpu(),
@@ -123,6 +132,11 @@ impl RenderPipelineBuilder {
       None => None,
     };
 
+    println!(
+      " Done. (Fragment shader: {} bytes)",
+      fragment_shader.map(|s| s.as_binary().len()).unwrap_or(0)
+    );
+
     let builder = lambda_platform::gfx::pipeline::RenderPipelineBuilder::new();
 
     let buffers = self.buffers;

lambda/src/runtimes/mod.rs

@@ -312,6 +312,7 @@ impl Runtime for GenericRuntime {
 
       match mapped_event {
         Some(event) => {
+          println!("Sending event: {:?} to all components", event);
           for component in &mut component_stack {
             component.on_event(event.clone());
           }