ApplicationContext.h

#pragma once
#include "Exceptions.h"
 
#include <filesystem>
#include <mutex>
#include <openxr/openxr.h>
#include <vulkan/vulkan_core.h>
#include <vk_mem_alloc.h>
#include <openxr/openxr_platform.h>
#include <optional>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace Engine
{
    namespace Exceptions
    {
        class Environment : public Exception {
        public:
            explicit Environment(const std::string& message) : Exception(message) {}

            explicit Environment(const std::stringstream& message) : Exception(message) {}
        };

        class MissingVulkanFeature : public Exception
        {
        public:
            explicit MissingVulkanFeature(const std::string& message) : Exception(message) {}

            explicit MissingVulkanFeature(const std::stringstream& message) : Exception(message) {}
        };
    }
 
    namespace Core
    {
        class SamplerCache
        {
        public:
            VkSampler getOrCreate( VkDevice device, VkSamplerAddressMode addressMode );

            void cleanup(VkDevice device);
 
        private:
            std::unordered_map<VkSamplerAddressMode, VkSampler> cache_;
            std::mutex                                          mutex_;
    };

    class ApplicationContext
    {
    public:
        ApplicationContext()  = default;

        ~ApplicationContext();

        void createDevice( VkSurfaceKHR mirrorSurface );

        [[nodiscard]] XrInstance getXrInstance() const;

        [[nodiscard]] XrSystemId getXrSystemId() const;

        [[nodiscard]] VkInstance getVkInstance() const;

        [[nodiscard]] 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]] XrViewConfigurationType getXrViewType() const;

        void createResources();

        void cleanup();

        [[nodiscard]] bool usesDedicatedTransferQueue() const;

        [[nodiscard]] VmaAllocator getVmaAllocator() const;

        [[nodiscard]] SamplerCache& getSamplerCache() { return samplerCache_; }

        [[nodiscard]] bool isMeshShaderSupported() const;

        [[nodiscard]] bool isFbColorSpaceSupported() const { return fbColorSpaceSupported_; }
 
    private:
        static void validateFeature( VkBool32 feature, const std::string & errorMessage );
 
        bool fbColorSpaceSupported_ = false;
        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_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;
 
        bool meshShaderSupported_ = false;
 
        SamplerCache samplerCache_;
    };
    }
}  // namespace EngineCore