refactor

src/graphics/render/ChunksRenderer.cpp

@@ -1,9 +1,17 @@
 #include "ChunksRenderer.hpp"
 #include "BlocksRenderer.hpp"
 #include "debug/Logger.hpp"
+#include "assets/Assets.hpp"
 #include "graphics/core/Mesh.hpp"
+#include "graphics/core/Shader.hpp"
+#include "graphics/core/Texture.hpp"
+#include "graphics/core/Atlas.hpp"
 #include "voxels/Chunk.hpp"
+#include "voxels/Chunks.hpp"
 #include "world/Level.hpp"
+#include "window/Camera.hpp"
+#include "maths/FrustumCulling.hpp"
+#include "util/listutil.hpp"
 #include "settings.hpp"
 
 #include <iostream>
@@ -12,6 +20,8 @@
 
 static debug::Logger logger("chunks-render");
 
+size_t ChunksRenderer::visibleChunks = 0;
+
 class RendererWorker : public util::Worker<std::shared_ptr<Chunk>, RendererResult> {
     Level* level;
     BlocksRenderer renderer;
@@ -39,9 +49,14 @@ public:
 
 ChunksRenderer::ChunksRenderer(
     Level* level, 
+    const Assets& assets,
+    const Frustum& frustum,
     const ContentGfxCache* cache, 
     const EngineSettings* settings
 ) : level(level),
+    assets(assets),
+    frustum(frustum),
+    settings(settings),
     threadPool(
         "chunks-render-pool",
         [=](){return std::make_shared<RendererWorker>(level, cache, settings);}, 
@@ -103,14 +118,84 @@ std::shared_ptr<Mesh> ChunksRenderer::getOrRender(const std::shared_ptr<Chunk>&
     return found->second;
 }
 
-std::shared_ptr<Mesh> ChunksRenderer::get(Chunk* chunk) {
-    auto found = meshes.find(glm::ivec2(chunk->x, chunk->z));
-    if (found != meshes.end()) {
-        return found->second;
-    }
-    return nullptr;
-}
-
 void ChunksRenderer::update() {
     threadPool.update();
 }
+
+bool ChunksRenderer::drawChunk(
+    size_t index, const Camera& camera, Shader& shader, bool culling
+) {
+    auto chunk = level->chunks->getChunks()[index];
+    if (chunk == nullptr || !chunk->flags.lighted) {
+        return false;
+    }
+    float distance = glm::distance(
+        camera.position,
+        glm::vec3(
+            (chunk->x + 0.5f) * CHUNK_W,
+            camera.position.y,
+            (chunk->z + 0.5f) * CHUNK_D
+        )
+    );
+    auto mesh = getOrRender(chunk, distance < CHUNK_W * 1.5f);
+    if (mesh == nullptr) {
+        return false;
+    }
+    if (culling) {
+        glm::vec3 min(chunk->x * CHUNK_W, chunk->bottom, chunk->z * CHUNK_D);
+        glm::vec3 max(
+            chunk->x * CHUNK_W + CHUNK_W,
+            chunk->top,
+            chunk->z * CHUNK_D + CHUNK_D
+        );
+
+        if (!frustum.isBoxVisible(min, max)) return false;
+    }
+    glm::vec3 coord(chunk->x * CHUNK_W + 0.5f, 0.5f, chunk->z * CHUNK_D + 0.5f);
+    glm::mat4 model = glm::translate(glm::mat4(1.0f), coord);
+    shader.uniformMatrix("u_model", model);
+    mesh->draw();
+    return true;
+}
+
+void ChunksRenderer::drawChunks(
+    const Camera& camera, Shader& shader
+) {
+    const auto& chunks = *level->chunks;
+    const auto& atlas = assets.require<Atlas>("blocks");
+
+    atlas.getTexture()->bind();
+    update();
+
+    // [warning] this whole method is not thread-safe for chunks
+
+    int chunksWidth = chunks.getWidth();
+    int chunksOffsetX = chunks.getOffsetX();
+    int chunksOffsetY = chunks.getOffsetY();
+
+    if (indices.size() != chunks.getVolume()) {
+        indices.clear();
+        for (int i = 0; i < chunks.getVolume(); i++) {
+            indices.push_back(ChunksSortEntry {i, 0});
+        }
+    }
+    float px = camera.position.x / static_cast<float>(CHUNK_W) - 0.5f;
+    float pz = camera.position.z / static_cast<float>(CHUNK_D) - 0.5f;
+    for (auto& index : indices) {
+        float x = index.index % chunksWidth + chunksOffsetX - px;
+        float z = index.index / chunksWidth + chunksOffsetY - pz;
+        index.d = (x * x + z * z) * 1024;
+    }
+    util::insertion_sort(indices.begin(), indices.end());
+
+    bool culling = settings->graphics.frustumCulling.get();
+
+    visibleChunks = 0;
+    //if (GLEW_ARB_multi_draw_indirect && false) {
+        // TODO: implement Multi Draw Indirect chunks draw
+    //} else {
+        for (size_t i = 0; i < indices.size(); i++) {
+            visibleChunks += drawChunk(indices[i].index, camera, shader, culling);
+        }
+    //}
+}