Univerxel/src/world/World.cpp

#include "World.hpp"

#include "../contouring/Dummy.hpp"
#include <Remotery.h>

World::World(const World::options &options): contouring(std::make_shared<contouring::Dummy>()) {
    setOptions(options);
}
World::~World() {
    contouring = NULL;
}

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

    // Update alive chunks
    {
        rmt_ScopedCPUSample(Update, 0);
        for(auto [chunkPos, chunk]: chunks) {
            if (glm::length2(last_pos - chunkPos) > keepDistance * keepDistance
                    && unloadQueue.push(chunkPos)) {
                //TODO: unloadCount++;
                continue;
            }

            if (chunk->update()) { // MAYBE: also contour joints
                contouring->onUpdate(chunkPos, chunks); //TODO: get update update_type(simple(pos), complex)
            } else if (chunkChange) { //NOTE: must be solved before octrees
                contouring->onNotify(chunkPos, chunks);
            }
        }
    }
    contouring->update(pos);

    rep.chunk_unload.push(unloadQueue.size());
    // Unload dead chunks
    {
        rmt_ScopedCPUSample(Unload, 0);
        for (size_t i = 0; i < 8 && !unloadQueue.empty(); i++) {
            chunks.extract(unloadQueue.pop());
            //TODO: save to file
        }
    }

    // Find missing chunks (~240ms from max loadDistance)
    if(chunkChange) {
        rmt_ScopedCPUSample(ToLoad, 0);
        std::vector<chunk_pos> to_load;
        for (int x = -loadDistance; x <= loadDistance; x++) {
        for (int y = -loadDistance; y <= loadDistance; y++) {
        for (int z = -loadDistance; z <= loadDistance; z++) {
            if (x * x + y * y + z * z <= loadDistance * loadDistance) {
                const chunk_pos p = last_pos + glm::ivec3(x, y, z);
                if (chunks.find(p) == chunks.end()) {
                    to_load.push_back(p);
                }
            }
        }}}
        std::sort(to_load.begin(), to_load.end(), [](const chunk_pos &a, const chunk_pos &b) {
            return glm::length2(a) < glm::length2(b);
        });
        for(auto p: to_load) {
            loadQueue.push(p);
        }
    }

    rep.chunk_load.push(loadQueue.size());
    // Load chunks
    {
        rmt_ScopedCPUSample(Load, 0);
        for (size_t i = 0; i < 8 && !loadQueue.empty(); i++) {
            const auto pos = loadQueue.pop();
            const auto chunk = std::make_shared<Chunk>(pos, generator);
            chunks.insert({pos, chunk});
            //trigger surronding render
            //MAYBE: contouring dependant
            for (size_t i = 0; i < 6; i++) {
                const auto it = chunks.find(pos + g_face_offsets[i]);
                if (it != chunks.end())
                    it->second->invalidate();
            }
        }
    }
    rep.chunk_count.push(chunks.size());
}
void World::setOptions(const World::options& options) {
    loadDistance = options.loadDistance;
    keepDistance = options.keepDistance;
}

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