KarmaGuiVulkanHandler.h

Go to the documentation of this file.

// Dear ImGui (1.89.2) is Copyright (c) 2014-2023 Omar Cornut.
 
// Major and heavy modifications of the original Dear ImGUI's take on Vulkan implementation
// https://github.com/ravimohan1991/imgui/blob/9068fd1afbaba56247aacd452bbadebb286800c7/backends/imgui_impl_vulkan.h
// Disclaimer:
// Most of the member variables and function naming in the herein is credited to the author(s) of Dear ImGUI. I take no responsibility
// of damage caused by short names herein (if any).
 
#pragma once
 
#include "KarmaGui.h"
#include "KarmaGuiInternal.h"
#include "Karma/Renderer/Scene.h"
#include "KarmaTypes.h"
#include <vulkan/vulkan.h>
 
namespace Karma
{
    class FVulkanSwapChain;
    class FVulkanRenderPass;
    class FVulkanRenderTargetsInfo;
    class FVulkanFramebuffer;
    class FVulkanFence;

    #define KR_MEMALIGN(_OFF,_ALIGN)        (((_OFF) + ((_ALIGN) - 1)) & ~((_ALIGN) - 1))

    #define KR_MAX(A, B)    (((A) >= (B)) ? (A) : (B))

    struct KarmaGui_ImplVulkan_InitInfo
    {
        VkInstance                      Instance;

        VkPhysicalDevice                PhysicalDevice;

        VkDevice                        Device;

        uint32_t                        QueueFamily;

        VkQueue                         Queue;

        VkDescriptorPool                DescriptorPool;

        VkRenderPass                    RenderPass;
 
        // begin Optional
        VkPipelineCache                 PipelineCache;

        uint32_t                        Subpass;
        // end Optional

        uint32_t                        MinImageCount;

        uint32_t                        ImageCount;

        VkSampleCountFlagBits           MSAASamples; // Multi sample anti aliasing samples

        const VkAllocationCallbacks* Allocator;
    };
 
    //-------------------------------------------------------------------------
    // Internal / Miscellaneous Vulkan Helpers
    // (Used by example's main.cpp. Used by multi-viewport features. PROBABLY NOT used by your own engine/app.)
    //-------------------------------------------------------------------------
    // You probably do NOT need to use or care about those functions.
    // Those functions only exist because:
    //   1) they facilitate the readability and maintenance of the multiple main.cpp examples files.
    //   2) the multi-viewport / platform window implementation needs them internally.
    // Generally we avoid exposing any kind of superfluous high-level helpers in the bindings,
    // but it is too much code to duplicate everywhere so we exceptionally expose them.
    //
    // Your engine/app(lication) will likely _already_ have code to setup all that stuff (swap chain, render pass, frame buffers, etc.).
    // You may read this code to learn about Vulkan, but it is recommended you use you own custom tailored code to do equivalent work.
    // (The ImGui_ImplVulkanH_XXX functions do not interact with any of the state used by the regular ImGui_ImplVulkan_XXX  functions)
    //-------------------------------------------------------------------------

    struct KarmaGui_Vulkan_Frame_On_Flight
    {
        FVulkanFence*             Fence;

        VkSemaphore         ImageAcquiredSemaphore;

        VkSemaphore         RenderCompleteSemaphore;

        VkCommandBuffer     CommandBuffer;
    };

    struct KarmaGui_ImplVulkanH_ImageFrame
    {
        VkImage             Backbuffer;

        VkImageView         BackbufferView;

        VkFramebuffer       Framebuffer;
    };

    struct KarmaGui_ImplVulkanH_RHIResources
    {
        FVulkanSwapChain*                           VulkanSwapChain;
        
        FVulkanRenderPass*                          VulkanRenderPass;
        KarmaVector<FVulkanFramebuffer*>            VulkanFrameBuffers;
        
        KarmaVector<FVulkanRenderTargetsInfo*>      RenderTargets;
    };

    struct KarmaGui_ImplVulkanH_Window
    {
        int                 Width;

        int                 Height;

        VkSwapchainKHR      Swapchain;

        VkCommandPool       CommandPool;

        VkSurfaceKHR        Surface;

        VkSurfaceFormatKHR  SurfaceFormat;

        VkPresentModeKHR    PresentMode;

        VkRenderPass        RenderPass;

        VkPipeline          Pipeline;

        bool                ClearEnable;

        VkClearValue        ClearValue;

        uint32_t            ImageFrameIndex;

        uint32_t            TotalImageCount;

        uint32_t            SemaphoreIndex;

        uint32_t             MAX_FRAMES_IN_FLIGHT;
        
        KarmaGui_ImplVulkanH_ImageFrame* ImageFrames;
 
        // Cowboy's Modification

        KarmaGui_Vulkan_Frame_On_Flight* FramesOnFlight;

        VkRect2D                            RenderArea;

        KarmaGui_ImplVulkanH_RHIResources*              RHIResources;

        KarmaGui_ImplVulkanH_Window()
        {
            memset((void*)this, 0, sizeof(*this));
            PresentMode = (VkPresentModeKHR)~0;     // Ensure we get an error if user doesn't set this.
            ClearEnable = true;
        }
    };

    struct KarmaGui_ImplVulkanH_ImageFrameRenderBuffers
    {
        VkDeviceMemory      VertexBufferMemory;

        VkDeviceMemory      IndexBufferMemory;

        VkDeviceSize        VertexBufferSize;

        VkDeviceSize        IndexBufferSize;

        VkBuffer            VertexBuffer;

        VkBuffer            IndexBuffer;
 
    public:

        KarmaGui_ImplVulkanH_ImageFrameRenderBuffers()
        {
            VertexBufferSize = IndexBufferSize = 0;
            IndexBuffer = VertexBuffer = VK_NULL_HANDLE;
            IndexBufferMemory = VertexBufferMemory = VK_NULL_HANDLE;
        }
    };

    struct KarmaGui_ImplVulkanH_WindowRenderBuffers
    {
        uint32_t            Index;

        uint32_t            Count;

        KarmaGui_ImplVulkanH_ImageFrameRenderBuffers* FrameRenderBuffers;
    };

    struct KarmaGui_ImplVulkan_ViewportData
    {
        bool                                    WindowOwned;

        KarmaGui_ImplVulkanH_Window                Window;

        KarmaGui_ImplVulkanH_WindowRenderBuffers   RenderBuffers;

        KarmaGui_ImplVulkan_ViewportData()
        {
            WindowOwned = false;
            memset(&RenderBuffers, 0, sizeof(RenderBuffers));
        }

        ~KarmaGui_ImplVulkan_ViewportData() { }
    };

    struct KarmaGui_ImplVulkan_Image_TextureData
    {
        std::string                 TextureLable;

        uint32_t                    width;

        uint32_t                    height;

        uint32_t                    channels;

        size_t                      size;

        VkSampler                   TextureSampler;

        VkDeviceMemory              TextureMemory;

        VkImage                     TextureImage;

        VkImageView                 TextureView;

        VkDescriptorSet             TextureDescriptorSet;

        VkDeviceMemory              UploadBufferMemory;

        VkBuffer                    UploadBuffer;

        KarmaGui_ImplVulkan_Image_TextureData()
        {
            TextureLable = "NO LABLE YET";
        }
    };

    struct KarmaGui_3DScene_To_2DTexture_Data
    {
        std::shared_ptr<Scene>              Scene3D;
        
        KGVec2                              Size;
        
        KGTextureID                         KarmaGui_Texture;
        
        VkImage                             Image;

        VkDeviceMemory                      DeviceMemory;

        VkImageView                         Image_View;
        
        VkImage                             DepthImage;
        
        VkDeviceMemory                      DepthDeviceMemory;
        
        VkImageView                         DepthImage_View;
        
        VkFramebuffer                       FrameBuffer;
    };

    struct KarmaGui_OffScreen_Render_Resources
    {
        VkSampler                           Sampler;
        
        FVulkanRenderPass*                  RenderPass;

        bool                                bAllocationDoneOnce;
 
        VkPipelineLayout                    OffscreenPipelineLayout;
        VkPipeline                          OffscreenGraphicsPipeline;
        
        KarmaGui_OffScreen_Render_Resources() : bAllocationDoneOnce(false)
        {}
    };

