VulkanRenderer.h

#pragma once
 
// Standard.
#include <vector>
 
// Custom.
#include "render/Renderer.h"
#include "render/general/resources/frame/FrameResourcesManager.h"
#include "render/vulkan/resources/VulkanResource.h"
#include "material/Material.h"
 
// External.
#include "vulkan/vulkan.h"
#include "VulkanMemoryAllocator/include/vk_mem_alloc.h"
 
namespace ne {
    class CameraProperties;
    class VulkanPipeline;
    struct VulkanFrameResource;
    struct QueuedForExecutionComputeShaders;
    class ComputeShaderInterface;
    class MeshNode;
    class Pipeline;
 
    class VulkanRenderer : public Renderer {
    public:
        VulkanRenderer() = delete;
        VulkanRenderer(const VulkanRenderer&) = delete;
        VulkanRenderer& operator=(const VulkanRenderer&) = delete;
 
        virtual ~VulkanRenderer() override;
 
        static uint32_t getUsedVulkanVersion();
 
        static constexpr VkFormat getDepthImageFormat() { return depthImageFormat; }
 
        static constexpr VkFormat getShadowMapFormat() { return shadowMapFormat; }
 
        static constexpr VkFormat getShadowMappingPointLightColorTargetFormat() {
            return shadowMappingPointLightColorTargetFormat;
        }
 
        static std::variant<std::unique_ptr<Renderer>, std::pair<Error, std::string>>
        create(GameManager* pGameManager, const std::vector<std::string>& vBlacklistedGpuNames);
 
        static void setObjectDebugOnlyName(
            Renderer* pRenderer, void* pObject, VkObjectType objectType, const std::string& sResourceName);
 
        VkSampler getTextureSampler();
 
        virtual std::vector<std::string> getSupportedGpuNames() const override;
 
        virtual std::variant<std::set<std::pair<unsigned int, unsigned int>>, Error>
        getSupportedRenderResolutions() const override;
 
        virtual std::variant<std::set<std::pair<unsigned int, unsigned int>>, Error>
        getSupportedRefreshRates() const override;
 
        virtual RendererType getType() const override;
 
        virtual std::string getUsedApiVersion() const override;
 
        virtual std::string getCurrentlyUsedGpuName() const override;
 
        virtual void waitForGpuToFinishWorkUpToThisPoint() override;
 
        std::variant<VkCommandBuffer, Error> createOneTimeSubmitCommandBuffer();
 
        [[nodiscard]] std::optional<Error>
        submitWaitDestroyOneTimeSubmitCommandBuffer(VkCommandBuffer pOneTimeSubmitCommandBuffer);
 
        [[nodiscard]] std::optional<Error> transitionImageLayout(
            VkImage pImage,
            VkFormat imageFormat,
            VkImageAspectFlags aspect,
            uint32_t levelCount,
            uint32_t layerCount,
            VkImageLayout oldLayout,
            VkImageLayout newLayout);
 
        virtual std::pair<unsigned int, unsigned int> getRenderTargetSize() const override;
 
        VkDevice getLogicalDevice() const;
 
        VkPhysicalDevice getPhysicalDevice() const;
 
        VkInstance getInstance() const;
 
        VkRenderPass getMainRenderPass() const;
 
        VkRenderPass getDepthOnlyRenderPass() const;
 
        VkRenderPass getShadowMappingRenderPass(bool bIsForPointLights) const;
 
        VkCommandPool getCommandPool() const;
 
        VkQueue getGraphicsQueue() const;
 
        VkSampler getComputeTextureSampler() const;
 
        VkSampler getShadowTextureSampler() const;
 
        std::optional<VkExtent2D> getSwapChainExtent() const;
 
        VkSampleCountFlagBits getMsaaSampleCount() const;
 
        virtual GpuResource* getDepthTextureNoMultisampling() override;
 
    protected:
        VulkanRenderer(GameManager* pGameManager);
 
        virtual std::variant<AntialiasingQuality, Error> getMaxSupportedAntialiasingQuality() const override;
 
        virtual void onFramebufferSizeChangedDerived(int iWidth, int iHeight) override;
 
        [[nodiscard]] virtual std::optional<Error> onRenderSettingsChangedDerived() override;
 
        virtual void waitForGpuToFinishUsingFrameResource(FrameResource* pFrameResource) override;
 
        virtual bool isInitialized() const override;
 
    private:
        struct SwapChainSupportDetails {
            VkSurfaceCapabilitiesKHR capabilities;
 
            std::vector<VkSurfaceFormatKHR> vSupportedFormats;
 
            std::vector<VkPresentModeKHR> vSupportedPresentModes;
        };
 
        struct QueueFamilyIndices {
            QueueFamilyIndices() = default;
 
            bool isComplete() const {
                return iGraphicsFamilyIndex.has_value() && iPresentFamilyIndex.has_value();
            }
 
            std::optional<uint32_t> iGraphicsFamilyIndex;
 
            std::optional<uint32_t> iPresentFamilyIndex;
        };
 
        struct SwapChainImageSemaphores {
            VkSemaphore pAcquireImageSemaphore = nullptr;
 
            VkSemaphore pQueueSubmitSemaphore = nullptr;
 
            size_t iUsedFrameResourceIndex = 0;
        };
 
        static std::variant<std::vector<const char*>, Error> getRequiredVulkanInstanceExtensions();
 
        static std::variant<std::string, Error>
        isGpuSupportsUsedDeviceExtensions(VkPhysicalDevice pGpuDevice);
 
        static void startShadowMappingRenderPass(
            VkRenderPass pShadowMappingRenderPass,
            VkCommandBuffer pCommandBuffer,
            VkFramebuffer pFramebufferToUse,
            uint32_t iShadowMapSize);
 
#if defined(DEBUG)
        [[nodiscard]] static std::optional<Error> makeSureUsedValidationLayersSupported();
 
        static VkResult createDebugUtilsMessengerEXT(
            VkInstance pInstance,
            const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
            const VkAllocationCallbacks* pAllocator,
            VkDebugUtilsMessengerEXT* pDebugMessenger);
 
        static void destroyDebugUtilsMessengerEXT(
            VkInstance pInstance,
            VkDebugUtilsMessengerEXT pDebugMessenger,
            const VkAllocationCallbacks* pAllocator);
 
        static PFN_vkCmdBeginDebugUtilsLabelEXT requestVkCmdBeginDebugUtilsLabelEXT(VkInstance pInstance);
 
        static PFN_vkCmdEndDebugUtilsLabelEXT requestVkCmdEndDebugUtilsLabelEXT(VkInstance pInstance);
#endif
 
        [[nodiscard]] std::optional<Error> initialize(const std::vector<std::string>& vBlacklistedGpuNames);
 
        [[nodiscard]] std::optional<Error>
        initializeVulkan(const std::vector<std::string>& vBlacklistedGpuNames);
 
        [[nodiscard]] std::optional<Error> createVulkanInstance();
 
        [[nodiscard]] std::optional<Error> createWindowSurface();
 
        size_t rateGpuSuitability(VkPhysicalDevice pGpuDevice);
 
        std::variant<std::string, Error> isDeviceSuitable(VkPhysicalDevice pGpu);
 
        std::variant<SwapChainSupportDetails, Error> querySwapChainSupportDetails(VkPhysicalDevice pGpu);
 
        std::variant<VulkanRenderer::QueueFamilyIndices, Error>
        queryQueueFamilyIndices(VkPhysicalDevice pGpu);
 
        std::variant<std::string, Error> isGpuSupportsSwapChain(VkPhysicalDevice pGpu);
 
        [[nodiscard]] std::optional<Error>
        pickPhysicalDevice(const std::vector<std::string>& vBlacklistedGpuNames);
 
        [[nodiscard]] std::optional<Error> createLogicalDevice();
 
        [[nodiscard]] std::optional<Error> createSwapChain();
 
        [[nodiscard]] std::optional<Error> createCommandPool();
 
        std::variant<VkExtent2D, Error>
        pickSwapChainExtent(const VkSurfaceCapabilitiesKHR& surfaceCapabilities);
 
        [[nodiscard]] std::optional<Error> createRenderPasses(bool bIsRendererInitialization);
 
        [[nodiscard]] std::optional<Error> createMainRenderPass();
 
        [[nodiscard]] std::optional<Error> createDepthOnlyRenderPass();
 
        [[nodiscard]] std::optional<Error> createShadowMappingRenderPasses();
 
        void destroySwapChainAndDependentResources(bool bDestroyPipelineManager);
 
        [[nodiscard]] std::optional<Error> createTextureSampler();
 
        [[nodiscard]] std::optional<Error> createComputeTextureSampler();
 
        [[nodiscard]] std::optional<Error> createShadowTextureSampler();
 
        bool isUsedDepthImageFormatSupported();
 
        [[nodiscard]] std::optional<Error> createDepthImage();
 
        [[nodiscard]] std::optional<Error> createMsaaImage();
 
        [[nodiscard]] std::optional<Error> recreateSwapChainAndDependentResources();
 
        [[nodiscard]] std::optional<Error> createSwapChainFramebuffers();
 
        virtual void prepareRenderTargetForNextFrame() override;
 
        virtual void prepareForDrawingNextFrame(
            CameraProperties* pCameraProperties, FrameResource* pCurrentFrameResource) override;
 
        void startMainRenderPass(VkCommandBuffer pCommandBuffer, size_t iAcquiredImageIndex);
 
        void startDepthOnlyRenderPass(VkCommandBuffer pCommandBuffer, size_t iAcquiredImageIndex);
 
        virtual void drawShadowMappingPass(
            FrameResource* pCurrentFrameResource,
            size_t iCurrentFrameResourceIndex,
            PipelineManager::GraphicsPipelineRegistry* pGraphicsPipelines) override;
 
        virtual void drawMeshesDepthPrepass(
            FrameResource* pCurrentFrameResource,
            size_t iCurrentFrameResourceIndex,
            const std::vector<Renderer::MeshesInFrustum::PipelineInFrustumInfo>& vOpaquePipelines) override;
 
        virtual void executeComputeShadersOnGraphicsQueue(
            FrameResource* pCurrentFrameResource,
            size_t iCurrentFrameResourceIndex,
            ComputeExecutionStage stage) override;
 
        virtual void drawMeshesMainPass(
            FrameResource* pCurrentFrameResource,
            size_t iCurrentFrameResourceIndex,
            const std::vector<Renderer::MeshesInFrustum::PipelineInFrustumInfo>& vOpaquePipelines,
            const std::vector<Renderer::MeshesInFrustum::PipelineInFrustumInfo>& vTransparentPipelines)
            override;
 
        virtual void
        present(FrameResource* pCurrentFrameResource, size_t iCurrentFrameResourceIndex) override;
 
        void drawMeshesMainPassSpecificPipelines(
            const std::vector<Renderer::MeshesInFrustum::PipelineInFrustumInfo>& pipelinesOfSpecificType,
            VkCommandBuffer pCommandBuffer,
            size_t iCurrentFrameResourceIndex);
 
        [[nodiscard]] std::optional<Error> updateMsaaSampleCount();
 
        static bool dispatchComputeShadersOnGraphicsQueue(
            VulkanFrameResource* pCurrentFrameResource,
            size_t iCurrentFrameResourceIndex,
            std::unordered_map<Pipeline*, std::unordered_set<ComputeShaderInterface*>>&
                computePipelinesToSubmit);
 
        VkInstance pInstance = nullptr;
 
        VkSurfaceKHR pWindowSurface = nullptr;
 
        VkPhysicalDevice pPhysicalDevice = nullptr;
 
        VkDevice pLogicalDevice = nullptr;
 
        VkQueue pGraphicsQueue = nullptr;
 
        VkQueue pPresentQueue = nullptr;
 
        VkSwapchainKHR pSwapChain = nullptr;
 
