declare_state()

bool MayaFlux::Buffers::NetworkGeometryBuffer::declare_state	(	const std::string &	name,
		size_t	element_count,
		size_t	stride_bytes,
		bool	double_buffered = true
	)

Declare a named auxiliary state field alongside the vertex data.

Parameters

name	Lookup key, unique within this buffer.
element_count	Number of elements the field holds. Fixed at declaration: it does not track later growth of the vertex buffer itself, since NetworkGeometryProcessor's resize path (1.5x headroom on overflow) has no knowledge of declared state fields. Declare at the network's expected particle count.
stride_bytes	Bytes per element.
double_buffered	False resolves read and write to one slot, which suits a value recomputed from other state each cycle.

Returns

True if the field was registered.

Mirrors VolumeGridBuffer::allocate_field: storage lives as raw handle pairs in the base VKBuffer's back_buffers, addressed by name rather than wrapped in a VKBuffer of its own. A processor resolves the handle it needs through read_state_handle/write_state_handle and writes its own descriptor directly against ShaderFoundry, the way VolumeFieldProcessor does for volume fields, rather than going through bind_buffer or the buffer's shared pipeline_context.

Definition at line 295 of file NetworkGeometryBuffer.cpp.

{
    if (name.empty()) {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::Init,
            "NetworkGeometryBuffer: state field declared with empty name, skipped");
        return false;
    }
 
    if (element_count == 0 || stride_bytes == 0) {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::Init,
            "NetworkGeometryBuffer: state field '{}' declares zero element count "
            "or stride, skipped",
            name);
        return false;
    }
 
    if (m_state_fields.contains(name)) {
        MF_ERROR(Journal::Component::Buffers, Journal::Context::Init,
            "NetworkGeometryBuffer: duplicate state 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(),
            "NetworkGeometryBuffer 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 = element_count * stride_bytes;
    const uint32_t slot_count = double_buffered ? 2 : 1;
 
    StateField field {
        .element_count = element_count,
        .stride_bytes = stride_bytes,
        .slot_a = static_cast<uint32_t>(resources.back_buffers.size()),
        .slot_b = 0,
        .read_is_a = true,
    };
 
    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_state_fields.emplace(name, field);
 
    MF_DEBUG(Journal::Component::Buffers, Journal::Context::Init,
        "NetworkGeometryBuffer: state field '{}', {} elements, stride {}, {} slot(s), {} bytes",
        name, element_count, stride_bytes, slot_count, field_bytes * slot_count);
 
    return true;
}

References MayaFlux::Buffers::VKBufferResources::GenerationSlot::buffer, MayaFlux::Journal::Buffers, MayaFlux::Buffers::NetworkGeometryBuffer::StateField::element_count, MayaFlux::Buffers::VKBuffer::get_buffer_resources(), MayaFlux::Registry::BackendRegistry::get_service(), MayaFlux::Journal::Init, MayaFlux::Registry::BackendRegistry::instance(), m_state_fields, MayaFlux::Buffers::VKBufferResources::GenerationSlot::mapped_ptr, MayaFlux::Buffers::VKBufferResources::GenerationSlot::memory, MF_DEBUG, MF_ERROR, and name.

Referenced by ensure_cluster_ids().

Here is the call graph for this function:

Here is the caller graph for this function: