EmaMaker
/
voxel-engine
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

initial update and render with concurrent DS

pull/1/head
EmaMaker 2023-04-29 14:54:43 +02:00
parent 1d3132cf3c
commit 78e3bc11e6
10 changed files with 168 additions and 337 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
include/camera.hpp
View File

@ -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

8
include/chunk.hpp
View File

@ -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::mutex mutex_state;
std::atomic<float> unload_timer{0};
std::vector<GLfloat> vertices;
std::vector<GLfloat> colors;

19
include/chunkmanager.hpp
View File

@ -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 initMeshThread();
void stopGenThread();
void stopMeshThread();
void mesh();
void generate();
void init();
std::thread 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 updateChunk(uint32_t, uint16_t, uint16_t, uint16_t);
void update();
}
#endif

4
include/renderer.hpp
View File

@ -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();
};

19
src/chunk.cpp
View File

@ -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)

1
src/chunkgenerator.cpp
View File

@ -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) {

295
src/chunkmanager.cpp
View File

@ -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 <atomic>
#include <iostream>
#include <math.h>
#include <mutex>
#include <set>
#include <string>
#include <unordered_map>
#include <thread>
#include "renderer.hpp"
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::mutex mutex_queue_generate;
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(){
std::atomic_bool should_run;
std::thread 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
// outwards. Alternate left and right
// Iterate over all chunks, in concentric spheres starting fron the player and going 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)
{
// Try to lock resources
f = 0;
f |= mutex_queue_generate.try_lock();
f |= mutex_queue_mesh.try_lock() << 1;
std::vector<uint32_t> chunks_todelete;
void update(){
while(should_run) {
//cameraPos = theCamera.getPos();
int chunkX=static_cast<int>(theCamera.getAtomicPosX() / CHUNK_SIZE);
int chunkY=static_cast<int>(theCamera.getAtomicPosY() / CHUNK_SIZE);
int chunkZ=static_cast<int>(theCamera.getAtomicPosZ() / CHUNK_SIZE);
cameraPos = theCamera.getPos();
chunkX=static_cast<int>(cameraPos.x) / CHUNK_SIZE;
chunkY=static_cast<int>(cameraPos.y) / CHUNK_SIZE;
chunkZ=static_cast<int>(cameraPos.z) / CHUNK_SIZE;
// Update other chunks
for(int i = 0; i < chunks_volume; i++) {
const uint16_t x = chunks_indices[i][0] + chunkX;
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
float currentTime = glfwGetTime();
ChunkTable::accessor a;
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
int nUnloaded{0};
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++;
if(! (a->second->getState(Chunk::CHUNK_STATE_GENERATED))) generateChunk(a->second);
if(! (a->second->getState(Chunk::CHUNK_STATE_MESHED))) chunkmesher::mesh(a->second);
// Delete afterwards to avoid exception due to invalid iterators
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";
renderer::getChunksToRender().insert(a->second);
for(int i = 0; i < chunks_volume; i++)
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;
a.release();
}
}
}
@ -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()
{
for (auto &n : chunks)
void stop() { should_run=false; }
void destroy(){
/*for(const auto& n : chunks){
delete n.second;
}
void stopGenThread(){
generate_should_run = false;
}
void stopMeshThread(){
mesh_should_run = false;
}*/
}
};

9
src/chunkmesher.cpp
View File

@ -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);

17
src/main.cpp
View File

@ -63,9 +63,7 @@ int main()
SpaceFilling::initLUT();
renderer::init();
chunkmanager::init();
std::thread genThread = chunkmanager::initGenThread();
std::thread meshThread = chunkmanager::initMeshThread();
std::thread chunkmanager_thread = chunkmanager::init();
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::stopMeshThread();
genThread.join();
meshThread.join();
chunkmanager::stop();
chunkmanager_thread.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();
}

62
src/renderer.cpp
View File

@ -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,20 +44,29 @@ 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;
int chunkY=static_cast<int>(cameraPos.y) / CHUNK_SIZE;
int chunkZ=static_cast<int>(cameraPos.z) / CHUNK_SIZE;
glm::vec3 cameraChunkPos = cameraPos / static_cast<float>(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++;
for(Chunk::Chunk* c : chunks_torender){
if(! (c->getState(Chunk::CHUNK_STATE_MESHED))) continue;
// If the mesh is ready send it to the gpu
if(! (c->getState(Chunk::CHUNK_STATE_MESH_LOADED))){
if(c->VAO == 0) c->createBuffers();
chunkmesher::sendtogpu(c);
c->setState(Chunk::CHUNK_STATE_MESH_LOADED, true);
}
if(glm::distance(c->getPosition(), cameraChunkPos) < static_cast<float>(RENDER_DISTANCE)){
// if chunk can be seen
// reset out-of-vision and unload flags
c->setState(Chunk::CHUNK_STATE_OUTOFVISION, false);
c->setState(Chunk::CHUNK_STATE_UNLOADED, false);
// Perform frustum culling and eventually render
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);
@ -76,9 +89,7 @@ namespace renderer{
if (!out)
{
toGpu++;
if(c->getState(Chunk::CHUNK_STATE_MESH_LOADED) && c->vIndex > 0)
if(c->vIndex > 0)
{
// glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); // wireframe mode
theShader->setMat4("model", model);
@ -90,13 +101,32 @@ namespace renderer{
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";
//std::cout << "Chunks to generate: " << to_generate.size() << "\n";
//std::cout << "Total chunks to draw: " << total << ". Sent to GPU: " << toGpu << "\n";
}
}
for(Chunk::Chunk* i : render_todelete){
chunks_torender.unsafe_erase(i);
}
render_todelete.clear();
}
void destroy(){
delete theShader;
}