1 files changed, 44 insertions, 88 deletions

diff --git a/serialize/wall-atlas.cpp b/serialize/wall-atlas.cpp
index 31090e45..8ebe106a 100644
--- a/serialize/wall-atlas.cpp
+++ b/serialize/wall-atlas.cpp
@@ -9,138 +9,94 @@
 
 // todo add test on dummy files that generates 100% coverage on the j.contains() blocks!
 
-namespace floormat {
+namespace floormat::Wall::detail {
+
+using nlohmann::json;
+using namespace std::string_literals;
 
 namespace {
 
-using nlohmann::json;
 constexpr auto none = (uint8_t)-1;
-using namespace std::string_literals;
-constexpr StringView rotation_names[] = { "n"_s, "e"_s, "s"_s, "w"_s, };
+constexpr StringView direction_names[] = { "n"_s, "e"_s, "s"_s, "w"_s, };
+
+} // namespace
 
-size_t rotation_from_name(StringView s)
+uint8_t direction_index_from_name(StringView s)
 {
-    for (auto i = 0uz; auto n : rotation_names)
-    {
+    for (uint8_t i = 0; auto n : direction_names)
         if (n == s)
             return i;
-        i++;
-    }
-    fm_throw("bad rotation name '{}'"_cf, fmt::string_view{s.data(), s.size()});
-}
+        else
+            i++;
 
-StringView rotation_to_name(size_t i)
-{
-    fm_soft_assert(i < std::size(rotation_names));
-    return rotation_names[i];
+    fm_throw("bad rotation name '{}'"_cf, fmt::string_view{s.data(), s.size()});
 }
 
-[[nodiscard]] wall_frames read_frames_metadata(const json& jfs)
+StringView direction_index_to_name(size_t i)
 {
-    wall_frames val;
-
-    if (jfs.contains("pixel-size"s))
-        val.pixel_size = jfs["pixel-size"s];
-    if (jfs.contains("tint"s))
-    {
-        std::tie(val.tint_mult, val.tint_add) = std::pair<Vector4, Vector3>{ jfs["tint"s]};
-        fm_soft_assert(val.tint_mult >= Color4{0});
-    }
-    if (jfs.contains("from-rotation"s))
-        val.from_rotation = (uint8_t)rotation_from_name(std::string{jfs["from-rotation"s]});
-    if (jfs.contains("mirrored"s))
-        val.mirrored = jfs["mirrored"s];
-    if (jfs.contains("use-default-tint"s))
-        val.use_default_tint = jfs["use-default-tint"s];
-
-    return val;
+    fm_soft_assert(i < arraySize(direction_names));
+    return direction_names[i];
 }
 
-[[nodiscard]] wall_frame_set read_frameset_metadata(const json& j)
+[[nodiscard]] Group read_group_metadata(const json& jgroup)
 {
-    return {};
-}
+    fm_assert(jgroup.is_object());
 
-void read_framesets(const json& jf, wall_atlas_def& val)
-{
-    fm_soft_assert(jf.is_object());
-    fm_soft_assert(val.framesets == nullptr && val.frameset_count == 0);
-    uint8_t count = 0;
+    Group val;
 
-    static_assert(std::size(rotation_names) == 4);
-    for (auto i = 0uz; i < 4; i++)
-    {
-        const auto& r = rotation_names[i];
-        auto key = std::string_view{r.data(), r.size()};
-        if (jf.contains(key))
-        {
-            fm_soft_assert(jf[key].is_object());
-            auto& index = val.frameset_indexes[i];
-            fm_soft_assert(index == none);
-            index = count++;
-        }
-    }
-    fm_soft_assert(count > 0);
-    fm_soft_assert(count == jf.size());
+    if (jgroup.contains("pixel-size"s))
+        val.pixel_size = jgroup["pixel-size"s];
+    if (jgroup.contains("tint"s))
+        std::tie(val.tint_mult, val.tint_add) = std::pair<Vector4, Vector3>{ jgroup["tint"s] };
+    if (jgroup.contains("from-rotation"s))
+        val.from_rotation = (uint8_t)direction_index_from_name(std::string{ jgroup["from-rotation"s] });
+    if (jgroup.contains("mirrored"s))
+        val.mirrored = jgroup["mirrored"s];
+    if (jgroup.contains("use-default-tint"s))
+        val.use_default_tint = jgroup["use-default-tint"s];
 
-    val.framesets = std::make_unique<wall_frame_set[]>(count);
-    val.frameset_count = count;
+    fm_soft_assert(val.tint_mult >= Color4{0});
 
-    for (auto i = 0uz; i < 4; i++)
-    {
-        auto index = val.frameset_indexes[i];
-        if (index == none)
-            continue;
-        auto r = rotation_to_name(i);
-        auto key = std::string_view{r.data(), r.size()};
-
-        fm_debug_assert(index < val.frameset_count);
-        val.framesets[index] = read_frameset_metadata(jf[key]);
-    }
+    return val;
 }
 
-void write_frameset_metadata(json& j, const wall_atlas& a, const wall_frames& val, size_t rot)
+void write_group_metadata(json& jgroup, const Group& val)
 {
-    constexpr wall_frames default_value;
+    constexpr Group default_value;
 
-    fm_soft_assert(val.count != (uint32_t)-1);
-    fm_soft_assert(val.index == (uint32_t)-1 || val.index < a.frame_array().size());
-    fm_soft_assert((val.index == (uint32_t)-1) == (val.count == 0));
+    fm_soft_assert(jgroup.is_object());
+    fm_soft_assert(jgroup.empty());
 
-    j["name"s] = rotation_to_name(rot);
-    j["pixel-size"s] = val.pixel_size;
+    jgroup["pixel-size"s] = val.pixel_size;
     if (val.tint_mult != default_value.tint_mult || val.tint_add != default_value.tint_add)
     {
         auto tint = std::pair<Vector4, Vector3>{{val.tint_mult}, {val.tint_add}};
-        j["tint"s] = tint;
+        jgroup["tint"s] = tint;
     }
     if (val.from_rotation != default_value.from_rotation)
     {
         fm_soft_assert(val.from_rotation != none && val.from_rotation < 4);
-        j["from-rotation"s] = val.from_rotation;
+        jgroup["from-rotation"s] = val.from_rotation;
     }
     if (val.mirrored != default_value.mirrored)
-        j["mirrored"s] = val.mirrored;
+        jgroup["mirrored"s] = val.mirrored;
     if (val.use_default_tint)
         if (val.tint_mult != default_value.tint_mult || val.tint_add != default_value.tint_add)
-            j["use-default-tint"s] = true;
+            jgroup["use-default-tint"s] = true;
 }
 
-} // namespace
-
-void Serialize::wall_test::read_atlas_header(const json& j, wall_atlas_def& val)
+Info read_info_header(const json& jroot)
 {
-    val = {};
-    val.info = { std::string(j["name"s]), j["depth"], };
-    val.frame_count = (uint32_t)j["frames"s].size();
-    read_framesets(j["framesets"s], val);
+    Info val { std::string(jroot["name"s]), jroot["depth"] };
+    return val;
 }
 
-} // namespace floormat
+} // namespace floormat::Wall::detail
 
 namespace nlohmann {
 
 using namespace floormat;
+using namespace floormat::Wall::detail;
 
 void adl_serializer<std::shared_ptr<wall_atlas>>::to_json(json& j, const std::shared_ptr<const wall_atlas>& x)
 {