diff --git a/src/ObjCommon/XModel/XModelCommon.h b/src/ObjCommon/XModel/XModelCommon.h
index 82f6bbef..4bc42851 100644
--- a/src/ObjCommon/XModel/XModelCommon.h
+++ b/src/ObjCommon/XModel/XModelCommon.h
@@ -1,11 +1,18 @@
 #pragma once
 
-#include "Math/Quaternion.h"
 #include "Utils/DistinctMapper.h"
 
 #include <string>
 #include <vector>
 
+struct XModelQuaternion
+{
+    float x;
+    float y;
+    float z;
+    float w;
+};
+
 struct XModelBone
 {
     std::string name;
@@ -13,8 +20,8 @@ struct XModelBone
     float scale[3];
     float globalOffset[3];
     float localOffset[3];
-    Quaternion32 globalRotation;
-    Quaternion32 localRotation;
+    XModelQuaternion globalRotation;
+    XModelQuaternion localRotation;
 };
 
 struct XModelBoneWeight
diff --git a/src/ObjLoading.lua b/src/ObjLoading.lua
index 30605cdb..9bda05ab 100644
--- a/src/ObjLoading.lua
+++ b/src/ObjLoading.lua
@@ -56,4 +56,5 @@ function ObjLoading:project()
 		minizip:include(includes)
 		zlib:include(includes)
 		json:include(includes)
+		eigen:include(includes)
 end
diff --git a/src/ObjLoading/AssetLoading/AbstractGdtEntryReader.cpp b/src/ObjLoading/AssetLoading/AbstractGdtEntryReader.cpp
index 01eba76a..307ce108 100644
--- a/src/ObjLoading/AssetLoading/AbstractGdtEntryReader.cpp
+++ b/src/ObjLoading/AssetLoading/AbstractGdtEntryReader.cpp
@@ -80,16 +80,16 @@ float AbstractGdtEntryReader::ReadFloatProperty(const std::string& propertyName,
     return result;
 }
 
-Vector2f AbstractGdtEntryReader::ReadVec2Property(const std::string& propertyName, const Vector2f defaultValue) const
+GdtVec2 AbstractGdtEntryReader::ReadVec2Property(const std::string& propertyName, const GdtVec2 defaultValue) const
 {
     const auto foundProperty = m_entry.m_properties.find(propertyName);
     if (foundProperty == m_entry.m_properties.end())
         return defaultValue;
 
     std::istringstream iss(foundProperty->second);
-    Vector2f result;
+    GdtVec2 result;
 
-    iss >> result(0) >> result(1);
+    iss >> result.x >> result.y;
 
     if (iss.fail())
     {
@@ -101,16 +101,16 @@ Vector2f AbstractGdtEntryReader::ReadVec2Property(const std::string& propertyNam
     return result;
 }
 
-Vector3f AbstractGdtEntryReader::ReadVec3Property(const std::string& propertyName, const Vector3f defaultValue) const
+GdtVec3 AbstractGdtEntryReader::ReadVec3Property(const std::string& propertyName, const GdtVec3 defaultValue) const
 {
     const auto foundProperty = m_entry.m_properties.find(propertyName);
     if (foundProperty == m_entry.m_properties.end())
         return defaultValue;
 
     std::istringstream iss(foundProperty->second);
-    Vector3f result;
+    GdtVec3 result;
 
-    iss >> result(0) >> result(1) >> result(2);
+    iss >> result.x >> result.y >> result.z;
 
     if (iss.fail())
     {
@@ -122,16 +122,16 @@ Vector3f AbstractGdtEntryReader::ReadVec3Property(const std::string& propertyNam
     return result;
 }
 
-Vector4f AbstractGdtEntryReader::ReadVec4Property(const std::string& propertyName, const Vector4f defaultValue) const
+GdtVec4 AbstractGdtEntryReader::ReadVec4Property(const std::string& propertyName, const GdtVec4 defaultValue) const
 {
     const auto foundProperty = m_entry.m_properties.find(propertyName);
     if (foundProperty == m_entry.m_properties.end())
         return defaultValue;
 
     std::istringstream iss(foundProperty->second);
-    Vector4f result;
+    GdtVec4 result;
 
-    iss >> result(0) >> result(1) >> result(2) >> result(3);
+    iss >> result.x >> result.y >> result.z >> result.w;
 
     if (iss.fail())
     {
diff --git a/src/ObjLoading/AssetLoading/AbstractGdtEntryReader.h b/src/ObjLoading/AssetLoading/AbstractGdtEntryReader.h
index a373570b..1b76c3ed 100644
--- a/src/ObjLoading/AssetLoading/AbstractGdtEntryReader.h
+++ b/src/ObjLoading/AssetLoading/AbstractGdtEntryReader.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "Math/Vector.h"
 #include "Obj/Gdt/GdtEntry.h"
 #include "Utils/ClassUtils.h"
 
@@ -16,6 +15,27 @@ private:
     std::string m_message;
 };
 
+struct GdtVec2
+{
+    float x;
+    float y;
+};
+
+struct GdtVec3
+{
+    float x;
+    float y;
+    float z;
+};
+
+struct GdtVec4
+{
+    float x;
+    float y;
+    float z;
+    float w;
+};
+
 class AbstractGdtEntryReader
 {
 protected:
@@ -25,9 +45,9 @@ protected:
     _NODISCARD bool ReadBoolProperty(const std::string& propertyName, bool defaultValue = false) const;
     _NODISCARD int ReadIntegerProperty(const std::string& propertyName, int defaultValue = 0) const;
     _NODISCARD float ReadFloatProperty(const std::string& propertyName, float defaultValue = 0.0f) const;
-    _NODISCARD Vector2f ReadVec2Property(const std::string& propertyName, Vector2f defaultValue = {}) const;
-    _NODISCARD Vector3f ReadVec3Property(const std::string& propertyName, Vector3f defaultValue = {}) const;
-    _NODISCARD Vector4f ReadVec4Property(const std::string& propertyName, Vector4f defaultValue = {}) const;
+    _NODISCARD GdtVec2 ReadVec2Property(const std::string& propertyName, GdtVec2 defaultValue = {}) const;
+    _NODISCARD GdtVec3 ReadVec3Property(const std::string& propertyName, GdtVec3 defaultValue = {}) const;
+    _NODISCARD GdtVec4 ReadVec4Property(const std::string& propertyName, GdtVec4 defaultValue = {}) const;
 
     const GdtEntry& m_entry;
 };
diff --git a/src/ObjLoading/Game/IW4/AssetLoaders/AssetLoaderMaterial.cpp b/src/ObjLoading/Game/IW4/AssetLoaders/AssetLoaderMaterial.cpp
index 57efc24f..d10a43b9 100644
--- a/src/ObjLoading/Game/IW4/AssetLoaders/AssetLoaderMaterial.cpp
+++ b/src/ObjLoading/Game/IW4/AssetLoaders/AssetLoaderMaterial.cpp
@@ -7,7 +7,6 @@
 #include "Game/IW4/MaterialConstantsIW4.h"
 #include "Game/IW4/ObjConstantsIW4.h"
 #include "Game/IW4/TechsetConstantsIW4.h"
-#include "Math/Vector.h"
 #include "ObjLoading.h"
 #include "Pool/GlobalAssetPool.h"
 #include "StateMap/StateMapFromTechniqueExtractor.h"
@@ -198,14 +197,14 @@ namespace IW4
 
             const auto distortionScaleX = ReadFloatProperty("distortionScaleX");
             const auto distortionScaleY = ReadFloatProperty("distortionScaleY");
-            AddConstant("distortionScale", Vector4f(distortionScaleX, distortionScaleY, 0, 0));
+            AddConstant("distortionScale", {distortionScaleX, distortionScaleY, 0, 0});
 
             if (uvAnim)
             {
                 const auto uvScrollX = ReadFloatProperty("uvScrollX");
                 const auto uvScrollY = ReadFloatProperty("uvScrollY");
                 const auto uvScrollRotate = ReadFloatProperty("uvScrollRotate");
-                AddConstant("uvAnimParms", Vector4f(uvScrollX, uvScrollY, uvScrollRotate, 0));
+                AddConstant("uvAnimParms", {uvScrollX, uvScrollY, uvScrollRotate, 0});
             }
         }
 
@@ -504,11 +503,11 @@ namespace IW4
                 const auto zFeatherDepth = ReadFloatProperty("zFeatherDepth");
                 if (std::fpclassify(zFeatherDepth) == FP_ZERO)
                     throw GdtReadingException("zFeatherDepth may not be zero");
-                AddConstant("featherParms", Vector4f(1.0f / zFeatherDepth, zFeatherDepth, 0, 0));
+                AddConstant("featherParms", {1.0f / zFeatherDepth, zFeatherDepth, 0, 0});
             }
 
             if (std::fpclassify(eyeOffsetDepth) != FP_ZERO)
-                AddConstant("eyeOffsetParms", Vector4f(eyeOffsetDepth, 0, 0, 0));
+                AddConstant("eyeOffsetParms", {eyeOffsetDepth, 0, 0, 0});
 
             const auto colorTint = ReadVec4Property("colorTint", {1.0f, 1.0f, 1.0f, 1.0f});
             AddConstant("colorTint", colorTint);
@@ -1009,13 +1008,13 @@ namespace IW4
             m_textures.push_back(textureDef);
         }
 
-        void AddConstant(const std::string& constantName, Vector4f literalData)
+        void AddConstant(const std::string& constantName, const GdtVec4& literalData)
         {
             MaterialConstantDef constantDef{};
-            constantDef.literal[0] = literalData(0);
-            constantDef.literal[1] = literalData(1);
-            constantDef.literal[2] = literalData(2);
-            constantDef.literal[3] = literalData(3);
+            constantDef.literal[0] = literalData.x;
+            constantDef.literal[1] = literalData.y;
+            constantDef.literal[2] = literalData.z;
+            constantDef.literal[3] = literalData.w;
             strncpy(constantDef.name, constantName.c_str(), std::extent_v<decltype(MaterialConstantDef::name)>);
             constantDef.nameHash = Common::R_HashString(constantName.c_str());
 
diff --git a/src/ObjWriting/Game/IW3/AssetDumpers/AssetDumperXModel.cpp b/src/ObjWriting/Game/IW3/AssetDumpers/AssetDumperXModel.cpp
index 862b0470..bc99e50b 100644
--- a/src/ObjWriting/Game/IW3/AssetDumpers/AssetDumperXModel.cpp
+++ b/src/ObjWriting/Game/IW3/AssetDumpers/AssetDumperXModel.cpp
@@ -1,7 +1,6 @@
 #include "AssetDumperXModel.h"
 
 #include "Game/IW3/CommonIW3.h"
-#include "Math/Quaternion.h"
 #include "ObjWriting.h"
 #include "Utils/DistinctMapper.h"
 #include "Utils/HalfFloat.h"
@@ -125,25 +124,31 @@ namespace
             bone.globalOffset[0] = model->baseMat[boneNum].trans[0];
             bone.globalOffset[1] = model->baseMat[boneNum].trans[1];
             bone.globalOffset[2] = model->baseMat[boneNum].trans[2];
-            bone.globalRotation = Quaternion32(
-                model->baseMat[boneNum].quat[0], model->baseMat[boneNum].quat[1], model->baseMat[boneNum].quat[2], model->baseMat[boneNum].quat[3]);
+            bone.globalRotation = {
+                model->baseMat[boneNum].quat[0],
+                model->baseMat[boneNum].quat[1],
+                model->baseMat[boneNum].quat[2],
+                model->baseMat[boneNum].quat[3],
+            };
 
             if (boneNum < model->numRootBones)
             {
                 bone.localOffset[0] = 0;
                 bone.localOffset[1] = 0;
                 bone.localOffset[2] = 0;
-                bone.localRotation = Quaternion32(0, 0, 0, 1);
+                bone.localRotation = {0, 0, 0, 1};
             }
             else
             {
                 bone.localOffset[0] = model->trans[boneNum - model->numRootBones][0];
                 bone.localOffset[1] = model->trans[boneNum - model->numRootBones][1];
                 bone.localOffset[2] = model->trans[boneNum - model->numRootBones][2];
-                bone.localRotation = Quaternion32(QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][0]),
-                                                  QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][1]),
-                                                  QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][2]),
-                                                  QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][3]));
+                bone.localRotation = {
+                    QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][0]),
+                    QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][1]),
+                    QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][2]),
+                    QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][3]),
+                };
             }
 
             out.m_bones.emplace_back(std::move(bone));
diff --git a/src/ObjWriting/Game/IW4/AssetDumpers/AssetDumperMaterial.cpp b/src/ObjWriting/Game/IW4/AssetDumpers/AssetDumperMaterial.cpp
index 8281590d..1fc8b5a0 100644
--- a/src/ObjWriting/Game/IW4/AssetDumpers/AssetDumperMaterial.cpp
+++ b/src/ObjWriting/Game/IW4/AssetDumpers/AssetDumperMaterial.cpp
@@ -3,9 +3,9 @@
 #include "Game/IW4/MaterialConstantsIW4.h"
 #include "Game/IW4/ObjConstantsIW4.h"
 #include "Game/IW4/TechsetConstantsIW4.h"
-#include "Math/Vector.h"
 #include "Utils/ClassUtils.h"
 
+#include <Eigen>
 #include <iomanip>
 #include <nlohmann/json.hpp>
 #include <sstream>
@@ -450,7 +450,7 @@ namespace IW4
     class ConstantsInfo
     {
     public:
-        Vector4f m_color_tint = Vector4f(1.0f, 1.0f, 1.0f, 1.0f);
+        Eigen::Vector4f m_color_tint = Eigen::Vector4f(1.0f, 1.0f, 1.0f, 1.0f);
         float m_env_map_min = 0.2f;
         float m_env_map_max = 1.0f;
         float m_env_map_exponent = 2.5f;
@@ -460,13 +460,13 @@ namespace IW4
         float m_falloff_end_angle = 65.0f;
         float m_dist_falloff_begin_distance = 200.0f;
         float m_dist_falloff_end_distance = 10.0f;
-        Vector4f m_falloff_begin_color = Vector4f(1.0f, 1.0f, 1.0f, 1.0f);
-        Vector4f m_falloff_end_color = Vector4f(0.5f, 0.5f, 0.5f, 0.5f);
-        Vector2f m_detail_scale = Vector2f(8.0f, 8.0f);
-        Vector2f m_distortion_scale = Vector2f(0.5f, 0.5f);
-        Vector4f m_color_obj_min = Vector4f(0.0f, 0.0f, 0.0f, 0.0f);
-        Vector4f m_color_obj_max = Vector4f(1.0f, 1.0f, 1.0f, 1.0f);
-        Vector4f m_water_color = Vector4f(1.0f, 1.0f, 1.0f, 1.0f);
+        Eigen::Vector4f m_falloff_begin_color = Eigen::Vector4f(1.0f, 1.0f, 1.0f, 1.0f);
+        Eigen::Vector4f m_falloff_end_color = Eigen::Vector4f(0.5f, 0.5f, 0.5f, 0.5f);
+        Eigen::Vector2f m_detail_scale = Eigen::Vector2f(8.0f, 8.0f);
+        Eigen::Vector2f m_distortion_scale = Eigen::Vector2f(0.5f, 0.5f);
+        Eigen::Vector4f m_color_obj_min = Eigen::Vector4f(0.0f, 0.0f, 0.0f, 0.0f);
+        Eigen::Vector4f m_color_obj_max = Eigen::Vector4f(1.0f, 1.0f, 1.0f, 1.0f);
+        Eigen::Vector4f m_water_color = Eigen::Vector4f(1.0f, 1.0f, 1.0f, 1.0f);
 
         // Speed in which the wave animation is played
         float m_flag_speed = 1.0f;
@@ -497,7 +497,7 @@ namespace IW4
             m_entry.m_properties.emplace(std::make_pair(key, std::move(value)));
         }
 
-        void SetValue(const std::string& key, const Vector4f& v)
+        void SetValue(const std::string& key, const Eigen::Vector4f& v)
         {
             std::ostringstream ss;
             ss << v.x() << " " << v.y() << " " << v.z() << " " << v.w();
@@ -1183,7 +1183,7 @@ namespace IW4
 
                 if (constant.nameHash == Common::R_HashString("colorTint"))
                 {
-                    m_constants_info.m_color_tint = Vector4f(constant.literal);
+                    m_constants_info.m_color_tint = Eigen::Vector4f(constant.literal);
                 }
                 else if (constant.nameHash == Common::R_HashString("envMapParms"))
                 {
@@ -1198,11 +1198,11 @@ namespace IW4
                 }
                 else if (constant.nameHash == Common::R_HashString("falloffBeginColor"))
                 {
-                    m_constants_info.m_falloff_begin_color = Vector4f(constant.literal);
+                    m_constants_info.m_falloff_begin_color = Eigen::Vector4f(constant.literal);
                 }
                 else if (constant.nameHash == Common::R_HashString("falloffEndColor"))
                 {
-                    m_constants_info.m_falloff_end_color = Vector4f(constant.literal);
+                    m_constants_info.m_falloff_end_color = Eigen::Vector4f(constant.literal);
                 }
                 else if (constant.nameHash == Common::R_HashString("eyeOffsetParms"))
                 {
@@ -1227,14 +1227,15 @@ namespace IW4
                         {
                             const auto detailScaleFactorX = static_cast<float>(colorMapTexture->width) / static_cast<float>(detailMapTexture->width);
                             const auto detailScaleFactorY = static_cast<float>(colorMapTexture->height) / static_cast<float>(detailMapTexture->height);
-                            m_constants_info.m_detail_scale = Vector2f(constant.literal[0] / detailScaleFactorX, constant.literal[1] / detailScaleFactorY);
+                            m_constants_info.m_detail_scale =
+                                Eigen::Vector2f(constant.literal[0] / detailScaleFactorX, constant.literal[1] / detailScaleFactorY);
                         }
                         else
-                            m_constants_info.m_detail_scale = Vector2f(constant.literal[0], constant.literal[1]);
+                            m_constants_info.m_detail_scale = Eigen::Vector2f(constant.literal[0], constant.literal[1]);
                     }
                     else
                     {
-                        m_constants_info.m_detail_scale = Vector2f(constant.literal[0], constant.literal[1]);
+                        m_constants_info.m_detail_scale = Eigen::Vector2f(constant.literal[0], constant.literal[1]);
                     }
                 }
                 else if (constant.nameHash == Common::R_HashString("flagParms"))
@@ -1252,7 +1253,7 @@ namespace IW4
                 }
                 else if (constant.nameHash == Common::R_HashString("distortionScale"))
                 {
-                    m_constants_info.m_distortion_scale = Vector2f(constant.literal[0], constant.literal[1]);
+                    m_constants_info.m_distortion_scale = Eigen::Vector2f(constant.literal[0], constant.literal[1]);
                 }
                 else if (constant.nameHash == Common::R_HashString("uvAnimParms"))
                 {
@@ -1262,15 +1263,15 @@ namespace IW4
                 }
                 else if (constant.nameHash == Common::R_HashString("colorObjMin"))
                 {
-                    m_constants_info.m_color_obj_min = Vector4f(constant.literal);
+                    m_constants_info.m_color_obj_min = Eigen::Vector4f(constant.literal);
                 }
                 else if (constant.nameHash == Common::R_HashString("colorObjMax"))
                 {
-                    m_constants_info.m_color_obj_max = Vector4f(constant.literal);
+                    m_constants_info.m_color_obj_max = Eigen::Vector4f(constant.literal);
                 }
                 else if (constant.nameHash == Common::R_HashString("waterColor"))
                 {
-                    m_constants_info.m_water_color = Vector4f(constant.literal);
+                    m_constants_info.m_water_color = Eigen::Vector4f(constant.literal);
                 }
                 else
                 {
diff --git a/src/ObjWriting/Game/IW4/AssetDumpers/AssetDumperXModel.cpp b/src/ObjWriting/Game/IW4/AssetDumpers/AssetDumperXModel.cpp
index d8310cdd..ebfa38c2 100644
--- a/src/ObjWriting/Game/IW4/AssetDumpers/AssetDumperXModel.cpp
+++ b/src/ObjWriting/Game/IW4/AssetDumpers/AssetDumperXModel.cpp
@@ -1,7 +1,6 @@
 #include "AssetDumperXModel.h"
 
 #include "Game/IW4/CommonIW4.h"
-#include "Math/Quaternion.h"
 #include "ObjWriting.h"
 #include "Utils/DistinctMapper.h"
 #include "Utils/HalfFloat.h"
@@ -120,25 +119,31 @@ namespace
             bone.globalOffset[0] = model->baseMat[boneNum].trans[0];
             bone.globalOffset[1] = model->baseMat[boneNum].trans[1];
             bone.globalOffset[2] = model->baseMat[boneNum].trans[2];
-            bone.globalRotation = Quaternion32(
-                model->baseMat[boneNum].quat[0], model->baseMat[boneNum].quat[1], model->baseMat[boneNum].quat[2], model->baseMat[boneNum].quat[3]);
+            bone.globalRotation = {
+                model->baseMat[boneNum].quat[0],
+                model->baseMat[boneNum].quat[1],
+                model->baseMat[boneNum].quat[2],
+                model->baseMat[boneNum].quat[3],
+            };
 
             if (boneNum < model->numRootBones)
             {
                 bone.localOffset[0] = 0;
                 bone.localOffset[1] = 0;
                 bone.localOffset[2] = 0;
-                bone.localRotation = Quaternion32(0, 0, 0, 1);
+                bone.localRotation = {0, 0, 0, 1};
             }
             else
             {
                 bone.localOffset[0] = model->trans[boneNum - model->numRootBones][0];
                 bone.localOffset[1] = model->trans[boneNum - model->numRootBones][1];
                 bone.localOffset[2] = model->trans[boneNum - model->numRootBones][2];
-                bone.localRotation = Quaternion32(QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][0]),
-                                                  QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][1]),
-                                                  QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][2]),
-                                                  QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][3]));
+                bone.localRotation = {
+                    QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][0]),
+                    QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][1]),
+                    QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][2]),
+                    QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][3]),
+                };
             }
 
             out.m_bones.emplace_back(std::move(bone));
diff --git a/src/ObjWriting/Game/IW5/AssetDumpers/AssetDumperXModel.cpp b/src/ObjWriting/Game/IW5/AssetDumpers/AssetDumperXModel.cpp
index 1cf707d5..bd089b9f 100644
--- a/src/ObjWriting/Game/IW5/AssetDumpers/AssetDumperXModel.cpp
+++ b/src/ObjWriting/Game/IW5/AssetDumpers/AssetDumperXModel.cpp
@@ -1,7 +1,6 @@
 #include "AssetDumperXModel.h"
 
 #include "Game/IW5/CommonIW5.h"
-#include "Math/Quaternion.h"
 #include "ObjWriting.h"
 #include "Utils/DistinctMapper.h"
 #include "Utils/HalfFloat.h"
@@ -120,25 +119,31 @@ namespace
             bone.globalOffset[0] = model->baseMat[boneNum].trans[0];
             bone.globalOffset[1] = model->baseMat[boneNum].trans[1];
             bone.globalOffset[2] = model->baseMat[boneNum].trans[2];
-            bone.globalRotation = Quaternion32(
-                model->baseMat[boneNum].quat[0], model->baseMat[boneNum].quat[1], model->baseMat[boneNum].quat[2], model->baseMat[boneNum].quat[3]);
+            bone.globalRotation = {
+                model->baseMat[boneNum].quat[0],
+                model->baseMat[boneNum].quat[1],
+                model->baseMat[boneNum].quat[2],
+                model->baseMat[boneNum].quat[3],
+            };
 
             if (boneNum < model->numRootBones)
             {
                 bone.localOffset[0] = 0;
                 bone.localOffset[1] = 0;
                 bone.localOffset[2] = 0;
-                bone.localRotation = Quaternion32(0, 0, 0, 1);
+                bone.localRotation = {0, 0, 0, 1};
             }
             else
             {
                 bone.localOffset[0] = model->trans[boneNum - model->numRootBones][0];
                 bone.localOffset[1] = model->trans[boneNum - model->numRootBones][1];
                 bone.localOffset[2] = model->trans[boneNum - model->numRootBones][2];
-                bone.localRotation = Quaternion32(QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][0]),
-                                                  QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][1]),
-                                                  QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][2]),
-                                                  QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][3]));
+                bone.localRotation = {
+                    QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][0]),
+                    QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][1]),
+                    QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][2]),
+                    QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][3]),
+                };
             }
 
             out.m_bones.emplace_back(std::move(bone));
diff --git a/src/ObjWriting/Game/T5/AssetDumpers/AssetDumperXModel.cpp b/src/ObjWriting/Game/T5/AssetDumpers/AssetDumperXModel.cpp
index ed204379..1ec2fb26 100644
--- a/src/ObjWriting/Game/T5/AssetDumpers/AssetDumperXModel.cpp
+++ b/src/ObjWriting/Game/T5/AssetDumpers/AssetDumperXModel.cpp
@@ -1,7 +1,6 @@
 #include "AssetDumperXModel.h"
 
 #include "Game/T5/CommonT5.h"
-#include "Math/Quaternion.h"
 #include "ObjWriting.h"
 #include "Utils/DistinctMapper.h"
 #include "Utils/HalfFloat.h"
@@ -125,25 +124,31 @@ namespace
             bone.globalOffset[0] = model->baseMat[boneNum].trans[0];
             bone.globalOffset[1] = model->baseMat[boneNum].trans[1];
             bone.globalOffset[2] = model->baseMat[boneNum].trans[2];
