From a65cf6ed668cdc0a4e99fb747db313e6049f7f09 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Tue, 1 Oct 2024 23:24:01 +0300
Subject: [PATCH 1/2] add ThreadPool maxWorkers constructor argument

---
 src/util/ThreadPool.hpp | 32 +++++++++++++++++++++++++++++---
 1 file changed, 29 insertions(+), 3 deletions(-)

diff --git a/src/util/ThreadPool.hpp b/src/util/ThreadPool.hpp
index c375b445..9acd1902 100644
--- a/src/util/ThreadPool.hpp
+++ b/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();
-            for (uint i = 0; i < num_threads; i++) {
+            uint numThreads = std::thread::hardware_concurrency();
+            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()
                 );

From e750d90ff41594be20269c0eddacc049b7e59144 Mon Sep 17 00:00:00 2001
From: MihailRis <mexaruc@gmail.com>
Date: Tue, 1 Oct 2024 23:25:25 +0300
Subject: [PATCH 2/2] add 'graphics.chunk-max-vertices',
 'graphics.chunk-max-renderers' settings

---
 src/files/settings_io.cpp              |  2 ++
 src/graphics/render/BlocksRenderer.cpp |  2 +-
 src/graphics/render/ChunksRenderer.cpp | 12 ++++++------
 src/settings.hpp                       |  2 ++
 4 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/src/files/settings_io.cpp b/src/files/settings_io.cpp
index f5fc05d2..7d04d693 100644
--- a/src/files/settings_io.cpp
+++ b/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);
diff --git a/src/graphics/render/BlocksRenderer.cpp b/src/graphics/render/BlocksRenderer.cpp
index 5b6f1257..38ac7f4c 100644
--- a/src/graphics/render/BlocksRenderer.cpp
+++ b/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),
diff --git a/src/graphics/render/ChunksRenderer.cpp b/src/graphics/render/ChunksRenderer.cpp
index 743676fa..76af55d2 100644
--- a/src/graphics/render/ChunksRenderer.cpp
+++ b/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";
 }
diff --git a/src/settings.hpp b/src/settings.hpp
index dcf5086b..ed368863 100644
--- a/src/settings.hpp
+++ b/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 {