Created Environment as a Resource

Deer/Include/Deer/Enviroment.h

@@ -2,6 +2,7 @@
 #include "Deer/Components.h"
 #include "Deer/Log.h"
 #include "Deer/Tools/Memory.h"
+#include "Deer/Resource.h"
 
 #include "entt/entt.hpp"
 
@@ -75,6 +76,21 @@ namespace Deer {
 		friend class Entity;
 	};
 
+	struct EntityData {
+		int toDo;
+	};
+
+	struct EnvironmentData {
+		std::vector<EntityData> entities;
+	};
+
+	template <>
+	class ResourceBuilder<Environment> {
+	  public:
+		using BaseDataType = EnvironmentData;
+		static Scope<Environment> buildResource(const BaseDataType& baseData);
+	};
+
 	// Warning: This calss does not initialize for performance
 	class Entity {
 	  public:

Deer/Include/Deer/Resource.h

@@ -0,0 +1,130 @@
+#pragma once
+#include "Deer/DataManagment.h"
+#include "Deer/Log.h"
+#include "Deer/Tools/Memory.h"
+#include "Deer/Tools/Path.h"
+#include "Deer/Tools/TypeDefs.h"
+
+#include <cxxabi.h>
+#include <unordered_map>
+#include <vector>
+
+namespace Deer {
+	template <typename T>
+	class ResourceManager;
+
+	template <typename T>
+	class Resource {
+	  public:
+		int32_t getResourceId() const { return resourceId; }
+
+		bool isValid() const { return ResourceManager<T>::isValid(*this); }
+		T& getData() { return ResourceManager<T>::getResourceData(*this); }
+
+		const std::string& getStorageId() const { return ResourceManager<T>::getStorageId(); }
+
+		inline explicit operator bool() const { return resourceId >= 0; }
+
+		static Resource<T> unsafeFromId(int32_t id) {
+			Resource<T> res;
+			res.resourceId = id;
+			return res;
+		}
+
+	  private:
+		// -1 = no resource loaded
+		int32_t resourceId = -1;
+		friend ResourceManager<T>;
+	};
+
+	template <typename T>
+	class ResourceBuilder {
+	  public:
+		using BaseDataType = char;
+		static Scope<T> buildResource(const BaseDataType& baseData) {
+			static_assert(sizeof(T) == 0, "ResourceBuilder must be specialized for this type T");
+			return nullptr;
+		}
+	};
+
+	template <typename T>
+	class ResourceManager {
+	  private:
+		struct ResourceData {
+		  public:
+			ResourceData(const std::string& _resourceId, Scope<T>&& _data)
+			    : storageId(_resourceId), data(std::move(_data)) {}
+
+			Scope<T> data;
+			const std::string storageId;
+		};
+
+		static std::vector<ResourceData> resources;
+		static std::unordered_map<std::string, Resource<T>> resourceCache;
+
+	  public:
+		template <typename DataSource>
+		static Resource<T> loadResource(const std::string& storageId) {
+			if (resourceCache.contains(storageId))
+				return resourceCache[storageId];
+
+			using ResourceBuilderBaseDataType = typename ResourceBuilder<T>::BaseDataType;
+			Scope<T> data;
+
+			if constexpr (!std::is_void_v<ResourceBuilderBaseDataType>) {
+				Scope<ResourceBuilderBaseDataType> baseData = DataManager<DataSource>::template load<ResourceBuilderBaseDataType>(storageId);
+				if (!baseData) {
+					const char* baseDataType = abi::__cxa_demangle(typeid(ResourceBuilderBaseDataType).name(), 0, 0, nullptr);
+					const char* dataType = abi::__cxa_demangle(typeid(T).name(), 0, 0, nullptr);
+					DEER_CORE_ERROR("Error loading base resource {} for resource {} with id {}", baseDataType, dataType, storageId.c_str());
+					return Resource<T>();
+				}
+				data = ResourceBuilder<T>::buildResource(*baseData.get());
+			} else {
+				data = ResourceBuilder<T>::buildResource(); // No base data
+			}
+
+			Resource<T> resource = Resource<T>::unsafeFromId(resources.size());
+			resources.push_back({storageId, std::move(data)});
+			resourceCache[storageId] = resource;
+
+			return resource;
+		}
+
+		static Resource<T> loadResourceFromData(const typename ResourceBuilder<T>::BaseDataType& resourceData, const std::string& storageId) {
+			Scope<T> data = ResourceBuilder<T>::buildResource(resourceData);
+
+			Resource<T> resource = Resource<T>::unsafeFromId(resources.size());
+			resources.push_back({storageId, std::move(data)});
+			resourceCache[storageId] = resource;
+
+			return resource;
+		}
+
+		static void unloadResources() {
+			resourceCache.clear();
+			resources.clear();
+		}
+
+		static inline bool isValid(Resource<T> res) {
+			return res.resourceId >= 0 && res.resourceId < static_cast<int32_t>(resources.size());
+		}
+
+		static inline const std::string& getStorageId(Resource<T> res) {
+			const static std::string invalid("NULL");
+			if (!isValid(res))
+				return invalid;
+
+			return resources[res.resourceId].storageId;
+		}
+
+		static T& getResourceData(Resource<T> res) {
+			return *resources[res.resourceId].data;
+		}
+	};
+
+	template <typename T>
+	std::vector<typename ResourceManager<T>::ResourceData> ResourceManager<T>::resources;
+	template <typename T>
+	std::unordered_map<std::string, Resource<T>> ResourceManager<T>::resourceCache;
+} // namespace Deer

Deer/Include/DeerRender/DataManager.h

@@ -1,2 +0,0 @@
-#pragma once
-#include "Deer/DataManager.h"

Deer/Include/DeerRender/Resource.h

@@ -1,120 +1,2 @@
 #pragma once
-#include "DeerRender/DataManagment.h"
+#include "Deer/Resource.h"
-#include "DeerRender/Log.h"
-#include "DeerRender/Tools/Memory.h"
-#include "DeerRender/Tools/Path.h"
-#include "DeerRender/Tools/TypeDefs.h"
-
-#include <cxxabi.h>
-#include <unordered_map>
-#include <vector>
-
-namespace Deer {
-	template <typename T>
-	class ResourceManager;
-
-	template <typename T>
-	class Resource {
-	  public:
-		int32_t getResourceId() const { return resourceId; }
-
-		bool isValid() const { return ResourceManager<T>::isValid(*this); }
-		T& getData() { return ResourceManager<T>::getResourceData(*this); }
-
-		const std::string& getStorageId() const { return ResourceManager<T>::getStorageId(); }
-
-		inline explicit operator bool() const { return resourceId >= 0; }
-
-		static Resource<T> unsafeFromId(int32_t id) {
-			Resource<T> res;
-			res.resourceId = id;
-			return res;
-		}
-
-	  private:
-		// -1 = no resource loaded
-		int32_t resourceId = -1;
-		friend ResourceManager<T>;
-	};
-
-	template <typename T>
-	class ResourceBuilder {
-	  public:
-		using BaseDataType = char;
-		static Scope<T> buildResource(const BaseDataType& baseData) {
-			static_assert(sizeof(T) == 0, "ResourceBuilder must be specialized for this type T");
-			return nullptr;
-		}
-	};
-
-	template <typename T>
-	class ResourceManager {
-	  private:
-		struct ResourceData {
-		  public:
-			ResourceData(const std::string& _resourceId, Scope<T>&& _data)
-			    : storageId(_resourceId), data(std::move(_data)) {}
-
-			Scope<T> data;
-			const std::string storageId;
-		};
-
-		static std::vector<ResourceData> resources;
-		static std::unordered_map<std::string, Resource<T>> resourceCache;
-
-	  public:
-		template <typename DataSource>
-		static Resource<T> loadResource(const std::string& storageId) {
-			if (resourceCache.contains(storageId))
-				return resourceCache[storageId];
-
-			using ResourceBuilderBaseDataType = typename ResourceBuilder<T>::BaseDataType;
-			Scope<T> data;
-
-			if constexpr (!std::is_void_v<ResourceBuilderBaseDataType>) {
-				Scope<ResourceBuilderBaseDataType> baseData = DataManager<DataSource>::template load<ResourceBuilderBaseDataType>(storageId);
-				if (!baseData) {
-					const char* baseDataType = abi::__cxa_demangle(typeid(ResourceBuilderBaseDataType).name(), 0, 0, nullptr);
-					const char* dataType = abi::__cxa_demangle(typeid(T).name(), 0, 0, nullptr);
-					DEER_CORE_ERROR("Error loading base resource {} for resource {} with id {}", baseDataType, dataType, storageId.c_str());
-					return Resource<T>();
-				}
-				data = ResourceBuilder<T>::buildResource(*baseData.get());
-			} else {
-				data = ResourceBuilder<T>::buildResource(); // No base data
-			}
-
-			Resource<T> resource = Resource<T>::unsafeFromId(resources.size());
-			resources.push_back({storageId, std::move(data)});
-			resourceCache[storageId] = resource;
-
-			return resource;
-		}
-
-		static void unloadResources() {
-			resourceCache.clear();
-			resources.clear();
-		}
-
-		static inline bool isValid(Resource<T> res) {
-			return res.resourceId >= 0 && res.resourceId < static_cast<int32_t>(resources.size());
-		}
-
-		static inline const std::string& getStorageId(Resource<T> res) {
-			const static std::string invalid("NULL");
-			if (!isValid(res))
-				return invalid;
-
-			return resources[res.resourceId].storageId;
-		}
-
-		static T& getResourceData(Resource<T> res) {
-			return *resources[res.resourceId].data;
-		}
-	};
-
-	template <typename T>
-	std::vector<typename ResourceManager<T>::ResourceData> ResourceManager<T>::resources;
-	template <typename T>
-	std::unordered_map<std::string, Resource<T>> ResourceManager<T>::resourceCache;
-} // namespace Deer

Deer/src/Deer/Scene/EnvironmentBuilder.cpp

@@ -0,0 +1,8 @@
+#include "Deer/Enviroment.h"
+
+namespace Deer {
+    Scope<Environment> ResourceBuilder<Environment>::buildResource(const BaseDataType& baseData) {
+        Scope<Environment> env = MakeScope<Environment>();
+        return env;
+    }
+}

DeerStudio/headers/DeerStudio/StudioAPI/Environment.h

@@ -1,5 +1,6 @@
 #pragma once
 #include "GenericRefStructs.h"
+#include <string>
 // #include "DeerRender/Scene.h"
 
 namespace Deer {
@@ -14,6 +15,6 @@ namespace Deer {
 		};
 
 		EnvironmentHandleStruct getMainEnvironment();
-		EnvironmentHandleStruct createEnvironment();
+		EnvironmentHandleStruct createLoadEnvironment(std::string& envId);
 	} // namespace StudioAPI
 } // namespace Deer

DeerStudio/src/DeerStudio/AngelScriptEngine/Registers/Environment.cpp

@@ -12,7 +12,7 @@ namespace Deer {
 	void AngelScriptEngine::registerEnvironmentFunctions() {
 		scriptEngine->SetDefaultNamespace("Engine");
 		REGISTER_GLOBAL_FUNC("Environment getMainEnvironment()", StudioAPI::getMainEnvironment);
-		REGISTER_GLOBAL_FUNC("Environment createEnvironment()", StudioAPI::createEnvironment);
+		REGISTER_GLOBAL_FUNC("Environment createLoadEnvironment(const string&in envId)", StudioAPI::createLoadEnvironment);
 		scriptEngine->SetDefaultNamespace("");
 
 		REGISTER_OBJECT_METHOD("Environment", "void render(FrameBuffer, SceneCamera&in)", StudioAPI::EnvironmentStruct, render);

DeerStudio/src/DeerStudio/StudioAPI/Environment.cpp

@@ -1,6 +1,7 @@
 #include "DeerRender/Enviroment.h"
 #include "DeerRender/Scene.h"
 #include "DeerRender/Tools/Memory.h"
+#include "DeerRender/Resource.h"
 
 #include "DeerStudio/StudioAPI/Environment.h"
 
@@ -38,11 +39,12 @@ namespace Deer {
 			return EnvironmentHandleStruct(-1);
 		}
 
-		EnvironmentHandleStruct createEnvironment() {
+		EnvironmentHandleStruct createLoadEnvironment(std::string& envId) {
-			uint16_t envId = environments.size();
+			EnvironmentData envData;
-			environments.push_back({});
+			Resource<Environment> environmentResource = ResourceManager<Environment>::loadResourceFromData(envData, envId);
+
+			return EnvironmentHandleStruct(environmentResource.getResourceId());
 
-			return EnvironmentHandleStruct(envId);
 		}
 	} // namespace StudioAPI
 } // namespace Deer

Editor/Modules/Viewport.disabled/dockPanelModule.json

@@ -1,8 +0,0 @@
-{
-    "dockPanelModule" : {
-        "name" : "Viewport",
-        "author" : "Chewico",
-        "version" : "1.0.0",
-        "services" : []
-    }
-}