loading works!!

.gitattributes

@@ -4,3 +4,4 @@
 *.png filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.blend filter=lfs diff=lfs merge=lfs -text
+*.pzl filter=lfs diff=lfs merge=lfs -text

src/dependency/minidef/src/CppGen.cpp

@@ -88,6 +88,25 @@ namespace Generated
         return isOk;
     }
 )END";
+
+    constexpr char LoadFuncHeader1[] =
+        R"END(    bool Load(%s* obj, uint32_t count, Deserializer& serializer);
+)END";
+    constexpr char LoadFuncBodyStart1[] = R"END(    bool Load(%s* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+)END";
+    constexpr char LoadFuncBodyType3[] = R"END(            isOk = Load(%sobj[i].%s, %u, serializer) && isOk;
+)END";
+    constexpr char LoadFuncBodyEnum1[] = R"END(            auto val = (%s)obj[i];
+            isOk = Load(&val, 1, serializer) && isOk;
+)END";
+    constexpr char LoadFuncBodyEnd[] = R"END(        }
+        return isOk;
+    }
+)END";
 } // namespace WriteTemplates
 
 void CppFileWriter::InitBuffer(WriteBuffer& buf)
@@ -220,24 +239,32 @@ void CppFileWriter::WriteTypes(const Def::DefinitionFile& definitions)
         Write(WriteTemplates::StructEnd);
     }
 }
-void CppFileWriter::WriteSaveMethods(const Def::DefinitionFile& definitions)
+void CppFileWriter::WriteSaveLoadMethods(const Def::DefinitionFile& definitions)
 {
-    char buf[64]{0};
+    char nameBuf[64]{0};
+    char fieldBuf[64]{0};
     for (int32_t enumIdx = 0; enumIdx < definitions.EnumCount; ++enumIdx)
     {
         const Def::Enum& e = definitions.Enums[enumIdx];
-        bx::snprintf(buf, sizeof(buf), "%s::Enum", e.Name);
+        bx::snprintf(nameBuf, sizeof(nameBuf), "%s::Enum", e.Name);
-        Write(WriteTemplates::SaveFuncHeader1, buf);
+        PrintTypeName(fieldBuf, sizeof(fieldBuf), e.EnumType, definitions);
 
-        WriteCpp(WriteTemplates::SaveFuncBodyStart1, buf);
+        Write(WriteTemplates::SaveFuncHeader1, nameBuf);
-        PrintTypeName(buf, sizeof(buf), e.EnumType, definitions);
+        Write(WriteTemplates::LoadFuncHeader1, nameBuf);
-        WriteCpp(WriteTemplates::SaveFuncBodyEnum1, buf);
+
+        WriteCpp(WriteTemplates::SaveFuncBodyStart1, nameBuf);
+        WriteCpp(WriteTemplates::SaveFuncBodyEnum1, fieldBuf);
         WriteCpp(WriteTemplates::SaveFuncBodyEnd);
+
+        WriteCpp(WriteTemplates::LoadFuncBodyStart1, nameBuf);
+        WriteCpp(WriteTemplates::LoadFuncBodyEnum1, fieldBuf);
+        WriteCpp(WriteTemplates::LoadFuncBodyEnd);
     }
     for (int32_t typeIdx = 0; typeIdx < definitions.TypeCount; ++typeIdx)
     {
         const Def::Type& t = definitions.Types[typeIdx];
         Write(WriteTemplates::SaveFuncHeader1, t.Name);
+        Write(WriteTemplates::LoadFuncHeader1, t.Name);
 
         WriteCpp(WriteTemplates::SaveFuncBodyStart1, t.Name);
         for (int32_t fieldIdx = 0; fieldIdx < t.FieldCount; ++fieldIdx)
@@ -248,11 +275,18 @@ void CppFileWriter::WriteSaveMethods(const Def::DefinitionFile& definitions)
                      bx::max(1, t.FieldArraySizes[fieldIdx]));
         }
         WriteCpp(WriteTemplates::SaveFuncBodyEnd);
+
+        WriteCpp(WriteTemplates::LoadFuncBodyStart1, t.Name);
+        for (int32_t fieldIdx = 0; fieldIdx < t.FieldCount; ++fieldIdx)
+        {
+            WriteCpp(WriteTemplates::LoadFuncBodyType3,
+                     t.FieldArraySizes[fieldIdx] > 0 ? "" : "&",
+                     t.FieldNames[fieldIdx],
+                     bx::max(1, t.FieldArraySizes[fieldIdx]));
+        }
+        WriteCpp(WriteTemplates::LoadFuncBodyEnd);
     }
 }
-void CppFileWriter::WriteLoadMethods(const Def::DefinitionFile& definitions)
-{
-}
 void CppFileWriter::GenerateCpp(const bx::FilePath& outDir, const Def::DefinitionFile& definitions)
 {
     LOG(0, "Generating output files...");
@@ -264,7 +298,7 @@ void CppFileWriter::GenerateCpp(const bx::FilePath& outDir, const Def::Definitio
     WriteCpp(WriteTemplates::FileCppStart);
     WriteEnums(definitions);
     WriteTypes(definitions);
-    WriteSaveMethods(definitions);
+    WriteSaveLoadMethods(definitions);
     Write(WriteTemplates::FileEnd);
     WriteCpp(WriteTemplates::FileEnd);
 

src/dependency/minidef/src/CppGen.h

@@ -24,8 +24,7 @@ struct CppFileWriter
     void PrintTypeName(char* buf, int32_t bufSize, const Def::FieldType& type, const Def::DefinitionFile& definitions);
     void WriteEnums(const Def::DefinitionFile& definitions);
     void WriteTypes(const Def::DefinitionFile& definitions);
-    void WriteSaveMethods(const Def::DefinitionFile& definitions);
+    void WriteSaveLoadMethods(const Def::DefinitionFile& definitions);
-    void WriteLoadMethods(const Def::DefinitionFile& definitions);
 
     void GenerateCpp(const bx::FilePath& outDir, const Def::DefinitionFile& definitions);
     void Write(const char* templateStr, ...);

src/game/Level.cpp

@@ -6,6 +6,10 @@
 #include "Puzzle.h"
 #include "SDL3/SDL_mouse.h"
 #include "bgfx/bgfx.h"
+#include "bx/error.h"
+#include "bx/file.h"
+#include "bx/filepath.h"
+#include "bx/string.h"
 #include "imgui.h"
 #include "rendering/Rendering.h"
 #include <SDL3/SDL.h>
@@ -72,6 +76,57 @@ namespace Game
 
         Generated::Setup(PuzzleData);
 
+        bx::Error err;
+        bx::DirectoryReader dirIter;
+        bx::FileInfo info;
+        bx::FilePath puzzleDirPath{"game/data/puzzles"};
+        uint32_t puzIdx = 0;
+        if (dirIter.open(puzzleDirPath, &err))
+        {
+            while (true)
+            {
+                int32_t readCount = dirIter.read(&info, sizeof(info), &err);
+                if (readCount == 0) break;
+                if (err.isOk())
+                {
+                    if (info.type != bx::FileType::File) continue;
+                    bx::StringView pathEnd = info.filePath.getExt();
+                    if (bx::strCmpI(pathEnd, ".pzl") != 0) continue;
+                    if (puzIdx >= BX_COUNTOF(Puzzles))
+                    {
+                        LOG_WARN("Too many puzzles!");
+                        break;
+                    }
+
+                    bx::FilePath fullPath = puzzleDirPath;
+                    fullPath.join(info.filePath);
+                    LOG("Loading %s", fullPath.getCPtr());
+
+                    Generated::Deserializer ser;
+                    ser.Init(fullPath);
+                    if (Generated::Load(&Puzzles[puzIdx].Data, 1, ser))
+                    {
+                        Puzzles[puzIdx].Setup();
+                        ++puzIdx;
+                    }
+                    else
+                    {
+                        LOG_WARN("Failed to load puzzle!");
+                    }
+                    ser.Finish();
+                }
+                else
+                {
+                    LOG_ERROR("Failed parsing file name at %s:\n%s", puzzleDirPath.getCPtr(), err.getMessage());
+                    break;
+                }
+            }
+        }
+        else
+        {
+            LOG_ERROR("Failed to open puzzle dir at %s:\n%s", puzzleDirPath.getCPtr(), err.getMessage().getCPtr());
+        }
+
         if (Cubes.Count == 0)
         {
             for (uint32_t yy = 0; yy < 11; ++yy)

src/game/Puzzle.cpp

@@ -38,7 +38,7 @@ namespace Generated
     }
     const StaticPuzzleCard& GetCard(const StaticPuzzleData& data, StaticPuzzleCardHandle H)
     {
-        // assert(IsValid(H));
+        assert(IsValid(H));
         return data.Cards[H.Idx];
     }
 
@@ -203,7 +203,7 @@ namespace Generated
         if (dataChanged)
         {
             char path[128]{0};
-            bx::snprintf(path, sizeof(path), "game/data/%s.pzl", obj.PuzzleName);
+            bx::snprintf(path, sizeof(path), "game/data/puzzles/%s.pzl", obj.PuzzleName);
             Serializer ser;
             ser.Init(path);
             if (Save(&obj, 1, ser))
@@ -231,4 +231,15 @@ namespace Generated
         lhs += rhs;
         return lhs;
     }
+    PuzPos operator-=(PuzPos lhs, const PuzPos& rhs)
+    {
+        lhs.X -= rhs.X;
+        lhs.Y -= rhs.Y;
+        return lhs;
+    }
+    PuzPos operator-(PuzPos lhs, const PuzPos& rhs)
+    {
+        lhs -= rhs;
+        return lhs;
+    }
 } // namespace Generated

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/gen/Def.h

@@ -2,17 +2,6 @@
 #include <bx/file.h>
 #include <cstdint>
 
-#define SAVE_T(T)                                                                                                      \
-    inline 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;                                                                                                   \
-    }
-
 namespace Generated
 {
     struct Serializer
@@ -40,17 +29,31 @@ namespace Generated
         }
     };
 
-    SAVE_T(uint8_t)
+    struct Deserializer
-    SAVE_T(uint16_t)
+    {
-    SAVE_T(uint32_t)
+        bx::Error Err;
-    SAVE_T(uint64_t)
+        bx::FilePath Path;
-    SAVE_T(int8_t)
+        bx::FileReader Reader;
-    SAVE_T(int16_t)
-    SAVE_T(int32_t)
-    SAVE_T(int64_t)
-    SAVE_T(float)
-    SAVE_T(double)
-    SAVE_T(bool)
-    SAVE_T(char)
 
+        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);
+            return Err.isOk();
+        }
+
+        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/gen/Generated.cpp

@@ -12,6 +12,16 @@ namespace Generated
         }
         return isOk;
     }
+    bool Load(PuzzleElementType::Enum* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+            auto val = (int32_t)obj[i];
+            isOk = Load(&val, 1, serializer) && isOk;
+        }
+        return isOk;
+    }
     bool Save(const PuzPos* obj, uint32_t count, Serializer& serializer)
     {
         bool isOk = true;
@@ -22,6 +32,16 @@ namespace Generated
         }
         return isOk;
     }
+    bool Load(PuzPos* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+            isOk = Load(&obj[i].X, 1, serializer) && isOk;
+            isOk = Load(&obj[i].Y, 1, serializer) && isOk;
+        }
+        return isOk;
+    }
     bool Save(const ElemPos* obj, uint32_t count, Serializer& serializer)
     {
         bool isOk = true;
@@ -32,6 +52,16 @@ namespace Generated
         }
         return isOk;
     }
+    bool Load(ElemPos* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+            isOk = Load(&obj[i].Position, 1, serializer) && isOk;
+            isOk = Load(&obj[i].ElemIdx, 1, serializer) && isOk;
+        }
+        return isOk;
+    }
     bool Save(const PuzzleNode* obj, uint32_t count, Serializer& serializer)
     {
         bool isOk = true;
@@ -41,6 +71,15 @@ namespace Generated
         }
         return isOk;
     }
+    bool Load(PuzzleNode* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+            isOk = Load(obj[i].PlacedTypes, 4, serializer) && isOk;
+        }
+        return isOk;
+    }
     bool Save(const StaticPuzzleCard* obj, uint32_t count, Serializer& serializer)
     {
         bool isOk = true;
@@ -51,6 +90,16 @@ namespace Generated
         }
         return isOk;
     }
+    bool Load(StaticPuzzleCard* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+            isOk = Load(obj[i].Nodes, 4, serializer) && isOk;
+            isOk = Load(&obj[i].ModelHandle, 1, serializer) && isOk;
+        }
+        return isOk;
+    }
     bool Save(const StaticPuzzleCardHandle* obj, uint32_t count, Serializer& serializer)
     {
         bool isOk = true;
@@ -60,6 +109,15 @@ namespace Generated
         }
         return isOk;
     }
