Removed all usages of binary serialisable interface, replaced with inline templates

Author: jonjondev

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

@@ -9,14 +9,14 @@
 
 #include "Texture2D.h"
 
+#include <resources/PackFile.h>
+#include <resources/ResourceSystem.h>
+#include <resources/Texture2DData.h>
 #include <utils/Defer.h>
 
 #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"
 #include "utils/TypeAdaptor.h"
 

engine/resources/PackFile.h

@@ -19,6 +19,9 @@
 #include <map>
 
 #include "PackFileData.h"
+#include "SceneData.h"
+#include "StaticMeshData.h"
+#include "Texture2DData.h"
 
 #define PACKER_MAGIC_NUMBER_FILE "pck"
 #define PACKER_MAGIC_NUMBER_TOC "toc!"
@@ -83,11 +86,11 @@ class PackFile
             return nullptr;
         }
 
-        BinarySerialisation::Buffer buffer;
-        buffer.Fill(reinterpret_cast<uint8_t*>(packFileData->data), packFileData->dataSize);
+        BinarySerialisation::Buffer dataBuffer;
+        dataBuffer.Fill(reinterpret_cast<uint8_t*>(packFileData->data), packFileData->dataSize);
 
         T* typedData = new T();
-        typedData->serialise(buffer, BinarySerialisation::DESERIALISE);
+        BinarySerialisation::serialise(dataBuffer, *typedData, BinarySerialisation::DESERIALISE);
 
         return std::shared_ptr<T>(typedData);
     }

engine/resources/SceneData.h

@@ -15,17 +15,21 @@
 namespace Siege
 {
 
-struct SceneData : BinarySerialisation::BinarySerialisable
+struct SceneData
 {
     std::vector<String> entities;
-
-    void serialise(BinarySerialisation::Buffer& buffer,
-                   BinarySerialisation::SerialisationMode mode) override
-    {
-        BinarySerialisation::serialise(buffer, entities, mode);
-    }
 };
 
+namespace BinarySerialisation
+{
+
+inline void serialise(Buffer& buffer, SceneData& value, SerialisationMode mode)
+{
+    serialise(buffer, value.entities, mode);
+}
+
+} // namespace BinarySerialisation
+
 } // namespace Siege
 
 #endif // SIEGE_ENGINE_SCENEDATA_H

engine/resources/StaticMeshData.h

@@ -50,19 +50,23 @@ inline void serialise(BinarySerialisation::Buffer& buffer,
     serialise(buffer, value.uv, mode);
 }
 
-struct StaticMeshData : BinarySerialisation::BinarySerialisable
+struct StaticMeshData
 {
     std::vector<uint32_t> indices;
     std::vector<BaseVertex> vertices;
-
-    void serialise(BinarySerialisation::Buffer& buffer,
-                   BinarySerialisation::SerialisationMode mode) override
-    {
-        BinarySerialisation::serialise(buffer, indices, mode);
-        BinarySerialisation::serialise(buffer, vertices, mode);
-    }
 };
 
+namespace BinarySerialisation
+{
+
+inline void serialise(Buffer& buffer, StaticMeshData& value, SerialisationMode mode)
+{
+    serialise(buffer, value.indices, mode);
+    serialise(buffer, value.vertices, mode);
+}
+
+} // namespace BinarySerialisation
+
 } // namespace Siege
 
 namespace std

engine/resources/Texture2DData.h

@@ -12,15 +12,13 @@
 
 #include <utils/BinarySerialisation.h>
 
-#include "PackFile.h"
-
 // TODO - Remove this hard-coded value and support various texture channel sizes
 #define TEXTURE2D_TEXTURE_CHANNELS 4
 
 namespace Siege
 {
 
-struct Texture2DData : BinarySerialisation::BinarySerialisable
+struct Texture2DData
 {
     int32_t texWidth = 0;
     int32_t texHeight = 0;
@@ -29,19 +27,23 @@ struct Texture2DData : BinarySerialisation::BinarySerialisable
 
     uint64_t GetImageSize() const
     {
-        return texWidth * texHeight * TEXTURE2D_TEXTURE_CHANNELS;
-    }
-
-    void serialise(BinarySerialisation::Buffer& buffer,
-                   BinarySerialisation::SerialisationMode mode) override
-    {
-        BinarySerialisation::serialise(buffer, texWidth, mode);
-        BinarySerialisation::serialise(buffer, texHeight, mode);
-        BinarySerialisation::serialise(buffer, texChannels, mode);
-        BinarySerialisation::serialise(buffer, pixels, mode);
+        return texWidth * texHeight * texChannels;
     }
 };
 
+namespace BinarySerialisation
+{
+
+inline void serialise(Buffer& buffer, Texture2DData& value, SerialisationMode mode)
+{
+    serialise(buffer, value.texWidth, mode);
+    serialise(buffer, value.texHeight, mode);
+    serialise(buffer, value.texChannels, mode);
+    serialise(buffer, value.pixels, mode);
+}
+
+} // namespace BinarySerialisation
+
 } // namespace Siege
 
 #endif // SIEGE_ENGINE_TEXTURE2DDATA_H

engine/utils/BinarySerialisation.h

@@ -56,13 +56,6 @@ struct Buffer
     }
 };
 
-struct BinarySerialisable
-{
-    virtual ~BinarySerialisable() = default;
-
-    virtual void serialise(Buffer& buffer, SerialisationMode mode) {}
-};
-
 template<typename T>
 void serialiseNative(Buffer& buffer, T& value, SerialisationMode mode)
 {
@@ -253,12 +246,6 @@ void serialise(Buffer& buffer, std::map<T1, T2>& value, SerialisationMode mode)
     }
 }
 
-template<typename T>
-void serialise(Buffer& buffer, T& value, SerialisationMode mode)
-{
-    value.serialise(buffer, mode);
-}
-
 } // namespace Siege::BinarySerialisation
 
 #endif // SIEGE_ENGINE_BINARYSERIALISATION_H

packer/src/types/GenericFileDataPacker.cpp

@@ -10,6 +10,7 @@
 #include "GenericFileDataPacker.h"
 
 #include <resources/PackFileData.h>
+#include <utils/Defer.h>
 #include <utils/Logging.h>
 
 #include <fstream>
@@ -25,7 +26,7 @@ Siege::PackFileData* PackGenericFile(const Siege::String& filePath)
 
     // Since we consumed the entire file, we can tell the size by checking where
     // the file stream is reading from (which presumably is at the end of the file).
-    uint32_t fileSize = static_cast<uint32_t>(file.tellg());
+    uint32_t fileSize = file.tellg();
     char* data = static_cast<char*>(malloc(fileSize));
     defer([&data] { free(data); });
 

packer/src/types/SceneDataPacker.cpp

@@ -36,7 +36,9 @@ Siege::PackFileData* PackSceneFile(const Siege::String& filePath)
     }
 
     Siege::BinarySerialisation::Buffer dataBuffer;
-    sceneData.serialise(dataBuffer, Siege::BinarySerialisation::SERIALISE);
+    Siege::BinarySerialisation::serialise(dataBuffer,
+                                          sceneData,
+                                          Siege::BinarySerialisation::SERIALISE);
 
     char* data = reinterpret_cast<char*>(dataBuffer.data.data());
     Siege::PackFileData* fileData = Siege::PackFileData::Create(data, dataBuffer.data.size());

packer/src/types/StaticMeshDataPacker.cpp

@@ -221,7 +221,9 @@ Siege::PackFileData* PackStaticMeshFile(const Siege::String& filePath,
                      staticMeshData.indices);
 
     Siege::BinarySerialisation::Buffer dataBuffer;
-    staticMeshData.serialise(dataBuffer, Siege::BinarySerialisation::SERIALISE);
+    Siege::BinarySerialisation::serialise(dataBuffer,
+                                          staticMeshData,
+                                          Siege::BinarySerialisation::SERIALISE);
 
     char* data = reinterpret_cast<char*>(dataBuffer.data.data());
     Siege::PackFileData* fileData = Siege::PackFileData::Create(data, dataBuffer.data.size());

packer/src/types/Texture2DDataPacker.cpp

@@ -36,7 +36,9 @@ Siege::PackFileData* PackTexture2DFile(const Siege::String& filePath)
     std::copy_n(pixels, texture2dData.GetImageSize(), std::back_inserter(texture2dData.pixels));
 
     Siege::BinarySerialisation::Buffer dataBuffer;
-    texture2dData.serialise(dataBuffer, Siege::BinarySerialisation::SERIALISE);
+    Siege::BinarySerialisation::serialise(dataBuffer,
+                                          texture2dData,
+                                          Siege::BinarySerialisation::SERIALISE);
 
     char* data = reinterpret_cast<char*>(dataBuffer.data.data());
     Siege::PackFileData* fileData = Siege::PackFileData::Create(data, dataBuffer.data.size());