processing_function()

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

overridevirtual

Processes a buffer by coordinating child buffer operations.

Parameters

buffer

Buffer to process (should be RootGraphicsBuffer)

This executes the batch processing loop:

1. Iterates through all child buffers
2. Executes each buffer's default processor
3. Runs each buffer's processing chain
4. Handles synchronization and error cases

Implements MayaFlux::Buffers::BufferProcessor.

Definition at line 20 of file RootGraphicsBuffer.cpp.

{
    auto root_buf = std::dynamic_pointer_cast<RootGraphicsBuffer>(buffer);
    if (!root_buf || root_buf != m_root_buffer.lock()) {
        MF_RT_ERROR(Journal::Component::Core, Journal::Context::BufferProcessing,
            "GraphicsBatchProcessor can only process its associated RootGraphicsBuffer");
        return;
    }
 
    root_buf->clear_renderable_buffers();
    root_buf->cleanup_marked_buffers();
 
    for (const auto& child : root_buf->get_child_buffers()) {
        if (!child)
            continue;
        child->clear_pipeline_commands();
 
        try {
            if (!child->needs_removal() && child->has_data_for_cycle()) {
                if (child->needs_default_processing() && child->get_default_processor())
                    child->process_default();
 
                if (auto chain = child->get_processing_chain()) {
                    if (child->has_data_for_cycle())
                        chain->process_complete(child);
                }
 
                if (!child->needs_removal()) {
                    for (const auto& [id, window] : child->get_render_pipelines()) {
                        const auto command = child->get_pipeline_command(id);
                        if (command == Portal::Graphics::INVALID_COMMAND_BUFFER)
                            continue;
 
                        RootGraphicsBuffer::RenderableBufferInfo info;
                        info.buffer = child;
                        info.target_window = window;
                        info.pipeline_id = id;
                        info.command_buffer_id = command;
                        info.needs_depth = child->needs_depth_attachment();
                        root_buf->add_renderable_buffer(info);
                    }
                }
            }
        } catch (const std::exception& e) {
            MF_RT_ERROR(Journal::Component::Core, Journal::Context::BufferProcessing,
                "Error processing graphics buffer: {}", e.what());
        }
 
        if (child->needs_removal()) {
            for (const auto& [id, window] : child->get_render_pipelines())
                root_buf->request_presentation_refresh(window);
        }
        for (const auto& window : child->take_presentation_refreshes())
            root_buf->request_presentation_refresh(window);
    }
 
    const auto& refreshes = root_buf->get_pending_presentation_refreshes();
    if (!refreshes.empty()) {
        std::erase_if(root_buf->m_renderable_buffers, [&refreshes](const auto& info) {
            return refreshes.contains(info.target_window);
        });
 
        for (const auto& child : root_buf->get_child_buffers()) {
            if (!child || child->needs_removal())
                continue;
 
            for (const auto& [id, window] : child->get_render_pipelines()) {
                if (!refreshes.contains(window) || !window || !window->is_graphics_registered())
                    continue;
 
                auto render = child->get_render_processor(id);
                if (!render || !render->is_visible(child))
                    continue;
 
                try {
                    auto command = child->get_pipeline_command(id);
                    if (command == Portal::Graphics::INVALID_COMMAND_BUFFER) {
                        render->record_draw(child);
                        command = child->get_pipeline_command(id);
                    }
                    if (command == Portal::Graphics::INVALID_COMMAND_BUFFER)
                        continue;
 
                    RootGraphicsBuffer::RenderableBufferInfo info;
                    info.buffer = child;
                    info.target_window = window;
                    info.pipeline_id = id;
                    info.command_buffer_id = command;
                    info.needs_depth = child->needs_depth_attachment();
                    root_buf->add_renderable_buffer(info);
                } catch (const std::exception& e) {
                    MF_RT_ERROR(Journal::Component::Core, Journal::Context::BufferProcessing,
                        "Error recording retained graphics buffer: {}", e.what());
                }
            }
        }
    }
 
    root_buf->sort_renderable_buffers();
}

References buffer, MayaFlux::Buffers::RootGraphicsBuffer::RenderableBufferInfo::buffer, MayaFlux::Journal::BufferProcessing, chain, MayaFlux::Buffers::RootGraphicsBuffer::RenderableBufferInfo::command_buffer_id, MayaFlux::Journal::Core, MayaFlux::Portal::Graphics::INVALID_COMMAND_BUFFER, m_root_buffer, MF_RT_ERROR, MayaFlux::Buffers::RootGraphicsBuffer::RenderableBufferInfo::needs_depth, MayaFlux::Buffers::RootGraphicsBuffer::RenderableBufferInfo::pipeline_id, MayaFlux::Buffers::RootGraphicsBuffer::RenderableBufferInfo::target_window, and window.