[add] more unit tests for buffer and render pass abstraction.

Author: vmarcella

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

@@ -343,6 +343,117 @@ impl Frame {
   }
 }
 
+// ---------------------- Command Encoding Abstractions -----------------------
+
+#[derive(Debug)]
+/// Thin wrapper around `wgpu::CommandEncoder` with convenience helpers.
+pub struct CommandEncoder {
+  raw: wgpu::CommandEncoder,
+}
+
+impl CommandEncoder {
+  /// Create a new command encoder with an optional label.
+  pub fn new(device: &wgpu::Device, label: Option<&str>) -> Self {
+    let raw =
+      device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label });
+    return Self { raw };
+  }
+
+  /// Begin a render pass targeting a single color attachment with the provided
+  /// load/store operations. Depth/stencil is not attached by this helper.
+  pub fn begin_render_pass<'view>(
+    &'view mut self,
+    label: Option<&str>,
+    view: &'view wgpu::TextureView,
+    ops: wgpu::Operations<wgpu::Color>,
+  ) -> RenderPass<'view> {
+    let color_attachment = wgpu::RenderPassColorAttachment {
+      view,
+      resolve_target: None,
+      depth_slice: None,
+      ops,
+    };
+    let color_attachments = [Some(color_attachment)];
+    let pass = self.raw.begin_render_pass(&wgpu::RenderPassDescriptor {
+      label,
+      color_attachments: &color_attachments,
+      depth_stencil_attachment: None,
+      timestamp_writes: None,
+      occlusion_query_set: None,
+    });
+    return RenderPass { raw: pass };
+  }
+
+  /// Finish recording and return the command buffer.
+  pub fn finish(self) -> wgpu::CommandBuffer {
+    return self.raw.finish();
+  }
+}
+
+#[derive(Debug)]
+/// Wrapper around `wgpu::RenderPass<'_>` exposing the operations needed by the
+/// Lambda renderer without leaking raw `wgpu` types at the call sites.
+pub struct RenderPass<'a> {
+  raw: wgpu::RenderPass<'a>,
+}
+
+impl<'a> RenderPass<'a> {
+  /// Set the active render pipeline.
+  pub fn set_pipeline(&mut self, pipeline: &wgpu::RenderPipeline) {
+    self.raw.set_pipeline(pipeline);
+  }
+
+  /// Apply viewport state.
+  pub fn set_viewport(
+    &mut self,
+    x: f32,
+    y: f32,
+    width: f32,
+    height: f32,
+    min_depth: f32,
+    max_depth: f32,
+  ) {
+    self
+      .raw
+      .set_viewport(x, y, width, height, min_depth, max_depth);
+  }
+
+  /// Apply scissor rectangle.
+  pub fn set_scissor_rect(&mut self, x: u32, y: u32, width: u32, height: u32) {
+    self.raw.set_scissor_rect(x, y, width, height);
+  }
+
+  /// Bind a group with optional dynamic offsets.
+  pub fn set_bind_group(
+    &mut self,
+    set: u32,
+    group: &wgpu::BindGroup,
+    dynamic_offsets: &[u32],
+  ) {
+    self.raw.set_bind_group(set, group, dynamic_offsets);
+  }
+
+  /// Bind a vertex buffer slot.
+  pub fn set_vertex_buffer(&mut self, slot: u32, buffer: &wgpu::Buffer) {
+    self.raw.set_vertex_buffer(slot, buffer.slice(..));
+  }
+
+  /// Upload push constants.
+  pub fn set_push_constants(
+    &mut self,
+    stages: wgpu::ShaderStages,
+    offset: u32,
+    data: &[u8],
+  ) {
+    self.raw.set_push_constants(stages, offset, data);
+  }
+
+  /// Issue a non-indexed draw over a vertex range.
+  pub fn draw(&mut self, vertices: std::ops::Range<u32>) {
+    self.raw.draw(vertices, 0..1);
+  }
+}
+
 #[derive(Debug, Clone)]
 /// Builder for a `Gpu` (adapter, device, queue) with feature validation.
 pub struct GpuBuilder {

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

@@ -239,15 +239,7 @@ impl BufferBuilder {
     data: Vec<Data>,
   ) -> Result<Buffer, &'static str> {
     let element_size = std::mem::size_of::<Data>();
-    let buffer_length = if self.buffer_length == 0 {
-      element_size * data.len()
-    } else {
-      self.buffer_length
-    };
-
-    if buffer_length == 0 {
-      return Err("Attempted to create a buffer with zero length.");
-    }
+    let buffer_length = self.resolve_length(element_size, data.len())?;
 
     // SAFETY: Converting data to bytes is safe because it's underlying
     // type, Data, is constrianed to Copy and the lifetime of the slice does
@@ -290,3 +282,51 @@ impl BufferBuilder {
       .build(render_context, mesh.vertices().to_vec());
   }
 }
