From f8ddb91c8a2716fb6f901afd5ced81cb266b3556 Mon Sep 17 00:00:00 2001 From: Lendemor Date: Wed, 30 May 2018 00:39:15 +0200 Subject: [PATCH] migrate resourcepack to use with cereal + small fix for config serialization --- src/editor.cpp | 4 +- src/editor.h | 4 +- src/scene/scenenode.h | 9 ++ src/test/main.cpp | 29 +++-- src/tools/loadingthread.cpp | 31 +++-- src/tools/loadingthread.h | 6 +- src/tools/newresourcepack.cpp | 218 ++++++++++++++++++++++++++++++++++ src/tools/newresourcepack.h | 139 ++++++++++++++++++++++ src/tools/resourcepack.cpp | 28 +++-- src/tools/resourcepack.h | 18 +-- 10 files changed, 433 insertions(+), 53 deletions(-) create mode 100644 src/tools/newresourcepack.cpp create mode 100644 src/tools/newresourcepack.h diff --git a/src/editor.cpp b/src/editor.cpp index ebafbb0..1589fa2 100644 --- a/src/editor.cpp +++ b/src/editor.cpp @@ -3,7 +3,7 @@ #include "engine.h" #include "tools/scenepicker.h" #include "scene/scenetree.h" -#include "tools/resourcepack.h" +#include "tools/newresourcepack.h" #include "editor/objecteditor.h" #include "sparrowshell/sparrowshell.h" @@ -185,7 +185,7 @@ void Editor::toggleRenderingPipelineGui() void Editor::toggleResourcePackGui() { if(m_editedResourcePack == nullptr) - m_editedResourcePack = new ResourcePack(); + m_editedResourcePack = new NewResourcePack(); else { delete m_editedResourcePack; diff --git a/src/editor.h b/src/editor.h index 8155968..24099bf 100644 --- a/src/editor.h +++ b/src/editor.h @@ -5,7 +5,7 @@ class Engine; class ScenePicker; -class ResourcePack; +class NewResourcePack; class ObjectEditor; class Mesh; @@ -13,7 +13,7 @@ class Editor : public SceneNode { ScenePicker* m_pickerNode; Mesh* m_selectedMesh; - ResourcePack* m_editedResourcePack; + NewResourcePack* m_editedResourcePack; ObjectEditor* m_objectEditor; bool m_materialEditorEnabled; bool m_editorEnabled; diff --git a/src/scene/scenenode.h b/src/scene/scenenode.h index 5ebe9af..c99f174 100644 --- a/src/scene/scenenode.h +++ b/src/scene/scenenode.h @@ -5,6 +5,8 @@ #include "LinearMath/btMotionState.h" #include +#include + class SceneTree; class Transform; class Engine; @@ -159,6 +161,13 @@ public: /// the scene node clones itself, with no parent virtual SceneNode* clone(); + //serialization methods + template + void serialize(Archive & archive) + { + archive(m_transform); + } + // global engine methods Engine& getEngine(); }; diff --git a/src/test/main.cpp b/src/test/main.cpp index 48660fa..225c395 100644 --- a/src/test/main.cpp +++ b/src/test/main.cpp @@ -173,17 +173,16 @@ struct Config void save() { - std::fstream configFile; - configFile.open("config.ini", std::ios_base::out); +// std::fstream configFile; +// configFile.open("config.ini", std::ios_base::out); + std::ofstream configFile("config.ini"); cereal::JSONOutputArchive output(configFile); - output(cereal::make_nvp("mode", mode)); - output(cereal::make_nvp("scene", scene)); - output(cereal::make_nvp("vsync", vsync)); - output(cereal::make_nvp("width", width)); - output(cereal::make_nvp("height", height)); - output.finishNode(); - configFile << std::endl; - configFile.close(); + + output(cereal::make_nvp("mode", mode), + cereal::make_nvp("scene", scene), + cereal::make_nvp("vsync", vsync), + cereal::make_nvp("width", width), + cereal::make_nvp("height", height)); } void load() @@ -195,11 +194,11 @@ struct Config try { cereal::JSONInputArchive input(configFile); - input(cereal::make_nvp("mode", mode)); - input(cereal::make_nvp("scene", scene)); - input(cereal::make_nvp("vsync", vsync)); - input(cereal::make_nvp("width", width)); - input(cereal::make_nvp("height", height)); + input(cereal::make_nvp("mode", mode), + cereal::make_nvp("scene", scene), + cereal::make_nvp("vsync", vsync), + cereal::make_nvp("width", width), + cereal::make_nvp("height", height)); } catch(cereal::Exception e) { diff --git a/src/tools/loadingthread.cpp b/src/tools/loadingthread.cpp index 86b5c83..cc5c549 100644 --- a/src/tools/loadingthread.cpp +++ b/src/tools/loadingthread.cpp @@ -6,7 +6,9 @@ #include #include -#include +//#include +#include +#include #include @@ -57,9 +59,9 @@ void LoadingThread::processTasks() sf::sleep(sf::milliseconds(500)); // wait for half a second else { - ResourceInterface* res = m_resourceQueue.front(); + std::shared_ptr res = m_resourceQueue.front(); m_resourceQueue.pop_front(); - res->load(m_taskProgress); + res->loadResource(m_taskProgress); glFlush(); if(m_taskProgress < 1.0) fprintf(stderr, "failed to process the following task : %s\n", res->m_name.c_str()); @@ -80,13 +82,13 @@ const std::string& LoadingThread::getCurrentTaskName() void LoadingThread::loadResourcePack(const std::string& name) { - std::fstream file; +/* std::fstream file; file.open("data/" + name + ".pack", std::ios_base::in); ObjectLoader loader; loader.loadAscii(file); file.close(); - const std::vector& packVec = loader.getObjects(); - ResourcePack* pack = packVec[0]; + const std::vector& packVec = loader.getObjects(); + NewResourcePack* pack = packVec[0]; m_packs[name] = pack; for(ResourceInterface* res : pack->m_resources) { @@ -94,18 +96,29 @@ void LoadingThread::loadResourcePack(const std::string& name) m_resourceQueue.push_back(res); else delete res; + }*/ + std::ifstream inputStream("data/" + name + ".pack"); + cereal::JSONInputArchive input(inputStream); + NewResourcePack pack; +// input(pack); + for(std::shared_ptr res : pack.m_resources) + { + if((m_references[res->m_name] += 1) == 1) + m_resourceQueue.push_back(res); + //else + //delete res; } } void LoadingThread::freeResourcePack(const std::string& name) { - ResourcePack* pack = m_packs[name]; - for(ResourceInterface* res : pack->m_resources) + NewResourcePack* pack = m_packs[name]; + for(std::shared_ptr res : pack->m_resources) { if((m_references[res->m_name] -= 1) == 0) { m_references.erase(res->m_name); - delete res; + //delete res; } } m_packs.erase(name); diff --git a/src/tools/loadingthread.h b/src/tools/loadingthread.h index 8f92a9a..70ed574 100644 --- a/src/tools/loadingthread.h +++ b/src/tools/loadingthread.h @@ -5,15 +5,15 @@ #include #include -#include "resourcepack.h" +#include "newresourcepack.h" class LoadingThread { static LoadingThread* singleton; static std::thread* thread; - std::deque m_resourceQueue; - std::unordered_map m_packs; + std::deque> m_resourceQueue; + std::unordered_map m_packs; std::unordered_map m_references; ResourceInterface* m_currentTask; bool m_running; diff --git a/src/tools/newresourcepack.cpp b/src/tools/newresourcepack.cpp new file mode 100644 index 0000000..8296660 --- /dev/null +++ b/src/tools/newresourcepack.cpp @@ -0,0 +1,218 @@ +#include "newresourcepack.h" + +#include "loader.h" +#include "resourcemanager.h" + +#include + +#include +#include +#include + +#include +#include +#include +#include + +void NewResourcePack::gui() +{ + static std::shared_ptr currentResource = nullptr; + + ImGui::Begin("ResourcePack"); + char buf[1024] = {0}; + strcpy(buf, m_name.c_str()); + if(ImGui::InputText("Pack name", buf, 1024)) + m_name = buf; + + if(ImGui::Button("Save resource pack")) + { + // std::fstream file; + // ObjectSaver saver; + // saver.addObject(this); + // file.open("data/" + m_name + ".pack", std::ios_base::out); + // saver.saveAscii(file); + //file.close(); + + std::ofstream outputStream("data/"+m_name+".pack"); + cereal::JSONOutputArchive output(outputStream); + output(std::shared_ptr(this)); + outputStream.close(); + + } + if(ImGui::Button("Load resource pack")) + { +// std::fstream file; +// file.open("data/" + m_name + ".pack", std::ios_base::in); +// ObjectLoader loader; +// loader.loadAscii(file); +// file.close(); +// const std::vector& packVec = loader.getObjects(); +// for(ResourceInterface* res : m_resources) +// delete res; +// m_resources = packVec[0]->m_resources; +// delete packVec[0]; + + std::ifstream inputStream("data/"+m_name+".pack"); + cereal::JSONInputArchive input(inputStream); + NewResourcePack tmp = NewResourcePack(); + tmp.m_name = this->m_name; + tmp.m_resources = this->m_resources; + input(tmp); + inputStream.close(); + } + + if(ImGui::Button("Add a texture")) + { + std::shared_ptr resource(new TextureResource()); + m_resources.push_back(resource); + } + + if(ImGui::Button("Add a material")) + { + std::shared_ptr resource(new MaterialResource()); +// MaterialResource* resource = new MaterialResource(); + m_resources.push_back(resource); + } + + for(std::shared_ptr res : m_resources) + { + if(ImGui::Button(res->m_name.c_str())) + currentResource = res; + } + ImGui::End(); + + if(currentResource != nullptr) + { + bool opened = true; + ImGui::Begin("Resource Editor", &opened); + + char resBuf[1024] = {0}; + strcpy(resBuf, currentResource->m_name.c_str()); + if(ImGui::InputText("Name (should be unique)", resBuf, 1024)) + currentResource->m_name = resBuf; + + currentResource->gui(); + if(ImGui::Button("Delete resource")) + { + for(unsigned int i=0; ialbedo = m_albedo; + m_material->metallic = m_metallic; + m_material->roughness = m_roughness; + m_material->emission = m_emission; + m_material->opacity = m_opacity; + m_material->setTexture(PBRMaterial::ALBEDO_SLOT, RESOURCE_GET(Texture, m_albedoTexture)); + m_material->setTexture(PBRMaterial::METALLIC_SLOT, RESOURCE_GET(Texture, m_metallicTexture)); + m_material->setTexture(PBRMaterial::ROUGHNESS_SLOT, RESOURCE_GET(Texture, m_roughnessTexture)); + m_material->setTexture(PBRMaterial::EMISSION_SLOT, RESOURCE_GET(Texture, m_emissionTexture)); + m_material->setTexture(PBRMaterial::NORMALS_SLOT, RESOURCE_GET(Texture, m_normalTexture)); + m_material->setTexture(PBRMaterial::ALPHA_SLOT, RESOURCE_GET(Texture, m_alphaMaskTexture)); + RESOURCE_ADD(m_material, PBRMaterial, m_name); + progress = 1; +} + +void MaterialResource::destroy() +{ + if(m_material != nullptr) + { + delete m_material; + m_material = nullptr; + RESOURCE_REMOVE(PBRMaterial,m_name); + } +} + +void MaterialResource::gui() +{ + ImGui::Text("TODO"); +} diff --git a/src/tools/newresourcepack.h b/src/tools/newresourcepack.h new file mode 100644 index 0000000..8020367 --- /dev/null +++ b/src/tools/newresourcepack.h @@ -0,0 +1,139 @@ +#ifndef NEWRESOURCEPACK_H +#define NEWRESOURCEPACK_H + +#include +#include + +#include +#include +#include + +class Texture; +class PBRMaterial; + +/** + * @brief The ResourceInterface struct holds a resource, it handles its loading and its destruction + */ +struct ResourceInterface +{ + std::string m_name; + + template + void serialize(Archive & archive){ + archive(m_name); + } + + virtual void loadResource(float & progress) = 0; + + virtual void destroy() = 0; + + virtual void gui() = 0; +}; + +/** + * @brief The ResourcePack class is just a container of LoadTask, it only exists for serialization purposes + */ +struct NewResourcePack +{ + std::string m_name; + std::vector> m_resources; + + NewResourcePack() {} + + void gui(); + + template + void serialize(Archive & archive){ + archive(m_name,CEREAL_NVP(m_resources)); + } +}; + +/*template +void serialize(Archive & archive, std::shared_ptr respack) +{ + archive(respack); +}*/ + +/* + * Some LoadTask implementations + */ + +class TextureResource : public ResourceInterface +{ + std::string m_name; + std::string m_path; + int m_bitsPerPixel; + bool m_isVerticallyReversed; + bool m_needsMipMaps; + + Texture* m_texture; + +public: + TextureResource(); + virtual ~TextureResource(); + + template + void serialize(Archive & archive) + { + archive(cereal::base_class(this), + m_path, + m_bitsPerPixel, + m_isVerticallyReversed, + m_needsMipMaps); + } + + void loadResource(float & progress); + + void destroy(); + void gui(); +}; + +class MaterialResource : public ResourceInterface +{ + glm::vec3 m_albedo; + float m_metallic; + float m_roughness; + glm::vec3 m_emission; + float m_opacity; + std::string m_albedoTexture; + std::string m_metallicTexture; + std::string m_roughnessTexture; + std::string m_emissionTexture; + std::string m_normalTexture; + std::string m_alphaMaskTexture; + + PBRMaterial* m_material; + +public: + MaterialResource(); + virtual ~MaterialResource(); + + template + void serialize(Archive & archive) + { + archive(cereal::base_class(this), + m_albedo, + m_metallic, + m_roughness, + m_emission, + m_opacity, + m_albedoTexture, + m_metallicTexture, + m_roughnessTexture, + m_emissionTexture, + m_normalTexture, + m_alphaMaskTexture); + } + + void loadResource(float & progress); + + void destroy(); + + void gui(); +}; + +//CEREAL_REGISTER_TYPE(TextureResource) +//CEREAL_REGISTER_TYPE(MaterialResource) + + +#endif // NEWRESOURCEPACK_H diff --git a/src/tools/resourcepack.cpp b/src/tools/resourcepack.cpp index e9434c4..a5fcc9a 100644 --- a/src/tools/resourcepack.cpp +++ b/src/tools/resourcepack.cpp @@ -13,9 +13,9 @@ #include -INIT_SERIALIZABLE(ResourcePack) +//INIT_SERIALIZABLE(ResourcePack) -void ResourcePack::gui() +/*void ResourcePack::gui() { static ResourceInterface* currentResource = nullptr; @@ -94,11 +94,11 @@ void ResourcePack::gui() if(!opened) currentResource = nullptr; } -} +}*/ -INIT_SERIALIZABLE(TextureResource) +//INIT_SERIALIZABLE(TextureResource) -TextureResource::TextureResource() : +/*TextureResource::TextureResource() : m_texture(nullptr) { m_name = "new texture"; @@ -111,9 +111,9 @@ TextureResource::TextureResource() : TextureResource::~TextureResource() { destroy(); -} +}*/ -void TextureResource::load(float & progress) +/* void TextureResource::load(float & progress) { progress = 0; Image* img = Loader::loadImage(m_path, m_bitsPerPixel, m_isVerticallyReversed); @@ -125,8 +125,9 @@ void TextureResource::load(float & progress) delete img; progress = 1; } +*/ -void TextureResource::destroy() +/* void TextureResource::destroy() { if(m_texture != nullptr) { @@ -134,9 +135,9 @@ void TextureResource::destroy() m_texture = nullptr; RESOURCE_REMOVE(Texture, m_name); } -} +}*/ -void TextureResource::gui() +/*void TextureResource::gui() { char buf[1024] = {0}; strcpy(buf, m_path.c_str()); @@ -154,10 +155,11 @@ void TextureResource::gui() else destroy(); } -} +}*/ -INIT_SERIALIZABLE(MaterialResource) +//INIT_SERIALIZABLE(MaterialResource) +/* MaterialResource::MaterialResource() : m_material(nullptr) { @@ -205,4 +207,4 @@ void MaterialResource::destroy() void MaterialResource::gui() { ImGui::Text("TODO"); -} +}*/ diff --git a/src/tools/resourcepack.h b/src/tools/resourcepack.h index 8e4c83b..dd8f625 100644 --- a/src/tools/resourcepack.h +++ b/src/tools/resourcepack.h @@ -8,8 +8,8 @@ class PBRMaterial; /** * @brief The ResourceInterface struct holds a resource, it handles its loading and its destruction - */ -struct ResourceInterface : public Serializable + **/ +/*struct ResourceInterface : public Serializable { P_STRING(m_name) @@ -18,12 +18,12 @@ struct ResourceInterface : public Serializable virtual void destroy() = 0; virtual void gui() {} -}; +};*/ /** * @brief The ResourcePack class is just a container of LoadTask, it only exists for serialization purposes */ -struct ResourcePack : public Serializable +/*struct ResourcePack : public Serializable { P_STRING(m_name) P_VECTOR_REFERENCE(ResourceInterface, m_resources) @@ -33,13 +33,13 @@ struct ResourcePack : public Serializable void gui(); SERIALIZABLE(ResourcePack, CAST(m_name), CAST(m_resources)) -}; +};*/ // // Some LoadTask implementations // -class TextureResource : public ResourceInterface +/*class TextureResource : public ResourceInterface { P_STRING(m_path) P_INT(m_bitsPerPixel) @@ -59,9 +59,9 @@ public: void destroy(); void gui(); -}; +};*/ -class MaterialResource : public ResourceInterface +/*class MaterialResource : public ResourceInterface { P_VEC3(m_albedo) P_FLOAT(m_metallic) @@ -100,6 +100,6 @@ public: void destroy(); void gui(); -}; +};*/ #endif // RESOURCEPACK_H