wip

11 files changed, 76 insertions, 53 deletions

diff --git a/src/chunk.cpp b/src/chunk.cpp
index 9eca0138..59e05d73 100644
--- a/src/chunk.cpp
+++ b/src/chunk.cpp
@@ -7,12 +7,14 @@ bool chunk::empty(bool force) const noexcept
     if (!force && !_maybe_empty)
         return false;
 
-    for (const tile& x : _tiles)
-        if (x.ground || x.wall_north || x.wall_west)
+    for (std::size_t i = 0; i < TILE_COUNT; i++)
+    {
+        if (_ground_atlases[i] || _wall_north_atlases[i] || _wall_west_atlases[i])
         {
             _maybe_empty = false;
             return false;
         }
+    }
 
     return true;
 }
diff --git a/src/chunk.hpp b/src/chunk.hpp
index 6031b913..564f049e 100644
--- a/src/chunk.hpp
+++ b/src/chunk.hpp
@@ -12,25 +12,15 @@ struct chunk final
     friend struct tile_ref;
     friend struct pass_mode_ref;
 
-#if 0
-    tile& operator[](local_coords xy) noexcept { return _tiles[xy.to_index()]; }
-    const tile& operator[](local_coords xy) const noexcept { return _tiles[xy.to_index()]; }
-    tile& operator[](std::size_t i) noexcept { return _tiles[i]; }
-    const tile& operator[](std::size_t i) const noexcept { return _tiles[i]; }
-    const auto& tiles() const noexcept { return _tiles; }
-    auto& tiles() noexcept { return _tiles; }
-#endif
+    tile_ref operator[](std::size_t idx) noexcept { return { *this, std::uint8_t(idx) }; }
+    tile_proto operator[](std::size_t idx) const noexcept { return tile_proto(tile_ref { *const_cast<chunk*>(this), std::uint8_t(idx) }); }
+    tile_ref operator[](local_coords xy) noexcept { return operator[](xy.to_index()); }
+    tile_proto operator[](local_coords xy) const noexcept { return operator[](xy.to_index()); }
 
     using iterator = tile_iterator;
 
-#if 0
-    iterator begin() noexcept { return iterator{_tiles.data(), 0}; }
-    iterator end() noexcept { return iterator{_tiles.data(), _tiles.size()}; }
-    const_iterator cbegin() const noexcept { return const_iterator{_tiles.data(), 0}; }
-    const_iterator cend() const noexcept { return const_iterator{_tiles.data(), _tiles.size()}; }
-    const_iterator begin() const noexcept { return cbegin(); }
-    const_iterator end() const noexcept { return cend(); }
-#endif
+    iterator begin() noexcept { return iterator { *this, 0 }; }
+    iterator end() noexcept { return iterator { *this, TILE_COUNT }; }
 
     bool empty(bool force = false) const noexcept;
 
@@ -43,8 +33,8 @@ private:
     static constexpr std::size_t PASS_BITS = 2;
 
     std::array<std::shared_ptr<tile_atlas>, TILE_COUNT> _ground_atlases, _wall_north_atlases, _wall_west_atlases;
-    std::array<std::uint16_t, TILE_COUNT> _ground_variants, _wall_north_variants, _wall_west_variants;
-    std::bitset<TILE_COUNT*2> _passability;
+    std::array<std::uint16_t, TILE_COUNT> _ground_variants = {}, _wall_north_variants = {}, _wall_west_variants = {};
+    std::bitset<TILE_COUNT*2> _passability = {};
     mutable bool _maybe_empty = true;
 };
 
diff --git a/src/local-coords.hpp b/src/local-coords.hpp
index e0aea1d6..949a90e0 100644
--- a/src/local-coords.hpp
+++ b/src/local-coords.hpp
@@ -12,7 +12,7 @@ struct local_coords final {
     template<std::integral T> requires (sizeof(T) <= sizeof(std::size_t))
     constexpr local_coords(T x, T y) noexcept;
     constexpr local_coords(std::uint8_t x, std::uint8_t y) noexcept : x{x}, y{y} {}
-    constexpr std::size_t to_index() const noexcept { return y*TILE_MAX_DIM + x; }
+    constexpr std::uint8_t to_index() const noexcept { return y*TILE_MAX_DIM + x; }
 };
 
 constexpr local_coords::local_coords(std::size_t index) noexcept :
diff --git a/src/tile-atlas.cpp b/src/tile-atlas.cpp
index e6df942f..624b4694 100644
--- a/src/tile-atlas.cpp
+++ b/src/tile-atlas.cpp
@@ -13,7 +13,8 @@ tile_atlas::tile_atlas(StringView name, const ImageView2D& image, Vector2ub tile
     texcoords_{make_texcoords_array(Vector2ui(image.size()), tile_count)},
     name_{name}, size_{image.size()}, dims_{tile_count}
 {
-    fm_assert(num_tiles() <= std::numeric_limits<decltype(tile_image::variant)>::max());
+    constexpr auto variant_max = std::numeric_limits<variant_t>::max();
+    fm_assert(num_tiles() <= variant_max);
     fm_assert(dims_[0] > 0 && dims_[1] > 0);
     fm_assert(size_ % Vector2ui{tile_count} == Vector2ui());
     tex_.setWrapping(GL::SamplerWrapping::ClampToEdge)
diff --git a/src/tile-image.cpp b/src/tile-image.cpp
index c9dc24f4..5d9d9f11 100644
--- a/src/tile-image.cpp
+++ b/src/tile-image.cpp
@@ -2,18 +2,16 @@
 
 namespace floormat {
 
-bool operator==(const tile_image_proto& a, const tile_image_proto& b) noexcept = default;
-
-tile_image_ref::tile_image_ref(std::shared_ptr<tile_atlas>& atlas, std::uint16_t& variant) noexcept :
-    atlas{atlas}, variant{variant}
+bool operator==(const tile_image_proto& a, const tile_image_proto& b) noexcept
 {
+    return a.atlas == b.atlas && a.variant == b.variant;
 }
 
-tile_image_ref& tile_image_ref::operator=(tile_image_ref&& ref) noexcept
+tile_image_proto::operator bool() const noexcept { return atlas != nullptr; }
+
+tile_image_ref::tile_image_ref(std::shared_ptr<tile_atlas>& atlas, std::uint16_t& variant) noexcept :
+    atlas{atlas}, variant{variant}
 {
-    atlas = ref.atlas;
-    variant = ref.variant;
-    return *this;
 }
 
 tile_image_ref& tile_image_ref::operator=(const tile_image_proto& proto) noexcept
@@ -24,11 +22,12 @@ tile_image_ref& tile_image_ref::operator=(const tile_image_proto& proto) noexcep
 }
 
 tile_image_ref::tile_image_ref(const tile_image_ref&) noexcept = default;
-tile_image_ref::tile_image_ref(tile_image_ref&&) noexcept = default;
 
 tile_image_ref::operator tile_image_proto() const noexcept
 {
     return { atlas, variant };
 }
 
+tile_image_ref::operator bool() const noexcept { return atlas != nullptr; }
+
 } // namespace floormat
diff --git a/src/tile-image.hpp b/src/tile-image.hpp
index 033d3916..5a13e13f 100644
--- a/src/tile-image.hpp
+++ b/src/tile-image.hpp
@@ -1,16 +1,20 @@
 #pragma once
 #include "compat/integer-types.hpp"
+#include <memory>
 
 namespace floormat {
 
 struct tile_atlas;
 
+using variant_t = std::uint16_t;
+
 struct tile_image_proto final
 {
     std::shared_ptr<tile_atlas> atlas;
-    std::uint16_t variant = (std::uint16_t)-1;
+    variant_t variant = (std::uint16_t)-1;
 
     friend bool operator==(const tile_image_proto& a, const tile_image_proto& b) noexcept;
+    operator bool() const noexcept;
 };
 
 struct tile_image_ref final
@@ -21,9 +25,9 @@ struct tile_image_ref final
     tile_image_ref(std::shared_ptr<tile_atlas>& atlas, std::uint16_t& variant) noexcept;
     tile_image_ref(const tile_image_ref&) noexcept;
     tile_image_ref(tile_image_ref&&) noexcept;
-    tile_image_ref& operator=(tile_image_ref&& tile_rvalue_ref) noexcept;
     tile_image_ref& operator=(const tile_image_proto& tile_proto) noexcept;
     operator tile_image_proto() const noexcept;
+    operator bool() const noexcept;
 };
 
 } // namespace floormat
diff --git a/src/tile-iterator.cpp b/src/tile-iterator.cpp
index 943bbaf8..6dfc5f6d 100644
--- a/src/tile-iterator.cpp
+++ b/src/tile-iterator.cpp
@@ -8,12 +8,12 @@ tile_iterator::tile_iterator(const tile_iterator&) noexcept = default;
 tile_iterator& tile_iterator::operator=(const tile_iterator&) noexcept = default;
 
 tile_iterator& tile_iterator::operator++() noexcept { pos++; return *this; }
-tile_iterator tile_iterator::operator++() noexcept { auto it = *this; pos++; return it; }
+tile_iterator tile_iterator::operator++(int) noexcept { auto it = *this; pos++; return it; }
 void tile_iterator::swap(tile_iterator& other) noexcept { std::swap(c, other.c); std::swap(pos, other.pos); }
 
