@vib3code/sdk 2.0.1 → 2.0.3-canary.75a3290

package/cpp/tests/Geometry_test.cpp

@@ -0,0 +1,213 @@
+/**
+ * Geometry_test.cpp - Unit tests for geometry generation
+ *
+ * Tests that the geometry generator produces valid vertex data for all 24
+ * geometry indices (3 core types x 8 base geometries).
+ *
+ * Since the geometry library may not have a standalone header, we include
+ * the relevant source and math headers directly.
+ */
+
+#include <gtest/gtest.h>
+#include "math/Vec4.hpp"
+#include "math/Mat4x4.hpp"
+#include "math/Rotor4D.hpp"
+#include "math/Projection.hpp"
+
+// Forward-declare the public API from GeometryGenerator.cpp
+// (linked via vib3_geometry library in CMake)
+namespace vib3 {
+    std::vector<Vec4> generateGeometry(int geometryIndex, int resolution) noexcept;
+}
+
+using namespace vib3;
+
+// ============================================================================
+// Geometry Name Constants (mirror the 24-geometry encoding)
+// ============================================================================
+
+// geometry_index = core_type * 8 + base_geometry
+// core_type: 0=Base, 1=Hypersphere, 2=Hypertetrahedron
+// base_geometry: 0=Tetrahedron, 1=Hypercube, 2=Sphere, 3=Torus,
+//                4=KleinBottle, 5=Fractal, 6=Wave, 7=Crystal
+
+static constexpr int kTetrahedronBase = 0;
+static constexpr int kHypercubeBase = 1;
+static constexpr int kSphereBase = 2;
+static constexpr int kTorusBase = 3;
+static constexpr int kKleinBottleBase = 4;
+static constexpr int kFractalBase = 5;
+static constexpr int kWaveBase = 6;
+static constexpr int kCrystalBase = 7;
+
+static constexpr int kHypersphereOffset = 8;
+static constexpr int kHypertetraOffset = 16;
+
+static constexpr int kTotalGeometries = 24;
+
+/** Default subdivision resolution for tests. */
+static constexpr int kDefaultRes = 16;
+
+// ============================================================================
+// Tesseract (Hypercube) Vertex Count
+// ============================================================================
+
+TEST(Geometry, TesseractHas16Vertices) {
+    // A 4D hypercube (tesseract) has 2^4 = 16 vertices
+    // The vertices are all combinations of (+/-1, +/-1, +/-1, +/-1)
+    auto vertices = generateGeometry(kHypercubeBase, kDefaultRes);
+    EXPECT_GE(vertices.size(), 16u)
+        << "Tesseract should have at least 16 vertices";
+
+    // Verify that all vertices have valid (non-NaN, non-Inf) components
+    for (const auto& v : vertices) {
+        EXPECT_FALSE(std::isnan(v.x)) << "Vertex has NaN x component";
+        EXPECT_FALSE(std::isnan(v.y)) << "Vertex has NaN y component";
+        EXPECT_FALSE(std::isnan(v.z)) << "Vertex has NaN z component";
+        EXPECT_FALSE(std::isnan(v.w)) << "Vertex has NaN w component";
+        EXPECT_FALSE(std::isinf(v.x)) << "Vertex has Inf x component";
+        EXPECT_FALSE(std::isinf(v.y)) << "Vertex has Inf y component";
+        EXPECT_FALSE(std::isinf(v.z)) << "Vertex has Inf z component";
+        EXPECT_FALSE(std::isinf(v.w)) << "Vertex has Inf w component";
+    }
+}
+
+// ============================================================================
+// Tetrahedron Vertex Count
+// ============================================================================
+
+TEST(Geometry, TetrahedronHas4Vertices) {
+    // A tetrahedron has 4 vertices
+    auto vertices = generateGeometry(kTetrahedronBase, kDefaultRes);
+    EXPECT_GE(vertices.size(), 4u)
+        << "Tetrahedron should have at least 4 vertices";
+
+    for (const auto& v : vertices) {
+        EXPECT_FALSE(std::isnan(v.x));
+        EXPECT_FALSE(std::isnan(v.y));
+        EXPECT_FALSE(std::isnan(v.z));
+        EXPECT_FALSE(std::isnan(v.w));
+    }
+}
+
+// ============================================================================
+// All 24 Geometries Produce Non-Empty Vertex Sets
+// ============================================================================
+
+TEST(Geometry, AllGeometriesProduceVertices) {
+    for (int i = 0; i < kTotalGeometries; ++i) {
+        auto vertices = generateGeometry(i, kDefaultRes);
+        EXPECT_GT(vertices.size(), 0u)
+            << "Geometry index " << i << " should produce non-empty vertex set";
+    }
+}
+
+TEST(Geometry, AllGeometriesHaveValidVertices) {
+    for (int i = 0; i < kTotalGeometries; ++i) {
+        auto vertices = generateGeometry(i, kDefaultRes);
+        for (size_t j = 0; j < vertices.size(); ++j) {
+            EXPECT_FALSE(std::isnan(vertices[j].x))
+                << "Geometry " << i << " vertex " << j << " has NaN x";
+            EXPECT_FALSE(std::isnan(vertices[j].y))
+                << "Geometry " << i << " vertex " << j << " has NaN y";
+            EXPECT_FALSE(std::isnan(vertices[j].z))
+                << "Geometry " << i << " vertex " << j << " has NaN z";
+            EXPECT_FALSE(std::isnan(vertices[j].w))
+                << "Geometry " << i << " vertex " << j << " has NaN w";
+            EXPECT_FALSE(std::isinf(vertices[j].x))
+                << "Geometry " << i << " vertex " << j << " has Inf x";
+            EXPECT_FALSE(std::isinf(vertices[j].y))
+                << "Geometry " << i << " vertex " << j << " has Inf y";
+            EXPECT_FALSE(std::isinf(vertices[j].z))
+                << "Geometry " << i << " vertex " << j << " has Inf z";
+            EXPECT_FALSE(std::isinf(vertices[j].w))
+                << "Geometry " << i << " vertex " << j << " has Inf w";
+        }
+    }
+}
+
+// ============================================================================
+// Core Type Offset Encoding
+// ============================================================================
+
+TEST(Geometry, BaseGeometriesRange0to7) {
+    // Base geometries (core_type=0) are indices 0-7
+    for (int i = 0; i <= 7; ++i) {
+        auto vertices = generateGeometry(i, kDefaultRes);
+        EXPECT_GT(vertices.size(), 0u)
+            << "Base geometry " << i << " should produce vertices";
+    }
+}
+
+TEST(Geometry, HypersphereGeometriesRange8to15) {
+    // Hypersphere warped geometries (core_type=1) are indices 8-15
+    for (int i = 8; i <= 15; ++i) {
+        auto vertices = generateGeometry(i, kDefaultRes);
+        EXPECT_GT(vertices.size(), 0u)
+            << "Hypersphere geometry " << i << " should produce vertices";
+    }
+}
+
+TEST(Geometry, HypertetraGeometriesRange16to23) {
+    // Hypertetrahedron warped geometries (core_type=2) are indices 16-23
+    for (int i = 16; i <= 23; ++i) {
+        auto vertices = generateGeometry(i, kDefaultRes);
+        EXPECT_GT(vertices.size(), 0u)
+            << "Hypertetra geometry " << i << " should produce vertices";
+    }
+}
+
+// ============================================================================
+// Specific Geometry Properties
+// ============================================================================
+
+TEST(Geometry, SphereVerticesAreApproximatelyOnUnitSphere) {
+    auto vertices = generateGeometry(kSphereBase, kDefaultRes);
+    EXPECT_GT(vertices.size(), 0u);
+
+    // For a unit sphere, most vertices should have length close to 1.0
+    int onSphere = 0;
+    for (const auto& v : vertices) {
+        float len = v.length();
+        if (std::abs(len - 1.0f) < 0.2f) {
+            ++onSphere;
+        }
+    }
+    // At least half should be near the unit sphere
+    EXPECT_GT(onSphere, static_cast<int>(vertices.size()) / 2)
+        << "Most sphere vertices should be near unit length";
+}
+
+TEST(Geometry, HypercubeVerticesHaveSymmetry) {
+    // Tesseract vertices should be symmetric: if (x,y,z,w) is a vertex,
+    // then (-x,y,z,w) should also be (approximately) a vertex
+    auto vertices = generateGeometry(kHypercubeBase, kDefaultRes);
+    EXPECT_GE(vertices.size(), 16u);
+
+    // Count vertices with positive x and negative x
+    int positiveX = 0, negativeX = 0;
+    for (const auto& v : vertices) {
+        if (v.x > 0.01f) ++positiveX;
+        if (v.x < -0.01f) ++negativeX;
+    }
+    // Should be roughly balanced
+    EXPECT_GT(positiveX, 0) << "Should have vertices with positive x";
+    EXPECT_GT(negativeX, 0) << "Should have vertices with negative x";
+}
+
+// ============================================================================
+// Same Base Geometry Across Core Types
+// ============================================================================
+
+TEST(Geometry, WarpedVersionsHaveSameOrMoreVertices) {
+    // Warped versions should have at least as many vertices as the base
+    for (int base = 0; base < 8; ++base) {
+        auto baseVertices = generateGeometry(base, kDefaultRes);
+        auto hypersphereVertices = generateGeometry(base + kHypersphereOffset, kDefaultRes);
+        auto hypertetraVertices = generateGeometry(base + kHypertetraOffset, kDefaultRes);
+
+        EXPECT_GT(baseVertices.size(), 0u);
+        EXPECT_GT(hypersphereVertices.size(), 0u);
+        EXPECT_GT(hypertetraVertices.size(), 0u);
+    }
+}

