generate type data

.gitattributes

@@ -6,3 +6,4 @@
 *.blend filter=lfs diff=lfs merge=lfs -text
 *.pzl filter=lfs diff=lfs merge=lfs -text
 *.exe filter=lfs diff=lfs merge=lfs -text
+*.glb filter=lfs diff=lfs merge=lfs -text

src/.gitattributes

@@ -1 +0,0 @@
-*.glb filter=lfs diff=lfs merge=lfs -text

src/dependency/minidef/src/CppGen.cpp

@@ -15,12 +15,15 @@ namespace WriteTemplates
 {
     constexpr char FileHeaderStart[] =
         R"END(#pragma once
-#include "Def.h"
+#include <cstdint>
 
 namespace Generated
 {
+    struct Serializer;
+    struct Deserializer;
 )END";
-    constexpr char FileCppStart[] = R"END(#include "Generated.h"
+    constexpr char FileCppStart[] = R"END(#include "Def.h"
+#include "Generated.h"
 
 namespace Generated
 {
@@ -43,8 +46,8 @@ namespace Generated
     constexpr char EnumHeader4[] =
         R"END(    struct %s
     {
-        static constexpr uint32_t Hash = %u;
         static constexpr int32_t EntryCount = %u;
+        static constexpr uint32_t Hash = %u;
         enum Enum : %s
         {
 )END";
@@ -196,8 +199,8 @@ void CppFileWriter::WriteEnums(const Def::DefinitionFile& definitions)
 
         Write(WriteTemplates::EnumHeader4,
               e.Name,
-              e.Hash,
               e.EntryCount,
+              e.Hash,
               Generated::KnownType::CName[(int32_t)e.EnumType.Native]);
         for (int32_t entryIdx = 0; entryIdx < e.EntryCount; ++entryIdx)
         {
@@ -331,3 +334,36 @@ void CppFileWriter::WriteCpp(const char* templateStr, ...)
     WriteInternal(CppWrite, templateStr, args);
     va_end(args);
 }
+
+void CppFileWriter::WriteTypeDataFile(const bx::FilePath& outDir, const Def::DefinitionFile& definitions)
+{
+    constexpr const char _4cc[] = "TDAT";
+    constexpr uint32_t version = 1;
+    bx::FilePath typeDataFilePath = outDir;
+    typeDataFilePath.join("TypeData.bin");
+
+    bx::Error err;
+    bx::FileWriter writer;
+    if (!writer.open(typeDataFilePath, false, &err))
+    {
+        LOG_ERROR(0, "Failed to open type data file to write: %s", err.getMessage().getCPtr());
+        return;
+    }
+    uint32_t size = sizeof(definitions);
+    writer.write(_4cc, 4, &err);
+    if (!err.isOk())
+    {
+        LOG_ERROR(0, "Failed to write type data: %s", err.getMessage().getCPtr());
+        writer.close();
+        return;
+    }
+    writer.write(&version, sizeof(version), &err);
+    writer.write(&size, sizeof(size), &err);
+    writer.write(&definitions, sizeof(definitions), &err);
+    if (!err.isOk())
+    {
+        LOG_ERROR(0, "Failed to write type data: %s", err.getMessage().getCPtr());
+    }
+    writer.close();
+    return;
+}

src/dependency/minidef/src/CppGen.h

@@ -29,4 +29,5 @@ struct CppFileWriter
     void GenerateCpp(const bx::FilePath& outDir, const Def::DefinitionFile& definitions);
     void Write(const char* templateStr, ...);
     void WriteCpp(const char* templateStr, ...);
+    void WriteTypeDataFile(const bx::FilePath& outDir, const Def::DefinitionFile& definitions);
 };

src/dependency/minidef/src/Gen/Def.cpp

@@ -0,0 +1,41 @@
+#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 Generated
+{
+    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 Generated

src/dependency/minidef/src/Gen/Def.h

@@ -1,2 +1,125 @@
 #pragma once
+#include "../TypeDef.h"
+// #include "../game/Log.h"
+
+#include "bx/string.h"
+#include <bx/file.h>
 #include <cstdint>
+
+#ifndef LOG_ERROR
+#define LOG_ERROR(...)
+#endif
+
+namespace Generated
+{
+    struct EmbeddedTypeDef
+    {
+        uint32_t Size = sizeof(Def::DefinitionFile);
+        Def::DefinitionFile Data;
+    };
+
+    struct Serializer
+    {
+        bx::Error Err;
+        bx::FilePath Path;
+        bx::FileWriter Writer;
+
+        bool Init(const bx::FilePath& path)
+        {
+            Path = path;
+            Writer.open(path, false, &Err);
+            return Err.isOk();
+        }
+
+        template <typename T> bool WriteT(const char* _4cc, const T& data)
+        {
+            if (!Write(_4cc, 4)) return false;
+
+            uint32_t hash = data.Hash;
+            if (!Write(&hash, sizeof(hash))) return false;
+
+            uint32_t size = sizeof(T);
+            if (!Write(&size, sizeof(size))) return false;
+
+            return Save(&data, 1, *this);
+        }
+
+        bool Write(const void* data, uint32_t size)
+        {
+            Writer.write(data, size, &Err);
+            if (!Err.isOk()) LOG_ERROR("Write error: %s", Err.getMessage().getCPtr());
+            return Err.isOk();
+        }
+
+        void Finish()
+        {
+            Writer.close();
+        }
+    };
+
+    struct Deserializer
+    {
+        bx::Error Err;
+        bx::FilePath Path;
+        bx::FileReader Reader;
+
+        bool Init(const bx::FilePath& path)
+        {
+            Path = path;
+            Reader.open(path, &Err);
+            return Err.isOk();
+        }
+
+        bool Read(void* data, uint32_t size)
+        {
+            Reader.read(data, size, &Err);
+            if (!Err.isOk()) LOG_ERROR("Read error: %s", Err.getMessage().getCPtr());
+            return Err.isOk();
+        }
+
+        template <typename T> bool ReadT(const char* _4cc, T& data)
+        {
+            char magic[5]{0};
+            if (!Read(magic, 4)) return false;
+
+            bx::StringView given{_4cc, 4};
+            bx::StringView loaded{magic, 4};
+            if (bx::strCmp(given, loaded) != 0)
+            {
+                LOG_ERROR("Magic mismatch! %s != %s", _4cc, magic);
+                return false;
+            }
+
+            uint32_t hash = 0;
+            if (!Read(&hash, sizeof(hash))) return false;
+            if (data.Hash != hash)
+            {
+                LOG_ERROR("Hash mismatch! %u != %u", data.Hash, hash);
+                return false;
+            }
+
+            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))
+            {
+                LOG_ERROR("Failed to load: %s", Err.getMessage().getCPtr());
+                return false;
+            }
+            return true;
+        }
+
+        void Finish()
+        {
+            Reader.close();
+        }
+    };
+
+    template <typename T> bool Save(const T* obj, uint32_t count, Serializer& serializer);
+    template <typename T> bool Load(T* obj, uint32_t count, Deserializer& serializer);
+} // namespace Generated

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

@@ -0,0 +1,68 @@
+#include "Def.h"
+#include "Generated.h"
+
+namespace Generated
+{
+    bool Save(const KnownType::Enum* obj, uint32_t count, Serializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+            auto val = (int32_t)obj[i];
+            isOk = Save(&val, 1, serializer) && isOk;
+        }
+        return isOk;
+    }
+    bool Load(KnownType::Enum* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+            int32_t& val = (int32_t&)obj[i];
+            isOk = Load(&val, 1, serializer) && isOk;
+        }
+        return isOk;
+    }
+    bool Save(const Test* obj, uint32_t count, Serializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+            isOk = Save(&obj[i].Number, 1, serializer) && isOk;
+        }
+        return isOk;
+    }
+    bool Load(Test* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+            isOk = Load(&obj[i].Number, 1, serializer) && isOk;
+        }
+        return isOk;
+    }
+    bool Save(const Texture* obj, uint32_t count, Serializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+            isOk = Save(&obj[i].Width, 1, serializer) && isOk;
+            isOk = Save(&obj[i].Height, 1, serializer) && isOk;
+            isOk = Save(obj[i].StrTest, 3, serializer) && isOk;
+            isOk = Save(&obj[i].T, 1, serializer) && isOk;
+        }
+        return isOk;
+    }
+    bool Load(Texture* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+            isOk = Load(&obj[i].Width, 1, serializer) && isOk;
+            isOk = Load(&obj[i].Height, 1, serializer) && isOk;
+            isOk = Load(obj[i].StrTest, 3, serializer) && isOk;
+            isOk = Load(&obj[i].T, 1, serializer) && isOk;
+        }
+        return isOk;
+    }
+}

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

@@ -1,12 +1,15 @@
 #pragma once
-#include "Def.h"
+#include <cstdint>
 
 namespace Generated
 {
+    struct Serializer;
+    struct Deserializer;
     struct KnownType
     {
         static constexpr int32_t EntryCount = 12;
-        enum class Enum : int32_t
+        static constexpr uint32_t Hash = 2024002654;
+        enum Enum : int32_t
         {
             i8,
             i16,
@@ -54,13 +57,21 @@ namespace Generated
     };
     struct Test
     {
+        static constexpr uint32_t Hash = 273256278;
         uint32_t Number = {};
     };
     struct Texture
     {
+        static constexpr uint32_t Hash = 992460010;
         uint32_t Width = {};
         uint32_t Height = {};
         char StrTest[3] = {};
         Test T = {};
     };
+    bool Save(const KnownType::Enum* obj, uint32_t count, Serializer& serializer);
+    bool Load(KnownType::Enum* obj, uint32_t count, Deserializer& serializer);
+    bool Save(const Test* obj, uint32_t count, Serializer& serializer);
+    bool Load(Test* obj, uint32_t count, Deserializer& serializer);
+    bool Save(const Texture* obj, uint32_t count, Serializer& serializer);
+    bool Load(Texture* obj, uint32_t count, Deserializer& serializer);
 }

src/dependency/minidef/src/MiniDef.cpp

@@ -519,5 +519,9 @@ int main(int argc, const char** argv)
     FileParser.CalculateHashes();
     Writer.GenerateCpp(outPath, FileParser.Definitions);
 
+    LOG(0, "Writing type data file");
+    Writer.WriteTypeDataFile(outPath, FileParser.Definitions);
+    LOG(0, "Finished writing type data file!");
+
     return 0;
 }

