m_instanced_zoom and array index untested, but bounds work (AlpineMapsOrg#162)

Author: adam-ce

gl_engine/TileGeometry.cpp

@@ -89,6 +89,15 @@ void TileGeometry::init()
     m_array_index_texture = std::make_unique<Texture>(Texture::Target::_2d, Texture::Format::R16UI);
     m_array_index_texture->setParams(Texture::Filter::Nearest, Texture::Filter::Nearest);
 
+    m_instanced_zoom = std::make_unique<Texture>(Texture::Target::_2d, Texture::Format::R8UI);
+    m_instanced_zoom->setParams(Texture::Filter::Nearest, Texture::Filter::Nearest);
+
+    m_instanced_array_index = std::make_unique<Texture>(Texture::Target::_2d, Texture::Format::R16UI);
+    m_instanced_array_index->setParams(Texture::Filter::Nearest, Texture::Filter::Nearest);
+
+    m_instanced_bounds = std::make_unique<Texture>(Texture::Target::_2d, Texture::Format::RGBA32F);
+    m_instanced_bounds->setParams(Texture::Filter::Nearest, Texture::Filter::Nearest);
+
     auto example_shader = std::make_shared<ShaderProgram>("tile.vert", "tile.frag");
     int bounds = example_shader->attribute_location("bounds");
     qDebug() << "attrib location for bounds: " << bounds;
@@ -197,6 +206,32 @@ void TileGeometry::draw(ShaderProgram* shader, const nucleus::camera::Definition
         height_texture_layer.emplace_back(tileset.second->height_texture_layer);
     }
 
+    {
+        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);
+            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);
+        shader->set_uniform("instanced_geom_array_index_sampler", 5);
+        m_instanced_array_index->upload(array_index_raster);
+
+        m_instanced_zoom->bind(6);
+        shader->set_uniform("instanced_geom_zoom_sampler", 6);
+        m_instanced_zoom->upload(zoom_level_raster);
+
+        m_instanced_bounds->bind(9);
+        shader->set_uniform("instanced_geom_bounds_sampler", 9);
+        m_instanced_bounds->upload(bounds_raster);
+    }
+
     m_bounds_buffer->bind();
     m_bounds_buffer->write(0, bounds.data(), GLsizei(bounds.size() * sizeof(decltype(bounds)::value_type)));
 
@@ -225,7 +260,11 @@ void TileGeometry::remove_tile(const nucleus::tile::Id& tile_id)
         m_gpu_tiles.erase(found_tile);
 }
 
-void TileGeometry::set_aabb_decorator(const nucleus::tile::utils::AabbDecoratorPtr& new_aabb_decorator) { m_draw_list_generator.set_aabb_decorator(new_aabb_decorator); }
+void TileGeometry::set_aabb_decorator(const nucleus::tile::utils::AabbDecoratorPtr& new_aabb_decorator)
+{
+    m_aabb_decorator = new_aabb_decorator;
+    m_draw_list_generator.set_aabb_decorator(new_aabb_decorator);
+}
 
 void TileGeometry::set_quad_limit(unsigned int new_limit) { m_gpu_array_helper.set_quad_limit(new_limit); }
 

gl_engine/TileGeometry.h

@@ -77,6 +77,9 @@ public slots:
     std::unique_ptr<Texture> m_heightmap_textures;
     std::unique_ptr<Texture> m_tile_id_texture;
     std::unique_ptr<Texture> m_array_index_texture;
+    std::unique_ptr<Texture> m_instanced_zoom;
+    std::unique_ptr<Texture> m_instanced_array_index;
+    std::unique_ptr<Texture> m_instanced_bounds;
     std::unique_ptr<QOpenGLVertexArrayObject> m_vao;
     std::pair<std::unique_ptr<QOpenGLBuffer>, size_t> m_index_buffer;
     std::unique_ptr<QOpenGLBuffer> m_bounds_buffer;
@@ -86,5 +89,6 @@ public slots:
     std::vector<TileInfo> m_gpu_tiles;
     nucleus::tile::DrawListGenerator m_draw_list_generator;
     nucleus::tile::GpuArrayHelper m_gpu_array_helper;
+    nucleus::tile::utils::AabbDecoratorPtr m_aabb_decorator;
 };
 } // namespace gl_engine

gl_engine/shaders/tile.glsl

@@ -19,7 +19,11 @@
 
 #include "tile_id.glsl"
 
-layout(location = 0) in highp vec4 bounds;
+uniform highp usampler2D instanced_texture_array_index_sampler;
+uniform highp usampler2D instanced_texture_zoom_sampler;
+uniform highp sampler2D instanced_geom_bounds_sampler;
+
+layout(location = 0) in highp vec4 bounds_attrib;
 layout(location = 1) in highp int height_texture_layer;
 layout(location = 2) in highp uvec2 packed_tile_id;
 
@@ -38,6 +42,7 @@ highp float y_to_lat(highp float y) {
 highp vec3 camera_world_space_position(out vec2 uv, out float n_quads_per_direction, out float quad_width, out float quad_height, out float altitude_correction_factor) {
     highp int n_quads_per_direction_int = n_edge_vertices - 1;
     n_quads_per_direction = float(n_quads_per_direction_int);
+    highp vec4 bounds = texelFetch(instanced_geom_bounds_sampler, ivec2(uint(gl_InstanceID), 0), 0);
     quad_width = (bounds.z - bounds.x) / n_quads_per_direction;
     quad_height = (bounds.w - bounds.y) / n_quads_per_direction;
 
@@ -70,6 +75,11 @@ highp vec3 camera_world_space_position(out vec2 uv, out float n_quads_per_direct
     altitude_correction_factor = 0.125 / cos(y_to_lat(pos_y)); // https://github.com/AlpineMapsOrg/renderer/issues/5
 
     uv = vec2(float(col) / n_quads_per_direction, float(row) / n_quads_per_direction);
+
+    /////////
+    // decrease_zoom_level_until(tile_id, uv, texelFetch(instanced_texture_zoom_sampler, ivec2(instance_id, 0), 0).x);
+    // highp float texture_layer_f = float(texelFetch(instanced_texture_array_index_sampler, ivec2(instance_id, 0), 0).x);
+    ////////
     float altitude_tex = float(texelFetch(height_tex_sampler, ivec3(col, row, height_texture_layer), 0).r);
     float adjusted_altitude = altitude_tex * altitude_correction_factor;