Merge branch 'main' into heightmaps

src/files/settings_io.cpp

@@ -70,6 +70,8 @@ SettingsHandler::SettingsHandler(EngineSettings& settings) {
     builder.add("gamma", &settings.graphics.gamma);
     builder.add("frustum-culling", &settings.graphics.frustumCulling);
     builder.add("skybox-resolution", &settings.graphics.skyboxResolution);
+    builder.add("chunk-max-vertices", &settings.graphics.chunkMaxVertices);
+    builder.add("chunk-max-renderers", &settings.graphics.chunkMaxRenderers);
 
     builder.section("ui");
     builder.add("language", &settings.ui.language);

src/graphics/render/BlocksRenderer.cpp

@@ -20,7 +20,7 @@ BlocksRenderer::BlocksRenderer(
     const ContentGfxCache* cache,
     const EngineSettings* settings
 ) : content(content),
-    vertexBuffer(std::make_unique<float[]>(capacity)),
+    vertexBuffer(std::make_unique<float[]>(capacity * VERTEX_SIZE)),
     indexBuffer(std::make_unique<int[]>(capacity)),
     vertexOffset(0),
     indexOffset(0),

src/graphics/render/ChunksRenderer.cpp

@@ -12,18 +12,17 @@
 
 static debug::Logger logger("chunks-render");
 
-const uint RENDERER_CAPACITY = 9 * 6 * 6 * 3000;
-
 class RendererWorker : public util::Worker<Chunk, RendererResult> {
     Level* level;
     BlocksRenderer renderer;
 public:
     RendererWorker(
         Level* level, 
-        const ContentGfxCache* cache, 
+        const ContentGfxCache* cache,
         const EngineSettings* settings
     ) : level(level), 
-        renderer(RENDERER_CAPACITY, level->content, cache, settings)
+        renderer(settings->graphics.chunkMaxVertices.get(),
+                 level->content, cache, settings)
     {}
 
     RendererResult operator()(const std::shared_ptr<Chunk>& chunk) override {
@@ -43,12 +42,13 @@ ChunksRenderer::ChunksRenderer(
         [=](RendererResult& mesh){
             meshes[mesh.key] = mesh.renderer->createMesh();
             inwork.erase(mesh.key);
-        })
+        }, settings->graphics.chunkMaxRenderers.get())
 {
     threadPool.setStandaloneResults(false);
     threadPool.setStopOnFail(false);
     renderer = std::make_unique<BlocksRenderer>(
-        RENDERER_CAPACITY, level->content, cache, settings
+        settings->graphics.chunkMaxVertices.get(), 
+        level->content, cache, settings
     );
     logger.info() << "created " << threadPool.getWorkersCount() << " workers";
 }

src/settings.hpp

@@ -64,6 +64,8 @@ struct GraphicsSettings {
     /// @brief Enable chunks frustum culling
     FlagSetting frustumCulling {true};
     IntegerSetting skyboxResolution {64 + 32, 64, 128};
+    IntegerSetting chunkMaxVertices {1'000'000, 0, 4'000'000};
+    IntegerSetting chunkMaxRenderers {0, -4, 32};
 };
 
 struct DebugSettings {

src/util/ThreadPool.hpp

@@ -103,14 +103,40 @@ namespace util {
             }
         }
     public:
+        static constexpr int UNLIMITED = 0;
+        static constexpr int HALF = -2;
+        static constexpr int QUARTER = -4;
+
+        /// @brief Main thread pool constructor
+        /// @param name thread pool name (used in logger)
+        /// @param workersSupplier workers factory function
+        /// @param resultConsumer workers results consumer function
+        /// @param maxWorkers max number of workers. Special values: 0 is 
+        /// unlimited, -2 is half of auto count, -4 is quarter.
         ThreadPool(
             std::string name,
             supplier<std::shared_ptr<Worker<T, R>>> workersSupplier,
-            consumer<R&> resultConsumer
+            consumer<R&> resultConsumer,
+            int maxWorkers=UNLIMITED
         )
             : logger(std::move(name)), resultConsumer(resultConsumer) {
-            const uint num_threads = std::thread::hardware_concurrency();
+            uint numThreads = std::thread::hardware_concurrency();
-            for (uint i = 0; i < num_threads; i++) {
+            switch (maxWorkers) {
+                case UNLIMITED:
+                    break;
+                case HALF:
+                    numThreads = std::max(1U, numThreads);
+                    break;
+                case QUARTER:
+                    numThreads = std::max(1U, numThreads / 4);
+                    break;
+                default:
+                    numThreads = std::max(
+                        1U, std::min(numThreads, static_cast<uint>(maxWorkers))
+                    );
+                    break;
+            }
+            for (uint i = 0; i < numThreads; i++) {
                 threads.emplace_back(
                     &ThreadPool<T, R>::threadLoop, this, i, workersSupplier()
                 );