[add] unit tests

Author: vmarcella

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

@@ -70,6 +70,30 @@ impl Visibility {
   }
 }
 
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  /// This test verifies that each public binding visibility option is
+  /// converted into the correct set of shader stage flags expected by the
+  /// underlying graphics layer. It checks single stage selections, a
+  /// combination of vertex and fragment stages, and the catch‑all option that
+  /// enables all stages. The goal is to demonstrate that the mapping logic is
+  /// precise and predictable so higher level code can rely on it when building
+  /// layouts and groups.
+  #[test]
+  fn visibility_maps_to_expected_shader_stages() {
+    assert_eq!(Visibility::Vertex.to_wgpu(), wgpu::ShaderStages::VERTEX);
+    assert_eq!(Visibility::Fragment.to_wgpu(), wgpu::ShaderStages::FRAGMENT);
+    assert_eq!(Visibility::Compute.to_wgpu(), wgpu::ShaderStages::COMPUTE);
+    assert_eq!(
+      Visibility::VertexAndFragment.to_wgpu(),
+      wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT
+    );
+    assert_eq!(Visibility::All.to_wgpu(), wgpu::ShaderStages::all());
+  }
+}
+
 #[derive(Default)]
 /// Builder for creating a `wgpu::BindGroupLayout`.
 pub struct BindGroupLayoutBuilder {

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

@@ -36,6 +36,36 @@ impl BindingVisibility {
   }
 }
 
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  /// This test confirms that every high‑level binding visibility option maps
+  /// directly to the corresponding visibility option in the platform layer.
+  /// Matching these values ensures that builder code in this module forwards
+  /// intent without alteration, which is important for readability and for
+  /// maintenance when constructing layouts and groups.
+  #[test]
+  fn binding_visibility_maps_to_platform_enum() {
+    use lambda_platform::wgpu::bind::Visibility as P;
+
+    assert!(matches!(BindingVisibility::Vertex.to_platform(), P::Vertex));
+    assert!(matches!(
+      BindingVisibility::Fragment.to_platform(),
+      P::Fragment
+    ));
+    assert!(matches!(
+      BindingVisibility::Compute.to_platform(),
+      P::Compute
+    ));
+    assert!(matches!(
+      BindingVisibility::VertexAndFragment.to_platform(),
+      P::VertexAndFragment
+    ));
+    assert!(matches!(BindingVisibility::All.to_platform(), P::All));
+  }
+}
+
 #[derive(Debug, Clone)]
 /// Bind group layout used when creating pipelines and bind groups.
 pub struct BindGroupLayout {

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

@@ -198,3 +198,258 @@ pub fn compute_model_view_projection_matrix_about_pivot(
   );
   projection.multiply(&view).multiply(&model)
 }
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::math::matrix as m;
+
+  /// This test demonstrates the complete order of operations used to produce a
+  /// model matrix. It rotates a base identity matrix by a chosen axis and
+  /// angle, applies a uniform scale using a diagonal scaling matrix, and then
+  /// applies a world translation. The expected matrix is built step by step in
+  /// the same manner so that individual differences are easy to reason about
+  /// when reading a failure. Every element is compared using a small tolerance
+  /// to account for floating point rounding.
+  #[test]
+  fn model_matrix_composes_rotation_scale_and_translation() {
+    let translation = [3.0, -2.0, 5.0];
+    let axis = [0.0, 1.0, 0.0];
+    let angle_in_turns = 0.25; // quarter turn
+    let scale = 2.0;
+
+    // Compute via the public function under test.
+    let actual = compute_model_matrix(translation, axis, angle_in_turns, scale);
+
+    // Build the expected matrix explicitly: R, then S, then T.
+    let mut expected: [[f32; 4]; 4] = m::identity_matrix(4, 4);
+    expected = m::rotate_matrix(expected, axis, angle_in_turns);
+
+    let mut s: [[f32; 4]; 4] = [[0.0; 4]; 4];
+    for i in 0..4 {
+      for j in 0..4 {
+        s[i][j] = if i == j {
+          if i == 3 {
+            1.0
+          } else {
+            scale
+          }
+        } else {
+          0.0
+        };
+      }
+    }
+    expected = expected.multiply(&s);
+
+    let t: [[f32; 4]; 4] = m::translation_matrix(translation);
+    let expected = t.multiply(&expected);
+
+    for i in 0..4 {
+      for j in 0..4 {
+        crate::assert_approximately_equal!(
+          actual.at(i, j),
+          expected.at(i, j),
+          1e-5
+        );
+      }
+    }
+  }
+
+  /// This test verifies that rotating and scaling around a local pivot point
+  /// produces the same result as translating into the pivot, applying the base
+  /// transform, and translating back out, followed by the world translation.
+  /// It constructs both forms and checks that all elements match within a
+  /// small tolerance.
+  #[test]
+  fn model_matrix_respects_local_pivot() {
+    let translation = [1.0, 2.0, 3.0];
+    let axis = [1.0, 0.0, 0.0];
+    let angle_in_turns = 0.125; // one eighth of a full turn
+    let scale = 0.5;
+    let pivot = [10.0, -4.0, 2.0];
+
+    let actual = compute_model_matrix_about_pivot(
+      translation,
+      axis,
+      angle_in_turns,
+      scale,
+      pivot,
+    );
+
+    let base =
+      compute_model_matrix([0.0, 0.0, 0.0], axis, angle_in_turns, scale);
+    let to_pivot: [[f32; 4]; 4] = m::translation_matrix(pivot);
+    let from_pivot: [[f32; 4]; 4] =
+      m::translation_matrix([-pivot[0], -pivot[1], -pivot[2]]);
+    let world: [[f32; 4]; 4] = m::translation_matrix(translation);
+    let expected = world
+      .multiply(&to_pivot)
+      .multiply(&base)
+      .multiply(&from_pivot);
+
+    for i in 0..4 {
+      for j in 0..4 {
+        crate::assert_approximately_equal!(
+          actual.at(i, j),
+          expected.at(i, j),
+          1e-5
+        );
+      }
+    }
+  }
+
+  /// This test confirms that the view computation is the inverse of a camera
+  /// translation. For a camera expressed only as a world space translation, the
+  /// inverse is a translation by the negated vector. The test constructs that
+  /// expected matrix directly and compares it to the function result.
+  #[test]
+  fn view_matrix_is_inverse_translation() {
+    let camera_position = [7.0, -3.0, 2.5];
+    let expected: [[f32; 4]; 4] = m::translation_matrix([
+      -camera_position[0],
+      -camera_position[1],
+      -camera_position[2],
+    ]);
+    let actual = compute_view_matrix(camera_position);
+    assert_eq!(actual, expected);
+  }
+
+  /// This test validates that the perspective projection matches an
+  /// OpenGL‑style projection that is converted into the normalized device
+  /// coordinate range used by the target platforms. The expected conversion is
+  /// performed by multiplying a fixed conversion matrix with the projection
+  /// produced by the existing matrix helper. The result is compared element by
+  /// element within a small tolerance.
+  #[test]
+  fn perspective_projection_matches_converted_reference() {
+    let fov_turns = 0.25;
+    let width = 1280;
+    let height = 720;
+    let near = 0.1;
+    let far = 100.0;
+
+    let actual =
+      compute_perspective_projection(fov_turns, width, height, near, far);
+
+    let aspect = width as f32 / height as f32;
+    let projection_gl: [[f32; 4]; 4] =
+      m::perspective_matrix(fov_turns, aspect, near, far);
+    let conversion = [
+      [1.0, 0.0, 0.0, 0.0],
+      [0.0, 1.0, 0.0, 0.0],
+      [0.0, 0.0, 0.5, 0.0],
+      [0.0, 0.0, 0.5, 1.0],
+    ];
+    let expected = conversion.multiply(&projection_gl);
+
+    for i in 0..4 {
+      for j in 0..4 {
+        crate::assert_approximately_equal!(
+          actual.at(i, j),
+          expected.at(i, j),
+          1e-5
+        );
+      }
+    }
+  }
+
+  /// This test builds a full model, view, and projection composition using both
+  /// the public helper and a reference expression that multiplies the same
+  /// parts in the same order. It uses a simple camera and a non‑trivial model
+  /// transform to provide coverage for the code paths. Results are compared
+  /// with a small tolerance to account for floating point rounding.
+  #[test]
+  fn model_view_projection_composition_matches_reference() {
+    let camera = SimpleCamera {
+      position: [0.5, -1.0, 2.0],
+      field_of_view_in_turns: 0.3,
+      near_clipping_plane: 0.01,
+      far_clipping_plane: 500.0,
+    };
+    let (w, h) = (1024, 600);
+    let model_t = [2.0, 0.5, -3.0];
+    let axis = [0.0, 0.0, 1.0];
+    let angle = 0.2;
+    let scale = 1.25;
+
+    let actual = compute_model_view_projection_matrix(
+      &camera, w, h, model_t, axis, angle, scale,
+    );
+
+    let model = compute_model_matrix(model_t, axis, angle, scale);
+    let view = compute_view_matrix(camera.position);
+    let proj = compute_perspective_projection(
+      camera.field_of_view_in_turns,
+      w,
+      h,
+      camera.near_clipping_plane,
+      camera.far_clipping_plane,
+    );
+    let expected = proj.multiply(&view).multiply(&model);
+
+    for i in 0..4 {
+      for j in 0..4 {
+        crate::assert_approximately_equal!(
+          actual.at(i, j),
+          expected.at(i, j),
+          1e-5
+        );
+      }
+    }
+  }
+
+  /// This test builds a full model, view, and projection composition for a
+  /// model that rotates and scales around a local pivot point. It compares the
+  /// public helper result to a reference expression that expands the pivot
+  /// operations into individual translations and the base transform. Elements
+  /// are compared with a small tolerance to make the test robust to floating
+  /// point differences.
+  #[test]
+  fn model_view_projection_about_pivot_matches_reference() {
+    let camera = SimpleCamera {
+      position: [-3.0, 0.0, 1.0],
+      field_of_view_in_turns: 0.15,
+      near_clipping_plane: 0.1,
+      far_clipping_plane: 50.0,
+    };
+    let (w, h) = (800, 480);
+    let model_t = [0.0, -1.0, 2.0];
+    let axis = [0.0, 1.0, 0.0];
+    let angle = 0.4;
+    let scale = 0.75;
+    let pivot = [5.0, 0.0, -2.0];
+
+    let actual = compute_model_view_projection_matrix_about_pivot(
+      &camera, w, h, model_t, axis, angle, scale, pivot,
+    );
+
+    let base = compute_model_matrix([0.0, 0.0, 0.0], axis, angle, scale);
+    let to_pivot: [[f32; 4]; 4] = m::translation_matrix(pivot);
+    let from_pivot: [[f32; 4]; 4] =
+      m::translation_matrix([-pivot[0], -pivot[1], -pivot[2]]);
+    let world: [[f32; 4]; 4] = m::translation_matrix(model_t);
+    let model = world
+      .multiply(&to_pivot)
+      .multiply(&base)
+      .multiply(&from_pivot);
+    let view = compute_view_matrix(camera.position);
+    let proj = compute_perspective_projection(
+      camera.field_of_view_in_turns,
+      w,
+      h,
+      camera.near_clipping_plane,
+      camera.far_clipping_plane,
+    );
+    let expected = proj.multiply(&view).multiply(&model);
+
+    for i in 0..4 {
+      for j in 0..4 {
+        crate::assert_approximately_equal!(
+          actual.at(i, j),
+          expected.at(i, j),
+          1e-5
+        );
+      }
+    }
+  }
+}