From 7957a12b840c4856e3b4275f49ec2bac484b1add Mon Sep 17 00:00:00 2001 From: MihailRis Date: Fri, 17 May 2024 21:37:02 +0300 Subject: [PATCH] format fix --- src/voxels/Chunks.cpp | 699 +++++++++++++++++++++--------------------- 1 file changed, 356 insertions(+), 343 deletions(-) diff --git a/src/voxels/Chunks.cpp b/src/voxels/Chunks.cpp index 42f70114..63919499 100644 --- a/src/voxels/Chunks.cpp +++ b/src/voxels/Chunks.cpp @@ -16,62 +16,67 @@ #include #include -Chunks::Chunks(uint32_t w, uint32_t d, - int32_t ox, int32_t oz, - WorldFiles* wfile, - LevelEvents* events, - const Content* content) - : contentIds(content->getIndices()), - chunks(w*d), - chunksSecond(w*d), - w(w), d(d), ox(ox), oz(oz), - worldFiles(wfile), - events(events) { - volume = (size_t)w*(size_t)d; - chunksCount = 0; +Chunks::Chunks( + uint32_t w, uint32_t d, + int32_t ox, int32_t oz, + WorldFiles* wfile, + LevelEvents* events, + const Content* content +) : contentIds(content->getIndices()), + chunks(w*d), + chunksSecond(w*d), + w(w), d(d), ox(ox), oz(oz), + worldFiles(wfile), + events(events) +{ + volume = static_cast(w)*static_cast(d); + chunksCount = 0; } voxel* Chunks::get(int32_t x, int32_t y, int32_t z) { - x -= ox * CHUNK_W; - z -= oz * CHUNK_D; - int cx = floordiv(x, CHUNK_W); - int cy = floordiv(y, CHUNK_H); - int cz = floordiv(z, CHUNK_D); - if (cx < 0 || cy < 0 || cz < 0 || cx >= int(w) || cy >= 1 || cz >= int(d)) - return nullptr; - auto& chunk = chunks[cz * w + cx]; // not thread safe - if (chunk == nullptr) - return nullptr; - int lx = x - cx * CHUNK_W; - int ly = y - cy * CHUNK_H; - int lz = z - cz * CHUNK_D; - return &chunk->voxels[(ly * CHUNK_D + lz) * CHUNK_W + lx]; + x -= ox * CHUNK_W; + z -= oz * CHUNK_D; + int cx = floordiv(x, CHUNK_W); + int cy = floordiv(y, CHUNK_H); + int cz = floordiv(z, CHUNK_D); + if (cx < 0 || cy < 0 || cz < 0 || cx >= int(w) || cy >= 1 || cz >= int(d)) { + return nullptr; + } + auto& chunk = chunks[cz * w + cx]; // not thread safe + if (chunk == nullptr) { + return nullptr; + } + int lx = x - cx * CHUNK_W; + int ly = y - cy * CHUNK_H; + int lz = z - cz * CHUNK_D; + return &chunk->voxels[(ly * CHUNK_D + lz) * CHUNK_W + lx]; } const AABB* Chunks::isObstacleAt(float x, float y, float z){ - int ix = floor(x); - int iy = floor(y); - int iz = floor(z); - voxel* v = get(ix, iy, iz); - if (v == nullptr) { - if (iy >= CHUNK_H) { - return nullptr; - } else { - static const AABB empty; - return ∅ - } - } - const Block* def = contentIds->getBlockDef(v->id); - if (def->obstacle) { - const auto& boxes = def->rotatable - ? def->rt.hitboxes[v->rotation()] - : def->hitboxes; - for (const auto& hitbox : boxes) { - if (hitbox.contains({x - ix, y - iy, z - iz})) - return &hitbox; + int ix = floor(x); + int iy = floor(y); + int iz = floor(z); + voxel* v = get(ix, iy, iz); + if (v == nullptr) { + if (iy >= CHUNK_H) { + return nullptr; + } else { + static const AABB empty; + return ∅ } - } - return nullptr; + } + const Block* def = contentIds->getBlockDef(v->id); + if (def->obstacle) { + const auto& boxes = def->rotatable + ? def->rt.hitboxes[v->rotation()] + : def->hitboxes; + for (const auto& hitbox : boxes) { + if (hitbox.contains({x - ix, y - iy, z - iz})) { + return &hitbox; + } + } + } + return nullptr; } bool Chunks::isSolidBlock(int32_t x, int32_t y, int32_t z) { @@ -89,159 +94,166 @@ bool Chunks::isReplaceableBlock(int32_t x, int32_t y, int32_t z) { } bool Chunks::isObstacleBlock(int32_t x, int32_t y, int32_t z) { - voxel* v = get(x, y, z); - if (v == nullptr) - return false; - return contentIds->getBlockDef(v->id)->obstacle; + voxel* v = get(x, y, z); + if (v == nullptr) + return false; + return contentIds->getBlockDef(v->id)->obstacle; } ubyte Chunks::getLight(int32_t x, int32_t y, int32_t z, int channel){ - x -= ox * CHUNK_W; - z -= oz * CHUNK_D; - int cx = floordiv(x, CHUNK_W); - int cy = floordiv(y, CHUNK_H); - int cz = floordiv(z, CHUNK_D); - if (cx < 0 || cy < 0 || cz < 0 || cx >= int(w) || cy >= 1 || cz >= int(d)) - return 0; - const auto& chunk = chunks[(cy * d + cz) * w + cx]; - if (chunk == nullptr) - return 0; - int lx = x - cx * CHUNK_W; - int ly = y - cy * CHUNK_H; - int lz = z - cz * CHUNK_D; - return chunk->lightmap.get(lx, ly, lz, channel); + x -= ox * CHUNK_W; + z -= oz * CHUNK_D; + int cx = floordiv(x, CHUNK_W); + int cy = floordiv(y, CHUNK_H); + int cz = floordiv(z, CHUNK_D); + if (cx < 0 || cy < 0 || cz < 0 || cx >= int(w) || cy >= 1 || cz >= int(d)) { + return 0; + } + const auto& chunk = chunks[(cy * d + cz) * w + cx]; + if (chunk == nullptr) { + return 0; + } + int lx = x - cx * CHUNK_W; + int ly = y - cy * CHUNK_H; + int lz = z - cz * CHUNK_D; + return chunk->lightmap.get(lx, ly, lz, channel); } light_t Chunks::getLight(int32_t x, int32_t y, int32_t z){ - x -= ox * CHUNK_W; - z -= oz * CHUNK_D; - int cx = floordiv(x, CHUNK_W); - int cy = floordiv(y, CHUNK_H); - int cz = floordiv(z, CHUNK_D); - if (cx < 0 || cy < 0 || cz < 0 || cx >= int(w) || cy >= 1 || cz >= int(d)) - return 0; - const auto& chunk = chunks[(cy * d + cz) * w + cx]; - if (chunk == nullptr) - return 0; - int lx = x - cx * CHUNK_W; - int ly = y - cy * CHUNK_H; - int lz = z - cz * CHUNK_D; - return chunk->lightmap.get(lx,ly,lz); + x -= ox * CHUNK_W; + z -= oz * CHUNK_D; + int cx = floordiv(x, CHUNK_W); + int cy = floordiv(y, CHUNK_H); + int cz = floordiv(z, CHUNK_D); + if (cx < 0 || cy < 0 || cz < 0 || cx >= int(w) || cy >= 1 || cz >= int(d)) { + return 0; + } + const auto& chunk = chunks[(cy * d + cz) * w + cx]; + if (chunk == nullptr) { + return 0; + } + int lx = x - cx * CHUNK_W; + int ly = y - cy * CHUNK_H; + int lz = z - cz * CHUNK_D; + return chunk->lightmap.get(lx,ly,lz); } -Chunk* Chunks::getChunkByVoxel(int32_t x, int32_t y, int32_t z){ - if (y < 0 || y >= CHUNK_H) - return nullptr; - x -= ox * CHUNK_W; - z -= oz * CHUNK_D; - int cx = floordiv(x, CHUNK_W); - int cz = floordiv(z, CHUNK_D); - if (cx < 0 || cz < 0 || cx >= int(w) || cz >= int(d)) - return nullptr; - return chunks[cz * w + cx].get(); +Chunk* Chunks::getChunkByVoxel(int32_t x, int32_t y, int32_t z) { + if (y < 0 || y >= CHUNK_H) + return nullptr; + x -= ox * CHUNK_W; + z -= oz * CHUNK_D; + int cx = floordiv(x, CHUNK_W); + int cz = floordiv(z, CHUNK_D); + if (cx < 0 || cz < 0 || cx >= int(w) || cz >= int(d)) + return nullptr; + return chunks[cz * w + cx].get(); } Chunk* Chunks::getChunk(int x, int z){ - x -= ox; - z -= oz; - if (x < 0 || z < 0 || x >= int(w) || z >= int(d)) - return nullptr; - return chunks[z * w + x].get(); + x -= ox; + z -= oz; + if (x < 0 || z < 0 || x >= int(w) || z >= int(d)) + return nullptr; + return chunks[z * w + x].get(); } -void Chunks::set(int32_t x, int32_t y, int32_t z, uint32_t id, uint8_t states){ - if (y < 0 || y >= CHUNK_H) - return; - x -= ox * CHUNK_W; - z -= oz * CHUNK_D; - int cx = floordiv(x, CHUNK_W); - int cz = floordiv(z, CHUNK_D); - if (cx < 0 || cz < 0 || cx >= int(w) || cz >= int(d)) - return; - Chunk* chunk = chunks[cz * w + cx].get(); - if (chunk == nullptr) - return; - int lx = x - cx * CHUNK_W; - int lz = z - cz * CHUNK_D; +void Chunks::set(int32_t x, int32_t y, int32_t z, uint32_t id, uint8_t states) { + if (y < 0 || y >= CHUNK_H) + return; + x -= ox * CHUNK_W; + z -= oz * CHUNK_D; + int cx = floordiv(x, CHUNK_W); + int cz = floordiv(z, CHUNK_D); + if (cx < 0 || cz < 0 || cx >= int(w) || cz >= int(d)) + return; + Chunk* chunk = chunks[cz * w + cx].get(); + if (chunk == nullptr) + return; + int lx = x - cx * CHUNK_W; + int lz = z - cz * CHUNK_D; voxel& vox = chunk->voxels[(y * CHUNK_D + lz) * CHUNK_W + lx]; - auto def = contentIds->getBlockDef(vox.id); - if (def->inventorySize == 0) - chunk->removeBlockInventory(lx, y, lz); - vox.id = id; - vox.states = states; + auto def = contentIds->getBlockDef(vox.id); + if (def->inventorySize == 0) + chunk->removeBlockInventory(lx, y, lz); + vox.id = id; + vox.states = states; - chunk->setUnsaved(true); - chunk->setModified(true); + chunk->setUnsaved(true); + chunk->setModified(true); - if (y < chunk->bottom) chunk->bottom = y; - else if (y + 1 > chunk->top) chunk->top = y + 1; - else if (id == 0) chunk->updateHeights(); + if (y < chunk->bottom) chunk->bottom = y; + else if (y + 1 > chunk->top) chunk->top = y + 1; + else if (id == 0) chunk->updateHeights(); - if (lx == 0 && (chunk = getChunk(cx+ox-1, cz+oz))) - chunk->setModified(true); - if (lz == 0 && (chunk = getChunk(cx+ox, cz+oz-1))) - chunk->setModified(true); + if (lx == 0 && (chunk = getChunk(cx+ox-1, cz+oz))) + chunk->setModified(true); + if (lz == 0 && (chunk = getChunk(cx+ox, cz+oz-1))) + chunk->setModified(true); - if (lx == CHUNK_W-1 && (chunk = getChunk(cx+ox+1, cz+oz))) - chunk->setModified(true); - if (lz == CHUNK_D-1 && (chunk = getChunk(cx+ox, cz+oz+1))) - chunk->setModified(true); + if (lx == CHUNK_W-1 && (chunk = getChunk(cx+ox+1, cz+oz))) + chunk->setModified(true); + if (lz == CHUNK_D-1 && (chunk = getChunk(cx+ox, cz+oz+1))) + chunk->setModified(true); } -voxel* Chunks::rayCast(glm::vec3 start, - glm::vec3 dir, - float maxDist, - glm::vec3& end, - glm::ivec3& norm, - glm::ivec3& iend) { - float px = start.x; - float py = start.y; - float pz = start.z; +voxel* Chunks::rayCast( + glm::vec3 start, + glm::vec3 dir, + float maxDist, + glm::vec3& end, + glm::ivec3& norm, + glm::ivec3& iend +) { + float px = start.x; + float py = start.y; + float pz = start.z; - float dx = dir.x; - float dy = dir.y; - float dz = dir.z; + float dx = dir.x; + float dy = dir.y; + float dz = dir.z; - float t = 0.0f; - int ix = floor(px); - int iy = floor(py); - int iz = floor(pz); + float t = 0.0f; + int ix = floor(px); + int iy = floor(py); + int iz = floor(pz); - int stepx = (dx > 0.0f) ? 1 : -1; - int stepy = (dy > 0.0f) ? 1 : -1; - int stepz = (dz > 0.0f) ? 1 : -1; + int stepx = (dx > 0.0f) ? 1 : -1; + int stepy = (dy > 0.0f) ? 1 : -1; + int stepz = (dz > 0.0f) ? 1 : -1; - constexpr float infinity = std::numeric_limits::infinity(); + constexpr float infinity = std::numeric_limits::infinity(); - float txDelta = (dx == 0.0f) ? infinity : abs(1.0f / dx); - float tyDelta = (dy == 0.0f) ? infinity : abs(1.0f / dy); - float tzDelta = (dz == 0.0f) ? infinity : abs(1.0f / dz); + float txDelta = (dx == 0.0f) ? infinity : abs(1.0f / dx); + float tyDelta = (dy == 0.0f) ? infinity : abs(1.0f / dy); + float tzDelta = (dz == 0.0f) ? infinity : abs(1.0f / dz); - float xdist = (stepx > 0) ? (ix + 1 - px) : (px - ix); - float ydist = (stepy > 0) ? (iy + 1 - py) : (py - iy); - float zdist = (stepz > 0) ? (iz + 1 - pz) : (pz - iz); + float xdist = (stepx > 0) ? (ix + 1 - px) : (px - ix); + float ydist = (stepy > 0) ? (iy + 1 - py) : (py - iy); + float zdist = (stepz > 0) ? (iz + 1 - pz) : (pz - iz); - float txMax = (txDelta < infinity) ? txDelta * xdist : infinity; - float tyMax = (tyDelta < infinity) ? tyDelta * ydist : infinity; - float tzMax = (tzDelta < infinity) ? tzDelta * zdist : infinity; + float txMax = (txDelta < infinity) ? txDelta * xdist : infinity; + float tyMax = (tyDelta < infinity) ? tyDelta * ydist : infinity; + float tzMax = (tzDelta < infinity) ? tzDelta * zdist : infinity; - int steppedIndex = -1; + int steppedIndex = -1; - while (t <= maxDist){ - voxel* voxel = get(ix, iy, iz); - if (voxel == nullptr){ return nullptr; } - - const Block* def = contentIds->getBlockDef(voxel->id); - if (def->selectable){ - end.x = px + t * dx; - end.y = py + t * dy; - end.z = pz + t * dz; - iend.x = ix; - iend.y = iy; - iend.z = iz; - - if (!def->rt.solid) { + while (t <= maxDist){ + voxel* voxel = get(ix, iy, iz); + if (voxel == nullptr){ + return nullptr; + } + const Block* def = contentIds->getBlockDef(voxel->id); + if (def->selectable){ + end.x = px + t * dx; + end.y = py + t * dy; + end.z = pz + t * dz; + iend.x = ix; + iend.y = iy; + iend.z = iz; + + if (!def->rt.solid) { const std::vector& hitboxes = def->rotatable ? def->rt.hitboxes[voxel->rotation()] : def->hitboxes; @@ -253,7 +265,7 @@ voxel* Chunks::rayCast(glm::vec3 start, for (const auto& box : hitboxes) { scalar_t boxDistance; - glm::ivec3 boxNorm; + glm::ivec3 boxNorm; if (ray.intersectAABB(iend, box, maxDist, boxNorm, boxDistance) > RayRelation::None && boxDistance < distance) { hit = true; distance = boxDistance; @@ -263,94 +275,95 @@ voxel* Chunks::rayCast(glm::vec3 start, } if (hit) return voxel; - } else { - iend.x = ix; - iend.y = iy; - iend.z = iz; + } else { + iend.x = ix; + iend.y = iy; + iend.z = iz; - norm.x = norm.y = norm.z = 0; - if (steppedIndex == 0) norm.x = -stepx; - if (steppedIndex == 1) norm.y = -stepy; - if (steppedIndex == 2) norm.z = -stepz; - return voxel; - } - } - if (txMax < tyMax) { - if (txMax < tzMax) { - ix += stepx; - t = txMax; - txMax += txDelta; - steppedIndex = 0; - } else { - iz += stepz; - t = tzMax; - tzMax += tzDelta; - steppedIndex = 2; - } - } else { - if (tyMax < tzMax) { - iy += stepy; - t = tyMax; - tyMax += tyDelta; - steppedIndex = 1; - } else { - iz += stepz; - t = tzMax; - tzMax += tzDelta; - steppedIndex = 2; - } - } - } - iend.x = ix; - iend.y = iy; - iend.z = iz; + norm.x = norm.y = norm.z = 0; + if (steppedIndex == 0) norm.x = -stepx; + if (steppedIndex == 1) norm.y = -stepy; + if (steppedIndex == 2) norm.z = -stepz; + return voxel; + } + } + if (txMax < tyMax) { + if (txMax < tzMax) { + ix += stepx; + t = txMax; + txMax += txDelta; + steppedIndex = 0; + } else { + iz += stepz; + t = tzMax; + tzMax += tzDelta; + steppedIndex = 2; + } + } else { + if (tyMax < tzMax) { + iy += stepy; + t = tyMax; + tyMax += tyDelta; + steppedIndex = 1; + } else { + iz += stepz; + t = tzMax; + tzMax += tzDelta; + steppedIndex = 2; + } + } + } + iend.x = ix; + iend.y = iy; + iend.z = iz; - end.x = px + t * dx; - end.y = py + t * dy; - end.z = pz + t * dz; - norm.x = norm.y = norm.z = 0; - return nullptr; + end.x = px + t * dx; + end.y = py + t * dy; + end.z = pz + t * dz; + norm.x = norm.y = norm.z = 0; + return nullptr; } glm::vec3 Chunks::rayCastToObstacle(glm::vec3 start, glm::vec3 dir, float maxDist) { - float px = start.x; - float py = start.y; - float pz = start.z; + float px = start.x; + float py = start.y; + float pz = start.z; - float dx = dir.x; - float dy = dir.y; - float dz = dir.z; + float dx = dir.x; + float dy = dir.y; + float dz = dir.z; - float t = 0.0f; - int ix = floor(px); - int iy = floor(py); - int iz = floor(pz); + float t = 0.0f; + int ix = floor(px); + int iy = floor(py); + int iz = floor(pz); - int stepx = (dx > 0.0f) ? 1 : -1; - int stepy = (dy > 0.0f) ? 1 : -1; - int stepz = (dz > 0.0f) ? 1 : -1; + int stepx = (dx > 0.0f) ? 1 : -1; + int stepy = (dy > 0.0f) ? 1 : -1; + int stepz = (dz > 0.0f) ? 1 : -1; - constexpr float infinity = std::numeric_limits::infinity(); + constexpr float infinity = std::numeric_limits::infinity(); - float txDelta = (dx == 0.0f) ? infinity : abs(1.0f / dx); - float tyDelta = (dy == 0.0f) ? infinity : abs(1.0f / dy); - float tzDelta = (dz == 0.0f) ? infinity : abs(1.0f / dz); + float txDelta = (dx == 0.0f) ? infinity : abs(1.0f / dx); + float tyDelta = (dy == 0.0f) ? infinity : abs(1.0f / dy); + float tzDelta = (dz == 0.0f) ? infinity : abs(1.0f / dz); - float xdist = (stepx > 0) ? (ix + 1 - px) : (px - ix); - float ydist = (stepy > 0) ? (iy + 1 - py) : (py - iy); - float zdist = (stepz > 0) ? (iz + 1 - pz) : (pz - iz); + float xdist = (stepx > 0) ? (ix + 1 - px) : (px - ix); + float ydist = (stepy > 0) ? (iy + 1 - py) : (py - iy); + float zdist = (stepz > 0) ? (iz + 1 - pz) : (pz - iz); - float txMax = (txDelta < infinity) ? txDelta * xdist : infinity; - float tyMax = (tyDelta < infinity) ? tyDelta * ydist : infinity; - float tzMax = (tzDelta < infinity) ? tzDelta * zdist : infinity; + float txMax = (txDelta < infinity) ? txDelta * xdist : infinity; + float tyMax = (tyDelta < infinity) ? tyDelta * ydist : infinity; + float tzMax = (tzDelta < infinity) ? tzDelta * zdist : infinity; - while (t <= maxDist) { - voxel* voxel = get(ix, iy, iz); - if (voxel == nullptr) { return glm::vec3(px + t * dx, py + t * dy, pz + t * dz); } - - const Block* def = contentIds->getBlockDef(voxel->id); - if (def->obstacle) { - if (!def->rt.solid) { + while (t <= maxDist) { + voxel* voxel = get(ix, iy, iz); + if (voxel == nullptr) { + return glm::vec3(px + t * dx, py + t * dy, pz + t * dz); + } + const Block* def = contentIds->getBlockDef(voxel->id); + if (def->obstacle) { + if (!def->rt.solid) { const std::vector& hitboxes = def->rotatable ? def->rt.hitboxes[voxel->rotation()] : def->modelBoxes; @@ -365,98 +378,98 @@ glm::vec3 Chunks::rayCastToObstacle(glm::vec3 start, glm::vec3 dir, float maxDis return start + (dir * glm::vec3(distance)); } } - } - else { - return glm::vec3(px + t * dx, py + t * dy, pz + t * dz); - } - } - if (txMax < tyMax) { - if (txMax < tzMax) { - ix += stepx; - t = txMax; - txMax += txDelta; - } - else { - iz += stepz; - t = tzMax; - tzMax += tzDelta; - } - } - else { - if (tyMax < tzMax) { - iy += stepy; - t = tyMax; - tyMax += tyDelta; - } - else { - iz += stepz; - t = tzMax; - tzMax += tzDelta; - } - } - } - return glm::vec3(px + maxDist * dx, py + maxDist * dy, pz + maxDist * dz); + } + else { + return glm::vec3(px + t * dx, py + t * dy, pz + t * dz); + } + } + if (txMax < tyMax) { + if (txMax < tzMax) { + ix += stepx; + t = txMax; + txMax += txDelta; + } + else { + iz += stepz; + t = tzMax; + tzMax += tzDelta; + } + } + else { + if (tyMax < tzMax) { + iy += stepy; + t = tyMax; + tyMax += tyDelta; + } + else { + iz += stepz; + t = tzMax; + tzMax += tzDelta; + } + } + } + return glm::vec3(px + maxDist * dx, py + maxDist * dy, pz + maxDist * dz); } void Chunks::setCenter(int32_t x, int32_t z) { - int cx = floordiv(x, CHUNK_W); - int cz = floordiv(z, CHUNK_D); - cx -= ox + w / 2; - cz -= oz + d / 2; - if (cx | cz) { - translate(cx,cz); - } + int cx = floordiv(x, CHUNK_W); + int cz = floordiv(z, CHUNK_D); + cx -= ox + w / 2; + cz -= oz + d / 2; + if (cx | cz) { + translate(cx,cz); + } } void Chunks::translate(int32_t dx, int32_t dz) { auto& regions = worldFiles->getRegions(); - for (uint i = 0; i < volume; i++){ - chunksSecond[i] = nullptr; - } - for (uint32_t z = 0; z < d; z++){ - for (uint32_t x = 0; x < w; x++){ - auto chunk = chunks[z * w + x]; - int nx = x - dx; - int nz = z - dz; - if (chunk == nullptr) - continue; - if (nx < 0 || nz < 0 || nx >= int(w) || nz >= int(d)){ - events->trigger(EVT_CHUNK_HIDDEN, chunk.get()); + for (uint i = 0; i < volume; i++){ + chunksSecond[i] = nullptr; + } + for (uint32_t z = 0; z < d; z++) { + for (uint32_t x = 0; x < w; x++) { + auto chunk = chunks[z * w + x]; + int nx = x - dx; + int nz = z - dz; + if (chunk == nullptr) + continue; + if (nx < 0 || nz < 0 || nx >= int(w) || nz >= int(d)) { + events->trigger(EVT_CHUNK_HIDDEN, chunk.get()); regions.put(chunk.get()); - chunksCount--; - continue; - } - chunksSecond[nz * w + nx] = chunk; - } - } - std::swap(chunks, chunksSecond); + chunksCount--; + continue; + } + chunksSecond[nz * w + nx] = chunk; + } + } + std::swap(chunks, chunksSecond); - ox += dx; - oz += dz; + ox += dx; + oz += dz; } void Chunks::resize(uint32_t newW, uint32_t newD) { - if (newW < w) { - int delta = w - newW; - translate(delta / 2, 0); - translate(-delta, 0); - translate(delta, 0); - } - if (newD < d) { - int delta = d - newD; - translate(0, delta / 2); - translate(0, -delta); - translate(0, delta); - } - const int newVolume = newW * newD; + if (newW < w) { + int delta = w - newW; + translate(delta / 2, 0); + translate(-delta, 0); + translate(delta, 0); + } + if (newD < d) { + int delta = d - newD; + translate(0, delta / 2); + translate(0, -delta); + translate(0, delta); + } + const int newVolume = newW * newD; std::vector> newChunks(newVolume); std::vector> newChunksSecond(newVolume); - for (int z = 0; z < int(d) && z < int(newD); z++) { - for (int x = 0; x < int(w) && x < int(newW); x++) { - newChunks[z * newW + x] = chunks[z * w + x]; - } - } + for (int z = 0; z < int(d) && z < int(newD); z++) { + for (int x = 0; x < int(w) && x < int(newW); x++) { + newChunks[z * newW + x] = chunks[z * w + x]; + } + } w = newW; d = newD; volume = newVolume; @@ -465,35 +478,35 @@ void Chunks::resize(uint32_t newW, uint32_t newD) { } void Chunks::_setOffset(int32_t x, int32_t z) { - ox = x; - oz = z; + ox = x; + oz = z; } bool Chunks::putChunk(std::shared_ptr chunk) { - int x = chunk->x; - int z = chunk->z; - x -= ox; - z -= oz; - if (x < 0 || z < 0 || x >= int(w) || z >= int(d)) - return false; - chunks[z * w + x] = chunk; - chunksCount++; - return true; + int x = chunk->x; + int z = chunk->z; + x -= ox; + z -= oz; + if (x < 0 || z < 0 || x >= int(w) || z >= int(d)) + return false; + chunks[z * w + x] = chunk; + chunksCount++; + return true; } void Chunks::saveAndClear(){ auto& regions = worldFiles->getRegions(); - for (size_t i = 0; i < volume; i++){ - Chunk* chunk = chunks[i].get(); - chunks[i] = nullptr; - if (chunk == nullptr || !chunk->isLighted()) + for (size_t i = 0; i < volume; i++){ + Chunk* chunk = chunks[i].get(); + chunks[i] = nullptr; + if (chunk == nullptr || !chunk->isLighted()) continue; - bool lightsUnsaved = !chunk->isLoadedLights() && + bool lightsUnsaved = !chunk->isLoadedLights() && worldFiles->doesWriteLights(); if (!chunk->isUnsaved() && !lightsUnsaved) continue; regions.put(chunk); - } - chunksCount = 0; + } + chunksCount = 0; }