Method merge

modules/engine/runtime/src/ecs/storage.cpp:644–753

}

void sugoi_storage_t::merge(sugoi_storage_t& src)
{
    using namespace sugoi;
    if (scheduler)
    {
        SKR_ASSERT(scheduler->is_main_thread(this));
        scheduler->sync_storage(&src);
    }
    auto&                           sents = src.entities;
    skr::stl_vector<sugoi_entity_t> map;
    map.resize(sents.entries.size());
    EIndex moveCount = 0;
    for (auto& e : sents.entries)
        if (e.chunk != nullptr)
            moveCount++;
    skr::stl_vector<sugoi_entity_t> newEnts;
    newEnts.resize(moveCount);
    entities.new_entities(newEnts.data(), moveCount);
    int j = 0;
    for (int i = 0; i < sents.entries.size(); ++i)
        if (sents.entries[i].chunk != nullptr)
            map[i] = newEnts[j++];

    sents.reset();
    struct mapper {
        uint32_t        count;
        sugoi_entity_t* data;
        void            move() {}
        void            reset() {}
        void            map(sugoi_entity_t& e)
        {
            if (e_id(e) > count) SUGOI_UNLIKELY
            {
                e = kEntityNull;
                return;
            }
            e = data[e_id(e)];
        }
    } m;
    m.count = (uint32_t)map.size();
    m.data  = map.data();
    skr::stl_vector<sugoi_chunk_t*> chunks;
    struct payload_t {
        mapper*  m;
        uint32_t start, end;
    };
    skr::stl_vector<payload_t> payloads;
    payload_t                  payload;
    payload.m     = &m;
    payload.start = payload.end = 0;
    uint32_t sizePerBatch       = 1024 * 16;
    uint32_t sizeRemain         = sizePerBatch;
    for (auto& i : src.groups)
    {
        sugoi_group_t* g = i.second;
        for (auto c : g->chunks)
        {
            chunks.push_back(c);