Updated static mesh serialisation to use binary serialiser

Author: jonjondev

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

@@ -11,10 +11,11 @@
 
 #include <resources/PackFile.h>
 #include <resources/ResourceSystem.h>
+#include <resources/PackFileData.h>
+#include <resources/StaticMeshData.h>
 #include <utils/Logging.h>
 
 #include "Swapchain.h"
-#include "resources/StaticMeshData.h"
 
 namespace Siege::Vulkan
 {
@@ -43,22 +44,31 @@ 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<StaticMeshData> vertexData = packFile->FindData<StaticMeshData>(filePath);
+    std::shared_ptr<PackFileData> vertexDataDataBuffer = packFile->FindData<PackFileData>(filePath);
 
-    CC_ASSERT(vertexData->verticesCount > 0, "Cannot load in a file with no vertices!")
-    CC_ASSERT(vertexData->indicesCount > 0, "Cannot load in a file with no indices!")
+    BinarySerialisation::Buffer buffer;
+    uint8_t* data = reinterpret_cast<uint8_t*>(vertexDataDataBuffer->data);
+    size_t dataSize = vertexDataDataBuffer->dataSize;
+    buffer.data.assign(data, dataSize);
 
-    CC_ASSERT(vertexData->verticesCount < MAX_VERTICES, "The provided model has too many vertices!")
-    CC_ASSERT(vertexData->indicesCount < MAX_INDICES, "The provided model has too many indices!")
+    // TODO - Fold into resource system
+    StaticMeshData staticMeshData;
+    staticMeshData.serialise(buffer, BinarySerialisation::DESERIALISE);
 
-    vertexBuffer = VertexBuffer(sizeof(BaseVertex) * vertexData->verticesCount);
-    vertexBuffer.Copy(vertexData->GetVertices(), sizeof(BaseVertex) * vertexData->verticesCount);
+    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!")
 
-    indexBuffer = IndexBuffer(sizeof(unsigned int) * vertexData->indicesCount);
-    indexBuffer.Copy(vertexData->GetIndices(), sizeof(unsigned int) * vertexData->indicesCount);
+    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 = vertexData->verticesCount;
-    indexCount = vertexData->indicesCount;
+    vertexCount = staticMeshData.vertices.size();
+    indexCount = staticMeshData.indices.size();
+
+    vertexBuffer = VertexBuffer(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);
 
     subMeshes = MHArray<SubMesh>(1);
     materials = MHArray<Material*>(1);

engine/resources/StaticMeshData.h

@@ -14,6 +14,7 @@
 #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"
 
@@ -39,50 +40,25 @@ inline bool operator!=(const BaseVertex& left, const BaseVertex& right)
     return !(left == right);
 }
 
-#pragma pack(push, 1)
-struct StaticMeshData
+inline void serialise(BinarySerialisation::Buffer& buffer, BaseVertex& value, BinarySerialisation::SerialisationMode mode)
 {
-    uint64_t indicesCount = 0;
-    uint64_t verticesCount = 0;
-    char data[];
-
-    uint32_t* GetIndices() const
-    {
-        return (uint32_t*) data;
-    }
-
-    BaseVertex* GetVertices() const
-    {
-        return (BaseVertex*) (data + sizeof(uint32_t) * indicesCount);
-    }
-
-    static StaticMeshData* Create(const std::vector<uint32_t>& objIndices,
-                                  const std::vector<BaseVertex>& objVertices)
-    {
-        uint32_t indicesDataSize = sizeof(uint32_t) * objIndices.size();
-        uint32_t verticesDataSize = sizeof(BaseVertex) * objVertices.size();
-        uint32_t totalDataSize = sizeof(StaticMeshData) + indicesDataSize + verticesDataSize;
-
-        void* mem = malloc(totalDataSize);
-        StaticMeshData* staticMeshData = new (mem) StaticMeshData();
-
-        staticMeshData->indicesCount = objIndices.size();
-        staticMeshData->verticesCount = objVertices.size();
-        memcpy(&staticMeshData->data[0], objIndices.data(), indicesDataSize);
-        memcpy(&staticMeshData->data[0] + indicesDataSize, objVertices.data(), verticesDataSize);
+    serialise(buffer, value.position, mode);
+    serialise(buffer, value.color, mode);
+    serialise(buffer, value.normal, mode);
+    serialise(buffer, value.uv, mode);
+}
 
-        return staticMeshData;
-    }
+struct StaticMeshData : BinarySerialisation::BinarySerialisable
+{
+    std::vector<uint32_t> indices;
+    std::vector<BaseVertex> vertices;
 
-    static uint32_t GetDataSize(void* objectData)
+    void serialise(BinarySerialisation::Buffer& buffer, BinarySerialisation::SerialisationMode mode) override
     {
-        if (!objectData) return 0;
-        StaticMeshData* staticMeshData = reinterpret_cast<StaticMeshData*>(objectData);
-        return sizeof(StaticMeshData) + sizeof(uint32_t) * staticMeshData->indicesCount +
-               sizeof(BaseVertex) * staticMeshData->verticesCount;
+        BinarySerialisation::serialise(buffer, indices, mode);
+        BinarySerialisation::serialise(buffer, vertices, mode);
     }
 };
-#pragma pack(pop)
 
 } // namespace Siege
 

engine/utils/BinarySerialisation.h

@@ -14,6 +14,10 @@
 #include <set>
 #include <vector>
 
+#include "math/vec/Vec.h"
+#include "math/vec/Vec2.h"
+#include "math/vec/Vec3.h"
+#include "Colour.h"
 #include "String.h"
 
 namespace Siege::BinarySerialisation
@@ -108,9 +112,29 @@ void serialiseContainer(Buffer& buffer, T& value)
     }
 }
 
-inline void serialise(Buffer& buffer, String& value, SerialisationMode mode)
+inline void serialise(Buffer& buffer, Vec2& value, SerialisationMode mode)
+{
+    serialiseNative(buffer, value.x, mode);
+    serialiseNative(buffer, value.y, mode);
+}
+
+inline void serialise(Buffer& buffer, Vec3& value, SerialisationMode mode)
+{
+    serialiseNative(buffer, value.x, mode);
+    serialiseNative(buffer, value.y, mode);
+    serialiseNative(buffer, value.z, mode);
+}
+
+inline void serialise(Buffer& buffer, FColour& value, SerialisationMode mode)
 {
+    serialiseNative(buffer, value.r, mode);
+    serialiseNative(buffer, value.g, mode);
+    serialiseNative(buffer, value.b, mode);
+    serialiseNative(buffer, value.a, mode);
+}
 
+inline void serialise(Buffer& buffer, String& value, SerialisationMode mode)
+{
     switch (mode)
     {
         case SERIALISE:

packer/src/types/StaticMeshDataPacker.cpp

@@ -12,6 +12,8 @@
 #include <assimp/postprocess.h>
 #include <assimp/scene.h>
 #include <resources/StaticMeshData.h>
+#include <resources/PackFileData.h>
+#include <utils/BinarySerialisation.h>
 #include <utils/FileSystem.h>
 #include <utils/Logging.h>
 
@@ -208,11 +210,15 @@ void* PackStaticMeshFile(const Siege::String& filePath, const Siege::String& ass
         }
     }
 
-    std::vector<Siege::BaseVertex> vertices;
-    std::vector<uint32_t> indices;
-    GetMeshesForNode(scene, scene->mRootNode, requestedNodePath, '/', baseXform, vertices, indices);
+    Siege::StaticMeshData staticMeshData;
+    GetMeshesForNode(scene, scene->mRootNode, requestedNodePath, '/', baseXform, staticMeshData.vertices, staticMeshData.indices);
 
-    Siege::StaticMeshData* staticMeshData = Siege::StaticMeshData::Create(indices, vertices);
-    fileSize = Siege::StaticMeshData::GetDataSize(staticMeshData);
-    return staticMeshData;
+    Siege::BinarySerialisation::Buffer dataBuffer;
+    staticMeshData.serialise(dataBuffer, Siege::BinarySerialisation::SERIALISE);
+
+    fileSize = dataBuffer.data.size();
+    char* data = reinterpret_cast<char*>(dataBuffer.data.data());
+
+    Siege::PackFileData* fileData = Siege::PackFileData::Create(data, fileSize);
+    return fileData;
 }

tests/src/resources/test_ResourceSystem.cpp

@@ -100,13 +100,12 @@ UTEST_F(test_ResourceSystem, LoadStaticMeshData)
 
     std::shared_ptr<StaticMeshData> data = packFile->FindData<StaticMeshData>("assets/cube.sm");
     ASSERT_TRUE(data);
-    ASSERT_EQ(36, data->indicesCount);
-    ASSERT_EQ(24, data->verticesCount);
-    ASSERT_EQ(1312, StaticMeshData::GetDataSize(data.get()));
+    ASSERT_EQ(36, data->indices.size());
+    ASSERT_EQ(24, data->vertices.size());
 
     uint32_t expectedIndices[36] {0, 1,  2, 3, 4,  5, 6, 7,  8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
                                   0, 18, 1, 3, 19, 4, 6, 20, 7, 9, 21, 10, 12, 22, 13, 15, 23, 16};
-    uint32_t* actualIndices = data->GetIndices();
+    uint32_t* actualIndices = data->indices.data();
     ASSERT_TRUE(actualIndices);
 
     bool indicesCorrect = true;
@@ -143,7 +142,7 @@ UTEST_F(test_ResourceSystem, LoadStaticMeshData)
                                      {{1, 1, -1}, {1, 1, 1, 1}, {0, 1, 0}, {0.375, 0.75}},
                                      {{1, -1, -1}, {1, 1, 1, 1}, {1, 0, 0}, {0.625, 0.75}},
                                      {{1, -1, 1}, {1, 1, 1, 1}, {0, 0, 1}, {0.625, 0.5}}};
-    BaseVertex* actualVertices = data->GetVertices();
+    BaseVertex* actualVertices = data->vertices.data();
     ASSERT_TRUE(actualVertices);
 
     bool verticesCorrect = true;