[add] ubo validation, add tests, and update render context impl.

Author: vmarcella

crates/lambda-rs/src/render/bind.rs

@@ -70,24 +70,38 @@ mod tests {
 /// Bind group layout used when creating pipelines and bind groups.
 pub struct BindGroupLayout {
   layout: Rc<lambda_platform::wgpu::bind::BindGroupLayout>,
+  /// Total number of dynamic bindings declared in this layout.
+  dynamic_binding_count: u32,
 }
 
 impl BindGroupLayout {
   pub(crate) fn raw(&self) -> &wgpu::BindGroupLayout {
     self.layout.raw()
   }
+
+  /// Number of dynamic bindings declared in this layout.
+  pub fn dynamic_binding_count(&self) -> u32 {
+    self.dynamic_binding_count
+  }
 }
 
 #[derive(Debug, Clone)]
 /// Bind group that binds one or more resources to a pipeline set index.
 pub struct BindGroup {
   group: Rc<lambda_platform::wgpu::bind::BindGroup>,
+  /// Cached number of dynamic bindings expected when binding this group.
+  dynamic_binding_count: u32,
 }
 
 impl BindGroup {
   pub(crate) fn raw(&self) -> &wgpu::BindGroup {
     self.group.raw()
   }
+
+  /// Number of dynamic bindings expected when calling set_bind_group.
+  pub fn dynamic_binding_count(&self) -> u32 {
+    self.dynamic_binding_count
+  }
 }
 
 /// Builder for creating a bind group layout with uniform buffer bindings.
@@ -135,6 +149,8 @@ impl BindGroupLayoutBuilder {
   pub fn build(self, render_context: &RenderContext) -> BindGroupLayout {
     let mut platform =
       lambda_platform::wgpu::bind::BindGroupLayoutBuilder::new();
+    let dynamic_binding_count =
+      self.entries.iter().filter(|(_, _, d)| *d).count() as u32;
     if let Some(label) = &self.label {
       platform = platform.with_label(label);
     }
@@ -148,6 +164,7 @@ impl BindGroupLayoutBuilder {
     let layout = platform.build(render_context.device());
     BindGroupLayout {
       layout: Rc::new(layout),
+      dynamic_binding_count,
     }
   }
 }
@@ -203,12 +220,23 @@ impl<'a> BindGroupBuilder<'a> {
     if let Some(label) = &self.label {
       platform = platform.with_label(label);
     }
+    let max_binding = render_context.limit_max_uniform_buffer_binding_size();
     for (binding, buffer, offset, size) in self.entries.into_iter() {
+      if let Some(sz) = size {
+        assert!(
+          sz.get() <= max_binding,
+          "Uniform binding at binding={} requests size={} > device limit {}",
+          binding,
+          sz.get(),
+          max_binding
+        );
+      }
       platform = platform.with_uniform(binding, buffer.raw(), offset, size);
     }
     let group = platform.build(render_context.device());
     BindGroup {
       group: Rc::new(group),
+      dynamic_binding_count: layout.dynamic_binding_count(),
     }
   }
 }

crates/lambda-rs/src/render/buffer.rs

@@ -138,6 +138,48 @@ impl Buffer {
   }
 }
 
+/// Strongly‑typed uniform buffer wrapper for ergonomics and safety.
+///
+/// Stores a single value of type `T` and provides a convenience method to
+/// upload updates to the GPU. The underlying buffer has `UNIFORM` usage and
+/// is CPU‑visible by default for easy updates via `Queue::write_buffer`.
+pub struct UniformBuffer<T> {
+  inner: Buffer,
+  _phantom: core::marker::PhantomData<T>,
+}
+
+impl<T: Copy> UniformBuffer<T> {
+  /// Create a new uniform buffer initialized with `initial`.
+  pub fn new(
+    render_context: &mut RenderContext,
+    initial: &T,
+    label: Option<&str>,
+  ) -> Result<Self, &'static str> {
+    let mut builder = BufferBuilder::new();
+    builder.with_length(core::mem::size_of::<T>());
+    builder.with_usage(Usage::UNIFORM);
+    builder.with_properties(Properties::CPU_VISIBLE);
+    if let Some(l) = label {
+      builder.with_label(l);
+    }
+    let inner = builder.build(render_context, vec![*initial])?;
+    Ok(Self {
+      inner,
+      _phantom: core::marker::PhantomData,
+    })
+  }
+
+  /// Borrow the underlying generic `Buffer` for binding.
+  pub fn raw(&self) -> &Buffer {
+    &self.inner
+  }
+
+  /// Write a new value to the GPU buffer at offset 0.
+  pub fn write(&self, render_context: &RenderContext, value: &T) {
+    self.inner.write_value(render_context, 0, value);
+  }
+}
+
 /// Builder for creating `Buffer` objects with explicit usage and properties.
 ///
 /// A buffer is a block of memory the GPU can access. You supply a total byte

crates/lambda-rs/src/render/mod.rs

@@ -10,6 +10,7 @@ pub mod pipeline;
 pub mod render_pass;
 pub mod scene_math;
 pub mod shader;
+pub mod validation;
 pub mod vertex;
 pub mod viewport;
 pub mod window;
@@ -213,6 +214,21 @@ impl RenderContext {
     self.config.format
   }
 
+  /// Device limit: maximum bytes that can be bound for a single uniform buffer binding.
+  pub fn limit_max_uniform_buffer_binding_size(&self) -> u64 {
+    self.gpu.limits().max_uniform_buffer_binding_size.into()
+  }
+
+  /// Device limit: number of bind groups that can be used by a pipeline layout.
+  pub fn limit_max_bind_groups(&self) -> u32 {
+    self.gpu.limits().max_bind_groups
+  }
+
+  /// Device limit: required alignment in bytes for dynamic uniform buffer offsets.
+  pub fn limit_min_uniform_buffer_offset_alignment(&self) -> u32 {
+    self.gpu.limits().min_uniform_buffer_offset_alignment
+  }
+
   /// Encode and submit GPU work for a single frame.
   fn render_internal(
     &mut self,
@@ -328,6 +344,14 @@ impl RenderContext {
           let group_ref = self.bind_groups.get(group).ok_or_else(|| {
             RenderError::Configuration(format!("Unknown bind group {group}"))
           })?;
+          // Validate dynamic offsets count and alignment before binding.
+          validation::validate_dynamic_offsets(
+            group_ref.dynamic_binding_count(),
+            &dynamic_offsets,
+            self.limit_min_uniform_buffer_offset_alignment(),
+            set,
+          )
+          .map_err(RenderError::Configuration)?;
           pass.set_bind_group(set, group_ref.raw(), &dynamic_offsets);
         }
         RenderCommand::BindVertexBuffer { pipeline, buffer } => {

crates/lambda-rs/src/render/pipeline.rs

@@ -200,6 +200,14 @@ impl RenderPipelineBuilder {
       })
       .collect();
 
+    let max_bind_groups = render_context.limit_max_bind_groups() as usize;
+    assert!(
+      self.bind_group_layouts.len() <= max_bind_groups,
+      "Pipeline declares {} bind group layouts, exceeds device max {}",
+      self.bind_group_layouts.len(),
+      max_bind_groups
+    );
+
     let bind_group_layout_refs: Vec<&wgpu::BindGroupLayout> = self
       .bind_group_layouts
       .iter()

crates/lambda-rs/src/render/validation.rs

@@ -0,0 +1,76 @@
+//! Small helpers for limits and alignment validation used by the renderer.
+
+/// Align `value` up to the nearest multiple of `align`.
+/// If `align` is zero, returns `value` unchanged.
+pub fn align_up(value: u64, align: u64) -> u64 {
+  if align == 0 {
+    return value;
+  }
+  let mask = align - 1;
+  (value + mask) & !mask
+}
+
+/// Validate a set of dynamic offsets against the required count and alignment.
+/// Returns `Ok(())` when valid; otherwise a human‑readable error message.
+pub fn validate_dynamic_offsets(
+  required_count: u32,
+  offsets: &[u32],
+  alignment: u32,
+  set_index: u32,
+) -> Result<(), String> {
+  if offsets.len() as u32 != required_count {
+    return Err(format!(
+      "Bind group at set {} expects {} dynamic offsets, got {}",
+      set_index,
+      required_count,
+      offsets.len()
+    ));
+  }
+  let align = alignment.max(1);
+  for (i, off) in offsets.iter().enumerate() {
+    if (*off as u32) % align != 0 {
+      return Err(format!(
+        "Dynamic offset[{}]={} is not {}-byte aligned",
+        i, off, align
+      ));
+    }
+  }
+  Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn align_up_noop_on_zero_align() {
+    assert_eq!(align_up(13, 0), 13);
+  }
+
+  #[test]
+  fn align_up_rounds_to_multiple() {
+    assert_eq!(align_up(0, 256), 0);
+    assert_eq!(align_up(1, 256), 256);
+    assert_eq!(align_up(255, 256), 256);
+    assert_eq!(align_up(256, 256), 256);
+    assert_eq!(align_up(257, 256), 512);
+  }
+
+  #[test]
+  fn validate_dynamic_offsets_count_and_alignment() {
+    // Correct count and alignment
+    assert!(validate_dynamic_offsets(2, &[0, 256], 256, 0).is_ok());
+
+    // Wrong count
+    let err = validate_dynamic_offsets(3, &[0, 256], 256, 1)
+      .err()
+      .unwrap();
+    assert!(err.contains("expects 3 dynamic offsets"));
+
+    // Misaligned
+    let err = validate_dynamic_offsets(2, &[0, 128], 256, 0)
+      .err()
+      .unwrap();
+    assert!(err.contains("not 256-byte aligned"));
+  }
+}