Updated texture2d serialisation to use binary serialiser

Author: jonjondev

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

@@ -14,6 +14,7 @@
 #include "Constants.h"
 #include "Context.h"
 #include "render/renderer/buffer/Buffer.h"
+#include "resources/PackFileData.h"
 #include "resources/ResourceSystem.h"
 #include "resources/Texture2DData.h"
 #include "utils/Descriptor.h"
@@ -93,14 +94,21 @@ Texture2D& Texture2D::operator=(Texture2D&& other)
 void Texture2D::LoadFromFile(const char* filePath)
 {
     PackFile* packFile = ResourceSystem::GetInstance().GetPackFile();
-    std::shared_ptr<Texture2DData> texture2dData = packFile->FindData<Texture2DData>(filePath);
-    uint64_t imageSize = texture2dData->GetImageSize();
-    const uint8_t* pixelPtr = texture2dData->GetPixels();
+    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);
 
     Buffer::Buffer stagingBuffer;
     defer([&stagingBuffer] { Buffer::DestroyBuffer(stagingBuffer); });
 
-    Buffer::CreateBuffer(imageSize,
+    Buffer::CreateBuffer(texture2dData.GetImageSize(),
                          VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
                          // specifies that data is accessible on the CPU.
                          VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
@@ -109,13 +117,13 @@ void Texture2D::LoadFromFile(const char* filePath)
                          OUT stagingBuffer.buffer,
                          OUT stagingBuffer.bufferMemory);
 
-    Buffer::CopyData(stagingBuffer, imageSize, pixelPtr);
+    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/Texture2DData.h

@@ -11,61 +11,34 @@
 #define SIEGE_ENGINE_TEXTURE2DDATA_H
 
 #include "PackFile.h"
+#include <utils/BinarySerialisation.h>
 
 // TODO - Remove this hard-coded value and support various texture channel sizes
 #define TEXTURE2D_TEXTURE_CHANNELS 4
 
 namespace Siege
 {
 
-#pragma pack(push, 1)
-struct Texture2DData
+struct Texture2DData : BinarySerialisation::BinarySerialisable
 {
     int32_t texWidth = 0;
     int32_t texHeight = 0;
-    int32_t texChannels = 0;
-    uint8_t pixels[];
-
-    const uint8_t* GetPixels() const
-    {
-        return &pixels[0];
-    }
+    int32_t texChannels = TEXTURE2D_TEXTURE_CHANNELS;
+    std::vector<uint8_t> pixels;
 
     uint64_t GetImageSize() const
     {
         return texWidth * texHeight * TEXTURE2D_TEXTURE_CHANNELS;
     }
 
-    static Texture2DData* Create(uint8_t* pixels,
-                                 int32_t texWidth,
-                                 int32_t texHeight,
-                                 int32_t texChannels)
-    {
-        uint64_t imageSize = texWidth * texHeight * TEXTURE2D_TEXTURE_CHANNELS;
-        uint32_t pixelDataSize = sizeof(uint8_t) * imageSize;
-        uint32_t totalDataSize = sizeof(Texture2DData) + pixelDataSize;
-
-        void* mem = malloc(totalDataSize);
-        Texture2DData* texture2dData = new (mem) Texture2DData();
-
-        texture2dData->texWidth = texWidth;
-        texture2dData->texHeight = texHeight;
-        texture2dData->texChannels = texChannels;
-        // Ensure we get no garbage data in the pixel array
-        memset(&texture2dData->pixels[0], 0, imageSize);
-        memcpy(&texture2dData->pixels[0], pixels, sizeof(uint8_t) * imageSize);
-
-        return texture2dData;
-    }
-
-    static uint32_t GetDataSize(void* objectData)
+    void serialise(BinarySerialisation::Buffer& buffer, BinarySerialisation::SerialisationMode mode) override
     {
-        if (!objectData) return 0;
-        Texture2DData* textureData = reinterpret_cast<Texture2DData*>(objectData);
-        return sizeof(Texture2DData) + sizeof(uint8_t) * textureData->GetImageSize();
+        BinarySerialisation::serialise(buffer, texWidth, mode);
+        BinarySerialisation::serialise(buffer, texHeight, mode);
+        BinarySerialisation::serialise(buffer, texChannels, mode);
+        BinarySerialisation::serialise(buffer, pixels, mode);
     }
 };
-#pragma pack(pop)
 
 } // namespace Siege
 

engine/utils/BinarySerialisation.h

@@ -84,6 +84,7 @@ void serialiseNative(Buffer& buffer, const T& value, SerialisationMode mode)
 
 SERIALISE_NATIVE(bool)
 SERIALISE_NATIVE(char)
+SERIALISE_NATIVE(unsigned char)
 SERIALISE_NATIVE(uint32_t)
 SERIALISE_NATIVE(int32_t)
 SERIALISE_NATIVE(float)

packer/src/types/Texture2DDataPacker.cpp

@@ -11,6 +11,8 @@
 
 #define STB_IMAGE_IMPLEMENTATION
 #include <resources/Texture2DData.h>
+#include <resources/PackFileData.h>
+#include <utils/BinarySerialisation.h>
 #include <stb_image.h>
 #include <utils/Defer.h>
 #include <utils/Logging.h>
@@ -27,8 +29,18 @@ void* PackTexture2DFile(const Siege::String& filePath, uint32_t& fileSize)
                 texHeight,
                 texChannels)
 
-    Siege::Texture2DData* texture2dData =
-        Siege::Texture2DData::Create(pixels, texWidth, texHeight, texChannels);
-    fileSize = Siege::Texture2DData::GetDataSize(texture2dData);
-    return texture2dData;
+    Siege::Texture2DData texture2dData;
+    texture2dData.texWidth = texWidth;
+    texture2dData.texHeight = texHeight;
+    texture2dData.texChannels = TEXTURE2D_TEXTURE_CHANNELS;
+    std::copy_n(pixels, texture2dData.GetImageSize(), std::back_inserter(texture2dData.pixels));
+
+    Siege::BinarySerialisation::Buffer dataBuffer;
+    texture2dData.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

@@ -168,8 +168,7 @@ UTEST_F(test_ResourceSystem, LoadTextureData)
     ASSERT_TRUE(data);
     ASSERT_EQ(160000, data->GetImageSize());
 
-    const uint8_t* actualPixels = data->GetPixels();
-    ASSERT_TRUE(actualPixels);
+    ASSERT_EQ(160000, data->pixels.size());
 }
 
 UTEST_F(test_ResourceSystem, LoadSceneData)