src/chunk: plug in lqt for collision detection

10 files changed, 204 insertions, 170 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index d30bf88d..b7ef8bd6 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,5 +1,5 @@
 set(self floormat)
-file(GLOB sources "*.cpp" "../shaders/*.cpp" CONFIGURE_ARGS)
+file(GLOB sources *.cpp ../shaders/*.cpp ../compat/*.cpp CONFIGURE_ARGS)
 add_library(${self} OBJECT "${sources}")
 target_link_libraries(
     ${self} PUBLIC
diff --git a/src/chunk-render.cpp b/src/chunk-render.cpp
new file mode 100644
index 00000000..37440af9
--- /dev/null
+++ b/src/chunk-render.cpp
@@ -0,0 +1,107 @@
+#include "chunk.hpp"
+#include "tile-atlas.hpp"
+#include "shaders/tile.hpp"
+#include <algorithm>
+#include <Magnum/GL/Buffer.h>
+#include <Corrade/Containers/ArrayViewStl.h>
+
+namespace floormat {
+
+static auto make_index_array(std::size_t offset)
+{
+    std::array<std::array<UnsignedShort, 6>, TILE_COUNT> array; // NOLINT(cppcoreguidelines-pro-type-member-init)
+    for (std::size_t i = 0; i < TILE_COUNT; i++)
+        array[i] = tile_atlas::indices(i + offset);
+    return array;
+}
+
+struct vertex {
+    Vector3 position;
+    Vector2 texcoords;
+    float depth = -1;
+};
+
+auto chunk::ensure_ground_mesh() noexcept -> ground_mesh_tuple
+{
+    if (!_ground_modified)
+        return { ground_mesh, ground_indexes };
+    _ground_modified = false;
+
+    for (std::size_t i = 0; i < TILE_COUNT; i++)
+        ground_indexes[i] = std::uint8_t(i);
+    std::sort(ground_indexes.begin(), ground_indexes.end(), [this](std::uint8_t a, std::uint8_t b) {
+        return _ground_atlases[a].get() < _ground_atlases[b].get();
+    });
+
+    std::array<std::array<vertex, 4>, TILE_COUNT> vertexes;
+    for (std::size_t k = 0; k < TILE_COUNT; k++)
+    {
+        const std::uint8_t i = ground_indexes[k];
+        if (auto atlas = _ground_atlases[i]; !atlas)
+            vertexes[k] = {};
+        else
+        {
+            const local_coords pos{i};
+            const auto quad = atlas->floor_quad(Vector3(pos.x, pos.y, 0) * TILE_SIZE, TILE_SIZE2);
+            const auto texcoords = atlas->texcoords_for_id(_ground_variants[i]);
+            const float depth = tile_shader::depth_value(pos);
+            auto& v = vertexes[k];
+            for (std::size_t j = 0; j < 4; j++)
+                v[j] = { quad[j], texcoords[j], depth };
+        }
+    }
+    const auto indexes = make_index_array(0);
+
+    GL::Mesh mesh{GL::MeshPrimitive::Triangles};
+    mesh.addVertexBuffer(GL::Buffer{vertexes}, 0, tile_shader::Position{}, tile_shader::TextureCoordinates{}, tile_shader::Depth{})
+        .setIndexBuffer(GL::Buffer{indexes}, 0, GL::MeshIndexType::UnsignedShort)
+        .setCount(6 * TILE_COUNT);
+    ground_mesh = Utility::move(mesh);
+    return { ground_mesh, ground_indexes };
+}
+
+auto chunk::ensure_wall_mesh() noexcept -> wall_mesh_tuple
+{
+    if (!_walls_modified)
+        return { wall_mesh, wall_indexes };
+    _walls_modified = false;
+
+    for (std::size_t i = 0; i < TILE_COUNT*2; i++)
+        wall_indexes[i] = std::uint16_t(i);
+
+    std::sort(wall_indexes.begin(), wall_indexes.end(), [this](std::uint16_t a, std::uint16_t b) {
+        return _wall_atlases[a] < _wall_atlases[b];
+    });
+
+    std::array<std::array<vertex, 4>, TILE_COUNT*2> vertexes;
+    for (std::size_t k = 0; k < TILE_COUNT*2; k++)
+    {
+        const std::uint16_t i = wall_indexes[k];
+        if (const auto& atlas = _wall_atlases[i]; !atlas)
+            vertexes[k] = {};
+        else
+        {
+            const auto& variant = _wall_variants[i];
+            const local_coords pos{i / 2u};
+            const auto center = Vector3(pos.x, pos.y, 0) * TILE_SIZE;
+            const auto quad = i & 1 ? atlas->wall_quad_W(center, TILE_SIZE) : atlas->wall_quad_N(center, TILE_SIZE);
+            const float depth = tile_shader::depth_value(pos);
+            const auto texcoords = atlas->texcoords_for_id(variant);
+            auto& v = vertexes[k];
+            for (std::size_t j = 0; j < 4; j++)
+                v[j] = { quad[j], texcoords[j], depth, };
+        }
+    }
+
+    using index_t = std::array<std::array<UnsignedShort, 6>, TILE_COUNT>;
+    const index_t indexes[2] = { make_index_array(0), make_index_array(TILE_COUNT) };
+
+    GL::Mesh mesh{GL::MeshPrimitive::Triangles};
+    mesh.addVertexBuffer(GL::Buffer{vertexes}, 0, tile_shader::Position{}, tile_shader::TextureCoordinates{}, tile_shader::Depth{})
+        .setIndexBuffer(GL::Buffer{indexes}, 0, GL::MeshIndexType::UnsignedShort)
+        .setCount(6 * TILE_COUNT);
+    wall_mesh = Utility::move(mesh);
+    return { wall_mesh, wall_indexes };
+}
+
+} // namespace floormat
diff --git a/src/chunk.cpp b/src/chunk.cpp
index 55afe1b9..e66b193a 100644
--- a/src/chunk.cpp
+++ b/src/chunk.cpp
@@ -1,9 +1,6 @@
 #include "chunk.hpp"
-#include "tile-atlas.hpp"
-#include "shaders/tile.hpp"
-#include <algorithm>
-#include <Corrade/Containers/ArrayViewStl.h>
-#include <Magnum/GL/Buffer.h>
+#include "compat/LooseQuadtree-impl.h"
+#include "src/tile-atlas.hpp"
 
 namespace floormat {
 
@@ -27,133 +24,97 @@ bool chunk::empty(bool force) const noexcept
 tile_atlas* chunk::ground_atlas_at(std::size_t i) const noexcept { return _ground_atlases[i].get(); }
 tile_atlas* chunk::wall_atlas_at(std::size_t i) const noexcept { return _wall_atlases[i].get(); }
 
-static auto make_index_array(std::size_t offset)
-{
-    std::array<std::array<UnsignedShort, 6>, TILE_COUNT> array; // NOLINT(cppcoreguidelines-pro-type-member-init)
-    for (std::size_t i = 0; i < TILE_COUNT; i++)
-        array[i] = tile_atlas::indices(i + offset);
-    return array;
-}
+tile_ref chunk::operator[](std::size_t idx) noexcept { return { *this, std::uint8_t(idx) }; }
+tile_proto chunk::operator[](std::size_t idx) const noexcept { return tile_proto(tile_ref { *const_cast<chunk*>(this), std::uint8_t(idx) }); }
+tile_ref chunk::operator[](local_coords xy) noexcept { return operator[](xy.to_index()); }
+tile_proto chunk::operator[](local_coords xy) const noexcept { return operator[](xy.to_index()); }
+
+auto chunk::begin() noexcept -> iterator { return iterator { *this, 0 }; }
+auto chunk::end() noexcept -> iterator { return iterator { *this, TILE_COUNT }; }
+auto chunk::cbegin() const noexcept -> const_iterator { return const_iterator { *this, 0 }; }
+auto chunk::cend() const noexcept -> const_iterator { return const_iterator { *this, TILE_COUNT }; }
+auto chunk::begin() const noexcept -> const_iterator { return cbegin(); }
+auto chunk::end() const noexcept -> const_iterator { return cend(); }
 
-struct vertex {
-    Vector3 position;
-    Vector2 texcoords;
-    float depth = -1;
-};
+void chunk::mark_ground_modified() noexcept { _ground_modified = true; _pass_modified = true; }
+void chunk::mark_walls_modified() noexcept { _walls_modified = true; _pass_modified = true; }
+void chunk::mark_scenery_modified() noexcept { _scenery_modified = true; _pass_modified = true; }
 
-auto chunk::ensure_ground_mesh() noexcept -> ground_mesh_tuple
+void chunk::mark_modified() noexcept
 {
-    if (!_ground_modified)
-        return { ground_mesh, ground_indexes };
-    _ground_modified = false;
+    mark_ground_modified();
+    mark_walls_modified();
+    mark_scenery_modified();
+}
 
-    for (std::size_t i = 0; i < TILE_COUNT; i++)
-        ground_indexes[i] = std::uint8_t(i);
-    std::sort(ground_indexes.begin(), ground_indexes.end(), [this](std::uint8_t a, std::uint8_t b) {
-        return _ground_atlases[a].get() < _ground_atlases[b].get();
-    });
+static constexpr auto tile_size2us = Vector2us(iTILE_SIZE2);
 
-    std::array<std::array<vertex, 4>, TILE_COUNT> vertexes;
-    for (std::size_t k = 0; k < TILE_COUNT; k++)
-    {
-        const std::uint8_t i = ground_indexes[k];
-        if (auto atlas = _ground_atlases[i]; !atlas)
-            vertexes[k] = {};
-        else
-        {
-            const local_coords pos{i};
-            const auto quad = atlas->floor_quad(Vector3(pos.x, pos.y, 0) * TILE_SIZE, TILE_SIZE2);
-            const auto texcoords = atlas->texcoords_for_id(_ground_variants[i]);
-            const float depth = tile_shader::depth_value(pos);
-            auto& v = vertexes[k];
-            for (std::size_t j = 0; j < 4; j++)
-                v[j] = { quad[j], texcoords[j], depth };
-        }
-    }
-    const auto indexes = make_index_array(0);
-
-    GL::Mesh mesh{GL::MeshPrimitive::Triangles};
-    mesh.addVertexBuffer(GL::Buffer{vertexes}, 0, tile_shader::Position{}, tile_shader::TextureCoordinates{}, tile_shader::Depth{})
-        .setIndexBuffer(GL::Buffer{indexes}, 0, GL::MeshIndexType::UnsignedShort)
-        .setCount(6 * TILE_COUNT);
-    ground_mesh = Utility::move(mesh);
-    return { ground_mesh, ground_indexes };
+static constexpr Vector2s tile_start(std::size_t k)
+{
+    const auto i = std::uint8_t(k);
+    const local_coords coord{i};
+    constexpr auto tile_size2s = Vector2s(tile_size2us), half = tile_size2s/2;
+    return tile_size2s * Vector2s(coord.x, coord.y) - half;
 }
 
-auto chunk::ensure_wall_mesh() noexcept -> wall_mesh_tuple
+auto chunk::ensure_passability() noexcept -> lqt&
 {
-    if (!_walls_modified)
-        return { wall_mesh, wall_indexes };
-    _walls_modified = false;
+    auto& qt = *_static_lqt;
+
+    if (!_pass_modified)
+        return qt;
+    _pass_modified = false;
 
-    for (std::size_t i = 0; i < TILE_COUNT*2; i++)
-        wall_indexes[i] = std::uint16_t(i);
+    qt.Clear();
+    _lqt_bboxes.clear();
+    _lqt_bboxes.reserve(32);
 
-    std::sort(wall_indexes.begin(), wall_indexes.end(), [this](std::uint16_t a, std::uint16_t b) {
-        return _wall_atlases[a] < _wall_atlases[b];
-    });
+    constexpr auto whole_tile = [](std::size_t k, pass_mode p) constexpr -> bbox {
+        auto start = tile_start(k);
+        return { start[0], start[1], tile_size2us[0], tile_size2us[1], p };
+    };
 
-    std::array<std::array<vertex, 4>, TILE_COUNT*2> vertexes;
-    for (std::size_t k = 0; k < TILE_COUNT*2; k++)
+    constexpr auto wall_north = [](std::size_t k, pass_mode p) constexpr -> bbox {
+        auto start = tile_start(k) - Vector2s(0, 1);
+        return { start[0], start[1], tile_size2us[0], 2, p };
+    };
+
+    constexpr auto wall_west = [](std::size_t k, pass_mode p) constexpr -> bbox {
+        auto start = tile_start(k) - Vector2s(1, 0);
+        return { start[0], start[1], 2, tile_size2us[1], p };
+    };
+
+    for (std::size_t i = 0; i < TILE_COUNT; i++)
     {
-        const std::uint16_t i = wall_indexes[k];
-        if (const auto& atlas = _wall_atlases[i]; !atlas)
-            vertexes[k] = {};
-        else
-        {
-            const auto& variant = _wall_variants[i];
-            const local_coords pos{i / 2u};
-            const auto center = Vector3(pos.x, pos.y, 0) * TILE_SIZE;
-            const auto quad = i & 1 ? atlas->wall_quad_W(center, TILE_SIZE) : atlas->wall_quad_N(center, TILE_SIZE);
-            const float depth = tile_shader::depth_value(pos);
-            const auto texcoords = atlas->texcoords_for_id(variant);
-            auto& v = vertexes[k];
-            for (std::size_t j = 0; j < 4; j++)
-                v[j] = { quad[j], texcoords[j], depth, };
-        }
+        const auto tile = const_cast<chunk&>(*this)[i];
+        if (auto s = tile.scenery())
+            if (auto p = s.frame.passability; p != pass_mode::pass)
+                _lqt_bboxes.push_back(whole_tile(i, p));
+        if (auto atlas = tile.ground_atlas())
+            if (auto p = atlas->pass_mode(pass_mode::pass); p != pass_mode::pass)
+                _lqt_bboxes.push_back(whole_tile(i, p));
+        if (auto atlas = tile.wall_north_atlas())
+            if (auto p = atlas->pass_mode(pass_mode::blocked); p != pass_mode::pass)
+                _lqt_bboxes.push_back(wall_north(i, p));
+        if (auto atlas = tile.wall_west_atlas())
+            if (auto p = atlas->pass_mode(pass_mode::blocked); p != pass_mode::pass)
+                _lqt_bboxes.push_back(wall_west(i, p));
     }
 
-    using index_t = std::array<std::array<UnsignedShort, 6>, TILE_COUNT>;
-    const index_t indexes[2] = { make_index_array(0), make_index_array(TILE_COUNT) };
+    for (auto& bbox : _lqt_bboxes)
+        qt.Insert(&bbox);
 
-    GL::Mesh mesh{GL::MeshPrimitive::Triangles};
-    mesh.addVertexBuffer(GL::Buffer{vertexes}, 0, tile_shader::Position{}, tile_shader::TextureCoordinates{}, tile_shader::Depth{})
-        .setIndexBuffer(GL::Buffer{indexes}, 0, GL::MeshIndexType::UnsignedShort)
-        .setCount(6 * TILE_COUNT);
-    wall_mesh = Utility::move(mesh);
-    return { wall_mesh, wall_indexes };
+    return qt;
 }
 
-fm_noinline
-chunk::chunk() noexcept // NOLINT(modernize-use-equals-default)
+void chunk::bb_extractor::ExtractBoundingBox(const chunk::bbox* x, BB* bbox)
 {
-    //fm_debug("chunk ctor");
+    *bbox = { x->left, x->top, std::int16_t(x->width), std::int16_t(x->height) };
 }
 
-tile_ref chunk::operator[](std::size_t idx) noexcept { return { *this, std::uint8_t(idx) }; }
-tile_proto chunk::operator[](std::size_t idx) const noexcept { return tile_proto(tile_ref { *const_cast<chunk*>(this), std::uint8_t(idx) }); }
-tile_ref chunk::operator[](local_coords xy) noexcept { return operator[](xy.to_index()); }
-tile_proto chunk::operator[](local_coords xy) const noexcept { return operator[](xy.to_index()); }
-
-auto chunk::begin() noexcept -> iterator { return iterator { *this, 0 }; }
-auto chunk::end() noexcept -> iterator { return iterator { *this, TILE_COUNT }; }
-auto chunk::cbegin() const noexcept -> const_iterator { return const_iterator { *this, 0 }; }
-auto chunk::cend() const noexcept -> const_iterator { return const_iterator { *this, TILE_COUNT }; }
-auto chunk::begin() const noexcept -> const_iterator { return cbegin(); }
-auto chunk::end() const noexcept -> const_iterator { return cend(); }
-
+chunk::chunk() noexcept : _static_lqt { std::make_unique<lqt>() } {}
+chunk::~chunk() noexcept = default;
 chunk::chunk(chunk&&) noexcept = default;
 chunk& chunk::operator=(chunk&&) noexcept = default;
 
-void chunk::mark_ground_modified() noexcept { _ground_modified = true; }
-void chunk::mark_walls_modified() noexcept { _walls_modified = true; }
-void chunk::mark_scenery_modified() noexcept { _scenery_modified = true; }
-
-void chunk::mark_modified() noexcept
-{
-    mark_ground_modified();
-    mark_walls_modified();
-    mark_scenery_modified();
-}
-
 } // namespace floormat
diff --git a/src/chunk.hpp b/src/chunk.hpp
index 9acd5f12..d66dfdc8 100644
--- a/src/chunk.hpp
+++ b/src/chunk.hpp
@@ -4,8 +4,12 @@
 #include "scenery.hpp"
 #include <type_traits>
 #include <array>
-#include <bitset>
+#include <vector>
+#include <memory>
 #include <Magnum/GL/Mesh.h>
+#include "compat/LooseQuadtree.h"
+
+namespace loose_quadtree { template<typename NumberT, typename ObjectT, typename BoundingBoxExtractorT> class LooseQuadtree; }
 
 namespace floormat {
 
@@ -14,7 +18,6 @@ struct anim_atlas;
 struct chunk final
 {
     friend struct tile_ref;
-    friend struct pass_mode_ref;
 
     tile_ref operator[](std::size_t idx) noexcept;
     tile_proto operator[](std::size_t idx) const noexcept;
@@ -34,6 +37,7 @@ struct chunk final
     bool empty(bool force = false) const noexcept;
 
     chunk() noexcept;
+    ~chunk() noexcept;
     chunk(const chunk&) = delete;
     chunk& operator=(const chunk&) = delete;
     chunk(chunk&&) noexcept;
@@ -59,6 +63,12 @@ struct chunk final
     wall_mesh_tuple ensure_wall_mesh() noexcept;
     tile_atlas* wall_atlas_at(std::size_t i) const noexcept;
 
+    struct bbox final { std::int16_t left, top; std::uint16_t width, height; enum pass_mode pass_mode; };
+    using BB = loose_quadtree::BoundingBox<std::int16_t>;
+    struct bb_extractor { static void ExtractBoundingBox(const bbox* object, BB* bbox); };
+    using lqt = loose_quadtree::LooseQuadtree<std::int16_t, bbox, bb_extractor>;
+    lqt& ensure_passability() noexcept;
+
 private:
     std::array<std::shared_ptr<tile_atlas>, TILE_COUNT> _ground_atlases;
     std::array<std::uint8_t, TILE_COUNT> ground_indexes = {};
@@ -68,12 +78,16 @@ private:
     std::array<variant_t, TILE_COUNT*2> _wall_variants = {};
     std::array<std::shared_ptr<anim_atlas>, TILE_COUNT> _scenery_atlases;
     std::array<scenery, TILE_COUNT> _scenery_variants = {};
-    std::bitset<TILE_COUNT*2> _passability = {};
+
+    std::unique_ptr<lqt> _static_lqt;
+    std::vector<bbox> _lqt_bboxes;
+
     GL::Mesh ground_mesh{NoCreate}, wall_mesh{NoCreate};
     mutable bool _maybe_empty      : 1 = true,
                  _ground_modified  : 1 = true,
                  _walls_modified   : 1 = true,
-                 _scenery_modified : 1 = true;
+                 _scenery_modified : 1 = true,
+                 _pass_modified    : 1 = true;
 };
 
 } // namespace floormat
diff --git a/src/pass-mode.hpp b/src/pass-mode.hpp
index a60a8188..112aafcc 100644
--- a/src/pass-mode.hpp
+++ b/src/pass-mode.hpp
@@ -3,8 +3,7 @@
 
 namespace floormat {
 
-enum class pass_mode : std::uint8_t { shoot_through, pass, blocked, see_through };
-constexpr inline std::uint8_t pass_mode_COUNT = std::uint8_t(pass_mode::see_through) + 1;
-static_assert(pass_mode_COUNT == 4);
+enum class pass_mode : std::uint8_t { blocked, see_through, shoot_through, pass, };
+constexpr inline std::uint8_t pass_mode_COUNT = 4;
 
 } // namespace floormat
diff --git a/src/scenery.hpp b/src/scenery.hpp
index 5cfe3827..04fcf984 100644
--- a/src/scenery.hpp
+++ b/src/scenery.hpp
@@ -36,7 +36,7 @@ struct scenery final
     frame_t frame = 0;
     rotation     r           : 3 = rotation::N;
     scenery_type type        : 3 = scenery_type::none;
-    pass_mode    passability : 2 = pass_mode{0};
+    pass_mode    passability : 2 = pass_mode::pass;
     std::uint8_t active      : 1 = false;
     std::uint8_t closing     : 1 = false;
     std::uint8_t interactive : 1 = false;
diff --git a/src/tile-atlas.cpp b/src/tile-atlas.cpp
index 6f9e832f..b13b9ea8 100644
--- a/src/tile-atlas.cpp
+++ b/src/tile-atlas.cpp
@@ -57,6 +57,7 @@ auto tile_atlas::make_texcoords_array(Vector2ui pixel_size, Vector2ub tile_count
 
 std::size_t tile_atlas::num_tiles() const { return Vector2ui{dims_}.product(); }
 Optional<enum pass_mode> tile_atlas::pass_mode() const { return passability; }
+enum pass_mode tile_atlas::pass_mode(enum pass_mode p) const { return passability ? *passability : p; }
 
 void tile_atlas::set_pass_mode(enum pass_mode p)
 {
diff --git a/src/tile-atlas.hpp b/src/tile-atlas.hpp
index 61f528ef..e4ac8412 100644
--- a/src/tile-atlas.hpp
+++ b/src/tile-atlas.hpp
@@ -28,6 +28,7 @@ struct tile_atlas final
     GL::Texture2D& texture() { return tex_; }
     StringView name() const { return name_; }
     Optional<enum pass_mode> pass_mode() const;
+    enum pass_mode pass_mode(enum pass_mode p) const;
     void set_pass_mode(enum pass_mode p);
 
 private:
diff --git a/src/tile.cpp b/src/tile.cpp
index 419e59a3..34d2a6e1 100644
--- a/src/tile.cpp
+++ b/src/tile.cpp
@@ -3,33 +3,6 @@
 
 namespace floormat {
 
-pass_mode_ref::pass_mode_ref(chunk& c, std::uint8_t i) noexcept : _chunk{&c}, i{i}
-{
-}
-
-pass_mode_ref& pass_mode_ref::operator=(pass_mode val) noexcept
-{
-    auto x = std::underlying_type_t<pass_mode>(val) & pass_mode_COUNT;
-    auto& bitset = _chunk->_passability;
-    bitset[i*2 + 0] = x & 1;
-    bitset[i*2 + 1] = x >> 1 & 1;
-    return *this;
-}
-
-pass_mode_ref& pass_mode_ref::operator=(const pass_mode_ref& x) noexcept
-{
-    return operator=(pass_mode(x)); // NOLINT(misc-unconventional-assign-operator)
-}
-
-pass_mode_ref::operator pass_mode() const noexcept
-{
-    auto& bitset = _chunk->_passability;
-    std::uint8_t ret = 0;
-    ret |= (std::uint8_t)bitset[i*2 + 1];
-    ret |= (std::uint8_t)bitset[i*2 + 0] << 1;
-    return pass_mode(ret);
-}
-
 bool operator==(const tile_proto& a, const tile_proto& b) noexcept {
     return a.ground()     == b.ground() &&
            a.wall_north() == b.wall_north() &&
@@ -64,15 +37,11 @@ tile_image_proto tile_ref::wall_north() const noexcept { return { _chunk->_wall_
 tile_image_proto tile_ref::wall_west() const noexcept  { return { _chunk->_wall_atlases[i*2+1],  _chunk->_wall_variants[i*2+1] };  }
 scenery_proto tile_ref::scenery() const noexcept       { return { _chunk->_scenery_atlases[i],    _chunk->_scenery_variants[i] }; }
 
-pass_mode_ref tile_ref::passability() noexcept { return { *_chunk, i }; }
-pass_mode tile_ref::passability() 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_atlases[i*2+0],  _chunk->_wall_atlases[i*2+1], _chunk->_scenery_atlases[i],
         _chunk->_ground_variants[i], _chunk->_wall_variants[i*2+0], _chunk->_wall_variants[i*2+1], _chunk->_scenery_variants[i],
-        passability(),
     };
 }
 
@@ -84,8 +53,7 @@ bool operator==(const tile_ref& a, const tile_ref& b) noexcept
         return a.ground()     == b.ground() &&
                a.wall_north() == b.wall_north() &&
                a.wall_west()  == b.wall_west() &&
-               a.scenery()    == b.scenery() &&
-               a.passability()  == b.passability();
+               a.scenery()    == b.scenery();
 }
 
 } // namespace floormat
diff --git a/src/tile.hpp b/src/tile.hpp
index 543b70b6..7a6604dd 100644
--- a/src/tile.hpp
+++ b/src/tile.hpp
@@ -1,32 +1,18 @@
 #pragma once
 #include "tile-image.hpp"
 #include "scenery.hpp"
-#include "pass-mode.hpp"
 
 namespace floormat {
 
 struct chunk;
 struct anim_atlas;
 
-struct pass_mode_ref final
-{
-    pass_mode_ref(chunk& c, std::uint8_t i) noexcept;
-    pass_mode_ref& operator=(pass_mode x) noexcept;
-    pass_mode_ref& operator=(const pass_mode_ref& x) noexcept;
-    operator pass_mode() const noexcept;
-
-private:
-    chunk* _chunk;
-    std::uint8_t i;
-};
-
 struct tile_proto final
 {
     std::shared_ptr<tile_atlas> ground_atlas, wall_north_atlas, wall_west_atlas;
     std::shared_ptr<anim_atlas> scenery_atlas;
     variant_t ground_variant = 0, wall_north_variant = 0, wall_west_variant = 0;
     struct scenery scenery_frame;
-    pass_mode passability = pass_mode{0};
 
     tile_image_proto ground() const noexcept;
     tile_image_proto wall_north() const noexcept;
@@ -60,9 +46,6 @@ struct tile_ref final
     std::shared_ptr<const tile_atlas> wall_west_atlas() const noexcept;
     std::shared_ptr<const anim_atlas> scenery_atlas() const noexcept;
 
-    pass_mode_ref passability() noexcept;
-    pass_mode passability() const noexcept;
-
     explicit operator tile_proto() const noexcept;
 
     struct chunk& chunk() noexcept { return *_chunk; }