Work on async asset loading

Author: KredeGC

Mahakam/src/Mahakam/Asset/Asset.h

@@ -1,10 +1,12 @@
 #pragma once
 
-#include "AssetDatabase.h"
 
 #include "Mahakam/Core/Allocator.h"
 #include "Mahakam/Core/Log.h"
 
+#include "AssetDatabase.h"
+#include "AssetDataFunctions.h"
+
 #include <cstddef>
 #include <filesystem>
 #include <memory>
@@ -23,8 +25,6 @@ namespace Mahakam
 
 		friend class AssetDatabase;
 
-		using AssetID = AssetDatabase::AssetID;
-		using ControlBlock = AssetDatabase::ControlBlock;
 		using ExtensionType = AssetDatabase::ExtensionType;
 
 		ControlBlock* m_Control;
@@ -176,6 +176,11 @@ namespace Mahakam
 			return m_Control ? m_Control->UseCount : 0;
 		}
 
+		AssetState GetState() const noexcept
+		{
+			return m_Control ? m_Control->State : AssetState::Failed;
+		}
+
 		T* get() const noexcept
 		{
 			return m_Control ? reinterpret_cast<T*>(m_Control + 1) : nullptr;
@@ -202,7 +207,7 @@ namespace Mahakam
 
 		explicit operator bool() const noexcept
 		{
-			return m_Control;
+			return m_Control ? (m_Control->State == AssetState::Loaded || m_Control->State == AssetState::Streaming) : false;
 		}
 
 	private:
@@ -222,7 +227,7 @@ namespace Mahakam
 				if (m_Control->ID)
 					AssetDatabase::UnloadAsset(m_Control);
 
-				auto destroy = m_Control->DeleteData;
+				auto destroy = m_Control->Functions->Delete;
 
 				MH_ASSERT(destroy, "Asset destructor encountered invalid control block");
 
@@ -234,35 +239,10 @@ namespace Mahakam
 	template<typename T, typename ... Args>
 	constexpr Asset<T> CreateAsset(Args&& ... args)
 	{
-		struct DataBlock
-		{
-			AssetDatabase::ControlBlock Control;
-			T Data;
-		};
-
-		DataBlock* block = Allocator::Allocate<DataBlock>(1);
+		DataBlock<T>* block = reinterpret_cast<DataBlock<T>*>(GetAssetDataFunctions<T>()->CreateControlBlock());
 
 		Allocator::Construct(&block->Data, std::forward<Args>(args)...);
-
-		auto mover = [](void* from, void* to)
-		{
-			*static_cast<T*>(to) = std::move(*static_cast<T*>(from));
-		};
-
-		auto deleter = [](void* p)
-		{
-			DataBlock* block = static_cast<DataBlock*>(p);
-
-			Allocator::Deconstruct(&block->Data);
-
-			Allocator::Deallocate(block, 1);
-		};
-
-		block->Control.UseCount = 0;
-		block->Control.ID = 0;
-		block->Control.State = AssetDatabase::AssetState::Loaded;
-		block->Control.MoveData = mover;
-		block->Control.DeleteData = deleter;
+		block->Control.State = AssetState::Loaded;
 
 		return Asset<T>(&block->Control);
 	}

Mahakam/src/Mahakam/Asset/AssetDataFunctions.h

@@ -0,0 +1,91 @@
+#pragma once
+
+#include "Mahakam/Core/Allocator.h"
+
+#include <cstdint>
+#include <type_traits>
+
+namespace Mahakam
+{
+    enum class AssetState
+    {
+        Failed = 0,
+        Loaded,
+        Processing,
+        Streaming
+    };
+
+    using AssetID = uint64_t;
+
+    struct ControlBlock;
+
+    struct AssetDataFunctions
+    {
+        ControlBlock* (*CreateControlBlock)();
+        void (*MoveConstruct)(void*, void*);
+        void (*MoveAssign)(void*, void*);
+        void (*Delete)(void*);
+    };
+
+    struct ControlBlock
+    {
+        // ID 0 is guaranteed to be invalid
+        size_t UseCount;
+        AssetID ID;
+        AssetState State;
+        AssetDataFunctions* Functions;
+    };
+
+    template<typename T>
+    struct DataBlock
+    {
+        ControlBlock Control;
+        T Data;
+    };
+
+    template<typename T>
+    AssetDataFunctions* GetAssetDataFunctions()
+    {
+        auto control = []()
+            {
+                DataBlock<T>* block = Allocator::Allocate<DataBlock<T>>(1);
+
+                block->Control.UseCount = 0;
+                block->Control.ID = 0;
+                block->Control.State = AssetState::Processing;
+                block->Control.Functions = GetAssetDataFunctions<T>();
+
+                return &block->Control;
+            };
+
+        auto constructor = [](void* obj, void* other)
+            {
+                Allocator::Construct(static_cast<T*>(obj), std::move(*static_cast<T*>(other)));
+            };
+
+        auto mover = [](void* from, void* to)
+            {
+                *static_cast<T*>(to) = std::move(*static_cast<T*>(from));
+            };
+
+        auto deleter = [](void* p)
+            {
+                DataBlock<T>* block = static_cast<DataBlock<T>*>(p);
+
+                if (block->Control.State == AssetState::Loaded || block->Control.State == AssetState::Streaming)
+                    Allocator::Deconstruct(&block->Data);
+
+                Allocator::Deallocate(block, 1);
+            };
+
+        static AssetDataFunctions static_functions
+        {
+            control,
+            constructor,
+            mover,
+            deleter
+        };
+
+        return &static_functions;
+    }
+}