[add] some polish to the API.

Author: vmarcella

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

@@ -121,7 +121,7 @@ pub struct Buffer {
 }
 
 impl Buffer {
-  /// Destroy the buffer and all it's resources with the render context that
+  /// Destroy the buffer and all its resources with the render context that
   /// created it. Dropping the buffer will release GPU resources.
   pub fn destroy(self, _render_context: &RenderContext) {}
 
@@ -294,8 +294,8 @@ impl BufferBuilder {
     let element_size = std::mem::size_of::<Data>();
     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
+    // SAFETY: Converting data to bytes is safe because its underlying
+    // type, Data, is constrained to Copy and the lifetime of the slice does
     // not outlive data.
     let bytes = unsafe {
       std::slice::from_raw_parts(

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

@@ -43,7 +43,6 @@ impl Mesh {
 /// Builder for constructing a `Mesh` from vertices and attributes.
 #[derive(Clone, Debug)]
 pub struct MeshBuilder {
-  capacity: usize,
   vertices: Vec<Vertex>,
   attributes: Vec<VertexAttribute>,
 }
@@ -52,7 +51,6 @@ impl MeshBuilder {
   /// Creates a new mesh builder.
   pub fn new() -> Self {
     return Self {
-      capacity: 0,
       vertices: Vec::new(),
       attributes: Vec::new(),
     };
@@ -61,7 +59,6 @@ impl MeshBuilder {
   /// Allocates memory for the given number of vertices and fills
   /// the mesh with empty vertices.
   pub fn with_capacity(&mut self, size: usize) -> &mut Self {
-    self.capacity = size;
     self.vertices.resize(
       size,
       Vertex {

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

@@ -161,13 +161,13 @@ impl RenderPipelineBuilder {
     // Shader modules
     let vertex_module = platform_pipeline::ShaderModule::from_spirv(
       render_context.gpu(),
-      &vertex_shader.as_binary(),
+      vertex_shader.binary(),
       Some("lambda-vertex-shader"),
     );
     let fragment_module = fragment_shader.map(|shader| {
       platform_pipeline::ShaderModule::from_spirv(
         render_context.gpu(),
-        &shader.as_binary(),
+        shader.binary(),
         Some("lambda-fragment-shader"),
       )
     });

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

@@ -10,6 +10,17 @@ use crate::math::{
   matrix::Matrix,
 };
 
+/// Build a 4x4 uniform scaling matrix with `uniform_scale` on the diagonal
+/// and `1.0` in the homogeneous component.
+fn scaling_matrix(uniform_scale: f32) -> [[f32; 4]; 4] {
+  return [
+    [uniform_scale, 0.0, 0.0, 0.0],
+    [0.0, uniform_scale, 0.0, 0.0],
+    [0.0, 0.0, uniform_scale, 0.0],
+    [0.0, 0.0, 0.0, 1.0],
+  ];
+}
+
 /// Convert OpenGL-style normalized device coordinates (Z in [-1, 1]) to
 /// wgpu/Vulkan/Direct3D normalized device coordinates (Z in [0, 1]).
 ///
@@ -48,17 +59,7 @@ pub fn compute_model_matrix(
   let mut model: [[f32; 4]; 4] = matrix::identity_matrix(4, 4);
   // Apply rotation first, then scaling via a diagonal matrix, and finally translation.
   model = matrix::rotate_matrix(model, rotation_axis, angle_in_turns);
-
-  let mut scaled: [[f32; 4]; 4] = [[0.0; 4]; 4];
-  for i in 0..4 {
-    for j in 0..4 {
-      if i == j {
-        scaled[i][j] = if i == 3 { 1.0 } else { uniform_scale };
-      } else {
-        scaled[i][j] = 0.0;
-      }
-    }
-  }
+  let scaled = scaling_matrix(uniform_scale);
   model = model.multiply(&scaled);
 
   let translation_matrix: [[f32; 4]; 4] =

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

@@ -62,7 +62,19 @@ pub struct Shader {
 }
 
 impl Shader {
-  /// Returns a copy of the SPIR-V binary representation of the shader.
+  /// Borrow the SPIR‑V binary representation of the shader as a word slice.
+  ///
+  /// Prefer this accessor to avoid unnecessary allocations when passing the
+  /// shader to pipeline builders. Use `as_binary` when an owned buffer is
+  /// explicitly required.
+  pub fn binary(&self) -> &[u32] {
+    return &self.binary;
+  }
+
+  /// Returns a copy of the SPIR‑V binary representation of the shader.
+  ///
+  /// Retained for compatibility with existing code that expects an owned
+  /// `Vec<u32>`. Prefer `binary()` for zero‑copy borrowing.
   pub fn as_binary(&self) -> Vec<u32> {
     return self.binary.clone();
   }

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

@@ -52,6 +52,7 @@ impl WindowBuilder {
   /// surface in `RenderContextBuilder`. This flag is reserved to influence
   /// that choice and is currently a no‑op.
   pub fn with_vsync(mut self, vsync: bool) -> Self {
+    self.vsync = vsync;
     return self;
   }