.gitignore

@@ -9,5 +9,3 @@ gmon.out*
 cscope*
 test.cpp
 a.out
-*screenshot*
-imgui.ini

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "lib/imgui"]
-	path = lib/imgui
-	url = https://github.com/ocornut/imgui/

CMakeLists.txt

@@ -2,8 +2,8 @@ cmake_minimum_required(VERSION 3.2)
 
 project(cmake-project-template)
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 11)
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -O3")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -O3")
 #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -g")
 
 set(CMAKE_INSTALL_PREFIX ${PROJECT_SOURCE_DIR})

include/camera.hpp

@@ -18,10 +18,6 @@ public:
 
 	// This matrix needs to be also updated in viewPortCallback whenever it is changed
         projection = glm::perspective(glm::radians(90.0f), 800.0f / 600.0f, 0.1f, 1200.0f);
-
-	posX = cameraPos.x;
-	posY = cameraPos.y;
-	posZ = cameraPos.z;
     }
 
     void update(GLFWwindow *window, float deltaTime)
@@ -116,7 +112,7 @@ public:
 
 
 private:
-    glm::vec3 cameraPos = glm::vec3(512.0, 80.0f, 512.0f);
+    glm::vec3 cameraPos = glm::vec3(256.0, 80.0f, 256.0f);
     glm::vec3 cameraFront = glm::vec3(0.0f, 0.0f, -1.0f);
     glm::vec3 cameraUp = glm::vec3(0.0f, 1.0f, 0.0f);
     glm::vec3 direction = glm::vec3(0.0f);

include/chunk.hpp

@@ -20,27 +20,16 @@
 #define CHUNK_VOLUME (CHUNK_SIZE * CHUNK_SIZE * CHUNK_SIZE)
 #define CHUNK_MAX_INDEX (CHUNK_VOLUME - 1)
 
-// int32_t is fine, since i'm limiting the coordinate to only use up to ten bits (1023). There's actually two spare bits
-typedef int32_t chunk_index_t;
-typedef int16_t chunk_intcoord_t;
-typedef uint16_t chunk_state_t;
-
 namespace Chunk
 {
 
-    chunk_index_t calculateIndex(chunk_intcoord_t i, chunk_intcoord_t j, chunk_intcoord_t k);
+    constexpr uint8_t CHUNK_STATE_GENERATED = 1;
-    chunk_index_t calculateIndex(glm::vec3 pos);
+    constexpr uint8_t CHUNK_STATE_MESHED = 2;
-
+    constexpr uint8_t CHUNK_STATE_MESH_LOADED = 4;
-    constexpr chunk_state_t CHUNK_STATE_GENERATED = 1;
+    constexpr uint8_t CHUNK_STATE_LOADED = 8;
-    constexpr chunk_state_t CHUNK_STATE_MESHED = 2;
+    constexpr uint8_t CHUNK_STATE_OUTOFVISION = 16;
-    constexpr chunk_state_t CHUNK_STATE_MESH_LOADED = 4;
+    constexpr uint8_t CHUNK_STATE_UNLOADED = 32;
-    constexpr chunk_state_t CHUNK_STATE_LOADED = 8;
+    constexpr uint8_t CHUNK_STATE_EMPTY = 64;
-    constexpr chunk_state_t CHUNK_STATE_OUTOFVISION = 16;
-    constexpr chunk_state_t CHUNK_STATE_UNLOADED = 32;
-    constexpr chunk_state_t CHUNK_STATE_EMPTY = 64;
-    constexpr chunk_state_t CHUNK_STATE_IN_GENERATION_QUEUE = 128;
-    constexpr chunk_state_t CHUNK_STATE_IN_MESHING_QUEUE = 256;
-    constexpr chunk_state_t CHUNK_STATE_IN_DELETING_QUEUE = 512;
 
     int coord3DTo1D(int x, int y, int z);
 
@@ -52,15 +41,13 @@ namespace Chunk
         ~Chunk();
 
     public:
+	void createBuffers();
+	void deleteBuffers();
+
         glm::vec3 getPosition() { return this->position; }
-        void setState(chunk_state_t nstate, bool value);
+        uint8_t getTotalState() { return this->state; }
-        bool getState(chunk_state_t n) { return (this->state & n) == n; }
+        bool getState(uint8_t n) { return (this->state & n) == n; }
-	bool isFree(){ return !(
+        void setState(uint8_t nstate, bool value);
-		this->getState(CHUNK_STATE_IN_GENERATION_QUEUE) ||
-		this->getState(CHUNK_STATE_IN_MESHING_QUEUE) ||
-		this->getState(CHUNK_STATE_IN_DELETING_QUEUE)
-		); }
-        chunk_state_t getTotalState() { return this->state; }
 
         void setBlock(Block b, int x, int y, int z);
         void setBlocks(int start, int end, Block b);
@@ -69,15 +56,14 @@ namespace Chunk
 	std::unique_ptr<Block[]> getBlocksArray(int* len) { return (this->blocks.toArray(len)); }
 
     public:
+        GLuint VAO{0}, VBO{0}, extentsBuffer{0}, texinfoBuffer{0}, numVertices{0};
 	std::atomic<float> unload_timer{0};
-	chunk_index_t getIndex(){ return this->index; }
 
     private:
         glm::vec3 position{};
         IntervalMap<Block> blocks{};
         
-	std::atomic<chunk_state_t> state{0};
+	std::atomic_uint8_t state{0};
-	chunk_index_t index;
     };
 };
 

include/chunkmanager.hpp

@@ -1,14 +1,14 @@
 #ifndef CHUNKMANAGER_H
 #define CHUNKMANAGER_H
 
+#include "chunk.hpp"
+
 #include <oneapi/tbb/concurrent_hash_map.h>
 #include <oneapi/tbb/concurrent_queue.h>
 #include <oneapi/tbb/concurrent_priority_queue.h>
 #include <thread>
 
-#include "chunk.hpp"
 #include "globals.hpp"
-#include "worldupdatemessage.h"
 
 // Seconds to be passed outside of render distance for a chunk to be destroyed
 #define UNLOAD_TIMEOUT 10
@@ -19,7 +19,7 @@
 
 namespace chunkmanager
 {
-    typedef oneapi::tbb::concurrent_hash_map<chunk_index_t, Chunk::Chunk*> ChunkTable;
+    typedef oneapi::tbb::concurrent_hash_map<uint32_t, Chunk::Chunk*> ChunkTable;
     typedef std::pair<Chunk::Chunk*, uint8_t> ChunkPQEntry;
     // The comparing function to use
     struct compare_f {
@@ -30,12 +30,15 @@ namespace chunkmanager
     typedef oneapi::tbb::concurrent_priority_queue<ChunkPQEntry, compare_f> ChunkPriorityQueue;
 
     void init();
-    void update();
+    void blockpick(bool place);
+    uint32_t calculateIndex(uint16_t i, uint16_t j, uint16_t k);
+    
     void stop();
     void destroy();
-    WorldUpdateMsgQueue& getWorldUpdateQueue();
+    oneapi::tbb::concurrent_queue<Chunk::Chunk*>& getDeleteVector();
-    std::array<std::array<chunk_intcoord_t, 3>, chunks_volume>& getChunksIndices();
+    std::array<std::array<int, 3>, chunks_volume>& getChunksIndices();
     Block getBlockAtPos(int x, int y, int z);
+    void update();
 }
 
 #endif

include/chunkmeshdata.hpp

@@ -1,36 +0,0 @@
-#ifndef CHUNK_MESH_DATA_H
-#define CHUNK_MESH_DATA_H
-
-#include <oneapi/tbb/concurrent_queue.h>
-#include "chunk.hpp"
-
-enum class ChunkMeshDataType{
-    MESH_UPDATE
-};
-
-typedef struct ChunkMeshData{
-    chunk_index_t index;
-    glm::vec3 position;
-    int num_vertices = 0;
-
-    std::vector<GLfloat> vertices;
-    std::vector<GLfloat> extents;
-    std::vector<GLfloat> texinfo;
-    
-    ChunkMeshDataType message_type;
-
-    void clear(){
-	vertices.clear();
-	texinfo.clear();
-	extents.clear();
-	index = 0;
-	position = glm::vec3(0);
-	num_vertices = 0;
-    }
-
-}ChunkMeshData;
-typedef oneapi::tbb::concurrent_queue<ChunkMeshData*> ChunkMeshDataQueue;
-
-
-#endif
-

include/chunkmesher.hpp

@@ -5,12 +5,10 @@
 #include <vector>
 
 #include <glad/glad.h>
-#include <glm/glm.hpp>
 #include <GLFW/glfw3.h>
 #include <oneapi/tbb/concurrent_queue.h>
 
 #include "chunk.hpp"
-#include "chunkmeshdata.hpp"
 #include "globals.hpp"
 #include "shader.hpp"
 
@@ -23,12 +21,13 @@ namespace chunkmesher{
 	std::vector<GLfloat> extents;
 	std::vector<GLfloat> texinfo;
     };
+    oneapi::tbb::concurrent_queue<MeshData*>& getMeshDataQueue();
 
-    ChunkMeshDataQueue& getMeshDataQueue();
-    void init();
     void mesh(Chunk::Chunk* chunk);
+    void sendtogpu(MeshData* mesh_data);
+    void quad(MeshData* mesh_data, glm::vec3 bottomLeft, glm::vec3 topLeft, glm::vec3 topRight,
+	    glm::vec3 bottomRight, glm::vec3 normal, Block block, int dim, bool backFace);
 }
 
 
 #endif
-

include/controls.hpp

@@ -1,14 +0,0 @@
-#ifndef CONTROLS_H
-#define CONTROLS_H
-
-#include <glad/glad.h>
-#include <GLFW/glfw3.h>
-
-#define BLOCKPICK_TIMEOUT 0.1f
-
-namespace controls{
-    void init();
-    void update(GLFWwindow* window);
-};
-
-#endif

include/debugwindow.hpp

@@ -1,19 +0,0 @@
-#ifndef DEBUG_WINDOW_H
-#define DEBUG_WINDOW_H
-
-#include <any>
-#include <string>
-#include <GLFW/glfw3.h>
-
-namespace debug{
-    namespace window {
-	void init(GLFWwindow* window);
-	void prerender();
-	void render();
-	void destroy();
-
-	void set_parameter(std::string key, std::any value);
-    }
-}
-
-#endif

include/globals.hpp

@@ -13,8 +13,7 @@
 #define RENDER_DISTANCE 16
 
 extr Camera theCamera;
-// the cube spans in both directions, to each axis has to be multiplied by 2. 2^3=8
+constexpr int chunks_volume = static_cast<int>(1.333333333333*M_PI*(RENDER_DISTANCE*RENDER_DISTANCE*RENDER_DISTANCE));
-constexpr int chunks_volume = 8*(RENDER_DISTANCE*RENDER_DISTANCE*RENDER_DISTANCE);
 extr bool wireframe;
 
 extr float sines[360];

include/main.hpp

@@ -1,10 +1,8 @@
 #ifndef MAIN_H
 #define MAIN_H
 
-#include <glad/glad.h>
-#include <GLFW/glfw3.h>
-
 void framebuffer_size_callback(GLFWwindow *, int, int);
 void mouse_callback(GLFWwindow *window, double xpos, double ypos);
+void processInput(GLFWwindow *);
 
 #endif

include/renderer.hpp

@@ -6,56 +6,18 @@
 
 #include "chunk.hpp"
 #include "chunkmesher.hpp"
-#include "chunkmeshdata.hpp"
 #include "shader.hpp"
 
 namespace renderer{
-    typedef struct RenderInfo {
+    typedef oneapi::tbb::concurrent_unordered_set<Chunk::Chunk*> RenderSet;
-	chunk_index_t index;
-	int num_vertices;
-	glm::vec3 position;
-	bool buffers_allocated=false;
 
-	GLuint VAO, VBO, extentsBuffer, texinfoBuffer;
+    void init();
-
-	void allocateBuffers(){
-	    // Allocate buffers
-	    glGenVertexArrays(1, &VAO);
-	    glGenBuffers(1, &VBO);
-	    glGenBuffers(1, &extentsBuffer);
-	    glGenBuffers(1, &texinfoBuffer);
-
-	    buffers_allocated=true;
-	}
-
-	void deallocateBuffers(){
-	    // Allocate buffers
-	    glDeleteBuffers(1, &VBO);
-	    glDeleteBuffers(1, &extentsBuffer);
-	    glDeleteBuffers(1, &texinfoBuffer);
-	    glDeleteVertexArrays(1, &VAO);
-
-	    buffers_allocated=false;
-	}
-    } RenderInfo;
-
-    typedef oneapi::tbb::concurrent_queue<int32_t> IndexQueue;
-
-    void init(GLFWwindow* window);
-    void send_chunk_to_gpu(ChunkMeshData* mesh_data, RenderInfo* render_info);
     void render();
-    void resize_framebuffer(int width, int height);
-    void framebuffer_size_callback(GLFWwindow *window, int width, int height);
     void destroy();
-
-    void saveScreenshot(bool forceFullHD=false);
-
     Shader* getRenderShader();
-    ChunkMeshDataQueue& getMeshDataQueue();
+    RenderSet& getChunksToRender();
-    IndexQueue& getDeleteIndexQueue();
+    oneapi::tbb::concurrent_queue<chunkmesher::MeshData*>& getMeshDataQueue();
-
 
 };
 
 #endif
-

include/shader.hpp

@@ -34,70 +34,60 @@ public:
         gShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
         try
         {
-            std::stringstream vShaderStream, fShaderStream, gShaderStream;
-	    if(geometryPath){
-		gShaderFile.open(geometryPath);
-		gShaderStream << gShaderFile.rdbuf();
-		gShaderFile.close();
-		geometryCode = gShaderStream.str();
-	    }
-
             // open files
             vShaderFile.open(vertexPath);
             fShaderFile.open(fragmentPath);
+            gShaderFile.open(geometryPath);
+            std::stringstream vShaderStream, fShaderStream, gShaderStream;
             // read file's buffer contents into streams
             vShaderStream << vShaderFile.rdbuf();
             fShaderStream << fShaderFile.rdbuf();
+            gShaderStream << gShaderFile.rdbuf();
             // close file handlers
             vShaderFile.close();
             fShaderFile.close();
+            gShaderFile.close();
             // convert stream into string
             vertexCode = vShaderStream.str();
             fragmentCode = fShaderStream.str();
+	    geometryCode = gShaderStream.str();
         }
         catch (std::ifstream::failure &e)
         {
             std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ: " << e.what() << std::endl;
         }
-        // shader Program
-        ID = glCreateProgram();
-        unsigned int vertex, fragment, geometry;
-
-	// geometry shader
-	if(geometryPath){
-	    const char *gShaderCode = geometryCode.c_str();
-	    geometry = glCreateShader(GL_GEOMETRY_SHADER);
-	    glShaderSource(geometry, 1, &gShaderCode, NULL);
-	    glCompileShader(geometry);
-	    checkCompileErrors(geometry, "GEOMETRY");
-
-	    glAttachShader(ID, geometry);
-	}
-    
-        // vertex shader
         const char *vShaderCode = vertexCode.c_str();
+        const char *fShaderCode = fragmentCode.c_str();
+        const char *gShaderCode = geometryCode.c_str();
+        // 2. compile shaders
+        unsigned int vertex, fragment, geometry;
+        // vertex shader
         vertex = glCreateShader(GL_VERTEX_SHADER);
         glShaderSource(vertex, 1, &vShaderCode, NULL);
         glCompileShader(vertex);
         checkCompileErrors(vertex, "VERTEX");
-        glAttachShader(ID, vertex);
-
         // fragment Shader
-        const char *fShaderCode = fragmentCode.c_str();
         fragment = glCreateShader(GL_FRAGMENT_SHADER);
         glShaderSource(fragment, 1, &fShaderCode, NULL);
         glCompileShader(fragment);
         checkCompileErrors(fragment, "FRAGMENT");
+	// geometry shader
+	geometry = glCreateShader(GL_GEOMETRY_SHADER);
+	glShaderSource(geometry, 1, &gShaderCode, NULL);
+	glCompileShader(geometry);
+	checkCompileErrors(geometry, "GEOMETRY");
+    
+        // shader Program
+        ID = glCreateProgram();
+        glAttachShader(ID, vertex);
         glAttachShader(ID, fragment);
-	
+        glAttachShader(ID, geometry);
-	// Constructu the program
         glLinkProgram(ID);
         checkCompileErrors(ID, "PROGRAM");
-
         // delete the shaders as they're linked into our program now and no longer necessary
         glDeleteShader(vertex);
         glDeleteShader(fragment);
-        if(geometryPath) glDeleteShader(geometry);
+        glDeleteShader(geometry);
     }
     // activate the shader
     // ------------------------------------------------------------------------

include/worldupdatemessage.h

@@ -1,24 +0,0 @@
-#ifndef WORLD_UPDATE_MSG_H
-#define WORLD_UPDATE_MSG_H
-
-#include <glm/glm.hpp>
-#include <oneapi/tbb/concurrent_queue.h>
-
-#include "block.hpp"
-
-enum class WorldUpdateMsgType{
-    BLOCKPICK_PLACE,
-    BLOCKPICK_BREAK
-};
-
-typedef struct WorldUpdateMsg{
-    WorldUpdateMsgType msg_type;
-    glm::vec3 cameraPos;
-    glm::vec3 cameraFront;
-    float time;
-    Block block;
-} WorldUpdateMsg;
-
-typedef oneapi::tbb::concurrent_queue<WorldUpdateMsg> WorldUpdateMsgQueue;
-
-#endif

lib/CMakeLists.txt

@@ -1,3 +1,2 @@
 add_subdirectory(glad)
-add_subdirectory(glm)
+add_subdirectory(glm)
-add_subdirectory(imgui)

lib/imgui

@@ -1 +0,0 @@
-Subproject commit 6addf28c4b5d8fd109a6db73bed6436952b230b2

shaders/shader-quad.fs

@@ -1,28 +0,0 @@
-#version 330 core
-
-in vec2 TexCoord;
-out vec4 FragColor;
-
-uniform sampler2D renderTex;
-uniform int screenWidth;
-uniform int screenHeight;
-uniform int crosshairType;
-
-void main(){
-    float crosshair_alpha = 0.8;
-
-    float dist = length(gl_FragCoord.xy-vec2(screenWidth/2, screenHeight/2));
-
-    FragColor = texture(renderTex, TexCoord);
-    /*float crosshair_color = (FragColor.x + FragColor.y + FragColor.z) / 3;
-    /*if(crosshair_color <= 0.5) crosshair_color = 1.0;
-    /*else crosshair_color = 0.0;*/
-    float crosshair_color = 1.0;
-
-    if(dist <= 7){
-	if( (crosshairType == 0 && dist >= 5) ||
-		(crosshairType == 1 && ( int(gl_FragCoord.x) == int(screenWidth / 2) ||
-		 int(gl_FragCoord.y) == int(screenHeight / 2)) )
-	    ) FragColor = vec4(vec3(crosshair_color), crosshair_alpha);
-	}
-}

shaders/shader-quad.vs

@@ -1,12 +0,0 @@
-#version 330 core
-
-layout (location = 0) in vec3 aPos;
-layout (location = 1) in vec2 aTexCoord;
-
-out vec2 TexCoord;
-
-void main()
-{
-    TexCoord = aTexCoord;
-    gl_Position = vec4(aPos, 1.0);
-}

shaders/shader-texture.gs

@@ -26,30 +26,29 @@ void main(){
     EmitVertex();
 
     if(gs_in[0].Extents.x == 0){
-
+	TexCoord = vec3(0.0, gs_in[0].Extents.z, gs_in[0].BlockType);
-	TexCoord = vec3(gs_in[0].Extents.z, 0.0,  gs_in[0].BlockType);
 	gl_Position = gl_in[0].gl_Position + vec4(0.0, 0.0, gs_in[0].Extents.z, 0.0);
 	FragPos = vec3(gl_Position);
 	gl_Position = projection * view * gl_Position;
 	EmitVertex();
 
-	TexCoord = vec3(0.0, gs_in[0].Extents.y, gs_in[0].BlockType);
+	TexCoord = vec3(gs_in[0].Extents.y, 0.0,  gs_in[0].BlockType);
 	gl_Position = gl_in[0].gl_Position + vec4(0.0, gs_in[0].Extents.y, 0.0, 0.0);
 	FragPos = vec3(gl_Position);
 	gl_Position = projection * view * gl_Position;
 	EmitVertex();
 
-	TexCoord = vec3(gs_in[0].Extents.z, gs_in[0].Extents.y,  gs_in[0].BlockType);
+	TexCoord = vec3(gs_in[0].Extents.y, gs_in[0].Extents.z,  gs_in[0].BlockType);
     }
     else if(gs_in[0].Extents.y == 0){
-	TexCoord = vec3(gs_in[0].Extents.x, 0.0, gs_in[0].BlockType);
+	TexCoord = vec3(0.0, gs_in[0].Extents.z, gs_in[0].BlockType);
-	gl_Position = gl_in[0].gl_Position + vec4(gs_in[0].Extents.x, 0.0, 0.0, 0.0);
+	gl_Position = gl_in[0].gl_Position + vec4(0.0, 0.0, gs_in[0].Extents.z, 0.0);
 	FragPos = vec3(gl_Position);
 	gl_Position = projection * view * gl_Position;
 	EmitVertex();
 
-	TexCoord = vec3(0.0, gs_in[0].Extents.z, gs_in[0].BlockType);
+	TexCoord = vec3(gs_in[0].Extents.x, 0.0, gs_in[0].BlockType);
-	gl_Position = gl_in[0].gl_Position + vec4(0.0, 0.0, gs_in[0].Extents.z, 0.0);
+	gl_Position = gl_in[0].gl_Position + vec4(gs_in[0].Extents.x, 0.0, 0.0, 0.0);
 	FragPos = vec3(gl_Position);
 	gl_Position = projection * view * gl_Position;
 	EmitVertex();

src/CMakeLists.txt

@@ -1,10 +1,9 @@
 cmake_minimum_required(VERSION 3.2)
 project(OpenGLTest)
 
-set(SOURCE_FILES main.cpp controls.cpp chunk.cpp chunkmanager.cpp chunkmesher.cpp chunkgenerator.cpp
+set(SOURCE_FILES main.cpp chunk.cpp chunkmanager.cpp chunkmesher.cpp chunkgenerator.cpp renderer.cpp spacefilling.cpp stb_image.cpp utils.cpp OpenSimplexNoise.cpp)
-	debugwindow.cpp renderer.cpp spacefilling.cpp stb_image.cpp utils.cpp OpenSimplexNoise.cpp)
 
 add_executable(OpenGLTest ${SOURCE_FILES})
 
-target_link_libraries(OpenGLTest glfw tbb glad glm imgui)
+target_link_libraries(OpenGLTest glfw tbb glad glm)
 install(TARGETS OpenGLTest DESTINATION ${DIVISIBLE_INSTALL_BIN_DIR})

src/chunk.cpp

@@ -15,27 +15,32 @@ namespace Chunk
         return utils::coord3DTo1D(x, y, z, CHUNK_SIZE, CHUNK_SIZE, CHUNK_SIZE);
     }
 
-    chunk_index_t calculateIndex(glm::vec3 pos){
-	return calculateIndex(static_cast<chunk_intcoord_t>(pos.x), static_cast<chunk_intcoord_t>(pos.y),
-		static_cast<chunk_intcoord_t>(pos.z));
-    }
-
-    chunk_index_t calculateIndex(chunk_intcoord_t i, chunk_intcoord_t j, chunk_intcoord_t k){
-	 return i | (j << 10) | (k << 20); 
-    }
-
     Chunk::Chunk(glm::vec3 pos)
     {
         this->position = pos;
         this->setState(CHUNK_STATE_EMPTY, true);
 	this->setBlocks(0, CHUNK_MAX_INDEX, Block::AIR);
-	this->index = calculateIndex(pos);
     }
 
     Chunk ::~Chunk()
     {
     }
 
+    void Chunk::createBuffers(){
+	glGenVertexArrays(1, &(this->VAO));
+	glGenBuffers(1, &(this->VBO));
+	glGenBuffers(1, &(this->extentsBuffer));
+	glGenBuffers(1, &(this->texinfoBuffer));
+
+    }
+
+    void Chunk::deleteBuffers(){
+	glDeleteBuffers(1, &(this->VBO));
+	glDeleteBuffers(1, &(this->extentsBuffer));
+	glDeleteBuffers(1, &(this->texinfoBuffer));
+        glDeleteVertexArrays(1, &(this->VAO));
+    }
+
     Block Chunk::getBlock(int x, int y, int z)
     {
 	if(x < 0 || y < 0 || z < 0 || x > CHUNK_SIZE -1 || y > CHUNK_SIZE -1 || z > CHUNK_SIZE-1 ||
@@ -54,7 +59,7 @@ namespace Chunk
         this->blocks.insert(start < 0 ? 0 : start, end >= CHUNK_VOLUME ? CHUNK_VOLUME : end, b);
     }
 
-    void Chunk::setState(chunk_state_t nstate, bool value)
+    void Chunk::setState(uint8_t nstate, bool value)
     {
         if (value)
 	    this->state.fetch_or(nstate);

src/chunkmanager.cpp

@@ -6,61 +6,80 @@
 #include <thread>
 
 #include <glm/glm.hpp>
-#include <glm/gtx/string_cast.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 
-#include <oneapi/tbb/parallel_for.h>
-
 #include "block.hpp"
 #include "chunk.hpp"
 #include "chunkgenerator.hpp"
 #include "chunkmesher.hpp"
-#include "debugwindow.hpp"
 #include "globals.hpp"
 #include "renderer.hpp"
-#include "utils.hpp"
 
 namespace chunkmanager
 {
-    void blockpick(WorldUpdateMsg& msg); // There's no need of passing by value again (check
-					 // controls.cpp)
     void generate();
     void mesh();
-    void send_to_chunk_meshing_thread(Chunk::Chunk* c, int priority);
 
-    /* Chunk holding data structures */
     // Concurrent hash table of chunks
     ChunkTable chunks;
     // Chunk indices. Centered at (0,0,0), going in concentric sphere outwards
-    std::array<std::array<chunk_intcoord_t, 3>, chunks_volume> chunks_indices;
+    std::array<std::array<int, 3>, chunks_volume> chunks_indices;
-
-    /* World Update messaging data structure */
-    WorldUpdateMsgQueue WorldUpdateQueue;
 
     /* Multithreading */
     std::atomic_bool should_run;
     std::thread gen_thread, mesh_thread, update_thread;
-
     // Queue of chunks to be generated
     ChunkPriorityQueue chunks_to_generate_queue;
     // Queue of chunks to be meshed
     ChunkPriorityQueue chunks_to_mesh_queue;
 
-    WorldUpdateMsgQueue& getWorldUpdateQueue(){ return WorldUpdateQueue; }
+
-    
     // Init chunkmanager. Chunk indices and start threads
+    int chunks_volume_real;
     void init(){
 	int index{0};
+	int rr{RENDER_DISTANCE * RENDER_DISTANCE};
 
-	for(chunk_intcoord_t i = -RENDER_DISTANCE; i < RENDER_DISTANCE; i++)
+        int xp{0}, x{0};
-	    for(chunk_intcoord_t j = -RENDER_DISTANCE; j < RENDER_DISTANCE; j++)
+        bool b = true;
-		for(chunk_intcoord_t k = -RENDER_DISTANCE; k < RENDER_DISTANCE; k++){
 
-		    chunks_indices[index][0]=i;
+        // Iterate over all chunks, in concentric spheres starting fron the player and going outwards. Alternate left and right
-		    chunks_indices[index][1]=j;
+        // Eq. of the sphere (x - a)² + (y - b)² + (z - c)² = r²
-		    chunks_indices[index][2]=k;
+        while (xp <= RENDER_DISTANCE)
+        {
+	    // Alternate between left and right
+            if (b) x = +xp;
+            else x = -xp;
+
+	    // Step 1. At current x, get the corresponding y values (2nd degree equation, up to 2
+	    // possible results)
+            int y1 = static_cast<int>(sqrt((rr) - x*x));
+
+            for (int y = -y1 + 1 ; y <= y1; y++)
+            {
+                // Step 2. At both y's, get the corresponding z values
+		int z1 = static_cast<int>(sqrt( rr - x*x - y*y));
+
+                for (int z = -z1 + 1; z <= z1; z++){
+		    chunks_indices[index][0] = x;
+		    chunks_indices[index][1] = y;
+		    chunks_indices[index][2] = z;
 		    index++;
 		}
+            }
+
+            if (!b)
+            {
+                xp++;
+                b = true;
+            }
+            else  b = false;
+	}
+	chunks_volume_real = index;
+
+	// Also init mesh data queue
+	for(int i = 0; i < 10; i++)
+	    chunkmesher::getMeshDataQueue().push(new chunkmesher::MeshData());
 
 	should_run = true;
 	update_thread = std::thread(update);
@@ -72,13 +91,8 @@ namespace chunkmanager
     void generate(){
 	while(should_run){
 	    ChunkPQEntry entry;
-	    if(chunks_to_generate_queue.try_pop(entry)){
+	    while(chunks_to_generate_queue.try_pop(entry)) generateChunk(entry.first);
-		Chunk::Chunk* chunk = entry.first;
-		generateChunk(chunk);
-		chunk->setState(Chunk::CHUNK_STATE_IN_GENERATION_QUEUE, false);
-	    }
 	}
-	chunks_to_generate_queue.clear();
     }
 
     // Method for chunk meshing thread(s)
@@ -87,216 +101,86 @@ namespace chunkmanager
 	    ChunkPQEntry entry;
 	    if(chunks_to_mesh_queue.try_pop(entry)){
 		Chunk::Chunk* chunk = entry.first;
-		chunkmesher::mesh(chunk);
+		if(chunk->getState(Chunk::CHUNK_STATE_GENERATED)){
-		chunk->setState(Chunk::CHUNK_STATE_IN_MESHING_QUEUE, false);
+		    chunkmesher::mesh(chunk);
+		    renderer::getChunksToRender().insert(chunk);
+		}
 	    }
 	}
-	chunks_to_mesh_queue.clear();
     }
 
-    void send_to_chunk_meshing_thread(Chunk::Chunk* c, int priority){
+    oneapi::tbb::concurrent_queue<Chunk::Chunk*> chunks_todelete;
-	c->setState(Chunk::CHUNK_STATE_IN_MESHING_QUEUE, true);
+    int nUnloaded{0};
-	chunks_to_mesh_queue.push(std::make_pair(c, MESHING_PRIORITY_NORMAL));
-    }
-
-    oneapi::tbb::concurrent_queue<chunk_index_t> chunks_todelete;
     void update(){
 	while(should_run) {
-	    /* Setup variables for the whole loop */
+	    int chunkX=static_cast<int>(theCamera.getAtomicPosX() / CHUNK_SIZE);
-	    // Atomic is needed by parallel_for
+	    int chunkY=static_cast<int>(theCamera.getAtomicPosY() / CHUNK_SIZE);
-	    std::atomic_int nUnloaded{0}, nMarkUnload{0}, nExplored{0}, nMeshed{0}, nGenerated{0};
+	    int chunkZ=static_cast<int>(theCamera.getAtomicPosZ() / CHUNK_SIZE);
-	    std::atomic_int chunkX=static_cast<int>(theCamera.getAtomicPosX() / CHUNK_SIZE);
-	    std::atomic_int chunkY=static_cast<int>(theCamera.getAtomicPosY() / CHUNK_SIZE);
-	    std::atomic_int chunkZ=static_cast<int>(theCamera.getAtomicPosZ() / CHUNK_SIZE);
 
-	    /* Process update messages before anything happens */
+	    // Update other chunks
-	    WorldUpdateMsg msg;
+	    for(int i = 0; i < chunks_volume_real; i++) {
-	    while(WorldUpdateQueue.try_pop(msg)){
+		const uint16_t x = chunks_indices[i][0] + chunkX;
-		switch(msg.msg_type){
+		const uint16_t y = chunks_indices[i][1] + chunkY;
-		    case WorldUpdateMsgType::BLOCKPICK_BREAK:
+		const uint16_t z = chunks_indices[i][2] + chunkZ;
-		    case WorldUpdateMsgType::BLOCKPICK_PLACE:
+		const uint32_t index = calculateIndex(x, y, z);
-			blockpick(msg);
-			break;
-		}
-	    }
 
+		if(x > 1023 || y > 1023 || z > 1023) continue;
 
-	    /* Delete old chunks */
-	    // In my head it makes sense to first delete old chunks, then create new ones
-	    // I think it's easier for memory allocator to re-use the memory that was freed just
-	    // before, but this isn't backed be any evidence and I might be wrong. Anyway this way
-	    // works fine so I'm gonna keep it.
-	    chunk_index_t i;
-	    ChunkTable::accessor a;
-	    while(chunks_todelete.try_pop(i)){
-		const chunk_index_t index = i;
-		if(chunks.find(a, index)){
-		    Chunk::Chunk* c = a->second;
-		    // Use the accessor to erase the element
-		    // Using the key doesn't work
-		    if(chunks.erase(a)){
-			nUnloaded++;
-			renderer::getDeleteIndexQueue().push(index);
-			delete c;
-		    } else {
-			c->setState(Chunk::CHUNK_STATE_IN_DELETING_QUEUE, false);
-			std::cout << "failed to delete " << index << std::endl;
-		    }
-		} else std::cout << "no such element found to delete\n";
-	    }
-
-	    /* Create new chunks around the player */
-	    for(int i = 0; i < chunks_volume; i++) {
-		const chunk_intcoord_t x = chunks_indices[i][0] + chunkX;
-		const chunk_intcoord_t y = chunks_indices[i][1] + chunkY;
-		const chunk_intcoord_t z = chunks_indices[i][2] + chunkZ;
-
-		if(x < 0 || y < 0 || z < 0 || x > 1023 || y > 1023 || z > 1023) continue;
-		nExplored++;
-
-		const chunk_index_t index = Chunk::calculateIndex(x, y, z);
 		ChunkTable::accessor a;
-		if(!chunks.find(a, index)) chunks.emplace(a, std::make_pair(index, new
+		if(!chunks.find(a, index)) chunks.emplace(a, std::make_pair(index, new Chunk::Chunk(glm::vec3(x,y,z))));
-			    Chunk::Chunk(glm::vec3(x,y,z))));
+
+		if(! (a->second->getState(Chunk::CHUNK_STATE_GENERATED))) {
+		    chunks_to_generate_queue.push(std::make_pair(a->second, GENERATION_PRIORITY_NORMAL));
+		}else if(! (a->second->getState(Chunk::CHUNK_STATE_MESHED))){
+		    chunks_to_mesh_queue.push(std::make_pair(a->second, MESHING_PRIORITY_NORMAL));
+		}
+
+		a.release();
 	    }
 
-	    /* Update all the chunks */
+	    Chunk::Chunk* n;
-	    oneapi::tbb::parallel_for(chunks.range(), [&](ChunkTable::range_type &r){
+	    nUnloaded = 0;
-		for(ChunkTable::iterator a = r.begin(); a != r.end(); a++){
+	    while(chunks_todelete.try_pop(n)){
-		    Chunk::Chunk* c = a->second;
+		int x = static_cast<uint16_t>(n->getPosition().x);
+		int y = static_cast<uint16_t>(n->getPosition().y);
+		int z = static_cast<uint16_t>(n->getPosition().z);
+		if(x > 1023 || y > 1023 || z > 1023) continue;
+		const uint32_t index = calculateIndex(x, y, z);
 
-		    int x = c->getPosition().x;
+		chunks.erase(index);
-		    int y = c->getPosition().y;
+		//delete n;
-		    int z = c->getPosition().z;
+		nUnloaded++;
-		    int distx = x - chunkX;
+	    }
-		    int disty = y - chunkY;
-		    int distz = z - chunkZ;
-
-		    // Local variables avoid continously having to call atomic variables
-		    int gen{0}, mesh{0}, unload{0};
-
-		    if(
-			    distx >= -RENDER_DISTANCE && distx < RENDER_DISTANCE &&
-			    disty >= -RENDER_DISTANCE && disty < RENDER_DISTANCE &&
-			    distz >= -RENDER_DISTANCE && distz < RENDER_DISTANCE
-		      ){
-
-			// If within distance
-			// Reset out-of-view flags
-			c->setState(Chunk::CHUNK_STATE_OUTOFVISION, false);
-			c->setState(Chunk::CHUNK_STATE_UNLOADED, false);
-
-			// If not yet generated
-			if(!c->getState(Chunk::CHUNK_STATE_GENERATED)){
-			    if(c->isFree()){
-				// Generate
-
-				// Mark as present in the queue before sending to avoid strange
-				// a chunk being marked as in the queue after it was already
-				// processed
-				c->setState(Chunk::CHUNK_STATE_IN_GENERATION_QUEUE, true);
-				chunks_to_generate_queue.push(std::make_pair(c, GENERATION_PRIORITY_NORMAL));
-			    }
-			}else{
-			    gen++;
-			    // If generated but not yet meshed
-			    if(!c->getState(Chunk::CHUNK_STATE_MESHED)){
-				ChunkTable::accessor a1;
-
-				// Checking if nearby chunks have been generated allows for seamless
-				// borders between chunks
-				if(c->isFree() &&
-				    (distx+1 >= RENDER_DISTANCE || x + 1 > 1023 || (chunks.find(a1, Chunk::calculateIndex(x+1, y, z)) &&
-					a1->second->getState(Chunk::CHUNK_STATE_GENERATED))) &&
-				    (distx-1 < -RENDER_DISTANCE || x - 1 < 0 || (chunks.find(a1, Chunk::calculateIndex(x-1, y, z)) &&
-					a1->second->getState(Chunk::CHUNK_STATE_GENERATED))) &&
-				    (disty+1 >= RENDER_DISTANCE || y + 1 > 1023 || (chunks.find(a1, Chunk::calculateIndex(x, y+1, z)) &&
-					a1->second->getState(Chunk::CHUNK_STATE_GENERATED))) &&
-				    (disty-1 < -RENDER_DISTANCE || y - 1 < 0|| (chunks.find(a1, Chunk::calculateIndex(x, y-1, z)) &&
-					a1->second->getState(Chunk::CHUNK_STATE_GENERATED))) &&
-				    (distz+1 >= RENDER_DISTANCE || z + 1 > 1023 || (chunks.find(a1, Chunk::calculateIndex(x, y, z+1)) &&
-					a1->second->getState(Chunk::CHUNK_STATE_GENERATED))) &&
-				    (distz-1 < -RENDER_DISTANCE || z - 1 < 0|| (chunks.find(a1, Chunk::calculateIndex(x, y, z-1)) &&
-					a1->second->getState(Chunk::CHUNK_STATE_GENERATED)))
-				  )
-				{
-				    // Mesh
-
-				    // Mark as present in the queue before sending to avoid strange
-				    // a chunk being marked as in the queue after it was already
-				    // processed
-				    send_to_chunk_meshing_thread(c, MESHING_PRIORITY_NORMAL);
-				}
-			    }else mesh++;
-			}
-
-		    }else{
-			// If not within distance
-			if(c->getState(Chunk::CHUNK_STATE_OUTOFVISION)){
-			    // If enough time has passed, set to be deleted
-			    if(c->isFree() && glfwGetTime() - c->unload_timer >= UNLOAD_TIMEOUT){
-				c->setState(Chunk::CHUNK_STATE_IN_DELETING_QUEUE, true);
-				chunks_todelete.push(c->getIndex());
-				unload++;
-			    }
-			}else{
-			    // Mark as out of view, and start waiting time
-			    c->setState(Chunk::CHUNK_STATE_OUTOFVISION, true);
-			    c->setState(Chunk::CHUNK_STATE_UNLOADED, false);
-			    c->unload_timer = glfwGetTime();
-			}
-		    }
-
-		    // Update atomic variables only once at the end
-		    nGenerated += gen;
-		    nMeshed += mesh;
-		    nMarkUnload += unload;
-		}
-	    });
-
-	    debug::window::set_parameter("update_chunks_total", (int)chunks.size());
-	    debug::window::set_parameter("update_chunks_generated", (int) nGenerated);
-	    debug::window::set_parameter("update_chunks_meshed", (int) nMeshed);
-	    debug::window::set_parameter("update_chunks_freed", (int) nUnloaded);
-	    debug::window::set_parameter("update_chunks_explored", (int) nExplored);
 	}
     }
 
-    std::array<std::array<chunk_intcoord_t, 3>, chunks_volume>& getChunksIndices(){ return chunks_indices; }
+    // uint32_t is fine, since i'm limiting the coordinate to only use up to ten bits (1023). There's actually two spare bits
+    uint32_t calculateIndex(uint16_t i, uint16_t j, uint16_t k){
+	 return i | (j << 10) | (k << 20); 
+    }
+
+    oneapi::tbb::concurrent_queue<Chunk::Chunk*>& getDeleteVector(){ return chunks_todelete; }
+    std::array<std::array<int, 3>, chunks_volume>& getChunksIndices(){ return chunks_indices; }
 
     void stop() {
 	should_run=false;
-
-	std::cout << "Waiting for secondary threads to shut down" << std::endl;
 	update_thread.join();
-	std::cout << "Update thread has terminated" << std::endl;
 	gen_thread.join();
-	std::cout << "Generation thread has terminated" << std::endl;
 	mesh_thread.join();
-	std::cout << "Meshing thread has terminated" << std::endl;
     }
-
     void destroy(){
-	for(const auto& n : chunks){
+	/*for(const auto& n : chunks){
 	    delete n.second;
-	}
+	}*/
-	chunks.clear();
     }
 
-
+    void blockpick(bool place){
-    glm::vec3 ray_intersect(glm::vec3 startposition, glm::vec3 startdir){
-	int old_bx{0}, old_by{0}, old_bz{0};
-	int old_px{0}, old_py{0}, old_pz{0};
-	Chunk::Chunk* old_chunk{nullptr};
-	glm::vec3 old_pos;
-
 	// cast a ray from the camera in the direction pointed by the camera itself
-	glm::vec3 origin = startposition;
+	glm::vec3 pos = glm::vec3(theCamera.getAtomicPosX(), theCamera.getAtomicPosY(),
-	glm::vec3 pos = origin;
+		theCamera.getAtomicPosZ());
-	glm::vec3 front = startdir;
 	for(float t = 0.0; t <= 10.0; t += 0.5){
 	    // traverse the ray a block at the time
-	    pos = origin + t*front;
+	    pos = theCamera.getPos() + t * theCamera.getFront();
 
 	    // get which chunk and block the ray is at
 	    int px = ((int)(pos.x))/CHUNK_SIZE;
@@ -306,196 +190,56 @@ namespace chunkmanager
 	    int by = pos.y - py*CHUNK_SIZE;
 	    int bz = pos.z - pz*CHUNK_SIZE;
 
-	    if(bx == old_bx && by == old_by && bz == old_bz) continue;
-
 	    // exit early if the position is invalid or the chunk does not exist
 	    if(px < 0 || py < 0 || pz < 0 || px >= 1024 || py >= 1024 || pz >= 1024) continue;
 
-	    ChunkTable::const_accessor a;
+	    ChunkTable::accessor a;
-	    if(!chunks.find(a, Chunk::calculateIndex(px, py, pz))) continue;
+	    if(!chunks.find(a, calculateIndex(px, py, pz))) continue;
 	    Chunk::Chunk* c = a->second;
-	    if(!c->isFree() || !c->getState(Chunk::CHUNK_STATE_GENERATED)){
+	    if(!c->getState(Chunk::CHUNK_STATE_GENERATED) || c->getState(Chunk::CHUNK_STATE_EMPTY)) continue;
-		a.release();
-		continue;
-	    }
 
 	    Block b = c->getBlock(bx, by, bz);
+
 	    a.release();
-	    
 	    // if the block is non empty
-	    if(b != Block::AIR) return pos;
+	    if(b != Block::AIR){
 
-	    old_chunk = c;
+		// if placing a new block
-	    old_bx = bx;
+		if(place){
-	    old_by = by;
+		    // Go half a block backwards on the ray, to check the block where the ray was
-	    old_bz = bz;
+		    // coming from
-	    old_px = px;
+		    // Doing this and not using normal adds the unexpected (and unwanted) ability to
-	    old_py = py;
+		    // place blocks diagonally, without faces colliding with the block that has
-	    old_pz = pz;
+		    // been clicked
-	    old_pos = pos;
+		    pos -= theCamera.getFront()*0.5f;
 
-	}
+		    int px1 = ((int)(pos.x))/CHUNK_SIZE;
-	return glm::vec3(-1);
+		    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;
 
-    void blockpick(WorldUpdateMsg& msg){
+		    // exit early if the position is invalid or the chunk does not exist
-	//std::cout << glm::to_string(ray_intersect(msg.cameraPos, msg.cameraFront)) << std::endl;
+		    if(px1 < 0 || py1 < 0 || pz1 < 0 || px1 >= 1024 || py1 >= 1024 || pz1 >= 1024) return;
-	glm::vec3 ray_pos = ray_intersect(msg.cameraPos, msg.cameraFront);
+		    ChunkTable::accessor a1;
-	if(ray_pos == glm::vec3(-1)) return;
+		    if(!chunks.find(a1, calculateIndex(px1, py1, pz1))) return;
+		    Chunk::Chunk* c1 = a1->second;
+		    // place the new block (only stone for now)
+		    c1->setBlock( Block::STONE, bx1, by1, bz1);
 
-	// Chunk in which the blockpick is happening
+		    // mark the mesh of the chunk the be updated
-	int chunkx = (int)(ray_pos.x) / CHUNK_SIZE;
+		    chunks_to_mesh_queue.push(std::make_pair(c1, MESHING_PRIORITY_PLAYER_EDIT));
-	int chunky = (int)(ray_pos.y) / CHUNK_SIZE;
+		    chunks_to_mesh_queue.push(std::make_pair(c, MESHING_PRIORITY_PLAYER_EDIT));
-	int chunkz = (int)(ray_pos.z) / CHUNK_SIZE;
-	// Block (chunk coord) in which the blockpick is happening
-	int blockx = ray_pos.x - chunkx*CHUNK_SIZE;
-	int blocky = ray_pos.y - chunky*CHUNK_SIZE;
-	int blockz = ray_pos.z - chunkz*CHUNK_SIZE;
-
-	// The chunk must exist, otherwise ray_intersect would have returned an error
-	// Also, the block must be different from AIR
-	
-	ChunkTable::accessor a;
-	if(!chunks.find(a, Chunk::calculateIndex(chunkx, chunky, chunkz))) return;
-	Chunk::Chunk* c = a->second;
-	if(!(c->isFree() && c->getState(Chunk::CHUNK_STATE_GENERATED))) return;
-
-	if(msg.msg_type == WorldUpdateMsgType::BLOCKPICK_BREAK){
-	    c->setBlock(Block::AIR, blockx, blocky, blockz);
-	    send_to_chunk_meshing_thread(c, MESHING_PRIORITY_PLAYER_EDIT);
-	}else{
-	    // Traverse voxel using Amanatides&Woo traversal algorithm
-	    // http://www.cse.yorku.ca/~amana/research/grid.pdf
-
-	    glm::vec3 pos = msg.cameraPos;
-	    glm::vec3 front = glm::normalize(pos - ray_pos);
-
-	    // Original chunk in which the blockpick started
-	    const int ochunkX=chunkx, ochunkY = chunky, ochunkZ = chunkz;
-
-	    // The ray has equation pos + t*front
-
-	    // Initialize phase
-	    // Origin integer voxel coordinates
-	    // Avoid floating point accuracy errors: work as close to 0 as possible, translate
-	    // everything later
-	    int basex = std::floor(ray_pos.x);
-	    int basey = std::floor(ray_pos.y);
-	    int basez = std::floor(ray_pos.z);
-	    double x = ray_pos.x - basex;
-	    double y = ray_pos.y - basey;
-	    double z = ray_pos.z - basez;
-
-	    auto sign = [=](double f){ return f > 0 ? 1 : f < 0 ? -1 : 0; };
-	    auto tmax = [=](double p, double dir){
-		int s = sign(dir);
-
-		if(s > 0)
-		    return (1 - p) / dir;
-		else if(s < 0)
-		    return -(p) / dir;
-		return 0.0;
-	    };
-
-
-	    // Step
-	    int stepX = sign(front.x);
-	    int stepY = sign(front.y);
-	    int stepZ = sign(front.z);
-
-	    // tMax: the value of t at which the ray crosses the first voxel boundary
-	    double tMaxX = tmax(x, front.x);
-	    double tMaxY = tmax(y, front.y);
-	    double tMaxZ = tmax(z, front.z);
-
-	    // tDelta: how far along the ray along they ray (in units of t) for the _ component of such
-	    // a movement to equal the width of a voxel
-	    double tDeltaX = stepX / front.x;
-	    double tDeltaY = stepY / front.y;
-	    double tDeltaZ = stepZ / front.z;
-
-	    for(int i = 0; i < 10; i++){
-		if(tMaxX < tMaxY){
-		    if(tMaxX < tMaxZ) {
-			x += stepX;
-			tMaxX += tDeltaX;
-		    }else{
-			z += stepZ;
-			tMaxZ += tDeltaZ;
-		    }
 		}else{
-		    if(tMaxY < tMaxZ){
+		    // replace the current block with air to remove it
-			y += stepY;
+		    c->setBlock( Block::AIR, bx, by, bz);
-			tMaxY += tDeltaY;
+
-		    }else{
+		    chunks_to_mesh_queue.push(std::make_pair(c, MESHING_PRIORITY_PLAYER_EDIT));
-			z += stepZ;
-			tMaxZ += tDeltaZ;
-		    }
 		}
-
-		int realx = basex + x;
-		int realy = basey + y;
-		int realz = basez + z;
-
-		chunkx = realx / CHUNK_SIZE;
-		chunky = realy / CHUNK_SIZE;
-		chunkz = realz / CHUNK_SIZE;
-
-		if(chunkx < 0 || chunky < 0 || chunkz < 0 || chunkx > 1023 || chunky > 1023 ||
-			chunkz > 1023) continue;
-
-		blockx = realx - chunkx*CHUNK_SIZE;
-		blocky = realy - chunky*CHUNK_SIZE;
-		blockz = realz - chunkz*CHUNK_SIZE;
-
-
-		Chunk::Chunk* chunk;
-		ChunkTable::accessor b;
-
-		if(chunkx != ochunkX || chunky != ochunkY || chunkz != ochunkZ){
-		    if(!chunks.find(b, Chunk::calculateIndex(chunkx, chunky, chunkz)))
-			continue;
-		    chunk = b->second;
-		    if(!(chunk->isFree() && chunk->getState(Chunk::CHUNK_STATE_GENERATED)))
-			continue;
-
-		}else{
-		    chunk = c;
-		}
-
-		if(chunk->getBlock(blockx, blocky, blockz) != Block::AIR) continue;
-		chunk->setBlock(msg.block, blockx, blocky, blockz);
-		send_to_chunk_meshing_thread(chunk, MESHING_PRIORITY_PLAYER_EDIT);
 		break;
 	    }
 	}
-
-	// Release the chunk in which the blockpick started to avoid locks
-	a.release();
-	 // When necessary, also mesh nearby chunks
-	ChunkTable::accessor a1, a2, b1, b2, c1, c2;
-	if(blockx == 0 && chunkx - 1 >= 0 && chunks.find(a1, Chunk::calculateIndex(chunkx - 1, chunky, chunkz)))
-	  send_to_chunk_meshing_thread(a1->second, MESHING_PRIORITY_PLAYER_EDIT);
-	if(blocky == 0 && chunky - 1 >= 0 && chunks.find(b1, Chunk::calculateIndex(chunkx, chunky - 1, chunkz)))
-	  send_to_chunk_meshing_thread(b1->second, MESHING_PRIORITY_PLAYER_EDIT);
-	if(blockz == 0 && chunkz - 1 >= 0 && chunks.find(c1, Chunk::calculateIndex(chunkx, chunky, chunkz - 1)))
-	  send_to_chunk_meshing_thread(c1->second, MESHING_PRIORITY_PLAYER_EDIT);
-	if(blockx == CHUNK_SIZE - 1 && chunkx +1 < 1024 && chunks.find(a2, Chunk::calculateIndex(chunkx +1, chunky, chunkz)))
-	  send_to_chunk_meshing_thread(a2->second, MESHING_PRIORITY_PLAYER_EDIT);
-	if(blocky == CHUNK_SIZE - 1 && chunky +1 < 1024 && chunks.find(b2, Chunk::calculateIndex(chunkx, chunky +1, chunkz)))
-	  send_to_chunk_meshing_thread(b2->second, MESHING_PRIORITY_PLAYER_EDIT);
-	if(blockz == CHUNK_SIZE - 1 && chunkz +1 < 1024 && chunks.find(c2, Chunk::calculateIndex(chunkx, chunky, chunkz +1)))
-	  send_to_chunk_meshing_thread(c2->second, MESHING_PRIORITY_PLAYER_EDIT);
-
-	// Update debugging information
-
-	debug::window::set_parameter("block_last_action", msg.msg_type ==
-		WorldUpdateMsgType::BLOCKPICK_PLACE);
-	debug::window::set_parameter("block_last_action_block_type", (int)(msg.msg_type ==
-		WorldUpdateMsgType::BLOCKPICK_PLACE ? msg.block : Block::AIR));
-	debug::window::set_parameter("block_last_action_x", chunkx*CHUNK_SIZE+blockx);
-	debug::window::set_parameter("block_last_action_y", chunky*CHUNK_SIZE+blocky);
-	debug::window::set_parameter("block_last_action_z", chunkz*CHUNK_SIZE+blockz);
     }
 
     Block getBlockAtPos(int x, int y, int z){
@@ -509,7 +253,7 @@ namespace chunkmanager
 
 	//std::cout << "Block at " << x << ", " << y << ", " << z << " is in chunk " << cx << "," << cy << "," << cz << "\n";
 	ChunkTable::accessor a;
-	if(!chunks.find(a, Chunk::calculateIndex(cx, cy, cz))) return Block::NULLBLK;
+	if(!chunks.find(a, calculateIndex(cx, cy, cz))) return Block::NULLBLK;
 	else {
 	    int bx = x % CHUNK_SIZE;
 	    int by = y % CHUNK_SIZE;
@@ -521,4 +265,3 @@ namespace chunkmanager
 	}
     }
 };
-

src/chunkmesher.cpp

@@ -11,24 +11,15 @@
 #include "spacefilling.hpp"
 #include "utils.hpp"
 
-#define CHUNK_MESH_DATA_QUANTITY 100
-#define CHUNK_MESH_WORLD_LIMIT_BORDERS 0
-
 namespace chunkmesher{
 
-ChunkMeshDataQueue MeshDataQueue;
+oneapi::tbb::concurrent_queue<MeshData*> MeshDataQueue;
 
-ChunkMeshDataQueue& getMeshDataQueue(){ return MeshDataQueue; }
+oneapi::tbb::concurrent_queue<MeshData*>& getMeshDataQueue(){ return MeshDataQueue; }
-
-void init()
-{
-    for(int i = 0; i < CHUNK_MESH_DATA_QUANTITY; i++)
-	MeshDataQueue.push(new ChunkMeshData{});
-}
     
 void mesh(Chunk::Chunk* chunk)
 {
-    ChunkMeshData* mesh_data;
+    MeshData* mesh_data;
     if(!MeshDataQueue.try_pop(mesh_data)) return;
 
     /*
@@ -47,27 +38,34 @@ void mesh(Chunk::Chunk* chunk)
      */
 
     // Cleanup previous data
-    mesh_data->clear();
+    mesh_data->numVertices = 0;
-    mesh_data->message_type = ChunkMeshDataType::MESH_UPDATE;
+    mesh_data->chunk = chunk;
-    mesh_data->index = chunk->getIndex();
+    mesh_data->vertices.clear();
-    mesh_data->position = chunk->getPosition();
+    mesh_data->extents.clear();
+    mesh_data->texinfo.clear();
+
+    // Abort if chunk is empty
+    if(chunk->getState(Chunk::CHUNK_STATE_EMPTY)){
+	chunk->setState(Chunk::CHUNK_STATE_MESHED, true);
+	renderer::getMeshDataQueue().push(mesh_data);
+	return;
+    }
 
     // convert tree to array since it is easier to work with it
     int length{0};
-    std::unique_ptr<Block[]> blocks;
+    std::unique_ptr<Block[]> blocks = chunk->getBlocksArray(&length);
-
+    if(length == 0) {
+	chunk->setState(Chunk::CHUNK_STATE_MESHED, true);
+	renderer::getMeshDataQueue().push(mesh_data);
+	return;
+    }
+    
     int k, l, u, v, w, h, n, j, i;
     int x[]{0, 0, 0};
     int q[]{0, 0, 0};
     int du[]{0, 0, 0};
     int dv[]{0, 0, 0};
 
-    // Abort if chunk is empty
-    if(chunk->getState(Chunk::CHUNK_STATE_EMPTY)) goto end;
-
-    blocks = chunk->getBlocksArray(&length);
-    if(length == 0) goto end;
-
     std::array<Block, CHUNK_SIZE * CHUNK_SIZE> mask;
     for (bool backFace = true, b = false; b != backFace; backFace = backFace && b, b = !b)
     {
@@ -130,15 +128,9 @@ void mesh(Chunk::Chunk* chunk)
 			// The else case provides face culling for adjacent solid faces
 			// Checking for NULLBLK avoids creating empty faces if nearby chunk was not
 			// yet generated
-#if CHUNK_MESH_WORLD_LIMIT_BORDERS == 1
 			mask[n++] = b1 == b2 ? Block::NULLBLK
                                     : backFace ? b1 == Block::NULLBLK || b1 == Block::AIR ? b2 : Block::NULLBLK
                                     : b2 == Block::NULLBLK || b2 == Block::AIR ? b1 : Block::NULLBLK;
-#else
-			mask[n++] = b1 == b2 ? Block::NULLBLK
-                                    : backFace ? b1 == Block::AIR ? b2 : Block::NULLBLK
-                                    : b2 == Block::AIR ? b1 : Block::NULLBLK;
-#endif
                     }
                 }
 
@@ -199,7 +191,7 @@ void mesh(Chunk::Chunk* chunk)
 
 				mesh_data->texinfo.push_back(backFace ? 0.0 : 1.0);
 				mesh_data->texinfo.push_back((int)(mask[n]) - 2);
-				mesh_data->num_vertices++;
+				mesh_data->numVertices++;
                             }
 
                             for (l = 0; l < h; ++l)
@@ -228,8 +220,49 @@ void mesh(Chunk::Chunk* chunk)
         }
     }
 
-end:
     chunk->setState(Chunk::CHUNK_STATE_MESHED, true);
     renderer::getMeshDataQueue().push(mesh_data);
 }
+
+void sendtogpu(MeshData* mesh_data)
+{
+    if (mesh_data->numVertices > 0)
+    {
+	if(mesh_data->chunk->VAO == 0) mesh_data->chunk->createBuffers();
+
+	// bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
+	glBindVertexArray(mesh_data->chunk->VAO);
+
+	// position attribute
+	glBindBuffer(GL_ARRAY_BUFFER, mesh_data->chunk->VBO);
+	glBufferData(GL_ARRAY_BUFFER, mesh_data->vertices.size() * sizeof(GLfloat), &(mesh_data->vertices[0]), GL_STATIC_DRAW);
+	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *)0);
+	glEnableVertexAttribArray(0);
+
+	// normal attribute
+	glBindBuffer(GL_ARRAY_BUFFER, mesh_data->chunk->extentsBuffer);
+	glBufferData(GL_ARRAY_BUFFER, mesh_data->extents.size() * sizeof(GLfloat), &(mesh_data->extents[0]), GL_STATIC_DRAW);
+	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *)(0));
+	glEnableVertexAttribArray(1);
+
+	// texcoords attribute
+	glBindBuffer(GL_ARRAY_BUFFER, mesh_data->chunk->texinfoBuffer);
+	glBufferData(GL_ARRAY_BUFFER, mesh_data->texinfo.size() * sizeof(GLfloat), &(mesh_data->texinfo[0]), GL_STATIC_DRAW);
+	glEnableVertexAttribArray(2);
+	glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), (void *)0);
+
+	glBindVertexArray(0);
+
+	// save the number of indices of the mesh, it is needed later for drawing
+	mesh_data->chunk->numVertices = (GLuint)(mesh_data->numVertices);
+
+	// once data has been sent to the GPU, it can be cleared from system RAM
+	mesh_data->vertices.clear();
+	mesh_data->extents.clear();
+	mesh_data->texinfo.clear();
+    }
+    
+    // mark the chunk mesh has loaded on GPU
+    mesh_data->chunk->setState(Chunk::CHUNK_STATE_MESH_LOADED, true);
+}
 };

src/controls.cpp

@@ -1,66 +0,0 @@
-#include "controls.hpp"
-
-#include "camera.hpp"
-#include "chunkmanager.hpp"
-#include "debugwindow.hpp"
-#include "globals.hpp"
-#include "renderer.hpp"
-
-namespace controls{
-    /* Block picking */
-    int block_to_place{2};
-    float lastBlockPick=0.0;
-    bool blockpick = false;
-
-    /* Cursor */
-    bool cursor = false;
-
-    void init(){
-	debug::window::set_parameter("block_type_return", &block_to_place);
-    }
-    
-    void update(GLFWwindow* window){
-	float current_time = glfwGetTime();
-
-	/* BlockPicking */
-	// Reset blockpicking if enough time has passed
-	if(current_time - lastBlockPick > BLOCKPICK_TIMEOUT) blockpick = false;
-	// Reset blockpicking if both mouse buttons are released
-	if(glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_1) == GLFW_RELEASE && glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_2) == GLFW_RELEASE) blockpick = false;
-	// Process block picking if a mouse button is pressed
-	if((glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_1) == GLFW_PRESS ||
-		glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_2 == GLFW_PRESS)) && !blockpick){
-
-	    // Start timeout for next block pick action
-	    blockpick =  true;
-	    lastBlockPick = current_time;
-
-	    // Construct the message to send to chunkmanager
-
-	    // WorldUpdateMsg is allocated on the stack
-	    // unlike ChunkMeshData, the fields of WorldUpdateMsg are few and light, so there's no
-	    // problem in passing them by value each time.
-	    // It also has the advantage of having less memory to manage, since I'm not allocating
-	    // anything on the heap
-
-	    WorldUpdateMsg msg{};
-	    msg.cameraPos = theCamera.getPos();
-	    msg.cameraFront = theCamera.getFront();
-	    msg.time = current_time;
-	    msg.msg_type = glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_1) == GLFW_PRESS ?
-	    WorldUpdateMsgType::BLOCKPICK_PLACE : WorldUpdateMsgType::BLOCKPICK_BREAK;
-	    msg.block = (Block)(block_to_place);
-
-	    // Send to chunk manager
-	    chunkmanager::getWorldUpdateQueue().push(msg);
-	}
-
-	/* SCREENSHOTS */
-	if(glfwGetKey(window, GLFW_KEY_F2) == GLFW_PRESS) renderer::saveScreenshot();
-	if(glfwGetKey(window, GLFW_KEY_F3) == GLFW_PRESS) renderer::saveScreenshot(true);
-	if(glfwGetKey(window, GLFW_KEY_M) == GLFW_PRESS) {
-	    cursor = !cursor;
-	    glfwSetInputMode(window, GLFW_CURSOR, cursor ? GLFW_CURSOR_NORMAL : GLFW_CURSOR_DISABLED);
-	}
-    }
-};

