Chewico/DeerEngine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Created Environment as a Resource

Browse Source
This commit is contained in:
Chewico 2025-12-04 23:41:43 +01:00
parent 23989d5cf7
commit ded41e7c3e
11 changed files with 164 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
Deer/Include/Deer/Enviroment.h
View File

@ -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:

130
Deer/Include/Deer/Resource.h Normal file
View File

@ -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

2
Deer/Include/DeerRender/DataManager.h
View File

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

120
Deer/Include/DeerRender/Resource.h
View File

@ -1,120 +1,2 @@
#pragma once
#include "DeerRender/DataManagment.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
#include "Deer/Resource.h"

8
Deer/src/Deer/Scene/EnvironmentBuilder.cpp Normal file
View File

@ -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;
}
}

3
DeerStudio/headers/DeerStudio/StudioAPI/Environment.h
View File

@ -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

2
DeerStudio/src/DeerStudio/AngelScriptEngine/Registers/Environment.cpp
View File

@ -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);

10
DeerStudio/src/DeerStudio/StudioAPI/Environment.cpp
View File

@ -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() {
uint16_t envId = environments.size();
environments.push_back({});
EnvironmentHandleStruct createLoadEnvironment(std::string& envId) {
EnvironmentData envData;
Resource<Environment> environmentResource = ResourceManager<Environment>::loadResourceFromData(envData, envId);
return EnvironmentHandleStruct(environmentResource.getResourceId());
return EnvironmentHandleStruct(envId);
}
} // namespace StudioAPI
} // namespace Deer

8
Editor/Modules/Viewport.disabled/dockPanelModule.json
View File

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

0
Editor/Modules/Viewport.disabled/Viewport.as → Editor/Modules/Viewport/Viewport.as
View File

0
Editor/Modules/Viewport.disabled/as.predefined → Editor/Modules/Viewport/as.predefined
View File