Folded system data deserialisation into packfile access operations, fixed all tests

Author: jonjondev

engine/core/scene/SceneFile.cpp

@@ -10,8 +10,8 @@
 #include "SceneFile.h"
 
 #include <resources/PackFile.h>
-#include <resources/ResourceSystem.h>
 #include <resources/PackFileData.h>
+#include <resources/ResourceSystem.h>
 #include <resources/SceneData.h>
 #include <utils/Logging.h>
 
@@ -106,43 +106,36 @@ bool SceneFile::Deserialise(std::vector<Entity*>& entities)
         };
 
     // TODO: Implement proper write-mode handling for scene system
-    String ScenePath = MakeScenePath(sceneName);
+    String scenePath = MakeScenePath(sceneName);
     if (!SceneSystem::GetBaseDirectory().IsEmpty())
     {
         bool result = FileSystem::ForEachFileInDir(
-            ScenePath,
+            scenePath,
             [&deserialiseEntityString](const std::filesystem::path& path) {
                 if (path.extension() != ENTITY_FILE_EXT) return;
                 String entityData = FileSystem::Read(path.c_str());
                 deserialiseEntityString(entityData, path);
             });
         if (!result)
         {
-            CC_LOG_ERROR("Failed to read scene file at path \"{}\"", ScenePath)
+            CC_LOG_ERROR("Failed to read scene file at path \"{}\"", scenePath)
             return false;
         }
     }
     else
     {
         PackFile* packFile = ResourceSystem::GetInstance().GetPackFile();
 
-        std::shared_ptr<PackFileData> sceneDataBuffer = packFile->FindData<PackFileData>(ScenePath);
-        if (!sceneDataBuffer)
+        std::shared_ptr<SceneData> sceneData = packFile->FindDataDeserialised<SceneData>(scenePath);
+        if (!sceneData)
         {
-            CC_LOG_WARNING("Failed to find scene \"{}\" in pack file", ScenePath)
+            CC_LOG_WARNING(
+                "Failed to retrieve deserialised scene data for scene \"{}\" from pack file",
+                scenePath)
             return false;
         }
 
-        BinarySerialisation::Buffer buffer;
-        uint8_t* data = reinterpret_cast<uint8_t*>(sceneDataBuffer->data);
-        size_t dataSize = sceneDataBuffer->dataSize;
-        buffer.data.assign(data, dataSize);
-
-        // TODO - Fold into resource system
-        SceneData sceneData;
-        sceneData.serialise(buffer, BinarySerialisation::DESERIALISE);
-
-        for (const String& entityData : sceneData.entities)
+        for (const String& entityData : sceneData->entities)
         {
             deserialiseEntityString(entityData.Str(), "");
         }

engine/render/renderer/platform/vulkan/Font.cpp

@@ -10,8 +10,8 @@
 #include "Font.h"
 
 #include <freetype/freetype.h>
-#include <resources/PackFileData.h>
 #include <resources/PackFile.h>
+#include <resources/PackFileData.h>
 #include <resources/ResourceSystem.h>
 #include <utils/Defer.h>
 #include <utils/Logging.h>
@@ -27,7 +27,7 @@ namespace Siege::Vulkan
 Font::Font(const char* filePath)
 {
     PackFile* packFile = ResourceSystem::GetInstance().GetPackFile();
-    std::shared_ptr<PackFileData> fileData = packFile->FindData<PackFileData>(filePath);
+    std::shared_ptr<PackFileData> fileData = packFile->FindData(filePath);
 
     FT_Open_Args args;
     args.flags = FT_OPEN_MEMORY;

engine/render/renderer/platform/vulkan/Shader.cpp

@@ -9,8 +9,8 @@
 
 #include "Shader.h"
 
-#include <resources/PackFileData.h>
 #include <resources/PackFile.h>
+#include <resources/PackFileData.h>
 #include <resources/ResourceSystem.h>
 #include <utils/Logging.h>
 
@@ -174,7 +174,7 @@ void Shader::Destroy()
 MHArray<char> Shader::ReadFileAsBinary(const String& filePath)
 {
     PackFile* packFile = ResourceSystem::GetInstance().GetPackFile();
-    std::shared_ptr<PackFileData> fileData = packFile->FindData<PackFileData>(filePath);
+    std::shared_ptr<PackFileData> fileData = packFile->FindData(filePath);
     MHArray<char> buffer(fileData->data, fileData->dataSize);
     return buffer;
 }

engine/render/renderer/platform/vulkan/StaticMesh.cpp

@@ -11,7 +11,6 @@
 
 #include <resources/PackFile.h>
 #include <resources/ResourceSystem.h>
-#include <resources/PackFileData.h>
 #include <resources/StaticMeshData.h>
 #include <utils/Logging.h>
 
@@ -44,31 +43,25 @@ StaticMesh::StaticMesh(const char* filePath, Material* material)
 {
     // TODO(Aryeh): How to extract material data from object files?
     PackFile* packFile = ResourceSystem::GetInstance().GetPackFile();
-    std::shared_ptr<PackFileData> vertexDataDataBuffer = packFile->FindData<PackFileData>(filePath);
+    std::shared_ptr<StaticMeshData> staticMeshData =
+        packFile->FindDataDeserialised<StaticMeshData>(filePath);
 
-    BinarySerialisation::Buffer buffer;
-    uint8_t* data = reinterpret_cast<uint8_t*>(vertexDataDataBuffer->data);
-    size_t dataSize = vertexDataDataBuffer->dataSize;
-    buffer.data.assign(data, dataSize);
+    CC_ASSERT(!staticMeshData->vertices.empty(), "Cannot load in a file with no vertices!")
+    CC_ASSERT(!staticMeshData->indices.empty(), "Cannot load in a file with no indices!")
 
-    // TODO - Fold into resource system
-    StaticMeshData staticMeshData;
-    staticMeshData.serialise(buffer, BinarySerialisation::DESERIALISE);
+    CC_ASSERT(staticMeshData->vertices.size() < MAX_VERTICES,
+              "The provided model has too many vertices!")
+    CC_ASSERT(staticMeshData->indices.size() < MAX_INDICES,
+              "The provided model has too many indices!")
 
-    CC_ASSERT(!staticMeshData.vertices.empty(), "Cannot load in a file with no vertices!")
-    CC_ASSERT(!staticMeshData.indices.empty(), "Cannot load in a file with no indices!")
-
-    CC_ASSERT(staticMeshData.vertices.size() < MAX_VERTICES, "The provided model has too many vertices!")
-    CC_ASSERT(staticMeshData.indices.size() < MAX_INDICES, "The provided model has too many indices!")
-
-    vertexCount = staticMeshData.vertices.size();
-    indexCount = staticMeshData.indices.size();
+    vertexCount = staticMeshData->vertices.size();
+    indexCount = staticMeshData->indices.size();
 
     vertexBuffer = VertexBuffer(sizeof(BaseVertex) * vertexCount);
-    vertexBuffer.Copy(staticMeshData.vertices.data(), sizeof(BaseVertex) * vertexCount);
+    vertexBuffer.Copy(staticMeshData->vertices.data(), sizeof(BaseVertex) * vertexCount);
 
     indexBuffer = IndexBuffer(sizeof(unsigned int) * indexCount);
-    indexBuffer.Copy(staticMeshData.indices.data(), sizeof(unsigned int) * indexCount);
+    indexBuffer.Copy(staticMeshData->indices.data(), sizeof(unsigned int) * indexCount);
 
     subMeshes = MHArray<SubMesh>(1);
     materials = MHArray<Material*>(1);

engine/render/renderer/platform/vulkan/Texture2D.cpp

@@ -94,21 +94,13 @@ Texture2D& Texture2D::operator=(Texture2D&& other)
 void Texture2D::LoadFromFile(const char* filePath)
 {
     PackFile* packFile = ResourceSystem::GetInstance().GetPackFile();
-    std::shared_ptr<PackFileData> texture2dDataBuffer = packFile->FindData<PackFileData>(filePath);
-
-    BinarySerialisation::Buffer buffer;
-    uint8_t* data = reinterpret_cast<uint8_t*>(texture2dDataBuffer->data);
-    size_t dataSize = texture2dDataBuffer->dataSize;
-    buffer.data.assign(data, dataSize);
-
-    // TODO - Fold into resource system
-    Texture2DData texture2dData;
-    texture2dData.serialise(buffer, BinarySerialisation::DESERIALISE);
+    std::shared_ptr<Texture2DData> texture2dData =
+        packFile->FindDataDeserialised<Texture2DData>(filePath);
 
     Buffer::Buffer stagingBuffer;
     defer([&stagingBuffer] { Buffer::DestroyBuffer(stagingBuffer); });
 
-    Buffer::CreateBuffer(texture2dData.GetImageSize(),
+    Buffer::CreateBuffer(texture2dData->GetImageSize(),
                          VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
                          // specifies that data is accessible on the CPU.
                          VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
@@ -117,13 +109,13 @@ void Texture2D::LoadFromFile(const char* filePath)
                          OUT stagingBuffer.buffer,
                          OUT stagingBuffer.bufferMemory);
 
-    Buffer::CopyData(stagingBuffer, texture2dData.GetImageSize(), texture2dData.pixels.data());
+    Buffer::CopyData(stagingBuffer, texture2dData->GetImageSize(), texture2dData->pixels.data());
 
-    extent = {static_cast<uint32_t>(texture2dData.texWidth),
-              static_cast<uint32_t>(texture2dData.texHeight)};
+    extent = {static_cast<uint32_t>(texture2dData->texWidth),
+              static_cast<uint32_t>(texture2dData->texHeight)};
 
-    Utils::Extent3D imageExtent {static_cast<uint32_t>(texture2dData.texWidth),
-                                 static_cast<uint32_t>(texture2dData.texHeight),
+    Utils::Extent3D imageExtent {static_cast<uint32_t>(texture2dData->texWidth),
+                                 static_cast<uint32_t>(texture2dData->texHeight),
                                  1};
     image = Image({Utils::RGBASRGB, imageExtent, Vulkan::Utils::USAGE_TEXTURE, 1, 1});
 

engine/resources/PackFile.cpp

@@ -52,6 +52,27 @@ bool PackFile::LoadFromPath(const String& filepath)
     return true;
 }
 
+std::shared_ptr<PackFileData> PackFile::FindData(const String& filepath)
+{
+    const TocEntry* toc = entries[filepath];
+    if (!toc)
+    {
+        return nullptr;
+    }
+
+    uLongf bodyDataSizeUncompressed = toc->dataSize;
+    uLongf bodyDataSizeCompressed = toc->dataSizeCompressed;
+
+    PackFileData* packFileData = new (malloc(bodyDataSizeUncompressed)) PackFileData();
+    int result = uncompress(reinterpret_cast<Bytef*>(packFileData),
+                            &bodyDataSizeUncompressed,
+                            reinterpret_cast<Bytef*>(body + toc->dataOffset),
+                            bodyDataSizeCompressed);
+    CC_ASSERT(result == Z_OK, "Decompression failed for filepath: " + filepath);
+
+    return std::shared_ptr<PackFileData>(packFileData);
+}
+
 const std::map<String, PackFile::TocEntry*>& PackFile::GetEntries()
 {
     return entries;

engine/resources/PackFile.h

@@ -10,13 +10,15 @@
 #ifndef SIEGE_ENGINE_PACKFILE_H
 #define SIEGE_ENGINE_PACKFILE_H
 
-#include <utils/String.h>
+#include <utils/BinarySerialisation.h>
 #include <utils/Logging.h>
+#include <utils/String.h>
+#include <zlib.h>
 
 #include <filesystem>
 #include <map>
 
-#include <zlib.h>
+#include "PackFileData.h"
 
 #define PACKER_MAGIC_NUMBER_FILE "pck"
 #define PACKER_MAGIC_NUMBER_TOC "toc!"
@@ -69,23 +71,25 @@ class PackFile
 
     bool LoadFromPath(const String& filepath);
 
+    std::shared_ptr<PackFileData> FindData(const String& filepath);
+
     template<typename T>
-    std::shared_ptr<T> FindData(const String& filepath)
+    std::shared_ptr<T> FindDataDeserialised(const String& filepath)
     {
-        const TocEntry* toc = entries[filepath];
-        if (!toc)
+        std::shared_ptr<PackFileData> packFileData = FindData(filepath);
+        if (!packFileData)
         {
+            CC_LOG_WARNING("Failed to find data for filepath \"{}\"", filepath);
             return nullptr;
         }
 
-        uLongf bodyDataSizeUncompressed = toc->dataSize;
-        uLongf bodyDataSizeCompressed = toc->dataSizeCompressed;
-        void* mem = malloc(bodyDataSizeUncompressed);
+        BinarySerialisation::Buffer buffer;
+        buffer.Fill(reinterpret_cast<uint8_t*>(packFileData->data), packFileData->dataSize);
 
-        int result = uncompress(static_cast<Bytef*>(mem), &bodyDataSizeUncompressed, reinterpret_cast<Bytef*>(body + toc->dataOffset), bodyDataSizeCompressed);
-        CC_ASSERT(result == Z_OK, "Decompression failed for filepath: " + filepath);
+        T* typedData = new T();
+        typedData->serialise(buffer, BinarySerialisation::DESERIALISE);
 
-        return std::shared_ptr<T>(static_cast<T*>(mem), free);
+        return std::shared_ptr<T>(typedData);
     }
 
     const std::map<String, TocEntry*>& GetEntries();

engine/resources/PackFileData.h

@@ -10,7 +10,10 @@
 #ifndef SIEGE_ENGINE_PACKFILEDATA_H
 #define SIEGE_ENGINE_PACKFILEDATA_H
 
-#include "PackFile.h"
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <new>
 
 namespace Siege
 {
@@ -26,25 +29,19 @@ struct PackFileData
         return &data[0];
     }
 
-    static PackFileData* Create(char* data, uint32_t dataSize)
+    uint32_t GetDataSize() const
     {
-        uint32_t totalDataSize = sizeof(PackFileData) + dataSize;
+        return sizeof(PackFileData) + dataSize;
+    }
 
-        void* mem = malloc(totalDataSize);
+    static PackFileData* Create(char* data, uint32_t dataSize)
+    {
+        void* mem = malloc(sizeof(PackFileData) + dataSize);
         PackFileData* fileData = new (mem) PackFileData();
-
         fileData->dataSize = dataSize;
         memcpy(&fileData->data[0], data, dataSize);
-
         return fileData;
     }
-
-    static uint32_t GetDataSize(void* objectData)
-    {
-        if (!objectData) return 0;
-        PackFileData* fileData = reinterpret_cast<PackFileData*>(objectData);
-        return sizeof(PackFileData) + fileData->dataSize;
-    }
 };
 #pragma pack(pop)
 

engine/resources/SceneData.h

@@ -19,7 +19,8 @@ struct SceneData : BinarySerialisation::BinarySerialisable
 {
     std::vector<String> entities;
 
-    void serialise(BinarySerialisation::Buffer& buffer, BinarySerialisation::SerialisationMode mode) override
+    void serialise(BinarySerialisation::Buffer& buffer,
+                   BinarySerialisation::SerialisationMode mode) override
     {
         BinarySerialisation::serialise(buffer, entities, mode);
     }

engine/resources/StaticMeshData.h

@@ -10,11 +10,11 @@
 #ifndef SIEGE_ENGINE_STATICMESHDATA_H
 #define SIEGE_ENGINE_STATICMESHDATA_H
 
+#include <utils/BinarySerialisation.h>
 #include <utils/Colour.h>
 #include <utils/math/vec/Hashing.h>
 #include <utils/math/vec/Vec2.h>
 #include <utils/math/vec/Vec3.h>
-#include <utils/BinarySerialisation.h>
 
 #include "PackFile.h"
 
@@ -40,7 +40,9 @@ inline bool operator!=(const BaseVertex& left, const BaseVertex& right)
     return !(left == right);
 }
 
-inline void serialise(BinarySerialisation::Buffer& buffer, BaseVertex& value, BinarySerialisation::SerialisationMode mode)
+inline void serialise(BinarySerialisation::Buffer& buffer,
+                      BaseVertex& value,
+                      BinarySerialisation::SerialisationMode mode)
 {
     serialise(buffer, value.position, mode);
     serialise(buffer, value.color, mode);
@@ -53,7 +55,8 @@ struct StaticMeshData : BinarySerialisation::BinarySerialisable
     std::vector<uint32_t> indices;
     std::vector<BaseVertex> vertices;
 
-    void serialise(BinarySerialisation::Buffer& buffer, BinarySerialisation::SerialisationMode mode) override
+    void serialise(BinarySerialisation::Buffer& buffer,
+                   BinarySerialisation::SerialisationMode mode) override
     {
         BinarySerialisation::serialise(buffer, indices, mode);
         BinarySerialisation::serialise(buffer, vertices, mode);