    struct KarmaGui_ImplVulkan_Data
    {
        KarmaGui_ImplVulkan_InitInfo   VulkanInitInfo;

        VkRenderPass                RenderPass;
        
        std::vector<KarmaGui_3DScene_To_2DTexture_Data>     Elements3DTo2D;
        
        KarmaGui_OffScreen_Render_Resources                 OffScreenRR;
        
        VkDeviceSize                BufferMemoryAlignment;

        VkPipelineCreateFlags       PipelineCreateFlags;

        VkDescriptorSetLayout       DescriptorSetLayout;

        VkPipelineLayout            PipelineLayout;

        VkPipeline                  Pipeline;

        uint32_t                    Subpass;

        VkShaderModule              ShaderModuleVert;

        VkShaderModule              ShaderModuleFrag;
 
        // Font data
        VkSampler                   FontSampler;

        VkDeviceMemory              FontMemory;

        VkImage                     FontImage;

        VkImageView                 FontView;

        VkDescriptorSet             FontDescriptorSet;

        VkDeviceMemory              UploadBufferMemory;

        VkBuffer                    UploadBuffer;
 
        // Image data
        std::vector<KarmaGui_ImplVulkan_Image_TextureData*>         vulkanMesaDecalDataList;
 
        // Render buffers for main window
        //KarmaGui_ImplVulkanH_WindowRenderBuffers MainWindowRenderBuffers;
        
        // heh, not working with initializers in MSVC. Need a blog post!
        
        /*
        ImGui_ImplVulkan_Data()
        {
            memset((void*)this, 0, sizeof(*this));
            BufferMemoryAlignment = 256;
        }*/
    };

    class KARMA_API KarmaGuiVulkanHandler
    {
    public:
        /*
        inline static KarmaGui_ImplVulkan_Data* KarmaGui_ImplVulkan_GetBackendData()
        {
            return KarmaGui::GetCurrentContext() ? (KarmaGui_ImplVulkan_Data*)KarmaGui::GetIO().BackendRendererUserData : nullptr;
        }*/
        // GetIO should fetche the configuration settings and whatnot, which in this case is the struct KarmaGui_ImplVulkan_Data

        static uint32_t KarmaGui_ImplVulkan_MemoryType(VkMemoryPropertyFlags properties, uint32_t type_bits);

        static void CreateOrResizeBuffer(VkBuffer& buffer, VkDeviceMemory& bufferMemory, VkDeviceSize& pBufferSize, size_t newSize, VkBufferUsageFlagBits usage);

        static void KarmaGui_ImplVulkan_SetupRenderState(KGDrawData* drawData, VkPipeline pipeline, VkCommandBuffer commandBuffer, KarmaGui_ImplVulkanH_ImageFrameRenderBuffers* remderingBufferData, int width, int height);
                
        static void KarmaGui_ImplVulkan_CreateShaderModules(VkDevice device, const VkAllocationCallbacks* allocator);
 
        static VkShaderModule KarmaGui_ImplVulkan_CreateShaderModule(const std::vector<uint32_t>& code);

        static void KarmaGui_ImplVulkan_CreateFontSampler(VkDevice device, const VkAllocationCallbacks* allocator);

        static void KarmaGui_ImplVulkan_CreateDescriptorSetLayout(VkDevice device, const VkAllocationCallbacks* allocator);

        static void KarmaGui_ImplVulkan_CreatePipelineLayout(VkDevice device, const VkAllocationCallbacks* allocator);

        static void KarmaGui_ImplVulkan_CreatePipeline(VkDevice device, const VkAllocationCallbacks* allocator, VkPipelineCache pipelineCache, VkRenderPass renderPass, VkSampleCountFlagBits MSAASamples, VkPipeline* pipeline, uint32_t subpass);

        static void KarmaGui_ImplVulkan_CreateWindow(KarmaGuiViewport* viewport);
 
        // Overload for destroying KarmaGui window
        static void KarmaGui_ImplVulkan_DestroyWindow(KarmaGuiViewport* viewport);

        static void KarmaGui_ImplVulkan_DestroyWindow(KarmaGui_ImplVulkanH_Window* windowData);

        static void KarmaGui_ImplVulkan_SetWindowSize(KarmaGuiViewport* viewport, KGVec2 size);

        static void KarmaGui_ImplVulkan_RenderWindow(KarmaGuiViewport* viewport, void*);

        static void KarmaGui_ImplVulkan_RenderDrawData(KGDrawData* drawData, VkCommandBuffer commandBuffer, VkPipeline pipeline, uint32_t imageFrameIndex);

        static void KarmaGui_ImplVulkan_SwapBuffers(KarmaGuiViewport* viewport, void*);

        static void CheckInitialization();

        static void FillWindowData(KarmaGui_ImplVulkanH_Window* windowData, bool bCreateSyncronicity);

        static void MakeRenderPassInfo(FVulkanSwapChain* SwapChain, struct FVulkanRenderPassInfo& RPInfo);
        
        static void CreateDepthRenderTarget(FVulkanRenderTargetsInfo& RTInfo, FVulkanSwapChain* SwapChain);
        
        static void GatherSwapChainColorRenderTargets(FVulkanRenderTargetsInfo& RTInfo, FVulkanSwapChain* SwapChain, uint32_t SwapChainImageIndex);
        
        static void ShivaSwapChainForRebuild(KarmaGui_ImplVulkanH_Window* windowData);
        
        static void CreateOffScreenTextureResources();
        
        static void CreateOffScreenTextureDepthResource(KarmaGui_3DScene_To_2DTexture_Data* textureData);
        
        static void CreateOffScreenTextureRenderpassResource();
        
        static void CreateOffScreenTextureFrameBufferResource(KarmaGui_3DScene_To_2DTexture_Data* textureData);
 
        static void CreateOffScreenTextureGraphicsPipelineResource(VkRenderPass renderPassKG, float windowKGWidth, float windowKGHeight);

        static void ClearVulkanWindowData(KarmaGui_ImplVulkanH_Window* vulkanWindowData, bool bDestroySyncronicity = false);

        static void DestroyWindowDataFrame(KarmaGui_ImplVulkanH_ImageFrame* frame);

        static void DestroyFramesOnFlightData(KarmaGui_Vulkan_Frame_On_Flight* frameSyncronicityData);

        static void KarmaGui_ImplVulkan_CreateOrResizeWindow(KarmaGui_ImplVulkanH_Window* windowData, bool bCreateSyncronicity, bool bRecreateSwapChainAndCommandBuffers);
 
        static void KarmaGui_ImplVulkan_DestroyAllViewportsRenderBuffers(VkDevice device, const VkAllocationCallbacks* allocator);

        static void KarmaGui_ImplVulkan_ShivaWindowRenderBuffers(VkDevice device, KarmaGui_ImplVulkanH_WindowRenderBuffers* buffers, const VkAllocationCallbacks* allocator);

        static void KarmaGui_ImplVulkan_ShivaFrameRenderBuffers(VkDevice device, KarmaGui_ImplVulkanH_ImageFrameRenderBuffers* buffers, const VkAllocationCallbacks* allocator);

        static bool KarmaGui_ImplVulkan_CreateFontsTexture(VkCommandBuffer commandBuffer);

        static bool KarmaGui_ImplVulkan_CreateTexture(VkCommandBuffer commandBuffer, char const* fileName, const std::string& lable = "");

        static bool KarmaGui_ImplVulkan_CreateDeviceObjects();

        static void KarmaGui_ImplVulkan_DestroyFontUploadObjects();

        static void KarmaGui_ImplVulkan_DestroyDeviceObjects();

        static void KarmaGui_ImplVulkan_Shutdown();

        static void KarmaGui_ImplVulkan_NewFrame();
 
        // Register a texture (VkDescriptorSet == ImTextureID)
        // FIXME: This is experimental in the sense that we are unsure how to best design/tackle this problem, please post to   https://github.com/ocornut/imgui/pull/914 if you have suggestions.
        static VkDescriptorSet KarmaGui_ImplVulkan_AddTexture(VkSampler sampler, VkImageView imageView, VkImageLayout imageLayout);

        static void KarmaGui_ImplVulkan_InitPlatformInterface();

        static void KarmaGui_ImplVulkan_ShutdownPlatformInterface();
    };
}