puzzle ids

src/game/Level.cpp

@@ -46,8 +46,9 @@ namespace Game
         bgfx::setTexture(1, rendering.DitherTextures.DitherSampler, rendering.DitherTextures.FinalTex);
         bgfx::setTexture(2, rendering.DitherTextures.RampSampler, rendering.DitherTextures.RampTex);
         bgfx::setUniform(currentMaterial.Uniforms[Material::UTime], timeValues);
-        bgfx::setUniform(currentMaterial.Uniforms[Material::UDotColor], TestColor);
+        bgfx::setUniform(currentMaterial.Uniforms[Material::UDotColor], &TestColor.x);
         bgfx::setUniform(currentMaterial.Uniforms[Material::UTexInfo], texInfo);
+        bgfx::setUniform(currentMaterial.Uniforms[Material::UBaseColor], &BaseColor.x);
 
         bgfx::submit(currentMaterial.ViewID, currentMaterial.Shader);
     }
@@ -79,8 +80,7 @@ namespace Game
         bx::Error err;
         bx::DirectoryReader dirIter;
         bx::FileInfo info;
-        bx::FilePath puzzleDirPath{"game/data/puzzles"};
+        bx::FilePath puzzleDirPath{Puzzle::PuzzleFileDir};
-        uint32_t puzIdx = 0;
         if (dirIter.open(puzzleDirPath, &err))
         {
             while (true)
@@ -92,11 +92,6 @@ namespace Game
                     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);
@@ -104,10 +99,17 @@ namespace Game
 
                     Generated::Deserializer ser;
                     ser.Init(fullPath);
-                    if (Generated::Load(&Puzzles[puzIdx].Data, 1, ser))
+                    Generated::PuzzleData dataBuf;
+                    if (ser.ReadT("PZZL", dataBuf))
                     {
-                        Puzzles[puzIdx].Setup();
+                        if (dataBuf.ID >= BX_COUNTOF(Puzzles))
-                        ++puzIdx;
+                        {
+                            LOG_ERROR("Puzzle ID out of bounds: %u", dataBuf.ID);
+                            ser.Finish();
+                            continue;
+                        }
+                        Puzzles[dataBuf.ID].Data = dataBuf;
+                        Puzzles[dataBuf.ID].Setup();
                     }
                     else
                     {
@@ -284,9 +286,6 @@ namespace Game
         {
             EData.Transform.Position = {0.0f, -1.0f, 0.0f};
             EData.Transform.Scale = {100.0f, 1.0f, 100.0f};
-            EData.TestColor[0] = 0.3f;
-            EData.TestColor[1] = 0.325f;
-            EData.TestColor[2] = 0.3f;
         }
     }
 
@@ -296,7 +295,6 @@ namespace Game
         EData.ModelHandle = GameRendering::Get().GetModelHandleFromPath("models/zurg.gltf");
 
         EData.Transform.Position = {0.0f, 0.0f, 0.0f};
-        EData.TestColor[0] = 0.0f;
     }
 
     void WorldPuzzle::Setup()

src/game/Level.h

@@ -17,7 +17,8 @@ namespace Game
 {
     struct EntityRenderData
     {
-        float TestColor[4]{1.0f, 1.0f, 1.0f, 1.0f};
+        Vec4 TestColor{1.0f, 1.0f, 1.0f, 1.0f};
+        Vec4 BaseColor{0.0f, 0.0f, 0.0f, 1.0f};
         Transform Transform;
         uint16_t MaterialHandle = UINT16_MAX;
         uint16_t ModelHandle = UINT16_MAX;

src/game/Puzzle.cpp

@@ -5,6 +5,7 @@
 #include "bx/bx.h"
 #include "imgui.h"
 #include <cassert>
+#include <cstdio>
 
 namespace
 {
@@ -186,6 +187,11 @@ namespace Generated
 {
     constexpr float UIPuzBoxSize = 26;
 
+    void WritePuzzleFilePath(char* buf, int32_t bufSize, uint16_t puzID)
+    {
+        bx::snprintf(buf, bufSize, "%s/%u.pzl", Puzzle::PuzzleFileDir, puzID);
+    }
+
     const char* GetShortNodeName(const PuzzleNode& node)
     {
         PuzzleElementType::Enum elemMax = PuzzleElementType::None;
@@ -203,7 +209,22 @@ namespace Generated
         bool isVisible = true;
         if (ImGui::Begin("Puzzle", &isVisible))
         {
-            ImGui::Text("%s", obj.PuzzleName);
+            if (ImGui::Button("Delete Puzzle"))
+            {
+                char filepath[128]{0};
+                WritePuzzleFilePath(filepath, sizeof(filepath), obj.ID);
+                remove(filepath);
+                obj.ID = UINT16_MAX;
+                ImGui::End();
+                return false;
+            }
+            int32_t val = obj.ID;
+            if (ImGui::InputInt("ID", &val))
+            {
+                obj.ID = val;
+                dataChanged = true;
+            }
+            dataChanged = ImGui::InputText("Name", obj.PuzzleName, sizeof(obj.PuzzleName)) || dataChanged;
 
             int32_t W = obj.WidthTiles;
             int32_t H = obj.HeightTiles;
@@ -232,13 +253,31 @@ namespace Generated
 
             for (int32_t y = 0; y < obj.HeightTiles; ++y)
             {
+                ImGui::PushID(y);
                 for (int32_t x = 0; x < obj.WidthTiles; ++x)
                 {
+                    ImGui::PushID(x);
                     PuzzleNode& node = obj.PlacedNodes[Puzzle::Config::MaxPuzzleSizeTiles * y + x];
                     ImVec2 pos = ImVec2{puzCursorStart.x + x * UIPuzBoxSize + 5, puzCursorStart.y + y * UIPuzBoxSize};
                     ImGui::SetCursorScreenPos(pos);
                     ImGui::Text("%s", GetShortNodeName(node));
+                    ImGui::SetCursorScreenPos(pos);
+                    if (x % Puzzle::Config::CardSize == 0 && y % Puzzle::Config::CardSize == 0)
+                    {
+                        ImGui::InvisibleButton("bn", {UIPuzBoxSize * 2, UIPuzBoxSize * 2});
+                        if (ImGui::BeginDragDropTarget())
+                        {
+                            if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("cardtype", 0))
+                            {
+                                uint32_t CardIdx = *reinterpret_cast<uint32_t*>(payload->Data);
+                                obj.PlacedCards[obj.PlacedCardCount].RefCard = {(uint16_t)CardIdx};
                             }
+                            ImGui::EndDragDropTarget();
+                        }
+                    }
+                    ImGui::PopID();
+                }
+                ImGui::PopID();
             }
 
             for (int32_t y = 0; y <= obj.HeightTiles; ++y)
@@ -256,15 +295,13 @@ namespace Generated
                                  x % Puzzle::Config::CardSize == 0 ? 0xFFFFFFFF : 0x11FFFFFF);
             }
 
-            ImGui::Spacing();
+            ImVec2 pos = ImVec2{puzCursorStart.x + obj.WidthTiles * UIPuzBoxSize + 5,
-            ImGui::Spacing();
+                                puzCursorStart.y + obj.HeightTiles * UIPuzBoxSize};
 
+            ImGui::SetCursorScreenPos(pos);
+            ImGui::NewLine();
             if (ImGui::TreeNodeEx("Available Cards", ImGuiTreeNodeFlags_DefaultOpen | ImGuiTreeNodeFlags_Framed))
             {
-                for (int32_t i = 0; i < obj.AvailableCardCount; ++i)
-                {
-                    ImGui::Text("Card");
-                }
                 ImGui::TreePop();
             }
         }
@@ -273,10 +310,10 @@ namespace Generated
         if (dataChanged)
         {
             char path[128]{0};
-            bx::snprintf(path, sizeof(path), "game/data/puzzles/%s.pzl", obj.PuzzleName);
+            WritePuzzleFilePath(path, sizeof(path), obj.ID);
             Serializer ser;
             ser.Init(path);
-            if (Save(&obj, 1, ser))
+            if (ser.WriteT("PZZL", obj))
             {
                 LOG("Saved to %s", path);
             }

src/game/Puzzle.h

@@ -6,6 +6,7 @@
 
 namespace Puzzle
 {
+    constexpr const char* PuzzleFileDir = "game/data/puzzles/";
     struct Config
     {
         static constexpr uint32_t CardSize = 2;

src/game/mini.def

@@ -1,3 +1,43 @@
+type Vec2
+{
+	f32 X
+	f32 Y
+}
+
+type Vec3
+{
+	f32 X
+	f32 Y
+	f32 Z
+}
+
+type Vec4
+{
+	f32 X
+	f32 Y
+	f32 Z
+	f32 W
+}
+
+type Mat3
+{
+	f32 M Arr(9) Default("{
+	1.0f, 0.0f, 0.0f,
+	0.0f, 1.0f, 0.0f,
+	0.0f, 0.0f, 1.0f
+	}")
+}
+
+type Mat4
+{
+	f32 M Arr(16) Default("{
+	1.0f, 0.0f, 0.0f, 0.0f,
+	0.0f, 1.0f, 0.0f, 0.0f,
+	0.0f, 0.0f, 1.0f, 0.0f,
+	0.0f, 0.0f, 0.0f, 1.0f
+	}")
+}
+
 type PuzPos
 {
 	i8 X
@@ -60,6 +100,8 @@ type PlacedPuzzleCard
 
 type PuzzleData
 {
+	u16              ID
+	str              PuzzleName          Arr(64)
 	u8               WidthTiles
 	u8               HeightTiles
 	u32              AvailableCardCount
@@ -69,5 +111,4 @@ type PuzzleData
 	PuzzleNode       PlacedNodes         Arr(1024)
 	u32              GoalPositionCount
 	ElemPos          GoalPositions       Arr(16)
-	str              PuzzleName          Arr(64)
 }

src/game/rendering/Rendering.cpp

@@ -13,10 +13,12 @@
 #include "bx/constants.h"
 #include "bx/filepath.h"
 #include "bx/math.h"
+#include "bx/string.h"
 #include "bx/timer.h"
 #include <bgfx/bgfx.h>
 #include <bimg/bimg.h>
 #include <bx/file.h>
+#include <cstdint>
 #include <cstdio>
 #include <thread>
 
@@ -505,18 +507,54 @@ namespace Game
                 }
                 Vec3 quadPos = level.UIQuads.Get({0}).EData.Transform.GetPosition();
                 ImGui::Text("%f %f %f", quadPos.x, quadPos.y, quadPos.z);
+
+                if (ImGui::ColorEdit3("Base Color", &DefaultBaseColor.x))
+                {
+                    auto& tiles = GetInstance().GameLevel.PuzzleTiles;
+                    for (int32_t i = 0; i < tiles.Count; ++i)
+                    {
+                        tiles.Data[i].EData.BaseColor = DefaultBaseColor;
+                    }
+                }
+                if (ImGui::ColorEdit3("Dot Color", &DefaultTileColor.x))
+                {
+                    auto& tiles = GetInstance().GameLevel.PuzzleTiles;
+                    for (int32_t i = 0; i < tiles.Count; ++i)
+                    {
+                        tiles.Data[i].EData.TestColor = DefaultTileColor;
+                    }
+                }
+
                 ImGui::Text("Shader log:");
                 ImGui::TextWrapped("%s", GetShared().Dev.ShaderLog);
             }
             ImGui::End();
             if (ImGui::Begin("Puzzles"))
             {
-                ImGui::Text("List");
+                if (ImGui::Button("Add"))
+                {
+                    bool found = false;
+                    for (int32_t i = 0; i < BX_COUNTOF(level.Puzzles); ++i)
+                    {
+                        auto& puz = level.Puzzles[i].Data;
+                        if (puz.ID == UINT16_MAX)
+                        {
+                            bx::strCopy(puz.PuzzleName, sizeof(puz.PuzzleName), "Unnamed Puzzle");
+                            puz.ID = i;
+                            found = true;
+                            break;
+                        }
+                    }
+                    if (!found)
+                    {
+                        LOG_ERROR("Too many puzzles!");
+                    }
+                }
                 ImGui::Separator();
                 for (int32_t i = 0; i < BX_COUNTOF(level.Puzzles); ++i)
                 {
                     auto& puzzleData = level.Puzzles[i].Data;
-                    if (puzzleData.PuzzleName[0] == 0) continue;
+                    if (puzzleData.ID == UINT16_MAX) continue;
 
                     bool isSelected = debug.SelectedDebugLevel == i;
                     ImGui::PushID("selectable");
@@ -525,21 +563,16 @@ namespace Game
                         debug.SelectedDebugLevel = isSelected ? UINT16_MAX : i;
                     }
                     ImGui::PopID();
-                    if (isSelected)
+                }
+            }
+            ImGui::End();
+            if (debug.SelectedDebugLevel < BX_COUNTOF(level.Puzzles))
             {
-                        ImGui::PushID("edit field");
+                if (!Generated::RenderDebugUI(level.Puzzles[debug.SelectedDebugLevel].Data))
-                        ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x);
-                        ImGui::InputText("", puzzleData.PuzzleName, sizeof(Generated::PuzzleData::PuzzleName));
-                        ImGui::PopID();
-
-                        if (!Generated::RenderDebugUI(puzzleData))
                 {
                     debug.SelectedDebugLevel = UINT16_MAX;
                 }
             }
-                }
-            }
-            ImGui::End();
             if (ImGui::Begin("Cards"))
             {
                 Generated::StaticPuzzleData& staticData = Generated::GetStaticPuzzleData();
@@ -559,7 +592,15 @@ namespace Game
 
                     Generated::StaticPuzzleCard& card = staticData.Cards[i];
                     ImGui::PushID(i);
-                    ImGui::Text("%i", i);
+                    char cardName[64]{0};
+                    bx::snprintf(cardName, sizeof(cardName), "%i", i);
+                    ImGui::Selectable(cardName);
+                    if (ImGui::BeginDragDropSource())
+                    {
+                        ImGui::Text("Card %i", i);
+                        ImGui::SetDragDropPayload("cardtype", &i, sizeof(i));
+                        ImGui::EndDragDropSource();
+                    }
 
                     Tools::ModelDropdown(card.ModelHandle);
                     for (int32_t y = 0; y < Puzzle::Config::CardSize; ++y)
@@ -634,6 +675,7 @@ namespace Game
         mat.Uniforms[Material::UTime] = bgfx::createUniform("u_time", bgfx::UniformType::Vec4);
         mat.Uniforms[Material::UDotColor] = bgfx::createUniform("u_testColor", bgfx::UniformType::Vec4);
         mat.Uniforms[Material::UTexInfo] = bgfx::createUniform("u_texInfo", bgfx::UniformType::Vec4);
+        mat.Uniforms[Material::UBaseColor] = bgfx::createUniform("u_baseColor", bgfx::UniformType::Vec4);
         mat.Textures[0].Handle = tex;
         mat.Textures[0].SamplerHandle = sampler;
         mat.ViewID = view;

src/game/rendering/Rendering.h

@@ -46,6 +46,7 @@ namespace Game
             UTime = 0,
             UDotColor = 1,
             UTexInfo = 2,
+            UBaseColor = 3,
         };
 
         bgfx::ProgramHandle Shader;
@@ -108,6 +109,8 @@ namespace Game
         uint16_t MainViewID = 10;
         float LastShaderLoadTime = 0.0f;
         int32_t DitherRecursion = 1;
+        Vec4 DefaultBaseColor;
+        Vec4 DefaultTileColor;
 
       public:
         void Setup();

src/game/shaders/frag.sc

@@ -11,6 +11,7 @@ SAMPLER2D(s_rampSampler, 2);
 uniform vec4 u_time;
 uniform vec4 u_testColor;
 uniform vec4 u_texInfo;
+uniform vec4 u_baseColor;
 
 float calcBrightness(vec3 lightPos, vec3 vertPos, vec3 normal)
 {
@@ -103,8 +104,7 @@ void main()
 	float g = dither(brightness * texColor.g, v_uv0);
 	float b = dither(brightness * texColor.b, v_uv0);
 	// float3 finalColor = vec3(r, g, b);
-	float3 finalColor = dither(brightness, v_uv0);
+	float3 ditheredColor = dither(brightness, v_uv0);
+	float3 finalColor = mix(u_baseColor, texColor, ditheredColor);
 	gl_FragColor = vec4(finalColor, 1.0);
-	// gl_FragColor = vec4(finalColor * 0.8 + subLayer * 0.2, 1.0);
-	// gl_FragColor = vec4(finalColor * 0.8 + vec3(uv % 1, 0.0) * 0.2, 1.0);
 }

src/gen/Generated.cpp

@@ -22,6 +22,108 @@ namespace Generated
         }
         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 = Save(&obj[i].Y, 1, serializer) && isOk;
+        }
+        return isOk;
+    }
+    bool Load(Vec2* 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 Vec3* 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 = Save(&obj[i].Y, 1, serializer) && isOk;
+            isOk = Save(&obj[i].Z, 1, serializer) && isOk;
+        }
+        return isOk;
+    }
+    bool Load(Vec3* 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;
+            isOk = Load(&obj[i].Z, 1, serializer) && isOk;
+        }
+        return isOk;
+    }
+    bool Save(const Vec4* 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 = Save(&obj[i].Y, 1, serializer) && isOk;
+            isOk = Save(&obj[i].Z, 1, serializer) && isOk;
+            isOk = Save(&obj[i].W, 1, serializer) && isOk;
+        }
+        return isOk;
+    }
+    bool Load(Vec4* 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;
+            isOk = Load(&obj[i].Z, 1, serializer) && isOk;
+            isOk = Load(&obj[i].W, 1, serializer) && isOk;
+        }
+        return isOk;
+    }
+    bool Save(const Mat3* obj, uint32_t count, Serializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+            isOk = Save(obj[i].M, 9, serializer) && isOk;
+        }
+        return isOk;
+    }
+    bool Load(Mat3* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+            isOk = Load(obj[i].M, 9, serializer) && isOk;
+        }
+        return isOk;
+    }
+    bool Save(const Mat4* obj, uint32_t count, Serializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+            isOk = Save(obj[i].M, 16, serializer) && isOk;
+        }
+        return isOk;
+    }
+    bool Load(Mat4* obj, uint32_t count, Deserializer& serializer)
+    {
+        bool isOk = true;
+        for (uint32_t i = 0; i < count; ++i)
+        {
+            isOk = Load(obj[i].M, 16, serializer) && isOk;
+        }
+        return isOk;
+    }
     bool Save(const PuzPos* obj, uint32_t count, Serializer& serializer)
     {
         bool isOk = true;
@@ -187,6 +289,7 @@ namespace Generated
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
+            isOk = Save(&obj[i].ID, 1, serializer) && isOk;
             isOk = Save(&obj[i].WidthTiles, 1, serializer) && isOk;
             isOk = Save(&obj[i].HeightTiles, 1, serializer) && isOk;
             isOk = Save(&obj[i].AvailableCardCount, 1, serializer) && isOk;
@@ -205,6 +308,7 @@ namespace Generated
         bool isOk = true;
         for (uint32_t i = 0; i < count; ++i)
         {
+            isOk = Load(&obj[i].ID, 1, serializer) && isOk;
             isOk = Load(&obj[i].WidthTiles, 1, serializer) && isOk;
             isOk = Load(&obj[i].HeightTiles, 1, serializer) && isOk;
             isOk = Load(&obj[i].AvailableCardCount, 1, serializer) && isOk;

src/gen/Generated.h

@@ -52,6 +52,46 @@ namespace Generated
             "#",
         };
     };
+    struct Vec2
+    {
+        static constexpr uint32_t Hash = 4242122113;
+        float X = {};
+        float Y = {};
+    };
+    struct Vec3
+    {
+        static constexpr uint32_t Hash = 1694997017;
+        float X = {};
+        float Y = {};
+        float Z = {};
+    };
+    struct Vec4
+    {
+        static constexpr uint32_t Hash = 447058821;
+        float X = {};
+        float Y = {};
+        float Z = {};
+        float W = {};
+    };
+    struct Mat3
+    {
+        static constexpr uint32_t Hash = 3364737048;
+        float M[9] = {
+	1.0f, 0.0f, 0.0f,
+	0.0f, 1.0f, 0.0f,
+	0.0f, 0.0f, 1.0f
+	};
+    };
+    struct Mat4
+    {
+        static constexpr uint32_t Hash = 1650094019;
+        float M[16] = {
+	1.0f, 0.0f, 0.0f, 0.0f,
+	0.0f, 1.0f, 0.0f, 0.0f,
+	0.0f, 0.0f, 1.0f, 0.0f,
+	0.0f, 0.0f, 0.0f, 1.0f
+	};
+    };
     struct PuzPos
     {
         static constexpr uint32_t Hash = 1834398141;
@@ -102,7 +142,8 @@ namespace Generated
     };
     struct PuzzleData
     {
-        static constexpr uint32_t Hash = 2015691597;
+        static constexpr uint32_t Hash = 255994202;
+        uint16_t ID = {};
         uint8_t WidthTiles = {};
         uint8_t HeightTiles = {};
         uint32_t AvailableCardCount = {};
@@ -116,6 +157,16 @@ namespace Generated
     };
     bool Save(const PuzzleElementType::Enum* obj, uint32_t count, Serializer& serializer);
     bool Load(PuzzleElementType::Enum* 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);
+    bool Load(Vec3* obj, uint32_t count, Deserializer& serializer);
+    bool Save(const Vec4* obj, uint32_t count, Serializer& serializer);
+    bool Load(Vec4* obj, uint32_t count, Deserializer& serializer);
+    bool Save(const Mat3* obj, uint32_t count, Serializer& serializer);
+    bool Load(Mat3* obj, uint32_t count, Deserializer& serializer);
+    bool Save(const Mat4* obj, uint32_t count, Serializer& serializer);
+    bool Load(Mat4* 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);