if draw resolution is independent of available height data, it often renders using low resolution data, making a stair case effect.

(AlpineMapsOrg#162)
- disabled shadow mapping for now
- disabled normal computation for now

idea:
use several geometry sets, with varying resolution. draw, e.g. 17x17
geometry, if we are 2 zoom levels below max res.

Author: adam-ce

app/RenderingContext.cpp

@@ -155,6 +155,7 @@ void RenderingContext::initialise()
     m->engine_context->set_ortho_layer(std::make_shared<gl_engine::TextureLayer>(512));
     m->engine_context->tile_geometry()->set_quad_limit(512);
     m->engine_context->tile_geometry()->set_aabb_decorator(m->aabb_decorator);
+    m->engine_context->set_aabb_decorator(m->aabb_decorator);
     m->engine_context->ortho_layer()->set_quad_limit(512);
 
     connect(m->geometry.scheduler.get(), &nucleus::tile::GeometryScheduler::gpu_quads_updated, m->engine_context->tile_geometry(), &gl_engine::TileGeometry::update_gpu_quads);

gl_engine/MapLabels.cpp

@@ -74,7 +74,10 @@ void MapLabels::init(ShaderRegistry* shader_registry)
     m_indices_count = m_mapLabelFactory.m_indices.size();
 }
 