+
+impl BufferBuilder {
+  /// Resolve the effective buffer length from explicit size or data length.
+  /// Returns an error if the resulting length would be zero.
+  pub(crate) fn resolve_length(
+    &self,
+    element_size: usize,
+    data_len: usize,
+  ) -> Result<usize, &'static str> {
+    let buffer_length = if self.buffer_length == 0 {
+      element_size * data_len
+    } else {
+      self.buffer_length
+    };
+    if buffer_length == 0 {
+      return Err("Attempted to create a buffer with zero length.");
+    }
+    return Ok(buffer_length);
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn resolve_length_rejects_zero() {
+    let builder = BufferBuilder::new();
+    let result = builder.resolve_length(std::mem::size_of::<u32>(), 0);
+    assert!(result.is_err());
+  }
+
+  #[test]
+  fn label_is_recorded_on_builder() {
+    let mut builder = BufferBuilder::new();
+    builder.with_label("buffer-test");
+    // Indirect check via building a small buffer would require a device; ensure
+    // the label setter stores the value locally instead.
+    // Access through an internal helper to avoid exposing label publicly.
+    #[allow(clippy::redundant_closure_call)]
+    {
+      // Create a small closure to read the private label field.
+      // The test module shares the parent scope, so it can access fields.
+      let read = |b: &BufferBuilder| b.label.as_deref();
+      assert_eq!(read(&builder), Some("buffer-test"));
+    }
+  }
+}

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

@@ -19,6 +19,7 @@ use std::iter;
 
 use lambda_platform::wgpu::{
   types as wgpu,
+  CommandEncoder as PlatformCommandEncoder,
   Gpu,
   GpuBuilder,
   Instance,
@@ -251,12 +252,10 @@ impl RenderContext {
     };
 
     let view = frame.texture_view();
-    let mut encoder =
-      self
-        .device()
-        .create_command_encoder(&wgpu::CommandEncoderDescriptor {
-          label: Some("lambda-render-command-encoder"),
-        });
+    let mut encoder = PlatformCommandEncoder::new(
+      self.device(),
+      Some("lambda-render-command-encoder"),
+    );
 
     let mut command_iter = commands.into_iter();
     while let Some(command) = command_iter.next() {
@@ -271,21 +270,8 @@ impl RenderContext {
             ))
           })?;
 
-          let color_attachment = wgpu::RenderPassColorAttachment {
-            view,
-            depth_slice: None,
-            resolve_target: None,
-            ops: pass.color_ops(),
-          };
-          let color_attachments = [Some(color_attachment)];
           let mut pass_encoder =
-            encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-              label: pass.label(),
-              color_attachments: &color_attachments,
-              depth_stencil_attachment: None,
-              timestamp_writes: None,
-              occlusion_query_set: None,
-            });
+            encoder.begin_render_pass(pass.label(), view, pass.color_ops());
 
           self.encode_pass(&mut pass_encoder, viewport, &mut command_iter)?;
         }
@@ -306,7 +292,7 @@ impl RenderContext {
   /// Encode a single render pass and consume commands until `EndRenderPass`.
   fn encode_pass<I>(
     &mut self,
-    pass: &mut wgpu::RenderPass<'_>,
+    pass: &mut lambda_platform::wgpu::RenderPass<'_>,
     initial_viewport: viewport::Viewport,
     commands: &mut I,
   ) -> Result<(), RenderError>
@@ -372,7 +358,7 @@ impl RenderContext {
               ));
             })?;
 
-          pass.set_vertex_buffer(buffer as u32, buffer_ref.raw().slice(..));
+          pass.set_vertex_buffer(buffer as u32, buffer_ref.raw());
         }
         RenderCommand::PushConstants {
           pipeline,
@@ -394,7 +380,7 @@ impl RenderContext {
           pass.set_push_constants(stage.to_wgpu(), offset, slice);
         }
         RenderCommand::Draw { vertices } => {
-          pass.draw(vertices, 0..1);
+          pass.draw(vertices);
         }
         RenderCommand::BeginRenderPass { .. } => {
           return Err(RenderError::Configuration(
@@ -411,7 +397,7 @@ impl RenderContext {
 
   /// Apply both viewport and scissor state to the active pass.
   fn apply_viewport(
-    pass: &mut wgpu::RenderPass<'_>,
+    pass: &mut lambda_platform::wgpu::RenderPass<'_>,
     viewport: &viewport::Viewport,
   ) {
     let (x, y, width, height, min_depth, max_depth) = viewport.viewport_f32();