ApplicationContext.h

Go to the documentation of this file.

#pragma once
#include <filesystem>
#include <vulkan/vulkan_core.h>
#include <vk_mem_alloc.h>
#include <openxr/openxr.h>
#include <openxr/openxr_platform.h>
#include <optional>
#include <string>
#include <utility>
#include <vector>
 
namespace EngineCore
{
    class EnvironmentException : public std::exception
    {
    public:
        explicit EnvironmentException( std::string message ) : message_( std::move( message ) ) {}
 
        [[nodiscard]] const char * what() const noexcept override
        {
            return message_.c_str();
        }
 
    private:
        std::string message_;
    };

    class ApplicationContext
    {
    public:
        ApplicationContext()  = default;
        ~ApplicationContext() = default;

        void createDevice( VkSurfaceKHR mirrorSurface );

        [[nodiscard]] XrInstance getXrInstance() const;

        [[nodiscard]] XrSystemId getXrSystemId() const;

        [[nodiscard]] VkInstance getVkInstance() const;

        [[nodiscard]] const VkDevice getVkDevice() const;

        [[nodiscard]] const VkQueue & getPresentQueue() const;

        [[nodiscard]] const VkQueue & getGraphicsQueue() const;

        [[nodiscard]] const VkQueue & getTransferQueue() const;

        [[nodiscard]] VkSampleCountFlagBits getMultisampleCount() const;

        [[nodiscard]] const VkPhysicalDevice & getVkPhysicalDevice() const;

        [[nodiscard]] uint32_t getVkGraphicsQueueFamilyIndex() const;

        [[nodiscard]] uint32_t getVkTransferQueueFamilyIndex() const;

        [[nodiscard]] VkDeviceSize getUniformBufferOffsetAlignment() const;

        [[nodiscard]] uint32_t getMaxPushConstantsSize() const;

        [[nodiscard]] const XrViewConfigurationType getXrViewType() const;

        void createResources();

        void cleanup();

        [[nodiscard]] bool usesDedicatedTransferQueue() const;

        [[nodiscard]] VmaAllocator getVmaAllocator() const;
 
    private:
        void pickQueueFamilies(
            VkPhysicalDevice physicalDevice,
            VkSurfaceKHR     surface,
            uint32_t &       outGraphicsIndex,
            uint32_t &       outPresentIndex,
            uint32_t &       outTransferIndex
        );

        void createOpenXrInstance(
            std::optional<std::filesystem::path> customOpenXrRuntimePath =
                std::optional<std::filesystem::path>()
        );

        void                                    LoadOpenXrExtensionFunctions();
        PFN_xrGetVulkanInstanceExtensionsKHR    xrGetVulkanInstanceExtensionsKHR    = nullptr;
        PFN_xrGetVulkanGraphicsDevice2KHR       xrGetVulkanGraphicsDevice2KHR       = nullptr;
        PFN_xrGetVulkanGraphicsRequirements2KHR xrGetVulkanGraphicsRequirements2KHR = nullptr;
 
        PFN_xrCreateVulkanInstanceKHR xrCreateVulkanInstanceKHR = nullptr;
        PFN_xrCreateVulkanDeviceKHR   xrCreateVulkanDeviceKHR   = nullptr;
 
#ifdef IS_IN_DEBUG
        PFN_xrCreateDebugUtilsMessengerEXT  xrCreateDebugUtilsMessengerEXT  = nullptr;
        PFN_xrDestroyDebugUtilsMessengerEXT xrDestroyDebugUtilsMessengerEXT = nullptr;
 
        void createOpenXrDebugMessenger();
#endif

        void retrieveXrSystemId();

        void checkRequiredEnvironmentBlendModeAvailability();

        void getVulkanInstanceExtensions();

        void logVulkanRequirements();

        void createVulkanInstance();

        std::vector<XrExtensionProperties> supportedOpenXRInstanceExtensions;

        std::vector<XrApiLayerProperties> supportedOpenXRApiLayers;

        XrInstance xrInstance = XR_NULL_HANDLE;
 
#ifdef IS_IN_DEBUG
        XrDebugUtilsMessengerEXT xrDebugMessenger = XR_NULL_HANDLE;
#endif

        XrSystemId xrSystemId = XR_NULL_SYSTEM_ID;

        std::vector<VkExtensionProperties> supportedVulkanInstanceExtensions;

        std::vector<const char *> vulkanInstanceExtensions;

        VkInstance vkInstance = VK_NULL_HANDLE;

        VkPhysicalDevice vkPhysicalDevice = VK_NULL_HANDLE;

        std::vector<VkExtensionProperties> supportedVulkanDeviceExtensions;
        std::vector<const char *> vulkanDeviceExtensions;
        VkDeviceSize uniformBufferOffsetAlignment = 0u;
        VkSampleCountFlagBits multisampleCount = VK_SAMPLE_COUNT_1_BIT;
        uint32_t maxPushConstantsSize = 128u;
 
        struct QueueFamily
        {
            struct Family
            {
                uint32_t index = 0u;
                VkQueue  queue = VK_NULL_HANDLE;
            };
 
            Family graphics;
            Family present;
            Family transfer;
        } queueFamily;
 
        VkDevice vkDevice = VK_NULL_HANDLE;

        VmaAllocator vmaAllocator_ = VK_NULL_HANDLE;
    };
}  // namespace EngineCore