Implement ToQuat

include/J3ML/LinearAlgebra/Angle2D.h

@@ -5,6 +5,10 @@
 namespace LinearAlgebra {
     class Angle2D {
     public:
-
+        float x;
+        float y;
+        bool operator==(const Angle2D& rhs) const {
+            return (this->x==rhs.x && this->y==rhs.y);
+        }
     };
 }

include/J3ML/LinearAlgebra/Matrix2x2.h

@@ -12,10 +12,20 @@ namespace LinearAlgebra {
         static const Matrix2x2 Identity;
         static const Matrix2x2 NaN;
 
+        Matrix2x2() {}
+        Matrix2x2(float val);
+        Matrix2x2(float m00, float m01, float m10, float m11);
+        Matrix2x2(const Vector2& r1, const Vector2& r2);
         Vector2 GetRow(int index) const;
         Vector2 GetColumn(int index) const;
         float At(int x, int y) const;
 
+        float Determinant() const;
+        Matrix2x2 Inverse() const;
+        Matrix2x2 Transpose() const;
+
+        Vector2 Transform(const Vector2& rhs) const;
+
 
         Vector2 operator * (const Vector2& rhs) const;
         Matrix2x2 operator * (const Matrix2x2 &rhs) const;

include/J3ML/LinearAlgebra/Matrix3x3.h

@@ -99,13 +99,9 @@ namespace LinearAlgebra {
         Matrix3x3 Transpose() const;
 
         // Transforms the given vectors by this matrix M, i.e. returns M * (x,y,z)
-
         Vector2 Transform(const Vector2& rhs) const;
         Vector3 Transform(const Vector3& rhs) const;
 
-
-
-        Vector3 operator[] (float index) const;
         Vector3 operator * (const Vector3& rhs) const;
         Matrix3x3 operator * (const Matrix3x3& rhs) const;
 

include/J3ML/LinearAlgebra/Matrix4x4.h

@@ -2,8 +2,6 @@
 
 #include <J3ML/LinearAlgebra.h>
 
-
-
 namespace LinearAlgebra {
     /// A 4-by-4 matrix for affine transformations and perspective projections of 3D geometry.
 /* This matrix can represent the most generic form of transformations for 3D objects,

include/J3ML/LinearAlgebra/Vector3.h

@@ -3,6 +3,7 @@
 #include <J3ML/LinearAlgebra/Vector3.h>
 #include <cstddef>
 #include <cstdlib>
+#include <J3ML/LinearAlgebra/Angle2D.h>
 
 
 namespace LinearAlgebra {
@@ -95,8 +96,8 @@ public:
     static Vector3 Lerp(const Vector3& lhs, const Vector3& rhs, float alpha);
 
 
-    float AngleBetween(const Vector3& rhs) const; // TODO: 3D Angle representation?
-    static float AngleBetween(const Vector3& lhs, const Vector3& rhs); // TODO: 3D Angle representation?
+    Angle2D AngleBetween(const Vector3& rhs) const;
+    static Angle2D AngleBetween(const Vector3& lhs, const Vector3& rhs);
 
     // Adds two vectors
     Vector3 operator+(const Vector3& rhs) const;
@@ -122,12 +123,9 @@ public:
     Vector3 operator+() const; // TODO: Implement
     // Unary - operator (Negation)
     Vector3 operator-() const;
-
-
 public:
      float x = 0;
      float y = 0;
      float z = 0;
-
 };
 }

src/J3ML/LinearAlgebra/Matrix3x3.cpp

@@ -175,5 +175,26 @@ namespace LinearAlgebra {
         };
     }
 
+    Quaternion Matrix3x3::ToQuat() const {
+        auto m00 = At(0,0);
+        auto m01 = At(0, 1);
+        auto m02 = At(0, 2);
+        auto m10 = At(1,0);
+        auto m11 = At(1, 1);
+        auto m12 = At(1, 2);
+        auto m20 = At(2,0);
+        auto m21 = At(2, 1);
+        auto m22 = At(2, 2);
+
+        auto w = std::sqrt(1.f + m00 + m11 + m22) / 2.f;
+        float w4 = (4.f * w);
+        return {
+                (m21 - m12) / w4,
+                (m02 - m20) / w4,
+                (m10 - m01) / w4,
+                w
+        };
+    }
+
 }
 

src/J3ML/LinearAlgebra/Vector2.cpp

@@ -116,7 +116,6 @@ namespace LinearAlgebra {
     {
         auto numer = this->Dot(rhs);
         auto denom = this->Magnitude() * rhs.Magnitude();
-        std::cout << numer << ", " << denom << std::endl;
         return std::acos(numer / denom);
     }
 

src/J3ML/LinearAlgebra/Vector3.cpp

@@ -269,7 +269,7 @@ namespace LinearAlgebra {
     }
 
     Vector3 Vector3::Sub(const Vector3 &lhs, const Vector3 &rhs) {
-        lhs.Sub(rhs);
+        return lhs.Sub(rhs);
     }
 
     Vector3 Vector3::Mul(float scalar) const {
@@ -288,5 +288,18 @@ namespace LinearAlgebra {
         return lhs.Div(rhs);
     }
 
+    Angle2D Vector3::AngleBetween(const Vector3 &rhs) const {
+        const auto Pi_x_180 = 180.f / M_PI;
+        auto dist = this->Distance(rhs);
+        float x = -(asinf((rhs.y - this->y) / dist));
+        float y = (atan2f(rhs.x - this->x,rhs.z - this->z));
+        return {x, y};
+    }
+
+    Angle2D Vector3::AngleBetween(const Vector3 &lhs, const Vector3 &rhs) // TODO: 3D Angle representation?
+    {
+        return lhs.AngleBetween(rhs);
+    }
+
 #pragma endregion
 }

tests/LinearAlgebra/Vector3Tests.cpp

@@ -3,111 +3,118 @@
 
 using Vector3 = LinearAlgebra::Vector3;
 
+void EXPECT_V3_EQ(const Vector3& lhs, const Vector3& rhs)
+{
+    EXPECT_FLOAT_EQ(lhs.x, rhs.x);
+    EXPECT_FLOAT_EQ(lhs.y, rhs.y);
+    EXPECT_FLOAT_EQ(lhs.z, rhs.z);
+}
+
 TEST(Vector3Test, V3_Constructor_Default)
 {
-    EXPECT_EQ(Vector3(), Vector3::Zero);
+    EXPECT_V3_EQ(Vector3(), Vector3::Zero);
 }
 
 TEST(Vector3Test, V3_Constructor_XYZ)
 {
     Vector3 Input {0, 1, 0};
 
-    EXPECT_EQ(Input, Vector3::Down);
+    EXPECT_V3_EQ(Input, Vector3::Down);
 }
 
 TEST(Vector3Test, V3_Addition_Op) {
-    Vector3 A {};
-    Vector3 B {};
+    Vector3 A {1,1,1};
+    Vector3 B {2,2,2};
 
-    Vector3 ExpectedResult {};
+    Vector3 ExpectedResult {3,3,3};
 
-    EXPECT_EQ(A + B, ExpectedResult);
+    EXPECT_V3_EQ(A + B, ExpectedResult);
 }
 TEST(Vector3Test, V3_Addition_Method) {
-    Vector3 A {};
-    Vector3 B {};
+    Vector3 A {1,1,1};
+    Vector3 B {2,2,2};
 
-    Vector3 ExpectedResult {};
+    Vector3 ExpectedResult {3,3,3};
 
-    EXPECT_EQ(A.Add(B), ExpectedResult);
+    EXPECT_V3_EQ(A.Add(B), ExpectedResult);
 }
 TEST(Vector3Test, V3_Addition_Static) {
-    Vector3 A {};
-    Vector3 B {};
+    Vector3 A {1,1,1};
+    Vector3 B {3,3,3};
 
-    Vector3 ExpectedResult {};
+    Vector3 ExpectedResult {4,4,4};
 
-    EXPECT_EQ(Vector3::Add(A, B), ExpectedResult);
+    EXPECT_V3_EQ(Vector3::Add(A, B), ExpectedResult);
 }
 TEST(Vector3Test, V3_Subtract_Op) {
-    Vector3 A {};
-    Vector3 B {};
+    Vector3 A {2,2,2};
+    Vector3 B {.5f, .5f, .5f};
 
-    Vector3 ExpectedResult {};
+    Vector3 ExpectedResult {1.5f, 1.5f, 1.5f};
 
-    EXPECT_EQ(A - B, ExpectedResult);
+    EXPECT_V3_EQ(A - B, ExpectedResult);
 }
 TEST(Vector3Test, V3_Subtract_Method) {
-    Vector3 A {};
-    Vector3 B {};
+    Vector3 A {3,3,3};
+    Vector3 B {1,1,1};
 
-    Vector3 ExpectedResult {};
+    Vector3 ExpectedResult {2,2,2};
 
-    EXPECT_EQ(A.Sub(B), ExpectedResult);
+    EXPECT_V3_EQ(A.Sub(B), ExpectedResult);
 }
 TEST(Vector3Test, V3_Subtract_Static) {
-    Vector3 A {};
-    Vector3 B {};
+    Vector3 A {4,4,4};
+    Vector3 B {1,1,1};
 
-    Vector3 ExpectedResult {};
+    Vector3 ExpectedResult {3,3,3};
 
-    EXPECT_EQ(Vector3::Sub(A, B), ExpectedResult);
+    EXPECT_V3_EQ(Vector3::Sub(A, B), ExpectedResult);
 }
 TEST(Vector3Test, V3_Scalar_Mult_Op) {
-    Vector3 A { };
+    Vector3 A { 1,1,1};
     float B = 1.5f;
 
-    Vector3 ExpectedResult {};
+    Vector3 ExpectedResult {1.5f, 1.5f, 1.5f};
 
-    EXPECT_EQ(A * B, ExpectedResult);
+    EXPECT_V3_EQ(A * B, ExpectedResult);
 }
 TEST(Vector3Test, V3_Scalar_Mult_Method) {
-    Vector3 A { };
+    Vector3 A {3,3,3};
     float B = 1.5f;
 
-    Vector3 ExpectedResult {};
+    Vector3 ExpectedResult {4.5f, 4.5f, 4.5f};
 
-    EXPECT_EQ(A.Mul(B), ExpectedResult);
+    EXPECT_V3_EQ(A.Mul(B), ExpectedResult);
 }
 TEST(Vector3Test, V3_Scalar_Mult_Static) {
-    Vector3 A { };
+    Vector3 A {2,2,2};
     float B = 1.5f;
 
-    Vector3 ExpectedResult {};
+    Vector3 ExpectedResult {3.f, 3.f, 3.f};
 
-    EXPECT_EQ(Vector3::Mul(A, B), ExpectedResult);
+    EXPECT_V3_EQ(Vector3::Mul(A, B), ExpectedResult);
 }
 TEST(Vector3Test, V3_Scalar_Div_Op) {
-    Vector3 A {};
-    float B = 1.5f;
+    Vector3 A {4,4,4};
+    float B = 2.f;
 
-    Vector3 ExpectedResult { };
-    EXPECT_EQ(A / B, ExpectedResult);
+    Vector3 ExpectedResult {2,2,2};
+    EXPECT_V3_EQ(A / B, ExpectedResult);
 }
 TEST(Vector3Test, V3_Scalar_Div_Method) {
-    Vector3 A { };
-    float B = 1.5f;
-    Vector3 ExpectedResult { };
+    Vector3 A {6,6,6};
+    float B = 2.f;
+    Vector3 ExpectedResult { 3,3,3};
 
-    EXPECT_EQ(A.Div(B), ExpectedResult);
+    EXPECT_V3_EQ(A.Div(B), ExpectedResult);
 }
 TEST(Vector3Test, V3_Scalar_Div_Static) {
-    Vector3 A { };
+    Vector3 A {3,3,3};
     float B = 1.5f;
 
-    Vector3 ExpectedResult { };
+    Vector3 ExpectedResult { 2.f, 2.f, 2.f};
 
-    EXPECT_EQ(Vector3::Div(A, B), ExpectedResult);
+    EXPECT_V3_EQ(Vector3::Div(A, B), ExpectedResult);
 }
 TEST(Vector3Test, V3_Sizeof) {
     EXPECT_EQ(sizeof(Vector3), 12);
@@ -116,12 +123,75 @@ TEST(Vector3Test, V3_NaN) {
     EXPECT_NE(Vector3(0, 0, 0), Vector3::NaN);
 
 }
-TEST(Vector3Test, V3_Min) {}
-TEST(Vector3Test, V3_Max) {}
-TEST(Vector3Test, V3_Clamp) {}
-TEST(Vector3Test, V3_DotProduct) {}
-TEST(Vector3Test, V3_CrossProduct) {}
-TEST(Vector3Test, V3_Project) {}
-TEST(Vector3Test, V3_Normalize) {}
-TEST(Vector3Test, V3_Lerp) {}
-TEST(Vector3Test, V3_AngleBetween) {}
+TEST(Vector3Test, V3_Min) {
+    Vector3 Input {2,2,2};
+    Vector3 Minimum {3,3,3};
+    Vector3 ExpectedResult {2,2,2};
+
+    EXPECT_V3_EQ(Input.Min(Minimum), ExpectedResult);
+}
+TEST(Vector3Test, V3_Max) {
+    Vector3 Input {2,2,2};
+    Vector3 Maximum {3,3,3};
+    Vector3 ExpectedResult {3,3,3};
+
+    EXPECT_V3_EQ(Input.Max(Maximum), ExpectedResult);
+}
+TEST(Vector3Test, V3_Clamp) {
+    Vector3 Input {5,-1,8};
+    Vector3 Minimum {1,1,1};
+    Vector3 Maximum {5,5,5};
+
+    Vector3 ExpectedResult {5,1,5};
+
+    EXPECT_V3_EQ(Input.Clamp(Minimum, Maximum), ExpectedResult);
+
+}
+TEST(Vector3Test, V3_DotProduct) {
+    Vector3 A{6,6,6};
+    Vector3 B{1,1,1};
+
+
+    float ExpectedResult = 1;
+
+    EXPECT_FLOAT_EQ(A.Dot(B), ExpectedResult);
+}
+TEST(Vector3Test, V3_CrossProduct) {
+    Vector3 A{1,1,1};
+    Vector3 B{2,2,2};
+
+    Vector3 ExpectedResult {0,0,0};
+
+    EXPECT_V3_EQ(A.Cross(B), ExpectedResult);
+
+}
+TEST(Vector3Test, V3_Project) {
+    Vector3 Base {};
+    Vector3 Projection {};
+    Vector3 ExpectedResult {};
+}
+TEST(Vector3Test, V3_Normalize) {
+    Vector3 Input {2, 0, 0};
+    Vector3 ExpectedResult {1, 0, 0};
+
+    EXPECT_V3_EQ(Input.Normalize(), ExpectedResult);
+}
+TEST(Vector3Test, V3_Lerp)
+{
+    Vector3 Start {};
+    Vector3 Finish {};
+    float Percent = 50;
+    Vector3 ExpectedResult {};
+    EXPECT_V3_EQ(Start.Lerp(Finish, Percent), ExpectedResult);
+}
+TEST(Vector3Test, V3_AngleBetween) {
+    Vector3 A{ .5f, .5f, .5f};
+    Vector3 B {.25f, .75f, .25f};
+    A = A.Normalize();
+    B = B.Normalize();
+    LinearAlgebra::Angle2D ExpectedResult {-0.697914, -2.35619};
+    std::cout << A.AngleBetween(B).x << ", " << A.AngleBetween(B).y << "";
+    auto angle = A.AngleBetween(B);
+    EXPECT_FLOAT_EQ(angle.x, ExpectedResult.x);
+    EXPECT_FLOAT_EQ(angle.y, ExpectedResult.y);
+}