[update] pipeline so that the fragment shader is optional, add render commands & push constant implementation for the new demo.

vmarcella · vmarcella · commit 3018d8c95d88 · 2023-01-14T23:29:56.000-08:00
diff --git a/crates/lambda-platform/src/gfx/pipeline.rs b/crates/lambda-platform/src/gfx/pipeline.rs
@@ -85,7 +85,7 @@ impl<RenderBackend: internal::Backend> RenderPipelineBuilder<RenderBackend> {
     gpu: &Gpu<RenderBackend>,
     render_pass: &super::render_pass::RenderPass<RenderBackend>,
     vertex_shader: &ShaderModule<RenderBackend>,
-    fragment_shader: &ShaderModule<RenderBackend>,
+    fragment_shader: Option<&ShaderModule<RenderBackend>>,
   ) -> RenderPipeline<RenderBackend> {
     // TODO(vmarcella): The pipeline layout should be configurable through the
     // RenderPipelineBuilder.
@@ -104,10 +104,13 @@ impl<RenderBackend: internal::Backend> RenderPipelineBuilder<RenderBackend> {
     let primitive_assembler =
       super::assembler::PrimitiveAssemblerBuilder::new().build(vertex_shader);
 
-    let fragment_entry = internal::EntryPoint {
-      entry: fragment_shader.entry(),
-      module: super::internal::module_for(fragment_shader),
-      specialization: fragment_shader.specializations().clone(),
+    let fragment_entry = match fragment_shader {
+      Some(shader) => Some(internal::EntryPoint::<RenderBackend> {
+        entry: "main",
+        module: super::internal::module_for(shader),
+        specialization: gfx_hal::pso::Specialization::default(),
+      }),
+      None => None,
     };
 
     let mut pipeline_desc = internal::GraphicsPipelineDesc::new(
@@ -116,7 +119,7 @@ impl<RenderBackend: internal::Backend> RenderPipelineBuilder<RenderBackend> {
         cull_face: internal::Face::BACK,
         ..internal::Rasterizer::FILL
       },
-      Some(fragment_entry),
+      fragment_entry,
       &pipeline_layout,
       internal::Subpass {
         index: 0,
diff --git a/lambda/examples/push_constants.rs b/lambda/examples/push_constants.rs
@@ -1,12 +1,41 @@
 use lambda::{
   core::{
     component::Component,
-    render::shader,
+    render::{
+      command::RenderCommand,
+      pipeline::{
+        RenderPipeline,
+        RenderPipelineBuilder,
+      },
+      render_pass::{
+        RenderPass,
+        RenderPassBuilder,
+      },
+      shader::{
+        Shader,
+        ShaderBuilder,
+      },
+      viewport,
+      ResourceId,
+    },
     runtime::start_runtime,
   },
-  math,
+  math::{
+    matrix::{
+      self,
+      Matrix,
+    },
+    vector::Vector,
+  },
   runtimes::GenericRuntimeBuilder,
 };
+use lambda_platform::{
+  gfx::pipeline::PipelineStage,
+  shaderc::{
+    ShaderKind,
+    VirtualShader,
+  },
+};
 
 const VERTEX_SHADER_SOURCE: &str = r#"
 #version 450
@@ -29,14 +58,44 @@ void main() {
 
 "#;
 
-struct PushConstantsExample {}
+#[repr(C)]
+#[derive(Debug, Clone, Copy)]
+pub struct PushConstant {
+  data: [f32; 4],
+  render_matrix: [[f32; 4]; 4],
+}
+
+pub struct PushConstantsExample {
+  frame_number: u64,
+  shader: Shader,
+  render_pipeline: Option<ResourceId>,
+  render_pass: Option<ResourceId>,
+}
+
+pub fn push_constants_to_bytes(push_constants: &PushConstant) -> &[u32] {
+  let bytes = unsafe {
+    let size_in_bytes = std::mem::size_of::<PushConstant>();
+    let size_in_u32 = size_in_bytes / std::mem::size_of::<u32>();
+    let ptr = push_constants as *const PushConstant as *const u32;
+    std::slice::from_raw_parts(ptr, size_in_u32)
+  };
+
+  return bytes;
+}
 
 impl Component for PushConstantsExample {
   fn on_attach(
     &mut self,
     render_context: &mut lambda::core::render::RenderContext,
   ) {
-    todo!()
+    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));
   }
 
   fn on_detach(
@@ -50,28 +109,94 @@ impl Component for PushConstantsExample {
     todo!()
   }
 
+  /// Update the frame number every frame.
   fn on_update(&mut self, last_frame: &std::time::Duration) {
-    todo!()
+    self.frame_number += 1;
   }
 
   fn on_render(
     &mut self,
     render_context: &mut lambda::core::render::RenderContext,
   ) -> Vec<lambda::core::render::command::RenderCommand> {
-    use math::vector::Vector;
     let mut camera = [0.0, 0.0, -2.0];
-    let view: [[f32; 4]; 4] = math::matrix::translation_matrix(camera);
+    let view: [[f32; 4]; 4] = matrix::translation_matrix(camera);
+
+    // Create a projection matrix.
     let mut projection: [[f32; 4]; 4] =
-      math::matrix::perspective_matrix(1.0 / 2.0, 1700.0 / 900.0, 0.1, 200.0);
+      matrix::perspective_matrix(1.0 / 2.0, 1700.0 / 900.0, 0.1, 200.0);
     projection.as_mut()[1].as_mut()[1] *= -1.0;
 
-    todo!()
+    // Rotate model.
+    let model: [[f32; 4]; 4] = matrix::rotate_matrix(
+      matrix::filled_matrix(4, 4, 1.0),
+      [0.0, 1.0, 0.0],
+      0.4 * 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 render_pipeline = self
+      .render_pipeline
+      .expect("No render pipeline actively set for rendering.");
+
+    let mut commands = vec![
+      RenderCommand::SetViewports {
+        start_at: 0,
+        viewports: vec![viewport.clone()],
+      },
+      RenderCommand::SetScissors {
+        start_at: 0,
+        viewports: vec![viewport.clone()],
+      },
+      RenderCommand::SetPipeline {
+        pipeline: render_pipeline.clone(),
+      },
+      RenderCommand::BeginRenderPass {
+        render_pass: self
+          .render_pass
+          .expect("Cannot begin the render pass when it doesn't exist.")
+          .clone(),
+        viewport: viewport.clone(),
+      },
+      RenderCommand::PushConstants {
+        pipeline: render_pipeline.clone(),
+        stage: PipelineStage::VERTEX,
+        offset: 0,
+        bytes: Vec::from(push_constants_to_bytes(&PushConstant {
+          data: [0.0, 0.0, 0.0, 0.0],
+          render_matrix: mesh_matrix,
+        })),
+      },
+      RenderCommand::Draw { vertices: 0..3 },
+    ];
+    commands.push(RenderCommand::EndRenderPass);
+
+    return commands;
   }
 }
 
 impl Default for PushConstantsExample {
   fn default() -> Self {
-    return Self {};
+    let triangle_in_3d = VirtualShader::Source {
+      source: VERTEX_SHADER_SOURCE.to_string(),
+      kind: ShaderKind::Vertex,
+      entry_point: "main".to_string(),
+      name: "push_constants".to_string(),
+    };
+
+    let mut builder = ShaderBuilder::new();
+    let shader = builder.build(triangle_in_3d);
+
+    return Self {
+      frame_number: 0,
+      shader,
+      render_pipeline: None,
+      render_pass: None,
+    };
   }
 }
 
diff --git a/lambda/src/core/render/pipeline.rs b/lambda/src/core/render/pipeline.rs
@@ -69,19 +69,22 @@ impl RenderPipelineBuilder {
     render_context: &mut RenderContext,
     render_pass: &super::render_pass::RenderPass,
     vertex_shader: &Shader,
-    fragment_shader: &Shader,
+    fragment_shader: Option<&Shader>,
   ) -> RenderPipeline {
     let vertex_shader_module = ShaderModuleBuilder::new().build(
       mut_gpu_from_context(render_context),
       &vertex_shader.as_binary(),
       ShaderModuleType::Vertex,
     );
 
-    let fragment_shader_module = ShaderModuleBuilder::new().build(
-      mut_gpu_from_context(render_context),
-      &fragment_shader.as_binary(),
-      ShaderModuleType::Fragment,
-    );
+    let fragment_shader_module = match fragment_shader {
+      Some(shader) => Some(ShaderModuleBuilder::new().build(
+        mut_gpu_from_context(render_context),
+        &shader.as_binary(),
+        ShaderModuleType::Fragment,
+      )),
+      None => None,
+    };
 
     let render_pipeline =
       lambda_platform::gfx::pipeline::RenderPipelineBuilder::new()
@@ -90,11 +93,14 @@ impl RenderPipelineBuilder {
           gpu_from_context(render_context),
           &platform_render_pass_from_render_pass(render_pass),
           &vertex_shader_module,
-          &fragment_shader_module,
+          fragment_shader_module.as_ref(),
         );
 
+    // Clean up shader modules.
     vertex_shader_module.destroy(mut_gpu_from_context(render_context));
-    fragment_shader_module.destroy(mut_gpu_from_context(render_context));
+    if let Some(fragment_shader_module) = fragment_shader_module {
+      fragment_shader_module.destroy(mut_gpu_from_context(render_context));
+    }
 
     return RenderPipeline {
       pipeline: Rc::new(render_pipeline),
diff --git a/lambda/src/math/matrix.rs b/lambda/src/math/matrix.rs
@@ -2,10 +2,9 @@
 
 use lambda_platform::rand::get_uniformly_random_floats_between;
 
-use super::vector::Vector;
-use crate::{
-  assert_approximately_equal,
-  math::turns_to_radians,
+use super::{
+  turns_to_radians,
+  vector::Vector,
 };
 
 // -------------------------------- MATRIX -------------------------------------
@@ -183,6 +182,7 @@ pub fn perspective_matrix<
   return result;
 }
 
+/// Create a matrix of any size that is filled with zeros.
 pub fn zeroed_matrix<
   V: Vector<Scalar = f32>,
   MatrixLike: Matrix<V> + Default,
@@ -218,6 +218,7 @@ pub fn filled_matrix<
   return result;
 }
 
+/// Creates an identity matrix of the given size.
 pub fn identity_matrix<
   V: Vector<Scalar = f32>,
   MatrixLike: Matrix<V> + Default,
@@ -483,12 +484,15 @@ mod tests {
     assert_eq!(perspective, expected);
   }
 
+  /// Test the rotation matrix for a 3D rotation.
   #[test]
   fn rotate_matrices() {
-    let rotation_matrix: [[f32; 4]; 4] = filled_matrix(4, 4, 1.0);
-    let rotated_matrix = rotate_matrix(rotation_matrix, [0.0, 0.0, 1.0], 0.0);
-    assert_eq!(rotated_matrix, rotation_matrix);
+    // Test a zero turn rotation.
+    let matrix: [[f32; 4]; 4] = filled_matrix(4, 4, 1.0);
+    let rotated_matrix = rotate_matrix(matrix, [0.0, 0.0, 1.0], 0.0);
+    assert_eq!(rotated_matrix, matrix);
 
+    // Test a 90 degree rotation.
     let matrix = [
       [1.0, 2.0, 3.0, 4.0],
       [5.0, 6.0, 7.0, 8.0],
diff --git a/tools/lambda_rs_demo/src/main.rs b/tools/lambda_rs_demo/src/main.rs
@@ -26,7 +26,7 @@ use lambda::{
 };
 
 pub struct DemoComponent {
-  triangle_vertex: Shader,
+  fragment_shader: Shader,
   vertex_shader: Shader,
   render_pass_id: Option<lambda::core::render::ResourceId>,
   render_pipeline_id: Option<lambda::core::render::ResourceId>,
@@ -44,7 +44,7 @@ impl Component for DemoComponent {
       render_context,
       &render_pass,
       &self.vertex_shader,
-      &self.triangle_vertex,
+      Some(&self.fragment_shader),
     );
 
     // Attach the render pass and pipeline to the render context
@@ -176,7 +176,7 @@ impl Default for DemoComponent {
 
     return DemoComponent {
       vertex_shader: vs,
-      triangle_vertex: fs,
+      fragment_shader: fs,
       render_pass_id: None,
       render_pipeline_id: None,
       width: 800,
diff --git a/tools/triangles_demo/src/main.rs b/tools/triangles_demo/src/main.rs
@@ -51,7 +51,7 @@ impl Component for TrianglesComponent {
         render_context,
         &render_pass,
         &self.vertex_shader,
-        &self.triangle_vertex,
+        Some(&self.triangle_vertex),
       );
 
     self.render_pass = Some(render_context.attach_render_pass(render_pass));