src/game/Level.cpp

@@ -1,9 +1,12 @@
+#include "../gen/Def.h"
 #include "Global.h"
 #include "Input.h"
 #include "Instance.h"
 #include "Level.h"
 #include "Log.h"
 #include "Puzzle.h"
+#include "rendering/Rendering.h"
+
 #include "SDL3/SDL_mouse.h"
 #include "bgfx/bgfx.h"
 #include "bx/error.h"
@@ -11,7 +14,6 @@
 #include "bx/filepath.h"
 #include "bx/string.h"
 #include "imgui.h"
-#include "rendering/Rendering.h"
 #include <SDL3/SDL.h>
 #include <bx/math.h>
 #include <cstdint>

src/game/Puzzle.cpp

@@ -1,3 +1,4 @@
+#include "../gen/Def.h"
 #include "Global.h"
 #include "Instance.h"
 #include "Log.h"
@@ -192,10 +193,6 @@ namespace Puzzle
                     continue;
                 if (IsValidGoalConnection(puzzle, nextPos, currentPos, goalType))
                 {
-                    if (nextPos.X == 0 && nextPos.Y == 4)
-                    {
-                        LOG("test");
-                    }
                     if (IsValidSource(GetNodeAt(puzzle, nextPos), goalType))
                     {
                         return true;

src/game/Tools.cpp

@@ -1,6 +1,7 @@
 #include "Global.h"
 #include "Instance.h"
 #include "Tools.h"
+#include "bx/string.h"
 #include "rendering/Rendering.h"
 
 #include <imgui.h>
@@ -20,15 +21,24 @@ namespace Tools
         return "---";
     }
 
-    void ModelDropdown(uint16_t& modelHandle)
+    void ModelDropdown(uint32_t& modelHandle)
     {
         auto& R = Game::GameRendering::Get();
-        const char* name = GetAssetPath(R.Models[modelHandle].AssetHandle);
+        const char* name = GetAssetPath(modelHandle);
+        int32_t idx = -1;
+        for (int32_t i = 0; i < R.ModelCount; ++i)
+        {
+            if (R.Models[i].AssetHandle == modelHandle)
+            {
+                idx = i;
+                break;
+            }
+        }
         if (ImGui::BeginCombo("Models", name))
         {
             for (int32_t i = 0; i < R.ModelCount; ++i)
             {
-                if (ImGui::Selectable(GetAssetPath(R.Models[i].AssetHandle), i == modelHandle))
+                if (ImGui::Selectable(GetAssetPath(R.Models[i].AssetHandle), i == idx))
                 {
                     modelHandle = i;
                 }

src/game/Tools.h

@@ -3,5 +3,5 @@
 
 namespace Tools
 {
-    void ModelDropdown(uint16_t& modelHandle);
+    void ModelDropdown(uint32_t& modelHandle);
 } // namespace Tools

src/game/mini.def

@@ -59,7 +59,7 @@ enum PuzzleElementType(u8)
 type StaticPuzzleCard
 {
 	PuzzleElementType Elements     Arr(4)
-	u16               ModelHandle
+	u32               ModelHandle
 }
 
 type StaticPuzzleCardHandle

src/gen/Def.h

@@ -1,4 +1,5 @@
 #pragma once
+#include "../dependency/minidef/src/TypeDef.h"
 #include "../game/Log.h"
 
 #include "bx/string.h"
@@ -7,6 +8,12 @@
 
 namespace Generated
 {
+    struct EmbeddedTypeDef
+    {
+        uint32_t Size = sizeof(Def::DefinitionFile);
+        Def::DefinitionFile Data;
+    };
+
     struct Serializer
     {
         bx::Error Err;

src/gen/Generated.cpp

@@ -1,3 +1,4 @@
+#include "Def.h"
 #include "Generated.h"
 
 namespace Generated

src/gen/Generated.h

@@ -1,12 +1,14 @@
 #pragma once
-#include "Def.h"
+#include <cstdint>
 
 namespace Generated
 {
+    struct Serializer;
+    struct Deserializer;
     struct PuzzleElementType
     {
-        static constexpr uint32_t Hash = 2024002654;
         static constexpr int32_t EntryCount = 8;
+        static constexpr uint32_t Hash = 2024002654;
         enum Enum : int32_t
         {
             None,
@@ -100,9 +102,9 @@ namespace Generated
     };
     struct StaticPuzzleCard
     {
-        static constexpr uint32_t Hash = 2507139249;
+        static constexpr uint32_t Hash = 1414289929;
         PuzzleElementType::Enum Elements[4] = {};
-        uint16_t ModelHandle = {};
+        uint32_t ModelHandle = {};
     };
     struct StaticPuzzleCardHandle
     {
@@ -111,7 +113,7 @@ namespace Generated
     };
     struct StaticPuzzleData
     {
-        static constexpr uint32_t Hash = 3210954810;
+        static constexpr uint32_t Hash = 84985581;
         StaticPuzzleCard Cards[64] = {};
     };
     struct PuzzleCardStack