File display_provider.hpp

File List > illixr > vk > display_provider.hpp

Go to the documentation of this file

#pragma once

#include "illixr/global_module_defs.hpp"
#include "illixr/phonebook.hpp"
#include "vulkan_utils.hpp"

#include 

using namespace ILLIXR;

namespace ILLIXR::vulkan { 
class display_provider : public phonebook::service {
public:
    ~display_provider() override = default;

    // required by timewarp_vk as a service

    VkInstance                                   vk_instance_        = VK_NULL_HANDLE;
    VkPhysicalDevice                             vk_physical_device_ = VK_NULL_HANDLE;
    VkDevice                                     vk_device_          = VK_NULL_HANDLE;
    std::unordered_map<queue::queue_type, queue> queues_;

    virtual void poll_window_events() { };

    // addtionally required for native display

    virtual void recreate_swapchain() { };

    VkSurfaceKHR             vk_surface_   = VK_NULL_HANDLE;
    VkSwapchainKHR           vk_swapchain_ = VK_NULL_HANDLE;
    VkSurfaceFormatKHR       swapchain_image_format_;
    std::vector<VkImage>     swapchain_images_;
    std::vector<VkImageView> swapchain_image_views_;
    VkExtent2D               swapchain_extent_ = {display_params::width_pixels, display_params::height_pixels};

    // optional
    VmaAllocator vma_allocator_;

    // for ffmpeg
    VkPhysicalDeviceFeatures2 features_;
    std::vector<const char*>  enabled_instance_extensions_;
    std::vector<const char*>  enabled_device_extensions_;

    // Queue handles borrowed from another runtime must also borrow its host
    // synchronization. A private ILLIXR mutex cannot serialize Monado submits.
    virtual void lock_queue(queue::queue_type type) {
        queues_.at(type).mutex->lock();
    }

    virtual void unlock_queue(queue::queue_type type) {
        queues_.at(type).mutex->unlock();
    }
};

// RAII keeps the runtime's queue lock exception-safe at Vulkan call sites.
class queue_guard {
public:
    queue_guard(display_provider& provider, queue::queue_type type)
        : provider_(provider)
        , type_(type) {
        provider_.lock_queue(type_);
    }

    ~queue_guard() {
        provider_.unlock_queue(type_);
    }

    queue_guard(const queue_guard&)            = delete;
    queue_guard& operator=(const queue_guard&) = delete;

private:
    display_provider& provider_;
    queue::queue_type type_;
};
} // namespace ILLIXR::vulkan