package/cpp/tests/Mat4x4_test.cpp

@@ -0,0 +1,494 @@
+/**
+ * Mat4x4_test.cpp - Unit tests for Mat4x4 4x4 matrix class
+ *
+ * Tests identity construction, matrix-vector multiplication, matrix-matrix
+ * multiplication, determinant, transpose, rotation factories, and inversion.
+ */
+
+#include <gtest/gtest.h>
+#include "math/Mat4x4.hpp"
+#include "math/Vec4.hpp"
+#include <cmath>
+#include <numbers>
+
+using namespace vib3;
+
+static constexpr float kEpsilon = 1e-4f;
+static constexpr float kPi = std::numbers::pi_v<float>;
+static constexpr float kHalfPi = kPi / 2.0f;
+
+// ============================================================================
+// Construction
+// ============================================================================
+
+TEST(Mat4x4, DefaultConstructorIsIdentity) {
+    Mat4x4 m;
+    EXPECT_TRUE(m.isIdentity());
+}
+
+TEST(Mat4x4, IdentityFactory) {
+    Mat4x4 m = Mat4x4::identity();
+    EXPECT_TRUE(m.isIdentity());
+
+    // Verify diagonal is 1, off-diagonal is 0
+    for (size_t r = 0; r < 4; ++r) {
+        for (size_t c = 0; c < 4; ++c) {
+            if (r == c) {
+                EXPECT_FLOAT_EQ(m.at(r, c), 1.0f);
+            } else {
+                EXPECT_FLOAT_EQ(m.at(r, c), 0.0f);
+            }
+        }
+    }
+}
+
+TEST(Mat4x4, ZeroFactory) {
+    Mat4x4 m = Mat4x4::zero();
+    for (size_t r = 0; r < 4; ++r) {
+        for (size_t c = 0; c < 4; ++c) {
+            EXPECT_FLOAT_EQ(m.at(r, c), 0.0f);
+        }
+    }
+}
+
+TEST(Mat4x4, DiagonalConstructor) {
+    Mat4x4 m(3.0f);
+    EXPECT_FLOAT_EQ(m.at(0, 0), 3.0f);
+    EXPECT_FLOAT_EQ(m.at(1, 1), 3.0f);
+    EXPECT_FLOAT_EQ(m.at(2, 2), 3.0f);
+    EXPECT_FLOAT_EQ(m.at(3, 3), 3.0f);
+    EXPECT_FLOAT_EQ(m.at(0, 1), 0.0f);
+    EXPECT_FLOAT_EQ(m.at(1, 0), 0.0f);
+}
+
+TEST(Mat4x4, ColumnConstructor) {
+    Vec4 c0(1.0f, 0.0f, 0.0f, 0.0f);
+    Vec4 c1(0.0f, 2.0f, 0.0f, 0.0f);
+    Vec4 c2(0.0f, 0.0f, 3.0f, 0.0f);
+    Vec4 c3(0.0f, 0.0f, 0.0f, 4.0f);
+    Mat4x4 m(c0, c1, c2, c3);
+    EXPECT_FLOAT_EQ(m.at(0, 0), 1.0f);
+    EXPECT_FLOAT_EQ(m.at(1, 1), 2.0f);
+    EXPECT_FLOAT_EQ(m.at(2, 2), 3.0f);
+    EXPECT_FLOAT_EQ(m.at(3, 3), 4.0f);
+}
+
+// ============================================================================
+// Element Access
+// ============================================================================
+
+TEST(Mat4x4, ColumnAccess) {
+    Mat4x4 m = Mat4x4::identity();
+    Vec4 col0 = m.column(0);
+    EXPECT_FLOAT_EQ(col0.x, 1.0f);
+    EXPECT_FLOAT_EQ(col0.y, 0.0f);
+    EXPECT_FLOAT_EQ(col0.z, 0.0f);
+    EXPECT_FLOAT_EQ(col0.w, 0.0f);
+}
+
+TEST(Mat4x4, RowAccess) {
+    Mat4x4 m = Mat4x4::identity();
+    Vec4 row0 = m.row(0);
+    EXPECT_FLOAT_EQ(row0.x, 1.0f);
+    EXPECT_FLOAT_EQ(row0.y, 0.0f);
+    EXPECT_FLOAT_EQ(row0.z, 0.0f);
+    EXPECT_FLOAT_EQ(row0.w, 0.0f);
+}
+
+TEST(Mat4x4, SetColumn) {
+    Mat4x4 m = Mat4x4::zero();
+    m.setColumn(1, Vec4(10.0f, 20.0f, 30.0f, 40.0f));
+    EXPECT_FLOAT_EQ(m.at(0, 1), 10.0f);
+    EXPECT_FLOAT_EQ(m.at(1, 1), 20.0f);
+    EXPECT_FLOAT_EQ(m.at(2, 1), 30.0f);
+    EXPECT_FLOAT_EQ(m.at(3, 1), 40.0f);
+}
+
+TEST(Mat4x4, SetRow) {
+    Mat4x4 m = Mat4x4::zero();
+    m.setRow(2, Vec4(10.0f, 20.0f, 30.0f, 40.0f));
+    EXPECT_FLOAT_EQ(m.at(2, 0), 10.0f);
+    EXPECT_FLOAT_EQ(m.at(2, 1), 20.0f);
+    EXPECT_FLOAT_EQ(m.at(2, 2), 30.0f);
+    EXPECT_FLOAT_EQ(m.at(2, 3), 40.0f);
+}
+
+// ============================================================================
+// Matrix-Vector Multiplication
+// ============================================================================
+
+TEST(Mat4x4, IdentityTimesVectorIsVector) {
+    Mat4x4 m = Mat4x4::identity();
+    Vec4 v(1.0f, 2.0f, 3.0f, 4.0f);
+    Vec4 result = m * v;
+    EXPECT_FLOAT_EQ(result.x, 1.0f);
+    EXPECT_FLOAT_EQ(result.y, 2.0f);
+    EXPECT_FLOAT_EQ(result.z, 3.0f);
+    EXPECT_FLOAT_EQ(result.w, 4.0f);
+}
+
+TEST(Mat4x4, ZeroMatrixTimesVectorIsZero) {
+    Mat4x4 m = Mat4x4::zero();
+    Vec4 v(1.0f, 2.0f, 3.0f, 4.0f);
+    Vec4 result = m * v;
+    EXPECT_FLOAT_EQ(result.x, 0.0f);
+    EXPECT_FLOAT_EQ(result.y, 0.0f);
+    EXPECT_FLOAT_EQ(result.z, 0.0f);
+    EXPECT_FLOAT_EQ(result.w, 0.0f);
+}
+
+TEST(Mat4x4, MultiplyVec4MatchesOperator) {
+    Mat4x4 m = Mat4x4::identity();
+    Vec4 v(1.0f, 2.0f, 3.0f, 4.0f);
+    Vec4 r1 = m * v;
+    Vec4 r2 = m.multiplyVec4(v);
+    EXPECT_FLOAT_EQ(r1.x, r2.x);
+    EXPECT_FLOAT_EQ(r1.y, r2.y);
+    EXPECT_FLOAT_EQ(r1.z, r2.z);
+    EXPECT_FLOAT_EQ(r1.w, r2.w);
+}
+
+TEST(Mat4x4, ScaleMatrixTimesVector) {
+    Mat4x4 m = Mat4x4::scale(2.0f, 3.0f, 4.0f, 5.0f);
+    Vec4 v(1.0f, 1.0f, 1.0f, 1.0f);
+    Vec4 result = m * v;
+    EXPECT_NEAR(result.x, 2.0f, kEpsilon);
+    EXPECT_NEAR(result.y, 3.0f, kEpsilon);
+    EXPECT_NEAR(result.z, 4.0f, kEpsilon);
+    EXPECT_NEAR(result.w, 5.0f, kEpsilon);
+}
+
+// ============================================================================
+// Matrix-Matrix Multiplication
+// ============================================================================
+
+TEST(Mat4x4, IdentityTimesIdentityIsIdentity) {
+    Mat4x4 a = Mat4x4::identity();
+    Mat4x4 b = Mat4x4::identity();
+    Mat4x4 result = a * b;
+    EXPECT_TRUE(result.isIdentity());
+}
+
+TEST(Mat4x4, IdentityTimesMatrixIsMatrix) {
+    Mat4x4 m = Mat4x4::scale(2.0f);
+    Mat4x4 result = Mat4x4::identity() * m;
+    for (size_t r = 0; r < 4; ++r) {
+        for (size_t c = 0; c < 4; ++c) {
+            EXPECT_NEAR(result.at(r, c), m.at(r, c), kEpsilon);
+        }
+    }
+}
+
+TEST(Mat4x4, MatrixTimesIdentityIsMatrix) {
+    Mat4x4 m = Mat4x4::scale(3.0f);
+    Mat4x4 result = m * Mat4x4::identity();
+    for (size_t r = 0; r < 4; ++r) {
+        for (size_t c = 0; c < 4; ++c) {
+            EXPECT_NEAR(result.at(r, c), m.at(r, c), kEpsilon);
+        }
+    }
+}
+
+TEST(Mat4x4, ScaleMatrixMultiplication) {
+    Mat4x4 s2 = Mat4x4::scale(2.0f);
+    Mat4x4 s3 = Mat4x4::scale(3.0f);
+    Mat4x4 result = s2 * s3;
+    // scale(2) * scale(3) = scale(6)
+    EXPECT_NEAR(result.at(0, 0), 6.0f, kEpsilon);
+    EXPECT_NEAR(result.at(1, 1), 6.0f, kEpsilon);
+    EXPECT_NEAR(result.at(2, 2), 6.0f, kEpsilon);
+    EXPECT_NEAR(result.at(3, 3), 6.0f, kEpsilon);
+}
+
+TEST(Mat4x4, CompoundMultiplication) {
+    Mat4x4 m = Mat4x4::identity();
+    m *= Mat4x4::scale(2.0f);
+    EXPECT_NEAR(m.at(0, 0), 2.0f, kEpsilon);
+    EXPECT_NEAR(m.at(1, 1), 2.0f, kEpsilon);
+}
+
+// ============================================================================
+// Scalar Operations
+// ============================================================================
+
+TEST(Mat4x4, ScalarMultiplication) {
+    Mat4x4 m = Mat4x4::identity();
+    Mat4x4 result = m * 3.0f;
+    EXPECT_NEAR(result.at(0, 0), 3.0f, kEpsilon);
+    EXPECT_NEAR(result.at(1, 1), 3.0f, kEpsilon);
+    EXPECT_NEAR(result.at(0, 1), 0.0f, kEpsilon);
+}
+
+TEST(Mat4x4, ScalarMultiplicationFreeFunction) {
+    Mat4x4 m = Mat4x4::identity();
+    Mat4x4 result = 5.0f * m;
+    EXPECT_NEAR(result.at(0, 0), 5.0f, kEpsilon);
+}
+
+// ============================================================================
+// Addition and Subtraction
+// ============================================================================
+
+TEST(Mat4x4, MatrixAddition) {
+    Mat4x4 a = Mat4x4::identity();
+    Mat4x4 b = Mat4x4::identity();
+    Mat4x4 result = a + b;
+    EXPECT_NEAR(result.at(0, 0), 2.0f, kEpsilon);
+    EXPECT_NEAR(result.at(1, 1), 2.0f, kEpsilon);
+    EXPECT_NEAR(result.at(0, 1), 0.0f, kEpsilon);
+}
+
+TEST(Mat4x4, MatrixSubtraction) {
+    Mat4x4 a = Mat4x4::identity();
+    Mat4x4 b = Mat4x4::identity();
+    Mat4x4 result = a - b;
+    // Should be zero matrix
+    for (size_t r = 0; r < 4; ++r) {
+        for (size_t c = 0; c < 4; ++c) {
+            EXPECT_NEAR(result.at(r, c), 0.0f, kEpsilon);
+        }
+    }
+}
+
+// ============================================================================
+// Determinant
+// ============================================================================
+
+TEST(Mat4x4, DeterminantOfIdentityIsOne) {
+    Mat4x4 m = Mat4x4::identity();
+    EXPECT_NEAR(m.determinant(), 1.0f, kEpsilon);
+}
+
+TEST(Mat4x4, DeterminantOfZeroIsZero) {
+    Mat4x4 m = Mat4x4::zero();
+    EXPECT_NEAR(m.determinant(), 0.0f, kEpsilon);
+}
+
+TEST(Mat4x4, DeterminantOfScaleMatrix) {
+    Mat4x4 m = Mat4x4::scale(2.0f, 3.0f, 4.0f, 5.0f);
+    // det(diag(2,3,4,5)) = 2*3*4*5 = 120
+    EXPECT_NEAR(m.determinant(), 120.0f, kEpsilon);
+}
+
+TEST(Mat4x4, DeterminantOfUniformScale) {
+    Mat4x4 m = Mat4x4::scale(2.0f);
+    // det(2*I) = 2^4 = 16
+    EXPECT_NEAR(m.determinant(), 16.0f, kEpsilon);
+}
+
+TEST(Mat4x4, DeterminantOfRotationIsOne) {
+    // Rotation matrices have determinant 1
+    Mat4x4 m = Mat4x4::rotationXY(0.5f);
+    EXPECT_NEAR(m.determinant(), 1.0f, kEpsilon);
+}
+
+// ============================================================================
+// Transpose
+// ============================================================================
+
+TEST(Mat4x4, TransposeOfIdentityIsIdentity) {
+    Mat4x4 m = Mat4x4::identity();
+    Mat4x4 t = m.transposed();
+    EXPECT_TRUE(t.isIdentity());
+}
+
+TEST(Mat4x4, TransposeSwapsElements) {
+    Mat4x4 m = Mat4x4::zero();
+    m.at(0, 1) = 5.0f;
+    m.at(1, 0) = 10.0f;
+    Mat4x4 t = m.transposed();
+    EXPECT_FLOAT_EQ(t.at(0, 1), 10.0f);
+    EXPECT_FLOAT_EQ(t.at(1, 0), 5.0f);
+}
+
+TEST(Mat4x4, DoubleTransposeIsOriginal) {
+    Mat4x4 m = Mat4x4::rotationXY(0.7f);
+    Mat4x4 tt = m.transposed().transposed();
+    for (size_t r = 0; r < 4; ++r) {
+        for (size_t c = 0; c < 4; ++c) {
+            EXPECT_NEAR(tt.at(r, c), m.at(r, c), kEpsilon);
+        }
+    }
+}
+
+TEST(Mat4x4, TransposeInPlace) {
+    Mat4x4 m = Mat4x4::zero();
+    m.at(0, 2) = 7.0f;
+    m.transpose();
+    EXPECT_FLOAT_EQ(m.at(2, 0), 7.0f);
+    EXPECT_FLOAT_EQ(m.at(0, 2), 0.0f);
+}
+
+// ============================================================================
+// Inverse
+// ============================================================================
+
+TEST(Mat4x4, InverseOfIdentityIsIdentity) {
+    Mat4x4 m = Mat4x4::identity();
+    Mat4x4 inv = m.inverse();
+    EXPECT_TRUE(inv.isIdentity());
+}
+
+TEST(Mat4x4, InverseOfScaleMatrix) {
+    Mat4x4 m = Mat4x4::scale(2.0f);
+    Mat4x4 inv = m.inverse();
+    // inverse of scale(2) should be scale(0.5)
+    EXPECT_NEAR(inv.at(0, 0), 0.5f, kEpsilon);
+    EXPECT_NEAR(inv.at(1, 1), 0.5f, kEpsilon);
+    EXPECT_NEAR(inv.at(2, 2), 0.5f, kEpsilon);
+    EXPECT_NEAR(inv.at(3, 3), 0.5f, kEpsilon);
+}
+
+TEST(Mat4x4, MatrixTimesInverseIsIdentity) {
+    Mat4x4 m = Mat4x4::rotationXY(0.8f);
+    Mat4x4 inv = m.inverse();
+    Mat4x4 product = m * inv;
+    EXPECT_TRUE(product.isIdentity(1e-4f));
+}
+
+// ============================================================================
+// Rotation Matrices
+// ============================================================================
+
+TEST(Mat4x4, RotationXY_RotatesXtoY) {
+    Mat4x4 m = Mat4x4::rotationXY(kHalfPi);
+    Vec4 result = m * Vec4::unitX();
+    EXPECT_NEAR(result.x, 0.0f, kEpsilon);
+    EXPECT_NEAR(result.y, 1.0f, kEpsilon);
+    EXPECT_NEAR(result.z, 0.0f, kEpsilon);
+    EXPECT_NEAR(result.w, 0.0f, kEpsilon);
+}
+
+TEST(Mat4x4, RotationXZ_RotatesXtoZ) {
+    Mat4x4 m = Mat4x4::rotationXZ(kHalfPi);
+    Vec4 result = m * Vec4::unitX();
+    EXPECT_NEAR(result.x, 0.0f, kEpsilon);
+    EXPECT_NEAR(result.y, 0.0f, kEpsilon);
+    EXPECT_NEAR(result.z, 1.0f, kEpsilon);
+    EXPECT_NEAR(result.w, 0.0f, kEpsilon);
+}
+
+TEST(Mat4x4, RotationYZ_RotatesYtoZ) {
+    Mat4x4 m = Mat4x4::rotationYZ(kHalfPi);
+    Vec4 result = m * Vec4::unitY();
+    EXPECT_NEAR(result.x, 0.0f, kEpsilon);
+    EXPECT_NEAR(result.y, 0.0f, kEpsilon);
+    EXPECT_NEAR(result.z, 1.0f, kEpsilon);
+    EXPECT_NEAR(result.w, 0.0f, kEpsilon);
+}
+
+TEST(Mat4x4, RotationXW_RotatesXtoW) {
+    Mat4x4 m = Mat4x4::rotationXW(kHalfPi);
+    Vec4 result = m * Vec4::unitX();
+    EXPECT_NEAR(result.x, 0.0f, kEpsilon);
+    EXPECT_NEAR(result.y, 0.0f, kEpsilon);
+    EXPECT_NEAR(result.z, 0.0f, kEpsilon);
+    EXPECT_NEAR(result.w, 1.0f, kEpsilon);
+}
+
+TEST(Mat4x4, RotationYW_RotatesYtoW) {
+    Mat4x4 m = Mat4x4::rotationYW(kHalfPi);
+    Vec4 result = m * Vec4::unitY();
+    EXPECT_NEAR(result.x, 0.0f, kEpsilon);
+    EXPECT_NEAR(result.y, 0.0f, kEpsilon);
+    EXPECT_NEAR(result.z, 0.0f, kEpsilon);
+    EXPECT_NEAR(result.w, 1.0f, kEpsilon);
+}
+
+TEST(Mat4x4, RotationZW_RotatesZtoW) {
+    Mat4x4 m = Mat4x4::rotationZW(kHalfPi);
+    Vec4 result = m * Vec4::unitZ();
+    EXPECT_NEAR(result.x, 0.0f, kEpsilon);
+    EXPECT_NEAR(result.y, 0.0f, kEpsilon);
+    EXPECT_NEAR(result.z, 0.0f, kEpsilon);
+    EXPECT_NEAR(result.w, 1.0f, kEpsilon);
+}
+
+TEST(Mat4x4, RotationZeroAngleIsIdentity) {
+    Mat4x4 m = Mat4x4::rotationXY(0.0f);
+    EXPECT_TRUE(m.isIdentity());
+}
+
+TEST(Mat4x4, RotationFromAnglesAllZerosIsIdentity) {
+    Mat4x4 m = Mat4x4::rotationFromAngles(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
+    EXPECT_TRUE(m.isIdentity());
+}
+
+TEST(Mat4x4, RotationFromAnglesArrayOverload) {
+    std::array<float, 6> angles = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
+    Mat4x4 m = Mat4x4::rotationFromAngles(angles);
+    EXPECT_TRUE(m.isIdentity());
+}
+
+TEST(Mat4x4, RotationIsOrthogonal) {
+    Mat4x4 m = Mat4x4::rotationFromAngles(0.3f, 0.5f, 0.7f, 0.1f, 0.2f, 0.4f);
+    EXPECT_TRUE(m.isOrthogonal(1e-3f));
+}
+
+TEST(Mat4x4, RotationDeterminantIsOne) {
+    Mat4x4 m = Mat4x4::rotationFromAngles(0.3f, 0.5f, 0.7f, 0.1f, 0.2f, 0.4f);
+    EXPECT_NEAR(m.determinant(), 1.0f, kEpsilon);
+}
+
+TEST(Mat4x4, RotationPreservesVectorLength) {
+    Mat4x4 m = Mat4x4::rotationFromAngles(0.5f, 0.3f, 0.7f, 0.2f, 0.4f, 0.1f);
+    Vec4 v(1.0f, 2.0f, 3.0f, 4.0f);
+    Vec4 rotated = m * v;
+    EXPECT_NEAR(rotated.length(), v.length(), kEpsilon);
+}
+
+// ============================================================================
+// Scale
+// ============================================================================
+
+TEST(Mat4x4, UniformScaleMatrix) {
+    Mat4x4 m = Mat4x4::scale(3.0f);
+    EXPECT_FLOAT_EQ(m.at(0, 0), 3.0f);
+    EXPECT_FLOAT_EQ(m.at(1, 1), 3.0f);
+    EXPECT_FLOAT_EQ(m.at(2, 2), 3.0f);
+    EXPECT_FLOAT_EQ(m.at(3, 3), 3.0f);
+}
+
+TEST(Mat4x4, ScaleFromVec4) {
+    Vec4 s(2.0f, 3.0f, 4.0f, 5.0f);
+    Mat4x4 m = Mat4x4::scale(s);
+    EXPECT_FLOAT_EQ(m.at(0, 0), 2.0f);
+    EXPECT_FLOAT_EQ(m.at(1, 1), 3.0f);
+    EXPECT_FLOAT_EQ(m.at(2, 2), 4.0f);
+    EXPECT_FLOAT_EQ(m.at(3, 3), 5.0f);
+}
+
+// ============================================================================
+// Comparison
+// ============================================================================
+
+TEST(Mat4x4, EqualityOperator) {
+    Mat4x4 a = Mat4x4::identity();
+    Mat4x4 b = Mat4x4::identity();
+    EXPECT_TRUE(a == b);
+    EXPECT_FALSE(a != b);
+}
+
+TEST(Mat4x4, InequalityOperator) {
+    Mat4x4 a = Mat4x4::identity();
+    Mat4x4 b = Mat4x4::scale(2.0f);
+    EXPECT_FALSE(a == b);
+    EXPECT_TRUE(a != b);
+}
+
+// ============================================================================
+// Data Pointer
+// ============================================================================
+
+TEST(Mat4x4, DataPointerAccess) {
+    Mat4x4 m = Mat4x4::identity();
+    const float* p = m.ptr();
+    // Column-major: first column is [1,0,0,0]
+    EXPECT_FLOAT_EQ(p[0], 1.0f);
+    EXPECT_FLOAT_EQ(p[1], 0.0f);
+    EXPECT_FLOAT_EQ(p[2], 0.0f);
+    EXPECT_FLOAT_EQ(p[3], 0.0f);
+    // Second column starts at index 4: [0,1,0,0]
+    EXPECT_FLOAT_EQ(p[4], 0.0f);
+    EXPECT_FLOAT_EQ(p[5], 1.0f);
+}