setup_backend_service()

void MayaFlux::Core::BackendWindowHandler::setup_backend_service

(

const std::shared_ptr< Registry::Service::DisplayService > &

display_service

)

Definition at line 70 of file BackendWindowHandler.cpp.

{
    display_service->present_frame = [this](const std::shared_ptr<void>& window_ptr, uint64_t command_buffer_bits) {
        auto window = std::static_pointer_cast<Window>(window_ptr);
        auto ctx = find_window_context(window);
        if (!ctx) {
            MF_RT_ERROR(Journal::Component::Core, Journal::Context::GraphicsCallback,
                "Window '{}' not registered for presentation", window->get_create_info().title);
            return;
        }
        ctx->command_buffer = *reinterpret_cast<vk::CommandBuffer*>(&command_buffer_bits);
        this->render_window(window);
    };
 
    display_service->wait_idle = [this]() {
        m_context.get_device().waitIdle();
    };
 
    display_service->resize_surface = [this](const std::shared_ptr<void>& window_ptr, uint32_t width, uint32_t height) {
        auto window = std::static_pointer_cast<Window>(window_ptr);
        window->set_size(width, height);
        for (auto& ctx : m_window_contexts) {
            if (ctx.window == window) {
                ctx.needs_recreation = true;
                break;
            }
        }
    };
 
    display_service->get_swapchain_image_count = [this](const std::shared_ptr<void>& window_ptr) -> uint32_t {
        auto window = std::static_pointer_cast<Window>(window_ptr);
        for (const auto& ctx : m_window_contexts) {
            if (ctx.window == window) {
                return static_cast<uint32_t>(ctx.swapchain->get_image_count());
            }
        }
        return 0;
    };
 
    display_service->get_swapchain_format = [this](const std::shared_ptr<void>& window_ptr) -> uint32_t {
        auto window = std::static_pointer_cast<Window>(window_ptr);
        for (const auto& ctx : m_window_contexts) {
            if (ctx.window == window) {
                return static_cast<int>(ctx.swapchain->get_image_format());
            }
        }
        return 0;
    };
 
    display_service->get_current_framebuffer = [this](const std::shared_ptr<void>& window_ptr) -> void* {
        auto window = std::static_pointer_cast<Window>(window_ptr);
        auto* context = find_window_context(window);
 
        if (!context || context->framebuffers.empty()) {
            return nullptr;
        }
 
        size_t frame_index = context->current_frame % context->framebuffers.size();
        auto& handle = *context->framebuffers[frame_index];
        return static_cast<void*>(&handle);
    };
 
    display_service->get_swapchain_extent = [this](
                                                const std::shared_ptr<void>& window_ptr,
                                                uint32_t& out_width,
                                                uint32_t& out_height) {
        auto window = std::static_pointer_cast<Window>(window_ptr);
        auto* context = find_window_context(window);
 
        if (context && context->swapchain) {
            auto extent = context->swapchain->get_extent();
            out_width = extent.width;
            out_height = extent.height;
        } else {
            out_width = 0;
            out_height = 0;
        }
    };
 
    display_service->get_window_render_pass = [this](const std::shared_ptr<void>& window_ptr) -> void* {
        auto window = std::static_pointer_cast<Window>(window_ptr);
        auto* context = find_window_context(window);
 
        if (!context || !context->render_pass) {
            return nullptr;
        }
 
        vk::RenderPass rp = context->render_pass->get();
        return static_cast<void*>(rp);
    };
 
    display_service->attach_render_pass = [this](
                                              const std::shared_ptr<void>& window_ptr,
                                              const std::shared_ptr<void>& render_pass_handle) -> bool {
        auto window = std::static_pointer_cast<Window>(window_ptr);
        auto render_pass = std::static_pointer_cast<Core::VKRenderPass>(render_pass_handle);
        return this->attach_render_pass(window, render_pass);
    };
}

References attach_render_pass(), MayaFlux::Journal::Core, find_window_context(), MayaFlux::Core::VKContext::get_device(), MayaFlux::Journal::GraphicsCallback, m_context, m_window_contexts, MF_RT_ERROR, and render_window().

Here is the call graph for this function: