make BlocksRenderer::createMesh return MeshData & make ChunksRenderer workers have standalone results

src/graphics/core/MeshData.hpp

@@ -16,6 +16,8 @@ struct MeshData {
     util::Buffer<int> indices;
     util::Buffer<vattr> attrs;
 
+    MeshData() = default;
+
     /// @param vertices vertex data buffer
     /// @param indices nullable indices buffer
     /// @param attrs vertex attribute sizes (must be null-terminated) 

src/graphics/render/BlocksRenderer.cpp

@@ -531,7 +531,18 @@ void BlocksRenderer::build(const Chunk* chunk, const ChunksStorage* chunks) {
     render(voxels);
 }
 
-std::shared_ptr<Mesh> BlocksRenderer::createMesh() {
+MeshData BlocksRenderer::createMesh() {
+    const vattr attrs[]{ {3}, {2}, {1}, {0} };
+    return MeshData(
+        util::Buffer<float>(vertexBuffer.get(), vertexOffset), 
+        util::Buffer<int>(indexBuffer.get(), indexSize),
+        util::Buffer<vattr>({{3}, {2}, {1}, {0}})
+    );
+}
+
+std::shared_ptr<Mesh> BlocksRenderer::render(const Chunk* chunk, const ChunksStorage* chunks) {
+    build(chunk, chunks);
+
     const vattr attrs[]{ {3}, {2}, {1}, {0} };
     size_t vcount = vertexOffset / BlocksRenderer::VERTEX_SIZE;
     return std::make_shared<Mesh>(
@@ -539,11 +550,6 @@ std::shared_ptr<Mesh> BlocksRenderer::createMesh() {
     );
 }
 
-std::shared_ptr<Mesh> BlocksRenderer::render(const Chunk* chunk, const ChunksStorage* chunks) {
-    build(chunk, chunks);
-    return createMesh();
-}
-
 VoxelsVolume* BlocksRenderer::getVoxelsBuffer() const {
     return voxelsBuffer.get();
 }

src/graphics/render/BlocksRenderer.hpp

@@ -10,6 +10,7 @@
 #include "voxels/Block.hpp"
 #include "voxels/Chunk.hpp"
 #include "voxels/VoxelsVolume.hpp"
+#include "graphics/core/MeshData.hpp"
 
 class Content;
 class Mesh;
@@ -148,7 +149,7 @@ public:
 
     void build(const Chunk* chunk, const ChunksStorage* chunks);
     std::shared_ptr<Mesh> render(const Chunk* chunk, const ChunksStorage* chunks);
-    std::shared_ptr<Mesh> createMesh();
+    MeshData createMesh();
     VoxelsVolume* getVoxelsBuffer() const;
 
     bool isCancelled() const {

src/graphics/render/ChunksRenderer.cpp

@@ -27,7 +27,13 @@ public:
 
     RendererResult operator()(const std::shared_ptr<Chunk>& chunk) override {
         renderer.build(chunk.get(), level->chunksStorage.get());
-        return RendererResult {glm::ivec2(chunk->x, chunk->z), &renderer};
+        if (renderer.isCancelled()) {
+            return RendererResult {
+                glm::ivec2(chunk->x, chunk->z), true, MeshData()};
+        }
+        auto meshData = renderer.createMesh();
+        return RendererResult {
+            glm::ivec2(chunk->x, chunk->z), false, std::move(meshData)};
     }
 };
 
@@ -40,13 +46,12 @@ ChunksRenderer::ChunksRenderer(
         "chunks-render-pool",
         [=](){return std::make_shared<RendererWorker>(level, cache, settings);}, 
         [=](RendererResult& mesh){
-            if (!mesh.renderer->isCancelled()) {
+            if (!mesh.cancelled) {
-                meshes[mesh.key] = mesh.renderer->createMesh();
+                meshes[mesh.key] = std::make_shared<Mesh>(mesh.meshData);
             }
             inwork.erase(mesh.key);
         }, settings->graphics.chunkMaxRenderers.get())
 {
-    threadPool.setStandaloneResults(false);
     threadPool.setStopOnFail(false);
     renderer = std::make_unique<BlocksRenderer>(
         settings->graphics.chunkMaxVertices.get(), 

src/graphics/render/ChunksRenderer.hpp

@@ -9,6 +9,7 @@
 #include "voxels/Block.hpp"
 #include "voxels/ChunksStorage.hpp"
 #include "util/ThreadPool.hpp"
+#include "graphics/core/MeshData.hpp"
 
 class Mesh;
 class Chunk;
@@ -19,7 +20,8 @@ struct EngineSettings;
 
 struct RendererResult {
     glm::ivec2 key;
-    BlocksRenderer* renderer;
+    bool cancelled;
+    MeshData meshData;
 };
 
 class ChunksRenderer {