work on new drawing functions (AlpineMapsOrg#162)

Author: adam-ce

nucleus/camera/PositionStorage.cpp

@@ -22,15 +22,15 @@
 
 namespace nucleus::camera {
 
-PositionStorage* PositionStorage::_instance = nullptr;
+PositionStorage* PositionStorage::s_instance = nullptr;
 
-const std::map<std::string, Definition>& PositionStorage::positions() const { return _positions; }
+const std::map<std::string, Definition>& PositionStorage::positions() const { return m_positions; }
 
 PositionStorage* PositionStorage::instance()
 {
-    if (_instance == nullptr) {
-        _instance = new PositionStorage;
+    if (s_instance == nullptr) {
+        s_instance = new PositionStorage;
     }
-    return _instance;
+    return s_instance;
 }
 }

nucleus/camera/PositionStorage.h

@@ -94,27 +94,27 @@ class PositionStorage {
 
 private:
     PositionStorage() {
-        _positions.insert({"hochgrubach_spitze", nucleus::camera::stored_positions::oestl_hochgrubach_spitze()});
-        _positions.insert({"stephansdom", nucleus::camera::stored_positions::stephansdom()});
-        _positions.insert({"stephansdom_closeup", nucleus::camera::stored_positions::stephansdom_closeup()});
-        _positions.insert({"grossglockner", nucleus::camera::stored_positions::grossglockner()});
-        _positions.insert({"grossglockner_topdown", nucleus::camera::stored_positions::grossglockner_topdown()});
-        _positions.insert({"schneeberg", nucleus::camera::stored_positions::schneeberg()});
-        _positions.insert({"karwendel", nucleus::camera::stored_positions::karwendel()});
-        _positions.insert({"wien", nucleus::camera::stored_positions::wien()});
-        _positions.insert({"grossglockner_shadow", nucleus::camera::stored_positions::grossglockner_shadow()});
-        _positions.insert({"weichtalhaus", nucleus::camera::stored_positions::weichtalhaus()});
+        m_positions.insert({ "hochgrubach_spitze", nucleus::camera::stored_positions::oestl_hochgrubach_spitze() });
+        m_positions.insert({ "stephansdom", nucleus::camera::stored_positions::stephansdom() });
+        m_positions.insert({ "stephansdom_closeup", nucleus::camera::stored_positions::stephansdom_closeup() });
+        m_positions.insert({ "grossglockner", nucleus::camera::stored_positions::grossglockner() });
+        m_positions.insert({ "grossglockner_topdown", nucleus::camera::stored_positions::grossglockner_topdown() });
+        m_positions.insert({ "schneeberg", nucleus::camera::stored_positions::schneeberg() });
+        m_positions.insert({ "karwendel", nucleus::camera::stored_positions::karwendel() });
+        m_positions.insert({ "wien", nucleus::camera::stored_positions::wien() });
+        m_positions.insert({ "grossglockner_shadow", nucleus::camera::stored_positions::grossglockner_shadow() });
+        m_positions.insert({ "weichtalhaus", nucleus::camera::stored_positions::weichtalhaus() });
     }
-    static PositionStorage* _instance;
-    std::map<std::string, nucleus::camera::Definition> _positions;
+    static PositionStorage* s_instance;
+    std::map<std::string, nucleus::camera::Definition> m_positions;
 
 public:
     PositionStorage(PositionStorage &other) = delete;
     void operator=(const PositionStorage &) = delete;
     static PositionStorage *instance();
     nucleus::camera::Definition get(const std::string& name) {
-        auto it = _positions.find(name);
-        if (it != _positions.end()) {
+        auto it = m_positions.find(name);
+        if (it != m_positions.end()) {
             return it->second;
         } else {
             qWarning() << "Position by name" << name << "not existing.";
@@ -124,7 +124,7 @@ class PositionStorage {
 
     nucleus::camera::Definition get_by_index(unsigned id) {
         unsigned i = 0;
-        for (const auto& kv : _positions) {
+        for (const auto& kv : m_positions) {
             if (i == id) return kv.second;
             i++;
         }
@@ -134,7 +134,7 @@ class PositionStorage {
 
     QList<QString> getPositionList() {
         QList<QString> res;
-        for (const auto& kv : _positions) {
+        for (const auto& kv : m_positions) {
             res.append(kv.first.c_str());
         }
         return res;

nucleus/tile/drawing.cpp

@@ -22,55 +22,76 @@
 
 namespace nucleus::tile::drawing {
 
-std::vector<TileBounds> generate_list(const camera::Definition& camera, utils::AabbDecoratorPtr aabb_decorator, unsigned int max_zoom_level)
+std::vector<tile::Id> generate_list(const camera::Definition& camera, utils::AabbDecoratorPtr aabb_decorator, unsigned int max_zoom_level)
 {
     const auto tile_refine_functor = tile::utils::refineFunctor(camera, aabb_decorator, 1, 256, max_zoom_level);
+    return radix::quad_tree::onTheFlyTraverse(tile::Id { 0, { 0, 0 } }, tile_refine_functor, [](const tile::Id& v) { return v.children(); });
+}
+
+std::vector<TileBounds> compute_bounds(const std::vector<Id>& tiles, utils::AabbDecoratorPtr aabb_decorator)
+{
+    std::vector<TileBounds> bounded_tiles;
+    bounded_tiles.reserve(tiles.size());
+    for (const auto& t : tiles) {
+        bounded_tiles.emplace_back(t, aabb_decorator->aabb(t));
+    }
+    return bounded_tiles;
+}
 
-    auto tiles = radix::quad_tree::onTheFlyTraverse(tile::Id { 0, { 0, 0 } }, tile_refine_functor, [](const tile::Id& v) { return v.children(); });
+std::vector<tile::Id> limit(std::vector<tile::Id> tiles, uint max_n_tiles)
+{
+    if (tiles.size() < max_n_tiles)
+        return tiles;
 
-    if (tiles.size() > max_n_tiles) {
-        std::sort(tiles.begin(), tiles.end(), [&](const tile::Id& a, const tile::Id& b) { return a.zoom_level > b.zoom_level; });
-        std::unordered_set<tile::Id, tile::Id::Hasher> id_set;
-        id_set.reserve(tiles.size());
-        for (const auto t : tiles) {
-            id_set.insert(t);
+    std::sort(tiles.begin(), tiles.end(), [&](const tile::Id& a, const tile::Id& b) { return a.zoom_level > b.zoom_level; });
+    std::unordered_set<tile::Id, tile::Id::Hasher> id_set;
+    id_set.reserve(tiles.size());
+    for (const auto t : tiles) {
+        id_set.insert(t);
+    }
+    const auto all_in_set = [&](const std::array<Id, 4>& siblings) {
+        for (const auto& s : siblings) {
+            if (!id_set.contains(s))
+                return false;
         }
-        const auto all_in_set = [&](const std::array<Id, 4>& siblings) {
-            for (const auto& s : siblings) {
-                if (!id_set.contains(s))
-                    return false;
-            }
-            return true;
-        };
-        const auto remove = [&](const std::array<Id, 4>& siblings) {
-            for (const auto& s : siblings) {
-                const auto pos = std::find(tiles.crbegin(), tiles.crend(), s);
-                tiles.erase(std::next(pos).base());
-                id_set.erase(s);
-            }
-            return true;
-        };
+        return true;
+    };
+    const auto remove = [&](const std::array<Id, 4>& siblings) {
+        for (const auto& s : siblings) {
+            const auto pos = std::find(tiles.crbegin(), tiles.crend(), s);
+            tiles.erase(std::next(pos).base());
+            id_set.erase(s);
+        }
+        return true;
+    };
 
-        while (tiles.size() > max_n_tiles) {
-            for (auto it = tiles.crbegin(); it != tiles.crend(); ++it) {
-                const auto parent = (*it).parent();
-                const auto siblings = parent.children();
-                if (all_in_set(siblings)) {
-                    remove(siblings);
-                    tiles.push_back(parent);
-                    id_set.insert(parent);
-                    break;
-                }
+    while (tiles.size() > max_n_tiles) {
+        for (auto it = tiles.crbegin(); it != tiles.crend(); ++it) {
+            const auto parent = (*it).parent();
+            const auto siblings = parent.children();
+            if (all_in_set(siblings)) {
+                remove(siblings);
+                tiles.push_back(parent);
+                id_set.insert(parent);
+                break;
             }
         }
     }
+    return tiles;
+}
+
+std::vector<TileBounds> cull(std::vector<TileBounds> tiles, const camera::Definition& camera)
+{
+    std::vector<TileBounds> culled_tiles;
+    culled_tiles.reserve(tiles.size());
+    const auto frustum = camera.frustum();
 
-    std::vector<TileBounds> bounded_tiles;
-    bounded_tiles.reserve(tiles.size());
     for (const auto& t : tiles) {
-        bounded_tiles.emplace_back(t, aabb_decorator->aabb(t));
+        if (tile::utils::camera_frustum_contains_tile(frustum, t.bounds))
+            culled_tiles.push_back(t);
     }
-    return bounded_tiles;
+
+    return culled_tiles;
 }
 
 std::vector<TileBounds> sort(std::vector<TileBounds> list, const glm::dvec3& camera_position)

nucleus/tile/drawing.h

@@ -25,6 +25,9 @@
 namespace nucleus::tile::drawing {
 constexpr uint max_n_tiles = 1024;
 
-std::vector<TileBounds> generate_list(const camera::Definition& camera, utils::AabbDecoratorPtr aabb_decorator, unsigned max_zoom_level);
+std::vector<tile::Id> generate_list(const camera::Definition& camera, utils::AabbDecoratorPtr aabb_decorator, unsigned max_zoom_level);
+std::vector<TileBounds> compute_bounds(const std::vector<tile::Id>& tiles, utils::AabbDecoratorPtr aabb_decorator);
+std::vector<tile::Id> limit(std::vector<tile::Id> tiles, uint max_n_tiles);
+std::vector<TileBounds> cull(std::vector<TileBounds> list, const camera::Definition& camera);
 std::vector<TileBounds> sort(std::vector<TileBounds> list, const glm::dvec3& camera_position);
 }

unittests/nucleus/tile_drawing.cpp

@@ -32,19 +32,24 @@ TEST_CASE("tile/drawing")
     TileHeights h;
     h.emplace({ 0, { 0, 0 } }, { 100, 4000 });
     const auto aabb_decorator = AabbDecorator::make(std::move(h));
-    std::vector<std::pair<nucleus::camera::Definition, std::vector<TileBounds>>> lists;
+    std::vector<std::pair<nucleus::camera::Definition, std::vector<tile::Id>>> lists;
+    std::vector<std::pair<nucleus::camera::Definition, std::vector<TileBounds>>> tile_bound_lists;
     SECTION("should not generate more than 1024 tiles for all test cameras + sorting")
     {
         for (auto [name, camera] : nucleus::camera::PositionStorage::instance()->positions()) {
             CAPTURE(name);
             camera.set_viewport_size({ 1920, 1080 });
-            auto list = drawing::generate_list(camera, aabb_decorator, 20);
+            const auto list = drawing::generate_list(camera, aabb_decorator, 20);
             lists.emplace_back(camera, list);
-            CHECK(list.size() <= 1024u);
+            const auto limited = drawing::limit(list, 1024u);
+            CHECK(limited.size() <= 1024u);
+
+            const auto tiles_with_bounds = drawing::compute_bounds(limited, aabb_decorator);
+            tile_bound_lists.emplace_back(camera, tiles_with_bounds);
             // qDebug() << "list.size(): " << list.size();
-            list = drawing::sort(list, camera.position());
+            const auto sorted = drawing::sort(tiles_with_bounds, camera.position());
             auto dist = 0.0;
-            for (const auto t : list) {
+            for (const auto t : sorted) {
                 const auto d = glm::distance(t.bounds.centre(), camera.position());
                 CHECK(d > dist);
             }
@@ -53,15 +58,51 @@ TEST_CASE("tile/drawing")
 
     BENCHMARK("generate list")
     {
-        for (auto [camera, list] : lists) {
-            list = drawing::generate_list(camera, aabb_decorator, 20);
+        std::vector<std::vector<tile::Id>> tmp;
+        tmp.reserve(lists.size());
+        for (const auto& [camera, list] : lists) {
+            tmp.push_back(drawing::generate_list(camera, aabb_decorator, 20));
         }
+        return tmp;
+    };
+
+    BENCHMARK("limit")
+    {
+        std::vector<std::vector<tile::Id>> tmp;
+        tmp.reserve(lists.size());
+        for (const auto& [camera, list] : lists) {
+            tmp.push_back(drawing::limit(list, 1024u));
+        }
+        return tmp;
+    };
+
+    BENCHMARK("compute_aabbs")
+    {
+        std::vector<std::vector<TileBounds>> tmp;
+        tmp.reserve(lists.size());
+        for (const auto& [camera, list] : lists) {
+            tmp.push_back(drawing::compute_bounds(list, aabb_decorator));
+        }
+        return tmp;
     };
 
     BENCHMARK("sort")
     {
-        for (auto [camera, list] : lists) {
-            list = drawing::sort(list, camera.position());
+        std::vector<std::vector<TileBounds>> tmp;
+        tmp.reserve(lists.size());
+        for (const auto& [camera, list] : tile_bound_lists) {
+            tmp.push_back(drawing::sort(list, camera.position()));
+        }
+        return tmp;
+    };
+
+    BENCHMARK("cull")
+    {
+        std::vector<std::vector<TileBounds>> tmp;
+        tmp.reserve(lists.size());
+        for (const auto& [camera, list] : tile_bound_lists) {
+            tmp.push_back(drawing::cull(list, camera));
         }
+        return tmp;
     };
 }