[add] uniform buffer objects, bind groups, and scene math helpers for simplifying camera code.

Author: vmarcella

crates/lambda-rs-platform/src/wgpu/bind.rs

@@ -0,0 +1,207 @@
+//! Bind group and bind group layout builders for the platform layer.
+//!
+//! These types provide a thin, explicit wrapper around `wgpu` bind resources
+//! so higher layers can compose layouts and groups without pulling in raw
+//! `wgpu` descriptors throughout the codebase.
+
+use std::num::NonZeroU64;
+
+use crate::wgpu::types as wgpu;
+
+#[derive(Debug)]
+/// Wrapper around `wgpu::BindGroupLayout` that preserves a label.
+pub struct BindGroupLayout {
+  pub(crate) raw: wgpu::BindGroupLayout,
+  pub(crate) label: Option<String>,
+}
+
+impl BindGroupLayout {
+  /// Borrow the underlying `wgpu::BindGroupLayout`.
+  pub fn raw(&self) -> &wgpu::BindGroupLayout {
+    &self.raw
+  }
+
+  /// Optional debug label used during creation.
+  pub fn label(&self) -> Option<&str> {
+    self.label.as_deref()
+  }
+}
+
+#[derive(Debug)]
+/// Wrapper around `wgpu::BindGroup` that preserves a label.
+pub struct BindGroup {
+  pub(crate) raw: wgpu::BindGroup,
+  pub(crate) label: Option<String>,
+}
+
+impl BindGroup {
+  /// Borrow the underlying `wgpu::BindGroup`.
+  pub fn raw(&self) -> &wgpu::BindGroup {
+    &self.raw
+  }
+
+  /// Optional debug label used during creation.
+  pub fn label(&self) -> Option<&str> {
+    self.label.as_deref()
+  }
+}
+
+#[derive(Clone, Copy, Debug)]
+/// Visibility of a binding across shader stages.
+pub enum Visibility {
+  Vertex,
+  Fragment,
+  Compute,
+  VertexAndFragment,
+  All,
+}
+
+impl Visibility {
+  fn to_wgpu(self) -> wgpu::ShaderStages {
+    match self {
+      Visibility::Vertex => wgpu::ShaderStages::VERTEX,
+      Visibility::Fragment => wgpu::ShaderStages::FRAGMENT,
+      Visibility::Compute => wgpu::ShaderStages::COMPUTE,
+      Visibility::VertexAndFragment => {
+        wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT
+      }
+      Visibility::All => wgpu::ShaderStages::all(),
+    }
+  }
+}
+
+#[derive(Default)]
+/// Builder for creating a `wgpu::BindGroupLayout`.
+pub struct BindGroupLayoutBuilder {
+  label: Option<String>,
+  entries: Vec<wgpu::BindGroupLayoutEntry>,
+}
+
+impl BindGroupLayoutBuilder {
+  /// Create a builder with no entries.
+  pub fn new() -> Self {
+    Self {
+      label: None,
+      entries: Vec::new(),
+    }
+  }
+
+  /// Attach a human‑readable label.
+  pub fn with_label(mut self, label: &str) -> Self {
+    self.label = Some(label.to_string());
+    self
+  }
+
+  /// Declare a uniform buffer binding at the provided index.
+  pub fn with_uniform(mut self, binding: u32, visibility: Visibility) -> Self {
+    self.entries.push(wgpu::BindGroupLayoutEntry {
+      binding,
+      visibility: visibility.to_wgpu(),
+      ty: wgpu::BindingType::Buffer {
+        ty: wgpu::BufferBindingType::Uniform,
+        has_dynamic_offset: false,
+        min_binding_size: None,
+      },
+      count: None,
+    });
+    self
+  }
+
+  /// Declare a uniform buffer binding with dynamic offsets at the provided index.
+  pub fn with_uniform_dynamic(
+    mut self,
+    binding: u32,
+    visibility: Visibility,
+  ) -> Self {
+    self.entries.push(wgpu::BindGroupLayoutEntry {
+      binding,
+      visibility: visibility.to_wgpu(),
+      ty: wgpu::BindingType::Buffer {
+        ty: wgpu::BufferBindingType::Uniform,
+        has_dynamic_offset: true,
+        min_binding_size: None,
+      },
+      count: None,
+    });
+    self
+  }
+
+  /// Build the layout using the provided device.
+  pub fn build(self, device: &wgpu::Device) -> BindGroupLayout {
+    let raw =
+      device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+        label: self.label.as_deref(),
+        entries: &self.entries,
+      });
+    BindGroupLayout {
+      raw,
+      label: self.label,
+    }
+  }
+}
+
+#[derive(Default)]
+/// Builder for creating a `wgpu::BindGroup`.
+pub struct BindGroupBuilder<'a> {
+  label: Option<String>,
+  layout: Option<&'a wgpu::BindGroupLayout>,
+  entries: Vec<wgpu::BindGroupEntry<'a>>,
+}
+
+impl<'a> BindGroupBuilder<'a> {
+  /// Create a new builder with no layout or entries.
+  pub fn new() -> Self {
+    Self {
+      label: None,
+      layout: None,
+      entries: Vec::new(),
+    }
+  }
+
+  /// Attach a human‑readable label.
+  pub fn with_label(mut self, label: &str) -> Self {
+    self.label = Some(label.to_string());
+    self
+  }
+
+  /// Specify the layout to use for this bind group.
+  pub fn with_layout(mut self, layout: &'a BindGroupLayout) -> Self {
+    self.layout = Some(layout.raw());
+    self
+  }
+
+  /// Bind a uniform buffer at a binding index with optional size slice.
+  pub fn with_uniform(
+    mut self,
+    binding: u32,
+    buffer: &'a wgpu::Buffer,
+    offset: u64,
+    size: Option<NonZeroU64>,
+  ) -> Self {
+    self.entries.push(wgpu::BindGroupEntry {
+      binding,
+      resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
+        buffer,
+        offset,
+        size,
+      }),
+    });
+    self
+  }
+
+  /// Build the bind group with the accumulated entries.
+  pub fn build(self, device: &wgpu::Device) -> BindGroup {
+    let layout = self
+      .layout
+      .expect("BindGroupBuilder requires a layout before build");
+    let raw = device.create_bind_group(&wgpu::BindGroupDescriptor {
+      label: self.label.as_deref(),
+      layout,
+      entries: &self.entries,
+    });
+    BindGroup {
+      raw,
+      label: self.label,
+    }
+  }
+}

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

