new save format

src/dependency/minidef/Logging.h

@@ -1,18 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-#define LOG(line, fmt, ...) Logging::Log(Logging::ELogType::Log, line, fmt, ##__VA_ARGS__)
-#define LOG_WARN(line, fmt, ...) Logging::Log(Logging::ELogType::Warn, line, fmt, ##__VA_ARGS__)
-#define LOG_ERROR(line, fmt, ...) Logging::Log(Logging::ELogType::Error, line, fmt, ##__VA_ARGS__)
-
-struct Logging
-{
-    enum class ELogType
-    {
-        Log,
-        Warn,
-        Error,
-    };
-    static void Log(ELogType logType, uint32_t line, const char* format, ...);
-};

src/dependency/minidef/src/CppGen.cpp

@@ -85,6 +85,8 @@ namespace Gen
         {
 )END";
     constexpr char SaveFuncBodyType3[] = R"END(            isOk = Save(%sobj[i].%s, %u, serializer) && isOk;
+)END";
+    constexpr char SaveFuncBodyNative[] = R"END(            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
 )END";
     constexpr char SaveFuncBodyEnum1[] = R"END(            auto val = (%s)obj[i];
             isOk = Save(&val, 1, serializer) && isOk;
@@ -104,6 +106,8 @@ namespace Gen
         {
 )END";
     constexpr char LoadFuncBodyType3[] = R"END(            isOk = Load(%sobj[i].%s, %u, serializer) && isOk;
+)END";
+    constexpr char LoadFuncBodyNative[] = R"END(            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
 )END";
     constexpr char LoadFuncBodyEnum2[] = R"END(            %s& val = (%s&)obj[i];
             isOk = Load(&val, 1, serializer) && isOk;
@@ -119,7 +123,7 @@ namespace Gen
     {
         uint32_t Size = 0;
         uint32_t Hash = 0;
-        const char Name[64]{"Dummy"};
+        char Name[64]{"Dummy"};
         uint16_t ChildCount = 0;
         uint16_t ChildIndices[64]{0};
     };
@@ -326,22 +330,36 @@ void CppFileWriter::WriteSaveLoadMethods(const Def::DefinitionFile& definitions)
 
         WriteCpp(WriteTemplates::SaveFuncBodyStart1, typeName);
         for (int32_t fieldIdx = 0; fieldIdx < t.FieldCount; ++fieldIdx)
+        {
+            if (Def::IsFieldNative(definitions, t, fieldIdx))
+            {
+                WriteCpp(WriteTemplates::SaveFuncBodyNative);
+            }
+            else
             {
                 WriteCpp(WriteTemplates::SaveFuncBodyType3,
                          t.FieldArraySizes[fieldIdx] > 0 ? "" : "&",
                          t.FieldNames[fieldIdx],
                          bx::max(1, t.FieldArraySizes[fieldIdx]));
             }
+        }
         WriteCpp(WriteTemplates::SaveFuncBodyEnd);
 
         WriteCpp(WriteTemplates::LoadFuncBodyStart1, typeName);
         for (int32_t fieldIdx = 0; fieldIdx < t.FieldCount; ++fieldIdx)
+        {
+            if (Def::IsFieldNative(definitions, t, fieldIdx))
+            {
+                WriteCpp(WriteTemplates::LoadFuncBodyNative);
+            }
+            else
             {
                 WriteCpp(WriteTemplates::LoadFuncBodyType3,
                          t.FieldArraySizes[fieldIdx] > 0 ? "" : "&",
                          t.FieldNames[fieldIdx],
                          bx::max(1, t.FieldArraySizes[fieldIdx]));
             }
+        }
         WriteCpp(WriteTemplates::LoadFuncBodyEnd);
     }
 }

src/dependency/minidef/src/Gen/Generated.cpp

@@ -220,7 +220,7 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Save(&obj[i].Number, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }
@@ -229,7 +229,7 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Load(&obj[i].Number, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }
@@ -238,9 +238,9 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Save(&obj[i].Width, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Save(&obj[i].Height, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Save(obj[i].StrTest, 3, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
             isOk = Save(&obj[i].T, 1, serializer) && isOk;
         }
         return isOk;
@@ -250,9 +250,9 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Load(&obj[i].Width, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Load(&obj[i].Height, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Load(obj[i].StrTest, 3, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
             isOk = Load(&obj[i].T, 1, serializer) && isOk;
         }
         return isOk;

src/dependency/minidef/src/Gen/Generated.h

@@ -104,7 +104,7 @@ namespace Gen
     {
         uint32_t Size = 0;
         uint32_t Hash = 0;
-        const char Name[64]{"Dummy"};
+        char Name[64]{"Dummy"};
         uint16_t ChildCount = 0;
         uint16_t ChildIndices[64]{0};
     };

src/dependency/minidef/src/TypeDef.h

@@ -69,4 +69,10 @@ namespace Def
         Def::Enum Enums[MaxTypes];
         int32_t EnumCount = 0;
     };
+
+    inline bool IsFieldNative(const DefinitionFile& definitions, const Type& type, int32_t fieldIdx)
+    {
+        return ((int32_t)definitions.Types[type.FieldTypes[fieldIdx].TypeIdx].TypeFlags &
+                (int32_t)ETypeFlags::IsNative) > 0;
+    }
 } // namespace Def

src/gen/Def.cpp

@@ -1,41 +1 @@
-#include "Def.h"
+// #include "Def.h"
-
-#define INST(T)                                                                                                        \
-    template bool Save<T>(const T* obj, uint32_t count, Serializer& serializer);                                       \
-    template bool Load<T>(T * obj, uint32_t count, Deserializer & serializer);
-
-namespace Gen
-{
-    template <typename T> bool Save(const T* obj, uint32_t count, Serializer& serializer)
-    {
-        bool isOk = true;
-        for (uint32_t i = 0; i < count; ++i)
-        {
-            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
-        }
-        return isOk;
-    }
-
-    template <typename T> bool Load(T* obj, uint32_t count, Deserializer& serializer)
-    {
-        bool isOk = true;
-        for (uint32_t i = 0; i < count; ++i)
-        {
-            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
-        }
-        return isOk;
-    }
-
-    INST(uint8_t)
-    INST(uint16_t)
-    INST(uint32_t)
-    INST(uint64_t)
-    INST(int8_t)
-    INST(int16_t)
-    INST(int32_t)
-    INST(int64_t)
-    INST(float)
-    INST(double)
-    INST(bool)
-    INST(char)
-} // namespace Gen

src/gen/Def.h

@@ -1,12 +1,44 @@
 #pragma once
 #include "../game/Log.h"
 
+#include "Generated.h"
 #include "bx/string.h"
 #include <bx/file.h>
 #include <cstdint>
 
 namespace Gen
 {
+    struct EmbeddedTypeTableBuffer
+    {
+        uint16_t DefCount = 0;
+        Meta::TypeDef Defs[64];
+
+        void AddDef(const Meta::TypeDef& def)
+        {
+            if (DefCount >= BX_COUNTOF(Defs))
+            {
+                LOG_WARN("Ran out of type definition space!");
+                return;
+            }
+            for (int32_t i = 0; i < DefCount; ++i)
+            {
+                if (Defs[i].Hash == def.Hash) return;
+            }
+            Defs[DefCount] = def;
+            ++DefCount;
+        }
+    };
+
+    struct EmbeddedTypeInfoHeader
+    {
+        static constexpr uint32_t CurrentHeaderVersion = 1;
+        uint32_t HeaderVersion = CurrentHeaderVersion;
+        uint32_t BaseTypeHash = 0;
+        uint16_t BaseTypeIdx = 0;
+        uint16_t TypeCount = 0;
+        uint32_t TypeDataSize = 0;
+    };
+
     struct Serializer
     {
         bx::Error Err;
@@ -41,19 +73,39 @@ namespace Gen
 
         template <typename T> bool WriteT(const T& data)
         {
-            uint32_t hash = data.Hash;
+            const Meta::TypeDef& baseDef = Meta::Metadata.TypeDefinitions[data.TypeIdx];
-            if (!Write(&hash, sizeof(hash))) return false;
 
-            uint32_t defSize = 0;
+            EmbeddedTypeTableBuffer typeBuf;
-            if (!Write(&defSize, sizeof(defSize))) return false;
+            typeBuf.AddDef(baseDef);
 
-            // auto& definitions = GetDefinitions();
+            // DefCount updates dynamically here!
-            // if (!Write(&definitions, sizeof(definitions))) return false;
+            for (int32_t i = 0; i < typeBuf.DefCount; ++i)
+            {
+                const Meta::TypeDef& def = typeBuf.Defs[i];
+                for (int32_t j = 0; j < def.ChildCount; ++j)
+                {
+                    typeBuf.AddDef(Meta::Metadata.TypeDefinitions[def.ChildIndices[j]]);
+                }
+            }
 
-            uint32_t size = sizeof(T);
+            EmbeddedTypeInfoHeader header;
-            if (!Write(&size, sizeof(size))) return false;
+            header.BaseTypeHash = baseDef.Hash;
+            header.BaseTypeIdx = 0;
+            header.TypeCount = typeBuf.DefCount;
+            header.TypeDataSize = header.TypeCount * sizeof(Meta::TypeDef);
 
-            return Save(&data, 1, *this);
+            if (!Write(&header, sizeof(header))) return false;
+            for (int32_t i = 0; i < typeBuf.DefCount; ++i)
+            {
+                if (!Write(&typeBuf.Defs[i], sizeof(typeBuf.Defs[i]))) return false;
+            }
+
+            if (!Save(&data, 1, *this))
+            {
+                LOG_ERROR("Failed to save!");
+                return false;
+            }
+            return true;
         }
 
         bool Write(const void* data, uint32_t size)
@@ -117,34 +169,33 @@ namespace Gen
 
         template <typename T> bool ReadT(T& data)
         {
-            uint32_t hash = 0;
+            EmbeddedTypeInfoHeader header;
-            if (!Read(&hash, sizeof(hash))) return false;
+            if (!Read(&header, sizeof(header))) return false;
 
-            uint32_t defSize = 0;
+            if (header.HeaderVersion != EmbeddedTypeInfoHeader::CurrentHeaderVersion)
-            if (!Read(&defSize, sizeof(defSize))) return false;
-
-            if (data.Hash != hash)
             {
-                LOG_WARN("Hash mismatch! %u != %u", data.Hash, hash);
+                // TODO: upgrade
+                LOG_ERROR("Header version mismatch: %u != %u",
+                          header.HeaderVersion,
+                          EmbeddedTypeInfoHeader::CurrentHeaderVersion);
+                return false;
+            }
 
-                // TODO: figure out upgrade data
+            const Meta::TypeDef& baseTypeDef = Meta::Metadata.TypeDefinitions[data.TypeIdx];
+            if (header.BaseTypeHash != baseTypeDef.Hash)
+            {
+                LOG_WARN("Hash mismatch! %u != %u", header.BaseTypeHash, baseTypeDef.Hash);
+
+                // TODO: patch data
                 data = {};
-                return true;
+                return false;
             }
             else
             {
                 LOG("Hash match!");
 
                 // Skip definitions, we know they match
-                Reader.seek(defSize);
+                Reader.seek(header.TypeDataSize);
-
-                uint32_t size = 0;
-                if (!Read(&size, sizeof(size))) return false;
-                if (sizeof(T) != size)
-                {
-                    LOG_ERROR("Size mismatch! %u != %u", sizeof(T), size);
-                    return false;
-                }
 
                 if (!Load(&data, 1, *this))
                 {

src/gen/Generated.cpp

@@ -8,7 +8,7 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            auto val = (int32_t)obj[i];
+            auto val = (uint8_t)obj[i];
             isOk = Save(&val, 1, serializer) && isOk;
         }
         return isOk;
@@ -18,7 +18,7 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            int32_t& val = (int32_t&)obj[i];
+            uint8_t& val = (uint8_t&)obj[i];
             isOk = Load(&val, 1, serializer) && isOk;
         }
         return isOk;
@@ -43,13 +43,205 @@ namespace Gen
         }
         return isOk;
     }
+    bool Save(const int8_t* obj, uint32_t count, Serializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
+    bool Load(int8_t* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
+    bool Save(const int16_t* obj, uint32_t count, Serializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
+    bool Load(int16_t* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
+    bool Save(const int32_t* obj, uint32_t count, Serializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
+    bool Load(int32_t* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
+    bool Save(const int64_t* obj, uint32_t count, Serializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
+    bool Load(int64_t* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
+    bool Save(const uint8_t* obj, uint32_t count, Serializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
+    bool Load(uint8_t* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
+    bool Save(const uint16_t* obj, uint32_t count, Serializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
+    bool Load(uint16_t* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
+    bool Save(const uint32_t* obj, uint32_t count, Serializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
+    bool Load(uint32_t* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
+    bool Save(const uint64_t* obj, uint32_t count, Serializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
+    bool Load(uint64_t* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
+    bool Save(const bool* obj, uint32_t count, Serializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
+    bool Load(bool* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
+    bool Save(const float* obj, uint32_t count, Serializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
+    bool Load(float* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
+    bool Save(const double* obj, uint32_t count, Serializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
+    bool Load(double* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
+    bool Save(const char* obj, uint32_t count, Serializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
+    bool Load(char* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+        }
+        return isOk;
+    }
     bool Save(const Vec2* obj, uint32_t count, Serializer& serializer)
     {
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Save(&obj[i].x, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Save(&obj[i].y, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }
@@ -58,8 +250,8 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Load(&obj[i].x, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Load(&obj[i].y, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }
@@ -68,9 +260,9 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Save(&obj[i].x, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Save(&obj[i].y, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Save(&obj[i].z, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }
@@ -79,9 +271,9 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Load(&obj[i].x, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Load(&obj[i].y, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Load(&obj[i].z, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }
@@ -90,10 +282,10 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Save(&obj[i].x, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Save(&obj[i].y, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Save(&obj[i].z, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Save(&obj[i].w, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }
@@ -102,10 +294,10 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Load(&obj[i].x, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Load(&obj[i].y, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Load(&obj[i].z, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Load(&obj[i].w, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }
@@ -114,7 +306,7 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Save(obj[i].M, 9, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }
@@ -123,7 +315,7 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Load(obj[i].M, 9, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }
@@ -132,7 +324,7 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Save(obj[i].M, 16, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }
@@ -141,7 +333,7 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Load(obj[i].M, 16, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }
@@ -176,7 +368,7 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Save(&obj[i].Idx, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }
@@ -185,7 +377,7 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Load(&obj[i].Idx, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }
@@ -194,7 +386,7 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Save(&obj[i].ModelIdx, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
             isOk = Save(&obj[i].Asset, 1, serializer) && isOk;
         }
         return isOk;
@@ -204,7 +396,7 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Load(&obj[i].ModelIdx, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
             isOk = Load(&obj[i].Asset, 1, serializer) && isOk;
         }
         return isOk;
@@ -214,7 +406,7 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Save(&obj[i].TextureIdx, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
             isOk = Save(&obj[i].Asset, 1, serializer) && isOk;
         }
         return isOk;
@@ -224,7 +416,7 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Load(&obj[i].TextureIdx, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
             isOk = Load(&obj[i].Asset, 1, serializer) && isOk;
         }
         return isOk;
@@ -234,8 +426,8 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Save(&obj[i].X, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Save(&obj[i].Y, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }
@@ -244,8 +436,8 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Load(&obj[i].X, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Load(&obj[i].Y, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }
@@ -254,7 +446,7 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Save(obj[i].Elements, 4, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
             isOk = Save(&obj[i].ModelHandle, 1, serializer) && isOk;
             isOk = Save(&obj[i].BoardTextureHandle, 1, serializer) && isOk;
         }
@@ -265,7 +457,7 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Load(obj[i].Elements, 4, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
             isOk = Load(&obj[i].ModelHandle, 1, serializer) && isOk;
             isOk = Load(&obj[i].BoardTextureHandle, 1, serializer) && isOk;
         }
@@ -276,7 +468,7 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Save(&obj[i].Idx, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }
@@ -285,7 +477,7 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Load(&obj[i].Idx, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }
@@ -337,8 +529,8 @@ namespace Gen
         for (uint32_t i = 0; i < count; ++i)
         {
             isOk = Save(&obj[i].RefCard, 1, serializer) && isOk;
-            isOk = Save(&obj[i].MaxAvailableCount, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Save(&obj[i].UsedCount, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }
@@ -348,8 +540,8 @@ namespace Gen
         for (uint32_t i = 0; i < count; ++i)
         {
             isOk = Load(&obj[i].RefCard, 1, serializer) && isOk;
-            isOk = Load(&obj[i].MaxAvailableCount, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Load(&obj[i].UsedCount, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }
@@ -360,8 +552,8 @@ namespace Gen
         {
             isOk = Save(&obj[i].RefCard, 1, serializer) && isOk;
             isOk = Save(&obj[i].Position, 1, serializer) && isOk;
-            isOk = Save(&obj[i].Rotation, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Save(&obj[i].IsLocked, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }
@@ -372,8 +564,8 @@ namespace Gen
         {
             isOk = Load(&obj[i].RefCard, 1, serializer) && isOk;
             isOk = Load(&obj[i].Position, 1, serializer) && isOk;
-            isOk = Load(&obj[i].Rotation, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Load(&obj[i].IsLocked, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }
@@ -382,15 +574,15 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Save(&obj[i].ID, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Save(obj[i].PuzzleName, 64, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Save(&obj[i].WidthTiles, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Save(&obj[i].HeightTiles, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Save(&obj[i].AvailableCardCount, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
             isOk = Save(obj[i].AvailableCards, 16, serializer) && isOk;
             isOk = Save(obj[i].PlacedCards, 256, serializer) && isOk;
-            isOk = Save(obj[i].BackgroundTiles, 1024, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Save(&obj[i].GoalPositionCount, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
             isOk = Save(obj[i].GoalPositions, 16, serializer) && isOk;
         }
         return isOk;
@@ -400,15 +592,15 @@ namespace Gen
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
-            isOk = Load(&obj[i].ID, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Load(obj[i].PuzzleName, 64, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Load(&obj[i].WidthTiles, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Load(&obj[i].HeightTiles, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Load(&obj[i].AvailableCardCount, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
             isOk = Load(obj[i].AvailableCards, 16, serializer) && isOk;
             isOk = Load(obj[i].PlacedCards, 256, serializer) && isOk;
-            isOk = Load(obj[i].BackgroundTiles, 1024, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
-            isOk = Load(&obj[i].GoalPositionCount, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
             isOk = Load(obj[i].GoalPositions, 16, serializer) && isOk;
         }
         return isOk;
@@ -421,10 +613,10 @@ namespace Gen
             isOk = Save(&obj[i].BaseColor, 1, serializer) && isOk;
             isOk = Save(&obj[i].HighlightColor, 1, serializer) && isOk;
             isOk = Save(&obj[i].TF, 1, serializer) && isOk;
-            isOk = Save(&obj[i].Material, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
             isOk = Save(&obj[i].Texture, 1, serializer) && isOk;
             isOk = Save(&obj[i].Model, 1, serializer) && isOk;
-            isOk = Save(&obj[i].Visible, 1, serializer) && isOk;
+            isOk = serializer.Write(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }
@@ -436,10 +628,10 @@ namespace Gen
             isOk = Load(&obj[i].BaseColor, 1, serializer) && isOk;
             isOk = Load(&obj[i].HighlightColor, 1, serializer) && isOk;
             isOk = Load(&obj[i].TF, 1, serializer) && isOk;
-            isOk = Load(&obj[i].Material, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
             isOk = Load(&obj[i].Texture, 1, serializer) && isOk;
             isOk = Load(&obj[i].Model, 1, serializer) && isOk;
-            isOk = Load(&obj[i].Visible, 1, serializer) && isOk;
+            isOk = serializer.Read(&obj[i], sizeof(obj[i])) && isOk;
         }
         return isOk;
     }

src/gen/Generated.h

@@ -7,9 +7,9 @@ namespace Gen
     struct Deserializer;
     struct PuzzleElementType
     {
+        static constexpr uint16_t EnumIdx = 0;
         static constexpr int32_t EntryCount = 8;
-        static constexpr uint32_t Hash = 2024002654;
+        enum Enum : uint8_t
-        enum Enum : int32_t
         {
             None,
             WaterIn,
@@ -56,8 +56,8 @@ namespace Gen
     };
     struct EMaterial
     {
+        static constexpr uint16_t EnumIdx = 1;
         static constexpr int32_t EntryCount = 2;
-        static constexpr uint32_t Hash = 2024002654;
         enum Enum : int32_t
         {
             Default,
@@ -71,20 +71,20 @@ namespace Gen
     };
     struct Vec2
     {
-        static constexpr uint32_t Hash = 2667033957;
+        static constexpr uint16_t TypeIdx = 12;
         float x = {};
         float y = {};
     };
     struct Vec3
     {
-        static constexpr uint32_t Hash = 473740858;
+        static constexpr uint16_t TypeIdx = 13;
         float x = {};
         float y = {};
         float z = {};
     };
     struct Vec4
     {
-        static constexpr uint32_t Hash = 2507696603;
+        static constexpr uint16_t TypeIdx = 14;
         float x = {};
         float y = {};
         float z = {};
@@ -92,7 +92,7 @@ namespace Gen
     };
     struct Mat3
     {
-        static constexpr uint32_t Hash = 3364737048;
+        static constexpr uint16_t TypeIdx = 15;
         float M[9] = {
 	1.0f, 0.0f, 0.0f,
 	0.0f, 1.0f, 0.0f,
@@ -101,7 +101,7 @@ namespace Gen
     };
     struct Mat4
     {
-        static constexpr uint32_t Hash = 1650094019;
+        static constexpr uint16_t TypeIdx = 16;
         float M[16] = {
 	1.0f, 0.0f, 0.0f, 0.0f,
 	0.0f, 1.0f, 0.0f, 0.0f,
@@ -111,7 +111,7 @@ namespace Gen
     };
     struct Transform
     {
-        static constexpr uint32_t Hash = 4103530190;
+        static constexpr uint16_t TypeIdx = 17;
         Mat4 M = {};
         Mat4 MI = {};
         Vec3 Position = {};
@@ -120,62 +120,62 @@ namespace Gen
     };
     struct AssetHandle
     {
-        static constexpr uint32_t Hash = 2609735487;
+        static constexpr uint16_t TypeIdx = 18;
         uint32_t Idx = UINT32_MAX;
     };
     struct ModelHandle
     {
-        static constexpr uint32_t Hash = 298089627;
+        static constexpr uint16_t TypeIdx = 19;
         uint16_t ModelIdx = UINT16_MAX;
         AssetHandle Asset = {};
     };
     struct TextureHandle
     {
-        static constexpr uint32_t Hash = 1633273761;
+        static constexpr uint16_t TypeIdx = 20;
         uint16_t TextureIdx = UINT16_MAX;
         AssetHandle Asset = {};
     };
     struct PuzPos
     {
-        static constexpr uint32_t Hash = 1834398141;
+        static constexpr uint16_t TypeIdx = 21;
         int8_t X = {};
         int8_t Y = {};
     };
     struct StaticPuzzleCard
     {
-        static constexpr uint32_t Hash = 431895198;
+        static constexpr uint16_t TypeIdx = 22;
         PuzzleElementType::Enum Elements[4] = {};
         ModelHandle ModelHandle = {};
         TextureHandle BoardTextureHandle = {};
     };
     struct StaticPuzzleCardHandle
     {
-        static constexpr uint32_t Hash = 1742502768;
+        static constexpr uint16_t TypeIdx = 23;
         uint16_t Idx = UINT16_MAX;
     };
     struct PuzzleVisualSettings
     {
-        static constexpr uint32_t Hash = 4208425878;
+        static constexpr uint16_t TypeIdx = 24;
         Vec4 TileBaseColor = {};
         Vec4 TileDotColor = {};
         Vec4 DisabledCardTint = {};
     };
     struct StaticPuzzleData
     {
-        static constexpr uint32_t Hash = 1076634601;
+        static constexpr uint16_t TypeIdx = 25;
         StaticPuzzleCard Cards[64] = {};
         PuzzleVisualSettings Visuals = {};
     };
     struct PuzzleCardStack
     {
-        static constexpr uint32_t Hash = 53538532;
+        static constexpr uint16_t TypeIdx = 26;
         StaticPuzzleCardHandle RefCard = {};
         uint8_t MaxAvailableCount = {};
         uint8_t UsedCount = {};
     };
     struct PlacedPuzzleCard
     {
-        static constexpr uint32_t Hash = 3555575973;
+        static constexpr uint16_t TypeIdx = 27;
         StaticPuzzleCardHandle RefCard = {};
         PuzPos Position = {};
         uint8_t Rotation = {};
@@ -183,7 +183,7 @@ namespace Gen
     };
     struct PuzzleData
     {
-        static constexpr uint32_t Hash = 657000000;
+        static constexpr uint16_t TypeIdx = 28;
         uint16_t ID = {};
         char PuzzleName[64] = {};
         uint8_t WidthTiles = {};
@@ -197,7 +197,7 @@ namespace Gen
     };
     struct SavedEntityRenderData
     {
-        static constexpr uint32_t Hash = 3172756855;
+        static constexpr uint16_t TypeIdx = 29;
         Vec4 BaseColor = {};
         Vec4 HighlightColor = {};
         Transform TF = {};
@@ -210,6 +210,30 @@ namespace Gen
     bool Load(PuzzleElementType::Enum* obj, uint32_t count, Deserializer& serializer);
     bool Save(const EMaterial::Enum* obj, uint32_t count, Serializer& serializer);
     bool Load(EMaterial::Enum* obj, uint32_t count, Deserializer& serializer);
+    bool Save(const int8_t* obj, uint32_t count, Serializer& serializer);
+    bool Load(int8_t* obj, uint32_t count, Deserializer& serializer);
+    bool Save(const int16_t* obj, uint32_t count, Serializer& serializer);
+    bool Load(int16_t* obj, uint32_t count, Deserializer& serializer);
+    bool Save(const int32_t* obj, uint32_t count, Serializer& serializer);
+    bool Load(int32_t* obj, uint32_t count, Deserializer& serializer);
+    bool Save(const int64_t* obj, uint32_t count, Serializer& serializer);
+    bool Load(int64_t* obj, uint32_t count, Deserializer& serializer);
+    bool Save(const uint8_t* obj, uint32_t count, Serializer& serializer);
+    bool Load(uint8_t* obj, uint32_t count, Deserializer& serializer);
+    bool Save(const uint16_t* obj, uint32_t count, Serializer& serializer);
+    bool Load(uint16_t* obj, uint32_t count, Deserializer& serializer);
+    bool Save(const uint32_t* obj, uint32_t count, Serializer& serializer);
+    bool Load(uint32_t* obj, uint32_t count, Deserializer& serializer);
+    bool Save(const uint64_t* obj, uint32_t count, Serializer& serializer);
+    bool Load(uint64_t* obj, uint32_t count, Deserializer& serializer);
+    bool Save(const bool* obj, uint32_t count, Serializer& serializer);
+    bool Load(bool* obj, uint32_t count, Deserializer& serializer);
+    bool Save(const float* obj, uint32_t count, Serializer& serializer);
+    bool Load(float* obj, uint32_t count, Deserializer& serializer);
+    bool Save(const double* obj, uint32_t count, Serializer& serializer);
+    bool Load(double* obj, uint32_t count, Deserializer& serializer);
+    bool Save(const char* obj, uint32_t count, Serializer& serializer);
+    bool Load(char* obj, uint32_t count, Deserializer& serializer);
     bool Save(const Vec2* obj, uint32_t count, Serializer& serializer);
     bool Load(Vec2* obj, uint32_t count, Deserializer& serializer);
     bool Save(const Vec3* obj, uint32_t count, Serializer& serializer);
@@ -246,4 +270,65 @@ namespace Gen
     bool Load(PuzzleData* obj, uint32_t count, Deserializer& serializer);
     bool Save(const SavedEntityRenderData* obj, uint32_t count, Serializer& serializer);
     bool Load(SavedEntityRenderData* obj, uint32_t count, Deserializer& serializer);
+
+    namespace Meta {
+    struct TypeDef
+    {
+        uint32_t Size = 0;
+        uint32_t Hash = 0;
+        char Name[64]{"Dummy"};
+        uint16_t ChildCount = 0;
+        uint16_t ChildIndices[64]{0};
+    };
+
+    struct EnumDef
+    {
+        uint32_t Size = 0;
+        uint32_t Hash = 0;
+    };
+
+    struct MetadataTable
+    {
+        TypeDef TypeDefinitions[30]
+        {
+            TypeDef{sizeof(int8_t), 0, "i8", 0, {}},
+            TypeDef{sizeof(int16_t), 1, "i16", 0, {}},
+            TypeDef{sizeof(int32_t), 2, "i32", 0, {}},
+            TypeDef{sizeof(int64_t), 3, "i64", 0, {}},
+            TypeDef{sizeof(uint8_t), 4, "u8", 0, {}},
+            TypeDef{sizeof(uint16_t), 5, "u16", 0, {}},
+            TypeDef{sizeof(uint32_t), 6, "u32", 0, {}},
+            TypeDef{sizeof(uint64_t), 7, "u64", 0, {}},
+            TypeDef{sizeof(bool), 8, "b", 0, {}},
+            TypeDef{sizeof(float), 9, "f32", 0, {}},
+            TypeDef{sizeof(double), 10, "f64", 0, {}},
+            TypeDef{sizeof(char), 11, "str", 0, {}},
+            TypeDef{sizeof(Vec2), 2667033957, "Vec2", 2, {9, 9}},
+            TypeDef{sizeof(Vec3), 473740858, "Vec3", 3, {9, 9, 9}},
+            TypeDef{sizeof(Vec4), 2507696603, "Vec4", 4, {9, 9, 9, 9}},
+            TypeDef{sizeof(Mat3), 3364737048, "Mat3", 1, {9}},
+            TypeDef{sizeof(Mat4), 1650094019, "Mat4", 1, {9}},
+            TypeDef{sizeof(Transform), 4103530190, "Transform", 5, {16, 16, 13, 16, 13}},
+            TypeDef{sizeof(AssetHandle), 2609735487, "AssetHandle", 1, {6}},
+            TypeDef{sizeof(ModelHandle), 298089627, "ModelHandle", 2, {5, 18}},
+            TypeDef{sizeof(TextureHandle), 1633273761, "TextureHandle", 2, {5, 18}},
+            TypeDef{sizeof(PuzPos), 1834398141, "PuzPos", 2, {0, 0}},
+            TypeDef{sizeof(StaticPuzzleCard), 3413177578, "StaticPuzzleCard", 3, {0, 19, 20}},
+            TypeDef{sizeof(StaticPuzzleCardHandle), 1742502768, "StaticPuzzleCardHandle", 1, {5}},
+            TypeDef{sizeof(PuzzleVisualSettings), 4208425878, "PuzzleVisualSettings", 3, {14, 14, 14}},
+            TypeDef{sizeof(StaticPuzzleData), 423465540, "StaticPuzzleData", 2, {22, 24}},
+            TypeDef{sizeof(PuzzleCardStack), 53538532, "PuzzleCardStack", 3, {23, 4, 4}},
+            TypeDef{sizeof(PlacedPuzzleCard), 3555575973, "PlacedPuzzleCard", 4, {23, 21, 4, 8}},
+            TypeDef{sizeof(PuzzleData), 3349686056, "PuzzleData", 10, {5, 11, 4, 4, 6, 26, 27, 0, 6, 21}},
+            TypeDef{sizeof(SavedEntityRenderData), 3172756855, "SavedEntityRenderData", 7, {14, 14, 17, 1, 20, 19, 8}},
+        };
+        EnumDef EnumDefinitions[2]
+        {
+            EnumDef{sizeof(PuzzleElementType::Enum), 2983807453},
+            EnumDef{sizeof(EMaterial::Enum), 2024002654},
+        };
+    };
+
+    constexpr MetadataTable Metadata;
+    }
 }

src/notes.txt

@@ -0,0 +1,24 @@
+4 bytes: 4cc
+File type idendifier
+
+16 bytes: TypeInfoHeader
+4       | 4              | 2             | 2          | 4
+Version | Base Type Hash | Base Type Idx | Type Count | Type Data Size
+// If base type hash matches, skip past type data (using type data size)
+// and just load binary blob directly
+
+TypeDataSize bytes: TypeDefs
+
+// TODO: field table
+name | array size
+test | 1
+  a | 1
+  b | 1
+  c | 1
+  d | 32
+
+// todo: enum table for upgrading strings?
+
+xxx bytes: BaseType actual data
+
+[blob]