Merge pull request #29 from orange-cpp/u/orange-cpp/template-vectors

Added template Vectors 2d 3d 4d

CMakeLists.txt

@@ -13,10 +13,7 @@ option(OMATH_BUILD_AS_SHARED_LIBRARY "Build Omath as .so or .dll" OFF)
 if (OMATH_BUILD_AS_SHARED_LIBRARY)
     add_library(omath SHARED source/Vector3.cpp)
 else()
-    add_library(omath STATIC source/Vector3.cpp
+    add_library(omath STATIC source/Matrix.cpp)
-            include/omath/engines/OpenGL/Constants.hpp
-            include/omath/engines/OpenGL/Formulas.hpp
-            include/omath/engines/OpenGL/Camera.hpp)
 endif()
 
 set_target_properties(omath PROPERTIES

include/omath/Color.hpp

@@ -18,10 +18,10 @@ namespace omath
     };
 
 
-    class Color final : public Vector4
+    class Color final : public Vector4<float>
     {
         public:
-            constexpr Color(float r, float g, float b, float a) : Vector4(r,g,b,a)
+            constexpr Color(const float r, const float g, const float b, const float a) : Vector4(r,g,b,a)
             {
                 Clamp(0.f, 1.f);
             }

include/omath/Mat.hpp

@@ -333,21 +333,21 @@ namespace omath
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
     [[nodiscard]]
-    constexpr static Mat<1, 4, Type, St> MatRowFromVector(const Vector3& vector) noexcept
+    constexpr static Mat<1, 4, Type, St> MatRowFromVector(const Vector3<Type>& vector) noexcept
     {
         return {{vector.x, vector.y, vector.z, 1}};
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
     [[nodiscard]]
-    constexpr static Mat<4, 1, Type, St> MatColumnFromVector(const Vector3& vector) noexcept
+    constexpr static Mat<4, 1, Type, St> MatColumnFromVector(const Vector3<Type>& vector) noexcept
     {
         return {{vector.x}, {vector.y}, {vector.z}, {1}};
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
     [[nodiscard]]
-    constexpr Mat<4, 4, Type, St> MatTranslation(const Vector3& diff) noexcept
+    constexpr Mat<4, 4, Type, St> MatTranslation(const Vector3<Type>& diff) noexcept
     {
         return
         {
@@ -399,8 +399,8 @@ namespace omath
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
     [[nodiscard]]
-    static Mat<4, 4, Type, St> MatCameraView(const Vector3& forward, const Vector3& right, const Vector3& up,
+    static Mat<4, 4, Type, St> MatCameraView(const Vector3<Type>& forward, const Vector3<Type>& right,
-                                             const Vector3& cameraOrigin) noexcept
+                                             const Vector3<Type>& up, const Vector3<Type>& cameraOrigin) noexcept
     {
         return  Mat<4, 4, Type, St>
         {

include/omath/Matrix.hpp

@@ -2,10 +2,10 @@
 #include <initializer_list>
 #include <memory>
 #include <string>
+#include "Vector3.hpp"
 
 namespace omath
 {
-    class Vector3;
 
     class Matrix final
     {
@@ -19,10 +19,10 @@ namespace omath
         static Matrix ToScreenMatrix(float screenWidth, float screenHeight);
 
         [[nodiscard]]
-        static Matrix TranslationMatrix(const Vector3& diff);
+        static Matrix TranslationMatrix(const Vector3<float>& diff);
 
         [[nodiscard]]
-        static Matrix OrientationMatrix(const Vector3& forward, const Vector3& right, const Vector3& up);
+        static Matrix OrientationMatrix(const Vector3<float>& forward, const Vector3<float>& right, const Vector3<float>& up);
 
         [[nodiscard]]
         static Matrix ProjectionMatrix(float fieldOfView, float aspectRatio, float near, float far);

include/omath/Triangle.hpp

@@ -16,12 +16,12 @@ namespace omath
         {
         }
 
-        Vector3 m_vertex1;
+        Vector3<float> m_vertex1;
-        Vector3 m_vertex2;
+        Vector3<float> m_vertex2;
-        Vector3 m_vertex3;
+        Vector3<float> m_vertex3;
 
         [[nodiscard]]
-        constexpr Vector3 CalculateNormal() const
+        constexpr Vector3<float> CalculateNormal() const
         {
             const auto b = SideBVector();
             const auto a = SideAVector();
@@ -41,7 +41,7 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Vector3 SideAVector() const
+        constexpr Vector3<float> SideAVector() const
         {
             return m_vertex1 - m_vertex2;
         }
@@ -61,12 +61,12 @@ namespace omath
             return std::abs(sideA*sideA + sideB*sideB - hypot*hypot) <= 0.0001f;
         }
         [[nodiscard]]
-        constexpr Vector3 SideBVector() const
+        constexpr Vector3<float> SideBVector() const
         {
             return m_vertex3 - m_vertex2;
         }
         [[nodiscard]]
-        constexpr Vector3 MidPoint() const
+        constexpr Vector3<float> MidPoint() const
         {
             return (m_vertex1 + m_vertex2 + m_vertex3) / 3;
         }

include/omath/Vector2.hpp

@@ -8,16 +8,18 @@
 
 namespace omath
 {
+
+    template<class Type> requires std::is_arithmetic_v<Type>
     class Vector2
     {
     public:
-        float x = 0.f;
+        Type x = static_cast<Type>(0);
-        float y = 0.f;
+        Type y = static_cast<Type>(0);
 
         // Constructors
         constexpr Vector2() = default;
 
-        constexpr Vector2(const float x, const float y) : x(x), y(y) {}
+        constexpr Vector2(const Type& x, const Type& y) : x(x), y(y) {}
 
         // Equality operators
         [[nodiscard]]
@@ -65,7 +67,7 @@ namespace omath
             return *this;
         }
 
-        constexpr Vector2& operator*=(const float fl)
+        constexpr Vector2& operator*=(const Type& fl)
         {
             x *= fl;
             y *= fl;
@@ -73,7 +75,7 @@ namespace omath
             return *this;
         }
 
-        constexpr Vector2& operator/=(const float fl)
+        constexpr Vector2& operator/=(const Type& fl)
         {
             x /= fl;
             y /= fl;
@@ -81,7 +83,7 @@ namespace omath
             return *this;
         }
 
-        constexpr Vector2& operator+=(const float fl)
+        constexpr Vector2& operator+=(const Type& fl)
         {
             x += fl;
             y += fl;
@@ -89,7 +91,7 @@ namespace omath
             return *this;
         }
 
-        constexpr Vector2& operator-=(const float fl)
+        constexpr Vector2& operator-=(const Type& fl)
         {
             x -= fl;
             y -= fl;
@@ -98,45 +100,45 @@ namespace omath
         }
 
         // Basic vector operations
-        [[nodiscard]] float DistTo(const Vector2& vOther) const
+        [[nodiscard]] Type DistTo(const Vector2& vOther) const
         {
             return std::sqrt(DistToSqr(vOther));
         }
 
-        [[nodiscard]] constexpr float DistToSqr(const Vector2& vOther) const
+        [[nodiscard]] constexpr Type DistToSqr(const Vector2& vOther) const
         {
             return (x - vOther.x) * (x - vOther.x) + (y - vOther.y) * (y - vOther.y);
         }
 
-        [[nodiscard]] constexpr float Dot(const Vector2& vOther) const
+        [[nodiscard]] constexpr Type Dot(const Vector2& vOther) const
         {
             return x * vOther.x + y * vOther.y;
         }
 
 #ifndef _MSC_VER
-        [[nodiscard]] constexpr float Length() const
+        [[nodiscard]] constexpr Type& Length() const
         {
             return std::hypot(x, y);
         }
 
         [[nodiscard]] constexpr Vector2 Normalized() const
         {
-            const float len = Length();
+            const Type len = Length();
             return len > 0.f ? *this / len : *this;
         }
 #else
-        [[nodiscard]] float Length() const
+        [[nodiscard]] Type Length() const
         {
             return std::hypot(x, y);
         }
 
         [[nodiscard]] Vector2 Normalized() const
         {
-            const float len = Length();
+            const Type len = Length();
             return len > 0.f ? *this / len : *this;
         }
 #endif
-        [[nodiscard]] constexpr float LengthSqr() const
+        [[nodiscard]] constexpr Type LengthSqr() const
         {
             return x * x + y * y;
         }
@@ -187,13 +189,13 @@ namespace omath
         }
 
          // Sum of elements
-        [[nodiscard]] constexpr float Sum() const
+        [[nodiscard]] constexpr Type Sum() const
         {
             return x + y;
         }
 
         [[nodiscard]]
-        constexpr std::tuple<float, float> AsTuple() const
+        constexpr std::tuple<Type, Type> AsTuple() const
         {
             return std::make_tuple(x, y);
         }

include/omath/Vector3.hpp

@@ -20,16 +20,17 @@ namespace omath
         IMPOSSIBLE_BETWEEN_ANGLE,
     };
 
-    class Vector3 : public Vector2
+    template<class Type> requires std::is_arithmetic_v<Type>
+    class Vector3 : public Vector2<Type>
     {
     public:
-        float z = 0.f;
+        Type z = static_cast<Type>(0);
-        constexpr Vector3(const float x, const float y, const float z) : Vector2(x, y), z(z) { }
+        constexpr Vector3(const Type& x, const Type& y, const Type& z) : Vector2<Type>(x, y), z(z) { }
-        constexpr Vector3() : Vector2() {};
+        constexpr Vector3() : Vector2<Type>() {};
 
         [[nodiscard]] constexpr bool operator==(const Vector3& src) const
         {
-            return Vector2::operator==(src) && (src.z == z);
+            return Vector2<Type>::operator==(src) && (src.z == z);
         }
 
         [[nodiscard]] constexpr bool operator!=(const Vector3& src) const
@@ -39,7 +40,7 @@ namespace omath
 
         constexpr Vector3& operator+=(const Vector3& v)
         {
-            Vector2::operator+=(v);
+            Vector2<Type>::operator+=(v);
             z += v.z;
 
             return *this;
@@ -47,7 +48,7 @@ namespace omath
 
         constexpr Vector3& operator-=(const Vector3& v)
         {
-            Vector2::operator-=(v);
+            Vector2<Type>::operator-=(v);
             z -= v.z;
 
             return *this;
@@ -55,7 +56,7 @@ namespace omath
 
         constexpr Vector3& operator*=(const float fl)
         {
-            Vector2::operator*=(fl);
+            Vector2<Type>::operator*=(fl);
             z *= fl;
 
             return *this;
@@ -63,7 +64,7 @@ namespace omath
 
         constexpr Vector3& operator*=(const Vector3& v)
         {
-            Vector2::operator*=(v);
+            Vector2<Type>::operator*=(v);
             z *= v.z;
 
             return *this;
@@ -71,7 +72,7 @@ namespace omath
 
         constexpr Vector3& operator/=(const Vector3& v)
         {
-            Vector2::operator/=(v);
+            Vector2<Type>::operator/=(v);
             z /= v.z;
 
             return *this;
@@ -79,7 +80,7 @@ namespace omath
 
         constexpr Vector3& operator+=(const float fl)
         {
-            Vector2::operator+=(fl);
+            Vector2<Type>::operator+=(fl);
             z += fl;
 
             return *this;
@@ -87,7 +88,7 @@ namespace omath
 
         constexpr Vector3& operator/=(const float fl)
         {
-            Vector2::operator/=(fl);
+            Vector2<Type>::operator/=(fl);
             z /= fl;
 
             return *this;
@@ -95,7 +96,7 @@ namespace omath
 
         constexpr Vector3& operator-=(const float fl)
         {
-            Vector2::operator-=(fl);
+            Vector2<Type>::operator-=(fl);
             z -= fl;
 
             return *this;
@@ -103,7 +104,7 @@ namespace omath
 
         constexpr Vector3& Abs()
         {
-            Vector2::Abs();
+            Vector2<Type>::Abs();
             z = z < 0.f ? -z : z;
 
             return *this;
@@ -116,7 +117,7 @@ namespace omath
 
         [[nodiscard]] constexpr float Dot(const Vector3& vOther) const
         {
-            return Vector2::Dot(vOther) + z * vOther.z;
+            return Vector2<Type>::Dot(vOther) + z * vOther.z;
         }
 
 #ifndef _MSC_VER
@@ -142,7 +143,7 @@ namespace omath
 #else
         [[nodiscard]] float Length() const
         {
-            return std::hypot(x, y, z);
+            return std::hypot(this->x, this->y, z);
         }
 
         [[nodiscard]] Vector3 Normalized() const
@@ -152,9 +153,9 @@ namespace omath
             return length != 0 ? *this / length : *this;
         }
 
-        [[nodiscard]] float Length2D() const
+        [[nodiscard]] Type Length2D() const
         {
-            return Vector2::Length();
+            return Vector2<Type>::Length();
         }
 
         [[nodiscard]] float DistTo(const Vector3& vOther) const
@@ -166,51 +167,51 @@ namespace omath
 
         [[nodiscard]] constexpr float LengthSqr() const
         {
-            return Vector2::LengthSqr() + z * z;
+            return Vector2<Type>::LengthSqr() + z * z;
         }
 
         [[nodiscard]] constexpr Vector3 operator-() const
         {
-            return {-x, -y, -z};
+            return {-this->x, -this->y, -z};
         }
 
         [[nodiscard]] constexpr Vector3 operator+(const Vector3& v) const
         {
-            return {x + v.x, y + v.y, z + v.z};
+            return {this->x + v.x, this->y + v.y, z + v.z};
         }
 
         [[nodiscard]] constexpr Vector3 operator-(const Vector3& v) const
         {
-            return {x - v.x, y - v.y, z - v.z};
+            return {this->x - v.x, this->y - v.y, z - v.z};
         }
 
         [[nodiscard]] constexpr Vector3 operator*(const float fl) const
         {
-            return {x * fl, y * fl, z * fl};
+            return {this->x * fl, this->y * fl, z * fl};
         }
 
         [[nodiscard]] constexpr Vector3 operator*(const Vector3& v) const
         {
-            return {x * v.x, y * v.y, z * v.z};
+            return {this->x * v.x, this->y * v.y, z * v.z};
         }
 
         [[nodiscard]] constexpr Vector3 operator/(const float fl) const
         {
-            return {x / fl, y / fl, z / fl};
+            return {this->x / fl, this->y / fl, z / fl};
         }
 
         [[nodiscard]] constexpr Vector3 operator/(const Vector3& v) const
         {
-            return {x / v.x, y / v.y, z / v.z};
+            return {this->x / v.x, this->y / v.y, z / v.z};
         }
 
         [[nodiscard]] constexpr Vector3 Cross(const Vector3 &v) const
         {
             return
             {
-                y * v.z - z * v.y,
+                this->y * v.z - z * v.y,
-                z * v.x - x * v.z,
+                z * v.x - this->x * v.z,
-                x * v.y - y * v.x
+                this->x * v.y - this->y * v.x
             };
         }
         [[nodiscard]] constexpr float Sum() const
@@ -239,14 +240,25 @@ namespace omath
 
         [[nodiscard]] constexpr float Sum2D() const
         {
-            return Vector2::Sum();
+            return Vector2<Type>::Sum();
         }
 
-        [[nodiscard]] Vector3 ViewAngleTo(const Vector3& other) const;
-
         [[nodiscard]] constexpr std::tuple<float, float, float> AsTuple() const
         {
-            return std::make_tuple(x, y, z);
+            return std::make_tuple(this->x, this->y, z);
+        }
+
+        [[nodiscard]] Vector3 ViewAngleTo(const Vector3 &other) const
+        {
+            const float distance = DistTo(other);
+            const auto delta = other - *this;
+
+            return
+            {
+                angles::RadiansToDegrees(std::asin(delta.z / distance)),
+                angles::RadiansToDegrees(std::atan2(delta.y, delta.x)),
+                0
+            };
         }
     };
 }
@@ -254,9 +266,9 @@ namespace omath
 namespace std
 {
     template<>
-    struct hash<omath::Vector3>
+    struct hash<omath::Vector3<float>>
     {
-        std::size_t operator()(const omath::Vector3& vec) const noexcept
+        std::size_t operator()(const omath::Vector3<float>& vec) const noexcept
         {
             std::size_t hash = 0;
             constexpr std::hash<float> hasher;

include/omath/Vector4.hpp

@@ -8,18 +8,19 @@
 
 namespace omath
 {
-    class Vector4 : public Vector3
+    template <class Type>
+    class Vector4 : public Vector3<Type>
     {
     public:
-        float w;
+        Type w;
 
-        constexpr Vector4(const float x, const float y, const float z, const float w) : Vector3(x, y, z), w(w) {}
+        constexpr Vector4(const Type& x, const Type& y, const Type& z, const Type& w) : Vector3<Type>(x, y, z), w(w) {}
-        constexpr Vector4() : Vector3(), w(0.f) {};
+        constexpr Vector4() : Vector3<Type>(), w(0) {};
 
         [[nodiscard]]
         constexpr bool operator==(const Vector4& src) const
         {
-            return Vector3::operator==(src) && w == src.w;
+            return Vector3<Type>::operator==(src) && w == src.w;
         }
 
         [[nodiscard]]
@@ -30,7 +31,7 @@ namespace omath
 
         constexpr Vector4& operator+=(const Vector4& v)
         {
-            Vector3::operator+=(v);
+            Vector3<Type>::operator+=(v);
             w += v.w;
 
             return *this;
@@ -38,7 +39,7 @@ namespace omath
 
         constexpr Vector4& operator-=(const Vector4& v)
         {
-            Vector3::operator-=(v);
+            Vector3<Type>::operator-=(v);
             w -= v.w;
 
             return *this;
@@ -46,7 +47,7 @@ namespace omath
 
         constexpr Vector4& operator*=(const float scalar)
         {
-            Vector3::operator*=(scalar);
+            Vector3<Type>::operator*=(scalar);
             w *= scalar;
 
             return *this;
@@ -54,7 +55,7 @@ namespace omath
 
         constexpr Vector4& operator*=(const Vector4& v)
         {
-            Vector3::operator*=(v);
+            Vector3<Type>::operator*=(v);
             w *= v.w;
 
             return *this;
@@ -62,7 +63,7 @@ namespace omath
 
         constexpr Vector4& operator/=(const float scalar)
         {
-            Vector3::operator/=(scalar);
+            Vector3<Type>::operator/=(scalar);
             w /= scalar;
 
             return *this;
@@ -70,35 +71,38 @@ namespace omath
 
         constexpr Vector4& operator/=(const Vector4& v)
         {
-            Vector3::operator/=(v);
+            Vector3<Type>::operator/=(v);
             w /= v.w;
             return *this;
         }
 
-        [[nodiscard]] constexpr float LengthSqr() const
+        [[nodiscard]] constexpr Type LengthSqr() const
         {
-            return Vector3::LengthSqr() + w * w;
+            return Vector3<Type>::LengthSqr() + w * w;
         }
 
         [[nodiscard]] constexpr float Dot(const Vector4& vOther) const
         {
-            return Vector3::Dot(vOther) + w * vOther.w;
+            return Vector3<Type>::Dot(vOther) + w * vOther.w;
         }
 
-        [[nodiscard]] float Length() const;
+        [[nodiscard]] Vector3<Type> Length() const
+        {
+            return std::sqrt(LengthSqr());
+        }
 
         constexpr Vector4& Abs()
         {
-            Vector3::Abs();
+            Vector3<Type>::Abs();
             w = w < 0.f ? -w : w;
 
             return *this;
         }
         constexpr Vector4& Clamp(const float min, const float max)
         {
-            x = std::clamp(x, min, max);
+            this->x = std::clamp(this->x, min, max);
-            y = std::clamp(y, min, max);
+            this->y = std::clamp(this->y, min, max);
-            z = std::clamp(z, min, max);
+            this->z = std::clamp(this->z, min, max);
 
             return *this;
         }
@@ -106,49 +110,49 @@ namespace omath
         [[nodiscard]]
         constexpr Vector4 operator-() const
         {
-            return {-x, -y, -z, -w};
+            return {-this->x, -this->y, -this->z, -w};
         }
 
         [[nodiscard]]
         constexpr Vector4 operator+(const Vector4& v) const
         {
-            return {x + v.x, y + v.y, z + v.z, w + v.w};
+            return {this->x + v.x, this->y + v.y, this->z + v.z, w + v.w};
         }
 
         [[nodiscard]]
         constexpr Vector4 operator-(const Vector4& v) const
         {
-            return {x - v.x, y - v.y, z - v.z, w - v.w};
+            return {this->x - v.x, this->y - v.y, this->z - v.z, w - v.w};
         }
 
         [[nodiscard]]
         constexpr Vector4 operator*(const float scalar) const
         {
-            return {x * scalar, y * scalar, z * scalar, w * scalar};
+            return {this->x * scalar, this->y * scalar, this->z * scalar, w * scalar};
         }
 
         [[nodiscard]]
         constexpr Vector4 operator*(const Vector4& v) const
         {
-            return {x * v.x, y * v.y, z * v.z, w * v.w};
+            return {this->x * v.x, this->y * v.y, this->z * v.z, w * v.w};
         }
 
         [[nodiscard]]
         constexpr Vector4 operator/(const float scalar) const
         {
-            return {x / scalar, y / scalar, z / scalar, w / scalar};
+            return {this->x / scalar, this->y / scalar, this->z / scalar, w / scalar};
         }
 
         [[nodiscard]]
         constexpr Vector4 operator/(const Vector4& v) const
         {
-            return {x / v.x, y / v.y, z / v.z, w / v.w};
+            return {this->x / v.x, this->y / v.y, this->z / v.z, w / v.w};
         }
 
         [[nodiscard]]
-        constexpr float Sum() const
+        constexpr Type Sum() const
         {
-            return Vector3::Sum() + w;
+            return Vector3<Type>::Sum() + w;
         }
     };
 }

include/omath/collision/LineTracer.hpp

@@ -11,14 +11,14 @@ namespace omath::collision
     class Ray
     {
     public:
-        Vector3 start;
+        Vector3<float> start;
-        Vector3 end;
+        Vector3<float> end;
 
         [[nodiscard]]
-        Vector3 DirectionVector() const;
+        Vector3<float> DirectionVector() const;
 
         [[nodiscard]]
-        Vector3 DirectionVectorNormalized() const;
+        Vector3<float> DirectionVectorNormalized() const;
     };
     class LineTracer
     {
@@ -27,12 +27,12 @@ namespace omath::collision
 
 
         [[nodiscard]]
-        static bool CanTraceLine(const Ray& ray, const Triangle<Vector3>& triangle);
+        static bool CanTraceLine(const Ray& ray, const Triangle<Vector3<float>>& triangle);
 
 
         // Realization of Möller–Trumbore intersection algorithm
         // https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm
         [[nodiscard]]
-        static Vector3 GetRayHitPoint(const Ray& ray, const Triangle<Vector3>& triangle);
+        static Vector3<float> GetRayHitPoint(const Ray& ray, const Triangle<Vector3<float>>& triangle);
     };
 }

include/omath/engines/OpenGL/Camera.hpp

@@ -10,9 +10,9 @@ namespace omath::opengl
     class Camera final : public projection::Camera<Mat4x4, ViewAngles>
     {
     public:
-        Camera(const Vector3& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
+        Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
                const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, float near, float far);
-        void LookAt(const Vector3& target) override;
+        void LookAt(const Vector3<float>& target) override;
         [[nodiscard]] Mat4x4 CalcViewMatrix() const override;
         [[nodiscard]] Mat4x4 CalcProjectionMatrix() const override;
     };

include/omath/engines/OpenGL/Constants.hpp

@@ -10,9 +10,9 @@
 
 namespace omath::opengl
 {
-    constexpr Vector3 kAbsUp = {0, 1, 0};
+    constexpr Vector3<float> kAbsUp = {0, 1, 0};
-    constexpr Vector3 kAbsRight = {1, 0, 0};
+    constexpr Vector3<float> kAbsRight = {1, 0, 0};
-    constexpr Vector3 kAbsForward = {0, 0, -1};
+    constexpr Vector3<float> kAbsForward = {0, 0, -1};
 
     using Mat4x4 = Mat<4, 4, float, MatStoreType::COLUMN_MAJOR>;
     using Mat3x3 = Mat<4, 4, float, MatStoreType::COLUMN_MAJOR>;

include/omath/engines/OpenGL/Formulas.hpp

@@ -8,7 +8,7 @@
 namespace omath::opengl
 {
     [[nodiscard]]
-    inline Vector3 ForwardVector(const ViewAngles& angles)
+    inline Vector3<float> ForwardVector(const ViewAngles& angles)
     {
         const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsForward);
 
@@ -16,7 +16,7 @@ namespace omath::opengl
     }
 
     [[nodiscard]]
-    inline Vector3 RightVector(const ViewAngles& angles)
+    inline Vector3<float> RightVector(const ViewAngles& angles)
     {
         const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsRight);
 
@@ -24,14 +24,14 @@ namespace omath::opengl
     }
 
     [[nodiscard]]
-    inline Vector3 UpVector(const ViewAngles& angles)
+    inline Vector3<float> UpVector(const ViewAngles& angles)
     {
         const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsUp);
 
         return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
     }
 
-    [[nodiscard]] inline Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3& cam_origin)
+    [[nodiscard]] inline Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
     {
         return MatCameraView<float, MatStoreType::COLUMN_MAJOR>(-ForwardVector(angles), RightVector(angles), UpVector(angles), cam_origin);
     }

include/omath/engines/Source/Camera.hpp

@@ -10,9 +10,9 @@ namespace omath::source
     class Camera final : public projection::Camera<Mat4x4, ViewAngles>
     {
     public:
-        Camera(const Vector3& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
+        Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
                const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, float near, float far);
-        void LookAt(const Vector3& target) override;
+        void LookAt(const Vector3<float>& target) override;
         [[nodiscard]] Mat4x4 CalcViewMatrix() const override;
         [[nodiscard]] Mat4x4 CalcProjectionMatrix() const override;
     };

include/omath/engines/Source/Constants.hpp

@@ -9,9 +9,9 @@
 #include <omath/ViewAngles.hpp>
 namespace omath::source
 {
-    constexpr Vector3 kAbsUp = {0, 0, 1};
+    constexpr Vector3<float> kAbsUp = {0, 0, 1};
-    constexpr Vector3 kAbsRight = {0, -1, 0};
+    constexpr Vector3<float> kAbsRight = {0, -1, 0};
-    constexpr Vector3 kAbsForward = {1, 0, 0};
+    constexpr Vector3<float> kAbsForward = {1, 0, 0};
 
     using Mat4x4 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
     using Mat3x3 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;

include/omath/engines/Source/Formulas.hpp

@@ -7,7 +7,7 @@
 namespace omath::source
 {
     [[nodiscard]]
-    inline Vector3 ForwardVector(const ViewAngles& angles)
+    inline Vector3<float> ForwardVector(const ViewAngles& angles)
     {
         const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsForward);
 
@@ -15,7 +15,7 @@ namespace omath::source
     }
 
     [[nodiscard]]
-    inline Vector3 RightVector(const ViewAngles& angles)
+    inline Vector3<float> RightVector(const ViewAngles& angles)
     {
         const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsRight);
 
@@ -23,14 +23,14 @@ namespace omath::source
     }
 
     [[nodiscard]]
-    inline Vector3 UpVector(const ViewAngles& angles)
+    inline Vector3<float> UpVector(const ViewAngles& angles)
     {
         const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsUp);
 
         return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
     }
 
-    [[nodiscard]] inline Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3& cam_origin)
+    [[nodiscard]] inline Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
     {
         return MatCameraView(ForwardVector(angles), RightVector(angles), UpVector(angles), cam_origin);
     }

include/omath/pathfinding/Astar.hpp

@@ -14,12 +14,17 @@ namespace omath::pathfinding
     {
     public:
         [[nodiscard]]
-        static std::vector<Vector3> FindPath(const Vector3& start, const Vector3& end, const NavigationMesh& navMesh);
+        static std::vector<Vector3<float>> FindPath(const Vector3<float>& start, const Vector3<float>& end,
+                                                    const NavigationMesh& navMesh);
+
     private:
         [[nodiscard]]
-        static std::vector<Vector3> ReconstructFinalPath(const std::unordered_map<Vector3, PathNode>& closedList, const Vector3& current);
+        static std::vector<Vector3<float>>
+        ReconstructFinalPath(const std::unordered_map<Vector3<float>, PathNode>& closedList,
+                             const Vector3<float>& current);
 
         [[nodiscard]]
-        static auto GetPerfectNode(const std::unordered_map<Vector3, PathNode>& openList, const Vector3& endVertex);
+        static auto GetPerfectNode(const std::unordered_map<Vector3<float>, PathNode>& openList,
+                                   const Vector3<float>& endVertex);
     };
-}
+} // namespace omath::pathfinding

include/omath/pathfinding/NavigationMesh.hpp

@@ -22,17 +22,17 @@ namespace omath::pathfinding
     public:
 
         [[nodiscard]]
-        std::expected<Vector3, std::string> GetClosestVertex(const Vector3& point) const;
+        std::expected<Vector3<float>, std::string> GetClosestVertex(const Vector3<float>& point) const;
 
 
         [[nodiscard]]
-        const std::vector<Vector3>& GetNeighbors(const Vector3& vertex) const;
+        const std::vector<Vector3<float>>& GetNeighbors(const Vector3<float>& vertex) const;
 
         [[nodiscard]]
         bool Empty() const;
         [[nodiscard]] std::vector<uint8_t> Serialize() const;
         void Deserialize(const std::vector<uint8_t>& raw);
 
-        std::unordered_map<Vector3, std::vector<Vector3>> m_verTextMap;
+        std::unordered_map<Vector3<float>, std::vector<Vector3<float>>> m_verTextMap;
     };
 }

include/omath/projectile_prediction/ProjPredEngine.hpp

@@ -13,7 +13,7 @@ namespace omath::projectile_prediction
     {
     public:
         [[nodiscard]]
-        virtual std::optional<Vector3> MaybeCalculateAimPoint(const Projectile& projectile,
+        virtual std::optional<Vector3<float>> MaybeCalculateAimPoint(const Projectile& projectile,
                                                               const Target& target) const = 0;
         virtual ~ProjPredEngine() = default;
     };

include/omath/projectile_prediction/ProjPredEngineAVX2.hpp

@@ -9,7 +9,7 @@ namespace omath::projectile_prediction
     class ProjPredEngineAVX2 final : public ProjPredEngine
     {
     public:
-        [[nodiscard]] std::optional<Vector3> MaybeCalculateAimPoint(const Projectile& projectile,
+        [[nodiscard]] std::optional<Vector3<float>> MaybeCalculateAimPoint(const Projectile& projectile,
                                                                     const Target& target) const override;
 
 
@@ -17,7 +17,7 @@ namespace omath::projectile_prediction
         ~ProjPredEngineAVX2() override = default;
 
     private:
-        [[nodiscard]] static std::optional<float> CalculatePitch(const Vector3& projOrigin, const Vector3& targetPos,
+        [[nodiscard]] static std::optional<float> CalculatePitch(const Vector3<float>& projOrigin, const Vector3<float>& targetPos,
                                                                  float bulletGravity, float v0, float time);
         const float m_gravityConstant;
         const float m_simulationTimeStep;

include/omath/projectile_prediction/ProjPredEngineLegacy.hpp

@@ -20,7 +20,7 @@ namespace omath::projectile_prediction
                                       float distanceTolerance);
 
         [[nodiscard]]
-        std::optional<Vector3> MaybeCalculateAimPoint(const Projectile& projectile,
+        std::optional<Vector3<float>> MaybeCalculateAimPoint(const Projectile& projectile,
                                                       const Target& target) const override;
 
     private:
@@ -31,11 +31,11 @@ namespace omath::projectile_prediction
 
         [[nodiscard]]
         std::optional<float> MaybeCalculateProjectileLaunchPitchAngle(const Projectile& projectile,
-                                                                      const Vector3& targetPosition) const;
+                                                                      const Vector3<float>& targetPosition) const;
 
 
         [[nodiscard]]
-        bool IsProjectileReachedTarget(const Vector3& targetPosition, const Projectile& projectile, float pitch,
+        bool IsProjectileReachedTarget(const Vector3<float>& targetPosition, const Projectile& projectile, float pitch,
                                        float time) const;
     };
 } // namespace omath::projectile_prediction

include/omath/projectile_prediction/Projectile.hpp

@@ -12,9 +12,9 @@ namespace omath::projectile_prediction
     public:
 
         [[nodiscard]]
-        Vector3 PredictPosition(float pitch, float yaw, float time, float gravity) const;
+        Vector3<float> PredictPosition(float pitch, float yaw, float time, float gravity) const;
 
-        Vector3 m_origin;
+        Vector3<float> m_origin;
         float m_launchSpeed{};
         float m_gravityScale{};
     };

include/omath/projectile_prediction/Target.hpp

@@ -12,7 +12,7 @@ namespace omath::projectile_prediction
     public:
 
         [[nodiscard]]
-        constexpr Vector3 PredictPosition(const float time, const float gravity) const
+        constexpr Vector3<float> PredictPosition(const float time, const float gravity) const
         {
             auto predicted = m_origin + m_velocity * time;
 
@@ -22,8 +22,8 @@ namespace omath::projectile_prediction
             return predicted;
         }
 
-        Vector3 m_origin;
+        Vector3<float> m_origin;
-        Vector3 m_velocity;
+        Vector3<float> m_velocity;
         bool m_isAirborne{};
     };
 }

include/omath/projection/Camera.hpp

@@ -31,7 +31,7 @@ namespace omath::projection
     {
     public:
         virtual ~Camera() = default;
-        Camera(const Vector3& position, const ViewAnglesType& viewAngles, const ViewPort& viewPort,
+        Camera(const Vector3<float>& position, const ViewAnglesType& viewAngles, const ViewPort& viewPort,
                const FieldOfView& fov, const float near, const float far) :
             m_viewPort(viewPort), m_fieldOfView(fov), m_farPlaneDistance(far), m_nearPlaneDistance(near),
             m_viewAngles(viewAngles), m_origin(position)
@@ -39,7 +39,7 @@ namespace omath::projection
 
         }
 
-        virtual void LookAt(const Vector3& target) = 0;
+        virtual void LookAt(const Vector3<float>& target) = 0;
 
         [[nodiscard]] virtual Mat4x4Type CalcViewMatrix() const = 0;
 
@@ -74,7 +74,7 @@ namespace omath::projection
             m_viewProjectionMatrix = CalcViewProjectionMatrix();
         }
 
-        void SetOrigin(const Vector3& origin)
+        void SetOrigin(const Vector3<float>& origin)
         {
             m_origin = origin;
             m_viewProjectionMatrix = CalcViewProjectionMatrix();
@@ -106,12 +106,12 @@ namespace omath::projection
             return m_viewAngles;
         }
 
-        [[nodiscard]] const Vector3& GetOrigin() const
+        [[nodiscard]] const Vector3<float>& GetOrigin() const
         {
             return m_origin;
         }
 
-        [[nodiscard]] std::expected<Vector3, Error> WorldToScreen(const Vector3& worldPosition) const
+        [[nodiscard]] std::expected<Vector3<float>, Error> WorldToScreen(const Vector3<float>& worldPosition) const
         {
             if (!m_viewProjectionMatrix.has_value())
                 m_viewProjectionMatrix = CalcViewProjectionMatrix();
@@ -143,7 +143,7 @@ namespace omath::projection
 
 
         ViewAnglesType m_viewAngles;
-        Vector3 m_origin;
+        Vector3<float> m_origin;
 
     private:
         template<class Type>

source/CMakeLists.txt

@@ -1,9 +1,6 @@
 target_sources(omath PRIVATE
-        Vector3.cpp
         Matrix.cpp
         color.cpp
-        Vector4.cpp
-        Vector2.cpp
 )
 
 add_subdirectory(projectile_prediction)

source/Matrix.cpp

@@ -315,7 +315,7 @@ namespace omath
         };
     }
 
-    Matrix Matrix::TranslationMatrix(const Vector3& diff)
+    Matrix Matrix::TranslationMatrix(const Vector3<float>& diff)
     {
         return {
                 {1.f, 0.f, 0.f, 0.f},
@@ -325,7 +325,7 @@ namespace omath
         };
     }
 
-    Matrix Matrix::OrientationMatrix(const Vector3& forward, const Vector3& right, const Vector3& up)
+    Matrix Matrix::OrientationMatrix(const Vector3<float>& forward, const Vector3<float>& right, const Vector3<float>& up)
     {
         return {
                 {right.x, up.x, forward.x, 0.f},

source/Vector2.cpp

@@ -1,11 +0,0 @@
-//
-// Created by Vlad on 02.09.2024.
-//
-#include "omath/Vector2.hpp"
-#include <cmath>
-
-
-namespace omath
-{
-
-}

source/Vector3.cpp

@@ -1,23 +0,0 @@
-//
-// Created by vlad on 10/28/23.
-//
-
-#include <omath/Vector3.hpp>
-#include <cmath>
-#include <omath/Angles.hpp>
-
-namespace omath
-{
-    Vector3 Vector3::ViewAngleTo(const Vector3 &other) const
-    {
-        const float distance = DistTo(other);
-        const auto delta = other - *this;
-
-        return
-        {
-            angles::RadiansToDegrees(std::asin(delta.z / distance)),
-            angles::RadiansToDegrees(std::atan2(delta.y, delta.x)),
-            0.f
-        };
-    }
-}

source/Vector4.cpp

@@ -1,16 +0,0 @@
-//
-// Vector4.cpp
-//
-
-#include "omath/Vector4.hpp"
-#include <cmath>
-
-
-namespace omath
-{
-
-    float Vector4::Length() const
-    {
-        return std::sqrt(LengthSqr());
-    }
-}

source/collision/LineTracer.cpp

@@ -5,21 +5,21 @@
 
 namespace omath::collision
 {
-    bool LineTracer::CanTraceLine(const Ray& ray, const Triangle<Vector3>& triangle)
+    bool LineTracer::CanTraceLine(const Ray& ray, const Triangle<Vector3<float>>& triangle)
     {
         return GetRayHitPoint(ray, triangle) == ray.end;
     }
-    Vector3 Ray::DirectionVector() const
+    Vector3<float> Ray::DirectionVector() const
     {
         return end - start;
     }
 
-    Vector3 Ray::DirectionVectorNormalized() const
+    Vector3<float> Ray::DirectionVectorNormalized() const
     {
         return DirectionVector().Normalized();
     }
 
-    Vector3 LineTracer::GetRayHitPoint(const Ray& ray, const Triangle<Vector3>& triangle)
+    Vector3<float> LineTracer::GetRayHitPoint(const Ray& ray, const Triangle<Vector3<float>>& triangle)
     {
         constexpr float kEpsilon = std::numeric_limits<float>::epsilon();
 

source/engines/OpenGL/Camera.cpp

@@ -8,12 +8,12 @@
 namespace omath::opengl
 {
 
-    Camera::Camera(const Vector3& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
+    Camera::Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
                    const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, const float near, const float far) :
         projection::Camera<Mat4x4, ViewAngles>(position, viewAngles, viewPort, fov, near, far)
     {
     }
-    void Camera::LookAt([[maybe_unused]] const Vector3& target)
+    void Camera::LookAt([[maybe_unused]] const Vector3<float>& target)
     {
         const float distance = m_origin.DistTo(target);
         const auto delta = target - m_origin;

source/engines/Source/Camera.cpp

@@ -8,12 +8,12 @@
 namespace omath::source
 {
 
-    Camera::Camera(const Vector3& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
+    Camera::Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
                    const projection::FieldOfView& fov, const float near, const float far) :
         projection::Camera<Mat4x4, ViewAngles>(position, viewAngles, viewPort, fov, near, far)
     {
     }
-    void Camera::LookAt(const Vector3& target)
+    void Camera::LookAt(const Vector3<float>& target)
     {
         const float distance = m_origin.DistTo(target);
         const auto delta = target - m_origin;

source/pathfinding/Astar.cpp

@@ -13,15 +13,15 @@ namespace omath::pathfinding
 {
     struct PathNode final
     {
-        std::optional<Vector3> cameFrom;
+        std::optional<Vector3<float>> cameFrom;
         float gCost = 0.f;
     };
 
 
-    std::vector<Vector3> Astar::ReconstructFinalPath(const std::unordered_map<Vector3, PathNode>& closedList,
+    std::vector<Vector3<float>> Astar::ReconstructFinalPath(const std::unordered_map<Vector3<float>, PathNode>& closedList,
-                                                     const Vector3& current)
+                                                     const Vector3<float>& current)
     {
-        std::vector<Vector3> path;
+        std::vector<Vector3<float>> path;
         std::optional currentOpt = current;
 
         while (currentOpt)
@@ -39,7 +39,7 @@ namespace omath::pathfinding
         std::ranges::reverse(path);
         return path;
     }
-    auto Astar::GetPerfectNode(const std::unordered_map<Vector3, PathNode>& openList, const Vector3& endVertex)
+    auto Astar::GetPerfectNode(const std::unordered_map<Vector3<float>, PathNode>& openList, const Vector3<float>& endVertex)
     {
         return std::ranges::min_element(openList,
                                         [&endVertex](const auto& a, const auto& b)
@@ -50,10 +50,10 @@ namespace omath::pathfinding
                                         });
     }
 
-    std::vector<Vector3> Astar::FindPath(const Vector3& start, const Vector3& end, const NavigationMesh& navMesh)
+    std::vector<Vector3<float>> Astar::FindPath(const Vector3<float>& start, const Vector3<float>& end, const NavigationMesh& navMesh)
     {
-        std::unordered_map<Vector3, PathNode> closedList;
+        std::unordered_map<Vector3<float>, PathNode> closedList;
-        std::unordered_map<Vector3, PathNode> openList;
+        std::unordered_map<Vector3<float>, PathNode> openList;
 
         auto maybeStartVertex = navMesh.GetClosestVertex(start);
         auto maybeEndVertex = navMesh.GetClosestVertex(end);

source/pathfinding/NavigationMesh.cpp

@@ -7,7 +7,7 @@
 #include <algorithm>
 namespace omath::pathfinding
 {
-    std::expected<Vector3, std::string> NavigationMesh::GetClosestVertex(const Vector3 &point) const
+    std::expected<Vector3<float>, std::string> NavigationMesh::GetClosestVertex(const Vector3<float> &point) const
     {
         const auto res = std::ranges::min_element(m_verTextMap,
             [&point](const auto& a, const auto& b)
@@ -21,7 +21,7 @@ namespace omath::pathfinding
         return res->first;
     }
 
-    const std::vector<Vector3>& NavigationMesh::GetNeighbors(const Vector3 &vertex) const
+    const std::vector<Vector3<float>>& NavigationMesh::GetNeighbors(const Vector3<float> &vertex) const
     {
         return m_verTextMap.at(vertex);
     }
@@ -73,18 +73,18 @@ namespace omath::pathfinding
 
         while (offset < raw.size())
         {
-            Vector3 vertex;
+            Vector3<float> vertex;
             loadFromVector(raw, offset, vertex);
 
             uint16_t neighborsCount;
             loadFromVector(raw, offset, neighborsCount);
 
-            std::vector<Vector3> neighbors;
+            std::vector<Vector3<float>> neighbors;
             neighbors.reserve(neighborsCount);
 
             for (size_t i = 0; i < neighborsCount; ++i)
             {
-                Vector3 neighbor;
+                Vector3<float> neighbor;
                 loadFromVector(raw, offset, neighbor);
                 neighbors.push_back(neighbor);
             }

source/projectile_prediction/ProjPredEngineAVX2.cpp

@@ -6,7 +6,7 @@
 
 namespace omath::projectile_prediction
 {
-    std::optional<Vector3> ProjPredEngineAVX2::MaybeCalculateAimPoint(const Projectile& projectile,
+    std::optional<Vector3<float>> ProjPredEngineAVX2::MaybeCalculateAimPoint(const Projectile& projectile,
                                                                       const Target& target) const
     {
         const float bulletGravity = m_gravityConstant * projectile.m_gravityScale;
@@ -110,7 +110,7 @@ namespace omath::projectile_prediction
         m_maximumSimulationTime(simulationTimeStep)
     {
     }
-    std::optional<float> ProjPredEngineAVX2::CalculatePitch(const Vector3& projOrigin, const Vector3& targetPos,
+    std::optional<float> ProjPredEngineAVX2::CalculatePitch(const Vector3<float>& projOrigin, const Vector3<float>& targetPos,
                                                             const float bulletGravity, const float v0, const float time)
     {
         if (time <= 0.0f)

source/projectile_prediction/ProjPredEngineLegacy.cpp

@@ -11,7 +11,7 @@ namespace omath::projectile_prediction
     {
     }
 
-    std::optional<Vector3> ProjPredEngineLegacy::MaybeCalculateAimPoint(const Projectile& projectile,
+    std::optional<Vector3<float>> ProjPredEngineLegacy::MaybeCalculateAimPoint(const Projectile& projectile,
                                                                         const Target& target) const
     {
         for (float time = 0.f; time < m_maximumSimulationTime; time += m_simulationTimeStep)
@@ -36,7 +36,7 @@ namespace omath::projectile_prediction
 
     std::optional<float>
     ProjPredEngineLegacy::MaybeCalculateProjectileLaunchPitchAngle(const Projectile& projectile,
-                                                                   const Vector3& targetPosition) const
+                                                                   const Vector3<float>& targetPosition) const
     {
         const auto bulletGravity = m_gravityConstant * projectile.m_gravityScale;
         const auto delta = targetPosition - projectile.m_origin;
@@ -57,7 +57,7 @@ namespace omath::projectile_prediction
         return angles::RadiansToDegrees(angle);
     }
 
-    bool ProjPredEngineLegacy::IsProjectileReachedTarget(const Vector3& targetPosition, const Projectile& projectile,
+    bool ProjPredEngineLegacy::IsProjectileReachedTarget(const Vector3<float>& targetPosition, const Projectile& projectile,
                                                          const float pitch, const float time) const
     {
         const auto yaw = projectile.m_origin.ViewAngleTo(targetPosition).y;

source/projectile_prediction/Projectile.cpp

@@ -8,7 +8,7 @@
 
 namespace omath::projectile_prediction
 {
-    Vector3 Projectile::PredictPosition(const float pitch, const float yaw, const float time, const float gravity) const
+    Vector3<float> Projectile::PredictPosition(const float pitch, const float yaw, const float time, const float gravity) const
     {
         auto currentPos = m_origin + source::ForwardVector({source::PitchAngle::FromDegrees(-pitch),
                                                             source::YawAngle::FromDegrees(yaw),

tests/engines/UnitTestOpenGL.cpp

@@ -62,7 +62,7 @@ TEST(UnitTestOpenGL, CameraSetAndGetOrigin)
 {
     auto cam = omath::opengl::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
 
-    EXPECT_EQ(cam.GetOrigin(), omath::Vector3{});
+    EXPECT_EQ(cam.GetOrigin(), omath::Vector3<float>{});
     cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
 
     EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);

tests/engines/UnitTestSourceEngine.cpp

@@ -62,7 +62,7 @@ TEST(UnitTestSourceEngine, CameraSetAndGetOrigin)
 {
     auto cam = omath::source::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
 
-    EXPECT_EQ(cam.GetOrigin(), omath::Vector3{});
+    EXPECT_EQ(cam.GetOrigin(), omath::Vector3<float>{});
     cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
 
     EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);

tests/general/UnitTestLineTrace.cpp

@@ -10,10 +10,10 @@ class LineTracerTest : public ::testing::Test
 {
 protected:
     // Set up common variables for use in each test
-    Vector3 vertex1{0.0f, 0.0f, 0.0f};
+    Vector3<float> vertex1{0.0f, 0.0f, 0.0f};
-    Vector3 vertex2{1.0f, 0.0f, 0.0f};
+    Vector3<float> vertex2{1.0f, 0.0f, 0.0f};
-    Vector3 vertex3{0.0f, 1.0f, 0.0f};
+    Vector3<float> vertex3{0.0f, 1.0f, 0.0f};
-    Triangle<Vector3> triangle{vertex1, vertex2, vertex3};
+    Triangle<Vector3<float>> triangle{vertex1, vertex2, vertex3};
 };
 
 // Test that a ray intersecting the triangle returns false for CanTraceLine
@@ -71,7 +71,7 @@ TEST_F(LineTracerTest, TriangleFarBeyondRayEndPoint)
     constexpr Ray ray{{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 1.0f}};
 
     // Define a triangle far beyond the ray's endpoint
-    constexpr Triangle<Vector3> distantTriangle{
+    constexpr Triangle<Vector3<float>> distantTriangle{
         {1000.0f, 1000.0f, 1000.0f}, {1001.0f, 1000.0f, 1000.0f}, {1000.0f, 1001.0f, 1000.0f}
     };
 

tests/general/UnitTestTriangle.cpp

@@ -13,28 +13,28 @@ class UnitTestTriangle : public ::testing::Test
 {
 protected:
     // Define some Triangles to use in tests
-    Triangle<Vector3> t1;
+    Triangle<Vector3<float>> t1;
-    Triangle<Vector3> t2;
+    Triangle<Vector3<float>> t2;
-    Triangle<Vector3> t3;
+    Triangle<Vector3<float>> t3;
 
     constexpr void SetUp() override
     {
         // Triangle with vertices (0, 0, 0), (1, 0, 0), (0, 1, 0)
-        t1 = Triangle<Vector3>(
+        t1 = Triangle<Vector3<float>>(
             Vector3(0.0f, 0.0f, 0.0f),
             Vector3(1.0f, 0.0f, 0.0f),
             Vector3(0.0f, 1.0f, 0.0f)
         );
 
         // Triangle with vertices (1, 2, 3), (4, 5, 6), (7, 8, 9)
-        t2 = Triangle<Vector3>(
+        t2 = Triangle<Vector3<float>>(
             Vector3(1.0f, 2.0f, 3.0f),
             Vector3(4.0f, 5.0f, 6.0f),
             Vector3(7.0f, 8.0f, 9.0f)
         );
 
         // An isosceles right triangle
-        t3 = Triangle<Vector3>(
+        t3 = Triangle<Vector3<float>>(
             Vector3(0.0f, 0.0f, 0.0f),
             Vector3(2.0f, 0.0f, 0.0f),
             Vector3(0.0f, 2.0f, 0.0f)
@@ -45,7 +45,7 @@ protected:
 // Test constructor and vertices
 TEST_F(UnitTestTriangle, Constructor)
 {
-    constexpr Triangle<Vector3> t(
+    constexpr Triangle<Vector3<float>> t(
         Vector3(1.0f, 2.0f, 3.0f),
         Vector3(4.0f, 5.0f, 6.0f),
         Vector3(7.0f, 8.0f, 9.0f)
@@ -113,7 +113,7 @@ TEST_F(UnitTestTriangle, SideVectors)
 
 TEST_F(UnitTestTriangle, IsRectangular)
 {
-    EXPECT_TRUE(Triangle<Vector3>({2,0,0}, {}, {0,2,0}).IsRectangular());
+    EXPECT_TRUE(Triangle<Vector3<float>>({2,0,0}, {}, {0,2,0}).IsRectangular());
 }
 // Test midpoint
 TEST_F(UnitTestTriangle, MidPoint)

tests/general/UnitTestVector2.cpp

@@ -12,8 +12,8 @@ using namespace omath;
 class UnitTestVector2 : public ::testing::Test
 {
 protected:
-    Vector2 v1;
+    Vector2<float> v1;
-    Vector2 v2;
+    Vector2<float> v2;
 
     constexpr void SetUp() override
     {
@@ -25,7 +25,7 @@ protected:
 // Test constructor and default values
 TEST_F(UnitTestVector2, Constructor_Default)
 {
-    constexpr Vector2 v;
+    constexpr Vector2<float> v;
     EXPECT_FLOAT_EQ(v.x, 0.0f);
     EXPECT_FLOAT_EQ(v.y, 0.0f);
 }

tests/general/UnitTestVector3.cpp

@@ -13,8 +13,8 @@ using namespace omath;
 class UnitTestVector3 : public ::testing::Test
 {
 protected:
-    Vector3 v1;
+    Vector3<float> v1;
-    Vector3 v2;
+    Vector3<float> v2;
 
     void SetUp() override
     {
@@ -26,7 +26,7 @@ protected:
 // Test constructor and default values
 TEST_F(UnitTestVector3, Constructor_Default)
 {
-    constexpr Vector3 v;
+    constexpr Vector3<float> v;
     EXPECT_FLOAT_EQ(v.x, 0.0f);
     EXPECT_FLOAT_EQ(v.y, 0.0f);
     EXPECT_FLOAT_EQ(v.z, 0.0f);
@@ -34,7 +34,7 @@ TEST_F(UnitTestVector3, Constructor_Default)
 
 TEST_F(UnitTestVector3, Constructor_Values)
 {
-    constexpr Vector3 v(1.0f, 2.0f, 3.0f);
+    constexpr Vector3<float> v(1.0f, 2.0f, 3.0f);
     EXPECT_FLOAT_EQ(v.x, 1.0f);
     EXPECT_FLOAT_EQ(v.y, 2.0f);
     EXPECT_FLOAT_EQ(v.z, 3.0f);

tests/general/UnitTestVector4.cpp

@@ -14,8 +14,8 @@ using namespace omath;
 class UnitTestVector4 : public ::testing::Test
 {
 protected:
-    Vector4 v1;
+    Vector4<float> v1;
-    Vector4 v2;
+    Vector4<float> v2;
 
     void SetUp() override
     {
@@ -27,7 +27,7 @@ protected:
 // Test constructor and default values
 TEST_F(UnitTestVector4, Constructor_Default)
 {
-    constexpr Vector4 v;
+    constexpr Vector4<float> v;
     EXPECT_FLOAT_EQ(v.x, 0.0f);
     EXPECT_FLOAT_EQ(v.y, 0.0f);
     EXPECT_FLOAT_EQ(v.z, 0.0f);