MySchoolEngine · RohacekD · Feb 21, 2023 · Feb 21, 2023 · Feb 22, 2023 · Feb 27, 2023
diff --git a/.gitmodules b/.gitmodules
@@ -43,6 +43,9 @@
 [submodule "vendor/RTTR"]
 	path = vendor/RTTR
 	url = https://github.com/RohacekD/rttr
+[submodule "vendor/slot_map"]
+	path = vendor/slot_map
+	url = https://github.com/SergeyMakeev/slot_map
 [submodule "vendor/libpng"]
 	path = vendor/libpng
 	url = https://github.com/glennrp/libpng

diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -0,0 +1,20 @@
+
+# Change Log
+All notable changes to this project will be documented in this file.
+
+## [Unreleased] - 17-11-2024
+
+This version started long ago and aimed for more API agnostic approach to rendering. Aiming for rendering through handles and allow me to optimase the rendering in the future without writing API specific code.
+
+### Added
+
+- `GLEngine::Renderer::ResouceManager` to manage GPU resources.
+- `Utils::Reflection::MetaGUI::Texture` first example how to write GUI for `GLEngine::Core::ResourceHandle<T>`
+- `GLEngine::Core::Filesystem` for usual path used across engine for unification
+
+### Changed
+
+- `GLEngine::Renderer::C_Material` GUI now allows setting textures
+- `GLEngine::Editor::C_ImageEditor` works with handles
+- `GLEngine::Core::C_ResourceManager::s_UpdatesBeforeDelete` timeout to unload unused resources
+### Fixed
diff --git a/Core/Core.natvis b/Core/Core.natvis
@@ -36,4 +36,15 @@
       <Item Name="[Resource]" Condition="m_Resource._Ptr">*m_Resource._Ptr</Item>
     </Expand>
   </Type>
+
+  <Type Name="GLEngine::Core::ResourceHandle&lt;*&gt;">
+    <DisplayString Condition="m_Resource._Ptr">{*m_Resource._Ptr}</DisplayString>
+    <DisplayString Condition="!m_Resource._Ptr">invalid</DisplayString>
+    <Expand>
+      <Item Name="[resource]" Condition="m_Resource._Ptr">*(($T1*)m_Resource._Ptr)</Item>
+    </Expand>
+  </Type>
+  <Type Name="GLEngine::Core::Resource">
+    <DisplayString>{m_State,en}</DisplayString>
+  </Type>
 </AutoVisualizer>
diff --git a/Core/Core/EventSystem/Event.h b/Core/Core/EventSystem/Event.h
@@ -60,15 +60,15 @@ enum class E_EventCategory
 
 
 #define EVENT_CLASS_CATEGORY(category)                                                                                                                                             \
-	virtual Utils::C_BitField<E_EventCategory> GetCategories() const override { return category; }
+	virtual ::Utils::C_BitField<E_EventCategory> GetCategories() const override { return category; }
 
 //=================================================================================
 class CORE_API_EXPORT I_Event {
 public:
 	virtual ~I_Event();
-	virtual E_EventType						   GetType() const		 = 0;
-	virtual Utils::C_BitField<E_EventCategory> GetCategories() const = 0;
-	virtual const char*						   GetName() const		 = 0;
+	virtual E_EventType							 GetType() const	   = 0;
+	virtual ::Utils::C_BitField<E_EventCategory> GetCategories() const = 0;
+	virtual const char*							 GetName() const	   = 0;
 
 	inline bool IsInCategory(E_EventCategory category) const { return GetCategories() & category; }
 
@@ -82,7 +82,7 @@ class CORE_API_EXPORT C_UserEvent : public I_Event {
 	virtual ~C_UserEvent();
 
 	virtual E_EventType						   GetType() const override;
-	virtual Utils::C_BitField<E_EventCategory> GetCategories() const override;
+	virtual ::Utils::C_BitField<E_EventCategory> GetCategories() const override;
 	virtual const char*						   GetName() const override;
 
 private:

diff --git a/Core/Core/EventSystem/Event/InputEvents.h b/Core/Core/EventSystem/Event/InputEvents.h
@@ -12,7 +12,7 @@ namespace Core {
 // Input event is window dependent
 class C_InputEvent : public I_Event {
 public:
-	virtual Utils::C_BitField<E_EventCategory> GetCategories() const override { return GetInputCategory() | E_EventCategory::Input; }
+	virtual ::Utils::C_BitField<E_EventCategory> GetCategories() const override { return GetInputCategory() | E_EventCategory::Input; }
 
 	// window which trigged this event
 	inline GUID GetWindowGUID() const { return m_WindowID; };
@@ -23,7 +23,7 @@ class C_InputEvent : public I_Event {
 	{
 	}
 
-	virtual Utils::C_BitField<E_EventCategory> GetInputCategory() const = 0;
+	virtual ::Utils::C_BitField<E_EventCategory> GetInputCategory() const = 0;
 
 private:
 	GUID m_WindowID;

diff --git a/Core/Core/EventSystem/Event/KeyboardEvents.h b/Core/Core/EventSystem/Event/KeyboardEvents.h
@@ -13,19 +13,19 @@ class C_KeyEvent : public C_InputEvent {
 public:
 	inline int GetKeyCode() const { return m_KeyCode; }
 
-	virtual Utils::C_BitField<E_KeyModifiers> GetModifiers() const { return m_Modifiers; }
+	virtual ::Utils::C_BitField<E_KeyModifiers> GetModifiers() const { return m_Modifiers; }
 
 protected:
-	C_KeyEvent(int keyCode, GUID window, Utils::C_BitField<E_KeyModifiers> modifiers)
+	C_KeyEvent(int keyCode, GUID window, ::Utils::C_BitField<E_KeyModifiers> modifiers)
 		: C_InputEvent(window)
 		, m_KeyCode(keyCode)
 		, m_Modifiers(modifiers)
 	{
 	}
-	int								  m_KeyCode;
-	Utils::C_BitField<E_KeyModifiers> m_Modifiers;
+	int									m_KeyCode;
+	::Utils::C_BitField<E_KeyModifiers> m_Modifiers;
 
-	virtual Utils::C_BitField<E_EventCategory> GetInputCategory() const override { return E_EventCategory::Keyboard; }
+	virtual ::Utils::C_BitField<E_EventCategory> GetInputCategory() const override { return E_EventCategory::Keyboard; }
 };
 
 //=================================================================================
@@ -81,6 +81,6 @@ class C_TextInputEvent : public C_InputEvent {
 protected:
 	unsigned int m_Codepoint;
 
-	virtual Utils::C_BitField<E_EventCategory> GetInputCategory() const override { return E_EventCategory::Keyboard; }
+	virtual ::Utils::C_BitField<E_EventCategory> GetInputCategory() const override { return E_EventCategory::Keyboard; }
 };
 } // namespace GLEngine::Core
diff --git a/Core/Core/EventSystem/Event/ResourceEvents.h b/Core/Core/EventSystem/Event/ResourceEvents.h
@@ -17,7 +17,7 @@ class BaseResourceEvent : public I_Event {
 	~BaseResourceEvent() = default;
 
 
-	Utils::C_BitField<E_EventCategory> GetCategories() const override { return {E_EventCategory::Resource}; }
+	::Utils::C_BitField<E_EventCategory> GetCategories() const override { return {E_EventCategory::Resource}; }
 
 protected:
 	ResourceHandleBase m_Handle;

diff --git a/Core/Core/Filesystem/Paths.h b/Core/Core/Filesystem/Paths.h
@@ -0,0 +1,6 @@
+#pragma once
+
+namespace GLEngine::Core::Filesystem {
+inline const static std::filesystem::path entityFile = ".ent";
+inline const static std::filesystem::path entityFolder = "./Entities";
+}
diff --git a/Core/Core/Resources/Metafile.cpp b/Core/Core/Resources/Metafile.cpp
@@ -1,6 +1,7 @@
 #include <CoreStdafx.h>
 
 #include <Core/Resources/Metafile.h>
+#include <Core/Resources/ResourceManager.h>
 
 #include <Utils/Serialization/XMLDeserialize.h>
 #include <Utils/Serialization/XMLSerialize.h>
@@ -39,7 +40,7 @@ bool C_Metafile::Load()
 		return false;
 	}
 
-	Utils::C_XMLDeserializer d;
+	Utils::C_XMLDeserializer d(Core::C_ResourceManager::Instance());
 	auto					 newThis = d.Deserialize<C_Metafile>(doc);
 	if (newThis.has_value() == false)
 	{

diff --git a/Core/Core/Resources/Resource.cpp b/Core/Core/Resources/Resource.cpp
@@ -2,6 +2,18 @@
 
 #include <Core/Resources/Resource.h>
 
+#include <rttr/registration>
+
+RTTR_REGISTRATION
+{
+	using namespace GLEngine::Core;
+
+	rttr::registration::class_<Resource>("Resource").property("FilePath", &Resource::m_Filepath);
+
+
+	rttr::type::register_wrapper_converter_for_base_classes<std::shared_ptr<Resource>>();
+}
+
 namespace GLEngine::Core {
 
 //=================================================================================

diff --git a/Core/Core/Resources/Resource.h b/Core/Core/Resources/Resource.h
@@ -3,9 +3,28 @@
 #include <Core/CoreApi.h>
 #include <Core/EventSystem/EventReciever.h>
 
-namespace GLEngine::Core {
+#include <rttr/registration_friend.h>
 
 #define DECLARE_RESOURCE_TYPE(resourceType)                                                                                                                                        \
+	RTTR_REGISTRATION                                                                                                                                                              \
+	{                                                                                                                                                                              \
+		using namespace GLEngine::Core;                                                                                                                                            \
+		rttr::registration::class_<ResourceHandle<resourceType>>((resourceType::GetResrourceTypeName() + "Handle").c_str())                                                        \
+			.constructor<>()(rttr::policy::ctor::as_object)                                                                                                                        \
+			.method("AfterDeserialize", &ResourceHandle<resourceType>::AfterDeserialize)();                                                                                        \
+                                                                                                                                                                                   \
+		rttr::registration::class_<resourceType>(#resourceType).constructor<>()(rttr::policy::ctor::as_std_shared_ptr);                                                            \
+                                                                                                                                                                                   \
+		rttr::type::register_wrapper_converter_for_base_classes<std::shared_ptr<resourceType>>();                                                                                  \
+		rttr::type::register_converter_func([](std::shared_ptr<resourceType> ptr, bool& ok) -> std::shared_ptr<Resource> {                                                         \
+			ok = true;                                                                                                                                                             \
+			return std::static_pointer_cast<Resource>(ptr);                                                                                                                        \
+		});                                                                                                                                                                        \
+	}
+
+namespace GLEngine::Core {
+
+#define DEFINE_RESOURCE_TYPE(resourceType)                                                                                                                                         \
 public:                                                                                                                                                                            \
 	static std::size_t GetResourceTypeHash()                                                                                                                                       \
 	{                                                                                                                                                                              \
@@ -16,7 +35,9 @@ public:
 	{                                                                                                                                                                              \
 		static std::string name(#resourceType);                                                                                                                                    \
 		return name;                                                                                                                                                               \
-	}
+	}                                                                                                                                                                              \
+	RTTR_ENABLE(Core::Resource)                                                                                                                                                    \
+public:
 
 
 enum class ResourceState : std::uint8_t
@@ -49,18 +70,21 @@ template <class T, class TBaseRes> concept IsBuildableResource = requires(T t, T
 
 template <typename T> concept BuildableResource = requires(T t)
 {
-	IsBeDerivedResource<T> && IsBuildableResource<T, typename T::T_BaseResource>;
+	IsBeDerivedResource<T>&& IsBuildableResource<T, typename T::T_BaseResource>;
 };
 
+class I_ResourceLoader;
+
 // derived resources should take base resource as only constructor argument
 class CORE_API_EXPORT Resource : public I_EventReciever {
 public:
 	Resource();
 	virtual ~Resource();
 
-	[[nodiscard]] virtual bool Load(const std::filesystem::path& filepath) = 0;
-	[[nodiscard]] virtual bool Reload()									   = 0;
-	[[nodiscard]] bool		   Save() const
+	[[nodiscard]] virtual std::unique_ptr<I_ResourceLoader> GetLoader()									= 0;
+	[[nodiscard]] virtual bool								Load(const std::filesystem::path& filepath) = 0;
+	[[nodiscard]] virtual bool								Reload()									= 0;
+	[[nodiscard]] bool										Save() const
 	{
 		if (!m_Dirty)
 			return true;
@@ -77,15 +101,19 @@ class CORE_API_EXPORT Resource : public I_EventReciever {
 
 	const std::filesystem::path& GetFilePath() const;
 
+	RTTR_ENABLE()
 protected:
+	std::filesystem::path m_Filepath;
+
 	virtual bool SaveInternal() const { return false; }
 
-	bool				  m_Dirty = false;
-	std::filesystem::path m_Filepath;
+	bool m_Dirty = false;
 
 private:
 	ResourceState m_State = ResourceState::Empty;
 	friend class C_ResourceManager;
+
+	RTTR_REGISTRATION_FRIEND
 };
 
 template <class ResourceType> concept is_resource = std::is_base_of_v<Resource, ResourceType>;

diff --git a/Core/Core/Resources/ResourceHandle.cpp b/Core/Core/Resources/ResourceHandle.cpp
@@ -3,6 +3,20 @@
 #include <Core/Resources/ResourceHandle.h>
 #include <Core/Resources/ResourceManager.h>
 
+#include <Utils/Reflection/Metadata.h>
+
+#include <rttr/registration>
+
+RTTR_REGISTRATION
+{
+	using namespace GLEngine::Core;
+	using namespace Utils::Reflection;
+
+	rttr::registration::class_<ResourceHandleBase>("ResourceHandleBase")
+		.constructor<std::shared_ptr<Resource>>()()
+		.constructor<>()()
+		.property("Resource", &ResourceHandleBase::m_Resource);
+}
 
 namespace GLEngine::Core {
 
@@ -29,7 +43,8 @@ ResourceState ResourceHandleBase::GetState() const
 //=================================================================================
 ResourceHandleBase::~ResourceHandleBase()
 {
-	if (m_Resource.use_count() == 2) {
+	if (m_Resource.use_count() == 2)
+	{
 		C_ResourceManager::Instance().AddResourceToUnusedList(m_Resource);
 	}
 }
@@ -52,4 +67,11 @@ bool ResourceHandleBase::IsFailed() const
 	return GetState() == ResourceState::Failed;
 }
 
+//=================================================================================
+const std::filesystem::path& ResourceHandleBase::GetFilePath() const
+{
+	if (m_Resource)
+		return m_Resource->GetFilePath();
+	return "";
 }
+} // namespace GLEngine::Core
diff --git a/Core/Core/Resources/ResourceHandle.h b/Core/Core/Resources/ResourceHandle.h
@@ -3,6 +3,10 @@
 #include <Core/CoreApi.h>
 #include <Core/Resources/Resource.h>
 
+#include <Utils/Serialization/XMLDeserialize.h>
+
+#include <rttr/registration_friend.h>
+
 namespace GLEngine::Core {
 class CORE_API_EXPORT ResourceHandleBase {
 public:
@@ -16,13 +20,17 @@ class CORE_API_EXPORT ResourceHandleBase {
 
 	explicit operator bool() const { return IsReady(); }
 
+	const std::filesystem::path& GetFilePath() const;
+
+	RTTR_ENABLE();
+
 protected:
 	std::shared_ptr<Resource> m_Resource; // nullptr only when no loader exists
+	RTTR_REGISTRATION_FRIEND;
 };
 
 // this forces include of ResourceType definition into headers, can I move it somewhere else?
-template <class ResourceType> requires(is_resource<ResourceType>)
-class ResourceHandle : public ResourceHandleBase {
+template <class ResourceType> requires(is_resource<ResourceType>) class ResourceHandle : public ResourceHandleBase {
 public:
 	ResourceHandle() = default;
 	ResourceHandle(std::shared_ptr<ResourceType> resource)
@@ -34,6 +42,19 @@ class ResourceHandle : public ResourceHandleBase {
 	ResourceType&		GetResource();
 
 	const std::filesystem::path& GetFilepath() const;
+
+	void AfterDeserialize(GLEngine::Utils::C_XMLDeserializer::DeserializeCtx& ctx);
+
+	RTTR_ENABLE(ResourceHandleBase);
+};
+
+// for usage in maps
+template <is_resource ResourceType>
+struct ResourceHandleCmp {
+	bool operator()(const ResourceHandle<ResourceType>& lhs, const ResourceHandle<ResourceType>& rhs) const
+	{
+		return lhs.GetFilepath() < rhs.GetFilepath();
+	}
 };
 
 } // namespace GLEngine::Core

diff --git a/Core/Core/Resources/ResourceHandle.inl b/Core/Core/Resources/ResourceHandle.inl
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <Core/Resources/ResourceManager.h>
+
 namespace GLEngine::Core {
 
 //=================================================================================
@@ -25,4 +27,11 @@ const std::filesystem::path& ResourceHandle<ResourceType>::GetFilepath() const
 	GLE_ASSERT(m_Resource, "Uninitalized resource");
 	return m_Resource->GetFilePath();
 }
+
+//=================================================================================
+template <class ResourceType> requires(is_resource<ResourceType>) void ResourceHandle<ResourceType>::AfterDeserialize(GLEngine::Utils::C_XMLDeserializer::DeserializeCtx& ctx)
+{
+	auto& rm = C_ResourceManager::Instance();
+	*this	 = rm.LoadResource<ResourceType>(GetFilePath());
+}
 } // namespace GLEngine::Core