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

blockpick: skip iteration if block has not changed

main
EmaMaker 2023-10-04 22:33:43 +02:00
parent 0560fd43c6
commit f3d8ffed54
3 changed files with 171 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

153
blockpick_aw Normal file
View File

@ -0,0 +1,153 @@
// Traverse voxel using Amanatides&Woo traversal algorithm
// http://www.cse.yorku.ca/~amana/research/grid.pdf
glm::vec3 pos = msg.cameraPos;
glm::vec3 front = msg.cameraFront;
int chunkX, chunkY, chunkZ, blockX, blockY, blockZ, old_blockX, old_blockY, old_blockZ;
Chunk::Chunk* old_chunk = nullptr;
// 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(pos.x);
int basey = std::floor(pos.y);
int basez = std::floor(pos.z);
double x = pos.x - basex;
double y = pos.y - basey;
double z = pos.z - basez;
/*double x = std::floor(pos.x + 0.5d);
double y = std::floor(pos.y + 0.5d);
double z = std::floor(pos.z + 0.5d);
*/
auto sign = [=](double f){ return f > 0 ? 1 : f < 0 ? -1 : 0; };
auto tmax = [=](double p, double dir){
int s = sign(dir);
double b = std::floor(p + 0.5d);
if(s > 0)
return (b + 1 - p) / dir;
else if(s < 0)
return (p - b) / 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;
std::cout << "starting blockpick at " << x << "," << y << "," << z << "+(" << basex << "," <<
basey << "," << basez << ") with tMax " << tMaxX
<< "," << tMaxY << "," << tMaxZ << " and delta " << tDeltaX << "," << tDeltaY << "," <<
tDeltaZ << std::endl;
while(utils::withinDistance(x,y,z,0,0,0,6)){
if(tMaxX < tMaxY){
if(tMaxX < tMaxZ) {
x += stepX;
tMaxX += tDeltaX;
}else{
z += stepZ;
tMaxZ += tDeltaZ;
}
}else{
if(tMaxY < tMaxZ){
y += stepY;
tMaxY += tDeltaY;
}else{
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) break;
blockX = realx - chunkX*CHUNK_SIZE;
blockY = realy - chunkY*CHUNK_SIZE;
blockZ = realz - chunkZ*CHUNK_SIZE;
std::cout << blockX << "," << blockY << "," << blockZ << std::endl;
ChunkTable::accessor a;
if(!chunks.find(a, Chunk::calculateIndex(chunkX, chunkY, chunkZ))) break;
Chunk::Chunk* chunk = a->second;
if(!(chunk->isFree() || chunk->getState(Chunk::CHUNK_STATE_GENERATED))) break;
Block block = chunk->getBlock(blockX, blockY, blockZ);
//chunk->setBlock(msg.block, blockX, blockY, blockZ);
//send_chunk_to_meshing_thread(chunk, MESHING_PRIORITY_PLAYER_EDIT);
if(block != Block::AIR){
if(msg.msg_type == WorldUpdateMsgType::BLOCKPICK_PLACE){
if(old_chunk){
old_chunk->setBlock(msg.block, old_blockX, old_blockY, old_blockZ);
send_chunk_to_meshing_thread(old_chunk, MESHING_PRIORITY_PLAYER_EDIT);
if(chunk != old_chunk) send_chunk_to_meshing_thread(chunk, MESHING_PRIORITY_PLAYER_EDIT);
debug::window::set_parameter("block_last_action", false);
debug::window::set_parameter("block_last_action_block_type",
(int)(msg.block));
debug::window::set_parameter("block_last_action_x", (int)x);
debug::window::set_parameter("block_last_action_y", (int)y);
debug::window::set_parameter("block_last_action_z", (int)z);
}
}else{
chunk->setBlock(Block::AIR, blockX, blockY, blockZ);
send_chunk_to_meshing_thread(chunk, MESHING_PRIORITY_PLAYER_EDIT);
// 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_chunk_to_meshing_thread(a1->second, MESHING_PRIORITY_PLAYER_EDIT);
if(blockY == 0 && chunkY - 1 >= 0 && chunks.find(b1, Chunk::calculateIndex(chunkX, chunkY - 1, chunkZ)))
send_chunk_to_meshing_thread(b1->second, MESHING_PRIORITY_PLAYER_EDIT);
if(blockZ == 0 && chunkZ - 1 >= 0 && chunks.find(c1, Chunk::calculateIndex(chunkX, chunkY, chunkZ - 1)))
send_chunk_to_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_chunk_to_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_chunk_to_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_chunk_to_meshing_thread(c2->second, MESHING_PRIORITY_PLAYER_EDIT);
debug::window::set_parameter("block_last_action", false);
debug::window::set_parameter("block_last_action_block_type", (int) (Block::AIR));
debug::window::set_parameter("block_last_action_x", (int)x);
debug::window::set_parameter("block_last_action_y", (int)y);
debug::window::set_parameter("block_last_action_z", (int)z);
}
break;
}
old_chunk = chunk;
old_blockX = blockX;
old_blockY = blockY;
old_blockZ = blockZ;
}

2
blockpick_old Normal file
View File

@ -0,0 +1,2 @@

39
src/chunkmanager.cpp
View File

@ -277,9 +277,12 @@ namespace chunkmanager
}
void blockpick(WorldUpdateMsg& msg){
int old_bx{0}, old_by{0}, old_bz{0};
Chunk::Chunk* old_chunk;
// cast a ray from the camera in the direction pointed by the camera itself
glm::vec3 pos = msg.cameraPos;
for(float t = 0.0; t <= 10.0; t += 0.5){
for(float t = 0.0; t <= 10.0; t += 0.1){
// traverse the ray a block at the time
pos = msg.cameraPos + t*msg.cameraFront;
@ -291,6 +294,8 @@ 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;
@ -307,31 +312,14 @@ namespace chunkmanager
// if placing a new block
if(msg.msg_type == WorldUpdateMsgType::BLOCKPICK_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 || px1 >= 1024 || py1 >= 1024 || pz1 >= 1024) return;
ChunkTable::accessor a1;
if(!chunks.find(a1, Chunk::calculateIndex(px1, py1, pz1))) return;
Chunk::Chunk* c1 = a1->second;
// place the new block (only stone for now)
c1->setBlock(msg.block, bx1, by1, bz1);
if(!old_chunk) break;
old_chunk->setBlock(msg.block, old_bx, old_by, old_bz);
// mark the mesh of the chunk the be updated
chunks_to_mesh_queue.push(std::make_pair(c1, MESHING_PRIORITY_PLAYER_EDIT));
chunks_to_mesh_queue.push(std::make_pair(c, MESHING_PRIORITY_PLAYER_EDIT));
chunks_to_mesh_queue.push(std::make_pair(old_chunk, MESHING_PRIORITY_PLAYER_EDIT));
if(c != old_chunk) chunks_to_mesh_queue.push(std::make_pair(c, MESHING_PRIORITY_PLAYER_EDIT));
debug::window::set_parameter("block_last_action", true);
debug::window::set_parameter("block_last_action_block_type", (int)(msg.block));
@ -368,6 +356,11 @@ namespace chunkmanager
}
break;
}
old_chunk = c;
old_bx = bx;
old_by = by;
old_bz = bz;
}
}