Adding code x3

include/J3ML/LinearAlgebra.h

@@ -21,10 +21,7 @@ namespace Math
 
 
     float NormalizeToRange(float input, float fromLower, float fromUpper, float toLower, float toUpper);
-    float NormalizeToRange(float input, const NumberRange& from, const NumberRange& to)
-    {
-
-    }
+    float NormalizeToRange(float input, const NumberRange& from, const NumberRange& to);
     // auto rotation_normalized = NormalizeToRange(inp, {0, 360}, {-1, 1});
     inline float Lerp(float a, float b, float t);
 

include/J3ML/LinearAlgebra/AxisAngle.h

@@ -9,7 +9,13 @@ namespace LinearAlgebra
     /// Transitional datatype, not useful for internal representation of rotation
     /// But has uses for conversion and manipulation.
     class AxisAngle {
-        Vector3 Axis;
-        float Angle;
+        Vector3 axis;
+        float angle;
+
+    public:
+        AxisAngle();
+        AxisAngle(Vector3 axis, float angle);
+
+
     };
 }

include/J3ML/LinearAlgebra/EulerAngle.h

@@ -1,5 +1,5 @@
 #pragma once
-
+#include <J3ML/LinearAlgebra.h>
 #include <J3ML/LinearAlgebra/Vector3.h>
 
 namespace LinearAlgebra {

include/J3ML/LinearAlgebra/Quaternion.h

@@ -2,9 +2,12 @@
 
 #include <J3ML/LinearAlgebra.h>
 
+#include <J3ML/LinearAlgebra/Vector4.h>
+#include <J3ML/LinearAlgebra/AxisAngle.h>
+
 namespace LinearAlgebra
 {
-    class Quaternion
+    class Quaternion : public Vector4
     {
     public:
         Quaternion();
@@ -12,15 +15,25 @@ namespace LinearAlgebra
         explicit Quaternion(const Matrix3x3& rotationMtrx);
         explicit Quaternion(const Matrix4x4& rotationMtrx);
         // @note The input data is not normalized after construction, this has to be done manually.
-        Quaternion(float x, float y, float z, float w);
+        Quaternion(float X, float Y, float Z, float W);
+
+
+
         // Constructs this quaternion by specifying a rotation axis and the amount of rotation to be performed about that axis
         // @param rotationAxis The normalized rotation axis to rotate about. If using Vector4 version of the constructor, the w component of this vector must be 0.
         Quaternion(const Vector3& rotationAxis, float rotationAngleBetween) { SetFromAxisAngle(rotationAxis, rotationAngleBetween); }
         Quaternion(const Vector4& rotationAxis, float rotationAngleBetween) { SetFromAxisAngle(rotationAxis, rotationAngleBetween); }
         //void Inverse();
+
+        explicit Quaternion(Vector4 vector4);
+
+        void SetFromAxisAngle(const Vector3 &vector3, float between);
+        void SetFromAxisAngle(const Vector4 &vector4, float between);
+
         Quaternion Inverse() const;
+        Quaternion Conjugate() const;
+
         //void Normalize();
-        Quaternion Normalize() const;
         Vector3 GetWorldX() const;
         Vector3 GetWorldY() const;
         Vector3 GetWorldZ() const;
@@ -35,22 +48,21 @@ namespace LinearAlgebra
 
         Quaternion GetInverse() const;
         Quaternion Lerp(const Quaternion& b, float t) const;
-        Quaternion Slerp(const Quaternion& target) const;
+        Quaternion Slerp(const Quaternion& q2, float t) const;
 
-        void SetFromAxisAngle(const Vector3& axis, float angle);
-
-        void SetFromAxisAngle(const Vector4& axis, float angle)
-        {
-
-        }
+        Quaternion Normalize() const;
 
 
         static Quaternion LookAt(const Vector3& position, const Vector3& direction, const Vector3& axisUp);
 
+        // TODO: Document (But do not override!) certain math functions that are the same for Vec4
+        // TODO: Double Check which operations need to be overriden for correct behavior!
+
+
         // Multiplies two quaternions together.
         // The product q1 * q2 returns a quaternion that concatenates the two orientation rotations.
         // The rotation q2 is applied first before q1.
-        Quaternion operator *  (const Quaternion& rhs) const;
+        Quaternion operator * (const Quaternion& rhs) const;
 
         Quaternion operator * (float scalar) const;
 
@@ -59,14 +71,16 @@ namespace LinearAlgebra
         Vector4 operator * (const Vector4& rhs) const;
 
         // Divides a quaternion by another. Divison "a / b" results in a quaternion that rotates the orientation b to coincide with orientation of
-        Quaternion operator / (const Quaternion& rhs) const;
+        //Quaternion operator / (const Quaternion& rhs) const;
         Quaternion operator +(const Quaternion& rhs) const;
         Quaternion operator +() const;
         Quaternion operator -() const;
-    public:
-        float x = 0;
-        float y = 0;
-        float z = 0;
-        float w = 0;
+        float Dot(const Quaternion &quaternion) const;
+
+        float Angle() const;
+
+        float AngleBetween(const Quaternion& target) const;
+
+        AxisAngle ToAxisAngle() const;
     };
 }

include/J3ML/LinearAlgebra/Vector4.h

@@ -33,7 +33,6 @@ namespace LinearAlgebra {
         float operator[](std::size_t index) const;
 
         bool IsWithinMarginOfError(const Vector4& rhs, float margin=0.0001f) const;
-
         bool IsNormalized(float epsilonSq = 1e-5f) const;
         bool IsZero(float epsilonSq = 1e-6f) const;
         bool IsFinite() const;
@@ -85,10 +84,10 @@ namespace LinearAlgebra {
         Vector4 operator-() const; // Unary - Operator (Negation)
     public:
 #if MUTABLE
-        float x = 0;
-        float y = 0;
-        float z = 0;
-        float w = 0;
+        float x;
+        float y;
+        float z;
+        float w;
 #else
          float x = 0;
          float y = 0;