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

Compare commits

base: Chewico:0b1dcb5e55ad883c7b6b5af93a3fbc7a0ceadd6b
Branches Tags
Chewico:main
Chewico:dev
..
compare: Chewico:b72fb412a7136ebffd6a31cd0b8919b759cbe7d0
Branches Tags
Chewico:dev
Chewico:main

No commits in common. "0b1dcb5e55ad883c7b6b5af93a3fbc7a0ceadd6b" and "b72fb412a7136ebffd6a31cd0b8919b759cbe7d0" have entirely different histories.
0b1dcb5e55 ... b72fb412a7

14 changed files with 132 additions and 78 deletions
Show Stats Expand all files Collapse all files

6
Deer/Include/DeerCore/Serialization/WorldSettings.h
View File

@ -3,8 +3,8 @@
#ifdef DEER_RENDER
#include "DeerRender/Mesh.h"
#include "DeerRender/Resource.h"
#include "DeerRender/Shader.h"
#include "DeerRender/Resource.h"
#include "DeerRender/Tools/Memory.h"
#include <functional>
@ -16,8 +16,8 @@ namespace Deer {
bool includeServer = false;
bool includeClient = true;
std::function<Resource<GPUMesh>(ResourceId)> meshLoadingFunction = nullptr;
std::function<Resource<Shader>(ResourceId)> shaderLoadingFunction = nullptr;
std::function<Resource<GPUMesh>(StorageType)> meshLoadingFunction = nullptr;
std::function<Resource<Shader>(StorageType)> shaderLoadingFunction = nullptr;
#else
bool includeServer = true;
bool includeClient = false;

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

@ -11,23 +11,23 @@
namespace Deer {
template <typename T>
class ResourceManager;
typedef uint32_t ResourceId;
typedef uint32_t StorageType;
ResourceId generatePhyisicalStorageId();
ResourceId generateRuntimeStorageId();
StorageType generatePhyisicalStorageId();
StorageType generateRuntimeStorageId();
template <typename DataSource>
class StorageBackend {
public:
template <typename T>
static Scope<T> load(ResourceId storageId);
static Scope<T> load(StorageType storageId);
};
template <typename T>
class Resource {
public:
int32_t getResourceId() const { return resourceId; }
ResourceId getStorageId() const { return ResourceManager<T>::getStorageId(*this); }
StorageType getStorageId() const { return ResourceManager<T>::getStorageId(*this); }
bool isValid() const { return ResourceManager<T>::isValid(*this); }
T& getData() { return ResourceManager<T>::getResourceData(*this); }
@ -61,15 +61,15 @@ namespace Deer {
struct ResourceData {
public:
Scope<T> data = nullptr;
ResourceId storageId = 0;
StorageType storageId = 0;
};
static std::vector<ResourceData> resources;
static std::unordered_map<ResourceId, Resource<T>> resourceCache;
static std::unordered_map<StorageType, Resource<T>> resourceCache;
public:
template <typename DataSource>
static Resource<T> loadResource(ResourceId storageId) {
static Resource<T> loadResource(StorageType storageId) {
if (resourceCache.contains(storageId))
return resourceCache[storageId];
@ -91,14 +91,14 @@ namespace Deer {
return resource;
}
static Resource<T> getResource(ResourceId storageId) {
static Resource<T> getResource(StorageType storageId) {
if (resourceCache.contains(storageId))
return resourceCache[storageId];
return Resource<T>();
}
static Resource<T> loadResourceFromData(const typename ResourceBuilder<T>::BaseDataType& resourceData, ResourceId storageId) {
static Resource<T> loadResourceFromData(const typename ResourceBuilder<T>::BaseDataType& resourceData, StorageType storageId) {
if (resourceCache.contains(storageId))
return resourceCache[storageId];
@ -123,7 +123,7 @@ namespace Deer {
return res.resourceId >= 0 && res.resourceId < static_cast<int32_t>(resources.size());
}
static inline ResourceId getStorageId(Resource<T> res) {
static inline StorageType getStorageId(Resource<T> res) {
if (!isValid(res))
return 0;
@ -138,7 +138,7 @@ namespace Deer {
template <typename T>
std::vector<typename ResourceManager<T>::ResourceData> ResourceManager<T>::resources;
template <typename T>
std::unordered_map<ResourceId, Resource<T>> ResourceManager<T>::resourceCache;
std::unordered_map<StorageType, Resource<T>> ResourceManager<T>::resourceCache;
} // namespace Deer
// BUILTIN RESOURCE IDS

4
Deer/src/DeerRender/Core/ResourceIdGenerator.cpp → Deer/src/DeerRender/Core/StorageTypeGenerator.cpp
View File

@ -3,11 +3,11 @@
#include <random>
namespace Deer {
ResourceId generatePhyisicalStorageId() {
StorageType generatePhyisicalStorageId() {
return std::random_device{}() | 0x80000000;
}
ResourceId generateRuntimeStorageId() {
StorageType generateRuntimeStorageId() {
return std::random_device{}() & 0x7FFFFFF;
}
} // namespace Deer

4
Deer/src/DeerRender/Scripting/InternalAPI/Resources.cpp
View File

@ -29,10 +29,6 @@ namespace Deer {
return ResourceManager<FrameBuffer>::loadResourceFromData(spec, generateRuntimeStorageId());
}
void resource_defaultConstructor(void* mem) {
new (mem) ResourceId(0);
}
int frameBuffer_getWidth(Resource<FrameBuffer>& frameBuffer) {
return frameBuffer.getData().getSpecification().width;
}

11
Deer/src/DeerRender/Scripting/InternalAPI/Resources.h
View File

@ -13,6 +13,16 @@ namespace Deer {
class Shader;
namespace Scripting {
template <typename T>
std::string resource_getPath(Resource<T> resource) {
return ResourceManager<T>::getStorageId(resource);
}
template <typename T>
std::string resource_getName(Resource<T> resource) {
return ResourceManager<T>::getStorageId(resource).stem().string();
}
enum ResourceType : uint32_t {
NONE = 0,
MESH = 1,
@ -23,7 +33,6 @@ namespace Deer {
// GENERIC RESOURCE
template <typename T>
bool resource_isValid(Resource<T>& resource) { return resource.isValid(); }
void resource_defaultConstructor(void*);
// Frame Buffer
int frameBuffer_getWidth(Resource<FrameBuffer>&);

6
Deer/src/DeerRender/Scripting/ResourcesRegistry.cpp
View File

@ -25,7 +25,7 @@ namespace Deer {
} // namespace Scripting
void Scripting::registerResourceStructs() {
AS_CHECK(scriptEngine->RegisterObjectType("StorageId", sizeof(ResourceId), asOBJ_VALUE | asOBJ_POD | asGetTypeTraits<ResourceId>()));
AS_CHECK(scriptEngine->RegisterObjectType("StorageId", sizeof(StorageType), asOBJ_VALUE | asOBJ_POD | asOBJ_APP_CLASS_ALLINTS | asGetTypeTraits<StorageType>()));
AS_CHECK(scriptEngine->RegisterObjectType("GPUMesh", sizeof(Resource<GPUMesh>), asOBJ_VALUE | asOBJ_POD | asOBJ_APP_CLASS_ALLINTS | asGetTypeTraits<Resource<GPUMesh>>()));
AS_CHECK(scriptEngine->RegisterObjectType("Shader", sizeof(Resource<Shader>), asOBJ_VALUE | asOBJ_POD | asOBJ_APP_CLASS_ALLINTS | asGetTypeTraits<Resource<Shader>>()));
@ -36,10 +36,8 @@ namespace Deer {
Resource<FrameBuffer> createFrameBuffer(const std::string name, int sixeX, int sizeY);
void Scripting::registerResourceFunctions() {
REGISTER_EXT_OBJECT_CONSTRUCTOR(scriptEngine, "StorageId", "void f()", resource_defaultConstructor);
REGISTER_EXT_OBJECT_METHOD(scriptEngine, "FrameBuffer", "int get_width() const property", frameBuffer_getWidth);
REGISTER_EXT_OBJECT_METHOD(scriptEngine, "FrameBuffer", "int get_heighqt() const property", frameBuffer_getHeight);
REGISTER_EXT_OBJECT_METHOD(scriptEngine, "FrameBuffer", "int get_height() const property", frameBuffer_getHeight);
REGISTER_EXT_OBJECT_METHOD(scriptEngine, "FrameBuffer", "bool isValid()", frameBuffer_isValid);
REGISTER_EXT_OBJECT_METHOD(scriptEngine, "FrameBuffer", "void resize(int, int)", frameBuffer_resize);
REGISTER_EXT_OBJECT_METHOD(scriptEngine, "FrameBuffer", "void clearRGBA(int, int, int, int)", frameBuffer_clearRGBA);

14
Deer/src/DeerRender/Serialization/Components/MeshComponentSerialization.h
View File

@ -19,15 +19,21 @@ namespace Deer {
template <class Archive>
void load(Archive& archive) {
ResourceId storageId_mesh;
ResourceId storageId_shader;
StorageType storageId_mesh;
StorageType storageId_shader;
archive(cereal::make_nvp("IsActive", component.active));
archive(cereal::make_nvp("Mesh", storageId_mesh));
archive(cereal::make_nvp("Shader", storageId_shader));
component.mesh = settings.meshLoadingFunction(storageId_mesh);
component.shader = settings.shaderLoadingFunction(storageId_shader);
Scope<MeshData> meshData = settings.meshLoadingFunction(storageId_mesh);
Scope<ShaderData> shaderData = settings.shaderLoadingFunction(storageId_shader);
Resource<GPUMesh> mesh = ResourceManager<GPUMesh>::loadResourceFromData(*meshData.get(), storageId_mesh);
component.mesh = mesh;
Resource<Shader> shader = ResourceManager<Shader>::loadResourceFromData(*shaderData.get(), storageId_shader);
component.shader = shader;
}
};
} // namespace Deer

14
DeerStudio/headers/DeerStudio/StudioAPI.h
View File

@ -21,9 +21,15 @@ namespace Deer {
int32_t resourceFolder_getResourceCount(int32_t&);
int32_t resourceFolder_getResourceIdByIndex(int32_t&);
std::string resourceId_getName(ResourceId&);
std::string resourceId_getPath(ResourceId&);
int32_t resourceId_getFolder(ResourceId&);
ResourceType resourceId_getType(ResourceId&);
Resource<Texture>
getIcon(std::string&);
CScriptArray* getResourceFolders(std::string& path);
CScriptArray* getResourceFiles(std::string& path);
CScriptDictionary* getResourceMetadata(std::string& resource);
CScriptDictionary* setResourceMetadata(std::string& resource);
ResourceType getResourceType(std::string&);
} // namespace StudioAPI
} // namespace Deer

19
DeerStudio/headers/DeerStudio/StudioResources.h
View File

@ -3,6 +3,7 @@
#include "DeerRender/Tools/Path.h"
#include "cereal/cereal.hpp"
#include <string>
namespace Deer {
@ -40,33 +41,25 @@ namespace Deer {
}
};
struct FolderInfo {
std::string name;
std::string parent;
std::string fullPath;
std::vector<uint32_t> resources;
std::vector<std::string> subfolders;
};
namespace StudioResources {
ResourceInformation* getResourceInfoFromPath(const std::string& path);
ResourceInformation* getResourceInfoFromId(uint32_t resource);
FolderInfo* getFolderInfoFromPath(std::string folderStr);
void scanResources();
} // namespace StudioResources
template <>
class StorageBackend<EditorDataSource> {
public:
template <typename T>
static Scope<T> load(ResourceId storageId);
static Scope<T> load(StorageType storageId);
template <>
Scope<MeshData> load(ResourceId storageId);
Scope<MeshData> load(StorageType storageId);
template <>
Scope<ShaderData> load(ResourceId storageId);
Scope<ShaderData> load(StorageType storageId);
template <>
Scope<TextureData> load(ResourceId storageId);
Scope<TextureData> load(StorageType storageId);
};
} // namespace Deer

2
DeerStudio/src/DeerStudio/EditorDataImporter/MeshData.cpp
View File

@ -15,7 +15,7 @@ namespace Deer {
Scope<MeshData> convertAssimpMesh(const aiMesh* mesh);
template <>
Scope<MeshData> StorageBackend<EditorDataSource>::load(ResourceId storageId) {
Scope<MeshData> StorageBackend<EditorDataSource>::load(StorageType storageId) {
ResourceInformation* info = StudioResources::getResourceInfoFromId(storageId);
if (!info)
return Scope<MeshData>();

2
DeerStudio/src/DeerStudio/EditorDataImporter/ShaderData.cpp
View File

@ -32,7 +32,7 @@ namespace Deer {
}
template <>
Scope<ShaderData> StorageBackend<EditorDataSource>::load(ResourceId storageId) {
Scope<ShaderData> StorageBackend<EditorDataSource>::load(StorageType storageId) {
ResourceInformation* info = StudioResources::getResourceInfoFromId(storageId);
if (!info)
return Scope<ShaderData>();

2
DeerStudio/src/DeerStudio/EditorDataImporter/TextureData.cpp
View File

@ -8,7 +8,7 @@
namespace Deer {
template <>
Scope<TextureData> StorageBackend<EditorDataSource>::load(ResourceId storageId) {
Scope<TextureData> StorageBackend<EditorDataSource>::load(StorageType storageId) {
ResourceInformation* info = StudioResources::getResourceInfoFromId(storageId);
if (!info)
return Scope<TextureData>();

75
DeerStudio/src/DeerStudio/StudioAPI.cpp
View File

@ -10,20 +10,65 @@
#include "scriptdictionary.h"
namespace Deer {
int32_t StudioAPI::getResourceFolder(std::string& path) {
}
bool StudioAPI::resourceFolder_isValid(int32_t&);
bool StudioAPI::resourceFolder_isRoot(int32_t&);
std::string StudioAPI::resourceFolder_getName(int32_t&);
std::string StudioAPI::resourceFolder_getFullPath(int32_t&);
int32_t StudioAPI::resourceFolder_getParentFolder(int32_t&);
int32_t StudioAPI::resourceFolder_getSubFolderCount(int32_t&);
int32_t StudioAPI::resourceFolder_getSubfolderByIndex(int32_t, int32_t&);
int32_t StudioAPI::resourceFolder_getResourceCount(int32_t&);
int32_t StudioAPI::resourceFolder_getResourceIdByIndex(int32_t&);
ResourceType StudioAPI::getResourceType(std::string& dir) {
Path path(dir);
std::string extension = path.extension().string();
if (extension == ".obj" || extension == ".fbx" || extension == ".dae" ||
extension == ".3ds" || extension == ".ply" || extension == ".stl" ||
extension == ".glb" || extension == ".gltf") {
return ResourceType::MESH;
}
if (extension == ".glsl")
return ResourceType::SHADER;
if (extension == ".png")
return ResourceType::TEXTURE;
return ResourceType::NONE;
};
CScriptArray* StudioAPI::getResourceFolders(std::string& path_s) {
asITypeInfo* arrayString = Scripting::getScriptEngine()->GetTypeInfoByDecl("array<string>");
CScriptArray* array = CScriptArray::Create(arrayString);
Path path_p = Path("Resources") / Path(path_s).lexically_normal();
try {
for (const auto& entry : std::filesystem::directory_iterator(path_p)) {
if (entry.is_directory()) {
std::string s = entry.path().lexically_relative("Resources").string();
array->Resize(array->GetSize() + 1);
array->SetValue(array->GetSize() - 1, &s);
}
}
} catch (const std::exception& e) {
DEER_EDITOR_ENGINE_ERROR("Error in getResourceFolders(), {}", e.what());
}
return array;
}
CScriptArray* StudioAPI::getResourceFiles(std::string& path_s) {
asITypeInfo* arrayString = Scripting::getScriptEngine()->GetTypeInfoByDecl("array<string>");
CScriptArray* array = CScriptArray::Create(arrayString);
Path path_p = Path("Resources") / Path(path_s).lexically_normal();
try {
for (const auto& entry : std::filesystem::directory_iterator(path_p)) {
if (entry.is_regular_file()) {
std::string s = entry.path().lexically_relative("Resources").string();
array->Resize(array->GetSize() + 1);
array->SetValue(array->GetSize() - 1, &s);
}
}
} catch (const std::exception& e) {
DEER_EDITOR_ENGINE_ERROR("Error in getResourceFiles(), {}", e.what());
}
return array;
}
std::string StudioAPI::resourceId_getName(ResourceId&);
std::string StudioAPI::resourceId_getPath(ResourceId&);
int32_t StudioAPI::resourceId_getFolder(ResourceId&);
ResourceType StudioAPI::resourceId_getType(ResourceId&);
} // namespace Deer

23
DeerStudio/src/DeerStudio/StudioResources.cpp
View File

@ -45,6 +45,14 @@ namespace cereal {
} // namespace cereal
namespace Deer {
struct FolderInfo {
std::string name;
std::string parent;
std::string fullPath;
std::vector<uint32_t> resources;
std::vector<std::string> subfolders;
};
namespace StudioResources {
std::vector<ResourceInformation> resources;
std::unordered_map<std::string, size_t> resourcePathToIndex;
@ -54,7 +62,7 @@ namespace Deer {
std::unordered_map<std::string, size_t> folderPathToFolderIndex;
void registerResource(ResourceInformation& resource, size_t index);
FolderInfo& getCreateFolderInfo(std::string folderStr);
FolderInfo& getFolderInfo(std::string folderStr);
ResourceType getResourceType(const std::string& dir) {
Path path(dir);
@ -76,13 +84,6 @@ namespace Deer {
};
} // namespace StudioResources
FolderInfo* StudioResources::getFolderInfoFromPath(std::string path) {
if (!folderPathToFolderIndex.contains(path))
return nullptr;
return &folders[folderPathToFolderIndex[path]];
}
ResourceInformation* StudioResources::getResourceInfoFromPath(const std::string& path) {
if (!resourcePathToIndex.contains(path))
return nullptr;
@ -97,7 +98,7 @@ namespace Deer {
return &resources[resourceIdToIndex[resource]];
}
FolderInfo& getCreateFolderInfo(std::string folderStr) {
FolderInfo& StudioResources::getFolderInfo(std::string folderStr) {
FolderInfo* folderInfo;
if (folderPathToFolderIndex.contains(folderStr)) {
size_t folderIndex = folderPathToFolderIndex[folderStr];
@ -116,7 +117,7 @@ namespace Deer {
folderPathToFolderIndex[folderStr] = folders.size() - 1;
if (!folderStr.empty()) {
FolderInfo& parentPathInfo = getCreateFolderInfo(folderInfo->parent);
FolderInfo& parentPathInfo = getFolderInfo(folderInfo->parent);
parentPathInfo.subfolders.push_back(folderStr);
}
}
@ -134,7 +135,7 @@ namespace Deer {
resourceIdToIndex[resource.resourceId] = index;
resourcePathToIndex[resource.resourcePath] = index;
FolderInfo& folderInfo = getCreateFolderInfo(resource.folderPath);
FolderInfo& folderInfo = getFolderInfo(resource.folderPath);
folderInfo.resources.push_back(resource.resourceId);
}