processing_function()

void MayaFlux::Buffers::CompositeGeometryProcessor::processing_function ( const std::shared_ptr< Buffer > &  buffer )

overridevirtual

BufferProcessor interface - aggregates all geometry.

Implements MayaFlux::Buffers::BufferProcessor.

Definition at line 82 of file CompositeGeometryProcessor.cpp.

{
    if (m_collections.empty())
        return;
 
    auto vk_buffer = std::dynamic_pointer_cast<VKBuffer>(buffer);
    if (!vk_buffer) {
        MF_RT_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "CompositeGeometryProcessor requires VKBuffer");
        return;
    }
 
    size_t total_bytes = 0;
    for (const auto& col : m_collections) {
        total_bytes += col.node->get_vertex_buffer_size_bytes();
    }
 
    if (total_bytes == 0) {
        if (vk_buffer->is_host_visible())
            vk_buffer->clear();
        return;
    }
 
    size_t available_size = vk_buffer->get_size_bytes();
    if (total_bytes > available_size) {
        auto new_size = static_cast<size_t>(static_cast<float>(total_bytes) * 1.5F);
        vk_buffer->resize(new_size, false);
        available_size = new_size;
    }
 
    m_staging_aggregate.resize(total_bytes);
    size_t current_byte_offset = 0;
 
    for (auto& col : m_collections) {
        auto vertex_data = col.node->get_vertex_data();
 
        if (vertex_data.empty()) {
            col.vertex_offset = 0;
            col.vertex_count = 0;
            continue;
        }
 
        std::memcpy(
            m_staging_aggregate.data() + current_byte_offset,
            vertex_data.data(),
            vertex_data.size_bytes());
 
        size_t stride = col.node->get_vertex_stride();
        if (stride == 0) {
            MF_RT_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "Collection '{}' has zero vertex stride", col.name);
            continue;
        }
 
        col.vertex_offset = static_cast<uint32_t>(current_byte_offset / stride);
        col.vertex_count = col.node->get_vertex_count();
        // col.vertex_count = static_cast<uint32_t>(vertex_data.size_bytes() / stride);
 
        if (auto layout = col.node->get_vertex_layout()) {
            layout->vertex_count = col.vertex_count;
            layout->stride_bytes = static_cast<uint32_t>(stride);
            col.vertex_layout = std::move(layout);
        }
 
        MF_RT_TRACE(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "Collection '{}': {} vertices at offset {} (stride: {})",
            col.name, col.vertex_count, col.vertex_offset, stride);
 
        current_byte_offset += vertex_data.size_bytes();
    }
 
    auto composite_buffer = std::dynamic_pointer_cast<CompositeGeometryBuffer>(buffer);
    if (composite_buffer) {
        for (const auto& col : m_collections) {
            composite_buffer->update_collection_render_range(
                col.name, col.vertex_offset, col.vertex_count);
 
            if (col.vertex_layout) {
                composite_buffer->update_collection_vertex_layout(
                    col.name, *col.vertex_layout);
            }
        }
    }
 
    upload_to_gpu(
        m_staging_aggregate.data(),
        std::min(total_bytes, available_size),
        vk_buffer,
        nullptr);
}

References MayaFlux::Journal::BufferProcessing, MayaFlux::Journal::Buffers, m_collections, m_staging_aggregate, MF_RT_ERROR, MF_RT_TRACE, and MayaFlux::Buffers::upload_to_gpu().

Here is the call graph for this function: