[Editor][Core] Continue to work on project exporter and serialization

fabsgc · Aug 7, 2024 · b098a6c · b098a6c
1 parent f8d3b7a
commit b098a6c
Show file tree

Hide file tree

Showing 14 changed files with 284 additions and 51 deletions.
diff --git a/Data/Project/default.project b/Data/Project/default.project
diff --git a/Source/Examples/Editor/TeEditor.cpp b/Source/Examples/Editor/TeEditor.cpp
@@ -994,7 +994,11 @@ namespace te
         }
 
         SPtr<ProjectExportOptions> options = te_shared_ptr_new<ProjectExportOptions>();
-        if (!gExporter().Export(_project.GetInternalPtr().get(), _project->GetPath(), options))
+        if (gExporter().Export(_project.GetInternalPtr().get(), _project->GetPath(), options))
+        {
+            TE_DEBUG("Project saved at the specified path : " + _project->GetPath());
+        }
+        else
         {
             TE_DEBUG("Fail to save your project at the specified path : " + _project->GetPath());
             return false;

diff --git a/Source/Framework/Core/Project/TeProject.cpp b/Source/Framework/Core/Project/TeProject.cpp
@@ -1,5 +1,7 @@
 #include "Project/TeProject.h"
+
 #include "Resources/TeResourceManager.h"
+#include "ThirdParty/Slugify/slugify.hpp"
 
 namespace te
 {
@@ -33,5 +35,27 @@ namespace te
     void Project::Serialize(StreamWriter* serializer) const
     {
         Resource::Serialize(serializer);
+
+        Vector<String> resources;
+
+        for (auto& resource : _resources)
+        {
+            resources.push_back(slugify(resource->GetName()) + ".resource");
+        }
+
+        serializer->WriteArray(resources);
+    }
+
+    void Project::Deserialize(StreamReader* deserializer, Project* object)
+    {
+        if (!object)
+        {
+            object = CreateEmpty().get();
+        }
+
+        Resource::Deserialize(deserializer, object);
+
+        Vector<String> resources;
+        deserializer->ReadArray(resources);
     }
 }
diff --git a/Source/Framework/Core/Project/TeProject.h b/Source/Framework/Core/Project/TeProject.h
@@ -37,6 +37,8 @@ namespace te
     public:
         void Serialize(StreamWriter* serializer) const override;
 
+        static void Deserialize(StreamReader* deserializer, Project* object);
+
     private:
         Project();
 

diff --git a/Source/Framework/Core/Resources/TeResource.cpp b/Source/Framework/Core/Resources/TeResource.cpp
@@ -19,4 +19,21 @@ namespace te
         serializer->WriteRaw<UINT32>(_size);
         serializer->WriteString(_UUID.ToString());
     }
+
+    void Resource::Deserialize(StreamReader* deserializer, Resource* object)
+    {
+        if (!object)
+            return;
+
+        Serializable::Deserialize(deserializer, object);
+
+        String uuid;
+
+        deserializer->ReadString(object->_name);
+        deserializer->ReadString(object->_path);
+        deserializer->ReadRaw<UINT32>(object->_size);
+        deserializer->ReadString(uuid);
+
+        object->_UUID = UUID(uuid);
+    }
 }
diff --git a/Source/Framework/Core/Resources/TeResource.h b/Source/Framework/Core/Resources/TeResource.h
@@ -1,8 +1,9 @@
 #pragma once
 
 #include "TeCorePrerequisites.h"
-#include "CoreUtility/TeCoreObject.h"
+
 #include "Utility/TeNonCopyable.h"
+#include "CoreUtility/TeCoreObject.h"
 #include "Serialization/TeSerializable.h"
 
 namespace te
@@ -32,8 +33,12 @@ namespace te
         static UINT32 GetResourceType() { return TypeID_Core::TID_Resource; }
 
     public:
+        /** @copydoc Serializable::Serialize */
         void Serialize(StreamWriter* serializer) const override;
 
+        /** @copydoc Serializable::Deserialize */
+        static void Deserialize(StreamReader* deserializer, Resource* object);
+
     protected:
         friend class ResourceManager;
         friend class ResourceHandleBase;

diff --git a/Source/Framework/Core/Serialization/TeBinaryReader.cpp b/Source/Framework/Core/Serialization/TeBinaryReader.cpp
@@ -23,7 +23,7 @@ namespace te
 
     bool BinaryReader::ReadData(UINT8* dest, size_t size)
     {
-
+        _stream->Read(dest, size);
         return true;
     }
 }
diff --git a/Source/Framework/Core/Serialization/TeBinaryReader.h b/Source/Framework/Core/Serialization/TeBinaryReader.h
@@ -18,12 +18,14 @@ namespace te
         ~BinaryReader();
 
         bool IsStreamGood() const final { return _stream->Good(); }
-		UINT64 GetStreamPosition() const override final { return _stream->Tell(); }
-		void SetStreamPosition(UINT64 position) final { _stream->Seek(position); }
-		bool ReadData(UINT8* dest, size_t size) override;
+        UINT64 GetStreamPosition() const override final { return _stream->Tell(); }
+        void SetStreamPosition(UINT64 position) final { _stream->Seek(position); }
+
+    private:
+        bool ReadData(UINT8* dest, size_t size) override;
 
     private:
         std::filesystem::path _path;
-		DataStream* _stream;
+        DataStream* _stream;
     };
 }
diff --git a/Source/Framework/Core/Serialization/TeSerializable.h b/Source/Framework/Core/Serialization/TeSerializable.h
@@ -20,6 +20,14 @@ namespace te
             serializer->WriteRaw<UINT32>(_coreType);
         }
 
+        static void Deserialize(StreamReader* deserialize, Serializable* object)
+        {
+            if (!object)
+                return;
+
+            deserialize->ReadRaw<UINT32>(object->_coreType);
+        }
+
     protected:
         UINT32 _coreType;
     };

diff --git a/Source/Framework/Core/Serialization/TeStreamReader.h b/Source/Framework/Core/Serialization/TeStreamReader.h
@@ -33,7 +33,115 @@ namespace te
         template<typename T>
         void ReadObject(T& obj)
         {
-            // TODO Serialization
+            T::Deserialize(this, obj);
+        }
+
+        template<typename Key, typename Value>
+        void ReadMap(Map<Key, Value>& map)
+        {
+            UINT32 size;
+            ReadRaw<UINT32>(size);
+
+            for (UINT32 i = 0; i < size; i++)
+            {
+                Key key;
+                if constexpr (std::is_trivial<Key>())
+                    ReadRaw<Key>(key);
+                else
+                    ReadObject<Key>(key);
+
+                if constexpr (std::is_trivial<Value>())
+                    ReadRaw<Value>(map[key]);
+                else
+                    ReadObject<Value>(map[key]);
+            }
+        }
+
+        template<typename Key, typename Value>
+        void ReadMap(UnorderedMap<Key, Value>& map)
+        {
+            UINT32 size;
+            ReadRaw<UINT32>(size);
+
+            for (UINT32 i = 0; i < size; i++)
+            {
+                Key key;
+                if constexpr (std::is_trivial<Key>())
+                    ReadRaw<Key>(key);
+                else
+                    ReadObject<Key>(key);
+
+                if constexpr (std::is_trivial<Value>())
+                    ReadRaw<Value>(map[key]);
+                else
+                    ReadObject<Value>(map[key]);
+            }
+        }
+
+        template<typename Value>
+        void ReadMap(const Map<String, Value>& map)
+        {
+            UINT32 size;
+            ReadRaw<UINT32>(size);
+
+            for (UINT32 i = 0; i < size; i++)
+            {
+                String key;
+                ReadString(key);
+
+                if constexpr (std::is_trivial<Value>())
+                    ReadRaw<Value>(map[key]);
+                else
+                    ReadObject<Value>(map[key]);
+            }
+        }
+
+        template<typename Value>
+        void ReadMap(UnorderedMap<String, Value>& map)
+        {
+            UINT32 size;
+            ReadRaw<UINT32>(size);
+
+            for (UINT32 i = 0; i < size; i++)
+            {
+                String key;
+                ReadString(key);
+
+                if constexpr (std::is_trivial<Value>())
+                    ReadRaw<Value>(map[key]);
+                else
+                    ReadObject<Value>(map[key]);
+            }
+        }
+
+        template<typename T>
+        void ReadArray(Vector<T>& array)
+        {
+            UINT32 size;
+            ReadRaw<UINT32>(size);
+
+            array.resize(size);
+
+            for (UINT32 i = 0; i < size; i++)
+            {
+                if constexpr (std::is_trivial<T>())
+                    ReadRaw<T>(array[i]);
+                else
+                    ReadObject<T>(array[i]);
+            }
+        }
+
+        void ReadArray(Vector<String>& array)
+        {
+            UINT32 size;
+            ReadRaw<UINT32>(size);
+
+            array.resize(size);
+
+            for (UINT32 i = 0; i < size; i++)
+            {
+                ReadString(array[i]);
+            }
         }
     };
 }