src/debugwindow.cpp

@@ -1,136 +0,0 @@
-#include "debugwindow.hpp"
-
-#include <imgui/imgui.h>
-#include <imgui/imgui_impl_opengl3.h>
-#include <imgui/imgui_impl_glfw.h>
-#include <imgui_stdlib.h>
-
-#include <iostream>
-#include <string>
-#include <unordered_map>
-
-namespace debug{
-    namespace window{
-
-	void show_debug_window();
-	constexpr int frametimes_array_size = 20;
-	float frametimes_array[frametimes_array_size]{};
-
-	std::unordered_map<std::string, std::any> parameters;
-
-	void init(GLFWwindow* window){
-	    // Setup Dear ImGui context
-	    IMGUI_CHECKVERSION();
-	    ImGui::CreateContext();
-	    ImGuiIO& io = ImGui::GetIO();
-	    io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;     // Enable Keyboard Controls
-
-	    // Setup Platform/Renderer backends
-	    ImGui_ImplGlfw_InitForOpenGL(window, true);          // Second param install_callback=true will install GLFW callbacks and chain to existing ones.
-	    ImGui_ImplOpenGL3_Init();
-	}
-
-	void prerender(){
-	    // Start the Dear ImGui frame
-	    ImGui_ImplOpenGL3_NewFrame();
-	    ImGui_ImplGlfw_NewFrame();
-	    ImGui::NewFrame();
-	    //ImGui::ShowDemoWindow(); // Show demo window! :)
-	    show_debug_window();
-	}
-
-	void render(){
-	    // (Your code clears your framebuffer, renders your other stuff etc.)
-	    ImGui::Render();
-	    ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
-	    // (Your code calls glfwSwapBuffers() etc.)
-	}
-
-	void destroy(){
-	    ImGui_ImplOpenGL3_Shutdown();
-	    ImGui_ImplGlfw_Shutdown();
-	    ImGui::DestroyContext();
-	    ImGui_ImplOpenGL3_Shutdown();
-	    ImGui_ImplGlfw_Shutdown();
-	    ImGui::DestroyContext();
-	}
-
-	void set_parameter(std::string key, std::any value){
-	    parameters[key] = value;
-	}
-
-	void show_debug_window(){
-	    ImGui::Begin("Debug Window");
-
-	    ImGui::PushItemWidth(ImGui::GetFontSize() * -12);
-
-	    try{
-		if (ImGui::CollapsingHeader("Frametimes")){
-		    ImGui::Text("FPS: %d", std::any_cast<int>(parameters.at("fps")));
-		    ImGui::Text("Frametime (ms): %f",
-			    std::any_cast<float>(parameters.at("frametime"))*1000);
-		    ImGui::Text("GPU: (%s) %s",
-			    std::any_cast<const GLubyte*>(parameters.at("gpu_vendor")),
-			    std::any_cast<const GLubyte*>(parameters.at("gpu_renderer")));
-		    //ImGui::PlotLines("Frame Times", arr, IM_ARRAYSIZE(arr);
-		}
-
-		if(ImGui::CollapsingHeader("Player")){
-		    ImGui::Text("X: %f, Y: %f, Z: %f",
-			    std::any_cast<float>(parameters.at("px")),std::any_cast<float>(parameters.at("py")),std::any_cast<float>(parameters.at("pz"))  );
-		    ImGui::Text("X: %d, Y: %d, Z: %d (chunk)", std::any_cast<int>(parameters.at("cx")),std::any_cast<int>(parameters.at("cy")),std::any_cast<int>(parameters.at("cz"))  );
-		    ImGui::Text("Pointing in direction: %f, %f, %f", 
-			    std::any_cast<float>(parameters.at("lx")),std::any_cast<float>(parameters.at("ly")),std::any_cast<float>(parameters.at("lz"))  );
-
-		    ImGui::SliderInt("Crosshair type",
-			    std::any_cast<int*>(parameters.at("crosshair_type_return")), 0, 1);
-		    ImGui::SliderInt("Block to place",
-			    std::any_cast<int*>(parameters.at("block_type_return")), 2, 6);
-
-		    if(parameters.find("block_last_action") != parameters.end()){
-			ImGui::Text("Last Block action: %s",
-			    std::any_cast<bool>(parameters.at("block_last_action")) ? "place" : "destroy");
-			ImGui::Text("Last Block action block type: %d",
-			    std::any_cast<int>(parameters.at("block_last_action_block_type")));
-			ImGui::Text("Last Block action position: X: %d, Y: %d, Z: %d",
-			    std::any_cast<int>(parameters.at("block_last_action_x")),std::any_cast<int>(parameters.at("block_last_action_y")),std::any_cast<int>(parameters.at("block_last_action_z"))  );
-		    }
-		}
-
-		if(ImGui::CollapsingHeader("Mesh")){
-		    ImGui::Text("Total chunk meshed: %d",
-			    std::any_cast<int>(parameters.at("render_chunks_total")));
-		    ImGui::Text("Of which renderable (not empty): %d",
-			    std::any_cast<int>(parameters.at("render_chunks_renderable")));
-		    ImGui::Text("Chunks rendered: %d",
-			std::any_cast<int>(parameters.at("render_chunks_rendered")));
-		    ImGui::Text("Frustum culled: %d",
-			std::any_cast<int>(parameters.at("render_chunks_culled")));
-		    ImGui::Text("Total vertices in the scene: %d",
-			std::any_cast<int>(parameters.at("render_chunks_vertices")));
-		    ImGui::Checkbox("Wireframe",
-			    std::any_cast<bool*>(parameters.at("wireframe_return")));
-		}
-
-		if(ImGui::CollapsingHeader("Chunks")){
-		    ImGui::Text("Total chunks present: %d",
-			std::any_cast<int>(parameters.at("update_chunks_total")));
-		    ImGui::Text("Chunks generated: %d",
-			std::any_cast<int>(parameters.at("update_chunks_generated")));
-		    ImGui::Text("Chunks meshed: %d",
-			std::any_cast<int>(parameters.at("update_chunks_meshed")));
-		    ImGui::Text("Chunks actually freed from memory: %d",
-			std::any_cast<int>(parameters.at("update_chunks_freed")));
-		    ImGui::Text("Chunks explored: %d",
-			std::any_cast<int>(parameters.at("update_chunks_explored")));
-		}
-	    }catch(const std::bad_any_cast& e){
-		std::cout << e.what() << std::endl;
-	    }catch(const std::out_of_range& e){
-		std::cout << e.what() << std::endl;
-	    }
-
-	    ImGui::End();
-	}
-    }
-}

src/main.cpp

@@ -1,4 +1,5 @@
-#include "main.hpp"
+#include <glad/glad.h>
+#include <GLFW/glfw3.h>
 
 #include <iostream>
 #include <thread>
@@ -6,18 +7,22 @@
 #define GLOBALS_DEFINER
 #include "globals.hpp"
 #undef GLOBALS_DEFINER
+
 #include "chunkmanager.hpp"
-#include "controls.hpp"
+#include "main.hpp"
-#include "debugwindow.hpp"
 #include "renderer.hpp"
-#include "shader.hpp"
 #include "spacefilling.hpp"
+#include "shader.hpp"
 
 float deltaTime = 0.0f; // Time between current frame and last frame
 float lastFrame = 0.0f; // Time of last frame
 float lastFPSFrame = 0.0f;
 int frames = 0;
 
+float lastBlockPick=0.0;
+bool blockpick = false;
+bool canChangeWireframe = true;
+
 int main()
 {
 
@@ -52,23 +57,20 @@ int main()
     glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
     glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
     glfwSetCursorPosCallback(window, mouse_callback);
+    glEnable(GL_DEPTH_TEST);
     //glEnable(GL_FRAMEBUFFER_SRGB); //gamma correction done in fragment shader
     //glEnable(GL_CULL_FACE); //GL_BACK GL_CCW by default
 
-    debug::window::set_parameter("gpu_vendor", glGetString(GL_VENDOR));
+    std::cout << "Using GPU: " << glGetString(GL_VENDOR) << " " << glGetString(GL_RENDERER) << "\n";
-    debug::window::set_parameter("gpu_renderer", glGetString(GL_RENDERER));
 
+    wireframe = false;
     for(int i = 0; i < 360; i++){
 	sines[i] = sin(3.14 / 180 * i);
 	cosines[i] = cos(3.14 / 180 * i);
     }
-
     SpaceFilling::initLUT();
-    controls::init();
     chunkmanager::init();
-    chunkmesher::init();
+    renderer::init();
-    debug::window::init(window);
-    renderer::init(window);
 
     while (!glfwWindowShouldClose(window))
     {
@@ -77,12 +79,10 @@ int main()
         deltaTime = currentFrame - lastFrame;
         lastFrame = currentFrame;
 
-	debug::window::set_parameter("frametime", deltaTime);
         // FPS Counter
         frames++;
         if(currentFrame - lastFPSFrame >= 1.0f){
-            //std::cout << "FPS: " << frames << " Frametime: " << deltaTime << std::endl;
+            std::cout << "FPS: " << frames << " Frametime: " << deltaTime << std::endl;
-	    debug::window::set_parameter("fps", frames);
             frames = 0;
             lastFPSFrame = currentFrame;
         }
@@ -90,26 +90,14 @@ int main()
         glClearColor(0.431f, 0.694f, 1.0f, 1.0f);
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-	// Input handling
-        // Only close event is handles by main
-	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
-	    glfwSetWindowShouldClose(window, true);
-	// the rest of input processing is handled by controls.cpp
-
         // Input processing
-	controls::update(window);
+        processInput(window);
 
         // Camera
         theCamera.update(window, deltaTime);
-	debug::window::set_parameter("px", theCamera.getPos().x);
+	
-	debug::window::set_parameter("py", theCamera.getPos().y);
+	// Reset blockping timeout if 200ms have passed
-	debug::window::set_parameter("pz", theCamera.getPos().z);
+	if(glfwGetTime() - lastBlockPick > 0.1) blockpick = false;
-	debug::window::set_parameter("cx", (int)(theCamera.getPos().x / CHUNK_SIZE));
-	debug::window::set_parameter("cy", (int)(theCamera.getPos().y / CHUNK_SIZE));
-	debug::window::set_parameter("cz", (int)(theCamera.getPos().z / CHUNK_SIZE));
-	debug::window::set_parameter("lx", theCamera.getFront().x);
-	debug::window::set_parameter("ly", theCamera.getFront().y);
-	debug::window::set_parameter("lz", theCamera.getFront().z);
 
 	// Render pass
 	renderer::render();
@@ -134,10 +122,37 @@ void framebuffer_size_callback(GLFWwindow *window, int width, int height)
 {
     glViewport(0, 0, width, height);
     theCamera.viewPortCallBack(window, width, height);
-    renderer::framebuffer_size_callback(window, width, height);
 }
 
 void mouse_callback(GLFWwindow *window, double xpos, double ypos)
 {
     theCamera.mouseCallback(window, xpos, ypos);
 }
+
+void processInput(GLFWwindow *window)
+{
+    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
+        glfwSetWindowShouldClose(window, true);
+
+    if(glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_2) == GLFW_PRESS && !blockpick){
+	chunkmanager::blockpick(false);
+	blockpick=true;
+	lastBlockPick=glfwGetTime();
+    }
+
+    if(glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_1) == GLFW_PRESS && !blockpick){
+	chunkmanager::blockpick(true);
+	blockpick=true;
+	lastBlockPick=glfwGetTime();
+    }
+
+    if (glfwGetKey(window, GLFW_KEY_F) == GLFW_PRESS && canChangeWireframe){
+	wireframe = !wireframe;
+	canChangeWireframe = false;
+    }
+    if (glfwGetKey(window, GLFW_KEY_F) == GLFW_RELEASE) canChangeWireframe = true;
+
+    // Reset blockpicking if enough time has passed
+    if(glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_1) == GLFW_RELEASE && glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_2) == GLFW_RELEASE) blockpick = false;
+
+}

src/renderer.cpp

@@ -1,93 +1,30 @@
 #include "renderer.hpp"
 
-#include <glm/ext.hpp>
+#include <oneapi/tbb/concurrent_vector.h>
-#include <glm/gtx/string_cast.hpp>
+#include <oneapi/tbb/concurrent_queue.h>
-#include <oneapi/tbb/concurrent_hash_map.h>
 
 #include "chunkmanager.hpp"
 #include "chunkmesher.hpp"
-#include "debugwindow.hpp"
 #include "globals.hpp"
 #include "stb_image.h"
-#define STB_IMAGE_WRITE_IMPLEMENTATION
-#include "stb_image_write.h"
 
 namespace renderer{
-    typedef oneapi::tbb::concurrent_hash_map<chunk_index_t, RenderInfo*> RenderTable;
+    RenderSet chunks_torender;
+    oneapi::tbb::concurrent_vector<Chunk::Chunk*> render_todelete;
+    oneapi::tbb::concurrent_queue<chunkmesher::MeshData*> MeshDataQueue;
 
-    RenderTable ChunksToRender;
+    Shader* theShader;
-    ChunkMeshDataQueue MeshDataQueue;
-    IndexQueue MeshDataToDelete;
-
-    Shader* theShader, *quadShader;
     GLuint chunkTexture;
 
     Shader* getRenderShader() { return theShader; }
-    ChunkMeshDataQueue& getMeshDataQueue(){ return MeshDataQueue; }
+    RenderSet& getChunksToRender(){ return chunks_torender; }
-    IndexQueue& getDeleteIndexQueue(){ return MeshDataToDelete; }
+    oneapi::tbb::concurrent_queue<chunkmesher::MeshData*>& getMeshDataQueue(){ return MeshDataQueue; }
 
-    GLuint renderTexFrameBuffer, renderTex, renderTexDepthBuffer, quadVAO, quadVBO;
-    int screenWidth, screenHeight;
 
-    int crosshair_type{0};
+    void init(){
-    bool wireframe{false};
-
-    void init(GLFWwindow* window){
-	// Setup rendering
-	// We will render the image to a texture, then display the texture on a quad that fills the
-	// entire screen.
-	// This makes it easy to capture screenshots or apply filters to the final image (e.g.
-	// over-impress HUD elements like a crosshair)
-	glfwGetWindowSize(window, &screenWidth, &screenHeight);
-
-	glGenFramebuffers(1, &renderTexFrameBuffer);
-	glBindFramebuffer(GL_FRAMEBUFFER, renderTexFrameBuffer);
-
-	// Depth buffer
-	glGenRenderbuffers(1, &renderTexDepthBuffer);
-	glBindRenderbuffer(GL_RENDERBUFFER, renderTexDepthBuffer);
-	glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, screenWidth, screenHeight); //Support up to
-										//full-hd for now
-	// Attach it to the frame buffer
-	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER,
-		renderTexDepthBuffer);
-	// Create texture to render to
-	// The texture we're going to render to
-	glGenTextures(1, &renderTex);
-	glBindTexture(GL_TEXTURE_2D, renderTex);
-	glTexImage2D(GL_TEXTURE_2D, 0,GL_RGB, screenWidth, screenHeight, 0,GL_RGB, GL_UNSIGNED_BYTE, 0); // Support
-											 // up to
-											 // full-hd
-											 // for now
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-	// Set the texture as a render attachment for the framebuffer
-	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, renderTex, 0);
-
-	// Create the quad to render the texture to
-	float vertices[] = {
-	    -1.0f, -1.0f, 0.0f, 0.0f, 0.0f,
-	    -1.0f, 1.0f, 0.0f, 0.0f, 1.0f,
-	    1.0f, -1.0f, 0.0f, 1.0f, 0.0f,
-	    1.0f, 1.0f, 0.0f, 1.0f, 1.0f
-	};
-	glGenBuffers(1, &quadVBO);
-	glGenVertexArrays(1, &quadVAO);
-	glBindVertexArray(quadVAO);
-	glBindBuffer(GL_ARRAY_BUFFER, quadVBO);
-	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
-	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5*sizeof(float), (void*)0);
-	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5*sizeof(float), (void*)(3*sizeof(float)));
-	glEnableVertexAttribArray(0);
-	glEnableVertexAttribArray(1);
-	glBindVertexArray(0);
-
-	// Rendering of the world
 	// Create Shader
 	theShader = new Shader{"shaders/shader-texture.gs", "shaders/shader-texture.vs", "shaders/shader-texture.fs"};
