setup_backend_service()

void MayaFlux::Core::BackendWindowHandler::setup_backend_service

(

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

display_service

)

Definition at line 137 of file BackendWindowHandler.cpp.

{
    display_service->submit_and_present = [this](
                                              const std::shared_ptr<void>& window_ptr,
                                              uint64_t primary_cmd_bits) {
        auto window = std::static_pointer_cast<Window>(window_ptr);
        vk::CommandBuffer primary_cmd = *reinterpret_cast<vk::CommandBuffer*>(&primary_cmd_bits);
 
        this->submit_and_present(window, primary_cmd);
    };
 
    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_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->acquire_next_swapchain_image = [this](const std::shared_ptr<void>& window_ptr) -> uint64_t {
        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 swapchain acquisition",
                window->get_create_info().title);
            return 0;
        }
 
        auto device = m_context.get_device();
        size_t frame_index = ctx->current_frame;
        auto& in_flight = ctx->in_flight[frame_index];
        auto& image_available = ctx->image_available[frame_index];
 
        if (device.waitForFences(1, &in_flight, VK_TRUE, UINT64_MAX) == vk::Result::eTimeout) {
            MF_RT_WARN(Journal::Component::Core, Journal::Context::GraphicsCallback,
                "Fence timeout during swapchain acquisition for window '{}'",
                window->get_create_info().title);
            return 0;
        }
 
        auto image_index_opt = ctx->swapchain->acquire_next_image(image_available);
        if (!image_index_opt.has_value()) {
            ctx->needs_recreation = true;
            return 0;
        }
 
        ctx->current_image_index = image_index_opt.value();
 
        if (device.resetFences(1, &in_flight) != vk::Result::eSuccess) {
            MF_RT_ERROR(Journal::Component::Core, Journal::Context::GraphicsCallback,
                "Failed to reset fence for window '{}'",
                window->get_create_info().title);
            return 0;
        }
 
        const auto& images = ctx->swapchain->get_images();
        VkImage raw = images[ctx->current_image_index];
        return reinterpret_cast<uint64_t>(raw);
    };
 
    display_service->get_current_image_view = [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->swapchain) {
            return nullptr;
        }
 
        const auto& image_views = context->swapchain->get_image_views();
        if (context->current_image_index >= image_views.size()) {
            MF_RT_ERROR(Journal::Component::Core, Journal::Context::GraphicsCallback,
                "Invalid current_image_index {} for window '{}' (swapchain has {} images)",
                context->current_image_index,
                window->get_create_info().title,
                image_views.size());
            return nullptr;
        }
 
        static thread_local vk::ImageView view;
        view = image_views[context->current_image_index];
        return static_cast<void*>(&view);
    };
 
    display_service->get_current_swapchain_image = [this](const std::shared_ptr<void>& window_ptr) -> uint64_t {
        auto window = std::static_pointer_cast<Window>(window_ptr);
        auto* ctx = find_window_context(window);
        if (!ctx || !ctx->swapchain)
            return 0;
 
        const auto& images = ctx->swapchain->get_images();
        if (ctx->current_image_index >= images.size())
            return 0;
 
        return reinterpret_cast<uint64_t>(static_cast<VkImage>(images[ctx->current_image_index]));
    };
 
    display_service->readback_swapchain_region = [this](
                                                     const std::shared_ptr<void>& window_ptr,
                                                     void* dst,
                                                     uint32_t /*x_offset*/,
                                                     uint32_t /*y_offset*/,
                                                     uint32_t pixel_width,
                                                     uint32_t pixel_height,
                                                     size_t byte_count) -> bool {
        auto window = std::static_pointer_cast<Window>(window_ptr);
        auto* ctx = find_window_context(window);
 
        if (!ctx || !ctx->swapchain) {
            MF_RT_ERROR(Journal::Component::Core, Journal::Context::GraphicsCallback,
                "readback_swapchain_region: window '{}' has no swapchain",
                window->get_create_info().title);
            return false;
        }
 
        if (!m_resource_manager) {
            MF_RT_ERROR(Journal::Component::Core, Journal::Context::GraphicsCallback,
                "readback_swapchain_region: resource manager not set");
            return false;
        }
 
        const auto& images = ctx->swapchain->get_images();
        if (ctx->current_image_index >= images.size()) {
            MF_RT_ERROR(Journal::Component::Core, Journal::Context::GraphicsCallback,
                "readback_swapchain_region: invalid image index {} for '{}'",
                ctx->current_image_index, window->get_create_info().title);
            return false;
        }
 
        auto proxy = std::make_shared<VKImage>(
            pixel_width, pixel_height, 1U,
            ctx->swapchain->get_image_format(),
            VKImage::Usage::TEXTURE_2D,
            VKImage::Type::TYPE_2D,
            1U, 1U,
            Kakshya::DataModality::IMAGE_COLOR);
 
        VKImageResources res {};
        res.image = images[ctx->current_image_index];
        proxy->set_image_resources(res);
        proxy->set_current_layout(vk::ImageLayout::ePresentSrcKHR);
 
        m_resource_manager->download_image_data(
            proxy,
            dst,
            byte_count,
            vk::ImageLayout::ePresentSrcKHR,
            vk::PipelineStageFlagBits::eBottomOfPipe);
 
        return true;
    };
 
    display_service->ensure_depth_attachment = [this](const std::shared_ptr<void>& window_ptr) {
        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,
                "ensure_depth_attachment: window '{}' not registered",
                window->get_create_info().title);
            return;
        }
        ensure_depth_image(*ctx);
    };
 
    display_service->get_depth_image_view = [this](const std::shared_ptr<void>& window_ptr) -> void* {
        auto window = std::static_pointer_cast<Window>(window_ptr);
        auto* ctx = find_window_context(window);
        if (!ctx || !ctx->depth_image || !ctx->depth_image->is_initialized()) {
            return nullptr;
        }
        static thread_local vk::ImageView view;
        view = ctx->depth_image->get_image_view();
        return static_cast<void*>(&view);
    };
 
    display_service->get_depth_format = [this](const std::shared_ptr<void>& window_ptr) -> uint32_t {
        auto window = std::static_pointer_cast<Window>(window_ptr);
        auto* ctx = find_window_context(window);
        if (!ctx || !ctx->depth_image || !ctx->depth_image->is_initialized()) {
            return static_cast<uint32_t>(vk::Format::eUndefined);
        }
        return static_cast<uint32_t>(ctx->depth_image->get_format());
    };
 
    // ======================================================================
    // get_last_frame – hazard‑pointer protected read + copy
    // ======================================================================
    display_service->get_last_frame = [this](const std::shared_ptr<void>& window_ptr)
        -> std::shared_ptr<std::vector<uint8_t>> {
        auto* ctx = find_window_context(std::static_pointer_cast<Window>(window_ptr));
        if (!ctx || !ctx->capture)
            return nullptr;
 
#ifdef MAYAFLUX_PLATFORM_MACOS
        auto& state = *ctx->capture;
 
        size_t slot = CaptureState::LAST_FRAME_MAX_READERS;
        for (size_t i = 0; i < CaptureState::LAST_FRAME_MAX_READERS; ++i) {
            bool expected = false;
            if (state.last_frame_slot_active[i].compare_exchange_strong(expected, true, std::memory_order_acquire)) {
                slot = i;
                break;
            }
        }
        if (slot == CaptureState::LAST_FRAME_MAX_READERS)
            return nullptr;
 
        const std::vector<uint8_t>* raw;
        do {
            raw = state.last_frame.load(std::memory_order_acquire);
            state.last_frame_hazard_ptrs[slot].store(raw, std::memory_order_release);
        } while (raw != state.last_frame.load(std::memory_order_acquire));
 
        if (!raw) {
            state.last_frame_hazard_ptrs[slot].store(nullptr, std::memory_order_release);
            state.last_frame_slot_active[slot].store(false, std::memory_order_release);
            return nullptr;
        }
 
        return std::shared_ptr<std::vector<uint8_t>>(
            const_cast<std::vector<uint8_t>*>(raw),
            [&state, slot](std::vector<uint8_t>*) {
                state.last_frame_hazard_ptrs[slot].store(nullptr, std::memory_order_release);
                state.last_frame_slot_active[slot].store(false, std::memory_order_release);
            });
#else
        return ctx->capture->last_frame.load(std::memory_order_acquire);
#endif
    };
 
    // ======================================================================
    // register_frame_observer – hazard‑pointer update of observer map
    // ======================================================================
    display_service->register_frame_observer = [this](
                                                   const std::shared_ptr<void>& window_ptr,
                                                   const std::function<void(
                                                       const std::shared_ptr<std::vector<uint8_t>>&,
                                                       uint32_t, uint32_t, uint32_t)>&
                                                       cb) -> uint32_t {
        auto* ctx = find_window_context(std::static_pointer_cast<Window>(window_ptr));
        if (!ctx) {
            MF_WARN(Journal::Component::Core, Journal::Context::GraphicsBackend,
                "register_frame_observer: window not registered with graphics backend");
            return 0;
        }
        if (!ctx->capture) {
            ensure_capture_state(*ctx);
        }
 
        auto& state = *ctx->capture;
        uint32_t id = state.next_observer_id.fetch_add(1, std::memory_order_relaxed);
 
#ifdef MAYAFLUX_PLATFORM_MACOS
        size_t obs_slot = CaptureState::OBSERVERS_MAX_READERS;
        for (size_t i = 0; i < CaptureState::OBSERVERS_MAX_READERS; ++i) {
            bool expected = false;
            if (state.observers_slot_active[i].compare_exchange_strong(expected, true, std::memory_order_acquire)) {
                obs_slot = i;
                break;
            }
        }
        if (obs_slot == CaptureState::OBSERVERS_MAX_READERS)
            return 0;
 
        const CaptureState::ObserverMap* current;
        CaptureState::ObserverMap* new_map = nullptr;
 
        do {
            if (new_map)
                delete new_map;
 
            do {
                current = state.observers.load(std::memory_order_acquire);
                state.observers_hazard_ptrs[obs_slot].store(current, std::memory_order_release);
            } while (current != state.observers.load(std::memory_order_acquire));
 
            new_map = new CaptureState::ObserverMap(current ? *current : CaptureState::ObserverMap {});
            (*new_map)[id] = cb;
 
        } while (!state.observers.compare_exchange_weak(current, new_map, std::memory_order_acq_rel, std::memory_order_acquire));
 
        state.observers_hazard_ptrs[obs_slot].store(nullptr, std::memory_order_release);
        state.observers_slot_active[obs_slot].store(false, std::memory_order_release);
 
        if (current)
            state.retire_observers(current);
#else
        auto current = state.observers.load(std::memory_order_acquire);
        std::shared_ptr<CaptureState::ObserverMap> next;
        do {
            next = std::make_shared<CaptureState::ObserverMap>(*current);
            (*next)[id] = cb;
        } while (!state.observers.compare_exchange_weak(
            current, next,
            std::memory_order_release, std::memory_order_acquire));
#endif
        return id;
    };
 
    // ======================================================================
    // unregister_frame_observer – hazard‑pointer update
    // ======================================================================
    display_service->unregister_frame_observer = [this](
                                                     const std::shared_ptr<void>& window_ptr, uint32_t id) {
        auto* ctx = find_window_context(std::static_pointer_cast<Window>(window_ptr));
        if (!ctx) {
            MF_WARN(Journal::Component::Core, Journal::Context::GraphicsBackend,
                "unregister_frame_observer: window not registered with graphics backend");
            return;
        }
        if (!ctx->capture) {
            MF_WARN(Journal::Component::Core, Journal::Context::GraphicsBackend,
                "unregister_frame_observer: capture not active for '{}'",
                ctx->window->get_create_info().title);
            return;
        }
 
        auto& state = *ctx->capture;
 
#ifdef MAYAFLUX_PLATFORM_MACOS
        size_t obs_slot = CaptureState::OBSERVERS_MAX_READERS;
        for (size_t i = 0; i < CaptureState::OBSERVERS_MAX_READERS; ++i) {
            bool expected = false;
            if (state.observers_slot_active[i].compare_exchange_strong(expected, true, std::memory_order_acquire)) {
                obs_slot = i;
                break;
            }
        }
        if (obs_slot == CaptureState::OBSERVERS_MAX_READERS)
            return;
 
        const CaptureState::ObserverMap* current;
        CaptureState::ObserverMap* new_map = nullptr;
 
        do {
            if (new_map)
                delete new_map;
 
            do {
                current = state.observers.load(std::memory_order_acquire);
                state.observers_hazard_ptrs[obs_slot].store(current, std::memory_order_release);
            } while (current != state.observers.load(std::memory_order_acquire));
 
            new_map = new CaptureState::ObserverMap(current ? *current : CaptureState::ObserverMap {});
            new_map->erase(id);
 
        } while (!state.observers.compare_exchange_weak(current, new_map, std::memory_order_acq_rel, std::memory_order_acquire));
 
        state.observers_hazard_ptrs[obs_slot].store(nullptr, std::memory_order_release);
        state.observers_slot_active[obs_slot].store(false, std::memory_order_release);
 
        if (current)
            state.retire_observers(current);
#else
        auto current = state.observers.load(std::memory_order_acquire);
        std::shared_ptr<CaptureState::ObserverMap> next;
        do {
            next = std::make_shared<CaptureState::ObserverMap>(*current);
            next->erase(id);
        } while (!state.observers.compare_exchange_weak(
            current, next,
            std::memory_order_release, std::memory_order_acquire));
#endif
    };
}

References MayaFlux::Journal::Core, current, MayaFlux::Core::BackendResourceManager::download_image_data(), ensure_capture_state(), ensure_depth_image(), find_window_context(), MayaFlux::Core::VKContext::get_device(), MayaFlux::Journal::GraphicsBackend, MayaFlux::Journal::GraphicsCallback, MayaFlux::Core::VKImageResources::image, MayaFlux::Kakshya::IMAGE_COLOR, m_context, m_resource_manager, m_window_contexts, MF_RT_ERROR, MF_RT_WARN, MF_WARN, submit_and_present(), MayaFlux::Core::VKImage::TEXTURE_2D, MayaFlux::Core::VKImage::TYPE_2D, and width.

Here is the call graph for this function: