VoxelWorld.cpp

浏览该文件的文档.

#include "voxel/VoxelWorld.h"
 
#include "procgen/heightmap/TerrainSampler.h"
 
#include "data/ByteData.h"
#include "graphics/Graphics.h"
#include "graphics/IGraphics3D.h"
#include "thread/Thread.h"
 
#include <algorithm>
#include <cmath>
#include <cstring>
#include <limits>
#include <thread>
 
namespace eve::voxel {
 
VoxelWorld::VoxelWorld() = default;
VoxelWorld::VoxelWorld(const CubeTypeRegistry &types) : types_(types) {}
VoxelWorld::~VoxelWorld() { waitStreamJobs(); }
 
void VoxelWorld::setTerrainParams(uint32_t seed, uint8_t top, uint8_t sub, uint8_t stone, float baseHeight,
                                  float amplitude, float scale) {
    waitStreamJobs();
    if (!terrainSampler_) terrainSampler_ = std::make_unique<procgen::TerrainSampler>();
    terrainSampler_->setSeed(seed);
    terrainSampler_->setBase(0.f);
    terrainSampler_->setAmplitude(1.f);
    terrainSampler_->setClamp(true, 0.f, 1.f);
    terrainSampler_->setFrequency(scale > 0.f ? scale : 1.f / 32.f);
    terrainTop_       = top;
    terrainSub_       = sub;
    terrainStone_     = stone;
    terrainBase_      = baseHeight;
    terrainAmplitude_ = amplitude < 0.f ? 0.f : amplitude;
    terrainEnabled_   = true;
}
 
void VoxelWorld::setTerrainParam(const std::string &key, float value) {
    waitStreamJobs();
    if (!terrainSampler_) terrainSampler_ = std::make_unique<procgen::TerrainSampler>();
    if (key == "seed") {
        terrainSampler_->setSeed(uint32_t(value));
    } else if (key == "top") {
        terrainTop_ = uint8_t(value);
    } else if (key == "sub") {
        terrainSub_ = uint8_t(value);
    } else if (key == "stone") {
        terrainStone_ = uint8_t(value);
    } else if (key == "sand") {
        terrainSand_ = uint8_t(value);
    } else if (key == "base") {
        terrainBase_ = value;
    } else if (key == "amplitude") {
        terrainAmplitude_ = value < 0.f ? 0.f : value;
    } else if (key == "scale" || key == "frequency") {
        terrainSampler_->setFrequency(value > 0.f ? value : 1.f / 32.f);
    } else if (key == "octaves") {
        terrainSampler_->setOctaves(int(value));
    } else if (key == "lacunarity") {
        terrainSampler_->setLacunarity(value);
    } else if (key == "gain") {
        terrainSampler_->setGain(value);
    } else if (key == "ridge") {
        terrainSampler_->setRidge(value);
    } else if (key == "warp") {
        terrainSampler_->setWarp(value);
    } else if (key == "exponent") {
        terrainSampler_->setExponent(value);
    } else if (key == "continent") {
        terrainSampler_->setContinent(value);
    } else if (key == "island") {
        terrainSampler_->setIsland(value);
    } else if (key == "coast") {
        terrainSampler_->setCoastSoftness(value);
    } else if (key == "worldWidth") {
        terrainSampler_->setWorldSize(int(value), terrainSampler_->getWorldHeight());
    } else if (key == "worldHeight") {
        terrainSampler_->setWorldSize(terrainSampler_->getWorldWidth(), int(value));
    } else if (key == "sandLevel") {
        sandLevel_ = value;
    } else if (key == "enable") {
        terrainEnabled_ = value != 0.f;
    }
}
 
void VoxelWorld::disableTerrain() {
    waitStreamJobs();
    terrainEnabled_ = false;
    terrainAssetEnabled_ = false;
    terrainAsset_.clear();
}
 
namespace {
 
void sampleTerrainColumn(const procgen::TerrainSampler *sampler, float base, float amp, uint8_t topTexDefault,
                         uint8_t sandTex, float sandLevel, int wx, int wz, int &height, uint8_t &topTex) {
    if (!sampler) {
        height = int(base);
        topTex = topTexDefault;
        return;
    }
    const float e = sampler->sample(float(wx), float(wz));
    height = int(std::floor(base + amp * e));
    topTex = (sandLevel > 0.f && sandTex != 0 && e <= sandLevel) ? sandTex : topTexDefault;
}
 
}  // namespace
 
namespace {
// Cap remesh worker count: enough to parallelize chunk meshing without
// oversubscribing small devices / browser pthread pools.
constexpr int kMaxRemeshWorkers = 4;
constexpr int kMaxStreamJobs = 8;
}  // namespace
 
Chunk *VoxelWorld::getOrCreateChunk(int cx, int cy, int cz) {
    const uint64_t k = key(cx, cy, cz);
    auto it = chunks_.find(k);
    if (it != chunks_.end()) return it->second.get();
    auto chunk = std::make_unique<Chunk>(cx, cy, cz);
    Chunk *raw = chunk.get();
    chunks_.emplace(k, std::move(chunk));
    return raw;
}
 
Chunk *VoxelWorld::getChunk(int cx, int cy, int cz) {
    auto it = chunks_.find(key(cx, cy, cz));
    return it == chunks_.end() ? nullptr : it->second.get();
}
 
const Chunk *VoxelWorld::getChunk(int cx, int cy, int cz) const {
    auto it = chunks_.find(key(cx, cy, cz));
    return it == chunks_.end() ? nullptr : it->second.get();
}
 
bool VoxelWorld::hasChunk(int cx, int cy, int cz) const {
    return chunks_.find(key(cx, cy, cz)) != chunks_.end();
}
 
void VoxelWorld::removeChunk(int cx, int cy, int cz) {
    if (chunks_.erase(key(cx, cy, cz)) > 0) ++revision_;
}
 
void VoxelWorld::clear() {
    waitStreamJobs();
    const bool changed = !chunks_.empty();
    chunks_.clear();
    visible_.clear();
    visibleChunkKeys_.clear();
    if (changed) ++revision_;
}
 
bool VoxelWorld::loadTerrainAsset(data::ByteData *bytes, float heightOffset, float heightScale) {
    waitStreamJobs();
    if (!bytes || !std::isfinite(heightOffset) || !std::isfinite(heightScale)) return false;
    std::string error;
    if (!terrainAsset_.open(static_cast<const uint8_t *>(bytes->getData()), bytes->getSize(),
                            &error)) return false;
    terrainAssetOffset_ = heightOffset;
    terrainAssetScale_ = heightScale;
    terrainAssetEnabled_ = true;
    return true;
}
 
procgen::TerrainStreamStats VoxelWorld::streamTerrainAssetAround(int worldX, int worldZ,
                                                                 int radiusChunks,
                                                                 int maxLoads) {
    if (!terrainAssetEnabled_) return {};
    return terrainAsset_.streamAround(worldX, worldZ, radiusChunks, maxLoads);
}
 
void VoxelWorld::setTerrainAssetMaterials(uint8_t vegetation, uint8_t sand, uint8_t snow,
                                          uint8_t alpine, uint8_t riverbed) {
    terrainVegetation_ = vegetation;
    terrainAssetSand_ = sand;
    terrainSnow_ = snow;
    terrainAlpine_ = alpine;
    terrainRiverbed_ = riverbed;
}
 
int VoxelWorld::terrainHeightAt(int wx, int wz) const {
    if (terrainAssetEnabled_) {
        float storedHeight = 0.f;
        if (terrainAsset_.sampleHeight(float(wx), float(wz), storedHeight))
            return int(std::floor(terrainAssetOffset_ + terrainAssetScale_ * storedHeight));
    }
    if (terrainEnabled_) {
        if (!terrainSampler_) return int(std::floor(terrainBase_));
        const float e = terrainSampler_->sample(float(wx), float(wz));
        return int(std::floor(terrainBase_ + terrainAmplitude_ * e));
    }
    return int(std::floor(terrainAssetOffset_));
}
 
uint8_t VoxelWorld::terrainSurfaceAt(int wx, int wz) const {
    if (!terrainAssetEnabled_) return terrainTop_;
    procgen::TerrainSample sample;
    if (!terrainAsset_.sampleCell(wx, wz, sample)) return terrainTop_;
    switch (sample.biome) {
    case procgen::Biome::Ocean:
    case procgen::Biome::Beach:
    case procgen::Biome::Desert:
        return terrainAssetSand_;
    case procgen::Biome::Tundra:
    case procgen::Biome::Taiga:
        return terrainSnow_;
    case procgen::Biome::Alpine:
        return terrainAlpine_;
    case procgen::Biome::River:
        return terrainRiverbed_;
    default:
        return terrainVegetation_;
    }
}
 
void VoxelWorld::setStreamCacheChunks(int extraChunks) {
    streamCacheChunks_ = extraChunks < 0 ? 0 : extraChunks;
}
 
int VoxelWorld::unloadChunksOutside(int centerX, int centerY, int centerZ, int radiusChunks) {
    if (radiusChunks < 0) return 0;
    const int64_t r2 = int64_t(radiusChunks) * int64_t(radiusChunks);
    std::vector<uint64_t> evict;
    evict.reserve(chunks_.size() / 4);
    for (auto &kv : chunks_) {
        int cx, cy, cz;
        unpackKey(kv.first, cx, cy, cz);
        const int64_t dx = int64_t(cx) - centerX;
        const int64_t dy = int64_t(cy) - centerY;
        const int64_t dz = int64_t(cz) - centerZ;
        if (dx * dx + dy * dy + dz * dz > r2) evict.push_back(kv.first);
    }
    for (uint64_t k : evict) chunks_.erase(k);
    if (!evict.empty()) {
        // Batch pointers may dangle after eviction; force re-selection.
        visible_.clear();
        visibleChunkKeys_.clear();
        ++revision_;
    }
    return int(evict.size());
}
 
void VoxelWorld::fillChunkTerrain(Chunk &c, int nx, int ny, int nz) const {
    const int wy0 = ny * kChunkSize;
    for (int lz = 0; lz < kChunkSize; ++lz)
        for (int lx = 0; lx < kChunkSize; ++lx) {
            int h = 0;
            uint8_t surface = terrainTop_;
            const int wx = nx * kChunkSize + lx;
            const int wz = nz * kChunkSize + lz;
            if (terrainAssetEnabled_) {
                h = terrainHeightAt(wx, wz);
                surface = terrainSurfaceAt(wx, wz);
            } else {
                sampleTerrainColumn(terrainSampler_.get(), terrainBase_, terrainAmplitude_,
                                    terrainTop_, terrainSand_, sandLevel_, wx, wz, h, surface);
            }
            for (int ly = 0; ly < kChunkSize; ++ly) {
                const int wy = wy0 + ly;
                if (wy <= h - 4)
                    c.set(lx, ly, lz, terrainStone_);
                else if (wy <= h - 1)
                    c.set(lx, ly, lz, terrainSub_);
                else if (wy == h)
                    c.set(lx, ly, lz, surface);
            }
        }
}
 
StreamStats VoxelWorld::streamAround(int centerX, int centerY, int centerZ, int radiusChunks,
                                     const std::function<void(Chunk &, int, int, int)> &generator,
                                     int maxCreates) {
    StreamStats stats;
    if (radiusChunks < 0) return stats;
    if (maxCreates < 0) maxCreates = 0;
 
    const int keepRadius = radiusChunks + streamCacheChunks_;
 
    if (!generator && terrainAssetEnabled_) {
        const int assetChunk = terrainAsset_.asset().getChunkSize();
        const int worldRadius = (keepRadius + 1) * kChunkSize;
        const int assetRadius = assetChunk > 0
            ? int(std::ceil(float(worldRadius) * 1.41421356f / float(assetChunk))) + 1 : 0;
        const int assetLoads = maxCreates > 0 ? maxCreates : 0;
        terrainAsset_.streamAround(centerX * kChunkSize + kChunkSize / 2,
                                   centerZ * kChunkSize + kChunkSize / 2, assetRadius, assetLoads);
    }
 
    // Evict only past the keep radius so recently left chunks stay resident.
    stats.evicted = unloadChunksOutside(centerX, centerY, centerZ, keepRadius);
    reapRetiredStreamJobs();
    restoreRetiredInside(centerX, centerY, centerZ, keepRadius);
    dropStreamJobsOutside(centerX, centerY, centerZ, keepRadius);
    const bool asyncTerrain = maxCreates > 0 && !generator && terrainEnabled_ && !terrainAssetEnabled_;
    if (asyncTerrain)
        stats.created = harvestStreamJobs(centerX, centerY, centerZ, keepRadius, maxCreates);
 
    struct Missing {
        int d2 = 0;
        int nx = 0;
        int ny = 0;
        int nz = 0;
    };
    std::vector<Missing> missing;
    const int64_t r2 = int64_t(radiusChunks) * int64_t(radiusChunks);
    for (int dz = -radiusChunks; dz <= radiusChunks; ++dz)
        for (int dy = -radiusChunks; dy <= radiusChunks; ++dy)
            for (int dx = -radiusChunks; dx <= radiusChunks; ++dx) {
                const int64_t d2 = int64_t(dx) * dx + int64_t(dy) * dy + int64_t(dz) * dz;
                if (d2 > r2) continue;
                const int nx = centerX + dx;
                const int ny = centerY + dy;
                const int nz = centerZ + dz;
                if (hasChunk(nx, ny, nz) || isStreamJob(nx, ny, nz)) continue;
                missing.push_back({int(d2), nx, ny, nz});
            }
    std::sort(missing.begin(), missing.end(), [](const Missing &a, const Missing &b) {
        if (a.d2 != b.d2) return a.d2 < b.d2;
        if (a.nx != b.nx) return a.nx < b.nx;
        if (a.ny != b.ny) return a.ny < b.ny;
        return a.nz < b.nz;
    });
 
    if (asyncTerrain) {
        thread::JobSystem *jobs = nullptr;
        try {
            jobs = thread::Thread::create()->getJobSystem();
        } catch (...) {
            jobs = nullptr;
        }
        if (jobs && jobs->isRunning()) {
            int submitted = 0;
            for (const Missing &m : missing) {
                if (int(inflight_.size()) >= kMaxStreamJobs) break;
                if (submitted >= maxCreates) break;
                StreamJob job;
                job.cx = m.nx;
                job.cy = m.ny;
                job.cz = m.nz;
                job.chunk = std::make_unique<Chunk>(m.nx, m.ny, m.nz);
                Chunk *raw = job.chunk.get();
                try {
                    CubeTypeRegistry typesCopy = types_;
                    job.job = jobs->submit([this, raw, nx = m.nx, ny = m.ny, nz = m.nz,
                                            typesCopy = std::move(typesCopy)]() {
                        fillChunkTerrain(*raw, nx, ny, nz);
                        raw->remesh(typesCopy, nullptr, nullptr);
                    });
                } catch (...) {
                    job.job = nullptr;
                }
                if (!job.job) {
                    fillChunkTerrain(*raw, m.nx, m.ny, m.nz);
                    raw->remesh(types_, nullptr, nullptr);
                    chunks_.emplace(key(m.nx, m.ny, m.nz), std::move(job.chunk));
                    ++stats.created;
                    ++revision_;
                    continue;
                }
                inflight_.push_back(std::move(job));
                ++submitted;
            }
            stats.pending = int(missing.size() - size_t(submitted)) + int(inflight_.size());
            return stats;
        }
    }
 
    const size_t budget = maxCreates > 0 ? size_t(maxCreates) : missing.size();
    const size_t createCount = std::min(budget, missing.size());
    std::vector<Chunk *> created;
    created.reserve(createCount);
    for (size_t i = 0; i < createCount; ++i) {
        const Missing &m = missing[i];
        Chunk *c = getOrCreateChunk(m.nx, m.ny, m.nz);
        if (generator)
            generator(*c, m.nx, m.ny, m.nz);
        else if (terrainEnabled_ || terrainAssetEnabled_)
            fillChunkTerrain(*c, m.nx, m.ny, m.nz);
        created.push_back(c);
        ++stats.created;
    }
    stats.pending = int(missing.size() - createCount) + getInflightStreamCount();
 
    if (stats.created > 0) {
        ++revision_;
        remeshChunks(created, 0);
        if (maxCreates > 0) {
            static const int nbs[6][3] = {{1, 0, 0}, {-1, 0, 0}, {0, 1, 0},
                                          {0, -1, 0}, {0, 0, 1}, {0, 0, -1}};
            for (Chunk *c : created) {
                for (const auto &d : nbs) {
                    if (Chunk *n = getChunk(c->cx() + d[0], c->cy() + d[1], c->cz() + d[2]))
                        n->markDirty();
                }
            }
            remeshDirty(1, 0);
        }
    }
    return stats;
}
 
namespace {
 
void putU32(std::vector<uint8_t> &out, uint32_t v) {
    out.push_back(uint8_t(v));
    out.push_back(uint8_t(v >> 8));
    out.push_back(uint8_t(v >> 16));
    out.push_back(uint8_t(v >> 24));
}
 
void putI32(std::vector<uint8_t> &out, int32_t v) { putU32(out, uint32_t(v)); }
 
bool getU32(const uint8_t *&p, const uint8_t *end, uint32_t &out) {
    if (end - p < 4) return false;
    out = uint32_t(p[0]) | (uint32_t(p[1]) << 8) | (uint32_t(p[2]) << 16) |
          (uint32_t(p[3]) << 24);
    p += 4;
    return true;
}
 
bool getI32(const uint8_t *&p, const uint8_t *end, int32_t &out) {
    uint32_t v;
    if (!getU32(p, end, v)) return false;
    out = int32_t(v);
    return true;
}
 
}  // namespace
 
void VoxelWorld::serializeWorld(std::vector<uint8_t> &out) const {
    out.clear();
    const char magic[4] = {'E', 'V', 'V', 'X'};
    out.insert(out.end(), magic, magic + 4);
    out.push_back(1);  // version
    putU32(out, uint32_t(chunks_.size()));
 
    // Deterministic output: sort chunk keys so saves are byte-stable.
    std::vector<uint64_t> keys;
    keys.reserve(chunks_.size());
    for (auto &kv : chunks_) keys.push_back(kv.first);
    std::sort(keys.begin(), keys.end());
    for (uint64_t key : keys) {
        const auto &chunk = chunks_.at(key);
        int cx, cy, cz;
        unpackKey(key, cx, cy, cz);
        putI32(out, int32_t(cx));
        putI32(out, int32_t(cy));
        putI32(out, int32_t(cz));
        const uint8_t *raw = chunk->rawVoxels();
        out.insert(out.end(), raw, raw + kChunkSize * kChunkSize * kChunkSize);
    }
}
 
bool VoxelWorld::deserializeWorld(const uint8_t *data, size_t size) {
    const uint8_t *p = data;
    const uint8_t *end = data + size;
    if (size < 9 || std::memcmp(p, "EVVX", 4) != 0 || p[4] != 1) return false;
    p += 5;
    uint32_t count = 0;
    if (!getU32(p, end, count)) return false;
    const size_t voxelBytes = size_t(kChunkSize) * kChunkSize * kChunkSize;
    if (uint64_t(count) > (uint64_t(end - p)) / (12 + voxelBytes)) return false;
 
    clear();
    for (uint32_t i = 0; i < count; ++i) {
        int32_t cx = 0, cy = 0, cz = 0;
        if (!getI32(p, end, cx) || !getI32(p, end, cy) || !getI32(p, end, cz)) return false;
        if (size_t(end - p) < voxelBytes) return false;
        Chunk *c = getOrCreateChunk(cx, cy, cz);
        c->setVoxelData(p);
        p += voxelBytes;
    }
    ++revision_;
    return true;
}
 
data::ByteData *VoxelWorld::saveWorld() const {
    std::vector<uint8_t> bytes;
    serializeWorld(bytes);
    return new data::ByteData(bytes.data(), bytes.size());
}
 
bool VoxelWorld::loadWorld(data::ByteData *bytes) {
    if (!bytes) return false;
    return deserializeWorld(static_cast<const uint8_t *>(bytes->getData()), bytes->getSize());
}
 
int VoxelWorld::getDirtyCount() const {
    int n = 0;
    for (auto &kv : chunks_) {
        if (kv.second->isDirty()) ++n;
    }
    return n;
}
 
int VoxelWorld::getInflightStreamCount() const {
    return int(inflight_.size() + retired_.size());
}
 
void VoxelWorld::waitStreamJobs() {
    auto waitAll = [](std::vector<StreamJob> &jobs) {
        for (StreamJob &job : jobs) {
            if (!job.job) continue;
            job.job->wait();
            delete job.job;
            job.job = nullptr;
        }
        jobs.clear();
    };
    waitAll(inflight_);
    waitAll(retired_);
}
 
void VoxelWorld::reapRetiredStreamJobs() {
    std::vector<StreamJob> keep;
    keep.reserve(retired_.size());
    for (StreamJob &job : retired_) {
        if (job.job && !job.job->isDone()) {
            keep.push_back(std::move(job));
            continue;
        }
        if (job.job) {
            job.job->wait();
            delete job.job;
        }
    }
    retired_ = std::move(keep);
}
 
bool VoxelWorld::isStreamJob(int cx, int cy, int cz) const {
    auto match = [cx, cy, cz](const StreamJob &job) {
        return job.cx == cx && job.cy == cy && job.cz == cz;
    };
    for (const StreamJob &job : inflight_) {
        if (match(job)) return true;
    }
    for (const StreamJob &job : retired_) {
        if (match(job)) return true;
    }
    return false;
}
 
void VoxelWorld::restoreRetiredInside(int centerX, int centerY, int centerZ, int radiusChunks) {
    const int64_t r2 = int64_t(radiusChunks) * int64_t(radiusChunks);
    std::vector<StreamJob> keep;
    keep.reserve(retired_.size());
    for (StreamJob &job : retired_) {
        const int64_t dx = int64_t(job.cx) - centerX;
        const int64_t dy = int64_t(job.cy) - centerY;
        const int64_t dz = int64_t(job.cz) - centerZ;
        if (dx * dx + dy * dy + dz * dz <= r2)
            inflight_.push_back(std::move(job));
        else
            keep.push_back(std::move(job));
    }
    retired_ = std::move(keep);
}
 
void VoxelWorld::dropStreamJobsOutside(int centerX, int centerY, int centerZ, int radiusChunks) {
    const int64_t r2 = int64_t(radiusChunks) * int64_t(radiusChunks);
    std::vector<StreamJob> keep;
    keep.reserve(inflight_.size());
    for (StreamJob &job : inflight_) {
        const int64_t dx = int64_t(job.cx) - centerX;
        const int64_t dy = int64_t(job.cy) - centerY;
        const int64_t dz = int64_t(job.cz) - centerZ;
        if (dx * dx + dy * dy + dz * dz <= r2) {
            keep.push_back(std::move(job));
            continue;
        }
        retired_.push_back(std::move(job));
    }
    inflight_ = std::move(keep);
}
 
int VoxelWorld::harvestStreamJobs(int centerX, int centerY, int centerZ, int radiusChunks,
                                  int maxHarvest) {
    const int64_t r2 = int64_t(radiusChunks) * int64_t(radiusChunks);
    int harvested = 0;
    std::vector<StreamJob> keep;
    keep.reserve(inflight_.size());
    for (StreamJob &job : inflight_) {
        if (!job.job || !job.job->isDone() || (maxHarvest > 0 && harvested >= maxHarvest)) {
            keep.push_back(std::move(job));
            continue;
        }
        job.job->wait();
        delete job.job;
        job.job = nullptr;
        const int64_t dx = int64_t(job.cx) - centerX;
        const int64_t dy = int64_t(job.cy) - centerY;
        const int64_t dz = int64_t(job.cz) - centerZ;
        const bool inside = dx * dx + dy * dy + dz * dz <= r2;
        if (!inside || hasChunk(job.cx, job.cy, job.cz) || !job.chunk) continue;
        chunks_.emplace(key(job.cx, job.cy, job.cz), std::move(job.chunk));
        ++harvested;
    }
    inflight_ = std::move(keep);
    if (harvested > 0) ++revision_;
    return harvested;
}
 
void VoxelWorld::remeshChunks(const std::vector<Chunk *> &chunks, int maxThreads) {
    const int count = int(chunks.size());
    if (count == 0) return;
 
    const auto remeshOne = [this](Chunk *c) {
        if (!c) return;
        c->remesh(types_, &VoxelWorld::chunkNeighborSampler, this);
    };
 
    int workers = maxThreads;
    if (workers <= 0) {
        workers = static_cast<int>(std::thread::hardware_concurrency());
        if (workers < 1) workers = 1;
        if (workers > kMaxRemeshWorkers) workers = kMaxRemeshWorkers;
    }
 
    if (workers <= 1 || count <= 1) {
        for (Chunk *c : chunks) remeshOne(c);
        return;
    }
 
    auto *jobs = thread::Thread::create()->getJobSystem();
    thread::Job *loop = nullptr;
    try {
        loop = jobs->parallelFor(0, count,
            [this, &chunks, &remeshOne](int first, int last) {
                for (int k = first; k < last; ++k) remeshOne(chunks[size_t(k)]);
            },
            (count + workers - 1) / workers);
    } catch (...) {
        for (Chunk *c : chunks) remeshOne(c);
        return;
    }
    loop->wait();
    delete loop;
}
 
int VoxelWorld::remeshDirty(int maxThreads, int maxChunks) {
    std::vector<Chunk *> dirty;
    dirty.reserve(chunks_.size());
    for (auto &kv : chunks_) {
        if (!kv.second->isDirty()) continue;
        dirty.push_back(kv.second.get());
        if (maxChunks > 0 && int(dirty.size()) >= maxChunks) break;
    }
    remeshChunks(dirty, maxThreads);
    return int(dirty.size());
}
 
void VoxelWorld::selectVisible(const float *viewProj16, float eyeX, float eyeY, float eyeZ,
                               float viewRange, bool faceCull) {
    visible_.clear();
    visibleChunkKeys_.clear();
    if (!viewProj16) return;
 
    const Frustum frustum = Frustum::fromViewProjColumnMajor(viewProj16);
    const float rangeSq = viewRange > 0.f ? viewRange * viewRange : 0.f;
 
    for (auto &kv : chunks_) {
        Chunk *chunk = kv.second.get();
 
        float minX, minY, minZ, maxX, maxY, maxZ;
        chunk->worldAABB(minX, minY, minZ, maxX, maxY, maxZ);
        const float cx = (minX + maxX) * 0.5f;
        const float cy = (minY + maxY) * 0.5f;
        const float cz = (minZ + maxZ) * 0.5f;
 
        if (viewRange > 0.f) {
            const float dx = cx - eyeX;
            const float dy = cy - eyeY;
            const float dz = cz - eyeZ;
            if (dx * dx + dy * dy + dz * dz > rangeSq) continue;
        }
 
        if (!frustum.intersectsAABB(minX, minY, minZ, maxX, maxY, maxZ)) continue;
 
        // Mesh only after range/frustum culling so edits far outside the view
        // are not remeshed every frame.
        chunk->ensureMeshed(types_, &VoxelWorld::chunkNeighborSampler, this);
 
        visibleChunkKeys_.push_back(kv.first);
 
        for (int i = 0; i < faceDirCount(); ++i) {
            const FaceDir dir = FaceDir(i);
            const int count = chunk->faceRectCount(dir);
            if (count <= 0) continue;
 
            if (faceCull) {
                // A perspective camera has a different view vector at every surface point.
                // Reject a direction only when every possible face plane in the chunk faces
                // away from the eye.  Testing against the chunk centre is not conservative:
                // when the eye crosses that centre plane it can discard faces on the far half
                // of the chunk that are still front-facing and visible (notably cave walls).
                bool allBackFacing = false;
                switch (dir) {
                    case FaceDir::PosX: allBackFacing = eyeX <= minX; break;
                    case FaceDir::NegX: allBackFacing = eyeX >= maxX; break;
                    case FaceDir::PosY: allBackFacing = eyeY <= minY; break;
                    case FaceDir::NegY: allBackFacing = eyeY >= maxY; break;
                    case FaceDir::PosZ: allBackFacing = eyeZ <= minZ; break;
                    case FaceDir::NegZ: allBackFacing = eyeZ >= maxZ; break;
                    case FaceDir::Count: break;
                }
                if (allBackFacing) continue;
            }
 
            DrawBatch batch;
            batch.chunk = chunk;
            batch.dir = dir;
            batch.packed = chunk->facePackedData(dir);
            batch.ao = chunk->faceAOPackedData(dir);
            batch.count = count;
            visible_.push_back(batch);
        }
    }
}
 
void VoxelWorld::getVisibleChunkCoord(int index, int &cx, int &cy, int &cz) const {
    if (index < 0 || index >= int(visibleChunkKeys_.size())) {
        cx = cy = cz = 0;
        return;
    }
    unpackKey(visibleChunkKeys_[size_t(index)], cx, cy, cz);
}
 
int VoxelWorld::getVisibleRectCount() const {
    int n = 0;
    for (const auto &b : visible_) n += b.count;
    return n;
}
 
void VoxelWorld::drawVisible(graphics::Graphics *gfx, graphics::Texture *atlas, int tilesPerRow) {
    if (!gfx) return;
    for (const auto &b : visible_) {
        if (!b.chunk || !b.packed || b.count <= 0) continue;
        gfx->drawVoxelFaceInstances(b.packed, b.count, b.chunk->originX(), b.chunk->originY(),
                                    b.chunk->originZ(), faceDirName(b.dir), atlas, tilesPerRow,
                                    b.ao);
    }
}
 
uint8_t VoxelWorld::getVoxel(int wx, int wy, int wz) const {
    const int cx = floorDiv(wx);
    const int cy = floorDiv(wy);
    const int cz = floorDiv(wz);
    const Chunk *c = getChunk(cx, cy, cz);
    if (!c) return 0;
    return c->get(wx - cx * kChunkSize, wy - cy * kChunkSize, wz - cz * kChunkSize);
}
 
void VoxelWorld::setVoxel(int wx, int wy, int wz, uint8_t texId) {
    const int cx = floorDiv(wx);
    const int cy = floorDiv(wy);
    const int cz = floorDiv(wz);
    const int lx = wx - cx * kChunkSize;
    const int ly = wy - cy * kChunkSize;
    const int lz = wz - cz * kChunkSize;
 
    Chunk *c = getChunk(cx, cy, cz);
    if (c && c->get(lx, ly, lz) == texId) return;
    if (texId == 0) {
        // Clearing an unallocated chunk is a no-op (air needs no storage).
        if (!c) return;
        c->set(lx, ly, lz, 0);
    } else {
        if (!c) c = getOrCreateChunk(cx, cy, cz);
        c->set(lx, ly, lz, texId);
    }
    ++revision_;
    markNeighborChunksDirty(cx, cy, cz, lx, ly, lz);
}
 
void VoxelWorld::markNeighborChunksDirty(int cx, int cy, int cz, int lx, int ly, int lz) {
    auto mark = [this](int nx, int ny, int nz) {
        if (Chunk *n = getChunk(nx, ny, nz)) n->markDirty();
    };
    if (lx == 0) mark(cx - 1, cy, cz);
    if (lx == kChunkSize - 1) mark(cx + 1, cy, cz);
    if (ly == 0) mark(cx, cy - 1, cz);
    if (ly == kChunkSize - 1) mark(cx, cy + 1, cz);
    if (lz == 0) mark(cx, cy, cz - 1);
    if (lz == kChunkSize - 1) mark(cx, cy, cz + 1);
}
 
uint8_t VoxelWorld::chunkNeighborSampler(void *userData, int chunkX, int chunkY, int chunkZ,
                                         int localX, int localY, int localZ) {
    const auto *self = static_cast<const VoxelWorld *>(userData);
    const int wx = chunkX * kChunkSize + localX;
    const int wy = chunkY * kChunkSize + localY;
    const int wz = chunkZ * kChunkSize + localZ;
    return self->getVoxel(wx, wy, wz);
}
 
bool VoxelWorld::raycast(float ox, float oy, float oz, float dx, float dy, float dz,
                         float maxDist, int &hitX, int &hitY, int &hitZ, int &prevX,
                         int &prevY, int &prevZ, int &faceX, int &faceY, int &faceZ) const {
    const float lenSq = dx * dx + dy * dy + dz * dz;
    if (lenSq <= 1e-12f || maxDist <= 0.f) return false;
    const float invLen = 1.f / std::sqrt(lenSq);
    const float rx = dx * invLen;
    const float ry = dy * invLen;
    const float rz = dz * invLen;
 
    int ix = int(std::floor(ox));
    int iy = int(std::floor(oy));
    int iz = int(std::floor(oz));
 
    if (getVoxel(ix, iy, iz) != 0) {
        hitX = prevX = ix;
        hitY = prevY = iy;
        hitZ = prevZ = iz;
        faceX = faceY = faceZ = 0;
        return true;
    }
 
    const float inf = std::numeric_limits<float>::infinity();
    const int stepX = rx > 0.f ? 1 : -1;
    const int stepY = ry > 0.f ? 1 : -1;
    const int stepZ = rz > 0.f ? 1 : -1;
    const float absInvX = rx != 0.f ? std::fabs(1.f / rx) : inf;
    const float absInvY = ry != 0.f ? std::fabs(1.f / ry) : inf;
    const float absInvZ = rz != 0.f ? std::fabs(1.f / rz) : inf;
    float tMaxX = rx != 0.f ? (rx > 0.f ? float(ix + 1) - ox : ox - float(ix)) * absInvX : inf;
    float tMaxY = ry != 0.f ? (ry > 0.f ? float(iy + 1) - oy : oy - float(iy)) * absInvY : inf;
    float tMaxZ = rz != 0.f ? (rz > 0.f ? float(iz + 1) - oz : oz - float(iz)) * absInvZ : inf;
 
    prevX = ix;
    prevY = iy;
    prevZ = iz;
    faceX = faceY = faceZ = 0;
 
    constexpr int kMaxSteps = 4096;
    for (int iter = 0; iter < kMaxSteps; ++iter) {
        float t;
        if (tMaxX <= tMaxY && tMaxX <= tMaxZ) {
            ix += stepX;
            t = tMaxX;
            tMaxX += absInvX;
            faceX = -stepX;
            faceY = 0;
            faceZ = 0;
        } else if (tMaxY <= tMaxZ) {
            iy += stepY;
            t = tMaxY;
            tMaxY += absInvY;
            faceX = 0;
            faceY = -stepY;
            faceZ = 0;
        } else {
            iz += stepZ;
            t = tMaxZ;
            tMaxZ += absInvZ;
            faceX = 0;
            faceY = 0;
            faceZ = -stepZ;
        }
        if (t > maxDist) return false;
        if (getVoxel(ix, iy, iz) != 0) {
            hitX = ix;
            hitY = iy;
            hitZ = iz;
            return true;
        }
        prevX = ix;
        prevY = iy;
        prevZ = iz;
    }
    return false;
}
 
bool VoxelWorld::raycastScript(float ox, float oy, float oz, float dx, float dy, float dz,
                               float maxDist) {
    raycastHit_ = raycast(ox, oy, oz, dx, dy, dz, maxDist, raycastHitX_, raycastHitY_,
                          raycastHitZ_, raycastPrevX_, raycastPrevY_, raycastPrevZ_,
                          raycastFaceX_, raycastFaceY_, raycastFaceZ_);
    return raycastHit_;
}
 
void VoxelWorld::setVoxelByName(int wx, int wy, int wz, const std::string &name, int orientation) {
    const CubeType *t = types_.find(name);
    uint8_t id = 0;
    if (t) id = types_.variantId(name, orientation);
    setVoxel(wx, wy, wz, id);
}
 
std::string VoxelWorld::getCubeTypeName(int wx, int wy, int wz) const {
    const CubeType *t = types_.find(getVoxel(wx, wy, wz));
    return t ? t->name : std::string{};
}
 
uint8_t VoxelWorld::getCubeTypeTex(int wx, int wy, int wz, const std::string &faceDir) const {
    FaceDir d;
    if (!faceDirFromName(faceDir, d)) return 0;
    const uint8_t id = getVoxel(wx, wy, wz);
    return resolveFaceTex(types_, id, d);
}
 
}  // namespace eve::voxel