SIMD vector math overhaul

.github/workflows/cmake-linux-vulkan.yml

@@ -143,8 +143,7 @@ jobs:
 
       - name: Test
         working-directory: ${{ env.BUILD_DIR }}/Tests/Core
-        # For now, we exclude Core_Math_UnitTests because it fails due to SIMD issues on x86. This needs to be fixed.
-        run: ctest -C ${{env.BUILD_TYPE}} --output-on-failure -E "Core_Math_UnitTests"
+        run: ctest -C ${{env.BUILD_TYPE}} --output-on-failure
 
   test-modules:
     runs-on: ubuntu-latest

Core/CMakeLists.txt

@@ -45,7 +45,6 @@ set(MathSrc
         Include/KryneEngine/Core/Math/Vector2.hpp
         Include/KryneEngine/Core/Math/Vector3.hpp
         Include/KryneEngine/Core/Math/Vector4.hpp
-        Include/KryneEngine/Core/Math/XSimdUtils.hpp
         Include/KryneEngine/Core/Math/Hashing.hpp
         Src/Math/Hashing.cpp
         Include/KryneEngine/Core/Math/Quaternion.hpp
@@ -62,6 +61,13 @@ set(MathSrc
         Include/KryneEngine/Core/Math/Float16.hpp
         Src/Math/Float16.cpp
         Include/KryneEngine/Core/Math/Color.hpp
+        Include/KryneEngine/Core/Math/Simd/SimdCommon.hpp
+        Include/KryneEngine/Core/Math/Simd/SimdTypes.hpp
+        Include/KryneEngine/Core/Math/Simd/SimdMemoryOperations.hpp
+        Include/KryneEngine/Core/Math/Simd/SimdArithmeticOperations.hpp
+        Include/KryneEngine/Core/Math/Simd/SimdMathOperations.hpp
+        Include/KryneEngine/Core/Math/Simd/SimdCompareOperations.hpp
+        Include/KryneEngine/Core/Math/Simd/VectorUtils.hpp
 )
 
 set(MemorySrc
@@ -211,6 +217,7 @@ elseif (GraphicsApi STREQUAL "MTL")
                 Src/Graphics/Metal/MetalArgumentBufferManager.cpp
                 Src/Graphics/Metal/MetalArgumentBufferManager.hpp
                 Src/Graphics/Metal/Helpers/RenderState.hpp
+                Include/KryneEngine/Core/Platform/Cpu.hpp
         )
 endif()
 
@@ -223,7 +230,7 @@ add_library(KryneEngine_Core
         ${ProfilingSrc}
         ${ThreadsSrc}
         ${WindowSrc})
-target_link_libraries(KryneEngine_Core EASTL glfw glm Tracy::TracyClient moodycamel Boost::context xsimd)
+target_link_libraries(KryneEngine_Core EASTL glfw glm Tracy::TracyClient moodycamel Boost::context)
 
 if (GraphicsApi STREQUAL "VK")
         message(STATUS "Finding and linking Vulkan lib")

Core/Include/KryneEngine/Core/Math/Color.hpp

@@ -98,23 +98,23 @@ namespace KryneEngine
         // Based on https://chilliant.blogspot.com/2012/08/srgb-approximations-for-hlsl.html
         [[nodiscard]] Color ToSrgb() const
         {
-            const float3_simd rgb { m_value.r, m_value.g, m_value.b };
+            const float3 rgb { m_value.r, m_value.g, m_value.b };
 
-            const float3_simd s1 = rgb.Sqrt();
-            const float3_simd s2 = s1.Sqrt();
-            const float3_simd s3 = s2.Sqrt();
+            const float3 s1 = rgb.Sqrt();
+            const float3 s2 = s1.Sqrt();
+            const float3 s3 = s2.Sqrt();
 
-            const float3_simd srgb = s1 * 0.585122381 + s2 * 0.783140355 - s3 * 0.368262736;
+            const float3 srgb = s1 * 0.585122381 + s2 * 0.783140355 - s3 * 0.368262736;
 
             return Color(float4(srgb, m_value.a));
         }
 
         // Based on https://chilliant.blogspot.com/2012/08/srgb-approximations-for-hlsl.html
         [[nodiscard]] Color FromSrgb() const
         {
-            const float3_simd srgb { m_value.r, m_value.g, m_value.b };
+            const float3 srgb { m_value.r, m_value.g, m_value.b };
 
-            const float3_simd rgb = srgb * (srgb * (srgb * 0.305306011 + 0.682171111) + 0.012522878);
+            const float3 rgb = srgb * (srgb * (srgb * 0.305306011 + 0.682171111) + 0.012522878);
 
             return Color(float4(rgb, m_value.a));
         }

Core/Include/KryneEngine/Core/Math/CoordinateSystem.hpp

@@ -40,38 +40,39 @@ namespace KryneEngine::Math
         RightHandedZUp,
     };
 
-    constexpr bool IsLeftHanded(CoordinateSystem _system)
+    constexpr bool IsLeftHanded(const CoordinateSystem _system)
     {
         return _system == CoordinateSystem::LeftHandedYUp || _system == CoordinateSystem::LeftHandedZUp;
     }
 
-    constexpr bool IsZUp(CoordinateSystem _system)
+    constexpr bool IsZUp(const CoordinateSystem _system)
     {
         return _system == CoordinateSystem::RightHandedZUp || _system == CoordinateSystem::LeftHandedZUp;
     }
 
-    inline float3 UpVector(CoordinateSystem _system = KE_DEFAULT_COORDINATE_SYSTEM)
+    inline float3 UpVector(const CoordinateSystem _system = KE_DEFAULT_COORDINATE_SYSTEM)
     {
         return IsZUp(_system) ? float3(0.0f, 0.0f, 1.0f) : float3(0.0f, 1.0f, 0.0f);
     }
 
-    inline float3 RightVector(CoordinateSystem _system = KE_DEFAULT_COORDINATE_SYSTEM)
+    inline float3 RightVector(const CoordinateSystem _system = KE_DEFAULT_COORDINATE_SYSTEM)
     {
         return float3 { 1.0f, 0.0f, 0.0f };
     }
 
-    inline float3 ForwardVector(CoordinateSystem _system = KE_DEFAULT_COORDINATE_SYSTEM)
+    inline float3 ForwardVector(const CoordinateSystem _system = KE_DEFAULT_COORDINATE_SYSTEM)
     {
         switch (_system)
         {
         case CoordinateSystem::LeftHandedYUp:
             return float3 { 0.0f, 0.0f, 1.0f };
         case CoordinateSystem::RightHandedYUp:
             return float3 { 0.0f, 0.0f, -1.0f };
-        case CoordinateSystem::RightHandedZUp:
-            return float3 { 0.0f, 1.0f, 0.0f };
         case CoordinateSystem::LeftHandedZUp:
             return float3 { 0.0f, -1.0f, 0.0f };
+        case CoordinateSystem::RightHandedZUp:
+        default:
+            return float3 { 0.0f, 1.0f, 0.0f };
         };
     }
 

Core/Include/KryneEngine/Core/Math/Matrix.hpp

