Function serialize_impl

modules/engine/runtime/src/ecs/serialize.cpp:29–98

}

static void serialize_impl(const sugoi_chunk_view_t& view, sugoi_type_index_t type, EIndex offset, uint32_t size, uint32_t elemSize, skr_binary_writer_t* s, skr_binary_reader_t* ds
, void (*serialize)(sugoi_chunk_t* chunk, EIndex index, char* data, EIndex count, skr_binary_writer_t* writer)
, void (*deserialize)(sugoi_chunk_t* chunk, EIndex index, char* data, EIndex count, skr_binary_reader_t* writer))
{
    using namespace sugoi;
    namespace bin = skr::binary;
    bool isSeralize = s != nullptr;
    char* src = view.chunk->data() + (size_t)offset + (size_t)size * view.start;
    if (type_index_t(type).is_buffer())
    {
        // array component is pointer based and must be converted to persistent data format
        if (isSeralize)
        {
            forloop (i, 0, view.count)
            {
                auto array = (sugoi_array_comp_t*)((size_t)i * size + src);
                intptr_t padding = ((char*)array->BeginX - (char*)(array + 1));
                intptr_t length = ((char*)array->EndX - (char*)array->BeginX);
                bin::Archive(s, (uint32_t)padding);
                bin::Archive(s, (uint32_t)length);
                if (serialize)
                    serialize(view.chunk, view.start + i, (char*)array->BeginX, (EIndex)(length / elemSize), s);
                else
                    ArchiveBuffer(s, (uint8_t*)array->BeginX, static_cast<uint32_t>(length));
            }
        }
        else
        {
            forloop (i, 0, view.count)
            {
                auto array = (sugoi_array_comp_t*)((size_t)i * size + src);
                uint32_t padding = 0, length = 0;
                bin::Archive(ds, padding);
                bin::Archive(ds, length);
                if (padding > elemSize) // array on heap
                {
                    array->BeginX = llvm_vecsmall::SmallVectorBase::allocate(length);
                    array->CapacityX = array->EndX = (char*)array->BeginX + length;
                }
                else
                {
                    array->BeginX = (char*)(array + 1) + padding;
                    array->EndX = (char*)array->BeginX + length;
                    array->CapacityX = (char*)array + size;
                }
                if (deserialize)
                    deserialize(view.chunk, view.start + i, (char*)array->BeginX, (EIndex)length, ds);
                else
                    ArchiveBuffer(ds, (uint8_t*)array->BeginX, length);
            }
        }
    }
    else
    {
        if (isSeralize)
        {
            if (serialize)
                serialize(view.chunk, view.start, src, view.count, s);