-            bone.globalRotation = Quaternion32(
-                model->baseMat[boneNum].quat[0], model->baseMat[boneNum].quat[1], model->baseMat[boneNum].quat[2], model->baseMat[boneNum].quat[3]);
+            bone.globalRotation = {
+                model->baseMat[boneNum].quat[0],
+                model->baseMat[boneNum].quat[1],
+                model->baseMat[boneNum].quat[2],
+                model->baseMat[boneNum].quat[3],
+            };
 
             if (boneNum < model->numRootBones)
             {
                 bone.localOffset[0] = 0;
                 bone.localOffset[1] = 0;
                 bone.localOffset[2] = 0;
-                bone.localRotation = Quaternion32(0, 0, 0, 1);
+                bone.localRotation = {0, 0, 0, 1};
             }
             else
             {
                 bone.localOffset[0] = model->trans[boneNum - model->numRootBones][0];
                 bone.localOffset[1] = model->trans[boneNum - model->numRootBones][1];
                 bone.localOffset[2] = model->trans[boneNum - model->numRootBones][2];
-                bone.localRotation = Quaternion32(QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][0]),
-                                                  QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][1]),
-                                                  QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][2]),
-                                                  QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][3]));
+                bone.localRotation = {
+                    QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][0]),
+                    QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][1]),
+                    QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][2]),
+                    QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][3]),
+                };
             }
 
             out.m_bones.emplace_back(std::move(bone));
diff --git a/src/ObjWriting/Game/T6/AssetDumpers/AssetDumperXModel.cpp b/src/ObjWriting/Game/T6/AssetDumpers/AssetDumperXModel.cpp
index f7b98d0e..722151d3 100644
--- a/src/ObjWriting/Game/T6/AssetDumpers/AssetDumperXModel.cpp
+++ b/src/ObjWriting/Game/T6/AssetDumpers/AssetDumperXModel.cpp
@@ -1,7 +1,6 @@
 #include "AssetDumperXModel.h"
 
 #include "Game/T6/CommonT6.h"
-#include "Math/Quaternion.h"
 #include "ObjWriting.h"
 #include "Utils/DistinctMapper.h"
 #include "Utils/QuatInt16.h"
@@ -136,25 +135,31 @@ namespace
             bone.globalOffset[0] = model->baseMat[boneNum].trans.x;
             bone.globalOffset[1] = model->baseMat[boneNum].trans.y;
             bone.globalOffset[2] = model->baseMat[boneNum].trans.z;
-            bone.globalRotation =
-                Quaternion32(model->baseMat[boneNum].quat.x, model->baseMat[boneNum].quat.y, model->baseMat[boneNum].quat.z, model->baseMat[boneNum].quat.w);
+            bone.globalRotation = {
+                model->baseMat[boneNum].quat.x,
+                model->baseMat[boneNum].quat.y,
+                model->baseMat[boneNum].quat.z,
+                model->baseMat[boneNum].quat.w,
+            };
 
             if (boneNum < model->numRootBones)
             {
                 bone.localOffset[0] = 0;
                 bone.localOffset[1] = 0;
                 bone.localOffset[2] = 0;
-                bone.localRotation = Quaternion32(0, 0, 0, 1);
+                bone.localRotation = {0, 0, 0, 1};
             }
             else
             {
                 bone.localOffset[0] = model->trans[boneNum - model->numRootBones][0];
                 bone.localOffset[1] = model->trans[boneNum - model->numRootBones][1];
                 bone.localOffset[2] = model->trans[boneNum - model->numRootBones][2];
-                bone.localRotation = Quaternion32(QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][0]),
-                                                  QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][1]),
-                                                  QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][2]),
-                                                  QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][3]));
+                bone.localRotation = {
+                    QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][0]),
+                    QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][1]),
+                    QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][2]),
+                    QuatInt16::ToFloat(model->quats[boneNum - model->numRootBones][3]),
+                };
             }
 
             out.m_bones.emplace_back(std::move(bone));
diff --git a/src/ObjWriting/XModel/Export/XModelExportWriter.cpp b/src/ObjWriting/XModel/Export/XModelExportWriter.cpp
index f65bc559..bd134ff7 100644
--- a/src/ObjWriting/XModel/Export/XModelExportWriter.cpp
+++ b/src/ObjWriting/XModel/Export/XModelExportWriter.cpp
@@ -1,7 +1,6 @@
 #include "XModelExportWriter.h"
 
-#include "Math/Quaternion.h"
-
+#include <Eigen>
 #include <chrono>
 #include <iomanip>
 #include <iostream>
@@ -61,10 +60,10 @@ protected:
             m_stream << std::format("OFFSET {:.6f}, {:.6f}, {:.6f}\n", bone.globalOffset[0], bone.globalOffset[1], bone.globalOffset[2]);
             m_stream << std::format("SCALE {:.6f}, {:.6f}, {:.6f}\n", bone.scale[0], bone.scale[1], bone.scale[2]);
 
-            const Matrix32 mat = bone.globalRotation.ToMatrix();
-            m_stream << std::format("X {:.6f}, {:.6f}, {:.6f}\n", mat.m_data[0][0], mat.m_data[1][0], mat.m_data[2][0]);
-            m_stream << std::format("Y {:.6f}, {:.6f}, {:.6f}\n", mat.m_data[0][1], mat.m_data[1][1], mat.m_data[2][1]);
-            m_stream << std::format("Z {:.6f}, {:.6f}, {:.6f}\n", mat.m_data[0][2], mat.m_data[1][2], mat.m_data[2][2]);
+            const auto mat = Eigen::Quaternionf(bone.globalRotation.w, bone.globalRotation.x, bone.globalRotation.y, bone.globalRotation.z).matrix();
+            m_stream << std::format("X {:.6f}, {:.6f}, {:.6f}\n", mat(0, 0), mat(1, 0), mat(2, 0));
+            m_stream << std::format("Y {:.6f}, {:.6f}, {:.6f}\n", mat(0, 1), mat(1, 1), mat(2, 1));
+            m_stream << std::format("Z {:.6f}, {:.6f}, {:.6f}\n", mat(0, 2), mat(1, 2), mat(2, 2));
             m_stream << '\n';
             boneNum++;
         }
diff --git a/src/ObjWriting/XModel/Gltf/GltfWriter.cpp b/src/ObjWriting/XModel/Gltf/GltfWriter.cpp
index 8133c334..46b0b185 100644
--- a/src/ObjWriting/XModel/Gltf/GltfWriter.cpp
+++ b/src/ObjWriting/XModel/Gltf/GltfWriter.cpp
@@ -1,7 +1,6 @@
 #include "GltfWriter.h"
 
 #include "GitVersion.h"
-#include "Math/Vector.h"
 #include "XModel/Gltf/GltfConstants.h"
 #include "XModel/Gltf/JsonGltf.h"
 
@@ -224,13 +223,12 @@ namespace
                 const auto& bone = xmodel.m_bones[boneIndex];
 
                 Eigen::Vector3f translation(bone.globalOffset[0], bone.globalOffset[2], -bone.globalOffset[1]);