@@ -15,34 +15,34 @@
 
 namespace KryneEngine
 {
-    using float3x3 = Math::Matrix33Base<float, false, KE_DEFAULT_MATRIX_ROW_MAJOR>;
-    using double3x3 = Math::Matrix33Base<double, false, KE_DEFAULT_MATRIX_ROW_MAJOR>;
-    using float3x3_simd = Math::Matrix33Base<float, true, KE_DEFAULT_MATRIX_ROW_MAJOR>;
-    using double3x3_simd = Math::Matrix33Base<double, true, KE_DEFAULT_MATRIX_ROW_MAJOR>;
+    using float3x3 = Math::Matrix33Base<float, KE_DEFAULT_MATRIX_ROW_MAJOR>;
+    using double3x3 = Math::Matrix33Base<double, KE_DEFAULT_MATRIX_ROW_MAJOR>;
 
-    using float4x4 = Math::Matrix44Base<float, false, KE_DEFAULT_MATRIX_ROW_MAJOR>;
-    using double4x4 = Math::Matrix44Base<double, false, KE_DEFAULT_MATRIX_ROW_MAJOR>;
-    using float4x4_simd = Math::Matrix44Base<float, true, KE_DEFAULT_MATRIX_ROW_MAJOR>;
-    using double4x4_simd = Math::Matrix44Base<double, true, KE_DEFAULT_MATRIX_ROW_MAJOR>;
+    using float4x4 = Math::Matrix44Base<float, KE_DEFAULT_MATRIX_ROW_MAJOR, false>;
+    using double4x4 = Math::Matrix44Base<double, KE_DEFAULT_MATRIX_ROW_MAJOR, false>;
+    using float4x4_simd = Math::Matrix44Base<float, KE_DEFAULT_MATRIX_ROW_MAJOR, false>;
+    using double4x4_simd = Math::Matrix44Base<double, KE_DEFAULT_MATRIX_ROW_MAJOR, false>;
 
-    template<class T, bool SimdOptimal, bool RowMajor>
-    Math::Matrix44Base<T, SimdOptimal, RowMajor> ToMatrix44(const Math::Matrix33Base<T, SimdOptimal, RowMajor>& _matrix)
+    template<Math::Matrix44Type T>
+    T ToMatrix44(const Math::Matrix33Base<typename T::ScalarType, T::kRowMajorLayout>& _matrix)
     {
-        return Math::Matrix44Base<T, SimdOptimal, RowMajor> {
-            Math::Vector4Base<T, SimdOptimal>{ _matrix.m_vectors[0], 0.f },
-            Math::Vector4Base<T, SimdOptimal>{ _matrix.m_vectors[1], 0.f },
-            Math::Vector4Base<T, SimdOptimal>{ _matrix.m_vectors[2], 0.f },
-            Math::Vector4Base<T, SimdOptimal>{ 0.0f, 0.0f, 0.0f, 1.0f }
+        using VectorType = T::VectorType;
+        return T {
+            VectorType{ _matrix.m_vectors[0], 0.f },
+            VectorType{ _matrix.m_vectors[1], 0.f },
+            VectorType{ _matrix.m_vectors[2], 0.f },
+            VectorType{ 0.0f, 0.0f, 0.0f, 1.0f }
         };
     }
 
-    template<class T, bool SimdOptimal, bool RowMajor>
-    Math::Matrix33Base<T, SimdOptimal, RowMajor> ToMatrix33(const Math::Matrix44Base<T, SimdOptimal, RowMajor>& _matrix)
+    template<class T, bool RowMajor, bool SimdAligned>
+    Math::Matrix33Base<T, RowMajor> ToMatrix33(const Math::Matrix44Base<T, RowMajor, SimdAligned>& _matrix)
     {
-        return Math::Matrix33Base<T, SimdOptimal, RowMajor> {
-            Math::Vector3Base<T, SimdOptimal>{ _matrix.m_vectors[0].x, _matrix.m_vectors[0].y, _matrix.m_vectors[0].z },
-            Math::Vector3Base<T, SimdOptimal>{ _matrix.m_vectors[1].x, _matrix.m_vectors[1].y, _matrix.m_vectors[1].z },
-            Math::Vector3Base<T, SimdOptimal>{ _matrix.m_vectors[2].x, _matrix.m_vectors[2].y, _matrix.m_vectors[2].z }
+        using Matrix = Math::Matrix33Base<T, RowMajor>;
+        return Matrix {
+            Matrix::VectorType(_matrix.m_vectors[0].x, _matrix.m_vectors[0].y, _matrix.m_vectors[0].z),
+            Matrix::VectorType(_matrix.m_vectors[1].x, _matrix.m_vectors[1].y, _matrix.m_vectors[1].z),
+            Matrix::VectorType(_matrix.m_vectors[2].x, _matrix.m_vectors[2].y, _matrix.m_vectors[2].z)
         };
     }
 }

Core/Include/KryneEngine/Core/Math/Matrix33.hpp

@@ -9,17 +9,18 @@
 #include <cstddef>
 #include <EASTL/type_traits.h>
 
-#include "KryneEngine/Core/Math/Vector3.hpp"
+#include "KryneEngine/Core/Math/Vector4.hpp"
 
 namespace KryneEngine::Math
 {
-    template<class T, bool SimdOptimal, bool RowMajor>
+    template<class T, bool RowMajor>
     struct Matrix33Base
     {
         using ScalarType = T;
-        static constexpr bool kSimdOptimal = SimdOptimal;
         static constexpr bool kRowMajorLayout = RowMajor;
 
+        using VectorType = Vector3Base<T>;
+
         Matrix33Base();
         ~Matrix33Base() = default;
 
@@ -52,23 +53,27 @@ namespace KryneEngine::Math
          * @note Requires that the type `U` is implicitly convertible to the type `T` of
          * the matrix through a constraint using `eastl::is_convertible_v<U, T>`.
          */
-        template<class U, bool VSimdOptimal>
+        template<class U>
         requires eastl::is_convertible_v<U, T>
         Matrix33Base(
-            const Vector3Base<U, VSimdOptimal>& _v1,
-            const Vector3Base<U, VSimdOptimal>& _v2,
-            const Vector3Base<U, VSimdOptimal>& _v3)
+            const Vector3Base<U>& _v1,
+            const Vector3Base<U>& _v2,
+            const Vector3Base<U>& _v3)
                 : m_vectors {
-                  Vector3Base<T, SimdOptimal>{ _v1 },
-                  Vector3Base<T, SimdOptimal>{ _v2 },
-                  Vector3Base<T, SimdOptimal>{ _v3 }
+                    VectorType { _v1 },
+                    VectorType { _v2 },
+                    VectorType { _v3 },
                 }
         {}
 
-        template<class U, bool S>
+        template<class U>
         requires eastl::is_convertible_v<U, T>
-        explicit Matrix33Base(const Matrix33Base<U, S, RowMajor>& _other)
-            : Matrix33Base(_other.m_vectors[0], _other.m_vectors[1], _other.m_vectors[2])
+        explicit Matrix33Base(const Matrix33Base<U, RowMajor>& _other)
+            : m_vectors {
+                VectorType(_other.m_vectors[0].x, _other.m_vectors[0].y, _other.m_vectors[0].z),
+                VectorType(_other.m_vectors[1].x, _other.m_vectors[1].y, _other.m_vectors[1].z),
+                VectorType(_other.m_vectors[2].x, _other.m_vectors[2].y, _other.m_vectors[2].z)
+            }
         {}
 
         [[nodiscard]] bool IsRowMajor() const { return RowMajor; }
@@ -110,7 +115,6 @@ namespace KryneEngine::Math
          *
          * @tparam U The type of the elements within the input matrix to be converted. This type must be convertible to the
          *         type of the elements of the target matrix `T`.
-         * @tparam OtherSimdOptimal Indicates whether the input matrix is optimized for SIMD operations.
          *
          * @param _other The input matrix to be converted to the target type and layout. This matrix must be in the opposite
          *        row-major/column-major layout relative to the target matrix.
@@ -120,23 +124,22 @@ namespace KryneEngine::Math
          *
          * @note The input matrix's type and layout constraints are enforced through a `requires` clause using `eastl::is_convertible_v<U, T>`.
          */
-        template <class U, bool OtherSimdOptimal>
+        template <class U>
         requires eastl::is_convertible_v<U, T>
-        static Matrix33Base Convert(const Matrix33Base<U, OtherSimdOptimal, !RowMajor>& _other)
+        static Matrix33Base Convert(const Matrix33Base<U, !RowMajor>& _other)
         {
-            Matrix33Base<U, OtherSimdOptimal, !RowMajor> transposed = _other;
+            Matrix33Base<U, !RowMajor> transposed = _other;
             transposed.Transpose();
             return Matrix33Base(transposed.m_vectors[0], transposed.m_vectors[1], transposed.m_vectors[2]);
         }
 
-        Vector3Base<T, SimdOptimal> m_vectors[3];
+        VectorType m_vectors[3];
     };
 
     template<class T>
     concept Matrix33Type = requires {
         typename T::ScalarType;
-        T::kSimdOptimal;
         T::kRowMajorLayout;
-        std::is_same_v<Matrix33Base<typename T::ScalarType, T::kSimdOptimal, T::kRowMajorLayout>, T>;
+        std::is_same_v<Matrix33Base<typename T::ScalarType, T::kRowMajorLayout>, T>;
     };
 }