VulkanContext.h

Go to the documentation of this file.

#pragma once
 
#define GLFW_INCLUDE_VULKAN
 
#include "Karma/Renderer/GraphicsContext.h"
#include "GLFW/glfw3.h"
#include "vulkan/vulkan_core.h"
#include "Platform/Vulkan/VulkanBuffer.h"
#include "Platform/Vulkan/VulkanRendererAPI.h"
 
namespace Karma
{
    class VulkanShader;
 
    class Texture;
 
    class Scene;

    class RendererAPI;

    struct VulkanUniformBuffer;
 
    struct FrameDescriptorSets 
    {
        VkDescriptorSet viewSet;     // Set 0: Camera UBO
        std::vector<VkDescriptorSet> textureSet;  // Set 1: Per-mesh Texture  
        std::vector<VkDescriptorSet> objectsSet;   // Set 2: Per-mesh UBO
    };

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

        std::optional<uint32_t> presentFamily;

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

    struct SwapChainSupportDetailsDepricated
    {
        VkSurfaceCapabilitiesKHR capabilities;

        std::vector<VkSurfaceFormatKHR> formats;

        std::vector<VkPresentModeKHR> presentModes;
    };

    class KARMA_API VulkanContext : public GraphicsContext
    {
    public:
        VulkanContext(GLFWwindow* windowHandle);
        
        virtual ~VulkanContext() override;

        virtual void Init() override;

        virtual void SwapBuffers() override;
 
        virtual bool OnWindowResize(WindowResizeEvent& event) override {/*No need for Vulkan for now.*/ return true; }

        void CreateInstance();

        void PrintAvailableExtensions();

        void PrintAvailablePhysicalDevices(const std::vector<VkPhysicalDevice>& physicalDevices);
 
        // Validation layers
        bool CheckValidationLayerSupport();
        std::vector<const char*> GetRequiredExtensions(VkInstanceCreateFlags& flagsToBeSet);
 
        static VKAPI_ATTR VkBool32 VKAPI_CALL DebugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
            VkDebugUtilsMessageTypeFlagsEXT messageType,
            const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
            void* pUserData);
 
        void SetupDebugMessenger();
        void PopulateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo);
        VkResult CreateDebugUtilsMessengerEXT(VkInstance instance,
            const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
            const VkAllocationCallbacks* pAllocator,
            VkDebugUtilsMessengerEXT* pDebugMessenger);
 
        void DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT debugMessenger, const VkAllocationCallbacks* pAllocator);

        void CreateSurface();

        void PickPhysicalDevice();

        bool IsDeviceSuitable(VkPhysicalDevice device);
        
        QueueFamilyIndicesDepricated FindQueueFamilies(VkPhysicalDevice device);

        void CreateLogicalDevice();

        void CreateSwapChain();

        bool CheckDeviceExtensionSupport(VkPhysicalDevice device);
        
        SwapChainSupportDetailsDepricated QuerySwapChainSupport(VkPhysicalDevice device);

        VkSurfaceFormatKHR ChooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats);

        VkPresentModeKHR ChooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes);
        
        VkExtent2D ChooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities);

        uint32_t FindMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties);

        void CreateImageViews();

        void CreateRenderPass();

        void CreateFrameBuffers();

        void CreateCommandPool();

        void CreateDepthResources();

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

        bool HasStencilComponent(VkFormat format);

        void TransitionImageLayout(VkImage image, VkFormat format, VkImageLayout oldLayout, VkImageLayout newLayout);
        
        void CopyBufferToImage(VkBuffer buffer, VkImage image, uint32_t width, uint32_t height);

        void RecreateSwapChain();

        void CleanupSwapChain();

        void SetVSync(bool bEnable);

        void Initializeglslang();
        
        void RegisterUBO(VulkanUniformBuffer* ubo);

        void ClearUBO();

        void RecreateUBO();

        VkShaderModule CreateShaderModule(const std::vector<uint32_t>& code);
 
        void CreateVulkanResourcesForScene(std::shared_ptr<Scene> scene3D );

        void CreateGeneralShader();

        void CreateGeneralTexture();

        void CreateGeneralDescriptorSetLayouts();

        void CreateKarmaGuiGeneralGraphicsPipeline(VkRenderPass renderPassKG, float windowKGWidth, float windowKGHeight);

        void CleanUpKarmaGuiGeneralGraphicsPipeline();

        void CreateGeneralDescriptorPool(uint32_t smElementsNumber);

        void CreateGeneralDescriptorSets(std::shared_ptr<Scene> scene3D, uint32_t smElementsNumber, uint32_t maxFramesInFlight);

        void UpdateGeneralDescriptorSets(std::shared_ptr<Scene> scene3D, uint32_t frameIndex);

        void UploadUBO(size_t frameIndex);
 
        // Getters
        VkDevice GetLogicalDevice() const { return m_device; }
        VkPhysicalDevice GetPhysicalDevice() const { return m_physicalDevice; }
        VkExtent2D GetSwapChainExtent() const { return m_swapChainExtent; }
        VkRenderPass GetRenderPass() const { return m_renderPass; }
        const std::vector<VkFramebuffer>& GetSwapChainFrameBuffer() const { return m_swapChainFrameBuffers; }
        VkSwapchainKHR GetSwapChain() const { return m_swapChain; }
        inline const std::vector<VkImage>& GetSwapChainImages() const { return m_swapChainImages; }
        VkFormat GetSwapChainImageFormat() const { return m_swapChainImageFormat; }
        const std::vector<VkImageView>& GetSwapChainImageViews() const { return m_swapChainImageViews; }
        VkSurfaceFormatKHR GetSurfaceFormat() const { return m_surfaceFormat; }
        VkQueue GetGraphicsQueue() const { return m_graphicsQueue; }
        VkQueue GetPresentQueue() const { return m_presentQueue; }
        VkCommandPool GetCommandPool() const { return m_commandPool; }
        VkImageView GetDepthImageView() const { return m_DepthImageView; }
        const VkPhysicalDeviceFeatures& GetSupportedDeviceFeatures() const { return m_SupportedDeviceFeatures; }
        VkInstance GetInstance() const { return m_Instance; }
        uint32_t GetImageCount() const { return uint32_t(m_swapChainImages.size()); }
        uint32_t GetMinImageCount() const { return m_MinImageCount; }
        VkSurfaceKHR GetSurface() const { return m_surface; }
        VkPresentModeKHR GetPresentMode() const { return m_presentMode; }
        std::shared_ptr<VulkanShader> GetGeneralShader() const { return m_GeneralShader; }
        VkPipeline GetKarmaGuiGeneralGraphicsPipeline() const { return m_KarmaGuiGeneralGraphicsPipeline; }
        VkPipelineLayout GetKarmaGuiGeneralPipelineLayout() const { return m_KarmaGuiGeneralPipelineLayout; }
        const std::vector<FrameDescriptorSets>& GetGeneralDescriptorSets() const { return m_GeneralDescriptorSets; }
 
    private:
        // Apologies for little out-of-sync naming convention, was dealing with flood of lines when
        // learning Vulkan!
        GLFWwindow* m_windowHandle;
        VulkanRendererAPI* m_vulkanRendererAPI;
 
        VkInstance m_Instance;
        VkDebugUtilsMessengerEXT debugMessenger;
 
        VkPhysicalDeviceFeatures m_SupportedDeviceFeatures;
 
        static bool bEnableValidationLayers;
 
        VkPhysicalDevice m_physicalDevice = VK_NULL_HANDLE;
        VkDevice m_device;
        VkQueue m_graphicsQueue;
 
        VkSurfaceKHR m_surface;
        VkQueue m_presentQueue;
        VkPresentModeKHR m_presentMode;
 
        VkSurfaceFormatKHR m_surfaceFormat;
 
        VkSwapchainKHR m_swapChain;
        std::vector<VkImage> m_swapChainImages;
        VkFormat m_swapChainImageFormat;
        VkExtent2D m_swapChainExtent;
        std::vector<VkImageView> m_swapChainImageViews;
 
        VkRenderPass m_renderPass;
 
        std::vector<VkFramebuffer> m_swapChainFrameBuffers;
        VkCommandPool m_commandPool;
 
        std::set<VulkanUniformBuffer*> m_VulkanUBO;
 
        // General vulkan resources
        std::shared_ptr<VulkanShader> m_GeneralShader;
        std::shared_ptr<Texture> m_GeneralTexture;
        VkPipelineLayout m_KarmaGuiGeneralPipelineLayout;
        VkPipeline m_KarmaGuiGeneralGraphicsPipeline;
        VkDescriptorSetLayout m_ViewLayout; // Camera UBO
        VkDescriptorSetLayout m_TextureLayout; // Material UBO + texture sampler
        VkDescriptorSetLayout m_ObjectLayout; // Object UBO
        VkDescriptorPool m_GeneralDescriptorPool;
        std::vector<FrameDescriptorSets> m_GeneralDescriptorSets;
 
        bool bVSync = true;
 
        VkImage m_DepthImage;
        VkDeviceMemory m_DepthImageMemory;
        VkImageView m_DepthImageView;
 
        uint32_t m_MinImageCount = 0;
    };
}