fallback_renderer()

void MayaFlux::Buffers::PresentProcessor::fallback_renderer ( const std::shared_ptr< RootGraphicsBuffer > &  root )

private

Definition at line 244 of file RootGraphicsBuffer.cpp.

{
    const auto& renderable_buffers = root->get_renderable_buffers();
    const auto& pending_refreshes = root->get_pending_presentation_refreshes();
    if (renderable_buffers.empty() && pending_refreshes.empty()) {
        return;
    }
 
    std::unordered_map<std::shared_ptr<Core::Window>, std::vector<const RootGraphicsBuffer::RenderableBufferInfo*>> buffers_by_window;
    for (auto it = pending_refreshes.begin(); it != pending_refreshes.end();) {
        const auto& window = *it++;
        if (window->should_close() || !window->is_graphics_registered()) {
            root->clear_presentation_refresh(window);
            continue;
        }
        buffers_by_window.try_emplace(window);
    }
 
    for (const auto& renderable : renderable_buffers) {
        if (renderable.target_window && renderable.target_window->is_graphics_registered()
            && renderable.command_buffer_id != Portal::Graphics::INVALID_COMMAND_BUFFER) {
            buffers_by_window[renderable.target_window].push_back(&renderable);
        }
    }
 
    if (buffers_by_window.empty()) {
        root->clear_renderable_buffers();
        return;
    }
 
    MF_RT_DEBUG(Journal::Component::Buffers, Journal::Context::BufferProcessing,
        "PresentProcessor submitting to {} windows", buffers_by_window.size());
 
    auto& foundry = Portal::Graphics::get_shader_foundry();
    auto& flow = Portal::Graphics::get_render_flow();
    auto display_service = Registry::BackendRegistry::instance()
                               .get_service<Registry::Service::DisplayService>();
 
    if (!display_service) {
        MF_RT_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
            "DisplayService not available for dynamic rendering");
        return;
    }
 
    for (const auto& [window, buffer_infos] : buffers_by_window) {
        uint64_t image_bits = display_service->acquire_next_swapchain_image(window);
        if (image_bits == 0) {
            MF_RT_WARN(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "Failed to acquire swapchain image for window '{}'",
                window->get_create_info().title);
            continue;
        }
        vk::Image swapchain_image { reinterpret_cast<VkImage>(image_bits) };
 
        auto primary_cmd_id = foundry.begin_commands(Portal::Graphics::ShaderFoundry::CommandBufferType::GRAPHICS);
        auto primary_cmd = foundry.get_command_buffer(primary_cmd_id);
 
        if (!primary_cmd) {
            MF_RT_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "Failed to create primary command buffer for window '{}'",
                window->get_create_info().title);
            for (const auto* info : buffer_infos) {
                info->buffer->clear_pipeline_commands();
            }
            continue;
        }
 
        try {
            bool window_needs_depth = false;
            for (const auto* info : buffer_infos) {
                if (info->needs_depth) {
                    window_needs_depth = true;
                    break;
                }
            }
 
            vk::ImageView depth_view = nullptr;
            if (window_needs_depth) {
                display_service->ensure_depth_attachment(window);
                auto* view_ptr = display_service->get_depth_image_view(window);
                if (view_ptr) {
                    depth_view = *static_cast<vk::ImageView*>(view_ptr);
                }
            }
 
            flow.begin_rendering(primary_cmd_id, window, swapchain_image,
                Portal::Graphics::default_color, depth_view);
 
            std::vector<vk::CommandBuffer> secondary_buffers;
            for (const auto* info : buffer_infos) {
                auto secondary = foundry.get_command_buffer(info->command_buffer_id);
                if (secondary) {
                    secondary_buffers.push_back(secondary);
                }
            }
 
            if (!secondary_buffers.empty()) {
                primary_cmd.executeCommands(secondary_buffers);
            }
 
            flow.end_rendering(primary_cmd_id, window);
 
            foundry.end_commands(primary_cmd_id);
            uint64_t primary_bits = *reinterpret_cast<uint64_t*>(&primary_cmd);
            display_service->submit_and_present(window, primary_bits);
            root->clear_presentation_refresh(window);
 
            MF_RT_DEBUG(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "Presented {} buffers to window '{}'",
                secondary_buffers.size(), window->get_create_info().title);
 
        } catch (const std::exception& e) {
            MF_RT_ERROR(Journal::Component::Buffers, Journal::Context::BufferProcessing,
                "Failed to submit/present for window '{}': {}",
                window->get_create_info().title,
                e.what());
        }
 
        for (const auto* info : buffer_infos) {
            info->buffer->clear_pipeline_commands();
        }
    }
 
    root->clear_renderable_buffers();
}

References MayaFlux::Journal::BufferProcessing, MayaFlux::Journal::Buffers, MayaFlux::Portal::Graphics::default_color, MayaFlux::Portal::Graphics::get_render_flow(), MayaFlux::Registry::BackendRegistry::get_service(), MayaFlux::Portal::Graphics::get_shader_foundry(), MayaFlux::Portal::Graphics::ShaderFoundry::GRAPHICS, MayaFlux::Registry::BackendRegistry::instance(), MayaFlux::Portal::Graphics::INVALID_COMMAND_BUFFER, MF_RT_DEBUG, MF_RT_ERROR, MF_RT_WARN, and window.

Referenced by processing_function().

Here is the call graph for this function:

Here is the caller graph for this function: