blam/html/imgui__impl__vulkan_8h_source.html

// dear imgui: Renderer for Vulkan

// This needs to be used along with a Platform Binding (e.g. GLFW, SDL, Win32, custom..)


// Implemented features:

//  [X] Renderer: Support for large meshes (64k+ vertices) with 16-bit indices.

// Missing features:

//  [ ] Renderer: User texture binding. Changes of ImTextureID aren't supported by this binding! See https://github.com/ocornut/imgui/pull/914


// You can copy and use unmodified imgui_impl_* files in your project. See main.cpp for an example of using this.

// If you are new to dear imgui, read examples/README.txt and read the documentation at the top of imgui.cpp.

// https://github.com/ocornut/imgui


// The aim of imgui_impl_vulkan.h/.cpp is to be usable in your engine without any modification.

// IF YOU FEEL YOU NEED TO MAKE ANY CHANGE TO THIS CODE, please share them and your feedback at https://github.com/ocornut/imgui/


// Important note to the reader who wish to integrate imgui_impl_vulkan.cpp/.h in their own engine/app.

// - Common ImGui_ImplVulkan_XXX functions and structures are used to interface with imgui_impl_vulkan.cpp/.h.

//   You will use those if you want to use this rendering back-end in your engine/app.

// - Helper ImGui_ImplVulkanH_XXX functions and structures are only used by this example (main.cpp) and by

//   the back-end itself (imgui_impl_vulkan.cpp), but should PROBABLY NOT be used by your own engine/app code.

// Read comments in imgui_impl_vulkan.h.


#pragma once


#include <vulkan/vulkan.h>

#include "../../imgui.h"      // IMGUI_IMPL_API


// Initialization data, for ImGui_ImplVulkan_Init()

// [Please zero-clear before use!]

struct ImGui_ImplVulkan_InitInfo

{

    VkInstance          Instance;

    VkPhysicalDevice    PhysicalDevice;

    VkDevice            Device;

    uint32_t            QueueFamily;

    VkQueue             Queue;

    VkPipelineCache     PipelineCache;

    VkDescriptorPool    DescriptorPool;

    uint32_t            MinImageCount;          // >= 2

    uint32_t            ImageCount;             // >= MinImageCount

    VkSampleCountFlagBits        MSAASamples;   // >= VK_SAMPLE_COUNT_1_BIT

    const VkAllocationCallbacks* Allocator;

    void                (*CheckVkResultFn)(VkResult err);

};


// Called by user code

IMGUI_IMPL_API bool     ImGui_ImplVulkan_Init(ImGui_ImplVulkan_InitInfo* info, VkRenderPass render_pass);

IMGUI_IMPL_API void     ImGui_ImplVulkan_Shutdown();

IMGUI_IMPL_API void     ImGui_ImplVulkan_NewFrame();

IMGUI_IMPL_API void     ImGui_ImplVulkan_RenderDrawData(ImDrawData* draw_data, VkCommandBuffer command_buffer);

IMGUI_IMPL_API bool     ImGui_ImplVulkan_CreateFontsTexture(VkCommandBuffer command_buffer);

IMGUI_IMPL_API void     ImGui_ImplVulkan_DestroyFontUploadObjects();

IMGUI_IMPL_API void     ImGui_ImplVulkan_SetMinImageCount(uint32_t min_image_count); // To override MinImageCount after initialization (e.g. if swap chain is recreated)


//-------------------------------------------------------------------------

// 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 upcoming multi-viewport feature will need 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 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 ImGui_ImplVulkanH_Frame;

struct ImGui_ImplVulkanH_Window;


// Helpers

IMGUI_IMPL_API void                 ImGui_ImplVulkanH_CreateWindow(VkInstance instance, VkPhysicalDevice physical_device, VkDevice device, ImGui_ImplVulkanH_Window* wnd, uint32_t queue_family, const VkAllocationCallbacks* allocator, int w, int h, uint32_t min_image_count);

IMGUI_IMPL_API void                 ImGui_ImplVulkanH_DestroyWindow(VkInstance instance, VkDevice device, ImGui_ImplVulkanH_Window* wnd, const VkAllocationCallbacks* allocator);

IMGUI_IMPL_API VkSurfaceFormatKHR   ImGui_ImplVulkanH_SelectSurfaceFormat(VkPhysicalDevice physical_device, VkSurfaceKHR surface, const VkFormat* request_formats, int request_formats_count, VkColorSpaceKHR request_color_space);

IMGUI_IMPL_API VkPresentModeKHR     ImGui_ImplVulkanH_SelectPresentMode(VkPhysicalDevice physical_device, VkSurfaceKHR surface, const VkPresentModeKHR* request_modes, int request_modes_count);

IMGUI_IMPL_API int                  ImGui_ImplVulkanH_GetMinImageCountFromPresentMode(VkPresentModeKHR present_mode);


// Helper structure to hold the data needed by one rendering frame

// (Used by example's main.cpp. Used by multi-viewport features. Probably NOT used by your own engine/app.)

// [Please zero-clear before use!]

struct ImGui_ImplVulkanH_Frame

{

    VkCommandPool       CommandPool;

    VkCommandBuffer     CommandBuffer;

    VkFence             Fence;

    VkImage             Backbuffer;

    VkImageView         BackbufferView;

    VkFramebuffer       Framebuffer;

};


struct ImGui_ImplVulkanH_FrameSemaphores

{

    VkSemaphore         ImageAcquiredSemaphore;

    VkSemaphore         RenderCompleteSemaphore;

};


// Helper structure to hold the data needed by one rendering context into one OS window

// (Used by example's main.cpp. Used by multi-viewport features. Probably NOT used by your own engine/app.)

struct ImGui_ImplVulkanH_Window

{

    int                 Width;

    int                 Height;

    VkSwapchainKHR      Swapchain;

    VkSurfaceKHR        Surface;

    VkSurfaceFormatKHR  SurfaceFormat;

    VkPresentModeKHR    PresentMode;

    VkRenderPass        RenderPass;

    bool                ClearEnable;

    VkClearValue        ClearValue;

    uint32_t            FrameIndex;             // Current frame being rendered to (0 <= FrameIndex < FrameInFlightCount)

    uint32_t            ImageCount;             // Number of simultaneous in-flight frames (returned by vkGetSwapchainImagesKHR, usually derived from min_image_count)

    uint32_t            SemaphoreIndex;         // Current set of swapchain wait semaphores we're using (needs to be distinct from per frame data)

    ImGui_ImplVulkanH_Frame*            Frames;

    ImGui_ImplVulkanH_FrameSemaphores*  FrameSemaphores;


    ImGui_ImplVulkanH_Window()

    {

        memset(this, 0, sizeof(*this));

        PresentMode = VK_PRESENT_MODE_MAX_ENUM_KHR;

        ClearEnable = true;

    }

};