-	quadShader = new Shader{nullptr, "shaders/shader-quad.vs", "shaders/shader-quad.fs"};
 
-	// Block textures
 	// Create 3d array texture
 	constexpr int layerCount = 5;
 	glGenTextures(1, &chunkTexture);
@@ -110,29 +47,10 @@ namespace renderer{
 	glTexParameteri(GL_TEXTURE_2D_ARRAY,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
 	glTexParameteri(GL_TEXTURE_2D_ARRAY,GL_TEXTURE_WRAP_S,GL_REPEAT);
 	glTexParameteri(GL_TEXTURE_2D_ARRAY,GL_TEXTURE_WRAP_T,GL_REPEAT);
-
-	debug::window::set_parameter("crosshair_type_return", &crosshair_type);
-	debug::window::set_parameter("wireframe_return", &wireframe);
     }
 
-
     void render(){
-	// Bind the frame buffer to render to the texture
+	int total{0}, toGpu{0};
-	glBindFramebuffer(GL_FRAMEBUFFER, renderTexFrameBuffer);
-	glViewport(0, 0, screenWidth, screenHeight);
-	glEnable(GL_DEPTH_TEST);
-	if(wireframe) glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-	else glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
-
-	// Clear the screen
-        glClearColor(0.431f, 0.694f, 1.0f, 1.0f);
-        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
-	/* UPDATE IMGUI */
-	debug::window::prerender();
-
-	/* RENDER THE WORLD TO TEXTURE */
-	int total{0}, toGpu{0}, oof{0}, vertices{0};
 	glm::vec4 frustumPlanes[6];
 	theCamera.getFrustumPlanes(frustumPlanes, true);
 	glm::vec3 cameraPos = theCamera.getPos();	
@@ -141,69 +59,32 @@ namespace renderer{
 	theShader->use();
 	theShader->setVec3("viewPos", cameraPos);
 
-	/* Process incoming mesh data */
+	chunkmesher::MeshData* m;
-	ChunkMeshData* m;
 	while(MeshDataQueue.try_pop(m)){
-	    RenderTable::accessor a;
+	    chunkmesher::sendtogpu(m);
-	    RenderInfo* render_info;
-
-	    if(ChunksToRender.find(a, m->index)){
-		render_info = a->second;
-		render_info->position = m->position;
-		render_info->num_vertices = m->num_vertices;
-
-		// Always updated the mesh, even if it's empty
-		// This should solve the problem of having floating quads when destroying a block
-		// near chunk borders
-		send_chunk_to_gpu(m, render_info);
-	    }else{
-		render_info = new RenderInfo();
-		render_info->index = m->index;
-		render_info->position = m->position;
-		render_info->num_vertices = m->num_vertices;
-
-		ChunksToRender.emplace(a, std::make_pair(render_info->index, render_info));
-
-		// Only send the mesh to the GPU if it's not empty
-		if(render_info->num_vertices > 0) send_chunk_to_gpu(m, render_info);
-	    }
-
 	    chunkmesher::getMeshDataQueue().push(m);
 	}
 
-	/* Process chunks to be removed */
+	if(wireframe) glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-	chunk_index_t queue_index;
+	else glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
-	while(MeshDataToDelete.try_pop(queue_index)){
-	    RenderTable::accessor a;
 
-	    if(ChunksToRender.find(a, queue_index)){
+	for(auto& c : chunks_torender){
-		RenderInfo* render_info = a->second;
+	    float dist = glm::distance(c->getPosition(), cameraChunkPos);
-		render_info->deallocateBuffers();
+	    if(dist <= static_cast<float>(RENDER_DISTANCE)){
-		delete render_info;
+		if(!c->getState(Chunk::CHUNK_STATE_MESH_LOADED)) continue;
-		ChunksToRender.erase(a);
-	    }
-	}
 
-	/* Render the chunks */
+		// reset out-of-vision and unload flags
-	// parallel_for cannot be used since all the rendering needs to happen in a single thread
+		c->setState(Chunk::CHUNK_STATE_OUTOFVISION, false);
-	for(RenderTable::iterator i = ChunksToRender.begin(); i != ChunksToRender.end(); i++){
+		c->setState(Chunk::CHUNK_STATE_UNLOADED, false);
-	    RenderInfo* render_info = i->second;
-
-	    if(render_info->num_vertices > 0)
-	    {
-		total++;
-
-		// Increase total vertex count
-		vertices += render_info->num_vertices;
 
 		// Perform frustum culling and eventually render
-		glm::vec3 chunk = render_info->position;
+		glm::vec3 chunk = c->getPosition();
 		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);
 		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
 		// TODO (?) implement frustum culling as per (Inigo Quilez)[https://iquilezles.org/articles/frustumcorrect/], and check each
-		// plane against each corner of the chunk
+		// plane against each corner of the chunk 
 		bool out=false;
 		int a{0};
 		for(int p = 0; p < 6; p++){
@@ -219,125 +100,49 @@ namespace renderer{
 
 		if (!out)
 		{
-		    theShader->setMat4("model", model);
+		    if(c->numVertices > 0)
-		    theShader->setMat4("view", theCamera.getView());
+		    {
-		    theShader->setMat4("projection", theCamera.getProjection());
+			theShader->setMat4("model", model);
+			theShader->setMat4("view", theCamera.getView());
+			theShader->setMat4("projection", theCamera.getProjection());
 
-		    glBindVertexArray(render_info->VAO);
+			glBindVertexArray(c->VAO);
-		    glDrawArrays(GL_POINTS, 0, render_info->num_vertices);
+			glDrawArrays(GL_POINTS, 0, c->numVertices);
-		    glBindVertexArray(0);
+			glBindVertexArray(0);
-
+		    }
-		    toGpu++;
 		}
+	    }else{
+		// When the chunk is outside render distance
+
+		if(c->getState(Chunk::CHUNK_STATE_OUTOFVISION)){
+		    if(glfwGetTime() - c->unload_timer > UNLOAD_TIMEOUT){
+			// If chunk was already out and enough time has passed
+			// Mark the chunk to be unloaded
+			// And mark is to be removed from the render set
+			render_todelete.push_back(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();
+		}
+		
 	    }
 	}
 
-	debug::window::set_parameter("render_chunks_total", (int)(ChunksToRender.size()));
+	for(auto& c : render_todelete){
-	debug::window::set_parameter("render_chunks_rendered", toGpu);
+	    // we can get away with unsafe erase as access to the container is only done by this
-	debug::window::set_parameter("render_chunks_renderable", total);
+	    // thread
-	debug::window::set_parameter("render_chunks_culled", total-toGpu);
+	    c->deleteBuffers();
-	debug::window::set_parameter("render_chunks_vertices", vertices);
+	    chunks_torender.unsafe_erase(c);
-
+	    chunkmanager::getDeleteVector().push(c);
-	/* DISPLAY TEXTURE ON A QUAD THAT FILLS THE SCREEN */
-	// Now to render the quad, with the texture on top
-	// Switch to the default frame buffer
-	glBindFramebuffer(GL_FRAMEBUFFER, 0);
-        glClearColor(0.431f, 0.694f, 1.0f, 1.0f);
-        glClear(GL_COLOR_BUFFER_BIT);
-	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
-
-	glBindVertexArray(quadVAO);
-	glDisable(GL_DEPTH_TEST);
-	glBindTexture(GL_TEXTURE_2D, renderTex);
-	quadShader->use();
-	quadShader->setInt("screenWidth", screenWidth);
-	quadShader->setInt("screenHeight", screenHeight);
-	quadShader->setInt("crosshairType", crosshair_type);
-	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-	glBindVertexArray(0);
-
-	debug::window::render();
-    }
-
-    void send_chunk_to_gpu(ChunkMeshData* mesh_data, RenderInfo* render_info)
-    {
-	if(!render_info->buffers_allocated) render_info->allocateBuffers();
-
-	// bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
-	glBindVertexArray(render_info->VAO);
-
-	// TODO: change GL_STATIC_DRAW to the one that means "few redraws and further in between"
-
-	// position attribute
-	glBindBuffer(GL_ARRAY_BUFFER, render_info->VBO);
-	glBufferData(GL_ARRAY_BUFFER, mesh_data->vertices.size() * sizeof(GLfloat), &(mesh_data->vertices[0]), GL_STATIC_DRAW);
-	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *)0);
-	glEnableVertexAttribArray(0);
-
-	// normal attribute
-	glBindBuffer(GL_ARRAY_BUFFER, render_info->extentsBuffer);
-	glBufferData(GL_ARRAY_BUFFER, mesh_data->extents.size() * sizeof(GLfloat), &(mesh_data->extents[0]), GL_STATIC_DRAW);
-	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *)(0));
-	glEnableVertexAttribArray(1);
-
-	// texcoords attribute
-	glBindBuffer(GL_ARRAY_BUFFER, render_info->texinfoBuffer);
-	glBufferData(GL_ARRAY_BUFFER, mesh_data->texinfo.size() * sizeof(GLfloat), &(mesh_data->texinfo[0]), GL_STATIC_DRAW);
-	glEnableVertexAttribArray(2);
-	glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), (void *)0);
-
-	glBindVertexArray(0);
-    }
-
-
-    void framebuffer_size_callback(GLFWwindow *window, int width, int height){
-	resize_framebuffer(width, height);
-    }
-
-    void resize_framebuffer(int width, int height){
-	screenWidth = width;
-	screenHeight = height;
-
-	theCamera.viewPortCallBack(nullptr, width, height);
-
-	glBindFramebuffer(GL_FRAMEBUFFER, renderTexFrameBuffer);
-	glBindTexture(GL_TEXTURE_2D, renderTex);
-	glTexImage2D(GL_TEXTURE_2D, 0,GL_RGB, width, height, 0,GL_RGB, GL_UNSIGNED_BYTE, 0); // Support
-	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, renderTex, 0);
-
-	glBindRenderbuffer(GL_RENDERBUFFER, renderTexDepthBuffer);
-	glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width, height); //Support up to
-	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER,
-		renderTexDepthBuffer);
-    }
-
-    void saveScreenshot(bool forceFullHD){
-	int old_screenWidth = screenWidth;
-	int old_screenHeight = screenHeight;
-
-	if(forceFullHD){
-	    resize_framebuffer(1920, 1080);
-	    // Do a render pass
-	    render();
 	}
-
+	render_todelete.clear();
-	// Bind the render frame buffer
-	glBindFramebuffer(GL_FRAMEBUFFER, renderTexFrameBuffer);
-	glPixelStorei(GL_PACK_ALIGNMENT, 1);
-	// Save the framebuffer in a byte array
-	GLubyte data[screenWidth*screenHeight*3];
-	glReadPixels(0, 0, screenWidth, screenHeight, GL_RGB, GL_UNSIGNED_BYTE, data);
-	// Save the byte array onto a texture
-	stbi_flip_vertically_on_write(1);
-	stbi_write_png(forceFullHD ? "screenshot_fullhd.png" : "screenshot.png", screenWidth,
-		screenHeight, 3, data, screenWidth*3);
-
-	if(forceFullHD) resize_framebuffer(old_screenWidth, old_screenHeight);
     }
 
     void destroy(){
 	delete theShader;
-	delete quadShader;
     }