allocate_field() [2/2]

bool MayaFlux::Buffers::VolumeGridBuffer::allocate_field ( const std::string &  name, size_t  stride_bytes, bool  double_buffered, Kinesis::LatticeSemantics  semantics  )

private

Allocate one field's slots and register it.

Parameters

name	Lookup key.
stride_bytes	Bytes per cell.
double_buffered	Whether to allocate a second slot.
semantics	What the values mean. Stored and never acted on.

Returns

True if the field was registered.

Definition at line 59 of file VolumeGridBuffer.cpp.

{
    if (name.empty()) {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::Init,
            "VolumeGridBuffer: field declared with empty name, skipped");
        return false;
    }
 
    if (stride_bytes == 0) {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::Init,
            "VolumeGridBuffer: field '{}' declares zero stride, skipped", name);
        return false;
    }
 
    if (m_fields.contains(name)) {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::Init,
            "VolumeGridBuffer: duplicate field '{}', later declaration discarded", name);
        return false;
    }
 
    auto buffer_service = Registry::BackendRegistry::instance()
                              .get_service<Registry::Service::BufferService>();
 
    if (!buffer_service || !buffer_service->allocate_raw_buffer) {
        error<std::runtime_error>(
            Journal::Component::Buffers,
            Journal::Context::Init,
            std::source_location::current(),
            "VolumeGridBuffer requires a valid buffer service");
    }
 
    const auto usage_flags = static_cast<uint32_t>(
        static_cast<VkBufferUsageFlags>(
            vk::BufferUsageFlagBits::eStorageBuffer
            | vk::BufferUsageFlagBits::eTransferSrc
            | vk::BufferUsageFlagBits::eTransferDst));
 
    const auto memory_flags = static_cast<uint32_t>(
        static_cast<VkMemoryPropertyFlags>(vk::MemoryPropertyFlagBits::eDeviceLocal));
 
    auto& resources = get_buffer_resources();
    const size_t field_bytes = static_cast<size_t>(get_cell_count()) * stride_bytes;
    const uint32_t slot_count = double_buffered ? 2 : 1;
 
    Field field {
        .stride_bytes = stride_bytes,
        .slot_a = static_cast<uint32_t>(resources.back_buffers.size()),
        .slot_b = 0,
        .read_is_a = true,
        .semantics = semantics,
    };
 
    for (uint32_t i = 0; i < slot_count; ++i) {
        void* out_buffer = nullptr;
        void* out_memory = nullptr;
        void* out_mapped = nullptr;
 
        buffer_service->allocate_raw_buffer(
            field_bytes, usage_flags, memory_flags, false,
            out_buffer, out_memory, out_mapped);
 
        VKBufferResources::GenerationSlot slot;
        slot.buffer = static_cast<vk::Buffer>(static_cast<VkBuffer>(out_buffer));
        slot.memory = static_cast<vk::DeviceMemory>(static_cast<VkDeviceMemory>(out_memory));
        slot.mapped_ptr = out_mapped;
 
        resources.back_buffers.push_back(slot);
    }
 
    field.slot_b = double_buffered ? field.slot_a + 1 : field.slot_a;
 
    m_fields.emplace(name, field);
    m_field_order.push_back(name);
 
    MF_DEBUG(Journal::Component::Buffers, Journal::Context::Init,
        "VolumeGridBuffer: field '{}', stride {}, {} slot(s), {} bytes, class {}",
        name, stride_bytes, slot_count, field_bytes * slot_count,
        Reflect::enum_to_string(semantics.value_class));
 
    return true;
}

References MayaFlux::Buffers::VKBufferResources::GenerationSlot::buffer, MayaFlux::Journal::Buffers, MayaFlux::Reflect::enum_to_string(), MayaFlux::Buffers::VKBuffer::get_buffer_resources(), get_cell_count(), MayaFlux::Registry::BackendRegistry::get_service(), MayaFlux::Journal::Init, MayaFlux::Registry::BackendRegistry::instance(), m_field_order, m_fields, MayaFlux::Buffers::VKBufferResources::GenerationSlot::mapped_ptr, MayaFlux::Buffers::VKBufferResources::GenerationSlot::memory, MF_DEBUG, MF_ERROR, name, MayaFlux::Buffers::VolumeGridBuffer::Field::stride_bytes, and MayaFlux::Kinesis::LatticeSemantics::value_class.

Here is the call graph for this function: