VulkanDynamicRHI.h

Go to the documentation of this file.

 
#pragma once
 
#include "DynamicRHI.h"
#include "VulkanRHI.h"
 
#include "VulkanDevice.h"
 
struct GLFWwindow;
 
namespace Karma
{
    class VulkanUniformBuffer;

    template<typename TRHI>
    FORCEINLINE TRHI* GetDynamicRHI()
    {
        return static_cast<TRHI*>(GDynamicRHI);
    }

    struct QueueFamilyIndices
    {
        std::optional<uint32_t> graphicsFamily;

        std::optional<uint32_t> presentFamily;

        bool IsComplete()
        {
            return graphicsFamily.has_value() && presentFamily.has_value();
        }
    };

    struct SwapChainSupportDetails
    {
        VkSurfaceCapabilitiesKHR capabilities;

        std::vector<VkSurfaceFormatKHR> formats;

        std::vector<VkPresentModeKHR> presentModes;
    };

    class FVulkanDynamicRHI : public IVulkanDynamicRHI
    {
    public:
        static FVulkanDynamicRHI& Get() { return *GetDynamicRHI<FVulkanDynamicRHI>(); }

        FVulkanDynamicRHI();

        virtual bool Init() override;

        virtual void Shutdown() override;

        void InitInstance();

        virtual void Present() override {}

        SwapChainSupportDetails QuerySwapChainSupport(VkPhysicalDevice device);

        inline VkInstance GetInstance() const
        {
            return m_VulkanInstance;
        }

        inline FVulkanDevice* GetDevice() const
        {
            return m_Device;
        }

        QueueFamilyIndices FindQueueFamilies(VkPhysicalDevice device);
        
        inline bool GetValidationLayersSetting() const { return bEnableValidationLayers; }

        inline const VkPhysicalDeviceFeatures& GetGpuDeviceFeatures() const{ return m_SupportedDeviceFeatures; }

        inline const SwapChainSupportDetails& GetGpuSwapChainSupportDetails() const { return m_GPUSwapChainSupport; }

        inline uint32_t SwapChainImageCount() const { return m_SwapChainImageCount; }

        VkFormat FindSupportedFormat(const std::vector<VkFormat>& candidates, VkImageTiling tiling, VkFormatFeatureFlags features) const;

        VkFormat FindDepthFormat() const;

        uint32_t FindMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties);
        
        // These may be abstracted to FDynamicRHI
        void RegisterUniformBufferObject(VulkanUniformBuffer* ubo);
        
        void UploadUniformBufferObjects(size_t frameIndex);
        
        inline GLFWwindow* GetSurfaceWindow() const { return m_WindowHandle; }
        inline VkSurfaceKHR GetSurface() const { return m_Surface; }
 
    protected:
        // Vulkan-specific members and methods can be added here

        void CreateInstance();

        void SetupDebugMessenger();

        void CreateSurface();

        void SelectDevice();
 
    private:

        void ComputeNumberOfSwapchainImagesSupported();

        bool CheckDeviceExtensionSupport(VkPhysicalDevice device);

        bool IsDeviceSuitable(VkPhysicalDevice device);

        void PrintAvailablePhysicalDevices(const std::vector<VkPhysicalDevice>& physicalDevices);

        VkResult CreateDebugUtilsMessengerEXT(VkInstance instance,
            const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
            const VkAllocationCallbacks* pAllocator,
            VkDebugUtilsMessengerEXT* pDebugMessenger);

        void DestroyDebugUtilsMessengerEXT(VkInstance instance, 
            VkDebugUtilsMessengerEXT debugMessenger, 
            const VkAllocationCallbacks* pAllocator);

        void PrintAvailableExtensions();

        std::vector<const char*> GetRequiredExtensions(VkInstanceCreateFlags& flagsToBeSet);

        bool CheckValidationLayerSupport();

        void PopulateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo);

        static VKAPI_ATTR VkBool32 VKAPI_CALL DebugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
            VkDebugUtilsMessageTypeFlagsEXT messageType,
            const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
            void* pUserData);
 
    public:
        // To be set manually by coder
        static std::vector<const char*> deviceExtensions;
        static const std::vector<const char*> validationLayers;
 
    protected:
        uint32_t m_APIVersion;
        VkInstance m_VulkanInstance;
        FVulkanDevice* m_Device;
        static bool bEnableValidationLayers;
        VkDebugUtilsMessengerEXT m_DebugMessenger;
        GLFWwindow* m_WindowHandle;
        VkSurfaceKHR m_Surface;
        VkPhysicalDeviceFeatures m_SupportedDeviceFeatures;
        VkPhysicalDevice m_PhysicalDevice = VK_NULL_HANDLE;// GPU
        SwapChainSupportDetails m_GPUSwapChainSupport;
        uint32_t m_SwapChainImageCount;
        
        std::set<VulkanUniformBuffer*> m_VulkanUBO;
    };
}