a

7 files changed, 25 insertions, 24 deletions

diff --git a/loader.hpp b/loader.hpp
index b6a1d1b4..49299bb6 100644
--- a/loader.hpp
+++ b/loader.hpp
@@ -15,7 +15,7 @@ struct loader_
 {
     virtual std::string shader(Containers::StringView filename) = 0;
     virtual Trade::ImageData2D tile_texture(Containers::StringView filename) = 0;
-    virtual std::shared_ptr<struct tile_atlas> tile_atlas(Containers::StringView filename, Vector2i size) = 0;
+    virtual std::shared_ptr<struct tile_atlas> tile_atlas(Containers::StringView filename, Vector2ui size) = 0;
     static void destroy();
 
     loader_(const loader_&) = delete;
diff --git a/main/loader-impl.cpp b/main/loader-impl.cpp
index 1f15ea68..1ddb8cdb 100644
--- a/main/loader-impl.cpp
+++ b/main/loader-impl.cpp
@@ -30,7 +30,7 @@ struct loader_impl final : loader_
 
     std::string shader(Containers::StringView filename) override;
     Trade::ImageData2D tile_texture(Containers::StringView filename) override;
-    std::shared_ptr<struct tile_atlas> tile_atlas(Containers::StringView filename, Vector2i size) override;
+    std::shared_ptr<struct tile_atlas> tile_atlas(Containers::StringView filename, Vector2ui size) override;
 
     explicit loader_impl();
     ~loader_impl() override;
@@ -46,7 +46,7 @@ std::string loader_impl::shader(Containers::StringView filename)
     return ret;
 }
 
-std::shared_ptr<tile_atlas> loader_impl::tile_atlas(Containers::StringView name, Vector2i size)
+std::shared_ptr<tile_atlas> loader_impl::tile_atlas(Containers::StringView name, Vector2ui size)
 {
     auto it = atlas_map.find(name);
     if (it != atlas_map.end())
diff --git a/main/main.cpp b/main/main.cpp
index 4acdd471..9dc5ce4e 100644
--- a/main/main.cpp
+++ b/main/main.cpp
@@ -75,7 +75,7 @@ chunk app::make_test_chunk()
     chunk c;
     c.foreach_tile([&, this](tile& x, std::size_t k, local_coords pt) {
       const auto& atlas = pt.x > N/2 && pt.y >= N/2 ? floor2 : floor1;
-      x.ground_image = { atlas, (std::uint8_t)(k % atlas->size()) };
+      x.ground_image = { atlas, (std::uint8_t)(k % atlas->num_tiles().product()) };
     });
     constexpr auto K = N/2;
     c[{K,   K  }].wall_north = { wall1, 0 };
diff --git a/serialize/magnum-vector.hpp b/serialize/magnum-vector.hpp
index 39924a9b..c4a2c36c 100644
--- a/serialize/magnum-vector.hpp
+++ b/serialize/magnum-vector.hpp
@@ -8,12 +8,14 @@
 namespace nlohmann {
 
 template<typename t>
+requires std::is_integral_v<t>
 struct adl_serializer<Magnum::Math::Vector2<t>> final {
     static void to_json(json& j, const Magnum::Math::Vector2<t>& x);
     static void from_json(const json& j, Magnum::Math::Vector2<t>& x);
 };
 
 template<typename t>
+requires std::is_integral_v<t>
 void adl_serializer<Magnum::Math::Vector2<t>>::to_json(json& j, const Magnum::Math::Vector2<t>& val)
 {
     char buf[64];
@@ -22,11 +24,12 @@ void adl_serializer<Magnum::Math::Vector2<t>>::to_json(json& j, const Magnum::Ma
 }
 
 template<typename t>
+requires std::is_integral_v<t>
 void adl_serializer<Magnum::Math::Vector2<t>>::from_json(const json& j, Magnum::Math::Vector2<t>& val)
 {
     std::string str = j;
-    int x = 0, y = 0, n = 0;
-    int ret = std::sscanf(str.c_str(), "%d x %d%n", &x, &y, &n);
+    long long x = 0, y = 0; int n = 0;
+    int ret = std::sscanf(str.c_str(), "%lld x %lld%n", &x, &y, &n);
     if (ret != 2 || (std::size_t)n != str.size())
     {
         std::string msg; msg.reserve(64 + str.size());
@@ -35,7 +38,7 @@ void adl_serializer<Magnum::Math::Vector2<t>>::from_json(const json& j, Magnum::
         msg += "' as Magnum::Vector2i";
         throw std::invalid_argument(msg);
     }
-    val = { x, y };
+    val = { (t)x, (t)y };
 }
 
 } // namespace nlohmann
diff --git a/serialize/tile-atlas.cpp b/serialize/tile-atlas.cpp
index 0f03e6b2..4a10d2c2 100644
--- a/serialize/tile-atlas.cpp
+++ b/serialize/tile-atlas.cpp
@@ -9,10 +9,10 @@ namespace Magnum::Examples::Serialize {
 
 struct proxy_atlas final {
     std::string name;
-    Vector2i size;
+    Vector2ui num_tiles;
 };
 
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(proxy_atlas, name, size)
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(proxy_atlas, name, num_tiles)
 
 } // namespace Magnum::Examples::Serialize
 
@@ -29,14 +29,14 @@ void adl_serializer<shared_atlas>::to_json(json& j, const shared_atlas& x)
         j = nullptr;
     else {
         using nlohmann::to_json;
-        to_json(j, proxy_atlas{x->name(), x->dimensions()});
+        to_json(j, proxy_atlas{x->name(), x->num_tiles()});
     }
 }
 
 void adl_serializer<shared_atlas>::from_json(const json& j, shared_atlas& x)
 {
     proxy_atlas proxy = j;
-    x = loader.tile_atlas(proxy.name, proxy.size);
+    x = loader.tile_atlas(proxy.name, proxy.num_tiles);
 }
 
 } // namespace nlohmann
diff --git a/tile-atlas.cpp b/tile-atlas.cpp
index ac786bd1..d5d56cce 100644
--- a/tile-atlas.cpp
+++ b/tile-atlas.cpp
@@ -5,15 +5,14 @@
 
 namespace Magnum::Examples {
 
-tile_atlas::tile_atlas(Containers::StringView name, const ImageView2D& image, Vector2i dims) :
+tile_atlas::tile_atlas(Containers::StringView name, const ImageView2D& image, Vector2ui dims) :
     name_{name},
     size_{image.size()},
     dims_{dims}
 {
     CORRADE_INTERNAL_ASSERT(dims_[0] > 0 && dims_[1] > 0);
-    CORRADE_INTERNAL_ASSERT(size_ % dims_ == Vector2i{});
-    CORRADE_INTERNAL_ASSERT(dims.product() < 256);
-    CORRADE_INTERNAL_ASSERT(tile_size() * dims_ == size_);
+    CORRADE_INTERNAL_ASSERT(size_ % dims_ == Vector2ui{});
+    CORRADE_INTERNAL_ASSERT(dims_.product() < 256);
     tex_.setWrapping(GL::SamplerWrapping::ClampToBorder)
         .setMagnificationFilter(GL::SamplerFilter::Linear)
         .setMinificationFilter(GL::SamplerFilter::Linear)
@@ -24,10 +23,10 @@ tile_atlas::tile_atlas(Containers::StringView name, const ImageView2D& image, Ve
 
 std::array<Vector2, 4> tile_atlas::texcoords_for_id(std::size_t id_) const
 {
-    ASSERT(id_ < size());
-    const Vector2i id = { (int)id_ % dims_[0], (int)id_ / dims_[0] };
-    const Vector2 p1(tile_size());
-    const auto p0 = Vector2(id * p1);
+    const auto sz = size_/dims_;
+    ASSERT(id_ < sz.product());
+    const Vector2ui id = { (unsigned)id_ % dims_[0], (unsigned)id_ / dims_[0] };
+    const Vector2 p0(id * sz), p1(sz);
     const auto x0 = p0.x(), x1 = p1.x(), y0 = p0.y(), y1 = p1.y();
     return {{
         { x0+x1, y0+y1 }, // bottom right
diff --git a/tile-atlas.hpp b/tile-atlas.hpp
index f4886962..b32a70d8 100644
--- a/tile-atlas.hpp
+++ b/tile-atlas.hpp
@@ -11,23 +11,22 @@ struct tile_atlas final
 {
     using quad = std::array<Vector3, 4>;
 
-    tile_atlas(Containers::StringView name, const ImageView2D& img, Vector2i dimensions);
+    tile_atlas(Containers::StringView name, const ImageView2D& img, Vector2ui dimensions);
 
     std::array<Vector2, 4> texcoords_for_id(std::size_t id) const;
     static constexpr quad floor_quad(Vector3 center, Vector2 size);
     static constexpr quad wall_quad_N(Vector3 center, Vector3 size);
     static constexpr quad wall_quad_W(Vector3 center, Vector3 size);
     static constexpr std::array<UnsignedShort, 6> indices(std::size_t N);
-    std::size_t size() const { return (std::size_t)dims_.product(); }
-    Vector2i tile_size() const { return size_ / dims_; }
-    Vector2i dimensions() const { return dims_; }
+    Vector2ui pixel_size() const { return size_; }
+    Vector2ui num_tiles() const { return dims_; }
     GL::RectangleTexture& texture() { return tex_; }
     Containers::StringView name() const { return name_; }
 
 private:
     GL::RectangleTexture tex_;
     std::string name_;
-    Vector2i size_, dims_;
+    Vector2ui size_, dims_;
 };
 
 constexpr std::array<UnsignedShort, 6> tile_atlas::indices(std::size_t N)