Removing .vscode project config

feat: Changes to Matrix2 FunctionTests
Insignificant changes
2025-05-04 21:31:44 +02:00 · 2025-05-04 21:30:14 +02:00 · 2025-05-04 21:29:31 +02:00 · 2025-05-04 21:28:51 +02:00 · 2025-05-04 21:27:53 +02:00 · 2025-05-04 21:26:24 +02:00
17 changed files with 3941 additions and 3426 deletions
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -21,7 +21,9 @@ clang-analyzer-*,
 -modernize-avoid-c-arrays,
 -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
 -readability-named-parameter,
-cert-env33-c
+-cert-env33-c,
+-readability-identifier-length,
+-cppcoreguidelines-pro-type-union-access
 '


--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -1,32 +0,0 @@
-{
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "name": "Debug MathTestFPU (gdb)",
-            "type": "cppdbg",
-            "request": "launch",
-            "program": "${workspaceFolder}/bin/1.0.0/Debug/MathTestFPU/MathTestFPU",
-            "args": [],
-            "stopAtEntry": false,
-            "cwd": "${fileDirname}",
-            "environment": [],
-            "externalConsole": false,
-            "MIMode": "gdb",
-            "setupCommands": [
-                {
-                    "description": "Enable pretty-printing for gdb",
-                    "text": "-enable-pretty-printing",
-                    "ignoreFailures": true
-                },
-                {
-                    "description": "Set Disassembly Flavor to Intel",
-                    "text": "-gdb-set disassembly-flavor intel",
-                    "ignoreFailures": true
-                }
-            ]
-        }
-    ]
-}
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,152 +0,0 @@
-{
-    "C_Cpp.formatting": "clangFormat",
-    "C_Cpp.loggingLevel": "Error",
-    "C_Cpp.default.cppStandard": "c++20",
-    "C_Cpp.default.includePath": [
-        "${workspaceFolder}/Engine/Source/Runtime/", 
-        "${workspaceFolder}/Engine/Source/ThirdParty/"
-    ],
-
-    "C_Cpp.default.browse.path": [
-        "${workspaceFolder}/Engine/Source/Runtime", 
-        "${workspaceFolder}/Engine/Source/ThirdParty"
-    ],
-    "C_Cpp.default.browse.databaseFilename": "${workspaceFolder}/.vscode/browse.vc.db",
-    "files.associations": {
-        "cstdint": "cpp",
-        "chrono": "cpp",
-        "string": "cpp",
-        "cctype": "cpp",
-        "clocale": "cpp",
-        "cmath": "cpp",
-        "cstdarg": "cpp",
-        "cstddef": "cpp",
-        "cstdio": "cpp",
-        "cstdlib": "cpp",
-        "cstring": "cpp",
-        "ctime": "cpp",
-        "cwchar": "cpp",
-        "cwctype": "cpp",
-        "any": "cpp",
-        "array": "cpp",
-        "atomic": "cpp",
-        "bit": "cpp",
-        "*.tcc": "cpp",
-        "bitset": "cpp",
-        "charconv": "cpp",
-        "cinttypes": "cpp",
-        "codecvt": "cpp",
-        "compare": "cpp",
-        "complex": "cpp",
-        "concepts": "cpp",
-        "condition_variable": "cpp",
-        "deque": "cpp",
-        "forward_list": "cpp",
-        "list": "cpp",
-        "map": "cpp",
-        "set": "cpp",
-        "unordered_map": "cpp",
-        "unordered_set": "cpp",
-        "vector": "cpp",
-        "exception": "cpp",
-        "expected": "cpp",
-        "algorithm": "cpp",
-        "functional": "cpp",
-        "iterator": "cpp",
-        "memory": "cpp",
-        "memory_resource": "cpp",
-        "numeric": "cpp",
-        "optional": "cpp",
-        "random": "cpp",
-        "ratio": "cpp",
-        "regex": "cpp",
-        "source_location": "cpp",
-        "string_view": "cpp",
-        "system_error": "cpp",
-        "tuple": "cpp",
-        "type_traits": "cpp",
-        "utility": "cpp",
-        "hash_map": "cpp",
-        "hash_set": "cpp",
-        "format": "cpp",
-        "fstream": "cpp",
-        "future": "cpp",
-        "initializer_list": "cpp",
-        "iomanip": "cpp",
-        "iosfwd": "cpp",
-        "iostream": "cpp",
-        "istream": "cpp",
-        "limits": "cpp",
-        "mutex": "cpp",
-        "new": "cpp",
-        "numbers": "cpp",
-        "ostream": "cpp",
-        "semaphore": "cpp",
-        "shared_mutex": "cpp",
-        "span": "cpp",
-        "sstream": "cpp",
-        "stdexcept": "cpp",
-        "stdfloat": "cpp",
-        "stop_token": "cpp",
-        "streambuf": "cpp",
-        "text_encoding": "cpp",
-        "thread": "cpp",
-        "cfenv": "cpp",
-        "typeindex": "cpp",
-        "typeinfo": "cpp",
-        "valarray": "cpp",
-        "variant": "cpp"
-    },
-    "C_Cpp.default.defines": [
-        "P_LINUX_BUILD",
-        "__SSE__",
-    ],
-    "C_Cpp.default.configurationProvider": "ms-vscode.cmake-tools",
-    "editor.tokenColorCustomizations": {
-        "[*Light*]": {
-            "textMateRules": [
-                {
-                    "scope": "ref.matchtext",
-                    "settings": {
-                        "foreground": "#000"
-                    }
-                }
-            ]
-        },
-        "[*Dark*]": {
-            "textMateRules": [
-                {
-                    "scope": "ref.matchtext",
-                    "settings": {
-                        "foreground": "#fff"
-                    }
-                }
-            ]
-        },
-        "textMateRules": [
-            {
-                "scope": "googletest.failed",
-                "settings": {
-                    "foreground": "#f00"
-                }
-            },
-            {
-                "scope": "googletest.passed",
-                "settings": {
-                    "foreground": "#0f0"
-                }
-            },
-            {
-                "scope": "googletest.run",
-                "settings": {
-                    "foreground": "#0f0"
-                }
-            }
-        ]
-    },
-    "gtest-adapter.debugConfig": [
-        "Debug MathTestFPU (gdb)"
-    ],
-    "gtest-adapter.supportLocation": true,
-    "premake.version": "Premake 5.0-beta5",
-}
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -1,28 +0,0 @@
-{
-    "tasks": [
-        {
-            "type": "cppbuild",
-            "label": "C/C++: g++ build active file",
-            "command": "/sbin/g++",
-            "args": [
-                "-fdiagnostics-color=always",
-                "-g",
-                "${file}",
-                "-o",
-                "${fileDirname}/${fileBasenameNoExtension}"
-            ],
-            "options": {
-                "cwd": "${fileDirname}"
-            },
-            "problemMatcher": [
-                "$gcc"
-            ],
-            "group": {
-                "kind": "build",
-                "isDefault": true
-            },
-            "detail": "Task generated by Debugger."
-        }
-    ],
-    "version": "2.0.0"
-}
--- a/Engine/Source/Runtime/Core/HAL/PlatformTypes.h
+++ b/Engine/Source/Runtime/Core/HAL/PlatformTypes.h
@@ -6,90 +6,85 @@
 //   Turn os specific types into global types.   //
 // ============================================= //

-
 namespace Phanes::Core::Types
 {

 	// Specific types size
 	//
 	// 8-Bit integer
-  typedef int8_t				int8;
+	using int8 = int8_t;

 	// 16-Bit integer
-  typedef int16_t				int16;
+	using int16 = int16_t;

 	// 32-Bit integer
-  typedef int32_t				int32;
+	using int32 = int32_t;

 	// 64-Bit integer
-  typedef int64_t				int64;
+	using int64 = int64_t;

 	// 8-Bit unsigned integer
-  typedef uint8_t				uint8;
+	using uint8 = uint8_t;

 	// 16-Bit unsigned integer
-  typedef uint16_t			uint16;
+	using uint16 = uint16_t;

 	// 32-Bit unsigned integer
-  typedef uint32_t			uint32;
+	using uint32 = uint32_t;

 	// 64-Bit unsigned integer
-  typedef uint64_t			uint64;
-
-
+	using uint64 = uint64_t;

 	// At least N bit types
 	//
 	// At least 8-Bit integer
-  typedef int_least8_t		lint8;
+	using lint8 = int_least8_t;

 	// At least 16-Bit integer
-  typedef int_least16_t		lint16;
+	using lint16 = int_least16_t;

 	// At least 32-Bit integer
-  typedef int_least32_t		lint32;
+	using lint32 = int_least32_t;

 	// At least 64-Bit integer
-  typedef int_least64_t		lint64;
+	using lint64 = int_least64_t;

 	// At least 8-Bit integer
-  typedef uint_least8_t		ulint8;
+	using ulint8 = uint_least8_t;

 	// At least 16-Bit integer
-  typedef uint_least16_t		ulint16;
+	using ulint16 = uint_least16_t;

 	// At least 32-Bit integer
-  typedef uint_least32_t		ulint32;
+	using ulint32 = uint_least32_t;

 	// At least 64-Bit integer
-  typedef uint_least64_t		ulint64;
-
-
+	using ulint64 = uint_least64_t;

 	// Fast N bit types
 	//
 	// Fast 8-bit integer
-  typedef int_fast8_t			fint8;
+	using fint8 = int_fast8_t;

 	// At least 16-Bit integer
-  typedef int_fast16_t		fint16;
+	using fint16 = int_fast16_t;

 	// At least 32-Bit integer
-  typedef int_fast32_t		fint32;
+	using fint32 = int_fast32_t;

 	// At least 64-Bit integer
-  typedef int_fast64_t		fint64;
+	using fint64 = int_fast64_t;

 	// At least 8-Bit integer
-  typedef uint_fast8_t		ufint8;
+	using ufint8 = uint_fast8_t;

 	// At least 16-Bit integer
-  typedef uint_fast16_t		ufint16;
+	using ufint16 = uint_fast16_t;

 	// At least 32-Bit integer
-  typedef uint_fast32_t		ufint32;
+	using ufint32 = uint_fast32_t;

 	// At least 64-Bit integer
-  typedef uint_fast64_t		ufint64;
+	using ufint64 = uint_fast64_t;

-}
+} // namespace Phanes::Core::Types
--- a/Engine/Source/Runtime/Core/Math/MathFwd.h
+++ b/Engine/Source/Runtime/Core/Math/MathFwd.h
@@ -1,52 +1,95 @@
 #pragma once

 #ifdef P_BUILD_LIB
-    #include "PhanesEnginePCH.h"
+#	include "PhanesEnginePCH.h"
 #else
-    #include <vector>
+#	include <vector>
 #endif

 #ifndef MATH_FWD_H
-#define MATH_FWD_H
+#	define MATH_FWD_H

-#include "Core/Math/Boilerplate.h"
-#include "Core/Math/SIMD/PhanesSIMDTypes.h"
+#	include "Core/Math/Boilerplate.h"
+#	include "Core/Math/SIMD/PhanesSIMDTypes.h"

 /**
- * Includes forward declarations, as well as certain useful typedefs.
+ * Includes forward declarations, as well as certain useful usings.
 * 
 * @ref OSAL/PlatformTypes.h
 */

-
-namespace Phanes::Core::Math {
+namespace Phanes::Core::Math
+{

 	/**
     * Template forward declarations.
     */

-    template<RealType T>    struct TColor;
-    template<RealType T>    struct TLinearColor;
-    template<RealType T>    struct TLine;
-    template<RealType T>    struct TQuaternion;
-    template<RealType T>    struct TTransform;
-    template<RealType T>    struct TPoint2;
-    template<RealType T>    struct TPoint3;
-    template<RealType T>    struct TPoint4;
-    template<IntType T>		struct TIntPoint2;
-    template<IntType T>		struct TIntPoint3;
-    template<IntType T>		struct TIntPoint4;
-    template<RealType T>    struct TMatrix2;
-    template<RealType T, bool S>    struct TMatrix3;
-    template<RealType T, bool S>    struct TMatrix4; 
-    template<RealType T, bool S>    struct TVector2;
-    template<RealType T, bool S>    struct TVector3;
-    template<RealType T, bool S>	struct TVector4;
-    template<IntType T, bool S>		struct TIntVector2;
-    template<IntType T, bool S>		struct TIntVector3;
-    template<IntType T, bool S>		struct TIntVector4;
-    template<RealType T, bool S>    struct TPlane;
-    template<RealType T, bool S>    struct TRay;
+	template <RealType T>
+	struct TColor;
+
+	template <RealType T>
+	struct TLinearColor;
+
+	template <RealType T>
+	struct TLine;
+
+	template <RealType T>
+	struct TTransform;
+
+	template <RealType T>
+	struct TPoint2;
+
+	template <RealType T>
+	struct TPoint3;
+
+	template <RealType T>
+	struct TPoint4;
+
+	template <IntType T>
+	struct TIntPoint2;
+
+	template <IntType T>
+	struct TIntPoint3;
+
+	template <IntType T>
+	struct TIntPoint4;
+
+	template <RealType T>
+	struct TMatrix2;
+
+	template <RealType T, bool S>
+	struct TQuaternion;
+
+	template <RealType T, bool S>
+	struct TMatrix3;
+
+	template <RealType T, bool S>
+	struct TMatrix4;
+
+	template <RealType T, bool S>
+	struct TVector2;
+
+	template <RealType T, bool S>
+	struct TVector3;
+
+	template <RealType T, bool S>
+	struct TVector4;
+
+	template <IntType T, bool S>
+	struct TIntVector2;
+
+	template <IntType T, bool S>
+	struct TIntVector3;
+
+	template <IntType T, bool S>
+	struct TIntVector4;
+
+	template <RealType T, bool S>
+	struct TPlane;
+
+	template <RealType T, bool S>
+	struct TRay;

 	/**
     * Specific instantiation of forward declarations.
@@ -54,148 +97,142 @@ namespace Phanes::Core::Math {

 	// TPoint2

-    typedef TPoint2<float>      Point2;
-    typedef TPoint2<float>      Point2f;
-    typedef TPoint2<double>     Point2d;
+	using Point2 = TPoint2<float>;
+	using Point2f = TPoint2<float>;
+	using Point2d = TPoint2<double>;

 	// TPoint3

-    typedef TPoint3<float>      Point3;
-    typedef TPoint3<float>      Point3f;
-    typedef TPoint3<double>     Point3d;
+	using Point3 = TPoint3<float>;
+	using Point3f = TPoint3<float>;
+	using Point3d = TPoint3<double>;

 	// TPoint4

-    typedef TPoint4<float>      Point4;
-    typedef TPoint4<float>      Point4f;
-    typedef TPoint4<double>     Point4d;
-
+	using Point4 = TPoint4<float>;
+	using Point4f = TPoint4<float>;
+	using Point4d = TPoint4<double>;

 	// TIntPoint2

-    typedef TIntPoint2<int>      IntPoint2;
-    typedef TIntPoint2<int>      IntPoint2i;
-    typedef TIntPoint2<long>     IntPoint2l;
+	using IntPoint2 = TIntPoint2<int>;
+	using IntPoint2i = TIntPoint2<int>;
+	using IntPoint2l = TIntPoint2<long>;

 	// TIntPoint3

-    typedef TIntPoint3<int>      IntPoint3;
-    typedef TIntPoint3<int>      IntPoint3i;
-    typedef TIntPoint3<long>     IntPoint3l;
+	using IntPoint3 = TIntPoint3<int>;
+	using IntPoint3i = TIntPoint3<int>;
+	using IntPoint3l = TIntPoint3<long>;

 	// TIntPoint4

-    typedef TIntPoint4<int>      IntPoint4;
-    typedef TIntPoint4<int>      IntPoint4i;
-    typedef TIntPoint4<long>     IntPoint4l;
+	using IntPoint4 = TIntPoint4<int>;
+	using IntPoint4i = TIntPoint4<int>;
+	using IntPoint4l = TIntPoint4<long>;

 	// IntVetor2

-    typedef TIntVector2<int, false>     IntVector2;
-    typedef TIntVector2<int, false>     Vector2i;
-    typedef TIntVector2<long, false>    LongVector2;
-    typedef TIntVector2<long, false>    Vector2l;
+	using IntVector2 = TIntVector2<int, false>;
+	using Vector2i = TIntVector2<int, false>;
+	using LongVector2 = TIntVector2<long, false>;
+	using Vector2l = TIntVector2<long, false>;

 	// IntVetor3

-    typedef TIntVector3<int, false>     IntVector3;
-    typedef TIntVector3<int, false>     Vector3i;
-    typedef TIntVector3<long, false>    LongVector3;
-    typedef TIntVector3<long, false>    Vector3l;
-
+	using IntVector3 = TIntVector3<int, false>;
+	using Vector3i = TIntVector3<int, false>;
+	using LongVector3 = TIntVector3<long, false>;
+	using Vector3l = TIntVector3<long, false>;

 	// IntVetor4

-    typedef TIntVector4<int, false>     IntVector4;
-    typedef TIntVector4<int, false>     Vector4i;
-    typedef TIntVector4<long, false>    LongVector4;
-    typedef TIntVector4<long, false>    Vector4l;
+	using IntVector4 = TIntVector4<int, false>;
+	using Vector4i = TIntVector4<int, false>;
+	using LongVector4 = TIntVector4<long, false>;
+	using Vector4l = TIntVector4<long, false>;

 	// Vector2

-    typedef TVector2<float, false>      Vector2;
-    typedef TVector2<float, false>      Vector2f;
-    typedef TVector2<double, false>     Vector2d;
-
-    typedef TVector2<double, SIMD::use_simd<double, 2, true>::value>        Vector2Regf64;
-    typedef TVector2<double, SIMD::use_simd<double, 2, true>::value>        Vector2Reg;
-    typedef TVector2<double, SIMD::use_simd<double, 2, true>::value>        Vector2Regd;
+	using Vector2 = TVector2<float, false>;
+	using Vector2f = TVector2<float, false>;
+	using Vector2d = TVector2<double, false>;

+	using Vector2Regf64 = TVector2<double, SIMD::use_simd<double, 2, true>::value>;
+	using Vector2Reg = TVector2<double, SIMD::use_simd<double, 2, true>::value>;
+	using Vector2Regd = TVector2<double, SIMD::use_simd<double, 2, true>::value>;

 	// Vector3

-    typedef TVector3<float, false>      Vector3;
-    typedef TVector3<float, false>      Vector3f;
-    typedef TVector3<double, false>     Vector3d;
-
-    typedef TVector3<float, SIMD::use_simd<float, 3, true>::value>          Vector3Reg;
-    typedef TVector3<float, SIMD::use_simd<float, 3, true>::value>          Vector3Regf32;
-    typedef TVector3<double, SIMD::use_simd<double, 3, true>::value>        Vector3Regd;
-    typedef TVector3<double, SIMD::use_simd<double, 3, true>::value>        Vector3Regf64;
+	using Vector3 = TVector3<float, false>;
+	using Vector3f = TVector3<float, false>;
+	using Vector3d = TVector3<double, false>;

+	using Vector3Reg = TVector3<float, SIMD::use_simd<float, 3, true>::value>;
+	using Vector3Regf32 = TVector3<float, SIMD::use_simd<float, 3, true>::value>;
+	using Vector3Regd = TVector3<double, SIMD::use_simd<double, 3, true>::value>;
+	using Vector3Regf64 = TVector3<double, SIMD::use_simd<double, 3, true>::value>;

 	// Vector4

-    typedef TVector4<float, false>      Vector4;
-    typedef TVector4<float, false>      Vector4f;
-    typedef TVector4<double, false>     Vector4d;
+	using Vector4 = TVector4<float, false>;
+	using Vector4f = TVector4<float, false>;
+	using Vector4d = TVector4<double, false>;

-    typedef TVector4<float, SIMD::use_simd<float, 4, true>::value>          Vector4Reg;
-    typedef TVector4<float, SIMD::use_simd<float, 4, true>::value>          Vector4Regf32;
-    typedef TVector4<double, SIMD::use_simd<double, 4, true>::value>        Vector4Regd;
-    typedef TVector4<double, SIMD::use_simd<double, 4, true>::value>        Vector4Regf64;
+	using Vector4Reg = TVector4<float, SIMD::use_simd<float, 4, true>::value>;
+	using Vector4Regf32 = TVector4<float, SIMD::use_simd<float, 4, true>::value>;
+	using Vector4Regd = TVector4<double, SIMD::use_simd<double, 4, true>::value>;
+	using Vector4Regf64 = TVector4<double, SIMD::use_simd<double, 4, true>::value>;

 	// Matrix2

-    typedef TMatrix2<float>             Matrix2;
-    typedef TMatrix2<float>             Matrix2f;
-    typedef TMatrix2<double>            Matrix2d;
+	using Matrix2 = TMatrix2<float>;
+	using Matrix2f = TMatrix2<float>;
+	using Matrix2d = TMatrix2<double>;

 	// Matrix3

-    typedef TMatrix3<float, false>      Matrix3;
-    typedef TMatrix3<float, false>      Matrix3f;
-    typedef TMatrix3<double, false>     Matrix3d;
+	using Matrix3 = TMatrix3<float, false>;
+	using Matrix3f = TMatrix3<float, false>;
+	using Matrix3d = TMatrix3<double, false>;

-    typedef TMatrix3<float, SIMD::use_simd<float, 3, true>::value>      Matrix3Reg;
-    typedef TMatrix3<float, SIMD::use_simd<float, 3, true>::value>      Matrix3Regf;
-    typedef TMatrix3<double, SIMD::use_simd<double, 3, true>::value>    Matrix3Regd;
-    typedef TMatrix3<double, SIMD::use_simd<double, 3, true>::value>   Matrix3Regf64;
+	using Matrix3Reg = TMatrix3<float, SIMD::use_simd<float, 3, true>::value>;
+	using Matrix3Regf = TMatrix3<float, SIMD::use_simd<float, 3, true>::value>;
+	using Matrix3Regd = TMatrix3<double, SIMD::use_simd<double, 3, true>::value>;
+	using Matrix3Regf64 = TMatrix3<double, SIMD::use_simd<double, 3, true>::value>;

 	// Matrix4

-    typedef TMatrix4<float, false>             Matrix4;
-    typedef TMatrix4<float, false>             Matrix4f;
-    typedef TMatrix4<double, false>            Matrix4d;
-
-    typedef TMatrix3<float, SIMD::use_simd<float, 4, true>::value>      Matrix4Reg;
-    typedef TMatrix3<float, SIMD::use_simd<float, 4, true>::value>      Matrix4Regf;
-    typedef TMatrix3<double, SIMD::use_simd<double, 4, true>::value>    Matrix4Regd;
-    typedef TMatrix3<double, SIMD::use_simd<double, 4, true>::value>   Matrix4Regf64;
-
+	using Matrix4 = TMatrix4<float, false>;
+	using Matrix4f = TMatrix4<float, false>;
+	using Matrix4d = TMatrix4<double, false>;

+	using Matrix4Reg = TMatrix3<float, SIMD::use_simd<float, 4, true>::value>;
+	using Matrix4Regf = TMatrix3<float, SIMD::use_simd<float, 4, true>::value>;
+	using Matrix4Regd = TMatrix3<double, SIMD::use_simd<double, 4, true>::value>;
+	using Matrix4Regf64 = TMatrix3<double, SIMD::use_simd<double, 4, true>::value>;

 	// TPlane

-    typedef TPlane<float, false>        Plane;
-    typedef TPlane<float, false>        Planef;
-    typedef TPlane<double, false>       Planed;
+	using Plane = TPlane<float, false>;
+	using Planef = TPlane<float, false>;
+	using Planed = TPlane<double, false>;

-    typedef TPlane<float, SIMD::use_simd<float, 4, true>::value>    PlaneReg;
-    typedef TPlane<float, SIMD::use_simd<double, 4, true>::value>   PlaneRegd;
+	using PlaneReg = TPlane<float, SIMD::use_simd<float, 4, true>::value>;
+	using PlaneRegd = TPlane<float, SIMD::use_simd<double, 4, true>::value>;

-
-} // Phanes::Core::Math::coretypes
+} // namespace Phanes::Core::Math

 namespace Phanes::Core::Math::Internal
 {

 	// Internal types

-    template <typename T, unsigned int D> struct AVector;
-
-    template <typename T, unsigned int n, unsigned int> struct AMatrix;
-}
+	template <typename T, unsigned int D>
+	struct AVector;

+	template <typename T, unsigned int n, unsigned int>
+	struct AMatrix;
+} // namespace Phanes::Core::Math::Internal

 #endif // !MATH_FWD_H
--- a/Engine/Source/Runtime/Core/Math/MathTypes.h
+++ b/Engine/Source/Runtime/Core/Math/MathTypes.h
@@ -6,7 +6,6 @@
 //   Turn os specific types into global types.   //
 // ============================================= //

-
 // TODO: include int128

 namespace Phanes::Core::Types
@@ -16,97 +15,91 @@ namespace Phanes::Core::Types

 	// MSVC specific types

-    typedef _FLOAT128			float128;
+	using float128 = _FLOAT128;

 #elif defined(P_LINUX_BUILD)

 	// Linux specific types

-    typedef __float128			float128;
+	using float128 = __float128;

 #endif
-
-
 	// Specific types size
 	//
 	// 8-Bit integer
-    typedef int8_t				int8;
+	using int8 = int8_t;

 	// 16-Bit integer
-    typedef int16_t				int16;
+	using int16 = int16_t;

 	// 32-Bit integer
-    typedef int32_t				int32;
+	using int32 = int32_t;

 	// 64-Bit integer
-    typedef int64_t				int64;
+	using int64 = int64_t;

 	// 8-Bit unsigned integer
-    typedef uint8_t				uint8;
+	using uint8 = uint8_t;

 	// 16-Bit unsigned integer
-    typedef uint16_t			uint16;
+	using uint16 = uint16_t;

 	// 32-Bit unsigned integer
-    typedef uint32_t			uint32;
+	using uint32 = uint32_t;

 	// 64-Bit unsigned integer
-    typedef uint64_t			uint64;
-
-
+	using uint64 = uint64_t;

 	// At least N bit types
 	//
 	// At least 8-Bit integer
-    typedef int_least8_t		lint8;
+	using lint8 = int_least8_t;

 	// At least 16-Bit integer
-    typedef int_least16_t		lint16;
+	using lint16 = int_least16_t;

 	// At least 32-Bit integer
-    typedef int_least32_t		lint32;
+	using lint32 = int_least32_t;

 	// At least 64-Bit integer
-    typedef int_least64_t		lint64;
+	using lint64 = int_least64_t;

 	// At least 8-Bit integer
-    typedef uint_least8_t		ulint8;
+	using ulint8 = uint_least8_t;

 	// At least 16-Bit integer
-    typedef uint_least16_t		ulint16;
+	using ulint16 = uint_least16_t;

 	// At least 32-Bit integer
-    typedef uint_least32_t		ulint32;
+	using ulint32 = uint_least32_t;

 	// At least 64-Bit integer
-    typedef uint_least64_t		ulint64;
-
-
+	using ulint64 = uint_least64_t;

 	// Fast N bit types
 	//
 	// Fast 8-bit integer
-    typedef int_fast8_t			fint8;
+	using fint8 = int_fast8_t;

 	// At least 16-Bit integer
-    typedef int_fast16_t		fint16;
+	using fint16 = int_fast16_t;

 	// At least 32-Bit integer
-    typedef int_fast32_t		fint32;
+	using fint32 = int_fast32_t;

 	// At least 64-Bit integer
-    typedef int_fast64_t		fint64;
+	using fint64 = int_fast64_t;

 	// At least 8-Bit integer
-    typedef uint_fast8_t		ufint8;
+	using ufint8 = uint_fast8_t;

 	// At least 16-Bit integer
-    typedef uint_fast16_t		ufint16;
+	using ufint16 = uint_fast16_t;

 	// At least 32-Bit integer
-    typedef uint_fast32_t		ufint32;
+	using ufint32 = uint_fast32_t;

 	// At least 64-Bit integer
-    typedef uint_fast64_t		ufint64;
+	using ufint64 = uint_fast64_t;

-}
+} // namespace Phanes::Core::Types
--- a/Engine/Source/Runtime/Core/Math/Matrix2.hpp
+++ b/Engine/Source/Runtime/Core/Math/Matrix2.hpp
@@ -7,18 +7,18 @@
 #include "Core/Math/Vector2.hpp"

 #ifndef MATRIX2_H
-#define MATRIX2_H
+#	define MATRIX2_H

-namespace Phanes::Core::Math {
+namespace Phanes::Core::Math
+{

 	// 2x2 Matrix defined in column-major order.
-    // Accessed by M[Row][Col].
+	// Accessed by M[Col][Row].

-    template<RealType T>
+	template <RealType T>
 	struct TMatrix2
 	{
 	public:
-
 		union
 		{
 			struct
@@ -38,7 +38,6 @@ namespace Phanes::Core::Math {
 		};

 	public:
-
 		TMatrix2() = default;

 		/**
@@ -59,25 +58,29 @@ namespace Phanes::Core::Math {

 		TMatrix2(T fields[2][2])
 		{
-            this->data[0][0] = fields[0][0]; this->data[1][0] = fields[1][0];
-            this->data[0][1] = fields[0][1]; this->data[1][1] = fields[1][1];
+			this->data[0][0] = fields[0][0];
+			this->data[1][0] = fields[1][0];
+			this->data[0][1] = fields[0][1];
+			this->data[1][1] = fields[1][1];
 		}

 		/**
         * Construct Matrix from parameters.
         *
         * @param(n00) M[0][0]
-         * @param(n10) M[1][0]
-         * @param(n01) M[0][1]
+         * @param(n01) M[1][0]
+         * @param(n10) M[0][1]
         * @param(n11) M[1][1]
         * 
-         * @note nXY = n[Row][Col]
+         * @note nXY = n[Col][Row]
         */

 		TMatrix2(T n00, T n01, T n10, T n11)
 		{
-            this->data[0][0] = n00; this->data[1][0] = n01; 
-            this->data[0][1] = n10; this->data[1][1] = n11;
+			this->data[0][0] = n00;
+			this->data[1][0] = n01;
+			this->data[0][1] = n10;
+			this->data[1][1] = n11;
 		}

 		/**
@@ -94,21 +97,19 @@ namespace Phanes::Core::Math {
 		}

 	public:
-       
-
-        T& operator() (int n, int m)
+		T& operator()(int n, int m)
 		{
 			return this->data[m][n];
 		}

-        T operator() (int n, int m) const
+		T operator()(int n, int m) const
 		{
 			return this->data[m][n];
 		}

-        TVector2<T, false>& operator[] (int m)
+		TVector2<T, false>& operator[](int m)
 		{
-            switch (m)
+			switch(m)
 			{
 			case 0:
 				return this->c0;
@@ -119,9 +120,9 @@ namespace Phanes::Core::Math {
 			throw std::invalid_argument("m is outside valid range.");
 		}

-        TVector2<T, false> operator[] (int m) const
+		TVector2<T, false> operator[](int m) const
 		{
-            switch (m)
+			switch(m)
 			{
 			case 0:
 				return this->c0;
@@ -131,15 +132,14 @@ namespace Phanes::Core::Math {

 			throw std::invalid_argument("m is outside valid range.");
 		}
-
 	};

 	// ====================== //
 	//    TMatrix2 operator   //
 	// ====================== //

-    template<RealType T>
-    TMatrix2<T>& operator+= (TMatrix2<T>& m1, T s)
+	template <RealType T>
+	TMatrix2<T>& operator+=(TMatrix2<T>& m1, T s)
 	{
 		m1(0, 0) += s;
 		m1(0, 1) += s;
@@ -149,8 +149,8 @@ namespace Phanes::Core::Math {
 		return m1;
 	}

-    template<RealType T>
-    TMatrix2<T>& operator+= (TMatrix2<T>& m1, const TMatrix2<T>& m2)
+	template <RealType T>
+	TMatrix2<T>& operator+=(TMatrix2<T>& m1, const TMatrix2<T>& m2)
 	{
 		m1(0, 0) += m2(0, 0);
 		m1(0, 1) += m2(0, 1);
@@ -160,8 +160,8 @@ namespace Phanes::Core::Math {
 		return m1;
 	}

-    template<RealType T>
-    TMatrix2<T>& operator-= (TMatrix2<T>& m1, T s)
+	template <RealType T>
+	TMatrix2<T>& operator-=(TMatrix2<T>& m1, T s)
 	{
 		m1(0, 0) -= s;
 		m1(0, 1) -= s;
@@ -171,8 +171,8 @@ namespace Phanes::Core::Math {
 		return m1;
 	}

-    template<RealType T>
-    TMatrix2<T>& operator-= (TMatrix2<T>& m1, const TMatrix2<T>& m2)
+	template <RealType T>
+	TMatrix2<T>& operator-=(TMatrix2<T>& m1, const TMatrix2<T>& m2)
 	{
 		m1(0, 0) -= m2(0, 0);
 		m1(0, 1) -= m2(0, 1);
@@ -182,8 +182,8 @@ namespace Phanes::Core::Math {
 		return m1;
 	}

-    template<RealType T>
-    TMatrix2<T>& operator*= (TMatrix2<T>& m1, T s)
+	template <RealType T>
+	TMatrix2<T>& operator*=(TMatrix2<T>& m1, T s)
 	{
 		m1.data[0][0] *= s;
 		m1.data[0][1] *= s;
@@ -193,8 +193,8 @@ namespace Phanes::Core::Math {
 		return m1;
 	}

-    template<RealType T>
-    TMatrix2<T>& operator*= (TMatrix2<T>& m1, const TMatrix2<T>& m2)
+	template <RealType T>
+	TMatrix2<T>& operator*=(TMatrix2<T>& m1, const TMatrix2<T>& m2)
 	{
 		TMatrix2<T> c = m1;

@@ -207,8 +207,8 @@ namespace Phanes::Core::Math {
 		return m1;
 	}

-    template<RealType T>
-    TMatrix2<T>& operator/= (TMatrix2<T>& m1, T s)
+	template <RealType T>
+	TMatrix2<T>& operator/=(TMatrix2<T>& m1, T s)
 	{
 		s = (T)1.0 / s;
 		m1.data[0][0] *= s;
@@ -219,87 +219,83 @@ namespace Phanes::Core::Math {
 		return m1;
 	}

-    template<RealType T>
-    TMatrix2<T> operator+ (const TMatrix2<T>& m1, T s)
+	template <RealType T>
+	TMatrix2<T> operator+(const TMatrix2<T>& m1, T s)
 	{
-            return TMatrix2<T>(m1(0, 0) + s, m1(0, 1) + s,
-                                                 m1(1, 0) + s, m1(1, 1) + s);
+		return TMatrix2<T>(m1(0, 0) + s, m1(0, 1) + s, m1(1, 0) + s, m1(1, 1) + s);
 	}

-    template<RealType T>
-    TMatrix2<T> operator+ (const TMatrix2<T>& m1, const TMatrix2<T>& m2)
+	template <RealType T>
+	TMatrix2<T> operator+(const TMatrix2<T>& m1, const TMatrix2<T>& m2)
 	{
-            return TMatrix2<T>(m1(0, 0) + m2(0, 0), m1(0, 1) + m2(0, 1),
-                               m1(1, 0) + m2(1, 0), m1(1, 1) + m2(1, 1));
+		return TMatrix2<T>(
+			m1(0, 0) + m2(0, 0), m1(0, 1) + m2(0, 1), m1(1, 0) + m2(1, 0), m1(1, 1) + m2(1, 1));
 	}

-    template<RealType T>
-    TMatrix2<T> operator- (const TMatrix2<T>& m1, T s)
+	template <RealType T>
+	TMatrix2<T> operator-(const TMatrix2<T>& m1, T s)
 	{
-            return TMatrix2<T>(m1(0, 0) - s, m1(0, 1) - s,
-                                                 m1(1, 0) - s, m1(1, 1) - s);
+		return TMatrix2<T>(m1(0, 0) - s, m1(0, 1) - s, m1(1, 0) - s, m1(1, 1) - s);
 	}

-    template<RealType T>
-    TMatrix2<T> operator- (const TMatrix2<T>& m1, const TMatrix2<T>& m2)
+	template <RealType T>
+	TMatrix2<T> operator-(const TMatrix2<T>& m1, const TMatrix2<T>& m2)
 	{
-            return TMatrix2<T>(m1(0, 0) - m2(0, 0), m1(0, 1) - m2(0, 1),
-                                                 m1(1, 0) - m2(1, 0), m1(1, 1) - m2(1, 1));
+		return TMatrix2<T>(
+			m1(0, 0) - m2(0, 0), m1(0, 1) - m2(0, 1), m1(1, 0) - m2(1, 0), m1(1, 1) - m2(1, 1));
 	}

-    template<RealType T>
-    TMatrix2<T> operator* (const TMatrix2<T>& m1, T s)
+	template <RealType T>
+	TMatrix2<T> operator*(const TMatrix2<T>& m1, T s)
 	{
-            return TMatrix2<T>(m1(0, 0) * s, m1(0, 1) * s,
-                               m1(1, 0) * s, m1(1, 1) * s);
+		return TMatrix2<T>(m1(0, 0) * s, m1(0, 1) * s, m1(1, 0) * s, m1(1, 1) * s);
 	}

-    template<RealType T>
-    TMatrix2<T> operator/ (const TMatrix2<T>& m1, T s)
+	template <RealType T>
+	TMatrix2<T> operator/(const TMatrix2<T>& m1, T s)
 	{
 		s = (T)1.0 / s;
-        return TMatrix2<T>(m1(0, 0) * s, m1(0, 1) * s,
-                           m1(1, 0) * s, m1(1, 1) * s);
+		return TMatrix2<T>(m1(0, 0) * s, m1(0, 1) * s, m1(1, 0) * s, m1(1, 1) * s);
 	}

-    template<RealType T>
-    TMatrix2<T> operator* (const TMatrix2<T>& m1, const TMatrix2<T>& m2)
+	template <RealType T>
+	TMatrix2<T> operator*(const TMatrix2<T>& m1, const TMatrix2<T>& m2)
 	{
-            return TMatrix2<T>(m1(0, 0) * m2(0, 0) + m1(0, 1) * m2(1, 0), m1(0, 0) * m2(0, 1) + m1(0, 1) * m2(1, 1),
-                               m1(1, 0) * m2(0, 0) + m1(1, 1) * m2(1, 0), m1(1, 0) * m2(0, 1) + m1(1, 1) * m2(1, 1));
+		return TMatrix2<T>(m1(0, 0) * m2(0, 0) + m1(0, 1) * m2(1, 0),
+						   m1(0, 0) * m2(0, 1) + m1(0, 1) * m2(1, 1),
+						   m1(1, 0) * m2(0, 0) + m1(1, 1) * m2(1, 0),
+						   m1(1, 0) * m2(0, 1) + m1(1, 1) * m2(1, 1));
 	}

-    template<RealType T>
-    TVector2<T, false> operator* (const TMatrix2<T>& m1, const TVector2<T, false>& v)
+	template <RealType T>
+	TVector2<T, false> operator*(const TMatrix2<T>& m1, const TVector2<T, false>& v)
 	{
-            return TVector2<T, false>(m1(0, 0) * v.x + m1(0, 1) * v.y,
-                                      m1(1, 0) * v.x + m1(1, 1) * v.y);
+		return TVector2<T, false>(m1(0, 0) * v.x + m1(0, 1) * v.y, m1(1, 0) * v.x + m1(1, 1) * v.y);
 	}

-    template<RealType T>
-    bool operator== (const TMatrix2<T>& m1, const TMatrix2<T>& m2)
+	template <RealType T>
+	bool operator==(const TMatrix2<T>& m1, const TMatrix2<T>& m2)
 	{
 		return m1[0] == m2[0] && m1[1] == m2[1];
 	}

-    template<RealType T>
-    bool operator!= (const TMatrix2<T>& m1, const TMatrix2<T>& m2)
+	template <RealType T>
+	bool operator!=(const TMatrix2<T>& m1, const TMatrix2<T>& m2)
 	{
 		return m1[0] != m2[0] || m1[1] != m2[1];
 	}

-
 	// ============================== //
 	//   Matrix function definition   //
 	// ============================== //

-    template<RealType T>
+	template <RealType T>
 	T Determinant(const TMatrix2<T>& m1)
 	{
 		return m1(0, 0) * m1(1, 1) - m1(0, 1) * m1(1, 0);
 	}

-    template<RealType T>
+	template <RealType T>
 	TMatrix2<T>& InverseV(TMatrix2<T>& m1)
 	{
 		float _1_det = 1.0f / Determinant(m1);
@@ -314,7 +310,7 @@ namespace Phanes::Core::Math {
 		return m1;
 	}

-    template<RealType T>
+	template <RealType T>
 	TMatrix2<T>& TransposeV(TMatrix2<T>& m1)
 	{
 		Swap(m1(0, 1), m1(1, 0));
@@ -326,33 +322,30 @@ namespace Phanes::Core::Math {
 	//   WITH RETURN   //
 	// =============== //

-    template<RealType T>
+	template <RealType T>
 	TMatrix2<T> Inverse(TMatrix2<T>& m1)
 	{
 		float _1_det = 1.0f / Determinant(m1);

-        return TMatrix2<T>( m1(1, 1) * _1_det, -m1(0, 1) * _1_det,
-                           -m1(1, 0) * _1_det,  m1(0, 0) * _1_det);
+		return TMatrix2<T>(
+			m1(1, 1) * _1_det, -m1(0, 1) * _1_det, -m1(1, 0) * _1_det, m1(0, 0) * _1_det);
 	}

-    template<RealType T>
+	template <RealType T>
 	TMatrix2<T> Transpose(const TMatrix2<T>& m1)
 	{
-        return TMatrix2<T>(m1(0, 0), m1(1, 0),
-                           m1(0, 1), m1(1, 1));
+		return TMatrix2<T>(m1(0, 0), m1(1, 0), m1(0, 1), m1(1, 1));
 	}

-    template<RealType T>
+	template <RealType T>
 	bool IsIdentityMatrix(const TMatrix2<T>& m1, T threshold = P_FLT_INAC)
 	{
 		return (abs(m1(0, 0) - (T)1.0) < P_FLT_INAC && abs(m1(0, 1)) < P_FLT_INAC &&
 				abs(m1(1, 0)) < P_FLT_INAC && abs(m1(1, 1) - (T)1.0) < P_FLT_INAC);
 	}

-} // Phanes::Core::Math
-
+} // namespace Phanes::Core::Math

 #endif // !MATRIX2_H

-
 #include "Core/Math/SIMD/SIMDIntrinsics.h"
--- a/Engine/Source/Runtime/Core/Math/Matrix4.hpp
+++ b/Engine/Source/Runtime/Core/Math/Matrix4.hpp
@@ -83,7 +83,7 @@ namespace Phanes::Core::Math {
 		/// Construct matrix from field of values.
 		/// </summary>
 		/// <param name="field"></param>
-		TMatrix4(T field[4][4])
+		explicit TMatrix4(T field[4][4])
 		{
 			this->c0 = TVector4(field[0]);
 			this->c1 = TVector4(field[1]);
--- a/Engine/Source/Runtime/Core/Math/Quaternion.hpp
+++ b/Engine/Source/Runtime/Core/Math/Quaternion.hpp
@@ -0,0 +1,85 @@
+#pragma once
+
+#include "Core/Math/Boilerplate.h"
+
+#include "Core/Math/MathFwd.h"
+#include "Core/Math/SIMD/PhanesSIMDTypes.h"
+#include "Core/Math/SIMD/Storage.h"
+#include "Core/Math/Vector3.hpp"
+#include "Core/Math/Vector4.hpp"
+
+#ifndef QUATERNION_H
+#	define QUATERNION_H
+
+namespace Phanes::Core::Math
+{
+	// Quaternion
+	template <RealType T, bool S>
+	struct TQuaternion
+	{
+		using Real = T;
+
+	public:
+		union
+		{
+			struct
+			{
+				float x;
+				float y;
+				float z;
+				float w;
+			};
+			union
+			{
+				typename SIMD::Storage<4, Real, SIMD::use_simd<Real, 4, S>::value>::type comp;
+				typename SIMD::Storage<4, Real, SIMD::use_simd<Real, 4, S>::value>::type data;
+			};
+		};
+
+	public:
+		/// Default constructor
+		TQuaternion() = default;
+
+		/**
+		 * Construct quaternion from vector4.
+		 * v.w is the scalar part of the quaternion (q.w).
+		 */
+		explicit TQuaternion(const TVector4<T, S>& v);
+
+		/**
+		 * Construct quaternion from vector (x,y,z) and scalar part (w).
+		 *
+		 * @param x X
+		 * @param y Y
+		 * @param z Z
+		 * @param w W
+		 */
+		TQuaternion(Real x, Real y, Real z, Real w);
+
+		/**
+		 * Construct vector from vector part and scalar part.
+		 */
+		TQuaternion(const TVector3<Real, S>& v, Real w);
+
+		/**
+		 * Construct quaternion from array of length >= four.
+		 *
+		 * @note If used with SIMD the array will is assumed to be aligned.
+		 */
+		explicit TQuaternion(const Real* comp);
+
+		/**
+		 * Construct from euler angles (yaw, pitch, roll)
+		 */
+		explicit TQuaternion(const TVector3<Real, S>& euler_angels);
+
+		/**
+		 * Construct from Transformation
+		 */
+
+		explicit TQuaternion(const TTransform<Real>& t);
+		explicit TQuaternion(const TMatrix4<Real, S>& t);
+	};
+} // namespace Phanes::Core::Math
+
+#endif // QUATERNION_H
--- a/Engine/Source/Runtime/Core/Math/SIMD/PhanesSIMDTypes.h
+++ b/Engine/Source/Runtime/Core/Math/SIMD/PhanesSIMDTypes.h
@@ -4,8 +4,8 @@
 //
 // ARM is not supported.

-#include "Core/Math/SIMD/Platform.h"
 #include "Core/Math/MathTypes.h"
+#include "Core/Math/SIMD/Platform.h"

 #if P_INTRINSICS == P_INTRINSICS_AVX2
 #	include <immintrin.h>
@@ -27,132 +27,128 @@ namespace Phanes::Core::Math::SIMD
 	/// <typeparam name="T">Type of vector</typeparam>
 	/// <typeparam name="L">Length of vector</typeparam>
 	/// <typeparam name="IsAligned">Whether the vector is aligned for simd usage.</typeparam>
-    template<typename T, size_t L, bool IsAligned>
+	template <typename T, size_t L, bool IsAligned>
 	struct use_simd
 	{
 		static const bool value = false;
 	};

-
 	// SSE / NEON

-    template<>
+	template <>
 	struct use_simd<float, 4, true>
 	{
-        static const bool value = true && (P_SSE__ || P_NEON__);
+		static const bool value = (P_SSE__ || P_NEON__);
 	};

-    template<>
+	template <>
 	struct use_simd<float, 3, true>
 	{
-        static const bool value = true && (P_SSE__ || P_NEON__);
+		static const bool value = (P_SSE__ || P_NEON__);
 	};

-    template<>
+	template <>
 	struct use_simd<int, 4, true>
 	{
-        static const bool value = true && (P_SSE__ || P_NEON__);
+		static const bool value = (P_SSE__ || P_NEON__);
 	};

-    template<>
+	template <>
 	struct use_simd<int, 3, true>
 	{
-        static const bool value = true && (P_SSE__ || P_NEON__);
+		static const bool value = (P_SSE__ || P_NEON__);
 	};

-    template<>
+	template <>
 	struct use_simd<unsigned int, 4, true>
 	{
-        static const bool value = true && (P_SSE__ || P_NEON__);
+		static const bool value = (P_SSE__ || P_NEON__);
 	};

-    template<>
+	template <>
 	struct use_simd<unsigned int, 3, true>
 	{
-        static const bool value = true && (P_SSE__ || P_NEON__);
+		static const bool value = (P_SSE__ || P_NEON__);
 	};

 	// SSE

-    template<>
+	template <>
 	struct use_simd<double, 2, true>
 	{
-        static const bool value = true && P_SSE__;
+		static const bool value = P_SSE__;
 	};

-    template<>
+	template <>
 	struct use_simd<Phanes::Core::Types::int64, 2, true>
 	{
-        static const bool value = true && P_SSE__;
+		static const bool value = P_SSE__;
 	};

-    template<>
+	template <>
 	struct use_simd<Phanes::Core::Types::uint64, 2, true>
 	{
-        static const bool value = true && P_SSE__;
+		static const bool value = P_SSE__;
 	};

