Enable Dependency management with fetchcontent

- Renamed the cmake imported targets for the ZEngine and Tetragrama
  dependencies.

- Change output location for the vulkan-loader to use FetchContent
  locations

Author: MathewBensonCode

.github/workflows/Engine-CI.yml

@@ -1,6 +1,6 @@
 on:
   push:
-    branches: [ master, develop, arena-integration ]
+    branches: [ master, develop, arena-integration, compile_on_linux_fetchcontent ]
   pull_request:
     branches: [ master, develop, arena-integration ]
 

Obelisk/EntryPoint.cpp

@@ -18,7 +18,7 @@ int applicationEntryPoint(int argc, char* argv[])
     MemoryManager       manager = {};
     MemoryConfiguration config  = {.DefaultSize = ZGiga(3u)};
     manager.Initialize(config);
-    auto                arena      = &(manager.Allocator);
+    auto                arena      = &(manager.ArenaAllocatorValue);
 
     LoggerConfiguration logger_cfg = {};
     Logger::Initialize(arena, logger_cfg);

Scripts/RunTests.ps1

@@ -77,5 +77,5 @@ function RunTests {
 }
 # Run tests for each configuration
 foreach ($config in $Configurations) {
-    RunTests -Configuration $config
+RunTests -Configuration $config
 }

ZEngine/CMakeLists.txt

@@ -6,8 +6,5 @@ project (ZEngine
 	LANGUAGES CXX C
 )
 
-set (CMAKE_CXX_STANDARD_REQUIRED ON)
-set	(CMAKE_CXX_STANDARD 20)
-
 add_subdirectory (ZEngine)
 add_subdirectory (tests)

ZEngine/ZEngine/Core/Memory/MemoryManager.h

@@ -12,14 +12,14 @@ namespace ZEngine::Core::Memory
     {
         void Initialize(const MemoryConfiguration& config)
         {
-            this->Allocator.Initialize(config.DefaultSize);
+            this->ArenaAllocatorValue.Initialize(config.DefaultSize);
         }
 
         void Shutdowm()
         {
-            Allocator.Shutdown();
+            ArenaAllocatorValue.Shutdown();
         }
 
-        ArenaAllocator Allocator = {};
+        ArenaAllocator ArenaAllocatorValue = {};
     };
 } // namespace ZEngine::Core::Memory

ZEngine/ZEngine/Maths/Math.cpp

@@ -0,0 +1,65 @@
+#include <Maths/Math.h>
+
+#include <glm/gtx/matrix_decompose.hpp>
+
+namespace glm
+{
+
+    bool DecomposeTransformComponent(const Matrix4& transform, Vector3& translation, Vector3& rotation, Vector3& scale)
+    {
+        // From glm::decompose in matrix_decompose.inl
+
+        using T = float;
+
+        mat4 LocalMatrix(transform);
+
+        // Normalize the matrix.
+        if (epsilonEqual(LocalMatrix[3][3], static_cast<float>(0), epsilon<T>()))
+            return false;
+
+        // First, isolate perspective.  This is the messiest.
+        if (epsilonNotEqual(LocalMatrix[0][3], static_cast<T>(0), epsilon<T>()) || epsilonNotEqual(LocalMatrix[1][3], static_cast<T>(0), epsilon<T>()) || epsilonNotEqual(LocalMatrix[2][3], static_cast<T>(0), epsilon<T>()))
+        {
+            // Clear the perspective partition
+            LocalMatrix[0][3] = LocalMatrix[1][3] = LocalMatrix[2][3] = static_cast<T>(0);
+            LocalMatrix[3][3]                                         = static_cast<T>(1);
+        }
+
+        // Next take care of translation (easy).
+        translation    = vec3(LocalMatrix[3]);
+        LocalMatrix[3] = vec4(0, 0, 0, LocalMatrix[3].w);
+
+        vec3 Row[3], Pdum3;
+
+        // Now get scale and shear.
+        for (length_t i = 0; i < 3; ++i)
+            for (length_t j = 0; j < 3; ++j)
+                Row[i][j] = LocalMatrix[i][j];
+
+        // Compute X scale factor and normalize first row.
+        scale.x    = length(Row[0]);
+        Row[0]     = detail::scale(Row[0], static_cast<T>(1));
+        scale.y    = length(Row[1]);
+        Row[1]     = detail::scale(Row[1], static_cast<T>(1));
+        scale.z    = length(Row[2]);
+        Row[2]     = detail::scale(Row[2], static_cast<T>(1));
+
+        // At this point, the matrix (in rows[]) is orthonormal.
+        // Check for a coordinate system flip.  If the determinant
+        // is -1, then negate the matrix and the scaling factors.
+
+        rotation.y = asin(-Row[0][2]);
+        if (cos(rotation.y) != 0)
+        {
+            rotation.x = atan2(Row[1][2], Row[2][2]);
+            rotation.z = atan2(Row[0][1], Row[0][0]);
+        }
+        else
+        {
+            rotation.x = atan2(-Row[2][0], Row[1][1]);
+            rotation.z = 0;
+        }
+
+        return true;
+    }
+} // namespace glm

ZEngine/tests/Memory/allocator_test.cpp

@@ -82,14 +82,14 @@ TEST(AllocatorTest, ArenaMemoryManager)
         void  Func() {}
     };
 
-    int* intPtr    = ZPushArray(&(manager.Allocator), int, 1);
-    auto structPtr = ZPushStruct(&(manager.Allocator), Foo);
+    int* intPtr    = ZPushArray(&(manager.ArenaAllocatorValue), int, 1);
+    auto structPtr = ZPushStruct(&(manager.ArenaAllocatorValue), Foo);
 
     *intPtr        = 12;
     structPtr->x   = 12;
     structPtr->y   = 798.0f;
 
-    char* str      = ZPushString(&(manager.Allocator), 12);
+    char* str      = ZPushString(&(manager.ArenaAllocatorValue), 12);
     Helpers::secure_memmove(str, 12, "hello", 5);
 
     EXPECT_EQ(*intPtr, 12);
@@ -121,7 +121,7 @@ TEST(AllocatorTest, ArenaMemoryTemp)
 {
     MemoryManager manager{};
     manager.Initialize({.DefaultSize = ZKilo(10)});
-    auto arena = &(manager.Allocator);
+    auto arena = &(manager.ArenaAllocatorValue);
     {
         auto fooPtr  = ZPushStruct(arena, Foo);
         fooPtr->x    = 10;
@@ -142,7 +142,7 @@ TEST(AllocatorTest, ArenaMemoryPool)
 {
     MemoryManager manager{};
     manager.Initialize({.DefaultSize = ZKilo(10)});
-    auto arena = &(manager.Allocator);
+    auto arena = &(manager.ArenaAllocatorValue);
     {
         PoolAllocator pool;
         pool.Initialize(arena, sizeof(Foo) * 100, sizeof(Foo));

ZEngine/tests/Memory/handleManager_test.cpp

@@ -10,7 +10,7 @@ class HandleManagerTest : public ::testing::Test
     void SetUp() override
     {
         manager.Initialize({.DefaultSize = ZKilo(10)});
-        auto arena = &(manager.Allocator);
+        auto arena = &(manager.ArenaAllocatorValue);
         handle_manager.Initialize(arena, 10);
     }
 
@@ -114,7 +114,7 @@ TEST_F(HandleManagerTest, ReuseSlot)
 TEST_F(HandleManagerTest, ConcurrentAccess)
 {
     ZEngine::Helpers::HandleManager<int*> h_manager;
-    h_manager.Initialize(&(manager.Allocator), 40);
+    h_manager.Initialize(&(manager.ArenaAllocatorValue), 40);
     const int                numThreads             = 4;
     const int                numOperationsPerThread = 10;
     std::vector<std::thread> threads;