Univerxel/src/world/Universe.cpp

#include "Universe.hpp"

#include <Remotery.h>
#include <filesystem>

#include "../contouring/Dummy.hpp"
#include "Chunk.hpp"

using namespace world;

Universe::Universe(const Universe::options &options): generator(42), dicts("content/zstd.dict"), contouring(std::make_shared<contouring::Dummy>()) {
    setOptions(options);
    folderPath = options.folderPath;
    struct vec_istream: std::streambuf {
        vec_istream(std::vector<char> &vec) {
            this->setg(&vec[0], &vec[0], &vec[0] + vec.size());
        }
    };
    running = true;
    std::filesystem::create_directories(folderPath);

    // Load workers
    for (size_t i = 0; i < 4; i++) {
        loadWorkers.emplace_back([&] {
            const auto ctx = dicts.make_reader();
            while (running) {
                chunk_pos pos;
                loadQueue.wait();
                if (loadQueue.pop(pos)) {
                    //MAYBE: loadQueue.take to avoid duplicated work on fast move
                    rmt_ScopedCPUSample(ProcessLoad, 0);
                    const region_pos rPos = glm::divide(pos, region_chunk_pos(REGION_LENGTH));
                    const region_chunk_pos cPos = glm::modulo(pos, region_chunk_pos(REGION_LENGTH));
                    const auto reg = getRegion(rPos);
                    Region::data data;
                    if(reg->read(cPos, ctx, data)) {
                        rmt_ScopedCPUSample(ProcessRead, 0);
                        vec_istream idata(data);
                        std::istream iss(&idata);
                        loadedQueue.push({pos, std::make_shared<Chunk>(iss)});
                    } else {
                        rmt_ScopedCPUSample(ProcessGenerate, 0);
                        loadedQueue.push({pos, std::make_shared<Chunk>(pos, generator)});
                    }
                }
            }
        });
    }

    // Save workers
    for (size_t i = 0; i < 2; i++) {
        saveWorkers.emplace_back([&] {
            const auto ctx = dicts.make_writer();
            while (running) {
                robin_hood::pair<chunk_pos, std::shared_ptr<Chunk>> task;
                saveQueue.wait();
                if (saveQueue.pop(task) && task.second->isModified()) {
                    //MAYBE: queue.take to avoid concurent write or duplicated work on fast move
                    rmt_ScopedCPUSample(ProcessSave, 0);
                    std::ostringstream out;
                    task.second->write(out);
                    const region_pos rPos = glm::divide(task.first, region_chunk_pos(REGION_LENGTH));
                    const region_chunk_pos cPos = glm::modulo(task.first, region_chunk_pos(REGION_LENGTH));
                    const auto reg = getRegion(rPos);
                    reg->write(cPos, ctx, out.str());
                }
            }
        });
    }
}
Universe::~Universe() {
    contouring = NULL;

    // Save all
    for(auto& pair: chunks) {
        saveQueue.push(pair);
    }
    if (auto size = saveQueue.size(); size > 0) {
        std::cout << std::endl;
        do {
            std::cout << "\rSaving... " << size << "            " << std::flush;
            std::this_thread::sleep_for(std::chrono::microseconds(500));
            size = saveQueue.size();
        } while (size > 0);
        std::cout << std::endl;
    }

    running = false;
    loadQueue.notify();
    saveQueue.notify();

    for (auto &worker: loadWorkers) {
        if (worker.joinable())
            worker.join();
    }
    for (auto &worker: saveWorkers) {
        if (worker.joinable())
            worker.join();
    }
}

std::shared_ptr<Region> Universe::getRegion(const region_pos& pos) {
    { // Found
        const auto shared = regions.lock_shared();
        const auto it = shared->find(pos);
        if(it != shared->end())
            return it->second;
    }
    // Reading
    const auto reg = std::make_shared<Region>(folderPath, pos);
    const auto unique = regions.lock();
    return unique->insert({pos, reg}).first->second;
}

void Universe::update(const camera_pos& pos, Universe::report& rep) {
    const chunk_pos newPos = glm::divide(pos, chunk_voxel_pos(CHUNK_LENGTH));
    const auto chunkChange = last_pos != newPos;
    last_pos = newPos;
    rmt_ScopedCPUSample(Universe, 0);

    // Update alive chunks
    {
        rmt_ScopedCPUSample(Update, 0);
        auto it = chunks.begin();
        while (it != chunks.end()) {
            if (glm::length2(last_pos - it->first) > keepDistance * keepDistance) {
                saveQueue.push(*it);
                it = chunks.erase(it);
            } else {
                if (const auto neighbors = it->second->update()) {
                    contouring->onUpdate(it->first, chunks, neighbors.value()); //TODO: get update update_type(simple(pos), complex)
                } else if (chunkChange) {
                    contouring->onNotify(it->first, chunks);
                }
                ++it;
            }
        }
    }
    rep.chunk_unload.push(saveQueue.size());
    {
        rmt_ScopedCPUSample(Contouring, 0);
        contouring->update(pos);
        //MAYBE: if(chunkChange) contouring->notify(chunks);
    }

    // Find missing chunks
    if(chunkChange) {
        rmt_ScopedCPUSample(ToLoad, 0);
        //NOTE: need dist so no easy sphere fill
        for (int x = -loadDistance; x <= loadDistance; x++) {
        for (int y = -loadDistance; y <= loadDistance; y++) {
        for (int z = -loadDistance; z <= loadDistance; z++) {
            const auto dist2 = x * x + y * y + z * z;
            if (dist2 <= loadDistance * loadDistance) {
                const chunk_pos p = last_pos + glm::ivec3(x, y, z);
                if (chunks.find(p) == chunks.end()) {
                    loadQueue.push(p, -dist2);
                }
            }
        }}}
    }

    rep.chunk_load.push(loadQueue.size());
    // Loaded chunks
    {
        rmt_ScopedCPUSample(Load, 0);
        robin_hood::pair<chunk_pos, std::shared_ptr<Chunk>> loaded;
        while (loadedQueue.pop(loaded)) {
            chunks.insert(loaded);
            contouring->onUpdate(loaded.first, chunks, Faces::All);
        }
    }
    rep.chunk_count.push(chunks.size());

    {
        rmt_ScopedCPUSample(Region, 0);
        const auto unique = regions.lock(); // MAYBE: shared then unique
        rep.region_count.push(unique->size());
        const auto me = glm::divide(last_pos, glm::ivec3(REGION_LENGTH));
        for (auto it = unique->begin(); it != unique->end(); it++) {
            if (glm::length2(it->first - me) > keepDistance) {
                LOG_D("Remove region");
                unique->erase(it);
                break; //NOTE: save one max per frame
            }
        }
    }
}
void Universe::setOptions(const Universe::options& options) {
    loadDistance = options.loadDistance;
    keepDistance = options.keepDistance;
}

void Universe::setContouring(std::shared_ptr<contouring::Abstract> ct) {
    contouring = ct;
    last_pos = chunk_pos(INT_MAX); // trigger chunkChange on next update
}

std::optional<std::pair<voxel_pos, Voxel>> Universe::raycast(const Ray &ray) const {
    std::vector<voxel_pos> points;
    ray.grid(points);
    std::shared_ptr<Chunk> chunk = NULL;
    chunk_pos chunk_pos(INT_MAX);
    for(auto point: points) {
        const auto pos = glm::divide(point, glm::ivec3(CHUNK_LENGTH));
        if(pos != chunk_pos) {
            if(const auto& newChunk = at(pos)) {
                chunk = newChunk.value();
                chunk_pos = pos;
            }
        }
        if(chunk != NULL) {
            const auto voxel = chunk->getAt(glm::modulo(point, glm::uvec3(CHUNK_LENGTH)));
            if(voxel.Density > 0)
                return {{point, voxel}};
        }
    }
    return {};
}

std::optional<Item> Universe::set(const voxel_pos& pos, const Voxel& val) {
    const auto chunkPos = glm::divide(pos, glm::ivec3(CHUNK_LENGTH));
    if(const auto& chunk = at(chunkPos)) {
        return {chunk.value()->breakAt(glm::modulo(pos, glm::ivec3(CHUNK_LENGTH)), val)};
    } else {
        return {};
    }
}
ItemList Universe::setCube(const voxel_pos& pos, const Voxel& val, int radius) {
    ItemList list;
    for (int z = -radius; z <= radius; z++) {
    for (int y = -radius; y <= radius; y++) {
    for (int x = -radius; x <= radius; x++) {
        //TODO: list.pop(val)
        list.add(set(pos + glm::lvec3(x, y, z), val));
    }}}
    return list;
}