diff --git a/Source/Framework/Core/Serialization/TeStreamWriter.h b/Source/Framework/Core/Serialization/TeStreamWriter.h
@@ -36,6 +36,100 @@ namespace te
             obj.Serialize(this);
         }
 
+        template<typename Key, typename Value>
+        void WriteMap(const Map<Key, Value>& map)
+        {
+            WriteRaw<uint32_t>((uint32_t)map.size());
+
+            for (const auto& [key, value] : map)
+            {
+                if constexpr (std::is_trivial<Key>())
+                    WriteRaw<Key>(key);
+                else
+                    WriteObject<Key>(key);
+
+                if constexpr (std::is_trivial<Value>())
+                    WriteRaw<Value>(value);
+                else
+                    WriteObject<Value>(value);
+            }
+        }
+
+        template<typename Key, typename Value>
+        void WriteMap(const UnorderedMap<Key, Value>& map)
+        {
+            WriteRaw<uint32_t>((uint32_t)map.size());
+
+            for (const auto& [key, value] : map)
+            {
+                if constexpr (std::is_trivial<Key>())
+                    WriteRaw<Key>(key);
+                else
+                    WriteObject<Key>(key);
+
+                if constexpr (std::is_trivial<Value>())
+                    WriteRaw<Value>(value);
+                else
+                    WriteObject<Value>(value);
+            }
+        }
+
+        template<typename Value>
+        void WriteMap(const Map<String, Value>& map)
+        {
+            WriteRaw<uint32_t>((uint32_t)map.size());
+
+            for (const auto& [key, value] : map)
+            {
+                WriteString(key);
+
+                if constexpr (std::is_trivial<Value>())
+                    WriteRaw<Value>(value);
+                else
+                    WriteObject<Value>(value);
+            }
+        }
+
+        template<typename Value>
+        void WriteMap(const UnorderedMap<String, Value>& map)
+        {
+            WriteRaw<uint32_t>((uint32_t)map.size());
+
+            for (const auto& [key, value] : map)
+            {
+                WriteString(key);
+
+                if constexpr (std::is_trivial<Value>())
+                    WriteRaw<Value>(value);
+                else
+                    WriteObject<Value>(value);
+            }
+        }
+
+        template<typename T>
+        void WriteArray(const std::vector<T>& array)
+        {
+            WriteRaw<uint32_t>((uint32_t)array.size());
+
+            for (const auto& element : array)
+            {
+                if constexpr (std::is_trivial<T>())
+                    WriteRaw<T>(element);
+                else
+                    WriteObject<T>(element);
+            }
+        }
+
+        void WriteArray(const std::vector<String>& array)
+        {
+            WriteRaw<uint32_t>((uint32_t)array.size());
+
+            for (const auto& element : array)
+            {
+                WriteString(element);
+            }
+        }
+
     protected:
         virtual bool WriteData(const UINT8* data, size_t size) = 0;
     };

diff --git a/Source/Framework/Utility/Utility/TeFileSystem.cpp b/Source/Framework/Utility/Utility/TeFileSystem.cpp
@@ -50,7 +50,7 @@ namespace te
 
     bool FileSystem::CreateDir(const String& path)
     {
-        if(std::filesystem::is_directory(path) && !std::filesystem::exists(path))
+        if(!std::filesystem::exists(path))
             return std::filesystem::create_directories(path);
 
         if(std::filesystem::exists(path))

diff --git a/Source/Plugins/TeProjectExporter/TeProjectExporter.cpp b/Source/Plugins/TeProjectExporter/TeProjectExporter.cpp
@@ -4,6 +4,7 @@
 #include "Exporter/TeProjectExportOptions.h"
 #include "Serialization/TeBinaryWriter.h"
 #include "Project/TeProject.h"
+#include "Utility/TeFileSystem.h"
 
 #include <filesystem>
 
@@ -44,8 +45,12 @@ namespace te
             std::string name = slugify(resource->GetName());
             std::filesystem::path resourcePath = workingDirectory;
             resourcePath += std::filesystem::path::preferred_separator;
+            resourcePath += "resources";
+            resourcePath += std::filesystem::path::preferred_separator;
             resourcePath += name + ".resource";
 
+            FileSystem::CreateDir(resourcePath.parent_path().generic_string());
+
             BinaryWriter* resourceSerializer = te_new<BinaryWriter>(resourcePath);
             resource->Serialize(resourceSerializer);