Temp

src/game/scene/world/LocalWorld.cpp

@@ -10,7 +10,6 @@
 
 LocalWorld::LocalWorld(LocalDefs& defs, glm::vec3* playerPos, ClientNetworkInterpreter* server) :
     playerPos(playerPos),
-    dimension(&playerChunkPos),
     meshGenStream(defs, dimension),
     server(server),
     defs(defs) {}
@@ -28,7 +27,7 @@ void LocalWorld::update(double delta) {
     finishChunks();
 
     updateBlockDamages(delta);
-    dimension.update();
+    dimension.update(*playerPos);
 
     auto end = particles.begin();
     for (auto i = particles.begin(); i < particles.end(); i++) {
@@ -84,11 +83,11 @@ void LocalWorld::finishMeshes() {
     for (MeshDetails* meshDetails : finishedMeshes) {
 
         if (!meshDetails->vertices.empty()) {
-            auto meshChunk = new MeshChunk();
-            meshChunk->build(meshDetails->vertices, meshDetails->indices);
+            auto meshChunk = std::make_shared<MeshChunk>();
+            meshChunk->create(meshDetails->vertices, meshDetails->indices);
             meshChunk->setPos(meshDetails->pos);
 
-            dimension.addMeshChunk(meshChunk);
+            dimension.setMeshChunk(meshChunk);
             lastMeshUpdates++;
         } else {
             dimension.removeMeshChunk(meshDetails->pos);
@@ -168,40 +167,11 @@ std::shared_ptr<BlockChunk> LocalWorld::getChunk(glm::vec3 chunkPos) {
     return dimension.getChunk(chunkPos);
 }
 void LocalWorld::commitChunk(glm::vec3 pos, std::shared_ptr<BlockChunk> c) {
-    dimension.addBlockChunk(std::move(c));
-    attemptMeshChunk(pos);
+    dimension.setChunk(std::move(c));
+//    attemptMeshChunk(pos);
 }
 void LocalWorld::remeshChunk(glm::vec3 pos) {
-    attemptMeshChunk(pos);
-}
-
-void LocalWorld::attemptMeshChunk(glm::vec3 pos) {
-    auto thisChunk = getChunk(pos);
-    if (thisChunk == nullptr) return;
-
-    auto vectors = VecUtils::getCardinalVectors();
-    for (int i = 0; i < vectors.size(); i++) {
-        thisChunk->adjacent[i] = getAdjacentExists(pos + vectors[i], pos);
-    }
-
-    if (thisChunk->allAdjacentsExist() && thisChunk->shouldRender()) pendingMesh.push_back(pos);
-}
-bool LocalWorld::getAdjacentExists(glm::vec3 pos, glm::vec3 otherPos) {
-    auto chunk = getChunk(pos);
-    glm::vec3 diff = otherPos - pos;
-
-    if (chunk != nullptr) {
-        auto vectors = VecUtils::getCardinalVectors();
-        for (int i = 0; i < vectors.size(); i++) {
-            if (diff == vectors[i]) {
-                chunk->adjacent[i] = true;
-            }
-        }
-
-        if (chunk->allAdjacentsExist() && chunk->shouldRender()) pendingMesh.push_back(pos);
-        return true;
-    }
-    return false;
+//    attemptMeshChunk(pos);
 }
 
 int LocalWorld::renderChunks(Renderer &renderer) {

src/game/scene/world/LocalWorld.h

@@ -45,9 +45,6 @@ public:
 
     void damageBlock(glm::vec3 pos, float amount);
 
-    void attemptMeshChunk(glm::vec3 pos);
-    bool getAdjacentExists(glm::vec3 pos, glm::vec3 myPos);
-
     int renderChunks(Renderer &render);
     void renderEntities(Renderer &renderer);
     int getMeshChunkCount();
@@ -80,6 +77,5 @@ private:
     ClientNetworkInterpreter* server = nullptr;
     WorldInterpolationStream* worldGenStream = nullptr;
     Dimension dimension;
-    MeshGenStream meshGenStream;
     std::vector<glm::vec3> pendingMesh;
 };

src/world/Dimension.h

@@ -4,25 +4,23 @@
 
 #pragma once
 
-
 #include <unordered_map>
 #include <glm/vec3.hpp>
 #include "region/Region.h"
 #include "../util/Vec.h"
 #include "../game/scene/world/graph/MeshChunk.h"
+#include "../game/scene/world/graph/ChunkRenderRef.h"
+#include "../game/scene/world/MeshGenStream.h"
 
 class Dimension {
 public:
-    typedef std::unordered_map<glm::vec3, std::shared_ptr<BlockChunk>, VecUtils::compareFunc> chunk_map;
 
-    Dimension() = default;
-    explicit Dimension(glm::vec3* playerPos);
-
-    void addBlockChunk(std::shared_ptr<BlockChunk> chunk);
-    void addMeshChunk(MeshChunk* chunk);
+    void setChunk(std::shared_ptr<BlockChunk> chunk);
+    void setMeshChunk(std::shared_ptr<MeshChunk> chunk);
     void removeMeshChunk(const glm::vec3& pos);
 
-    void update();
+    void update(glm::vec3 playerPos);
+
     void setBlock(glm::vec3 pos, unsigned int block);
     unsigned int getBlock(glm::vec3 pos);
 
@@ -30,11 +28,17 @@ public:
     int getMeshChunkCount();
 
     std::shared_ptr<BlockChunk> getChunk(glm::vec3 pos);
-
-    ~Dimension();
 private:
-    glm::vec3* playerPos = nullptr;
-    std::list<MeshChunk*> meshChunks;
-    chunk_map blockChunks;
+    void attemptMeshChunk(const sptr<BlockChunk>& chunk);
+    bool getAdjacentExists(glm::vec3 pos);
+
+    glm::vec3 playerPos {};
+
+    MeshGenStream meshGenStream;
+    std::unordered_map<glm::vec3, ChunkRenderRef, VecUtils::compareFunc> renderRefs;
+    std::list<std::shared_ptr<ChunkRenderElem>> renderElems;
+
+    typedef std::unordered_map<glm::vec3, std::shared_ptr<BlockChunk>, VecUtils::compareFunc> block_chunk_map;
+    block_chunk_map blockChunks;
 };