initial update and render with concurrent DS

include/camera.hpp

@@ -6,7 +6,7 @@
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtc/type_ptr.hpp>
 
-#include <iostream>
+#include <atomic>
 
 class Camera
 {
@@ -38,6 +38,9 @@ public:
         if (glfwGetKey(window, GLFW_KEY_Z) == GLFW_PRESS)
             this->cameraPos -= cameraSpeed * cameraUp;
 
+	posX = cameraPos.x;
+	posY = cameraPos.y;
+	posZ = cameraPos.z;
 
         direction.x = cos(glm::radians(yaw)) * cos(glm::radians(pitch));
         direction.y = sin(glm::radians(pitch));
@@ -78,6 +81,10 @@ public:
     glm::mat4 getView() { return view; }
     glm::mat4 getProjection() { return projection; }
 
+    float getAtomicPosX() { return posX; }
+    float getAtomicPosY() { return posY; }
+    float getAtomicPosZ() { return posZ; }
+
     // Plane extraction as per Gribb&Hartmann
     // 6 planes, each with 4 components (a,b,c,d)
     void getFrustumPlanes(glm::vec4 planes[6], bool normalize)
@@ -114,6 +121,8 @@ private:
 
     float lastX = 400, lastY = 300;
     float yaw, pitch;
+
+    std::atomic<float> posX, posY, posZ;
 };
 
 #endif

include/chunk.hpp

@@ -27,6 +27,8 @@ namespace Chunk
     constexpr uint8_t CHUNK_STATE_MESHED = 2;
     constexpr uint8_t CHUNK_STATE_MESH_LOADED = 4;
     constexpr uint8_t CHUNK_STATE_LOADED = 8;
+    constexpr uint8_t CHUNK_STATE_OUTOFVISION = 16;
+    constexpr uint8_t CHUNK_STATE_UNLOADED = 32;
     constexpr uint8_t CHUNK_STATE_EMPTY = 64;
 
     int coord3DTo1D(int x, int y, int z);
@@ -39,6 +41,9 @@ namespace Chunk
         ~Chunk();
 
     public:
+	void createBuffers();
+	void deleteBuffers();
+
         glm::vec3 getPosition() { return this->position; }
         uint8_t getTotalState() { return this->state; }
         bool getState(uint8_t n) { return (this->state & n) == n; }
@@ -52,8 +57,7 @@ namespace Chunk
 
     public:
         GLuint VAO{0}, VBO{0}, EBO{0}, colorBuffer{0}, vIndex{0};
-        
+	std::atomic<float> unload_timer{0};
-        std::mutex mutex_state;
         
 	std::vector<GLfloat> vertices;
 	std::vector<GLfloat> colors;

include/chunkmanager.hpp

@@ -1,33 +1,24 @@
 #ifndef CHUNKMANAGER_H
 #define CHUNKMANAGER_H
 
-// Second to be passed outside of render distance for a chunk to be destroyed
+// Seconds to be passed outside of render distance for a chunk to be destroyed
 #define UNLOAD_TIMEOUT 10
 
-#include <unordered_map>
 #include <thread>
+
 #include "chunk.hpp"
 #include "globals.hpp"
 
 namespace chunkmanager
 {
-    std::thread initGenThread();
+    std::thread init();
-    std::thread initMeshThread();
-    void stopGenThread();
-    void stopMeshThread();
-
-    void mesh();
-    void generate();
-
-    void init();
     void blockpick(bool place);
     uint32_t calculateIndex(uint16_t i, uint16_t j, uint16_t k);
     
+    void stop();
     void destroy();
-    std::unordered_map<std::uint32_t, Chunk::Chunk*>& getChunks();
     std::array<std::array<int, 3>, chunks_volume>& getChunksIndices();
-    void update(float deltaTime);
+    void update();
-    void updateChunk(uint32_t, uint16_t, uint16_t, uint16_t);
 }
 
 #endif

include/renderer.hpp

@@ -1,6 +1,9 @@
 #ifndef RENDERER_H
 #define RENDERER_H
 
+#include <oneapi/tbb/concurrent_unordered_set.h>
+
+#include "chunk.hpp"
 #include "shader.hpp"
 
 namespace renderer{
@@ -8,6 +11,7 @@ namespace renderer{
     void render();
     void destroy();
     Shader* getRenderShader();
+    oneapi::tbb::concurrent_unordered_set<Chunk::Chunk*>& getChunksToRender();
 
 };
 

src/chunk.cpp

@@ -19,27 +19,30 @@ namespace Chunk
     {
         this->position = pos;
         this->setState(CHUNK_STATE_EMPTY, true);
+    }
 
+    Chunk ::~Chunk()
+    {
+	vertices.clear();
+	indices.clear();
+	colors.clear();
+	this->deleteBuffers();
+    }
+
+    void Chunk::createBuffers(){
 	glGenVertexArrays(1, &(this->VAO));
 	glGenBuffers(1, &(this->colorBuffer));
 	glGenBuffers(1, &(this->VBO));
 	glGenBuffers(1, &(this->EBO));
 
-	mutex_state.unlock();
     }
 
-    Chunk ::~Chunk()
+    void Chunk::deleteBuffers(){
-    {
         glDeleteBuffers(1, &(this->colorBuffer));
         glDeleteBuffers(1, &(this->VBO));
         glDeleteBuffers(1, &(this->EBO));
         glDeleteVertexArrays(1, &(this->VAO));
 
-	vertices.clear();
-	indices.clear();
-	colors.clear();
-
-	mutex_state.unlock();
     }
 
     Block Chunk::getBlock(int x, int y, int z)

src/chunkgenerator.cpp

@@ -84,6 +84,7 @@ void generateNoise(Chunk::Chunk *chunk)
     }
 
     chunk->setBlocks(block_prev_start, CHUNK_VOLUME, block_prev);
+    chunk->setState(Chunk::CHUNK_STATE_GENERATED, true);
 }
 
 void generateNoise3D(Chunk::Chunk *chunk) {

src/chunkmanager.cpp

@@ -1,105 +1,36 @@
+#include "chunkmanager.hpp"
+
+#include <atomic>
+#include <math.h>
+#include <thread>
+
 #include <glm/glm.hpp>
 #include <glm/gtc/matrix_transform.hpp>
-#include <glm/gtc/type_ptr.hpp>
+#include <oneapi/tbb/concurrent_hash_map.h>
 
 #include "chunk.hpp"
 #include "chunkgenerator.hpp"
-#include "chunkmanager.hpp"
 #include "chunkmesher.hpp"
 #include "globals.hpp"
-
+#include "renderer.hpp"
-#include <atomic>
-#include <iostream>
-#include <math.h>
-#include <mutex>
-#include <set>
-#include <string>
-#include <unordered_map>
-#include <thread>
 
 namespace chunkmanager
 {
-    std::unordered_map<std::uint32_t, Chunk::Chunk *> chunks;
+    typedef oneapi::tbb::concurrent_hash_map<uint32_t, Chunk::Chunk*> ChunkTable;
+    ChunkTable chunks;
+
+    //std::unordered_map<std::uint32_t, Chunk::Chunk *> chunks;
     std::array<std::array<int, 3>, chunks_volume> chunks_indices;
 
-    // thread management
+    std::atomic_bool should_run;
-    std::mutex mutex_queue_generate;
+    std::thread init(){
-    std::mutex mutex_queue_mesh;
-    std::set<Chunk::Chunk *> to_generate;
-    std::set<Chunk::Chunk *> to_mesh;
-    std::atomic_bool generate_should_run;
-    std::atomic_bool mesh_should_run;
-
-    // update variables
-    uint8_t f = 0;
-    int rr{RENDER_DISTANCE * RENDER_DISTANCE};
-    glm::vec3 cameraPos;
-    int chunkX, chunkY, chunkZ;
-
-    // disposal
-    std::unordered_map<uint32_t, float> to_delete;
-    std::set<uint32_t> to_delete_delete;
-
-    void mesh()
-    {
-	while (mesh_should_run)
-            if (mutex_queue_mesh.try_lock())
-            {
-                for (const auto &c : to_mesh)
-                {
-                    if (c->mutex_state.try_lock())
-                    {
-                        chunkmesher::mesh(c);
-                        c->setState(Chunk::CHUNK_STATE_MESHED, true);
-                        c->mutex_state.unlock();
-                    }
-                }
-                to_mesh.clear();
-                mutex_queue_mesh.unlock();
-            }
-    }
-
-    void generate()
-    {
-        while (generate_should_run)
-            if (mutex_queue_generate.try_lock())
-            {
-                for (const auto &c : to_generate)
-                {
-                    if (c->mutex_state.try_lock())
-                    {
-                        generateChunk(c);
-                        c->setState(Chunk::CHUNK_STATE_GENERATED, true);
-                        c->mutex_state.unlock();
-                    }
-                }
-                to_generate.clear();
-                mutex_queue_generate.unlock();
-            }
-    }
-
-    std::thread initMeshThread()
-    {
-	mesh_should_run = true;
-        std::thread mesh_thread(mesh);
-        return mesh_thread;
-    }
-
-    std::thread initGenThread()
-    {
-	generate_should_run = true;
-        std::thread gen_thread(generate);
-        return gen_thread;
-    }
-
-    void init(){
 	int index{0};
+	int rr{RENDER_DISTANCE * RENDER_DISTANCE};
 
         int xp{0}, x{0};
         bool b = true;
 
-        // Iterate over all chunks, in concentric spheres starting fron the player and going
+        // Iterate over all chunks, in concentric spheres starting fron the player and going outwards. Alternate left and right
-	// outwards. Alternate left and right
         // Eq. of the sphere (x - a)² + (y - b)² + (z - c)² = r²
         while (xp <= RENDER_DISTANCE)
         {
@@ -131,168 +62,36 @@ namespace chunkmanager
             }
             else  b = false;
 	}
+
+	should_run = true;
+	std::thread update_thread (update);
+	return update_thread;
     }
 
-    void update(float deltaTime)
+    std::vector<uint32_t> chunks_todelete;
-    {
+    void update(){
-	// Try to lock resources
+	while(should_run) {
-        f = 0;
+	    //cameraPos = theCamera.getPos();
-        f |= mutex_queue_generate.try_lock();
+	    int chunkX=static_cast<int>(theCamera.getAtomicPosX() / CHUNK_SIZE);
-        f |= mutex_queue_mesh.try_lock() << 1;
+	    int chunkY=static_cast<int>(theCamera.getAtomicPosY() / CHUNK_SIZE);
+	    int chunkZ=static_cast<int>(theCamera.getAtomicPosZ() / CHUNK_SIZE);
 
-        cameraPos = theCamera.getPos();
+	    // Update other chunks
-        chunkX=static_cast<int>(cameraPos.x) / CHUNK_SIZE;
+	    for(int i = 0; i < chunks_volume; i++) {
-	chunkY=static_cast<int>(cameraPos.y) / CHUNK_SIZE;
+		const uint16_t x = chunks_indices[i][0] + chunkX;
-	chunkZ=static_cast<int>(cameraPos.z) / CHUNK_SIZE;
+		const uint16_t y = chunks_indices[i][1] + chunkY;
+		const uint16_t z = chunks_indices[i][2] + chunkZ;
+		const uint32_t index = calculateIndex(x, y, z);
 
-	// Use time in float to be consistent with glfw
+		ChunkTable::accessor a;
-	float currentTime = glfwGetTime();
+		if(!chunks.find(a, index)) chunks.emplace(a, std::make_pair(index, new Chunk::Chunk(glm::vec3(x,y,z))));
 
-	// Check for far chunks that need to be cleaned up from memory
+		if(! (a->second->getState(Chunk::CHUNK_STATE_GENERATED))) generateChunk(a->second);
-	int nUnloaded{0};
+		if(! (a->second->getState(Chunk::CHUNK_STATE_MESHED))) chunkmesher::mesh(a->second);
-	for(const auto& n : chunks){
-		Chunk::Chunk* c = n.second;
-		int x{(int)(c->getPosition().x)};
-		int y{(int)(c->getPosition().y)};
-		int z{(int)(c->getPosition().z)};
-		if( (chunkX-x)*(chunkX-x) + (chunkY-y)*(chunkY-y) + (chunkZ-z)*(chunkZ-z) >=
-			(int)(RENDER_DISTANCE*1.5)*(int)(RENDER_DISTANCE*1.5))
-		    if(to_delete.find(n.first) == to_delete.end())
-			to_delete.insert(std::make_pair(n.first, currentTime));
-	}
-	for(const auto& n :to_delete){
-	    if(  currentTime>=n.second + UNLOAD_TIMEOUT) {
-		    delete chunks.at(n.first);
-		    chunks.erase(n.first);
-		    nUnloaded++;
 
-		    // Delete afterwards to avoid exception due to invalid iterators
+		renderer::getChunksToRender().insert(a->second);
-		    to_delete_delete.insert(n.first);
-	    }
-	}
-	for(uint32_t i : to_delete_delete) to_delete.erase(i);
-	to_delete_delete.clear();
-	if(nUnloaded) std::cout << "Unloaded " << nUnloaded << " chunks\n";
 
-	for(int i = 0; i < chunks_volume; i++) 
+		a.release();
-	    updateChunk(calculateIndex(chunks_indices[i][0] + chunkX,
-					chunks_indices[i][1] + chunkY,
-					chunks_indices[i][2] + chunkZ),
-			chunks_indices[i][0] + chunkX,
-			chunks_indices[i][1] + chunkY,
-			chunks_indices[i][2] + chunkZ);
-
-	// Unlock mutexes if previously locked. Unlocking a mutex not locked by the current thread
-	// or already locked is undefined behaviour, so checking has to be done
-        if ((f & 1))
-            mutex_queue_generate.unlock();
-        if ((f & 2))
-            mutex_queue_mesh.unlock();
-    }
-
-    // Generation and meshing happen in two separate threads from the main one
-    // Chunk states are used to decide which actions need to be done on the chunk and sets+mutexes
-    // to pass the chunks to be operated on between the threads.
-    // Uploading data to GPU still needs to be done in the main thread, or another OpenGL context
-    // needs to be opened, which further complicates stuff.
-    void updateChunk(uint32_t index, uint16_t i, uint16_t j, uint16_t k)
-    {
-        if (chunks.find(index) == chunks.end())
-        {
-            Chunk::Chunk *c = new Chunk::Chunk(glm::vec3(i, j, k));
-            chunks.insert(std::make_pair(index, c));
-        }
-        else
-        {
-            Chunk::Chunk *c = chunks.at(index);
-
-            if (!(c->mutex_state.try_lock()))
-                return;
-
-            if (!c->getState(Chunk::CHUNK_STATE_GENERATED))
-            {
-                if (f & 1)
-                    to_generate.insert(c);
-            }
-            else
-            {
-                if (!c->getState(Chunk::CHUNK_STATE_MESHED))
-                {
-                    if (f & 2)
-                        to_mesh.insert(c);
-                }
-                else
-                {
-                    if (!c->getState(Chunk::CHUNK_STATE_MESH_LOADED)) chunkmesher::sendtogpu(c);
-                }
-            }
-            c->mutex_state.unlock();
-        }
-    }
-
-    void blockpick(bool place){
-	// cast a ray from the camera in the direction pointed by the camera itself
-	glm::vec3 pos = cameraPos;
-	for(float t = 0.0; t <= 10.0; t += 0.5){
-	    // traverse the ray a block at the time
-	    pos = theCamera.getPos() + t * theCamera.getFront();
-	    
-	    // get which chunk and block the ray is at
-	    int px = ((int)(pos.x))/CHUNK_SIZE;
-	    int py = ((int)(pos.y))/CHUNK_SIZE;
-	    int pz = ((int)(pos.z))/CHUNK_SIZE;
-	    int bx = pos.x - px*CHUNK_SIZE;
-	    int by = pos.y - py*CHUNK_SIZE;
-	    int bz = pos.z - pz*CHUNK_SIZE;
-
-	    // exit early if the position is invalid or the chunk does not exist
-	    if(px < 0 || py < 0 || pz < 0) return;
-	    if(chunks.find(calculateIndex(px, py, pz)) == chunks.end()) return;
-
-	    Chunk::Chunk* c = chunks.at(calculateIndex(px, py, pz));
-	    Block b = c->getBlock(bx, by, bz);
-
-	    // if the block is non empty
-	    if(b != Block::AIR){
-
-		// if placing a new block
-		if(place){
-		    // Go half a block backwards on the ray, to check the block where the ray was
-		    // coming from
-		    // Doing this and not using normal adds the unexpected (and unwanted) ability to
-		    // place blocks diagonally, without faces colliding with the block that has
-		    // been clicked
-		    pos -= theCamera.getFront()*0.5f;
-		    
-		    int px1 = ((int)(pos.x))/CHUNK_SIZE;
-		    int py1 = ((int)(pos.y))/CHUNK_SIZE;
-		    int pz1 = ((int)(pos.z))/CHUNK_SIZE;
-		    int bx1 = pos.x - px1*CHUNK_SIZE;
-		    int by1 = pos.y - py1*CHUNK_SIZE;
-		    int bz1 = pos.z - pz1*CHUNK_SIZE;
-
-		    // exit early if the position is invalid or the chunk does not exist
-		    if(px1 < 0 || py1 < 0 || pz1 < 0) return;
-		    if(chunks.find(calculateIndex(px1, py1, pz1)) == chunks.end()) return;
-
-		    Chunk::Chunk* c1 = chunks.at(calculateIndex(px1, py1, pz1));
-		    // place the new block (only stone for now)
-		    c1->setBlock( Block::STONE, bx1, by1, bz1);
-
-		    // update the mesh of the chunk
-		    chunkmesher::mesh(c1);
-		    // mark the mesh of the chunk the be updated on the gpu
-		    c1->setState(Chunk::CHUNK_STATE_MESH_LOADED, false);
-		}else{
-		    // replace the current block with air to remove it
-		    c->setBlock( Block::AIR, bx, by, bz);
-
-		    // update the mesh of the chunk
-		    chunkmesher::mesh(c);
-		    // mark the mesh of the chunk the be updated on the gpu
-		    c->setState(Chunk::CHUNK_STATE_MESH_LOADED, false);
-		}
-		break;
 	    }
 	}
     }
@@ -302,21 +101,13 @@ namespace chunkmanager
 	 return i | (j << 10) | (k << 20); 
     }
 
-    std::unordered_map<std::uint32_t, Chunk::Chunk*>& getChunks(){ return chunks; }
     std::array<std::array<int, 3>, chunks_volume>& getChunksIndices(){ return chunks_indices; }
 
-    void destroy()
+    void stop() { should_run=false; }
-    {
+    void destroy(){
-        for (auto &n : chunks)
+	/*for(const auto& n : chunks){
-            delete n.second;
+	    delete n.second;
-    }
+	}*/
-
-    void stopGenThread(){
-	generate_should_run = false;
-    }
-
-    void stopMeshThread(){
-	mesh_should_run = false;
     }
 
 };

src/chunkmesher.cpp

@@ -35,12 +35,16 @@ void mesh(Chunk::Chunk* chunk)
     chunk->vIndex = 0;
 
     // Abort if chunk is empty
-    if(chunk->getState(Chunk::CHUNK_STATE_EMPTY)) return;
+    if(chunk->getState(Chunk::CHUNK_STATE_EMPTY)){
+	chunk->setState(Chunk::CHUNK_STATE_MESHED, true);
+	return;
+    }
 
     // convert tree to array since it is easier to work with it
     int length{0};
     std::unique_ptr<Block[]> blocks = chunk->getBlocksArray(&length);
     if(length == 0) {
+	chunk->setState(Chunk::CHUNK_STATE_MESHED, true);
 	return;
     }
     
@@ -180,13 +184,14 @@ void mesh(Chunk::Chunk* chunk)
             }
         }
     }
+
+    chunk->setState(Chunk::CHUNK_STATE_MESHED, true);
 }
 
 void sendtogpu(Chunk::Chunk* chunk)
 {
     if (chunk->vIndex > 0)
     {
-
 	// bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
 	glBindVertexArray(chunk->VAO);
 

src/main.cpp

@@ -63,9 +63,7 @@ int main()
 
     SpaceFilling::initLUT();
     renderer::init();
-    chunkmanager::init();
+    std::thread chunkmanager_thread = chunkmanager::init();
-    std::thread genThread = chunkmanager::initGenThread();
-    std::thread meshThread = chunkmanager::initMeshThread();
 
     while (!glfwWindowShouldClose(window))
     {
@@ -94,9 +92,6 @@ int main()
 	// Reset blockping timeout if 200ms have passed
 	if(glfwGetTime() - lastBlockPick > 0.1) blockpick = false;
 
-        // ChunkManager
-        chunkmanager::update(deltaTime);
-
 	// Render pass
 	renderer::render();
 
@@ -106,10 +101,8 @@ int main()
     }
 
     // Stop threads and wait for them to finish
-    chunkmanager::stopGenThread();
+    chunkmanager::stop();
-    chunkmanager::stopMeshThread();
+    chunkmanager_thread.join();
-    genThread.join();
-    meshThread.join();
 
     // Cleanup allocated memory
     chunkmanager::destroy();
@@ -136,13 +129,13 @@ void processInput(GLFWwindow *window)
         glfwSetWindowShouldClose(window, true);
 
     if(glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_2) == GLFW_PRESS && !blockpick){
-	chunkmanager::blockpick(false);
+	//chunkmanager::blockpick(false);
 	blockpick=true;
 	lastBlockPick=glfwGetTime();
     }
 
     if(glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_1) == GLFW_PRESS && !blockpick){
-	chunkmanager::blockpick(true);
+	//chunkmanager::blockpick(true);
 	blockpick=true;
 	lastBlockPick=glfwGetTime();
     }

src/renderer.cpp

@@ -3,14 +3,18 @@
 #include "chunkmanager.hpp"
 #include "chunkmesher.hpp"
 #include "globals.hpp"
-
 #include "stb_image.h"
 
 namespace renderer{
+    oneapi::tbb::concurrent_unordered_set<Chunk::Chunk*> chunks_torender;
+    oneapi::tbb::concurrent_unordered_set<Chunk::Chunk*> render_todelete;
+
     Shader* theShader;
     GLuint chunkTexture;
 
     Shader* getRenderShader() { return theShader; }
+    oneapi::tbb::concurrent_unordered_set<Chunk::Chunk*>& getChunksToRender(){ return chunks_torender; }
+
 
     void init(){
 	// Create Shader
@@ -40,63 +44,89 @@ namespace renderer{
 	int total{0}, toGpu{0};
 	glm::vec4 frustumPlanes[6];
 	theCamera.getFrustumPlanes(frustumPlanes, true);
-
 	glm::vec3 cameraPos = theCamera.getPos();	
-        int chunkX=static_cast<int>(cameraPos.x) / CHUNK_SIZE;
+	glm::vec3 cameraChunkPos = cameraPos / static_cast<float>(CHUNK_SIZE);
-	int chunkY=static_cast<int>(cameraPos.y) / CHUNK_SIZE;
-	int chunkZ=static_cast<int>(cameraPos.z) / CHUNK_SIZE;
 
 	theShader->use();
 	theShader->setVec3("viewPos", cameraPos);
-	for(int i = 0; i < chunks_volume; i++) {
-	    Chunk::Chunk* c = chunkmanager::getChunks().at(chunkmanager::calculateIndex(chunkmanager::getChunksIndices()[i][0] +
-			chunkX, chunkmanager::getChunksIndices()[i][1] + chunkY, chunkmanager::getChunksIndices()[i][2] + chunkZ));
-	    // Frustum Culling of chunk
-	    total++;
 
-	    glm::vec3 chunk = c->getPosition();
+	for(Chunk::Chunk* c : chunks_torender){
-	    glm::vec4 chunkW = glm::vec4(chunk.x*static_cast<float>(CHUNK_SIZE), chunk.y*static_cast<float>(CHUNK_SIZE), chunk.z*static_cast<float>(CHUNK_SIZE),1.0);
+	    if(! (c->getState(Chunk::CHUNK_STATE_MESHED))) continue;
-	    glm::mat4 model = glm::translate(glm::mat4(1.0), ((float)CHUNK_SIZE) * chunk);
 
-	    // Check if all the corners of the chunk are outside any of the planes
+	    // If the mesh is ready send it to the gpu
-	    // TODO (?) implement frustum culling as per (Inigo Quilez)[https://iquilezles.org/articles/frustumcorrect/], and check each
+	    if(! (c->getState(Chunk::CHUNK_STATE_MESH_LOADED))){
-	    // plane against each corner of the chunk 
+		if(c->VAO == 0) c->createBuffers();
-	    bool out=false;
+		chunkmesher::sendtogpu(c);
-	    int a{0};
+		c->setState(Chunk::CHUNK_STATE_MESH_LOADED, true);
-	    for(int p = 0; p < 6; p++){
-		a = 0;
-		for(int i = 0; i < 8; i++)  a += glm::dot(frustumPlanes[p], glm::vec4(chunkW.x + ((float)(i & 1))*CHUNK_SIZE, chunkW.y
-				+ ((float)((i & 2) >> 1))*CHUNK_SIZE, chunkW.z + ((float)((i & 4) >> 2))*CHUNK_SIZE, 1.0)) < 0.0;
-
-		if(a==8){
-		    out=true;
-		    break;
-		}
 	    }
 
-	    if (!out)
+	    if(glm::distance(c->getPosition(), cameraChunkPos) < static_cast<float>(RENDER_DISTANCE)){
-	    {
+		// if chunk can be seen
-		toGpu++;
+		// reset out-of-vision and unload flags
+		c->setState(Chunk::CHUNK_STATE_OUTOFVISION, false);
+		c->setState(Chunk::CHUNK_STATE_UNLOADED, false);
 
-		if(c->getState(Chunk::CHUNK_STATE_MESH_LOADED) && c->vIndex > 0)
+		// Perform frustum culling and eventually render
-		{
+		glm::vec3 chunk = c->getPosition();
-		    // glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); // wireframe mode
+		glm::vec4 chunkW = glm::vec4(chunk.x*static_cast<float>(CHUNK_SIZE), chunk.y*static_cast<float>(CHUNK_SIZE), chunk.z*static_cast<float>(CHUNK_SIZE),1.0);
-		    theShader->setMat4("model", model);
+		glm::mat4 model = glm::translate(glm::mat4(1.0), ((float)CHUNK_SIZE) * chunk);
-		    theShader->setMat4("view", theCamera.getView());
-		    theShader->setMat4("projection", theCamera.getProjection());
 
-		    glBindVertexArray(c->VAO);
+		// Check if all the corners of the chunk are outside any of the planes
-		    glDrawElements(GL_TRIANGLES, c->vIndex , GL_UNSIGNED_INT, 0);
+		// TODO (?) implement frustum culling as per (Inigo Quilez)[https://iquilezles.org/articles/frustumcorrect/], and check each
-		    glBindVertexArray(0);
+		// plane against each corner of the chunk 
+		bool out=false;
+		int a{0};
+		for(int p = 0; p < 6; p++){
+		    a = 0;
+		    for(int i = 0; i < 8; i++)  a += glm::dot(frustumPlanes[p], glm::vec4(chunkW.x + ((float)(i & 1))*CHUNK_SIZE, chunkW.y
+				    + ((float)((i & 2) >> 1))*CHUNK_SIZE, chunkW.z + ((float)((i & 4) >> 2))*CHUNK_SIZE, 1.0)) < 0.0;
+
+		    if(a==8){
+			out=true;
+			break;
+		    }
 		}
+
+		if (!out)
+		{
+		    if(c->vIndex > 0)
+		    {
+			// glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); // wireframe mode
+			theShader->setMat4("model", model);
+			theShader->setMat4("view", theCamera.getView());
+			theShader->setMat4("projection", theCamera.getProjection());
+
+			glBindVertexArray(c->VAO);
+			glDrawElements(GL_TRIANGLES, c->vIndex , GL_UNSIGNED_INT, 0);
+			glBindVertexArray(0);
+		    }
+		}
+
+	    }else{
+		// When the chunk is outside render distance
+
+		if(c->getState(Chunk::CHUNK_STATE_OUTOFVISION) && glfwGetTime() -
+			c->unload_timer > UNLOAD_TIMEOUT){
+		    // If chunk was already out and enough time has passed
+		    // Mark the chunk to be unloaded
+		    c->setState(Chunk::CHUNK_STATE_UNLOADED, true);
+		    // And delete it from the render set 
+		    render_todelete.insert(c);
+		} else{
+		    // Mark has out of vision and annotate when it started
+		    c->setState(Chunk::CHUNK_STATE_OUTOFVISION, true);
+		    c->setState(Chunk::CHUNK_STATE_UNLOADED, false);
+		    c->unload_timer = glfwGetTime();
+		}
+		
 	    }
 	}
 	
-	//std::cout << "Chunks to mesh: " << to_mesh.size() << "\n";
+	for(Chunk::Chunk* i : render_todelete){
-	//std::cout << "Chunks to generate: " << to_generate.size() << "\n";
+	    chunks_torender.unsafe_erase(i);
-        //std::cout << "Total chunks to draw: " << total << ". Sent to GPU: " << toGpu << "\n";
+	}
+	render_todelete.clear();
     }
-
     void destroy(){
 	delete theShader;
     }