506 lines
15 KiB
C++
506 lines
15 KiB
C++
#include "world.h"
|
||
|
||
World::World() {}
|
||
|
||
World::~World() {}
|
||
|
||
Array2d<Chunk*>& World::GetChunks() { return m_chunks; }
|
||
|
||
void World::SetSeed(uint64_t seed) {
|
||
m_seed = seed;
|
||
}
|
||
|
||
Chunk* World::ChunkAt(float x, float y, float z) const {
|
||
int cx = (int)x / CHUNK_SIZE_X;
|
||
int cz = (int)z / CHUNK_SIZE_Z;
|
||
|
||
if (x < 0 || y < 0 || z < 0 ||
|
||
x >= WORLD_SIZE_X * CHUNK_SIZE_X ||
|
||
z >= CHUNK_SIZE_Z * WORLD_SIZE_Y ||
|
||
y > CHUNK_SIZE_Y)
|
||
return 0;
|
||
|
||
return m_chunks.Get(cx, cz);
|
||
}
|
||
|
||
Chunk* World::ChunkAt(const Vector3f& pos) const { return ChunkAt(pos.x, pos.y, pos.z); }
|
||
|
||
BlockType World::BlockAt(float x, float y, float z, BlockType defaultBlockType) const {
|
||
Chunk* c = ChunkAt(x, y, z);
|
||
|
||
if (!c)
|
||
return defaultBlockType;
|
||
|
||
int bx = (int)x % CHUNK_SIZE_X;
|
||
int by = (int)y % CHUNK_SIZE_Y;
|
||
int bz = (int)z % CHUNK_SIZE_Z;
|
||
|
||
return c->GetBlock(bx, by, bz);
|
||
}
|
||
|
||
BlockType World::BlockAt(const Vector3f& pos, BlockType defaultBlockType) const {
|
||
return BlockAt(pos.x, pos.y, pos.z, defaultBlockType);
|
||
}
|
||
|
||
void World::TransposeWorld(Player& player, Bullet* bullets[MAX_BULLETS]) {
|
||
int x = 0, y = 0;
|
||
|
||
if (player.GetPosition().x > (WORLD_SIZE_X * CHUNK_SIZE_X) * .6f) ++x;
|
||
else if (player.GetPosition().x < (WORLD_SIZE_X * CHUNK_SIZE_X) * .4f) --x;
|
||
if (player.GetPosition().z > (WORLD_SIZE_Y * CHUNK_SIZE_Z) * .6f) ++y;
|
||
else if (player.GetPosition().z < (WORLD_SIZE_Y * CHUNK_SIZE_Z) * .4f) --y;
|
||
|
||
if (!x && !y) return;
|
||
|
||
if (x > 0) {
|
||
for (int ax = 0; ax < WORLD_SIZE_X; ++ax)
|
||
for (int ay = 0; ay < WORLD_SIZE_Y; ++ay)
|
||
if (ax - x >= 0) {
|
||
m_chunks.Set(ax - x, ay,
|
||
m_chunks.Remove(ax, ay));
|
||
if (ax == WORLD_SIZE_X - 1 && m_chunks.Get(ax - x, ay))
|
||
m_chunks.Get(ax - x, ay)->MakeDirty();
|
||
}
|
||
else if (m_chunks.Get(ax, ay)) m_tbDeleted.emplace_back(m_chunks.Remove(ax, ay));
|
||
}
|
||
else if (x < 0) {
|
||
for (int ax = WORLD_SIZE_X - 1; ax >= 0; --ax)
|
||
for (int ay = WORLD_SIZE_Y - 1; ay >= 0; --ay)
|
||
if (ax - x < WORLD_SIZE_X) {
|
||
m_chunks.Set(ax - x, ay,
|
||
m_chunks.Remove(ax, ay));
|
||
if (ax == 0 && m_chunks.Get(ax - x, ay))
|
||
m_chunks.Get(ax - x, ay)->MakeDirty();
|
||
}
|
||
else if (m_chunks.Get(ax, ay)) m_tbDeleted.emplace_back(m_chunks.Remove(ax, ay));
|
||
}
|
||
|
||
if (y > 0) {
|
||
for (int ax = 0; ax < WORLD_SIZE_X; ++ax)
|
||
for (int ay = 0; ay < WORLD_SIZE_Y; ++ay)
|
||
if (ay - y >= 0) {
|
||
m_chunks.Set(ax, ay - y,
|
||
m_chunks.Remove(ax, ay));
|
||
if (ay == WORLD_SIZE_Y - 1 && m_chunks.Get(ax, ay - y))
|
||
m_chunks.Get(ax, ay - y)->MakeDirty();
|
||
}
|
||
else if (m_chunks.Get(ax, ay)) m_tbDeleted.emplace_back(m_chunks.Remove(ax, ay));
|
||
}
|
||
else if (y < 0) {
|
||
for (int ax = WORLD_SIZE_X - 1; ax >= 0; --ax)
|
||
for (int ay = WORLD_SIZE_Y - 1; ay >= 0; --ay)
|
||
if (ay - y < WORLD_SIZE_Y) {
|
||
m_chunks.Set(ax, ay - y,
|
||
m_chunks.Remove(ax, ay));
|
||
if (ay == 0 && m_chunks.Get(ax, ay - y))
|
||
m_chunks.Get(ax, ay - y)->MakeDirty();
|
||
}
|
||
else if (m_chunks.Get(ax, ay)) m_tbDeleted.emplace_back(m_chunks.Remove(ax, ay));
|
||
}
|
||
|
||
m_center[0] += x; m_center[1] += y;
|
||
player.Teleport(x, y);
|
||
|
||
for (int index = 0; index < MAX_BULLETS; ++index)
|
||
if (bullets[index]) bullets[index]->Transpose(x, y);
|
||
}
|
||
|
||
void World::CleanUpWorld(int& deleteframes, bool clear = false) {
|
||
if (clear) {
|
||
while (m_tbDeleted.size() > 0) {
|
||
delete m_tbDeleted.back();
|
||
m_tbDeleted.pop_back();
|
||
}
|
||
}
|
||
if (!m_tbDeleted.empty() && !deleteframes) {
|
||
int deleted = 0;
|
||
while (deleted < THREADS_DELETE_CHUNKS) {
|
||
|
||
|
||
}
|
||
delete m_tbDeleted.back();
|
||
m_tbDeleted.pop_back();
|
||
deleteframes = FRAMES_DELETE_CHUNKS;
|
||
}
|
||
}
|
||
|
||
void World::GetScope(unsigned int& x, unsigned int& y) {
|
||
x = m_center[0];
|
||
y = m_center[1];
|
||
}
|
||
|
||
void World::Update(int& rendercount, Bullet* bullets[MAX_BULLETS], Player& player, Transformation& world, Shader& shader, TextureAtlas& atlas, BlockInfo* blockinfo[BTYPE_LAST]) {
|
||
glStencilFunc(GL_EQUAL, 1, 0x00);
|
||
glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
|
||
atlas.Bind();
|
||
RenderWorld(rendercount, player, world, shader);
|
||
UpdateWorld(player, blockinfo);
|
||
//TransposeWorld(player, bullets);
|
||
shader.Disable();
|
||
glStencilFunc(GL_GREATER, 1, 0xFF);
|
||
}
|
||
|
||
void World::UpdateChunk(int& updates, unsigned int chx, unsigned int chy, BlockInfo* blockinfo[BTYPE_LAST]) {
|
||
if (updates == 0 && ChunkAt(chx, 1, chy) &&
|
||
ChunkAt(chx, 1, chy)->IsDirty()) {
|
||
ChunkAt(chx, 1, chy)->Update(blockinfo, this);
|
||
updates = FRAMES_UPDATE_CHUNKS;
|
||
}
|
||
|
||
}
|
||
|
||
void World::ChangeBlockAtCursor(BlockType blockType, Player& player, bool& block) {
|
||
Vector3f currentPos = player.GetPosition();
|
||
Vector3f currentBlock = currentPos;
|
||
Vector3f ray = player.GetDirection();
|
||
bool found = false;
|
||
|
||
if (block) return;
|
||
|
||
while ((currentPos - currentBlock).Length() <= MAX_SELECTION_DISTANCE && !found) {
|
||
currentBlock += ray / 10.f;
|
||
|
||
BlockType bt = BlockAt(currentBlock);
|
||
|
||
if (bt != BTYPE_AIR)
|
||
found = true;
|
||
}
|
||
|
||
if (found)
|
||
if (blockType != BTYPE_AIR) {
|
||
found = false;
|
||
while ((currentPos - currentBlock).Length() >= 1.7f && !found) {
|
||
currentBlock -= ray / 10.f;
|
||
|
||
BlockType bt = BlockAt(currentBlock);
|
||
|
||
if (bt == BTYPE_AIR) { // V<>rification pour <20>tre s<>r que le bloc <20> changer n'est pas dans le joueur.
|
||
int Bx = (int)currentBlock.x;
|
||
int By = (int)currentBlock.y;
|
||
int Bz = (int)currentBlock.z;
|
||
|
||
int Px = (int)currentPos.x;
|
||
int PyA = (int)currentPos.y;
|
||
int PyB = (int)(currentPos.y - .9f);
|
||
int PyC = (int)(currentPos.y - 1.7f);
|
||
int Pz = (int)currentPos.z;
|
||
|
||
if (!(Bx == Px &&
|
||
(By == PyA ||
|
||
By == PyB ||
|
||
By == PyC) &&
|
||
Bz == Pz))
|
||
found = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (found && (int)currentBlock.y < CHUNK_SIZE_Y) {
|
||
int bx = (int)currentBlock.x % CHUNK_SIZE_X;
|
||
int by = (int)currentBlock.y % CHUNK_SIZE_Y;
|
||
int bz = (int)currentBlock.z % CHUNK_SIZE_Z;
|
||
|
||
ChunkAt(currentBlock)->SetBlock(bx, by, bz, blockType, this);
|
||
ChunkAt(currentBlock)->MakeModified();
|
||
block = true;
|
||
}
|
||
}
|
||
|
||
void World::ChangeBlockAtPosition(BlockType blockType, Vector3f pos) {
|
||
int bx = (int)pos.x % CHUNK_SIZE_X;
|
||
int by = (int)pos.y % CHUNK_SIZE_Y;
|
||
int bz = (int)pos.z % CHUNK_SIZE_Z;
|
||
|
||
ChunkAt(pos)->SetBlock(bx, by, bz, blockType, this);
|
||
ChunkAt(pos)->MakeModified();
|
||
}
|
||
|
||
void World::RenderWorld(int& rendercount, Player& player, Transformation& world, Shader& shader) {
|
||
shader.Use();
|
||
rendercount = 0;
|
||
Vector3f angle;
|
||
Vector3f cursor;
|
||
Vector3f direct = player.GetDirection();
|
||
Vector3f pos = player.GetPosition() - direct;
|
||
|
||
direct.y = 0;
|
||
direct.Normalize();
|
||
pos.y = 1;
|
||
|
||
static Vector3<unsigned int> renderManifest[VIEW_DISTANCE * 8]; // Nombre de Chunks maximal <20> <20>tre rendus.
|
||
|
||
//for (int dist = VIEW_DISTANCE; dist >= 0; dist -= CHUNK_SIZE_X) {
|
||
for (int dist = 0; dist <= VIEW_DISTANCE; dist += CHUNK_SIZE_X) {
|
||
// Configuration du radar.
|
||
float sinus, cosinus;
|
||
int echantillons;
|
||
|
||
if (dist > VIEW_DISTANCE * .1f) {
|
||
sinus = .00872653549f; // sin(1/2 degr<67>)
|
||
cosinus = .99996192306; // cos(1/2 degr<67>)
|
||
echantillons = 180;
|
||
}
|
||
//else if (dist > VIEW_DISTANCE * .3f) {
|
||
// sinus = .01151891831f; // sin(2/3 degr<67>)
|
||
// cosinus = .99993365506; // cos(2/3 degr<67>)
|
||
// echantillons = 120;
|
||
//}
|
||
//else if (dist > VIEW_DISTANCE * .2f) {
|
||
// sinus = .01745240643; // sin(1 degr<67>)
|
||
// cosinus = .99984769515; // cos(1 degr<67>)
|
||
// echantillons = 90;
|
||
//}
|
||
//else if (dist > VIEW_DISTANCE * .1f) {
|
||
// sinus = .0261769483;
|
||
// cosinus = .99965732497;
|
||
// echantillons = 60;
|
||
//}
|
||
else {
|
||
sinus = .0348994967;
|
||
cosinus = .99939082701;
|
||
echantillons = 45;
|
||
}
|
||
|
||
angle.x = direct.z + direct.x;
|
||
angle.z = direct.z - direct.x;
|
||
angle.y = 0;
|
||
angle.Normalize();
|
||
|
||
for (int radar = 0; radar < echantillons; ++radar) {
|
||
float x = angle.x;
|
||
|
||
angle.x = angle.x * cosinus - angle.z * sinus;
|
||
angle.z = angle.z * cosinus + x * sinus;
|
||
angle.Normalize();
|
||
|
||
cursor = pos - direct * CHUNK_SIZE_X * 2 + angle * dist;
|
||
if (cursor.y >= 128.f || cursor.y >= 0.f) cursor.y = CHUNK_SIZE_Y / 2.f;
|
||
|
||
|
||
if (ChunkAt(cursor)) {
|
||
bool valide = true;
|
||
unsigned int chx, chy;
|
||
ChunkAt(cursor)->GetPosition(chx, chy);
|
||
for (int index = 0; index < rendercount; ++index) // Permet de v<>rifier seulement contre celles ajout<75>es dans la frame, et ne pas avoir <20> refaire l'array <20> chaque frame.
|
||
if (renderManifest[index].x == chx && renderManifest[index].z == chy)
|
||
valide = false;
|
||
|
||
if (valide) renderManifest[rendercount++] = Vector3<unsigned int>(chx,
|
||
(VIEW_DISTANCE - (pos - cursor).Length() * 3.f + 256.f) < 0.f? 0:
|
||
(VIEW_DISTANCE - (pos - cursor).Length() * 3.f + 256.f) * 1000,
|
||
chy);
|
||
}
|
||
}
|
||
}
|
||
for (int index = 0; index < rendercount; ++index) {
|
||
int chx = (renderManifest[index].x - m_center[0]) * CHUNK_SIZE_X, chy = (renderManifest[index].z - m_center[1]) * CHUNK_SIZE_Z;
|
||
|
||
world.ApplyTranslation(chx, 0, chy);
|
||
world.Use();
|
||
float blcolor = renderManifest[index].y / (VIEW_DISTANCE / 50.f);
|
||
glBlendColor(blcolor, blcolor, blcolor, 1.f);
|
||
ChunkAt(chx, 1, chy)->Render();
|
||
world.ApplyTranslation(-chx, 0, -chy);
|
||
}
|
||
shader.Disable();
|
||
};
|
||
|
||
void World::UpdateWorld(Player& player, BlockInfo* blockinfo[BTYPE_LAST]) {
|
||
int cx = player.GetPosition().x;
|
||
int cy = player.GetPosition().z;
|
||
static int frameGenerate = 1;
|
||
static int frameUpdate = 2;
|
||
static int frameDelete = 3;
|
||
int side = 0;
|
||
int threads = 0;
|
||
std::future<Chunk*> genThList[THREADS_GENERATE_CHUNKS];
|
||
std::future<Chunk*> updateThList[THREADS_UPDATE_CHUNKS];
|
||
std::future<void> delThList[THREADS_DELETE_CHUNKS];
|
||
|
||
if (frameGenerate > 0) --frameGenerate;
|
||
if (frameUpdate > 0) --frameUpdate;
|
||
if (frameDelete > 0) --frameDelete;
|
||
|
||
if (!frameGenerate)
|
||
while (side * CHUNK_SIZE_X <= VIEW_DISTANCE * 2 + CHUNK_SIZE_X) {
|
||
int tx = -side, ty = -side;
|
||
int chx = 0;
|
||
int chy = 0;
|
||
|
||
for (; tx <= side; ++tx) {
|
||
if (frameGenerate)
|
||
break;
|
||
chx = cx + tx * CHUNK_SIZE_X;
|
||
chy = cy + ty * CHUNK_SIZE_Z;
|
||
if (chx < WORLD_SIZE_X * CHUNK_SIZE_X && chy < WORLD_SIZE_Y * CHUNK_SIZE_Z &&
|
||
chx >= 0 && chy >= 0 && !ChunkAt(chx, 1, chy))
|
||
genThList[threads++] = std::async(std::launch::async,
|
||
[](unsigned int x, unsigned int y, uint64_t seed) {
|
||
return new Chunk(x, y, seed); },
|
||
chx / CHUNK_SIZE_X + m_center[0],
|
||
chy / CHUNK_SIZE_Z + m_center[1],
|
||
m_seed);
|
||
if (threads == THREADS_GENERATE_CHUNKS) frameGenerate = FRAMES_RENDER_CHUNKS;
|
||
}
|
||
for (; ty <= side; ++ty) {
|
||
if (frameGenerate)
|
||
break;
|
||
chx = cx + tx * CHUNK_SIZE_X;
|
||
chy = cy + ty * CHUNK_SIZE_Z;
|
||
if (chx < WORLD_SIZE_X * CHUNK_SIZE_X && chy < WORLD_SIZE_Y * CHUNK_SIZE_Z &&
|
||
chx >= 0 && chy >= 0 && !ChunkAt(chx, 1, chy))
|
||
genThList[threads++] = std::async(std::launch::async,
|
||
[](unsigned int x, unsigned int y, uint64_t seed) {
|
||
return new Chunk(x, y, seed); },
|
||
chx / CHUNK_SIZE_X + m_center[0],
|
||
chy / CHUNK_SIZE_Z + m_center[1],
|
||
m_seed);
|
||
if (threads == THREADS_GENERATE_CHUNKS) frameGenerate = FRAMES_RENDER_CHUNKS;
|
||
}
|
||
for (; tx >= -side; --tx) {
|
||
if (frameGenerate)
|
||
break;
|
||
chx = cx + tx * CHUNK_SIZE_X;
|
||
chy = cy + ty * CHUNK_SIZE_Z;
|
||
if (chx < WORLD_SIZE_X * CHUNK_SIZE_X && chy < WORLD_SIZE_Y * CHUNK_SIZE_Z &&
|
||
chx >= 0 && chy >= 0 && !ChunkAt(chx, 1, chy))
|
||
genThList[threads++] = std::async(std::launch::async,
|
||
[](unsigned int x, unsigned int y, uint64_t seed) {
|
||
return new Chunk(x, y, seed); },
|
||
chx / CHUNK_SIZE_X + m_center[0],
|
||
chy / CHUNK_SIZE_Z + m_center[1],
|
||
m_seed);
|
||
if (threads == THREADS_GENERATE_CHUNKS) frameGenerate = FRAMES_RENDER_CHUNKS;
|
||
}
|
||
for (; ty >= -side; --ty) {
|
||
if (frameGenerate)
|
||
break;
|
||
chx = cx + tx * CHUNK_SIZE_X;
|
||
chy = cy + ty * CHUNK_SIZE_Z;
|
||
if (chx < WORLD_SIZE_X * CHUNK_SIZE_X && chy < WORLD_SIZE_Y * CHUNK_SIZE_Z &&
|
||
chx >= 0 && chy >= 0 && !ChunkAt(chx, 1, chy))
|
||
genThList[threads++] = std::async(std::launch::async,
|
||
[](unsigned int x, unsigned int y, uint64_t seed) {
|
||
return new Chunk(x, y, seed); },
|
||
chx / CHUNK_SIZE_X + m_center[0],
|
||
chy / CHUNK_SIZE_Z + m_center[1],
|
||
m_seed);
|
||
if (threads == THREADS_GENERATE_CHUNKS) frameGenerate = FRAMES_RENDER_CHUNKS;
|
||
}
|
||
if (frameGenerate)
|
||
break;
|
||
++side;
|
||
}
|
||
|
||
if (threads > 0) {
|
||
for (int i = 0; i < threads; ++i)
|
||
genThList[i].wait();
|
||
|
||
for (int i = 0; i < threads; ++i) {
|
||
unsigned int x, y;
|
||
Chunk* chunk = genThList[i].get();
|
||
chunk->GetPosition(x, y);
|
||
m_chunks.Set(x - m_center[0], y - m_center[1], chunk);
|
||
}
|
||
}
|
||
|
||
side = 0;
|
||
threads = 0;
|
||
|
||
if (!frameUpdate)
|
||
while (side * CHUNK_SIZE_X <= VIEW_DISTANCE * 2) {
|
||
int tx = -side, ty = -side;
|
||
|
||
for (; tx <= side; ++tx) {
|
||
if (frameUpdate)
|
||
break;
|
||
unsigned int chx = cx + tx * CHUNK_SIZE_X, chy = cy + ty * CHUNK_SIZE_Z;
|
||
if (ChunkAt(chx, 1, chy) &&
|
||
ChunkAt(chx, 1, chy)->IsDirty()) {
|
||
updateThList[threads++] =
|
||
std::async(std::launch::async,
|
||
[](Chunk* chunk, BlockInfo* blockinfo[BTYPE_LAST], World* world) {
|
||
chunk->Update(blockinfo, world); return chunk; }, ChunkAt(chx, 1, chy), blockinfo, this);
|
||
if (threads == THREADS_UPDATE_CHUNKS) frameUpdate = FRAMES_UPDATE_CHUNKS;
|
||
}
|
||
}
|
||
for (; ty <= side; ++ty) {
|
||
if (frameUpdate)
|
||
break;
|
||
unsigned int chx = cx + tx * CHUNK_SIZE_X, chy = cy + ty * CHUNK_SIZE_Z;
|
||
if (ChunkAt(chx, 1, chy) &&
|
||
ChunkAt(chx, 1, chy)->IsDirty()) {
|
||
updateThList[threads++] =
|
||
std::async(std::launch::async,
|
||
[](Chunk* chunk, BlockInfo* blockinfo[BTYPE_LAST], World* world) {
|
||
chunk->Update(blockinfo, world); return chunk; }, ChunkAt(chx, 1, chy), blockinfo, this);
|
||
if (threads == THREADS_UPDATE_CHUNKS) frameUpdate = FRAMES_UPDATE_CHUNKS;
|
||
}
|
||
}
|
||
for (; tx >= -side; --tx) {
|
||
if (frameUpdate)
|
||
break;
|
||
unsigned int chx = cx + tx * CHUNK_SIZE_X, chy = cy + ty * CHUNK_SIZE_Z;
|
||
if (ChunkAt(chx, 1, chy) &&
|
||
ChunkAt(chx, 1, chy)->IsDirty()) {
|
||
updateThList[threads++] =
|
||
std::async(std::launch::async,
|
||
[](Chunk* chunk, BlockInfo* blockinfo[BTYPE_LAST], World* world) {
|
||
chunk->Update(blockinfo, world); return chunk; }, ChunkAt(chx, 1, chy), blockinfo, this);
|
||
if (threads == THREADS_UPDATE_CHUNKS) frameUpdate = FRAMES_UPDATE_CHUNKS;
|
||
}
|
||
}
|
||
for (; ty >= -side; --ty) {
|
||
if (frameUpdate)
|
||
break;
|
||
unsigned int chx = cx + tx * CHUNK_SIZE_X, chy = cy + ty * CHUNK_SIZE_Z;
|
||
if (ChunkAt(chx, 1, chy) &&
|
||
ChunkAt(chx, 1, chy)->IsDirty()) {
|
||
updateThList[threads++] =
|
||
std::async(std::launch::async,
|
||
[](Chunk* chunk, BlockInfo* blockinfo[BTYPE_LAST], World* world) {
|
||
chunk->Update(blockinfo, world); return chunk; }, ChunkAt(chx, 1, chy), blockinfo, this);
|
||
if (threads == THREADS_UPDATE_CHUNKS) frameUpdate = FRAMES_UPDATE_CHUNKS;
|
||
}
|
||
}
|
||
if (frameUpdate)
|
||
break;
|
||
++side;
|
||
}
|
||
|
||
if (threads > 0) {
|
||
for (int i = 0; i < threads; ++i) {
|
||
updateThList[i].wait();
|
||
Chunk* chunk = updateThList[i].get();
|
||
chunk->FlushMeshToVBO();
|
||
}
|
||
}
|
||
|
||
threads = 0;
|
||
|
||
int del = THREADS_DELETE_CHUNKS;
|
||
while (!m_tbDeleted.empty() && del--) { // Moins rapide que le bout en dessous, mais -beaucoup- plus stable.
|
||
m_tbDeleted.back()->FlushVBO();
|
||
m_tbDeleted.back()->~Chunk();
|
||
m_tbDeleted.pop_back();
|
||
}
|
||
|
||
/*while (!m_tbDeleted.empty() && !frameDelete) {
|
||
if (m_tbDeleted.back()) {
|
||
m_tbDeleted.back()->FlushVBO();
|
||
delThList[threads] =
|
||
std::async(std::launch::async,
|
||
[](Chunk* chunk) { delete chunk; }, m_tbDeleted.back());
|
||
m_tbDeleted.pop_back();
|
||
if (++threads > THREADS_DELETE_CHUNKS) frameDelete = FRAMES_DELETE_CHUNKS;
|
||
}
|
||
else m_tbDeleted.pop_back();
|
||
}*/
|
||
|
||
for (int x = 0; x < threads; ++x) {
|
||
delThList[x].wait();
|
||
delThList[x].get();
|
||
}
|
||
}
|
||
|
||
int World::GettbDeleted() const { return m_tbDeleted.size(); } |