        std::unique_ptr<VulkanResource> pDepthImage = nullptr;
 
        std::unique_ptr<VulkanResource> pDepthImageNoMultisampling = nullptr;
 
        std::unique_ptr<VulkanResource> pMsaaImage = nullptr;
 
        VkRenderPass pDepthOnlyRenderPass = nullptr;
 
        VkRenderPass pMainRenderPass = nullptr;
 
        VkRenderPass pShadowMappingDirectionalSpotRenderPass = nullptr;
 
        VkRenderPass pShadowMappingPointRenderPass = nullptr;
 
        VkCommandPool pCommandPool = nullptr;
 
        VkSampler pTextureSampler = nullptr;
 
        VkSampler pComputeTextureSampler = nullptr;
 
        VkSampler pShadowTextureSampler = nullptr;
 
#if defined(DEBUG)
        VkDebugUtilsMessengerEXT pValidationLayerDebugMessenger = nullptr;
#endif
 
        std::vector<VkImage> vSwapChainImages;
 
        std::vector<VkImageView> vSwapChainImageViews;
 
        std::vector<VkFramebuffer> vSwapChainFramebuffersMainRenderPass;
 
        std::vector<VkFramebuffer> vSwapChainFramebuffersDepthOnlyRenderPass;
 
        std::vector<std::pair<VkFence, size_t>> vSwapChainImageFenceRefs;
 
        std::vector<SwapChainImageSemaphores> vImageSemaphores;
 
        size_t iCurrentImageSemaphore = 0;
 
        std::vector<std::string> vSupportedGpuNames;
 
        std::string sUsedGpuName;
 
        QueueFamilyIndices physicalDeviceQueueFamilyIndices;
 
        std::optional<VkExtent2D> swapChainExtent;
 
        VkSampleCountFlagBits msaaSampleCount = VK_SAMPLE_COUNT_1_BIT;
 
        uint32_t iSwapChainImageCount = 0;
 
        uint32_t iLastAcquiredImageIndex = 0;
 
        bool bIsVulkanInitialized = false;
 
        bool bNeedToRecreateSwapchain = false;
 
        bool bIsUsingMsaaRenderTarget = false;
 
        bool bIsBeingDestroyed = false;
 
        static constexpr size_t iMainRenderPassColorAttachmentIndex = 0;
 
        static constexpr size_t iMainRenderPassDepthAttachmentIndex = 1;
 
        static constexpr size_t iMainRenderPassColorResolveTargetAttachmentIndex = 2;
 
        static constexpr size_t iDepthOnlyRenderPassDepthImageAttachmentIndex = 0;
 
        static constexpr size_t iDepthOnlyRenderPassDepthResolveTargetAttachmentIndex = 1;
 
        static constexpr auto swapChainImageFormat = VK_FORMAT_B8G8R8A8_UNORM;
 
        static constexpr auto swapChainImageColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
 
        static constexpr auto depthImageFormat = VK_FORMAT_D24_UNORM_S8_UINT;
 
        static constexpr auto shadowMapFormat = VK_FORMAT_D24_UNORM_S8_UINT;
 
        static constexpr auto shadowMappingPointLightColorTargetFormat = VK_FORMAT_R32_SFLOAT;
 
        static constexpr auto depthImageTiling = VK_IMAGE_TILING_OPTIMAL;
 
        static constexpr auto indexTypeFormat = VK_INDEX_TYPE_UINT32;
 
        static constexpr auto depthResolveMode = VK_RESOLVE_MODE_AVERAGE_BIT;
 
        static constexpr auto stencilResolveMode = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT;
 
        static constexpr uint32_t iUsedVulkanVersion = VK_API_VERSION_1_2;
 
        static inline const std::vector<const char*> vUsedDeviceExtensionNames = {
            VK_KHR_SWAPCHAIN_EXTENSION_NAME};
 
#if defined(DEBUG)
        static inline const std::vector<const char*> vUsedValidationLayerNames = {
            "VK_LAYER_KHRONOS_validation"};
#endif
    };
} // namespace ne