ensure_buffers()

bool MayaFlux::Portal::Graphics::PrimitiveMill::ensure_buffers ( const std::shared_ptr< Buffers::VKBuffer > &  source, const Kakshya::VertexLayout &  layout, uint32_t  total, size_t  run_count  )

private

Grows the destination ring, run and prefix buffers to fit.

Every slot is replaced at once, so one capacity covers them all. Doing so frees buffers a recorded draw may still name, hence the graphics queue drain first, and hence the 1.5x headroom: geometry a caller is actively adding to would otherwise re-grow, and stall, on nearly every cycle.

Definition at line 527 of file PrimitiveMill.cpp.

{
    auto svc = Registry::BackendRegistry::instance()
                   .get_service<Registry::Service::BufferService>();
    if (!svc) {
        MF_RT_ERROR(Journal::Component::Portal, Journal::Context::Rendering,
            "PrimitiveMill: BufferService unavailable");
        return false;
    }
 
    if (total > m_output_capacity || m_outputs.size() != m_output_ring) {
        const auto grown = static_cast<uint32_t>(static_cast<float>(total) * 1.5F);
 
        auto milled_layout = layout;
        milled_layout.vertex_count = total;
 
        if (!m_outputs.empty()) {
            get_shader_foundry().get_graphics_queue().waitIdle();
        }
 
        m_outputs.assign(m_output_ring, nullptr);
        for (auto& slot : m_outputs) {
            slot = std::make_shared<VKBuffer>(
                static_cast<size_t>(grown) * layout.stride_bytes,
                VKBuffer::Usage::VERTEX,
                source->get_modality());
            slot->set_vertex_layout(milled_layout);
            svc->initialize_buffer(slot);
        }
 
        m_output_capacity = grown;
        m_output_slot = 0;
        m_descriptors_written = false;
        m_bound_source.reset();
    } else {
        for (auto& slot : m_outputs) {
            auto milled_layout = *slot->get_vertex_layout();
            milled_layout.vertex_count = total;
            slot->set_vertex_layout(milled_layout);
        }
    }
 
    const auto run_bytes = std::max<size_t>(run_count * RUN_WORDS * sizeof(uint32_t), sizeof(uint32_t));
    if (!m_run_buf || m_run_buf->get_size_bytes() < run_bytes) {
        m_run_buf = std::make_shared<VKBuffer>(
            run_bytes, VKBuffer::Usage::HOST_STORAGE, Kakshya::DataModality::UNKNOWN);
        svc->initialize_buffer(m_run_buf);
        m_bound_source.reset();
    }
 
    const auto prefix_bytes = std::max<size_t>(m_prefix.size() * sizeof(uint32_t), sizeof(uint32_t));
    if (!m_prefix_buf || m_prefix_buf->get_size_bytes() < prefix_bytes) {
        m_prefix_buf = std::make_shared<VKBuffer>(
            prefix_bytes, VKBuffer::Usage::HOST_STORAGE, Kakshya::DataModality::UNKNOWN);
        svc->initialize_buffer(m_prefix_buf);
        m_bound_source.reset();
    }
 
    return !m_outputs.empty() && m_run_buf && m_prefix_buf;
}

References MayaFlux::Portal::Graphics::ShaderFoundry::get_graphics_queue(), MayaFlux::Registry::BackendRegistry::get_service(), MayaFlux::Portal::Graphics::get_shader_foundry(), MayaFlux::Registry::BackendRegistry::instance(), m_bound_source, m_descriptors_written, m_output_capacity, m_output_ring, m_output_slot, m_outputs, m_prefix, m_prefix_buf, m_run_buf, MF_RT_ERROR, MayaFlux::Journal::Portal, MayaFlux::Journal::Rendering, run_count, MayaFlux::Kakshya::VertexLayout::stride_bytes, total, MayaFlux::Kakshya::UNKNOWN, and MayaFlux::Kakshya::VertexLayout::vertex_count.

Referenced by mill().

Here is the call graph for this function:

Here is the caller graph for this function: