processing_function()

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

overridevirtual

BufferProcessor interface - aggregates and uploads network geometry.

Parameters

buffer

The buffer this processor is attached to

For each bound network:

1. Extract vertices from all internal nodes
2. Aggregate into single vertex array
3. Upload to GPU vertex buffer

Implements MayaFlux::Buffers::BufferProcessor.

Definition at line 104 of file NetworkGeometryProcessor.cpp.

{
    if (m_bindings.empty())
        return;
 
    auto vk_buffer = std::dynamic_pointer_cast<VKBuffer>(buffer);
    if (!vk_buffer) {
        MF_RT_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "NetworkGeometryProcessor requires VKBuffer");
        return;
    }
 
    for (auto& [name, binding] : m_bindings) {
        if (!binding.network || !binding.network->is_enabled()) {
            MF_RT_TRACE(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "Network '{}' disabled, skipping upload", name);
            continue;
        }
 
        const auto* chain = binding.network->get_operator_chain().get();
        const bool has_chain = chain && !chain->empty();
 
        if (!has_chain) {
            auto* primary_op = dynamic_cast<Nodes::Network::GraphicsOperator*>(
                binding.network->get_operator());
 
            if (primary_op && primary_op->supports_incremental_upload()) {
                const auto layout = primary_op->get_vertex_layout();
                const size_t total = static_cast<size_t>(primary_op->get_vertex_count())
                    * layout.stride_bytes;
                if (total > 0
                    && try_incremental_upload(primary_op, layout.stride_bytes,
                        binding, vk_buffer, total, name)) {
                    continue;
                }
            }
 
            auto gpu_data = extract_network_gpu_data(binding.network, name);
            if (gpu_data.vertex_data.empty() || gpu_data.vertex_count == 0) {
                if (vk_buffer->is_host_visible())
                    vk_buffer->clear();
                if (gpu_data.layout)
                    vk_buffer->set_vertex_layout(*gpu_data.layout);
                continue;
            }
 
            size_t total = gpu_data.vertex_data.size();
 
            if (total > vk_buffer->get_size_bytes()) {
                vk_buffer->resize(static_cast<size_t>(static_cast<float>(total) * 1.5F), false);
            }
 
            ensure_staging(binding, total);
            upload_to_gpu(gpu_data.vertex_data.data(), total, vk_buffer, binding.staging_buffer);
 
            if (gpu_data.layout)
                vk_buffer->set_vertex_layout(*gpu_data.layout);
 
            if (auto ngb = std::dynamic_pointer_cast<NetworkGeometryBuffer>(buffer);
                ngb && primary_op) {
                ngb->update_render_runs(primary_op->topology_runs());
            }
 
            binding.last_total_bytes = total;
 
            MF_RT_TRACE(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "Uploaded {} vertices from network '{}' ({} bytes)",
                gpu_data.vertex_count, name, total);
            continue;
        }
 
        struct SliceData {
            std::span<const uint8_t> bytes;
            size_t vertex_count {};
            std::optional<Kakshya::VertexLayout> layout;
            Nodes::Network::GraphicsOperator* op {};
        };
 
        std::vector<SliceData> slices;
        slices.reserve(1 + chain->size());
 
        auto primary = extract_network_gpu_data(binding.network, name);
        slices.push_back({ .bytes = primary.vertex_data,
            .vertex_count = primary.vertex_count,
            .layout = primary.layout,
            .op = dynamic_cast<Nodes::Network::GraphicsOperator*>(
                binding.network->get_operator()) });
 
        for (const auto& op : chain->operators()) {
            auto* gfx = dynamic_cast<Nodes::Network::GraphicsOperator*>(op.get());
            if (!gfx) {
                slices.push_back({ .bytes = {}, .vertex_count = 0, .layout = std::nullopt, .op = nullptr });
                continue;
            }
 
            if (!gfx->participates_in_rendering())
                continue;
 
            slices.push_back({ .bytes = gfx->get_vertex_data(),
                .vertex_count = gfx->get_vertex_count(),
                .layout = gfx->get_vertex_layout(),
                .op = gfx });
        }
 
        size_t total_bytes = 0;
        for (const auto& s : slices)
            total_bytes += s.bytes.size();
 
        if (total_bytes == 0) {
            if (vk_buffer->is_host_visible())
                vk_buffer->clear();
            if (primary.layout)
                vk_buffer->set_vertex_layout(*primary.layout);
            continue;
        }
 
        bool chain_gfx_dirty = false;
        bool needs_full_restore = false;
        for (const auto& op : chain->operators()) {
            if (op && op->demands_full_vertex_restore())
                needs_full_restore = true;
 
            auto* gfx = dynamic_cast<Nodes::Network::GraphicsOperator*>(op.get());
            if (gfx && gfx->participates_in_rendering() && gfx->is_vertex_data_dirty())
                chain_gfx_dirty = true;
        }
 
        if (!needs_full_restore && !chain_gfx_dirty && primary.layout.has_value()
            && try_incremental_upload(
                dynamic_cast<Nodes::Network::GraphicsOperator*>(binding.network->get_operator()),
                primary.layout->stride_bytes, binding, vk_buffer, total_bytes, name)) {
            continue;
        }
 
        if (total_bytes > vk_buffer->get_size_bytes()) {
            vk_buffer->resize(static_cast<size_t>(static_cast<float>(total_bytes) * 1.5F), false);
        }
 
        m_staging_aggregate.resize(total_bytes);
        size_t byte_offset = 0;
        for (const auto& s : slices) {
            if (!s.bytes.empty())
                std::memcpy(m_staging_aggregate.data() + byte_offset, s.bytes.data(), s.bytes.size());
            byte_offset += s.bytes.size();
        }
 
        ensure_staging(binding, total_bytes);
        upload_to_gpu(m_staging_aggregate.data(), total_bytes, vk_buffer, binding.staging_buffer);
 
        size_t aggregate_vertices = 0;
        for (const auto& s : slices)
            aggregate_vertices += s.vertex_count;
 
        for (auto& slice : std::views::reverse(slices)) {
            if (slice.layout) {
                auto aggregate = *slice.layout;
                aggregate.vertex_count = static_cast<uint32_t>(aggregate_vertices);
                vk_buffer->set_vertex_layout(aggregate);
                break;
            }
        }
 
        auto ngb = std::dynamic_pointer_cast<NetworkGeometryBuffer>(buffer);
        if (ngb) {
            byte_offset = 0;
            for (size_t i = 0; i < slices.size(); ++i) {
                const auto& s = slices[i];
                const uint32_t stride = s.layout ? s.layout->stride_bytes
                                                 : (slices[0].layout ? slices[0].layout->stride_bytes : 0);
                const uint32_t vert_offset = stride > 0
                    ? static_cast<uint32_t>(byte_offset / stride)
                    : 0;
 
                std::vector<Portal::Graphics::DrawRun> runs;
                if (s.op) {
                    for (auto run : s.op->topology_runs()) {
                        if (run.vertex_count == 0)
                            continue;
                        run.vertex_offset += vert_offset;
                        runs.push_back(run);
                    }
                }
 
                ngb->update_chain_render_range(i, vert_offset,
                    static_cast<uint32_t>(s.vertex_count), s.layout, std::move(runs));
 
                byte_offset += s.bytes.size();
            }
        }
 
        binding.last_total_bytes = total_bytes;
 
        MF_RT_TRACE(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "Uploaded {} bytes ({} slices) from network '{}'",
            total_bytes, slices.size(), name);
    }
}

References buffer, MayaFlux::Journal::BufferProcessing, MayaFlux::Journal::Buffers, chain, ensure_staging(), MayaFlux::Buffers::extract_network_gpu_data(), MayaFlux::Nodes::Network::GraphicsOperator::get_vertex_layout(), m_bindings, m_staging_aggregate, MF_RT_ERROR, MF_RT_TRACE, name, run(), MayaFlux::Kakshya::VertexLayout::stride_bytes, total, try_incremental_upload(), and MayaFlux::Buffers::upload_to_gpu().

Here is the call graph for this function: