processing_function()

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

overridevirtual

BufferProcessor interface - uploads all bound geometries.

Parameters

buffer

The buffer this processor is attached to

Uploads all geometry nodes to their target vertex buffers. Uses staging buffers for device-local targets.

Implements MayaFlux::Buffers::BufferProcessor.

Definition at line 146 of file GeometryBindingsProcessor.cpp.

{
    if (m_texture_dirty.test(std::memory_order_acquire)) {
        m_texture_dirty.clear(std::memory_order_release);
        if (auto vk = std::dynamic_pointer_cast<VKBuffer>(buffer)) {
            if (auto rp = vk->get_render_processor()) {
                if (m_pending_texture) {
                    rp->bind_texture(m_pending_texture->binding, m_pending_texture->image);
                }
            }
        }
        m_pending_texture.reset();
    }
 
    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,
            "GeometryBindingsProcessor requires VKBuffer, got different buffer type");
        return;
    }
 
    for (auto& [name, binding] : m_bindings) {
        if (!binding.node->needs_gpu_update()) {
            MF_TRACE(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "Geometry '{}' unchanged, skipping upload", name);
            continue;
        }
 
        auto vertices = binding.node->get_vertex_data();
 
        if (vertices.empty()) {
            if (binding.gpu_vertex_buffer->is_host_visible()) {
                binding.gpu_vertex_buffer->clear();
            }
 
            if (binding.node->get_vertex_layout()) {
                binding.gpu_vertex_buffer->set_vertex_layout(
                    binding.node->get_vertex_layout().value());
            }
 
            MF_RT_TRACE(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "Geometry '{}' cleared", name);
            continue;
        }
 
        upload_resizing(
            vertices.data(),
            vertices.size_bytes(),
            binding.gpu_vertex_buffer,
            binding.staging_buffer);
 
        if (binding.node->get_vertex_layout()) {
            binding.gpu_vertex_buffer->set_vertex_layout(
                binding.node->get_vertex_layout().value());
 
            MF_RT_TRACE(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "Set vertex layout for '{}' ({} vertices, {} attributes)",
                name,
                binding.node->get_vertex_count(),
                binding.node->get_vertex_layout()->attributes.size());
        } else {
            MF_RT_WARN(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "Geometry node '{}' has no vertex layout. "
                "RenderProcessor may fail without layout info.",
                name);
        }
 
        upload_index_data(name, binding);
        binding.node->clear_gpu_update_flag();
    }
 
    bool attached_is_target = false;
    for (const auto& [name, binding] : m_bindings) {
        if (binding.gpu_vertex_buffer == vk_buffer) {
            attached_is_target = true;
            break;
        }
    }
 
    if (!attached_is_target && !m_bindings.empty()) {
        auto& first_binding = m_bindings.begin()->second;
        if (first_binding.node->needs_gpu_update()) {
            auto vertices = first_binding.node->get_vertex_data();
 
            if (!vertices.empty()) {
                upload_resizing(
                    vertices.data(),
                    vertices.size_bytes(),
                    vk_buffer,
                    first_binding.staging_buffer);
 
                if (first_binding.node->get_vertex_layout()) {
                    vk_buffer->set_vertex_layout(
                        first_binding.node->get_vertex_layout().value());
                }
            }
            upload_index_data(m_bindings.begin()->first, first_binding);
            first_binding.node->clear_gpu_update_flag();
        }
    }
}

References MayaFlux::Journal::BufferProcessing, MayaFlux::Journal::Buffers, m_bindings, m_pending_texture, m_texture_dirty, MF_RT_ERROR, MF_RT_TRACE, MF_RT_WARN, MF_TRACE, upload_index_data(), and MayaFlux::Buffers::upload_resizing().

Here is the call graph for this function: