Univerxel/src/world/Universe.cpp

#include "Universe.hpp"

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

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

using namespace world;

const auto MAIN_AREA = 1;

Universe::Universe(const Universe::options &options):  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);
    //areas.emplace(MAIN_AREA, std::make_shared<Area>(area_pos(glm::multiply(chunk_pos(1 << 8, 0, 0))), 1 << 20));
    areas.emplace(2, std::make_shared<Area>(area_pos(voxel_pos(0)), 1 << 20));

    // Load workers
    for (size_t i = 0; i < 4; i++) {
        loadWorkers.emplace_back([&] {
            const auto ctx = dicts.make_reader();
            while (running) {
                std::pair<area_<chunk_pos>, std::shared_ptr<Area>> task;
                loadQueue.wait();
                if (loadQueue.pop(task)) {
                    //MAYBE: loadQueue.take to avoid duplicated work on fast move
                    rmt_ScopedCPUSample(ProcessLoad, 0);
                    const auto &pos = task.first;
                    const auto rcPos = glm::split(pos.second);
                    const auto reg = task.second->getRegion(folderPath, std::make_pair(pos.first, rcPos.first));
                    Region::data data;
                    if(reg->read(rcPos.second, 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.second, task.second->getGenerator())});
                    }
                }
            }
        });
    }

    // Save workers
    for (size_t i = 0; i < 2; i++) {
        saveWorkers.emplace_back([&] {
            const auto ctx = dicts.make_writer();
            while (running) {
                save_task_t task;
                saveQueue.wait();
                if (saveQueue.pop(task) && task.second.second->isModified()) {
                    //MAYBE: queue.take to avoid concurent write or duplicated work on fast move
                    rmt_ScopedCPUSample(ProcessSave, 0);
                    std::ostringstream out;
                    task.second.second->write(out);
                    const auto rcPos = glm::split(task.second.first);
                    const auto reg = task.first.second->getRegion(folderPath, std::make_pair(task.first.first, rcPos.first));
                    reg->write(rcPos.second, ctx, out.str());
                }
            }
        });
    }
}
Universe::~Universe() {
    contouring = nullptr;

    // Save all
    for(auto& area: areas) {
        for(const auto& chunk: area.second->getChunks())
            saveQueue.emplace(area, chunk);
    }
    if (auto size = saveQueue.size(); size > 0) {
        LOG_I("Saving " << size << " chunks");
        const auto SAVE_CHECK_TIME = 500;
        do {
            std::cout << "\rSaving... " << size << "            " << std::flush;
            std::this_thread::sleep_for(std::chrono::microseconds(SAVE_CHECK_TIME));
            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();
    }
    LOG_D("Universe disappeared");
}

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

    { // Update alive areas
        rmt_ScopedCPUSample(Update, 0);
        size_t chunk_count = 0;
        size_t region_count = 0;
        const bool queuesEmpty = loadQueue.empty() && saveQueue.empty();
        bool allLazy = true;
        auto it = areas.begin();
        while (it != areas.end()) {
            rmt_ScopedCPUSample(Area, 0);
            const bool chunkChangeArea = (it->first == 2 && it->second->move(glm::vec3(deltaTime))) || chunkChange; // TODO: area.velocity
            const chunk_pos diff = glm::divide(pos - it->second->getOffset().as_voxel());
            auto &chunks = it->second->setChunks();
            if (glm::length2(diff) > glm::pow2(keepDistance + it->second->getChunks().getRadius())) {
                auto it_c = chunks.begin();
                while(it_c != chunks.end()) {
                    saveQueue.emplace(*it, *it_c);
                    it_c = chunks.erase(it_c);
                }
                it = areas.erase(it);
            } else {
                bool lazyArea = queuesEmpty;
                { // Update alive chunks
                    rmt_ScopedCPUSample(Alive, 0);
                    auto it_c = chunks.begin();
                    while(it_c != chunks.end()) {
                        if (glm::length2(diff - it_c->first) > glm::pow2(keepDistance)) {
                            saveQueue.emplace(*it, *it_c);
                            lazyArea = false;
                            it_c = chunks.erase(it_c);
                        }else {
                            const area_<chunk_pos> acPos = std::make_pair(it->first, it_c->first);
                            if (const auto neighbors = it_c->second->update()) {
                                contouring->onUpdate(acPos, diff, chunks, neighbors.value());
                            } else if (chunkChange || it->first == 2) {
                                contouring->onNotify(acPos, diff, chunks);
                            }
                            ++it_c;
                            chunk_count++;
                        }
                    }
                }
                if (chunkChangeArea) { // Enqueue missing chunks
                    rmt_ScopedCPUSample(Missing, 0);
                    //TODO: 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 auto p = diff + chunk_pos(x, y, z);
                            if (chunks.inRange(p) && chunks.find(p) == chunks.end()) {
                                loadQueue.push(std::make_pair(it->first, p), it->second, -dist2);
                                lazyArea = false;
                            }
                        }
                    }}}
                }
                allLazy &= lazyArea;
                if (lazyArea) { // Clear un-used regions
                    rmt_ScopedCPUSample(Region, 0);
                    const auto unique = it->second->getRegions(); // MAYBE: shared then unique
                    region_count += unique->size();
                    for (auto it_r = unique->begin(); it_r != unique->end(); ++it_r) {
                        if (glm::length2(diff - glm::lvec3(it_r->first) * glm::lvec3(REGION_LENGTH)) > glm::pow2(keepDistance + REGION_LENGTH * 2)) {
                            unique->erase(it_r); //FIXME: may wait for os file access (long)
                            break; //NOTE: save one only max per frame
                        }
                    }
                }
                ++it;
            }
        }
        rep.chunk_count.push(chunk_count);
        rep.region_count.push(allLazy ? region_count : rep.region_count.current());
    }
    rep.chunk_load.push(loadQueue.size());
    rep.chunk_unload.push(saveQueue.size());
    {
        rmt_ScopedCPUSample(Contouring, 0);
        contouring->update(pos, areas);
        //MAYBE: if(chunkChange) contouring->notify(chunks);
    }

    { // Store loaded chunks
        rmt_ScopedCPUSample(Load, 0);
        robin_hood::pair<area_<chunk_pos>, std::shared_ptr<Chunk>> loaded;
        while (loadedQueue.pop(loaded)) {
            if (const auto it = areas.find(loaded.first.first); it != areas.end()) {
                auto &chunks = it->second->setChunks();
                chunks.emplace(loaded.first.second, loaded.second);
                const chunk_pos diff = glm::divide(pos - it->second->getOffset().as_voxel());
                contouring->onUpdate(loaded.first, diff, chunks, Faces::All);
            }
        }
    }
}
void Universe::setOptions(const Universe::options& options) {
    loadDistance = options.loadDistance;
    keepDistance = options.keepDistance;
}

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

std::optional<Universe::ray_target> Universe::raycast(const Ray &ray) const {
    //MAYBE: ray + offset to get float precision
    std::vector<voxel_pos> points;
    ray.grid(points);
    std::optional<Universe::ray_target> target = std::nullopt;
    size_t dist = points.size();
    for(auto& area: areas) {
        if(ray.intersect(area.second->getBounding()) != IBox::ContainmentType::Disjoint) {
            const auto &offset = area.second->getOffset().as_voxel();
            const auto &chunks = area.second->getChunks();
            std::shared_ptr<Chunk> chunk = nullptr;
            chunk_pos chunk_vec(INT_MAX);
            for (size_t i = 0; i < dist; i++) {
                const auto pos = points[i] - offset;
                const chunk_pos cPos = glm::divide(pos);
                if(cPos != chunk_vec) {
                    if (const auto it = chunks.find(cPos); it != chunks.end()) {
                        chunk = it->second;
                        chunk_vec = cPos;
                    } else {
                        chunk = nullptr;
                    }
                }
                if(chunk != nullptr) {
                    const auto voxel = chunk->getAt(glm::modulo(pos));
                    if(voxel.density() > 0) {
                        target = {ray_target{{area.first, pos}, voxel, offset}};
                        dist = i;
                        i = points.size();
                    }
                }
            }
        }
    }
    return target;
}

std::optional<Item> Universe::set(const area_<voxel_pos>& pos, const Voxel& val) {
    if(const auto it = areas.find(pos.first); it != areas.end()) {
        auto &chunks = it->second->setChunks();
        const auto split = glm::splitIdx(pos.second);
        if(chunks.inRange(split.first))
            if(const auto chunk = chunks.findInRange(split.first))
                return {chunk.value()->replace(split.second, val)};
    }
    return {};
}
ItemList Universe::setCube(const area_<voxel_pos>& pos, const Voxel& val, int radius) {
    ItemList list;
    if(const auto it = areas.find(pos.first); it != areas.end()) {
        auto& chunks = it->second->setChunks();
        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)
            const auto split = glm::splitIdx(pos.second + voxel_pos(x, y, z));
            if(chunks.inRange(split.first))
                if(const auto chunk = it->second->setChunks().findInRange(split.first))
                    list.add(chunk.value()->replace(split.second, val));
        }}}
    }
    return list;
}