-                Eigen::Quaternionf rotation(bone.globalRotation.m_w, bone.globalRotation.m_x, bone.globalRotation.m_z, -bone.globalRotation.m_y);
+                Eigen::Quaternionf rotation(bone.globalRotation.w, bone.globalRotation.x, bone.globalRotation.z, -bone.globalRotation.y);
                 if (bone.parentIndex >= 0)
                 {
                     const auto& parentBone = xmodel.m_bones[bone.parentIndex];
                     const auto inverseParentRotation =
-                        Eigen::Quaternionf(
-                            parentBone.globalRotation.m_w, parentBone.globalRotation.m_x, parentBone.globalRotation.m_z, -parentBone.globalRotation.m_y)
+                        Eigen::Quaternionf(parentBone.globalRotation.w, parentBone.globalRotation.x, parentBone.globalRotation.z, -parentBone.globalRotation.y)
                             .normalized()
                             .inverse()
                             .normalized();
@@ -521,8 +519,7 @@ namespace
                 for (const auto& bone : xmodel.m_bones)
                 {
                     const auto translation = Eigen::Translation3f(bone.globalOffset[0], bone.globalOffset[2], -bone.globalOffset[1]);
-                    const auto rotation =
-                        Eigen::Quaternionf(bone.globalRotation.m_w, bone.globalRotation.m_x, bone.globalRotation.m_z, -bone.globalRotation.m_y);
+                    const auto rotation = Eigen::Quaternionf(bone.globalRotation.w, bone.globalRotation.x, bone.globalRotation.z, -bone.globalRotation.y);
 
                     const auto inverseBindMatrix = (translation * rotation).matrix().inverse();
 
diff --git a/src/Utils/Math/Matrix.h b/src/Utils/Math/Matrix.h
deleted file mode 100644
index 4bbd96f1..00000000
--- a/src/Utils/Math/Matrix.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#pragma once
-
-template<typename T> class Matrix
-{
-public:
-    T m_data[4][4];
-
-    Matrix()
-        : m_data{
-            {T(1.0), 0,      0,      0     },
-            {0,      T(1.0), 0,      0     },
-            {0,      0,      T(1.0), 0     },
-            {0,      0,      0,      T(1.0)},
-    }
-    {
-    }
-
-    Matrix(T d00, T d01, T d02, T d03, T d10, T d11, T d12, T d13, T d20, T d21, T d22, T d23, T d30, T d31, T d32, T d33)
-        : m_data{
-            {d00, d01, d02, d03},
-            {d10, d11, d12, d13},
-            {d20, d21, d22, d23},
-            {d30, d31, d32, d33},
-    }
-    {
-    }
-
-    static Matrix<T> Identity()
-    {
-        return Matrix();
-    }
-};
-
-typedef Matrix<float> Matrix32;
-typedef Matrix<double> Matrix64;
diff --git a/src/Utils/Math/Quaternion.h b/src/Utils/Math/Quaternion.h
deleted file mode 100644
index b69cc414..00000000
--- a/src/Utils/Math/Quaternion.h
+++ /dev/null
@@ -1,186 +0,0 @@
-#pragma once
-
-#include "Matrix.h"
-#include "Utils/ClassUtils.h"
-
-template<typename T> class Quaternion
-{
-public:
-    T m_x;
-    T m_y;
-    T m_z;
-    T m_w;
-
-    Quaternion()
-    {
-        m_x = T(0);
-        m_y = T(0);
-        m_z = T(0);
-        m_w = T(1);
-    }
-
-    Quaternion(T x, T y, T z, T w)
-    {
-        m_x = x;
-        m_y = y;
-        m_z = z;
-        m_w = w;
-    }
-
-    _NODISCARD Matrix<T> ToMatrix() const
-    {
-        const T xx = m_x * m_x;
-        const T xy = m_x * m_y;
-        const T xz = m_x * m_z;
-        const T xw = m_x * m_w;
-        const T yy = m_y * m_y;
-        const T yz = m_y * m_z;
-        const T yw = m_y * m_w;
-        const T zz = m_z * m_z;
-        const T zw = m_z * m_w;
-
-        const T m00 = 1 - 2 * yy - 2 * zz;
-        const T m01 = 2 * xy - 2 * zw;
-        const T m02 = 2 * xz + 2 * yw;
-        const T m10 = 2 * xy + 2 * zw;
-        const T m11 = 1 - 2 * xx - 2 * zz;
-        const T m12 = 2 * yz - 2 * xw;
-        const T m20 = 2 * xz - 2 * yw;
-        const T m21 = 2 * yz + 2 * xw;
-        const T m22 = 1 - 2 * xx - 2 * yy;
-
-        return Matrix<T>(m00, m01, m02, 0, m10, m11, m12, 0, m20, m21, m22, 0, 0, 0, 0, T(1.0));
-    }
-
-    static T dot(const Quaternion& q1, const Quaternion& q2)
-    {
-        return static_cast<T>((q1.m_x * q2.m_x) + (q1.m_y * q2.m_y) + (q1.m_z * q2.m_z) + (q1.m_w * q2.m_w));
-    }
-
-    static Quaternion& conj(Quaternion& result)
-    {
-        result.m_x = -result.m_x;
-        result.m_y = -result.m_y;
-        result.m_z = -result.m_z;
-        return result;
-    }
-
-    static Quaternion& invert(Quaternion& result)
-    {
-        // from game programming gems p198
-        // do result = conj( q ) / norm( q )
-        Quaternion::conj(result);
-
-        // return if norm() is near 0 (divide by 0 would result in NaN)
-        T l = result.lengthSquared();
-        if (l < static_cast<T>(0.0001))
-        {
-            return result;
-        }
-
-        T l_inv = static_cast<T>(1.0) / l;
-        result.m_x *= l_inv;
-        result.m_y *= l_inv;
-        result.m_z *= l_inv;
-        result.m_w *= l_inv;
-        return result;
-    }
-
-    T lengthSquared() const
-    {
-        return Quaternion::dot(*this, *this);
-    }
-
-    T length() const
-    {
-        return sqrt(lengthSquared());
-    }
-
-    void Normalize()
-    {
-        const auto l = length();
-
-        // return if no magnitude (already as normalized as possible)
-        if (l < static_cast<T>(0.0001))
-            return;
-
-        T inverseLength = static_cast<T>(1.0) / l;
-        m_x *= inverseLength;
-        m_y *= inverseLength;
-        m_z *= inverseLength;
-        m_w *= inverseLength;
-    }
-
-    friend Quaternion operator+(const Quaternion& lhs, const Quaternion& rhs)
-    {
-        return Quaternion(lhs.m_x + rhs.m_x, lhs.m_y + rhs.m_y, lhs.m_z + rhs.m_z, lhs.m_w + rhs.m_w);
-    }
-
-    friend Quaternion operator-(const Quaternion& lhs, const Quaternion& rhs)
-    {
-        return Quaternion(lhs.m_x - rhs.m_x, lhs.m_y - rhs.m_y, lhs.m_z - rhs.m_z, lhs.m_w - rhs.m_w);
-    }
-
-    friend Quaternion& operator+=(Quaternion& lhs, const Quaternion& rhs)
-    {
-        lhs.m_x += rhs.m_x;
-        lhs.m_y += rhs.m_y;
-        lhs.m_z += rhs.m_z;
-        lhs.m_w += rhs.m_w;
-
-        return lhs;
-    }
-
-    friend Quaternion& operator-=(Quaternion& lhs, const Quaternion& rhs)
-    {
-        lhs.m_x -= rhs.m_x;
-        lhs.m_y -= rhs.m_y;
-        lhs.m_z -= rhs.m_z;
-        lhs.m_w -= rhs.m_w;
-
-        return lhs;
-    }
-
-    friend Quaternion operator*(const Quaternion& lhs, const Quaternion& rhs)
-    {
-        const T x2 = lhs.m_w * rhs.m_x + lhs.m_x * rhs.m_w + lhs.m_y * rhs.m_z - lhs.m_z * rhs.m_y;
-        const T y2 = lhs.m_w * rhs.m_y + lhs.m_y * rhs.m_w + lhs.m_z * rhs.m_x - lhs.m_x * rhs.m_z;
-        const T z2 = lhs.m_w * rhs.m_z + lhs.m_z * rhs.m_w + lhs.m_x * rhs.m_y - lhs.m_y * rhs.m_x;
-        const T w2 = lhs.m_w * rhs.m_w - lhs.m_x * rhs.m_x - lhs.m_y * rhs.m_y - lhs.m_z * rhs.m_z;
-
-        return Quaternion(x2, y2, z2, w2);
-    }
-
-    friend Quaternion operator/(const Quaternion& lhs, const Quaternion& rhs)
-    {
-        Quaternion rhsInv = rhs;
-        Quaternion::invert(rhsInv);
-        return lhs * rhsInv;
-    }
-
-    friend Quaternion& operator*=(Quaternion& lhs, const Quaternion& rhs)
-    {
-        const T x2 = lhs.m_w * rhs.m_x + lhs.m_x * rhs.m_w + lhs.m_y * rhs.m_z - lhs.m_z * rhs.m_y;
-        const T y2 = lhs.m_w * rhs.m_y + lhs.m_y * rhs.m_w + lhs.m_z * rhs.m_x - lhs.m_x * rhs.m_z;
-        const T z2 = lhs.m_w * rhs.m_z + lhs.m_z * rhs.m_w + lhs.m_x * rhs.m_y - lhs.m_y * rhs.m_x;
-        const T w2 = lhs.m_w * rhs.m_w - lhs.m_x * rhs.m_x - lhs.m_y * rhs.m_y - lhs.m_z * rhs.m_z;
-
-        lhs.m_x = x2;
-        lhs.m_y = y2;
-        lhs.m_z = z2;
-        lhs.m_w = w2;
-
-        return lhs;
-    }
-
-    friend Quaternion& operator/=(Quaternion& lhs, const Quaternion& rhs)
-    {
-        Quaternion rhsInv = rhs;
-        Quaternion::invert(rhsInv);
-        lhs *= rhsInv;
-        return lhs;
-    }
-};
-
-typedef Quaternion<float> Quaternion32;
-typedef Quaternion<double> Quaternion64;
diff --git a/src/Utils/Math/Vector.h b/src/Utils/Math/Vector.h
deleted file mode 100644
index 60092681..00000000
--- a/src/Utils/Math/Vector.h
+++ /dev/null
@@ -1,375 +0,0 @@
-#pragma once
-#include "Utils/ClassUtils.h"
-
-#include <cassert>
-#include <cstddef>
-
-template<typename T> class Vector2
-{
-    T m_value[2];
-
-public:
-    Vector2()
-        : m_value{T(0), T(0)}
-    {
-    }
-
-    Vector2(T x, T y)
-        : m_value{x, y}
-    {
-    }
-
-    explicit Vector2(const T* value)
-        : m_value{value[0], value[1]}
-    {
-    }
-
-    ~Vector2() = default;
-    Vector2(const Vector2& other) = default;
-    Vector2(Vector2&& other) noexcept = default;
-    Vector2& operator=(const Vector2& other) = default;
-    Vector2& operator=(Vector2&& other) noexcept = default;
-
-    _NODISCARD T& operator()(const size_t index)
-    {
-        assert(index < 2);
-        return m_value[index];
-    }
-
-    _NODISCARD const T& operator()(const size_t index) const
-    {
-        assert(index < 2);
-        return m_value[index];
-    }
-
-    _NODISCARD T& x()
-    {
-        return m_value[0];
-    }
-
-    _NODISCARD T& y()
-    {
-        return m_value[1];
-    }
-
-    _NODISCARD const T& x() const
-    {
-        return m_value[0];
-    }
-
-    _NODISCARD const T& y() const
-    {
-        return m_value[1];
-    }
-
-    friend Vector2 operator+(const Vector2& lhs, const Vector2& rhs)
-    {
-        return Vector2(lhs.m_value[0] + rhs.m_value[0], lhs.m_value[1] + rhs.m_value[1]);
-    }
-
-    friend Vector2 operator-(const Vector2& lhs, const Vector2& rhs)
-    {
-        return Vector2(lhs.m_value[0] - rhs.m_value[0], lhs.m_value[1] - rhs.m_value[1]);
-    }
-
-    friend Vector2& operator+=(Vector2& lhs, const Vector2& rhs)
-    {
-        lhs.m_value[0] += rhs.m_value[0];
-        lhs.m_value[1] += rhs.m_value[1];
-
-        return lhs;
-    }
-
-    friend Vector2& operator-=(Vector2& lhs, const Vector2& rhs)
-    {
-        lhs.m_value[0] -= rhs.m_value[0];
-        lhs.m_value[1] -= rhs.m_value[1];
-
-        return lhs;
-    }
-};
-
-typedef Vector2<float> Vector2f;
-typedef Vector2<double> Vector2d;
-
-template<typename T> class Vector3
-{
-    T m_value[3];
-
-public:
-    Vector3()
-        : m_value{T(0), T(0), T(0)}
-    {
-    }
-
-    Vector3(T x, T y, T z)
-        : m_value{x, y, z}
-    {
-    }
-
-    explicit Vector3(const T* value)
-        : m_value{value[0], value[1], value[2]}
-    {
-    }
-
-    ~Vector3() = default;
-    Vector3(const Vector3& other) = default;
-    Vector3(Vector3&& other) noexcept = default;
-    Vector3& operator=(const Vector3& other) = default;
-    Vector3& operator=(Vector3&& other) noexcept = default;
-
-    _NODISCARD T& operator()(const size_t index)
-    {
-        assert(index < 3);
-        return m_value[index];
-    }
-
-    _NODISCARD const T& operator()(const size_t index) const
-    {
-        assert(index < 3);
-        return m_value[index];
-    }
-
-    _NODISCARD T& x()
-    {
-        return m_value[0];
-    }
-
-    _NODISCARD T& y()
-    {
-        return m_value[1];
-    }
-
-    _NODISCARD T& z()
-    {
-        return m_value[2];
-    }
-
-    _NODISCARD const T& x() const
-    {
-        return m_value[0];
-    }
-
-    _NODISCARD const T& y() const
-    {
-        return m_value[1];
-    }
-
-    _NODISCARD const T& z() const
-    {
-        return m_value[2];
-    }
-
-    _NODISCARD T& r()
-    {
-        return m_value[0];
-    }
-
-    _NODISCARD T& g()
-    {
-        return m_value[1];
-    }
-
-    _NODISCARD T& b()
-    {
-        return m_value[2];
-    }
-
-    _NODISCARD const T& r() const
-    {
-        return m_value[0];
-    }
-
-    _NODISCARD const T& g() const
-    {
-        return m_value[1];
-    }
-
-    _NODISCARD const T& b() const
-    {
-        return m_value[2];
-    }
-
-    friend Vector3 operator+(const Vector3& lhs, const Vector3& rhs)
-    {
-        return Vector3(lhs.m_value[0] + rhs.m_value[0], lhs.m_value[1] + rhs.m_value[1], lhs.m_value[2] + rhs.m_value[2]);
-    }
-
-    friend Vector3 operator-(const Vector3& lhs, const Vector3& rhs)
-    {
-        return Vector3(lhs.m_value[0] - rhs.m_value[0], lhs.m_value[1] - rhs.m_value[1], lhs.m_value[2] - rhs.m_value[2]);
-    }
-
-    friend Vector3& operator+=(Vector3& lhs, const Vector3& rhs)
-    {
-        lhs.m_value[0] += rhs.m_value[0];
-        lhs.m_value[1] += rhs.m_value[1];
-        lhs.m_value[2] += rhs.m_value[2];
-
-        return lhs;
-    }
-
-    friend Vector3& operator-=(Vector3& lhs, const Vector3& rhs)
-    {
-        lhs.m_value[0] -= rhs.m_value[0];
-        lhs.m_value[1] -= rhs.m_value[1];
-        lhs.m_value[2] -= rhs.m_value[2];
-
-        return lhs;
-    }
-};
-
-typedef Vector3<float> Vector3f;
-typedef Vector3<double> Vector3d;
-
-template<typename T> class Vector4
-{
-    T m_value[4];
-
-public:
-    Vector4()
-        : m_value{T(0), T(0), T(0), T(0)}
-    {
-    }
-
-    Vector4(T x, T y, T z, T w)
-        : m_value{x, y, z, w}
-    {
-    }
-
-    explicit Vector4(const T* value)
-        : m_value{value[0], value[1], value[2], value[3]}
-    {
-    }
-
-    ~Vector4() = default;
-    Vector4(const Vector4& other) = default;
-    Vector4(Vector4&& other) noexcept = default;
-    Vector4& operator=(const Vector4& other) = default;
-    Vector4& operator=(Vector4&& other) noexcept = default;
-
-    _NODISCARD T& operator()(const size_t index)
-    {
-        assert(index < 4);
-        return m_value[index];
-    }
-
-    _NODISCARD const T& operator()(const size_t index) const
-    {
-        assert(index < 4);
-        return m_value[index];
-    }
-
-    _NODISCARD T& x()
-    {
-        return m_value[0];
-    }
-
-    _NODISCARD T& y()
-    {
-        return m_value[1];
-    }
-
-    _NODISCARD T& z()
-    {
-        return m_value[2];
-    }
-
-    _NODISCARD T& w()
-    {
-        return m_value[3];
-    }
-
-    _NODISCARD const T& x() const
-    {
-        return m_value[0];
-    }
-
-    _NODISCARD const T& y() const
-    {
-        return m_value[1];
-    }
-
-    _NODISCARD const T& z() const
-    {
-        return m_value[2];
-    }
-
-    _NODISCARD const T& w() const
-    {
-        return m_value[3];
-    }
-
-    _NODISCARD T& r()
-    {
-        return m_value[0];
-    }
-
-    _NODISCARD T& g()
-    {
-        return m_value[1];
-    }
-
-    _NODISCARD T& b()
-    {
-        return m_value[2];
-    }
-
-    _NODISCARD T& a()
-    {
-        return m_value[3];
-    }
-
-    _NODISCARD const T& r() const
-    {
-        return m_value[0];
-    }
-
-    _NODISCARD const T& g() const
-    {
-        return m_value[1];
-    }
-
-    _NODISCARD const T& b() const
-    {
-        return m_value[2];
-    }
-
-    _NODISCARD const T& a() const
-    {
-        return m_value[3];
-    }
-
-    friend Vector4 operator+(const Vector4& lhs, const Vector4& rhs)
-    {
-        return Vector4(lhs.m_value[0] + rhs.m_value[0], lhs.m_value[1] + rhs.m_value[1], lhs.m_value[2] + rhs.m_value[2], lhs.m_value[3] + rhs.m_value[3]);
-    }
-
-    friend Vector4 operator-(const Vector4& lhs, const Vector4& rhs)
-    {
-        return Vector4(lhs.m_value[0] - rhs.m_value[0], lhs.m_value[1] - rhs.m_value[1], lhs.m_value[2] - rhs.m_value[2], lhs.m_value[3] - rhs.m_value[3]);
-    }
-
-    friend Vector4& operator+=(Vector4& lhs, const Vector4& rhs)
-    {
-        lhs.m_value[0] += rhs.m_value[0];
-        lhs.m_value[1] += rhs.m_value[1];
-        lhs.m_value[2] += rhs.m_value[2];
-        lhs.m_value[3] += rhs.m_value[3];
-
-        return lhs;
-    }
-
-    friend Vector4& operator-=(Vector4& lhs, const Vector4& rhs)
-    {
-        lhs.m_value[0] -= rhs.m_value[0];
-        lhs.m_value[1] -= rhs.m_value[1];
-        lhs.m_value[2] -= rhs.m_value[2];
-        lhs.m_value[3] -= rhs.m_value[3];
-
-        return lhs;
-    }
-};
-
-typedef Vector4<float> Vector4f;
-typedef Vector4<double> Vector4d;