-
-
 	// AVX

-    template<>
+	template <>
 	struct use_simd<double, 4, true>
 	{
-        static const bool value = true && P_AVX__;
+		static const bool value = P_AVX__;
 	};

-    template<>
+	template <>
 	struct use_simd<double, 3, true>
 	{
-        static const bool value = true && P_AVX__;
+		static const bool value = P_AVX__;
 	};

-    template<>
+	template <>
 	struct use_simd<float, 8, true>
 	{
-        static const bool value = true && P_AVX__;
+		static const bool value = P_AVX__;
 	};

-
 	// AVX2

-    template<>
+	template <>
 	struct use_simd<Phanes::Core::Types::int64, 4, true>
 	{
-        static const bool value = true && P_AVX2__;
+		static const bool value = P_AVX2__;
 	};

-    template<>
+	template <>
 	struct use_simd<Phanes::Core::Types::int64, 3, true>
 	{
-        static const bool value = true && P_AVX2__;
+		static const bool value = P_AVX2__;
 	};

-    template<>
+	template <>
 	struct use_simd<Phanes::Core::Types::uint64, 4, true>
 	{
-        static const bool value = true && P_AVX2__;
+		static const bool value = P_AVX2__;
 	};

-    template<>
+	template <>
 	struct use_simd<Phanes::Core::Types::uint64, 3, true>
 	{
-        static const bool value = true && P_AVX2__;
+		static const bool value = P_AVX2__;
 	};

