move ortho textures to an array

Author: adam-ce

gl_engine/Texture.cpp

@@ -89,6 +89,9 @@ void gl_engine::Texture::allocate_array(unsigned int width, unsigned int height,
         internalformat = gl_engine::Texture::compressed_texture_format();
 
     f->glTexStorage3D(GLenum(m_target), mip_level_count, internalformat, GLsizei(width), GLsizei(height), GLsizei(n_layers));
+    m_width = width;
+    m_height = height;
+    m_n_layers = n_layers;
 }
 
 void gl_engine::Texture::upload(const nucleus::utils::ColourTexture& texture)
@@ -113,6 +116,10 @@ void gl_engine::Texture::upload(const nucleus::utils::ColourTexture& texture)
 
 void gl_engine::Texture::upload(const nucleus::utils::ColourTexture& texture, unsigned int array_index)
 {
+    assert(texture.width() == m_width);
+    assert(texture.height() == m_height);
+    assert(array_index < m_n_layers);
+
     auto* f = QOpenGLContext::currentContext()->extraFunctions();
     f->glBindTexture(GLenum(m_target), m_id);
     f->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

gl_engine/Texture.h

@@ -56,6 +56,9 @@ class Texture {
     Format m_format = Format::Invalid;
     Filter m_min_filter = Filter::Nearest;
     Filter m_mag_filter = Filter::Nearest;
+    unsigned m_width = unsigned(-1);
+    unsigned m_height = unsigned(-1);
+    unsigned m_n_layers = unsigned(-1);
 };
 
 } // namespace gl_engine

gl_engine/TileManager.cpp

@@ -61,23 +61,22 @@ void TileManager::init()
 {
     using nucleus::utils::terrain_mesh_index_generator::surface_quads_with_curtains;
     assert(QOpenGLContext::currentContext());
-    for (auto i = 0; i < MAX_TILES_PER_TILESET; ++i) {
-        const auto indices = surface_quads_with_curtains<uint16_t>(N_EDGE_VERTICES);
-        auto index_buffer = std::make_unique<QOpenGLBuffer>(QOpenGLBuffer::IndexBuffer);
-        index_buffer->create();
-        index_buffer->bind();
-        index_buffer->setUsagePattern(QOpenGLBuffer::StaticDraw);
-        index_buffer->allocate(indices.data(), bufferLengthInBytes(indices));
-        index_buffer->release();
-        m_index_buffers.emplace_back(std::move(index_buffer), indices.size());
-    }
-    auto* f = QOpenGLContext::currentContext()->extraFunctions();
-    f->glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &m_max_anisotropy);
-}
-
-const std::vector<TileSet>& TileManager::tiles() const
-{
-    return m_gpu_tiles;
+    const auto indices = surface_quads_with_curtains<uint16_t>(N_EDGE_VERTICES);
+    auto index_buffer = std::make_unique<QOpenGLBuffer>(QOpenGLBuffer::IndexBuffer);
+    index_buffer->create();
+    index_buffer->bind();
+    index_buffer->setUsagePattern(QOpenGLBuffer::StaticDraw);
+    index_buffer->allocate(indices.data(), bufferLengthInBytes(indices));
+    index_buffer->release();
+    m_index_buffer.first = std::move(index_buffer);
+    m_index_buffer.second = indices.size();
+
+    m_ortho_textures = std::make_unique<Texture>(Texture::Target::_2dArray, Texture::Format::CompressedRGBA8);
+    m_ortho_textures->setParams(Texture::Filter::Linear, Texture::Filter::Linear);
+    // TODO: might become larger than GL_MAX_ARRAY_TEXTURE_LAYERS
+    m_ortho_textures->allocate_array(ORTHO_RESOLUTION, ORTHO_RESOLUTION, unsigned(m_loaded_tiles.size()));
+
+    // m_heightmap_textures = std::make_unique<Texture>(Texture::Target::_2dArray, Texture::Format::R16UI);
 }
 
 bool compareTileSetPair(std::pair<float, const TileSet*> t1, std::pair<float, const TileSet*> t2)
@@ -95,12 +94,12 @@ void TileManager::draw(ShaderProgram* shader_program, const nucleus::camera::Def
 {
     QOpenGLExtraFunctions* f = QOpenGLContext::currentContext()->extraFunctions();
     shader_program->set_uniform("n_edge_vertices", N_EDGE_VERTICES);
-    shader_program->set_uniform("texture_sampler", 2);
+    shader_program->set_uniform("ortho_sampler", 2);
     shader_program->set_uniform("height_sampler", 1);
 
     // Sort depending on distance to sort_position
     std::vector<std::pair<float, const TileSet*>> tile_list;
-    for (const auto& tileset : tiles()) {
+    for (const auto& tileset : m_gpu_tiles) {
         float dist = 0.0;
         if (!draw_tiles.contains(tileset.tiles.front().first))
             continue;
@@ -115,12 +114,13 @@ void TileManager::draw(ShaderProgram* shader_program, const nucleus::camera::Def
     }
     if (sort_tiles) std::sort(tile_list.begin(), tile_list.end(), compareTileSetPair);
 
+    m_ortho_textures->bind(2);
     for (const auto& tileset : tile_list) {
         tileset.second->vao->bind();
         shader_program->set_uniform_array("bounds", boundsArray(*tileset.second, camera.position()));
-        shader_program->set_uniform("tileset_id", (int)((tileset.second->tiles[0].first.coords[0] + tileset.second->tiles[0].first.coords[1])));
+        shader_program->set_uniform("tileset_id", int((tileset.second->tiles[0].first.coords[0] + tileset.second->tiles[0].first.coords[1])));
         shader_program->set_uniform("tileset_zoomlevel", tileset.second->tiles[0].first.zoom_level);
-        tileset.second->ortho_texture->bind(2);
+        shader_program->set_uniform("texture_layer", int(tileset.second->texture_layer));
         tileset.second->heightmap_texture->bind(1);
         f->glDrawElements(GL_TRIANGLE_STRIP, tileset.second->gl_element_count, tileset.second->gl_index_type, nullptr);
     }
@@ -131,14 +131,19 @@ void TileManager::remove_tile(const tile::Id& tile_id)
 {
     if (!QOpenGLContext::currentContext()) // can happen during shutdown.
         return;
+
+    const auto t = std::find(m_loaded_tiles.begin(), m_loaded_tiles.end(), tile_id);
+    assert(t != m_loaded_tiles.end()); // removing a tile that's not here. likely there is a race.
+    *t = tile::Id { unsigned(-1), {} };
+    m_draw_list_generator.remove_tile(tile_id);
+
     // clear slot
     // or remove from list and free resources
     const auto found_tile = std::find_if(m_gpu_tiles.begin(), m_gpu_tiles.end(), [&tile_id](const TileSet& tileset) {
         return tileset.tiles.front().first == tile_id;
     });
     if (found_tile != m_gpu_tiles.end())
         m_gpu_tiles.erase(found_tile);
-    m_draw_list_generator.remove_tile(tile_id);
 
     emit tiles_changed();
 }
@@ -150,6 +155,12 @@ void TileManager::set_aabb_decorator(const nucleus::tile_scheduler::utils::AabbD
     m_draw_list_generator.set_aabb_decorator(new_aabb_decorator);
 }
 
+void TileManager::set_quad_limit(unsigned int new_limit)
+{
+    m_loaded_tiles.resize(new_limit * 4);
+    std::fill(m_loaded_tiles.begin(), m_loaded_tiles.end(), tile::Id { unsigned(-1), {} });
+}
+
 void TileManager::add_tile(
     const tile::Id& id, tile::SrsAndHeightBounds bounds, const nucleus::utils::ColourTexture& ortho_texture, const nucleus::Raster<uint16_t>& height_map)
 {
@@ -166,20 +177,23 @@ void TileManager::add_tile(
     tileset.vao->bind();
 
     { // vao state
-        m_index_buffers[0].first->bind();
-        tileset.gl_element_count = int(m_index_buffers[0].second);
+        m_index_buffer.first->bind();
+        tileset.gl_element_count = int(m_index_buffer.second);
         tileset.gl_index_type = GL_UNSIGNED_SHORT;
     }
     tileset.vao->release();
-    tileset.ortho_texture = std::make_unique<Texture>(Texture::Target::_2d,
-        ortho_texture.format() == nucleus::utils::ColourTexture::Format::Uncompressed_RGBA ? Texture::Format::RGBA8 : Texture::Format::CompressedRGBA8);
-    tileset.ortho_texture->setParams(Texture::Filter::Linear, Texture::Filter::Linear);
-    tileset.ortho_texture->upload(ortho_texture);
 
     tileset.heightmap_texture = std::make_unique<Texture>(Texture::Target::_2d, Texture::Format::R16UI);
     tileset.heightmap_texture->setParams(Texture::Filter::Nearest, Texture::Filter::Nearest);
     tileset.heightmap_texture->upload(height_map);
 
+    // find empty spot and upload texture
+    const auto t = std::find(m_loaded_tiles.begin(), m_loaded_tiles.end(), tile::Id { unsigned(-1), {} });
+    assert(t != m_loaded_tiles.end());
+    *t = id;
+    m_ortho_textures->upload(ortho_texture, unsigned(t - m_loaded_tiles.begin()));
+    tileset.texture_layer = unsigned(t - m_loaded_tiles.begin());
+
     // add to m_gpu_tiles
     m_gpu_tiles.push_back(std::move(tileset));
     m_draw_list_generator.add_tile(id);
@@ -194,6 +208,11 @@ void TileManager::set_permissible_screen_space_error(float new_permissible_scree
 
 void TileManager::update_gpu_quads(const std::vector<nucleus::tile_scheduler::tile_types::GpuTileQuad>& new_quads, const std::vector<tile::Id>& deleted_quads)
 {
+    for (const auto& quad : deleted_quads) {
+        for (const auto& id : quad.children()) {
+            remove_tile(id);
+        }
+    }
     for (const auto& quad : new_quads) {
         for (const auto& tile : quad.tiles) {
             // test for validity
@@ -203,9 +222,4 @@ void TileManager::update_gpu_quads(const std::vector<nucleus::tile_scheduler::ti
             add_tile(tile.id, tile.bounds, *tile.ortho, *tile.height);
         }
     }
-    for (const auto& quad : deleted_quads) {
-        for (const auto& id : quad.children()) {
-            remove_tile(id);
-        }
-    }
 }

gl_engine/TileManager.h

@@ -45,7 +45,6 @@ class TileManager : public QObject {
     explicit TileManager(QObject* parent = nullptr);
     void init(); // needs OpenGL context
 
-    [[nodiscard]] const std::vector<TileSet>& tiles() const;
     void draw(ShaderProgram* shader_program, const nucleus::camera::Definition& camera, const nucleus::tile_scheduler::DrawListGenerator::TileSet draw_tiles, bool sort_tiles, glm::dvec3 sort_position) const;
 
     const nucleus::tile_scheduler::DrawListGenerator::TileSet generate_tilelist(const nucleus::camera::Definition& camera) const;
@@ -60,6 +59,7 @@ public slots:
     void remove_tile(const tile::Id& tile_id);
     void initilise_attribute_locations(ShaderProgram* program);
     void set_aabb_decorator(const nucleus::tile_scheduler::utils::AabbDecoratorPtr& new_aabb_decorator);
+    void set_quad_limit(unsigned new_limit);
 
 private:
     void add_tile(const tile::Id& id, tile::SrsAndHeightBounds bounds, const nucleus::utils::ColourTexture& ortho, const nucleus::Raster<uint16_t>& heights);
@@ -68,16 +68,13 @@ public slots:
 
     static constexpr auto N_EDGE_VERTICES = 65;
     static constexpr auto ORTHO_RESOLUTION = 256;
-    static constexpr auto MAX_TILES_PER_TILESET = 1;
-    float m_max_anisotropy = 0;
+
+    std::vector<tile::Id> m_loaded_tiles;
+    std::pair<std::unique_ptr<QOpenGLBuffer>, size_t> m_index_buffer;
+    std::unique_ptr<Texture> m_ortho_textures;
+    std::unique_ptr<Texture> m_heightmap_textures;
 
     std::vector<TileSet> m_gpu_tiles;
-    // indexbuffers for 4^index tiles,
-    // e.g., for single tile tile sets take index 0
-    //       for 4 tiles take index 1, for 16 2..
-    // the size_t is the number of indices
-    std::vector<std::pair<std::unique_ptr<QOpenGLBuffer>, size_t>> m_index_buffers;
-    std::unique_ptr<QOpenGLBuffer> m_dummy_buffer;
     TileGLAttributeLocations m_attribute_locations;
     unsigned m_tiles_per_set = 1;
     nucleus::tile_scheduler::DrawListGenerator m_draw_list_generator;

gl_engine/TileSet.h

@@ -46,12 +46,12 @@ struct TileSet {
         [[nodiscard]] bool isValid() const { return tile_id.zoom_level < 100; }
     };
 
-    std::unique_ptr<Texture> ortho_texture;
     std::unique_ptr<Texture> heightmap_texture;
     std::unique_ptr<QOpenGLVertexArrayObject> vao;
     std::vector<std::pair<tile::Id, tile::SrsBounds>> tiles;
     int gl_element_count = -1;
     unsigned gl_index_type = 0;
+    unsigned texture_layer = unsigned(-1);
     // texture
 };
 } // namespace gl_engine

gl_engine/Window.cpp

@@ -422,11 +422,9 @@ void Window::updateCameraEvent()
     emit update_camera_requested();
 }
 
-void Window::set_permissible_screen_space_error(float new_error)
-{
-    if (m_tile_manager)
-        m_tile_manager->set_permissible_screen_space_error(new_error);
-}
+void Window::set_permissible_screen_space_error(float new_error) { m_tile_manager->set_permissible_screen_space_error(new_error); }
+
+void Window::set_quad_limit(unsigned int new_limit) { m_tile_manager->set_quad_limit(new_limit); }
 
 void Window::update_camera(const nucleus::camera::Definition& new_definition)
 {

gl_engine/Window.h

@@ -75,6 +75,7 @@ class Window : public nucleus::AbstractRenderWindow, public nucleus::camera::Abs
     void keyReleaseEvent(QKeyEvent*);
     void updateCameraEvent();
     void set_permissible_screen_space_error(float new_error) override;
+    void set_quad_limit(unsigned new_limit) override;
 
 public slots:
     void update_camera(const nucleus::camera::Definition& new_definition) override;

gl_engine/shaders/tile.frag

@@ -21,7 +21,8 @@
 #include "camera_config.glsl"
 #include "encoder.glsl"
 
-uniform sampler2D texture_sampler;
+uniform highp int texture_layer;
+uniform sampler2DArray ortho_sampler;
 
 layout (location = 0) out lowp vec3 texout_albedo;
 layout (location = 1) out highp vec4 texout_position;
@@ -54,7 +55,8 @@ void main() {
 #endif
 
     // Write Albedo (ortho picture) in gbuffer
-    lowp vec3 fragColor = texture(texture_sampler, uv).rgb;
+    highp float texture_layer_f = float(texture_layer);
+    lowp vec3 fragColor = texture(ortho_sampler, vec3(uv, texture_layer_f)).rgb;
     fragColor = mix(fragColor, conf.material_color.rgb, conf.material_color.a);
     texout_albedo = fragColor;
 

nucleus/AbstractRenderWindow.h

@@ -51,6 +51,7 @@ class AbstractRenderWindow : public QObject {
     virtual void paint(QOpenGLFramebufferObject* framebuffer = nullptr) = 0;
     virtual void deinit_gpu() = 0;
     virtual void set_permissible_screen_space_error(float new_error) = 0;
+    virtual void set_quad_limit(unsigned new_limit) = 0;
     [[nodiscard]] virtual camera::AbstractDepthTester* depth_tester() = 0;
     [[nodiscard]] virtual utils::ColourTexture::Format ortho_tile_compression_algorithm() const = 0;
 

nucleus/Controller.cpp

@@ -60,7 +60,8 @@ Controller::Controller(AbstractRenderWindow* render_window)
 
     m_tile_scheduler = std::make_unique<nucleus::tile_scheduler::Scheduler>();
     m_tile_scheduler->read_disk_cache();
-    m_tile_scheduler->set_gpu_quad_limit(500);
+    m_render_window->set_quad_limit(512); // must be same as scheduler, dynamic resizing is not supported atm
+    m_tile_scheduler->set_gpu_quad_limit(512);
     m_tile_scheduler->set_ram_quad_limit(12000);
     {
         QFile file(":/map/height_data.atb");