-std::strong_ordering tile_iterator::operator<=>(const tile_iterator&) const noexcept = default;
+bool operator==(const tile_iterator& a, const tile_iterator& b) noexcept { return a.c == b.c && a.pos == b.pos; }
 
-tile_iterator_tuple tile_iterator::operator->() { return { tile_ref{*c, i}, i, local_coords{i} }; }
-tile_iterator_tuple tile_iterator::operator*()  { return { tile_ref{*c, i}, i, local_coords{i} }; }
+tile_iterator_tuple tile_iterator::operator->() noexcept { return { tile_ref{*c, std::uint8_t(pos)}, pos, local_coords{pos} }; }
+tile_iterator_tuple tile_iterator::operator*()  noexcept { return { tile_ref{*c, std::uint8_t(pos)}, pos, local_coords{pos} }; }
 
 } // namespace floormat
diff --git a/src/tile-iterator.hpp b/src/tile-iterator.hpp
index 2f860380..5d999716 100644
--- a/src/tile-iterator.hpp
+++ b/src/tile-iterator.hpp
@@ -3,7 +3,6 @@
 #include "compat/integer-types.hpp"
 #include "local-coords.hpp"
 #include "tile.hpp"
-#include <compare>
 
 namespace floormat {
 
@@ -11,21 +10,22 @@ struct tile_iterator_tuple final { // NOLINT(cppcoreguidelines-pro-type-member-i
     const tile_iterator_tuple* operator->() const noexcept { return this; }
     tile_iterator_tuple* operator->() noexcept { return this; }
 
-    tile_ref tile;
-    std::size_t i;
-    local_coords pos;
+    tile_ref x;
+    std::size_t k;
+    local_coords pt;
 };
 
 class tile_iterator final {
     chunk* c;
     std::size_t pos;
 
+    friend bool operator==(const tile_iterator&, const tile_iterator&) noexcept;
+
 public:
     explicit tile_iterator(chunk& c, std::size_t pos) noexcept;
     tile_iterator(const tile_iterator&) noexcept;
     tile_iterator& operator=(const tile_iterator&) noexcept;
 
-    std::strong_ordering operator<=>(const tile_iterator&) const noexcept;
     void swap(tile_iterator& other) noexcept;
 
     tile_iterator& operator++() noexcept;
diff --git a/src/tile.cpp b/src/tile.cpp
index 4bf3ae3e..920ee2e5 100644
--- a/src/tile.cpp
+++ b/src/tile.cpp
@@ -29,27 +29,41 @@ pass_mode_ref::operator pass_mode() const noexcept
     return pass_mode(ret);
 }
 
-bool operator==(const tile_proto&, const tile_proto&) noexcept = default;
+bool operator==(const tile_proto& a, const tile_proto& b) noexcept {
+    return a.ground_image()     == b.ground_image() &&
+           a.wall_north_image() == b.wall_north_image() &&
+           a.wall_west_image()  == b.wall_west_image();
+};
 
-tile_ref::tile_ref(struct chunk& c, std::uint8_t i) noexcept : _chunk{&c}, i{i}
-{
-}
+tile_image_proto tile_proto::ground_image() const noexcept     { return { ground_atlas, ground_variant         }; }
+tile_image_proto tile_proto::wall_north_image() const noexcept { return { wall_north_atlas, wall_north_variant }; }
+tile_image_proto tile_proto::wall_west_image() const noexcept  { return { wall_west_atlas, wall_west_variant   }; }
+
+tile_ref::tile_ref(struct chunk& c, std::uint8_t i) noexcept : _chunk{&c}, i{i} {}
+
+std::shared_ptr<tile_atlas> tile_ref::ground_atlas()                  noexcept { return _chunk->_ground_atlases[i]; }
+std::shared_ptr<tile_atlas> tile_ref::wall_north_atlas()              noexcept { return _chunk->_wall_north_atlases[i]; }
+std::shared_ptr<tile_atlas> tile_ref::wall_west_atlas()               noexcept { return _chunk->_wall_west_atlases[i]; }
+
+std::shared_ptr<const tile_atlas> tile_ref::ground_atlas()      const noexcept { return _chunk->_ground_atlases[i]; }
+std::shared_ptr<const tile_atlas> tile_ref::wall_north_atlas()  const noexcept { return _chunk->_wall_north_atlases[i]; }
+std::shared_ptr<const tile_atlas> tile_ref::wall_west_atlas()   const noexcept { return _chunk->_wall_west_atlases[i]; }
 
 tile_image_ref tile_ref::ground() noexcept     { return {_chunk->_ground_atlases[i],     _chunk->_ground_variants[i] };     }
 tile_image_ref tile_ref::wall_north() noexcept { return {_chunk->_wall_north_atlases[i], _chunk->_wall_north_variants[i] }; }
 tile_image_ref tile_ref::wall_west() noexcept  { return {_chunk->_wall_west_atlases[i],  _chunk->_wall_west_variants[i] };  }
 
-tile_image_proto tile_ref::ground() const noexcept     { return {_chunk->_ground_atlases[i],     _chunk->_ground_variants[i] };     }
-tile_image_proto tile_ref::wall_north() const noexcept { return {_chunk->_wall_north_atlases[i], _chunk->_wall_north_variants[i] }; }
-tile_image_proto tile_ref::wall_west() const noexcept  { return {_chunk->_wall_west_atlases[i],  _chunk->_wall_west_variants[i] };  }
+tile_image_proto tile_ref::ground() const noexcept     { return { _chunk->_ground_atlases[i],     _chunk->_ground_variants[i] };     }
+tile_image_proto tile_ref::wall_north() const noexcept { return { _chunk->_wall_north_atlases[i], _chunk->_wall_north_variants[i] }; }
+tile_image_proto tile_ref::wall_west() const noexcept  { return { _chunk->_wall_west_atlases[i],  _chunk->_wall_west_variants[i] };  }
 
 pass_mode_ref tile_ref::pass_mode() noexcept { return { *_chunk, i }; }
-pass_mode tile_ref::pass_mode() const noexcept { return pass_mode_ref { *const_cast<chunk*>(_chunk), i }; }
+pass_mode tile_ref::pass_mode() const noexcept { return pass_mode_ref { *const_cast<struct chunk*>(_chunk), i }; }
 
 tile_ref::operator tile_proto() const noexcept
 {
     return {
-        _chunk->_ground_atlases[i], _chunk->_wall_north_atlases[i], _chunk->_wall_west_atlases[i],
+        _chunk->_ground_atlases[i],  _chunk->_wall_north_atlases[i],  _chunk->_wall_west_atlases[i],
         _chunk->_ground_variants[i], _chunk->_wall_north_variants[i], _chunk->_wall_west_variants[i],
         pass_mode(),
     };
diff --git a/src/tile.hpp b/src/tile.hpp
index 4bfeb84a..8061035f 100644
--- a/src/tile.hpp
+++ b/src/tile.hpp
@@ -6,7 +6,8 @@ namespace floormat {
 
 struct chunk;
 
-enum pass_mode : std::uint8_t { pass_ok, pass_blocked, pass_shoot_through, };
+// zero is the default, see bitset in chunk.hpp
+enum pass_mode : std::uint8_t { pass_shoot_through, pass_ok, pass_blocked, };
 
 struct pass_mode_ref final
 {
@@ -26,6 +27,10 @@ struct tile_proto final
     std::uint16_t ground_variant = 0xffff, wall_north_variant = 0xffff, wall_west_variant = 0xffff;
     pass_mode pass_mode = pass_mode::pass_shoot_through;
 
+    tile_image_proto ground_image() const noexcept;
+    tile_image_proto wall_north_image() const noexcept;
+    tile_image_proto wall_west_image() const noexcept;
+
     friend bool operator==(const tile_proto& a, const tile_proto& b) noexcept;
 };
 
@@ -41,6 +46,14 @@ struct tile_ref final
     tile_image_proto wall_north() const noexcept;
     tile_image_proto wall_west() const noexcept;
 
+    std::shared_ptr<tile_atlas> ground_atlas() noexcept;
+    std::shared_ptr<tile_atlas> wall_north_atlas() noexcept;
+    std::shared_ptr<tile_atlas> wall_west_atlas() noexcept;
+
+    std::shared_ptr<const tile_atlas> ground_atlas() const noexcept;
+    std::shared_ptr<const tile_atlas> wall_north_atlas() const noexcept;
+    std::shared_ptr<const tile_atlas> wall_west_atlas() const noexcept;
+
     pass_mode_ref pass_mode() noexcept;
     enum pass_mode pass_mode() const noexcept;
 
diff --git a/src/world.hpp b/src/world.hpp
index ae7b6240..9b58ff3d 100644
--- a/src/world.hpp
+++ b/src/world.hpp
@@ -29,7 +29,7 @@ private:
 public:
     explicit world();
 
-    struct pair final { chunk& c; tile& t; }; // NOLINT(cppcoreguidelines-avoid-const-or-ref-data-members)
+    struct pair final { chunk& c; tile_ref t; };
 
     template<typename Hash, typename Alloc, typename Pred>
     explicit world(std::unordered_map<chunk_coords, chunk, Hash, Alloc, Pred>&& chunks);