-    template<>
+	template <>
 	struct use_simd<int, 8, true>
 	{
-        static const bool value = true && P_AVX2__;
+		static const bool value = P_AVX2__;
 	};

-    template<>
+	template <>
 	struct use_simd<unsigned int, 8, true>
 	{
-        static const bool value = true && P_AVX2__;
+		static const bool value = P_AVX2__;
 	};
-}
+} // namespace Phanes::Core::Math::SIMD

 // Register aliases
 namespace Phanes::Core::Types
@@ -160,69 +156,123 @@ namespace Phanes::Core::Types

 #if P_INTRINSICS >= 1

-    typedef __m128      Vec4f32Reg;
-    typedef __m128d     Vec2f64Reg;
+	using Vec4f32Reg = __m128;
+	using Vec2f64Reg = __m128d;

-    typedef __m128i     Vec4i32Reg;
-    typedef __m128i     Vec2i64Reg;
+	using Vec4i32Reg = __m128i;
+	using Vec2i64Reg = __m128i;

-    typedef __m128i     Vec4u32Reg;
-    typedef __m128i     Vec2u64Reg;
+	using Vec4u32Reg = __m128i;
+	using Vec2u64Reg = __m128i;

 #elif P_INTRINSICS != P_INTRINSICS_NEON

-    typedef struct alignas(16) Vec4f32Reg { float data[4]; }                        Vec4f32Reg;
-    typedef struct alignas(16) Vec2f64Reg { double data[2]; }                       Vec2f64Reg;
-    typedef struct alignas(16) Vec4i32Reg { int data[4]; }                          Vec4i32Reg;
-    typedef struct alignas(16) Vec2i64Reg { Phanes::Core::Types::int64 data[2]; }   Vec2i64Reg;
-    typedef struct alignas(16) Vec4u32Reg { unsigned int data[4]; }                 Vec4u32Reg;
-    typedef struct alignas(16) Vec2u64Reg { Phanes::Core::Types::uint64 data[4]; }  Vec2u64Reg;
+	using Vec4f32Reg = struct alignas(16) Vec4f32Reg
+	{
+		float data[4];
+	};
+	using Vec2f64Reg = struct alignas(16) Vec2f64Reg
+	{
+		double data[2];
+	};
+	using Vec4i32Reg = struct alignas(16) Vec4i32Reg
+	{
+		int data[4];
+	};
+	using Vec2i64Reg = struct alignas(16) Vec2i64Reg
+	{
+		Phanes::Core::Types::int64 data[2];
+	};
+	using Vec4u32Reg = struct alignas(16) Vec4u32Reg
+	{
+		unsigned int data[4];
+	};
+	using Vec2u64Reg = struct alignas(16) Vec2u64Reg
+	{
+		Phanes::Core::Types::uint64 data[4];
+	};

 #endif

-
 #if P_INTRINSICS >= 2

-    typedef __m256      Vec4x2f32Reg;
-    typedef __m256      Vec8f32Reg;
-    typedef __m256d     Vec2x2f64Reg;
-    typedef __m256d     Vec4f64Reg;
+	using Vec4x2f32Reg = __m256;
+	using Vec8f32Reg = __m256;
+	using Vec2x2f64Reg = __m256d;
+	using Vec4f64Reg = __m256d;

 #elif P_INTRINSICS != P_INTRINSICS_NEON

-    typedef struct alignas(32) Vec4x2f32Reg { float data[8]; }  Vec4x2f32Reg;
-    typedef struct alignas(32) Vec8f32Reg   { float data[8]; }  Vec8f32Reg;
-    typedef struct alignas(32) Vec2x2f64Reg { double data[4]; } Vec2x2f64Reg;
-    typedef struct alignas(32) Vec4f64Reg   { double data[4]; } Vec4f64Reg;
+	using Vec4x2f32Reg = struct alignas(32) Vec4x2f32Reg
+	{
+		float data[8];
+	};
+	using Vec8f32Reg = struct alignas(32) Vec8f32Reg
+	{
+		float data[8];
+	};
+	using Vec2x2f64Reg = struct alignas(32) Vec2x2f64Reg
+	{
+		double data[4];
+	};
+	using Vec4f64Reg = struct alignas(32) Vec4f64Reg
+	{
+		double data[4];
+	};

 #endif

-
 #if P_INTRINSICS == 3

-    typedef __m256i     Vec4x2i32Reg;
-    typedef __m256i     Vec8i32Reg;
-    typedef __m256i     Vec2x2i64Reg;
-    typedef __m256i     Vec4i64Reg;
+	using Vec4x2i32Reg = __m256i;
+	using Vec8i32Reg;
+	= __m256i using Vec2x2i64Reg;
+	= __m256i using Vec4i64Reg;
+	= __m256i

-    typedef __m256i     Vec4x2u32Reg;
-    typedef __m256i     Vec8u32Reg;
-    typedef __m256i     Vec2x2u64Reg;
-    typedef __m256i     Vec4u64Reg;
+		using Vec4x2u32Reg;
+	= __m256i using Vec8u32Reg;
+	= __m256i using Vec2x2u64Reg;
+	= __m256i using Vec4u64Reg;
+	= __m256i

 #elif P_INTRINSICS != P_INTRINSICS_NEON

-    typedef struct alignas(32) Vec4x2i32Reg { int data[8]; }                         Vec4x2i32Reg;
-    typedef struct alignas(32) Vec8i32Reg   { int data[8]; }                         Vec8i32Reg;
-    typedef struct alignas(32) Vec2x2i64Reg { Phanes::Core::Types::int64 data[4]; }  Vec2x2i64Reg;
-    typedef struct alignas(32) Vec4i64Reg   { Phanes::Core::Types::int64 data[4]; }  Vec4i64Reg;
+	using Vec4x2i32Reg = struct alignas(32) Vec4x2i32Reg
+	{
+		int data[8];
+	};
+	using Vec8i32Reg = struct alignas(32) Vec8i32Reg
+	{
+		int data[8];
+	};
+	using Vec2x2i64Reg = struct alignas(32) Vec2x2i64Reg
+	{
+		Phanes::Core::Types::int64 data[4];
+	};
+	using Vec4i64Reg = struct alignas(32) Vec4i64Reg
+	{
+		Phanes::Core::Types::int64 data[4];
+	};

-    typedef struct alignas(32) Vec4x2u32Reg { unsigned int data[8]; }                Vec4x2u32Reg;
-    typedef struct alignas(32) Vec8u32Reg   { unsigned int data[8]; }                Vec8u32Reg;
-    typedef struct alignas(32) Vec2x2u64Reg { Phanes::Core::Types::uint64 data[4]; } Vec2x2u64Reg;
-    typedef struct alignas(32) Vec4u64Reg   { Phanes::Core::Types::uint64 data[4]; } Vec4u64Reg;
+	using Vec4x2u32Reg = struct alignas(32) Vec4x2u32Reg
+	{
+		unsigned int data[8];
+	};
+	using Vec8u32Reg = struct alignas(32) Vec8u32Reg
+	{
+		unsigned int data[8];
+	};
+	using Vec2x2u64Reg = struct alignas(32) Vec2x2u64Reg
+	{
+		Phanes::Core::Types::uint64 data[4];
+	};
+	using Vec4u64Reg = struct alignas(32) Vec4u64Reg
+	{
+		Phanes::Core::Types::uint64 data[4];
+	};

 #endif

 	// NEON ...
