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 100 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, got different buffer type");
        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;
        }
 
        std::vector<Nodes::GpuSync::PointVertex> vertices;
 
        if (auto particle_net = std::dynamic_pointer_cast<Nodes::Network::ParticleNetwork>(binding.network)) {
            vertices = extract_particle_vertices(particle_net);
        } else {
            vertices = extract_network_vertices(binding.network);
        }
 
        if (vertices.empty()) {
            if (binding.gpu_vertex_buffer->is_host_visible()) {
                binding.gpu_vertex_buffer->clear();
            }
            MF_RT_TRACE(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "Network '{}' has no vertices, cleared buffer", name);
            continue;
        }
 
        size_t required_size = vertices.size() * sizeof(Nodes::GpuSync::PointVertex);
        size_t available_size = binding.gpu_vertex_buffer->get_size_bytes();
 
        if (required_size > available_size) {
            auto new_size = static_cast<size_t>(required_size * 1.5F);
 
            MF_RT_TRACE(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "Network '{}' growing: resizing GPU buffer from {} → {} bytes",
                name, available_size, new_size);
 
            binding.gpu_vertex_buffer->resize(new_size, false);
            available_size = new_size;
 
            if (binding.staging_buffer) {
                binding.staging_buffer->resize(new_size, false);
                MF_RT_TRACE(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                    "Resized staging buffer for '{}' to {} bytes", name, new_size);
            }
        }
 
        size_t upload_size = std::min<size_t>(required_size, available_size);
 
        upload_to_gpu(
            vertices.data(),
            upload_size,
            binding.gpu_vertex_buffer,
            binding.staging_buffer);
 
        Kakshya::VertexLayout layout;
        layout.vertex_count = static_cast<uint32_t>(vertices.size());
        layout.stride_bytes = sizeof(Nodes::GpuSync::PointVertex);
 
        layout.attributes.push_back(Kakshya::VertexAttributeLayout {
            .component_modality = Kakshya::DataModality::VERTEX_POSITIONS_3D,
            .offset_in_vertex = 0,
            .name = "position" });
 
        layout.attributes.push_back(Kakshya::VertexAttributeLayout {
            .component_modality = Kakshya::DataModality::VERTEX_COLORS_RGB,
            .offset_in_vertex = sizeof(glm::vec3),
            .name = "color" });
 
        layout.attributes.push_back(Kakshya::VertexAttributeLayout {
            .component_modality = Kakshya::DataModality::UNKNOWN,
            .offset_in_vertex = sizeof(glm::vec3) + sizeof(glm::vec3),
            .name = "size" });
 
        binding.gpu_vertex_buffer->set_vertex_layout(layout);
 
        MF_RT_TRACE(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "Uploaded {} vertices from network '{}' ({} bytes)",
            vertices.size(), name, upload_size);
    }
}

References MayaFlux::Kakshya::VertexLayout::attributes, MayaFlux::Journal::BufferProcessing, MayaFlux::Journal::Buffers, MayaFlux::Kakshya::VertexAttributeLayout::component_modality, extract_network_vertices(), extract_particle_vertices(), m_bindings, MF_RT_ERROR, MF_RT_TRACE, MayaFlux::Kakshya::VertexLayout::stride_bytes, MayaFlux::Kakshya::UNKNOWN, MayaFlux::Buffers::upload_to_gpu(), MayaFlux::Kakshya::VERTEX_COLORS_RGB, MayaFlux::Kakshya::VertexLayout::vertex_count, and MayaFlux::Kakshya::VERTEX_POSITIONS_3D.

Here is the call graph for this function: