Added better support for casting vector3d to/from MAtrix

Vector3D.hpp

@@ -1,81 +1,44 @@
-#pragma once
+#ifndef VECTOR3D_H_
+#define VECTOR3D_H_
 
 #include <cstdint>
 #include <cmath>
 #include <type_traits>
 
+#include "Matrix.hpp"
+
 template <typename Type>
-class V3D{
-    public:
-    constexpr V3D(const V3D& other):
-    x(other.x),
-    y(other.y),
-    z(other.z){
-        static_assert(std::is_arithmetic<Type>::value, "Type must be a number");
-    }
-    
-    constexpr V3D(Type x=0, Type y=0, Type z=0): 
-    x(x), 
-    y(y), 
-    z(z){
-        static_assert(std::is_arithmetic<Type>::value, "Type must be a number");
-    }
+class V3D
+{
+public:
+    constexpr V3D(const Matrix<1, 3> &other);
+    constexpr V3D(const Matrix<3, 1> &other);
+
+    constexpr V3D(const V3D &other);
+
+    constexpr V3D(Type x = 0, Type y = 0, Type z = 0);
 
     template <typename OtherType>
-    constexpr V3D(const V3D<OtherType> other):
-    x(static_cast<Type>(other.x)),
-    y(static_cast<Type>(other.y)),
-    z(static_cast<Type>(other.z)){
-        static_assert(std::is_arithmetic<Type>::value, "Type must be a number");
-        static_assert(std::is_arithmetic<OtherType>::value, "OtherType must be a number");
-    }
+    constexpr V3D(const V3D<OtherType> other);
 
-    V3D& operator=(const V3D &other){
-        this->x = other.x;
-        this->y = other.y;
-        this->z = other.z;
-        return *this;
-    }
+    std::array<Type, 3> ToArray();
 
-    V3D& operator+=(const V3D &other){
-        this->x += other.x;
-        this->y += other.y;
-        this->z += other.z;
-        return *this;
-    }
+    V3D &operator=(const V3D &other);
 
-    V3D& operator-=(const V3D &other){
-        this->x -= other.x;
-        this->y -= other.y;
-        this->z -= other.z;
-        return *this;
-    }
+    V3D &operator+=(const V3D &other);
 
-    V3D& operator/=(const Type scalar){
-        if(scalar == 0){
-            return *this;
-        }
-        this->x /= scalar;
-        this->y /= scalar;
-        this->z /= scalar;
-        return *this;
-    }
+    V3D &operator-=(const V3D &other);
 
-    V3D& operator*=(const Type scalar){
-        this->x *= scalar;
-        this->y *= scalar;
-        this->z *= scalar;
-        return *this;
-    }
+    V3D &operator/=(const Type scalar);
 
-    bool operator==(const V3D &other){
-        return this->x == other.x && this->y == other.y && this->z == other.z;
-    }
+    V3D &operator*=(const Type scalar);
 
-    float magnitude(){
-        return std::sqrt(static_cast<float>(this->x * this->x + this->y * this->y + this->z * this->z));
-    }
+    bool operator==(const V3D &other);
+
+    float magnitude();
     Type x;
     Type y;
     Type z;
-};
+};
+
+#endif // VECTOR3D_H_