Removing .vscode project config

.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
 '
 
 

.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
-                }
-            ]
-        }
-    ]
-}

.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",
-}

.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"
-}

Engine/Source/Runtime/Core/Math/MathFwd.h

@@ -1,201 +1,238 @@
 #pragma once
 
 #ifdef P_BUILD_LIB
-    #include "PhanesEnginePCH.h"
-#else 
-    #include <vector>
+#	include "PhanesEnginePCH.h"
+#else
+#	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.
      */
 
-    // TPoint2
+	// 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
+	// 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
+	// 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
 
-    // TIntPoint2
+	using IntPoint2 = TIntPoint2<int>;
+	using IntPoint2i = TIntPoint2<int>;
+	using IntPoint2l = TIntPoint2<long>;
 
-    typedef TIntPoint2<int>      IntPoint2;
-    typedef TIntPoint2<int>      IntPoint2i;
-    typedef TIntPoint2<long>     IntPoint2l;
+	// TIntPoint3
 
-    // TIntPoint3
+	using IntPoint3 = TIntPoint3<int>;
+	using IntPoint3i = TIntPoint3<int>;
+	using IntPoint3l = TIntPoint3<long>;
 
-    typedef TIntPoint3<int>      IntPoint3;
-    typedef TIntPoint3<int>      IntPoint3i;
-    typedef TIntPoint3<long>     IntPoint3l;
+	// TIntPoint4
 
-    // TIntPoint4
+	using IntPoint4 = TIntPoint4<int>;
+	using IntPoint4i = TIntPoint4<int>;
+	using IntPoint4l = TIntPoint4<long>;
 
-    typedef TIntPoint4<int>      IntPoint4;
-    typedef TIntPoint4<int>      IntPoint4i;
-    typedef TIntPoint4<long>     IntPoint4l;
+	// IntVetor2
 
-    // IntVetor2
+	using IntVector2 = TIntVector2<int, false>;
+	using Vector2i = TIntVector2<int, false>;
+	using LongVector2 = TIntVector2<long, false>;
+	using Vector2l = TIntVector2<long, false>;
 
-    typedef TIntVector2<int, false>     IntVector2;
-    typedef TIntVector2<int, false>     Vector2i;
-    typedef TIntVector2<long, false>    LongVector2;
-    typedef TIntVector2<long, false>    Vector2l;
+	// IntVetor3
 
-    // IntVetor3
+	using IntVector3 = TIntVector3<int, false>;
+	using Vector3i = TIntVector3<int, false>;
+	using LongVector3 = TIntVector3<long, false>;
+	using Vector3l = TIntVector3<long, false>;
 
-    typedef TIntVector3<int, false>     IntVector3;
-    typedef TIntVector3<int, false>     Vector3i;
-    typedef TIntVector3<long, false>    LongVector3;
-    typedef TIntVector3<long, false>    Vector3l;
+	// IntVetor4
 
+	using IntVector4 = TIntVector4<int, false>;
+	using Vector4i = TIntVector4<int, false>;
+	using LongVector4 = TIntVector4<long, false>;
+	using Vector4l = TIntVector4<long, false>;
 
-    // IntVetor4
+	// Vector2
 
-    typedef TIntVector4<int, false>     IntVector4;
-    typedef TIntVector4<int, false>     Vector4i;
-    typedef TIntVector4<long, false>    LongVector4;
-    typedef TIntVector4<long, false>    Vector4l;
+	using Vector2 = TVector2<float, false>;
+	using Vector2f = TVector2<float, false>;
+	using Vector2d = TVector2<double, false>;
 
-    // Vector2
+	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>;
 
-    typedef TVector2<float, false>      Vector2;
-    typedef TVector2<float, false>      Vector2f;
-    typedef TVector2<double, false>     Vector2d;
+	// Vector3
 
-    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 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>;
 
-    // Vector3
+	// Vector4
 
-    typedef TVector3<float, false>      Vector3;
-    typedef TVector3<float, false>      Vector3f;
-    typedef TVector3<double, false>     Vector3d;
+	using Vector4 = TVector4<float, false>;
+	using Vector4f = TVector4<float, false>;
+	using Vector4d = TVector4<double, false>;
 
-    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 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
 
-    // Vector4
+	using Matrix2 = TMatrix2<float>;
+	using Matrix2f = TMatrix2<float>;
+	using Matrix2d = TMatrix2<double>;
 
-    typedef TVector4<float, false>      Vector4;
-    typedef TVector4<float, false>      Vector4f;
-    typedef TVector4<double, false>     Vector4d;
+	// Matrix3
 
-    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;
-    
-    // Matrix2 
-    
-    typedef TMatrix2<float>             Matrix2;
-    typedef TMatrix2<float>             Matrix2f;
-    typedef TMatrix2<double>            Matrix2d;
+	using Matrix3 = TMatrix3<float, false>;
+	using Matrix3f = TMatrix3<float, false>;
+	using Matrix3d = TMatrix3<double, false>;
 
-    // Matrix3 
+	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>;
 
-    typedef TMatrix3<float, false>      Matrix3;
-    typedef TMatrix3<float, false>      Matrix3f;
-    typedef TMatrix3<double, false>     Matrix3d;
+	// Matrix4
 
-    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 Matrix4 = TMatrix4<float, false>;
+	using Matrix4f = TMatrix4<float, false>;
+	using Matrix4d = TMatrix4<double, false>;
 
-    // Matrix4 
+	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>;
 
-    typedef TMatrix4<float, false>             Matrix4;
-    typedef TMatrix4<float, false>             Matrix4f;
-    typedef TMatrix4<double, false>            Matrix4d;
+	// TPlane
 
-    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 Plane = TPlane<float, false>;
+	using Planef = TPlane<float, false>;
+	using Planed = TPlane<double, false>;
 
+	using PlaneReg = TPlane<float, SIMD::use_simd<float, 4, true>::value>;
+	using PlaneRegd = TPlane<float, SIMD::use_simd<double, 4, true>::value>;
 
-
-    // TPlane 
-
-    typedef TPlane<float, false>        Plane;
-    typedef TPlane<float, false>        Planef;
-    typedef TPlane<double, false>       Planed;
-
-    typedef TPlane<float, SIMD::use_simd<float, 4, true>::value>    PlaneReg;
-    typedef TPlane<float, SIMD::use_simd<double, 4, true>::value>   PlaneRegd;
-
-
-} // Phanes::Core::Math::coretypes
+} // namespace Phanes::Core::Math
 
 namespace Phanes::Core::Math::Internal
 {
 
-    // Internal types
+	// Internal types
 
-    template <typename T, unsigned int D> struct AVector;
+	template <typename T, unsigned int D>
+	struct AVector;
 
-    template <typename T, unsigned int n, unsigned int> struct AMatrix;
-}
+	template <typename T, unsigned int n, unsigned int>
+	struct AMatrix;
+} // namespace Phanes::Core::Math::Internal
 
-
-#endif // !MATH_FWD_H
+#endif // !MATH_FWD_H

Engine/Source/Runtime/Core/Math/Matrix2.hpp

@@ -68,11 +68,11 @@ namespace Phanes::Core::Math
          * 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)

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]);
@@ -331,4 +331,4 @@ namespace Phanes::Core::Math {
 
 #endif // !MATRIX4_H
 
-#include "Core/Math/Matrix4.inl"
+#include "Core/Math/Matrix4.inl"

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

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;
-}

premake5.lua

@@ -63,17 +63,19 @@ function boilerplate()
 		buildoptions({ "-Wno-unused-parameter", "-fms-extensions" })
 	end
 
+	buildoptions({"-fno-fast-math"})
+
 	filter("configurations:Debug")
-	defines({ "DEBUG", "TRACE", "P_DEBUG" })
-	symbols("On")
-	buildmessage("Building %{prj.name} in debug mode")
+		defines({ "DEBUG", "TRACE", "P_DEBUG" })
+		symbols("On")
+		buildmessage("Building %{prj.name} in debug mode")
 
 	filter("configurations:Release")
-	defines({ "NDEBUG", "P_RELEASE" })
-	linktimeoptimization("On")
-	optimize("On")
-	intrinsics("On")
-	buildmessage("Building %{prj.name} in release mode")
+		defines({ "NDEBUG", "P_RELEASE" })
+		linktimeoptimization("On")
+		optimize("On")
+		intrinsics("On")
+		buildmessage("Building %{prj.name} in release mode")
 
 	filter({})
 end