-MapLabels::TileSet MapLabels::generate_draw_list(const nucleus::camera::Definition& camera) const { return m_draw_list_generator.cull(m_draw_list_generator.generate_for(camera), camera.frustum()); }
+MapLabels::TileSet MapLabels::generate_draw_list(const nucleus::camera::Definition& camera) const
+{
+    return m_draw_list_generator.cull(m_draw_list_generator.generate_for(camera), camera.frustum());
+}
 
 void MapLabels::upload_to_gpu(const TileId& id, const PointOfInterestCollection& features)
 {

gl_engine/ShadowMapping.cpp

@@ -55,6 +55,8 @@ void ShadowMapping::draw(TileGeometry* tile_geometry,
     std::shared_ptr<UniformBuffer<uboShadowConfig>> shadow_config,
     std::shared_ptr<UniformBuffer<uboSharedConfig>> shared_config)
 {
+    Q_UNUSED(tile_geometry);
+    Q_UNUSED(draw_tileset);
 
     // NOTE: ReverseZ is not necessary for ShadowMapping since a directional light is using an orthographic projection
     // and therefore the distribution of depth is linear anyway.
@@ -87,7 +89,7 @@ void ShadowMapping::draw(TileGeometry* tile_geometry,
         m_f->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
         m_shadow_program->set_uniform("current_layer", i);
-        tile_geometry->draw(m_shadow_program.get(), camera, draw_tileset, false, glm::dvec3(0.0));
+        // tile_geometry->draw(m_shadow_program.get(), camera, draw_tileset, false, glm::dvec3(0.0));
         m_shadowmapbuffer[i]->unbind();
     }
     m_shadow_program->release();

gl_engine/TextureLayer.cpp

@@ -48,21 +48,17 @@ void gl_engine::TextureLayer::init(ShaderRegistry* shader_registry)
     m_instanced_array_index->setParams(Texture::Filter::Nearest, Texture::Filter::Nearest);
 }
 
-void TextureLayer::draw(const TileGeometry& tile_geometry,
-    const nucleus::camera::Definition& camera,
-    const nucleus::tile::DrawListGenerator::TileSet& draw_tiles,
-    bool sort_tiles,
-    glm::dvec3 sort_position) const
+void TextureLayer::draw(
+    const TileGeometry& tile_geometry, const nucleus::camera::Definition& camera, const std::vector<nucleus::tile::TileBounds>& draw_list) const
 {
     m_shader->bind();
     m_texture_array->bind(2);
     m_shader->set_uniform("texture_sampler", 2);
 
-    const auto draw_list = tile_geometry.sort(camera, draw_tiles);
     nucleus::Raster<uint8_t> zoom_level_raster = { glm::uvec2 { 1024, 1 } };
     nucleus::Raster<uint16_t> array_index_raster = { glm::uvec2 { 1024, 1 } };
     for (unsigned i = 0; i < std::min(unsigned(draw_list.size()), 1024u); ++i) {
-        const auto layer = m_gpu_array_helper.layer(draw_list[i]);
+        const auto layer = m_gpu_array_helper.layer(draw_list[i].id);
         zoom_level_raster.pixel({ i, 0 }) = layer.id.zoom_level;
         array_index_raster.pixel({ i, 0 }) = layer.index;
     }
@@ -75,7 +71,7 @@ void TextureLayer::draw(const TileGeometry& tile_geometry,
     m_shader->set_uniform("instanced_texture_zoom_sampler", 8);
     m_instanced_zoom->upload(zoom_level_raster);
 
-    tile_geometry.draw(m_shader.get(), camera, draw_tiles, sort_tiles, sort_position);
+    tile_geometry.draw(m_shader.get(), camera, draw_list);
 }
 
 unsigned TextureLayer::tile_count() const { return m_gpu_array_helper.n_occupied(); }

gl_engine/TextureLayer.h

@@ -25,7 +25,7 @@
 #include <nucleus/tile/GpuArrayHelper.h>
 #include <nucleus/tile/types.h>
 
-namespace camera {
+namespace nucleus::camera {
 class Definition;
 }
 
@@ -44,11 +44,7 @@ class TextureLayer : public QObject {
 public:
     explicit TextureLayer(unsigned resolution = 256, QObject* parent = nullptr);
     void init(ShaderRegistry* shader_registry); // needs OpenGL context
-    void draw(const TileGeometry& tile_geometry,
-        const nucleus::camera::Definition& camera,
-        const nucleus::tile::DrawListGenerator::TileSet& draw_tiles,
-        bool sort_tiles,
-        glm::dvec3 sort_position) const;
+    void draw(const TileGeometry& tile_geometry, const nucleus::camera::Definition& camera, const std::vector<nucleus::tile::TileBounds>& draw_list) const;
 
     unsigned int tile_count() const;
 

gl_engine/TileGeometry.cpp

@@ -67,12 +67,6 @@ void TileGeometry::init()
     m_draw_tile_id_buffer->setUsagePattern(QOpenGLBuffer::DynamicDraw);
     m_draw_tile_id_buffer->allocate(GLsizei(m_gpu_array_helper.size() * sizeof(glm::u32vec2)));
 
-    m_height_texture_layer_buffer = std::make_unique<QOpenGLBuffer>(QOpenGLBuffer::VertexBuffer);
-    m_height_texture_layer_buffer->create();
-    m_height_texture_layer_buffer->bind();
-    m_height_texture_layer_buffer->setUsagePattern(QOpenGLBuffer::DynamicDraw);
-    m_height_texture_layer_buffer->allocate(GLsizei(m_gpu_array_helper.size() * sizeof(int32_t)));
-
     m_vao = std::make_unique<QOpenGLVertexArrayObject>();
     m_vao->create();
     m_vao->bind();
@@ -103,8 +97,6 @@ void TileGeometry::init()
     qDebug() << "attrib location for bounds: " << bounds;
     int packed_tile_id = example_shader->attribute_location("packed_tile_id");
     qDebug() << "attrib location for packed_tile_id: " << packed_tile_id;
-    int height_texture_layer = example_shader->attribute_location("height_texture_layer");
-    qDebug() << "attrib location for height_texture_layer: " << height_texture_layer;
 
     m_vao->bind();
     QOpenGLExtraFunctions* f = QOpenGLContext::currentContext()->extraFunctions();
@@ -120,12 +112,6 @@ void TileGeometry::init()
         f->glVertexAttribIPointer(GLuint(packed_tile_id), /*size*/ 2, /*type*/ GL_UNSIGNED_INT, /*stride*/ 0, nullptr);
         f->glVertexAttribDivisor(GLuint(packed_tile_id), 1);
     }
-    if (height_texture_layer != -1) {
-        m_height_texture_layer_buffer->bind();
-        f->glEnableVertexAttribArray(GLuint(height_texture_layer));
-        f->glVertexAttribIPointer(GLuint(height_texture_layer), /*size*/ 1, /*type*/ GL_INT, /*stride*/ 0, nullptr);
-        f->glVertexAttribDivisor(GLuint(height_texture_layer), 1);
-    }
 
     update_gpu_id_map();
 }
@@ -159,64 +145,43 @@ std::vector<nucleus::tile::Id> TileGeometry::sort(const nucleus::camera::Definit
     return sorted_ids;
 }
 
-void TileGeometry::draw(ShaderProgram* shader, const nucleus::camera::Definition& camera, const TileSet& draw_tiles, bool sort_tiles, glm::dvec3 sort_position) const
+void TileGeometry::draw(ShaderProgram* shader, const nucleus::camera::Definition& camera, const std::vector<nucleus::tile::TileBounds>& draw_list) const
 {
     QOpenGLExtraFunctions* f = QOpenGLContext::currentContext()->extraFunctions();
     shader->set_uniform("n_edge_vertices", N_EDGE_VERTICES);
     shader->set_uniform("height_tex_sampler", 1);
     shader->set_uniform("height_tex_index_sampler", 3);
     shader->set_uniform("height_tex_tile_id_sampler", 4);
 
-    // Sort depending on distance to sort_position
-    std::vector<std::pair<float, const TileInfo*>> tile_list;
-    for (const auto& tileset : m_gpu_tiles) {
-        float dist = 0.0;
-        if (!draw_tiles.contains(tileset.tile_id))
-            continue;
-        if (sort_tiles) {
-            glm::vec2 pos_wrt = glm::vec2(tileset.bounds.min.x - sort_position.x, tileset.bounds.min.y - sort_position.y);
-            dist = glm::length(pos_wrt);
-        }
-        tile_list.push_back(std::pair<float, const TileInfo*>(dist, &tileset));
-    }
-    if (sort_tiles)
-        std::sort(tile_list.begin(), tile_list.end(), [](const auto& a, const auto& b) { return a.first < b.first; });
-
     m_heightmap_textures->bind(1);
     m_array_index_texture->bind(3);
     m_tile_id_texture->bind(4);
     m_vao->bind();
 
     std::vector<glm::vec4> bounds;
-    bounds.reserve(tile_list.size());
+    bounds.reserve(draw_list.size());
 
     std::vector<glm::u32vec2> packed_id;
-    packed_id.reserve(tile_list.size());
-
-    std::vector<int32_t> height_texture_layer;
-    height_texture_layer.reserve(tile_list.size());
-
-    for (const auto& tileset : tile_list) {
-        bounds.emplace_back(tileset.second->bounds.min.x - camera.position().x,
-            tileset.second->bounds.min.y - camera.position().y,
-            tileset.second->bounds.max.x - camera.position().x,
-            tileset.second->bounds.max.y - camera.position().y);
-
-        packed_id.emplace_back(nucleus::srs::pack(tileset.second->tile_id));
-        height_texture_layer.emplace_back(tileset.second->height_texture_layer);
-    }
+    packed_id.reserve(draw_list.size());
 
     {
-        const auto draw_list = tile_list;
         nucleus::Raster<uint8_t> zoom_level_raster = { glm::uvec2 { 1024, 1 } };
         nucleus::Raster<uint16_t> array_index_raster = { glm::uvec2 { 1024, 1 } };
         nucleus::Raster<glm::vec4> bounds_raster = { glm::uvec2 { 1024, 1 } };
         for (unsigned i = 0; i < std::min(unsigned(draw_list.size()), 1024u); ++i) {
-            const auto layer = m_gpu_array_helper.layer(draw_list[i].second->tile_id);
+            const auto& tile = draw_list[i];
+            const auto bounds_2d = glm::vec4 { tile.bounds.min.x - camera.position().x,
+                tile.bounds.min.y - camera.position().y,
+                tile.bounds.max.x - camera.position().x,
+                tile.bounds.max.y - camera.position().y };
+            bounds.push_back(bounds_2d);
+            packed_id.push_back(nucleus::srs::pack(tile.id));
+
+            bounds_raster.pixel({ i, 0 }) = bounds_2d;
+
+            const auto layer = m_gpu_array_helper.layer(draw_list[i].id);
             zoom_level_raster.pixel({ i, 0 }) = layer.id.zoom_level;
             array_index_raster.pixel({ i, 0 }) = layer.index;
-            const auto aabb = m_aabb_decorator->aabb(layer.id);
-            bounds_raster.pixel({ i, 0 }) = { aabb.min.x - camera.position().x, aabb.min.y - camera.position().y, aabb.max.x - camera.position().x, aabb.max.y - camera.position().y };
         }
 
         m_instanced_array_index->bind(5);
@@ -238,10 +203,7 @@ void TileGeometry::draw(ShaderProgram* shader, const nucleus::camera::Definition
     m_draw_tile_id_buffer->bind();
     m_draw_tile_id_buffer->write(0, packed_id.data(), GLsizei(packed_id.size() * sizeof(decltype(packed_id)::value_type)));
 
-    m_height_texture_layer_buffer->bind();
-    m_height_texture_layer_buffer->write(0, height_texture_layer.data(), GLsizei(height_texture_layer.size() * sizeof(decltype(height_texture_layer)::value_type)));
-
-    f->glDrawElementsInstanced(GL_TRIANGLE_STRIP, GLsizei(m_index_buffer.second), GL_UNSIGNED_SHORT, nullptr, GLsizei(tile_list.size()));
+    f->glDrawElementsInstanced(GL_TRIANGLE_STRIP, GLsizei(m_index_buffer.second), GL_UNSIGNED_SHORT, nullptr, GLsizei(draw_list.size()));
     f->glBindVertexArray(0);
 }
 

gl_engine/TileGeometry.h

@@ -51,7 +51,7 @@ class TileGeometry : public QObject {
 
     explicit TileGeometry(QObject* parent = nullptr);
     void init(); // needs OpenGL context
-    void draw(ShaderProgram* shader_program, const nucleus::camera::Definition& camera, const TileSet& draw_tiles, bool sort_tiles, glm::dvec3 sort_position) const;
+    void draw(ShaderProgram* shader_program, const nucleus::camera::Definition& camera, const std::vector<nucleus::tile::TileBounds>& draw_list) const;
 
     TileSet generate_tilelist(const nucleus::camera::Definition& camera) const;
     TileSet cull(const TileSet& tileset, const nucleus::camera::Frustum& frustum) const;
@@ -84,7 +84,6 @@ public slots:
     std::pair<std::unique_ptr<QOpenGLBuffer>, size_t> m_index_buffer;
     std::unique_ptr<QOpenGLBuffer> m_bounds_buffer;
     std::unique_ptr<QOpenGLBuffer> m_draw_tile_id_buffer;
-    std::unique_ptr<QOpenGLBuffer> m_height_texture_layer_buffer;
 
     std::vector<TileInfo> m_gpu_tiles;
     nucleus::tile::DrawListGenerator m_draw_list_generator;

gl_engine/Window.cpp

@@ -44,6 +44,7 @@
 #include <QTimer>
 #include <glm/glm.hpp>
 #include <glm/gtx/transform.hpp>
+#include <nucleus/tile/drawing.h>
 #include <nucleus/timing/CpuTimer.h>
 #include <nucleus/timing/TimerManager.h>
 #include <nucleus/utils/bit_coding.h>
@@ -70,6 +71,7 @@
 using gl_engine::UniformBuffer;
 using gl_engine::Window;
 using namespace gl_engine;
+using namespace nucleus::tile;
 
 Window::Window(std::shared_ptr<Context> context)
     : m_context(context)
@@ -299,20 +301,22 @@ void Window::paint(QOpenGLFramebufferObject* framebuffer)
         tile_stats["n_label_tiles_gpu"] = m_context->map_label_manager()->tile_count();
         tile_stats["n_label_tiles_drawn"] = unsigned(label_tile_set.size());
     }
-    const auto tile_set = m_context->tile_geometry()->generate_tilelist(m_camera);
-    const auto culled_tile_set = m_context->tile_geometry()->cull(tile_set, m_camera.frustum());
+
+    const auto draw_list
+        = drawing::compute_bounds(drawing::limit(drawing::generate_list(m_camera, m_context->aabb_decorator(), 20), 1024u), m_context->aabb_decorator());
+    const auto culled_draw_list = drawing::sort(drawing::cull(draw_list, m_camera), m_camera.position());
 
     tile_stats["n_geometry_tiles_gpu"] = m_context->tile_geometry()->tile_count();
     tile_stats["n_ortho_tiles_gpu"] = m_context->ortho_layer()->tile_count();
-    tile_stats["n_geometry_tiles_drawn"] = unsigned(culled_tile_set.size());
+    tile_stats["n_geometry_tiles_drawn"] = unsigned(culled_draw_list.size());
     m_timer->stop_timer("draw_list");
 
     // DRAW SHADOWMAPS
-    if (m_shared_config_ubo->data.m_csm_enabled) {
-        m_timer->start_timer("shadowmap");
-        m_shadowmapping->draw(m_context->tile_geometry(), tile_set, m_camera, m_shadow_config_ubo, m_shared_config_ubo);
-        m_timer->stop_timer("shadowmap");
-    }
+    // if (m_shared_config_ubo->data.m_csm_enabled) {
+    //     m_timer->start_timer("shadowmap");
+    //     m_shadowmapping->draw(m_context->tile_geometry(), tile_set, m_camera, m_shadow_config_ubo, m_shared_config_ubo);
+    //     m_timer->stop_timer("shadowmap");
+    // }
 
     // DRAW GBUFFER
     m_gbuffer->bind();
@@ -339,7 +343,7 @@ void Window::paint(QOpenGLFramebufferObject* framebuffer)
     f->glDepthFunc(GL_GREATER); // reverse z
 
     m_timer->start_timer("tiles");
-    m_context->ortho_layer()->draw(*m_context->tile_geometry(), m_camera, culled_tile_set, true, m_camera.position());
+    m_context->ortho_layer()->draw(*m_context->tile_geometry(), m_camera, culled_draw_list);
     m_timer->stop_timer("tiles");
 
     m_gbuffer->unbind();

gl_engine/shaders/tile.glsl

@@ -18,14 +18,14 @@
 *****************************************************************************/
 
 #include "tile_id.glsl"
+#line 22
 
 uniform highp usampler2D instanced_geom_array_index_sampler;
 uniform highp usampler2D instanced_geom_zoom_sampler;
 uniform highp sampler2D instanced_geom_bounds_sampler;
 
 layout(location = 0) in highp vec4 bounds;
-layout(location = 1) in highp int height_texture_layer;
-layout(location = 2) in highp uvec2 packed_tile_id;
+layout(location = 1) in highp uvec2 packed_tile_id;
 
 uniform highp int n_edge_vertices;
 uniform mediump usampler2DArray height_tex_sampler;
@@ -83,7 +83,7 @@ highp vec3 camera_world_space_position(out vec2 uv, out float n_quads_per_direct
     decrease_zoom_level_until(geom_tile_id, geom_uv, geom_zoom);
     highp float geom_texture_layer_f = float(texelFetch(instanced_geom_array_index_sampler, ivec2(uint(gl_InstanceID), 0), 0).x);
     // float altitude_tex = float(geom_texture_layer_f);
-    float altitude_tex = float(texture(height_tex_sampler, vec3(uv, height_texture_layer)).r);
+    float altitude_tex = float(texture(height_tex_sampler, vec3(geom_uv, geom_texture_layer_f)).r);
     ////////
     // float altitude_tex = float(texelFetch(height_tex_sampler, ivec3(col, row, height_texture_layer), 0).r);
     float adjusted_altitude = altitude_tex * altitude_correction_factor;
@@ -119,6 +119,8 @@ highp vec3 normal_by_finite_difference_method(vec2 uv, float edge_vertices_count
     // from here: https://stackoverflow.com/questions/6656358/calculating-normals-in-a-triangle-mesh/21660173#21660173
     vec2 offset = vec2(1.0, 0.0) / (edge_vertices_count);
 
+    float height_texture_layer = 0;
+
     highp float hL = float(texture(height_tex_sampler, vec3(uv - offset.xy, height_texture_layer)).r);
     hL *= altitude_correction_factor;
     highp float hR = float(texture(height_tex_sampler, vec3(uv + offset.xy, height_texture_layer)).r);

gl_engine/shaders/tile.vert

@@ -53,6 +53,6 @@ void main() {
         case 2u: vertex_color = color_from_id_hash(uint(packed_tile_id.x ^ packed_tile_id.y)); break;
         case 3u: vertex_color = color_from_id_hash(uint(var_tile_id.z)); break;
         case 4u: vertex_color = color_from_id_hash(uint(gl_VertexID)); break;
-        case 5u: vertex_color = vec3(texture(height_tex_sampler, vec3(var_uv, height_texture_layer)).rrr) / 65535.0; break;
+        // case 5u: vertex_color = vec3(texture(height_tex_sampler, vec3(var_uv, height_texture_layer)).rrr) / 65535.0; break;
     }
 }

nucleus/EngineContext.cpp

@@ -22,6 +22,10 @@ using namespace nucleus;
 
 EngineContext::EngineContext() { }
 
+const tile::utils::AabbDecoratorPtr& EngineContext::aabb_decorator() const { return m_aabb_decorator; }
+
+void EngineContext::set_aabb_decorator(const tile::utils::AabbDecoratorPtr& new_aabb_decorator) { m_aabb_decorator = new_aabb_decorator; }
+
 EngineContext::EngineContext(QObject* parent)
     : QObject(parent)
 {

nucleus/EngineContext.h

@@ -20,7 +20,8 @@
 
 #include <QObject>
 
-#include "nucleus/track/Manager.h"
+#include <nucleus/tile/utils.h>
+#include <nucleus/track/Manager.h>
 
 namespace nucleus {
 
@@ -34,6 +35,9 @@ class EngineContext : public QObject {
     [[nodiscard]] virtual track::Manager* track_manager() = 0;
     bool is_alive() const;
 
+    [[nodiscard]] const tile::utils::AabbDecoratorPtr& aabb_decorator() const;
+    void set_aabb_decorator(const tile::utils::AabbDecoratorPtr& new_aabb_decorator);
+
 protected:
     explicit EngineContext();
     virtual void internal_initialise() = 0;
@@ -45,5 +49,6 @@ class EngineContext : public QObject {
 private:
     bool m_initialised = false;
     bool m_destroyed = false;
+    tile::utils::AabbDecoratorPtr m_aabb_decorator;
 };
 } // namespace nucleus