@@ -15,6 +15,8 @@ use wgpu::rwh::{
 
 use crate::winit::WindowHandle;
 
+pub mod bind;
+
 #[derive(Debug, Clone)]
 /// Builder for creating a `wgpu::Instance` with consistent defaults.
 ///

crates/lambda-rs/examples/push_constants.rs

@@ -21,6 +21,10 @@ use lambda::{
       RenderPipelineBuilder,
     },
     render_pass::RenderPassBuilder,
+    scene_math::{
+      compute_model_view_projection_matrix_about_pivot,
+      SimpleCamera,
+    },
     shader::{
       Shader,
       ShaderBuilder,
@@ -100,23 +104,7 @@ pub fn push_constants_to_bytes(push_constants: &PushConstant) -> &[u32] {
   return bytes;
 }
 
-fn make_transform(
-  translate: [f32; 3],
-  angle: f32,
-  scale: f32,
-) -> [[f32; 4]; 4] {
-  let c = angle.cos() * scale;
-  let s = angle.sin() * scale;
-
-  let [x, y, z] = translate;
-
-  return [
-    [c, 0.0, s, 0.0],
-    [0.0, scale, 0.0, 0.0],
-    [-s, 0.0, c, 0.0],
-    [x, y, z, 1.0],
-  ];
-}
+// Model, view, and projection matrix computations are handled by `scene_math`.
 
 // --------------------------------- COMPONENT ---------------------------------
 
@@ -196,6 +184,7 @@ impl Component<ComponentResult, String> for PushConstantsExample {
     logging::trace!("mesh: {:?}", mesh);
 
     let pipeline = RenderPipelineBuilder::new()
+      .with_culling(lambda::render::pipeline::CullingMode::None)
       .with_push_constant(PipelineStage::VERTEX, push_constant_size)
       .with_buffer(
         BufferBuilder::build_from_mesh(&mesh, render_context)
@@ -253,25 +242,23 @@ impl Component<ComponentResult, String> for PushConstantsExample {
     render_context: &mut lambda::render::RenderContext,
   ) -> Vec<lambda::render::command::RenderCommand> {
     self.frame_number += 1;
-    let camera = [0.0, 0.0, -2.0];
-    let view: [[f32; 4]; 4] = matrix::translation_matrix(camera);
-
-    // Create a projection matrix.
-    let projection: [[f32; 4]; 4] =
-      matrix::perspective_matrix(0.25, (4 / 3) as f32, 0.1, 100.0);
-
-    // Rotate model.
-    let model: [[f32; 4]; 4] = matrix::rotate_matrix(
-      matrix::identity_matrix(4, 4),
+    let camera = SimpleCamera {
+      position: [0.0, 0.0, 3.0],
+      field_of_view_in_turns: 0.25,
+      near_clipping_plane: 0.1,
+      far_clipping_plane: 100.0,
+    };
+    let mesh_matrix = compute_model_view_projection_matrix_about_pivot(
+      &camera,
+      self.width.max(1),
+      self.height.max(1),
+      [0.0, -1.0 / 3.0, 0.0],
       [0.0, 1.0, 0.0],
       0.001 * self.frame_number as f32,
+      0.5,
+      [0.0, 1.0 / 3.0, 0.0],
     );
 
-    // Create render matrix.
-    let mesh_matrix = projection.multiply(&view).multiply(&model);
-    let mesh_matrix =
-      make_transform([0.0, 0.0, 0.5], self.frame_number as f32 * 0.01, 0.5);
-
     // Create viewport.
     let viewport =
       viewport::ViewportBuilder::new().build(self.width, self.height);
@@ -309,7 +296,8 @@ impl Component<ComponentResult, String> for PushConstantsExample {
         offset: 0,
         bytes: Vec::from(push_constants_to_bytes(&PushConstant {
           data: [0.0, 0.0, 0.0, 0.0],
-          render_matrix: mesh_matrix,
+          // Transpose to match GPU's column‑major expectation.
+          render_matrix: mesh_matrix.transpose(),
         })),
       },
       RenderCommand::Draw {