-}
+} // namespace Phanes::Core::Types
--- a/Engine/Source/Runtime/Core/Math/SIMD/PhanesVectorMathFPU.hpp
+++ b/Engine/Source/Runtime/Core/Math/SIMD/PhanesVectorMathFPU.hpp
@@ -1,8 +1,7 @@
 #pragma once

-#include "Core/public/Math/SIMD/PhanesSIMDTypes.h"
-#include "Core/public/Math/MathCommon.hpp"
-
+#include "Core/Math/MathCommon.hpp"
+#include "Core/Math/SIMD/PhanesSIMDTypes.h"

 namespace Phanes::Core::Math::SIMD
 {
@@ -45,10 +44,12 @@ namespace Phanes::Core::Math::SIMD
 	/// <param name="v1"></param>
 	/// <param name="v2"></param>
 	/// <returns></returns>
-    Phanes::Core::Types::Vec4f32Reg vec4_dot(const Phanes::Core::Types::Vec4f32Reg v1, const Phanes::Core::Types::Vec4f32Reg v2)
+	Phanes::Core::Types::Vec4f32Reg vec4_dot(const Phanes::Core::Types::Vec4f32Reg v1,
+											 const Phanes::Core::Types::Vec4f32Reg v2)
 	{
 		Phanes::Core::Types::Vec4f32Reg r;
-        r.data[0] = v1.data[0] * v1.data[0] + v1.data[1] * v2.data[1] + v1.data[2] * v2.data[2] + v1.data[3] * v2.data[3];
+		r.data[0] = v1.data[0] * v1.data[0] + v1.data[1] * v2.data[1] + v1.data[2] * v2.data[2] +
+					v1.data[3] * v2.data[3];

 		return r;
 	}
@@ -59,16 +60,21 @@ namespace Phanes::Core::Math::SIMD
 	/// <param name="v1"></param>
 	/// <param name="v2"></param>
 	/// <returns></returns>
-    float vec4_dot_cvtf32(const Phanes::Core::Types::Vec4f32Reg v1, const Phanes::Core::Types::Vec4f32Reg v2)
+	float vec4_dot_cvtf32(const Phanes::Core::Types::Vec4f32Reg v1,
+						  const Phanes::Core::Types::Vec4f32Reg v2)
 	{
-        return v1.data[0] * v1.data[0] + v1.data[1] * v2.data[1] + v1.data[2] * v2.data[2] + v1.data[3] * v2.data[3];
+		return v1.data[0] * v1.data[0] + v1.data[1] * v2.data[1] + v1.data[2] * v2.data[2] +
+			   v1.data[3] * v2.data[3];
 	}

-    Phanes::Core::Types::Vec2f64Reg vec2_eq(const Phanes::Core::Types::Vec2f64Reg v1, const Phanes::Core::Types::Vec2f64Reg v2)
+	Phanes::Core::Types::Vec2f64Reg vec2_eq(const Phanes::Core::Types::Vec2f64Reg v1,
+											const Phanes::Core::Types::Vec2f64Reg v2)
 	{
 		Phanes::Core::Types::Vec4f64Reg r;

-        r.data[0] = (Phanes::Core::Math::Abs(v1.data[0] - v2.data[0]) < P_FLT_INAC) ? 0xFFFFFFFF : 0;
-        r.data[1] = (Phanes::Core::Math::Abs(v1.data[1] - v2.data[1]) < P_FLT_INAC) ? 0xFFFFFFFF : 0;
+		r.data[0] =
+			(Phanes::Core::Math::Abs(v1.data[0] - v2.data[0]) < P_FLT_INAC) ? 0xFFFFFFFF : 0;
+		r.data[1] =
+			(Phanes::Core::Math::Abs(v1.data[1] - v2.data[1]) < P_FLT_INAC) ? 0xFFFFFFFF : 0;
 	}
-}
+} // namespace Phanes::Core::Math::SIMD
--- a/Engine/Source/Runtime/Core/Math/SIMD/PhanesVectorMathSSE.hpp
+++ b/Engine/Source/Runtime/Core/Math/SIMD/PhanesVectorMathSSE.hpp
--- a/Engine/Source/Runtime/Core/Tests/Math/MathTestFPU/main.cpp
+++ b/Engine/Source/Runtime/Core/Tests/Math/MathTestFPU/main.cpp
@@ -1,21 +0,0 @@
-#include <iostream>
-#include "Core/Math/Include.h"
-
-namespace PMath = Phanes::Core::Math;
-
-int main() 
-{
-    PMath::Matrix4 m0 = PMath::Matrix4(1.0f, 5.0f, 3.0f, 4.0f,
-                                           2.0f, 6.0f, 4.0f, 1.0f,
-                                           2.0f, -3.0f, 5.0f, 3.0f,
-                                           8.0f, -4.0f, 6.0f, -2.0f);
-
-
-    PMath::Matrix4 m2;
-
-    std::cout << std::to_string(PMath::InverseV<float, false>(m0)) << std::endl;
-
-    std::cout << PMath::ToString(m0) << std::endl;
-
-    return 0;
-}
--- a/Engine/Source/Runtime/Core/Tests/Math/MathTestFPU/test.cpp
+++ b/Engine/Source/Runtime/Core/Tests/Math/MathTestFPU/test.cpp
--- a/README.md
+++ b/README.md
@@ -1,2 +1,45 @@
 # PhanesEngine
-3D / 2D Game Engine.
+
+Yet another Game Engine written in C++.
+
+## Build
+
+For building the engine premake5 is required. Execute `premake5 gmake` to generate the Makefile.
+
+### PhanesCore
+
+The Core Runtime library is build with:
+
+    make PhanesCore
+
+## Status
+
+Phanes is and will be developed, though progress will be slow.
+
+### Currenty under development
+
+- PhanesCore
+  - <span style="color:green; font-weight:800">Math</span>
+
+## Testing
+
+Testing PhanesEngine happens via the gtest framework. To run the tests for PhanesEngine one needs to
+build the test applications (currently only MathTestFPU) as well as gtet.
+
+    make MathTestFPU
+
+They depend on the gtest library so it should not be required to build it manually. If for some reason this doesn't
+work gtest can be build via:
+
+    make gtest
+
+## Sample Project
+
+The repository contains a sample game project using PhanesEngine. It can be build by executing:
+
+    make DevPlayground
+
+## Copyright
+
+PhanesEngine was developed by Thorben Höhne and is licensed under the Apache License Version 2.0. See
+[LICENSE](LICENSE) for more information.
--- a/premake5.lua
+++ b/premake5.lua
@@ -63,6 +63,8 @@ function boilerplate()
 		buildoptions({ "-Wno-unused-parameter", "-fms-extensions" })
 	end

+	buildoptions({"-fno-fast-math"})
+
 	filter("configurations:Debug")
 		defines({ "DEBUG", "TRACE", "P_DEBUG" })
 		symbols("On")
Author	SHA1	Message	Date
Thorben Höhne	1688665852	Removing .vscode project config	2025-05-04 21:31:44 +02:00
Thorben Höhne	b881bde64b	feat: Changes to Matrix2 FunctionTests	2025-05-04 21:30:14 +02:00
Thorben Höhne	e6d0cd2235	Insignificant changes	2025-05-04 21:29:31 +02:00
Thorben Höhne	91ea4a1aed	chore: Fixing wrong docs.	2025-05-04 21:28:51 +02:00
Thorben Höhne	8bd331396d	chore: Make construction from 2d Array explicit.	2025-05-04 21:27:53 +02:00
Thorben Höhne	af41821541	chore: Replacing typedef with using.	2025-05-04 21:26:24 +02:00
Thorben Höhne	1213bd3a2d	feat: Introducing TQuaternion.	2025-05-04 21:24:56 +02:00
Thorben Höhne	3d656bedb0	feat: Fixing typo	2025-05-04 19:58:52 +02:00
Thorben Höhne	81ef16cc99	feat: Fix misleading doc.	2025-05-04 16:30:02 +02:00
Thorben Höhne	77d39b6254	feat: First good README.md	2025-05-04 02:02:34 +02:00
Thorben Höhne	0f0c808817	chore: Fix import paths.	2025-05-04 00:54:56 +02:00
Thorben Höhne	26e2403fd7	chore: Changing typedef declarations to using.	2025-05-04 00:52:14 +02:00