+    bool Load(StaticPuzzleCardHandle* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+            isOk = Load(&obj[i].Idx, 1, serializer) && isOk;
+        }
+        return isOk;
+    }
     bool Save(const StaticPuzzleData* obj, uint32_t count, Serializer& serializer)
     {
         bool isOk = true;
@@ -69,6 +127,15 @@ namespace Generated
         }
         return isOk;
     }
+    bool Load(StaticPuzzleData* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+            isOk = Load(obj[i].Cards, 64, serializer) && isOk;
+        }
+        return isOk;
+    }
     bool Save(const PuzzleCardStack* obj, uint32_t count, Serializer& serializer)
     {
         bool isOk = true;
@@ -80,6 +147,17 @@ namespace Generated
         }
         return isOk;
     }
+    bool Load(PuzzleCardStack* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        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 = Load(&obj[i].UsedCount, 1, serializer) && isOk;
+        }
+        return isOk;
+    }
     bool Save(const PlacedPuzzleCard* obj, uint32_t count, Serializer& serializer)
     {
         bool isOk = true;
@@ -92,6 +170,18 @@ namespace Generated
         }
         return isOk;
     }
+    bool Load(PlacedPuzzleCard* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+            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 = Load(&obj[i].IsLocked, 1, serializer) && isOk;
+        }
+        return isOk;
+    }
     bool Save(const PuzzleData* obj, uint32_t count, Serializer& serializer)
     {
         bool isOk = true;
@@ -110,4 +200,22 @@ namespace Generated
         }
         return isOk;
     }
+    bool Load(PuzzleData* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+            isOk = Load(&obj[i].WidthTiles, 1, serializer) && isOk;
+            isOk = Load(&obj[i].HeightTiles, 1, serializer) && isOk;
+            isOk = Load(&obj[i].AvailableCardCount, 1, serializer) && isOk;
+            isOk = Load(obj[i].AvailableCards, 16, serializer) && isOk;
+            isOk = Load(&obj[i].PlacedCardCount, 1, serializer) && isOk;
+            isOk = Load(obj[i].PlacedCards, 256, serializer) && isOk;
+            isOk = Load(obj[i].PlacedNodes, 1024, serializer) && isOk;
+            isOk = Load(&obj[i].GoalPositionCount, 1, serializer) && isOk;
+            isOk = Load(obj[i].GoalPositions, 16, serializer) && isOk;
+            isOk = Load(obj[i].PuzzleName, 64, serializer) && isOk;
+        }
+        return isOk;
+    }
 }

src/gen/Generated.h

@@ -94,13 +94,23 @@ namespace Generated
         char PuzzleName[64] = {};
     };
     bool Save(const PuzzleElementType::Enum* obj, uint32_t count, Serializer& serializer);
+    bool Load(PuzzleElementType::Enum* obj, uint32_t count, Deserializer& serializer);
     bool Save(const PuzPos* obj, uint32_t count, Serializer& serializer);
+    bool Load(PuzPos* obj, uint32_t count, Deserializer& serializer);
     bool Save(const ElemPos* obj, uint32_t count, Serializer& serializer);
+    bool Load(ElemPos* obj, uint32_t count, Deserializer& serializer);
     bool Save(const PuzzleNode* obj, uint32_t count, Serializer& serializer);
+    bool Load(PuzzleNode* obj, uint32_t count, Deserializer& serializer);
     bool Save(const StaticPuzzleCard* obj, uint32_t count, Serializer& serializer);
+    bool Load(StaticPuzzleCard* obj, uint32_t count, Deserializer& serializer);
     bool Save(const StaticPuzzleCardHandle* obj, uint32_t count, Serializer& serializer);
+    bool Load(StaticPuzzleCardHandle* obj, uint32_t count, Deserializer& serializer);
     bool Save(const StaticPuzzleData* obj, uint32_t count, Serializer& serializer);
+    bool Load(StaticPuzzleData* obj, uint32_t count, Deserializer& serializer);
     bool Save(const PuzzleCardStack* obj, uint32_t count, Serializer& serializer);
+    bool Load(PuzzleCardStack* obj, uint32_t count, Deserializer& serializer);
     bool Save(const PlacedPuzzleCard* obj, uint32_t count, Serializer& serializer);
+    bool Load(PlacedPuzzleCard* obj, uint32_t count, Deserializer& serializer);
     bool Save(const PuzzleData* obj, uint32_t count, Serializer& serializer);
+    bool Load(PuzzleData* obj, uint32_t count, Deserializer& serializer);
 }