pull imgui docking 1.92.9 and generate

SDL3 Renderer Example

README.md

@@ -11,7 +11,7 @@ History:
 Initially cimgui was developed by Stephan Dilly as hand-written code but lately turned into an auto-generated version by sonoro1234 in order to keep up with imgui more easily (letting the user select the desired branch and commit)
 
 Notes:
-* currently this wrapper is based on version [1.92.4 of Dear ImGui with internal api]
+* currently this wrapper is based on version [1.92.9 of Dear ImGui with internal api]
 * only functions, structs and enums from imgui.h (an optionally imgui_internal.h) are wrapped.
 * if you are interested in imgui backends you should look [LuaJIT-ImGui](https://github.com/sonoro1234/LuaJIT-ImGui) project.
 * All naming is algorithmic except for those names that were coded in cimgui_overloads table (https://github.com/cimgui/cimgui/blob/master/generator/generator.lua#L60). In the official version this table is empty.
@@ -106,10 +106,14 @@ Notes:
 # example bindings based on cimgui
 
 * [LuaJIT-ImGui](https://github.com/sonoro1234/LuaJIT-ImGui)
+* [cimgui-go](https://github.com/AllenDang/cimgui-go)
+* [Hexa.NET.ImGui](https://github.com/HexaEngine/Hexa.NET.ImGui)
+* [dear-imgui-rs](https://github.com/Latias94/dear-imgui-rs)
+* [CImGui.jl](https://github.com/Gnimuc/CImGui.jl)
 * [ImGui.NET](https://github.com/mellinoe/ImGui.NET)
+* [Zig-ImGui](https://github.com/SpexGuy/Zig-ImGui)
 * [nimgl/imgui](https://github.com/nimgl/imgui)
 * [kotlin-imgui](https://github.com/Dominaezzz/kotlin-imgui)
-* [CImGui.jl](https://github.com/Gnimuc/CImGui.jl)
 * [odin-imgui](https://github.com/ThisDrunkDane/odin-imgui)
 * [DerelictImgui](https://github.com/Extrawurst/DerelictImgui)
 * [BindBC-CimGui](https://github.com/MrcSnm/bindbc-cimgui)

backend_test/example_sdl3_vulkan/main.c

@@ -12,7 +12,7 @@
 #endif
 
 //this must be equal to that in imgui_impl_vulkan.h
-#define IMGUI_IMPL_VULKAN_MINIMUM_IMAGE_SAMPLER_POOL_SIZE   (1)     // Minimum per atlas
+//#define IMGUI_IMPL_VULKAN_MINIMUM_IMAGE_SAMPLER_POOL_SIZE   (1)     // Minimum per atlas
 
 #define CIMGUI_DEFINE_ENUMS_AND_STRUCTS
 #include <cimgui.h>
@@ -214,7 +214,8 @@ static void SetupVulkan(const char** extensions, uint32_t extensions_count)
     {
         VkDescriptorPoolSize pool_sizes[] =
         {
-            { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, IMGUI_IMPL_VULKAN_MINIMUM_IMAGE_SAMPLER_POOL_SIZE },
+            { VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, IMGUI_IMPL_VULKAN_MINIMUM_SAMPLED_IMAGE_POOL_SIZE },
+            { VK_DESCRIPTOR_TYPE_SAMPLER, IMGUI_IMPL_VULKAN_MINIMUM_SAMPLER_POOL_SIZE },
         };
         VkDescriptorPoolCreateInfo pool_info = {};
         pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
@@ -281,9 +282,10 @@ static void CleanupVulkan()
     vkDestroyInstance(g_Instance, g_Allocator);
 }
 
-static void CleanupVulkanWindow()
+static void CleanupVulkanWindow(ImGui_ImplVulkanH_Window* wd)
 {
-    ImGui_ImplVulkanH_DestroyWindow(g_Instance, g_Device, &g_MainWindowData, g_Allocator);
+    ImGui_ImplVulkanH_DestroyWindow(g_Instance, g_Device, wd, g_Allocator);
+    vkDestroySurfaceKHR(g_Instance, wd->Surface, g_Allocator);
 }
 
 static void FrameRender(ImGui_ImplVulkanH_Window* wd, ImDrawData* draw_data)
@@ -620,7 +622,7 @@ int main(int argc, char* argv[])
     ImGui_ImplSDL3_Shutdown();
     igDestroyContext(NULL);
 
-    CleanupVulkanWindow();
+    CleanupVulkanWindow(&g_MainWindowData);
     CleanupVulkan();
 
     SDL_DestroyWindow(window);

backend_test/example_sdl_renderer3/CMakeLists.txt

@@ -0,0 +1,36 @@
+cmake_minimum_required(VERSION 3.30)
+project(cimgui_sdlrenderer3 LANGUAGES C CXX)
+
+set(CMAKE_C_STANDARD 11)
+
+include(FetchContent)
+
+FetchContent_Declare(
+        sdl3
+        GIT_REPOSITORY https://github.com/libsdl-org/SDL.git
+        GIT_TAG release-3.4.0
+        #GIT_SHALLOW TRUE
+        GIT_PROGRESS TRUE
+)
+
+set(SDL_TEST_LIBRARY OFF CACHE BOOL "" FORCE)
+FetchContent_MakeAvailable(sdl3)
+
+include(../cmake/GenerateCimguiBindings.cmake)
+
+set(inclulist ${sdl3_SOURCE_DIR}/include)
+GenerateCimguiBindings(cimgui_with_backend sdl3 sdlrenderer3 inclulist)
+target_link_libraries(cimgui_with_backend PRIVATE SDL3::SDL3)
+
+add_executable(${PROJECT_NAME} 
+	main.c
+)
+
+target_link_libraries(${PROJECT_NAME} PRIVATE SDL3::SDL3 cimgui_with_backend)
+target_compile_definitions(
+	${PROJECT_NAME}
+	PRIVATE 
+	CIMGUI_DEFINE_ENUMS_AND_STRUCTS=1
+	CIMGUI_USE_SDL3=1
+  CIMGUI_USE_SDLRENDERER3=1
+)

backend_test/example_sdl_renderer3/README.md

@@ -0,0 +1,16 @@
+# SDLRenderer3
+
+This example takes from `example_sdlgpu3`. We need to generate bindings for SDLRenderer3 backend because they are not native to `cimgui`. Then you can add the compiled library for linking in your application.
+
+For the generation phase from cmake you need LuaJIT to be present.
+
+## Building
+
+From the build directory of your choice:
+
+`cmake path_to_example_sdlgpu3`
+
+Then simply run:
+
+`make`
+

backend_test/example_sdl_renderer3/main.c

@@ -0,0 +1,158 @@
+#include <assert.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <SDL3/SDL.h>
+
+#include <cimgui.h>
+#include <cimgui_impl.h>
+
+#define igGetIO igGetIO_Nil
+
+int main() {
+    // Setup SDL library
+    if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMEPAD)) {
+      fprintf(stderr, "Failed to init video! %s", SDL_GetError());
+      return 1;
+    };
+   
+    // Setup window and renderer
+    float main_scale = SDL_GetDisplayContentScale(SDL_GetPrimaryDisplay());
+    SDL_WindowFlags window_flags = SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIDDEN | SDL_WINDOW_HIGH_PIXEL_DENSITY;
+    SDL_Window* window = NULL;
+    SDL_Renderer* renderer = NULL;
+    if (!SDL_CreateWindowAndRenderer("Dear ImGui SDL3 Renderer example", (int)(1280 * main_scale), (int)(720 * main_scale), window_flags, &window, &renderer))
+    {
+        printf("Error: SDL_CreateWindow(): %s\n", SDL_GetError());
+        return -1;
+    }
+    SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
+    SDL_ShowWindow(window);
+
+    // Setup Dear ImGui context
+    igCreateContext(NULL);
+    ImGuiIO* io = igGetIO(); (void)io;
+    io->ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
+    io->ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;
+
+    // Setup Dear ImGui style
+    igStyleColorsDark(NULL);
+    //igStyleColorsLight(NULL);
+  
+    // Setup scaling
+    ImGuiStyle* style = igGetStyle();
+    ImGuiStyle_ScaleAllSizes(style, main_scale);        
+    style->FontScaleDpi = main_scale;        // Set initial font scale. (using io.ConfigDpiScaleFonts=true makes this unnecessary. We leave both here for documentation purpose)
+    io->ConfigDpiScaleFonts = true;          // [Experimental] Automatically overwrite style.FontScaleDpi in Begin() when Monitor DPI changes. This will scale fonts but _NOT_ scale sizes/padding for now.
+    io->ConfigDpiScaleViewports = true;      // [Experimental] Scale Dear ImGui and Platform Windows when Monitor DPI changes.
+
+    // Setup Platform/Renderer backends
+    ImGui_ImplSDL3_InitForSDLRenderer(window, renderer);
+    ImGui_ImplSDLRenderer3_Init(renderer);
+
+    // Our state
+    bool show_demo_window = true;
+    bool show_another_window = false;
+    ImVec4 clear_color;
+    clear_color.x = 0.45f;
+    clear_color.y = 0.55f;
+    clear_color.z = 0.60f;
+    clear_color.w = 1.00f;
+
+    // Main loop
+    bool done = false;
+    while (!done)
+    {
+        // Poll and handle events (inputs, window resize, etc.)
+        // You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
+        // - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application, or clear/overwrite your copy of the mouse data.
+        // - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application, or clear/overwrite your copy of the keyboard data.
+        // Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
+        // [If using SDL_MAIN_USE_CALLBACKS: call ImGui_ImplSDL3_ProcessEvent() from your SDL_AppEvent() function]
+        SDL_Event event;
+        while (SDL_PollEvent(&event))
+        {
+            ImGui_ImplSDL3_ProcessEvent(&event);
+            if (event.type == SDL_EVENT_QUIT)
+                done = true;
+            if (event.type == SDL_EVENT_WINDOW_CLOSE_REQUESTED && event.window.windowID == SDL_GetWindowID(window))
+                done = true;
+        }
+
+        // [If using SDL_MAIN_USE_CALLBACKS: all code below would likely be your SDL_AppIterate() function]
+        if (SDL_GetWindowFlags(window) & SDL_WINDOW_MINIMIZED)
+        {
+            SDL_Delay(10);
+            continue;
+        }
+
+        // Setup Dear ImGui frame
+        SDL_SetRenderDrawColorFloat(renderer, clear_color.x, clear_color.y, clear_color.z, clear_color.w);
+        SDL_RenderClear(renderer);
+        ImGui_ImplSDLRenderer3_NewFrame();
+        ImGui_ImplSDL3_NewFrame();
+        igNewFrame();
+
+        // 1. Show the big demo window (Most of the sample code is in igShowDemoWindow()! You can browse its code to learn more about Dear ImGui!).
+        if (show_demo_window)
+            igShowDemoWindow(&show_demo_window);
+
+        // 2. Show a simple window that we create ourselves. We use a Begin/End pair to create a named window.
+        {
+            static float f = 0.0f;
+            static int counter = 0;
+
+            igBegin("Hello, world!", NULL, 0);                    // Create a window called "Hello, world!" and append into it.
+
+            igText("This is some useful text.");                  // Display some text (you can use a format strings too)
+            igCheckbox("Demo Window", &show_demo_window);         // Edit bools storing our window open/close state
+            igCheckbox("Another Window", &show_another_window);
+
+            igSliderFloat("float", &f, 0.0f, 1.0f, "%.3f", 0);    // Edit 1 float using a slider from 0.0f to 1.0f
+            igColorEdit4("clear color", (float*)&clear_color, 0); // Edit 3 floats representing a color
+
+            ImVec2 buttonSize;
+            buttonSize.x = 0;
+            buttonSize.y = 0;
+            if (igButton("Button", buttonSize))                   // Buttons return true when clicked (most widgets return true when edited/activated)
+                counter++;
+            igSameLine(0.0f, -1.0f);
+            igText("counter = %d", counter);
+
+            igText("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / io->Framerate, io->Framerate);
+            igEnd();
+        }
+
+        // 3. Show another simple window.
+        if (show_another_window)
+        {
+            igBegin("Another Window", &show_another_window, 0);   // Pass a pointer to our bool variable (the window will have a closing button that will clear the bool when clicked)
+            igText("Hello from another window!");
+            ImVec2 buttonSize;
+            buttonSize.x = 0; buttonSize.y = 0;
+            if (igButton("Close Me", buttonSize))
+                show_another_window = false;
+            igEnd();
+        }
+
+        // Rendering
+        igRender();
+        ImDrawData* draw_data = igGetDrawData();
+        const bool is_minimized = (draw_data->DisplaySize.x <= 0.0f || draw_data->DisplaySize.y <= 0.0f);
+        ImGui_ImplSDLRenderer3_RenderDrawData(draw_data, renderer);
+        SDL_RenderPresent(renderer);
+    }
+
+    // Cleanup
+    // [If using SDL_MAIN_USE_CALLBACKS: all code below would likely be your SDL_AppQuit() function]
+    ImGui_ImplSDL3_Shutdown();
+    ImGui_ImplSDLRenderer3_Shutdown();
+    igDestroyContext(NULL);
+
+    SDL_DestroyRenderer(renderer);
+    SDL_DestroyWindow(window);
+    SDL_Quit();
+
+    return 0;
+}

backend_test/example_sdl_vulkan/main.c

@@ -16,7 +16,7 @@
 #endif
 
 //this must be equal to that in imgui_impl_vulkan.h
-#define IMGUI_IMPL_VULKAN_MINIMUM_IMAGE_SAMPLER_POOL_SIZE   (1)     // Minimum per atlas
+//#define IMGUI_IMPL_VULKAN_MINIMUM_IMAGE_SAMPLER_POOL_SIZE   (1)     // Minimum per atlas
 
 #define CIMGUI_DEFINE_ENUMS_AND_STRUCTS
 #include "cimgui.h"
@@ -218,7 +218,8 @@ static void SetupVulkan(const char** extensions, uint32_t extensions_count)
     {
         VkDescriptorPoolSize pool_sizes[] =
         {
-            { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, IMGUI_IMPL_VULKAN_MINIMUM_IMAGE_SAMPLER_POOL_SIZE },
+            { VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, IMGUI_IMPL_VULKAN_MINIMUM_SAMPLED_IMAGE_POOL_SIZE },
+            { VK_DESCRIPTOR_TYPE_SAMPLER, IMGUI_IMPL_VULKAN_MINIMUM_SAMPLER_POOL_SIZE },
         };
         VkDescriptorPoolCreateInfo pool_info = {};
         pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
@@ -285,9 +286,10 @@ static void CleanupVulkan()
     vkDestroyInstance(g_Instance, g_Allocator);
 }
 
-static void CleanupVulkanWindow()
+static void CleanupVulkanWindow(ImGui_ImplVulkanH_Window* wd)
 {
-    ImGui_ImplVulkanH_DestroyWindow(g_Instance, g_Device, &g_MainWindowData, g_Allocator);
+    ImGui_ImplVulkanH_DestroyWindow(g_Instance, g_Device, wd, g_Allocator);
+    vkDestroySurfaceKHR(g_Instance, wd->Surface, g_Allocator);
 }
 
 static void FrameRender(ImGui_ImplVulkanH_Window* wd, ImDrawData* draw_data)
@@ -615,7 +617,7 @@ int main(int argc, char* argv[])
     ImGui_ImplSDL2_Shutdown();
     igDestroyContext(NULL);
 
-    CleanupVulkanWindow();
+    CleanupVulkanWindow(&g_MainWindowData);
     CleanupVulkan();
 
     SDL_DestroyWindow(window);

cimgui.cpp

@@ -1,5 +1,5 @@
 //This file is automatically generated by generator.lua from https://github.com/cimgui/cimgui
-//based on imgui.h file version "1.92.6" 19261 from Dear ImGui https://github.com/ocornut/imgui
+//based on imgui.h file version "1.92.9" 19290 from Dear ImGui https://github.com/ocornut/imgui
 //with imgui_internal.h api
 //with imgui_freetype.h api
 //docking branch
@@ -1023,10 +1023,6 @@ CIMGUI_API bool igColorButton(const char* desc_id,const ImVec4_c col,ImGuiColorE
 {
     return ImGui::ColorButton(desc_id,ConvertToCPP_ImVec4(col),flags,ConvertToCPP_ImVec2(size));
 }
-CIMGUI_API void igSetColorEditOptions(ImGuiColorEditFlags flags)
-{
-    return ImGui::SetColorEditOptions(flags);
-}
 CIMGUI_API bool igTreeNode_Str(const char* label)
 {
     return ImGui::TreeNode(label);
@@ -1139,6 +1135,10 @@ CIMGUI_API void igSetNextItemStorageID(ImGuiID storage_id)
 {
     return ImGui::SetNextItemStorageID(storage_id);
 }
+CIMGUI_API bool igTreeNodeGetOpen(ImGuiID storage_id)
+{
+    return ImGui::TreeNodeGetOpen(storage_id);
+}
 CIMGUI_API bool igSelectable_Bool(const char* label,bool selected,ImGuiSelectableFlags flags,const ImVec2_c size)
 {
     return ImGui::Selectable(label,selected,flags,ConvertToCPP_ImVec2(size));
@@ -1301,15 +1301,15 @@ CIMGUI_API void igEndPopup()
 {
     return ImGui::EndPopup();
 }
-CIMGUI_API void igOpenPopup_Str(const char* str_id,ImGuiPopupFlags popup_flags)
+CIMGUI_API bool igOpenPopup_Str(const char* str_id,ImGuiPopupFlags popup_flags)
 {
     return ImGui::OpenPopup(str_id,popup_flags);
 }
-CIMGUI_API void igOpenPopup_ID(ImGuiID id,ImGuiPopupFlags popup_flags)
+CIMGUI_API bool igOpenPopup_ID(ImGuiID id,ImGuiPopupFlags popup_flags)
 {
     return ImGui::OpenPopup(id,popup_flags);
 }
-CIMGUI_API void igOpenPopupOnItemClick(const char* str_id,ImGuiPopupFlags popup_flags)
+CIMGUI_API bool igOpenPopupOnItemClick(const char* str_id,ImGuiPopupFlags popup_flags)
 {
     return ImGui::OpenPopupOnItemClick(str_id,popup_flags);
 }
@@ -1353,9 +1353,9 @@ CIMGUI_API bool igTableSetColumnIndex(int column_n)
 {
     return ImGui::TableSetColumnIndex(column_n);
 }
-CIMGUI_API void igTableSetupColumn(const char* label,ImGuiTableColumnFlags flags,float init_width_or_weight,ImGuiID user_id)
+CIMGUI_API void igTableSetupColumn(const char* label,ImGuiTableColumnFlags flags,float init_width_or_weight,ImGuiID user_data)
 {
-    return ImGui::TableSetupColumn(label,flags,init_width_or_weight,user_id);
+    return ImGui::TableSetupColumn(label,flags,init_width_or_weight,user_data);
 }
 CIMGUI_API void igTableSetupScrollFreeze(int cols,int rows)
 {
@@ -1658,6 +1658,10 @@ CIMGUI_API ImGuiItemFlags igGetItemFlags()
 {
     return ImGui::GetItemFlags();
 }
+CIMGUI_API int igGetItemClickedCountWithSingleClickDelay(ImGuiMouseButton mouse_button,float delay)
+{
+    return ImGui::GetItemClickedCountWithSingleClickDelay(mouse_button,delay);
+}
 CIMGUI_API ImGuiViewport* igGetMainViewport()
 {
     return ImGui::GetMainViewport();
@@ -1758,7 +1762,7 @@ CIMGUI_API void igSetNextItemShortcut(ImGuiKeyChord key_chord,ImGuiInputFlags fl
 {
     return ImGui::SetNextItemShortcut(key_chord,flags);
 }
-CIMGUI_API void igSetItemKeyOwner_Nil(ImGuiKey key)
+CIMGUI_API bool igSetItemKeyOwner_Nil(ImGuiKey key)
 {
     return ImGui::SetItemKeyOwner(key);
 }
@@ -2459,9 +2463,17 @@ CIMGUI_API void ImDrawList_AddLine(ImDrawList* self,const ImVec2_c p1,const ImVe
 {
     return self->AddLine(ConvertToCPP_ImVec2(p1),ConvertToCPP_ImVec2(p2),col,thickness);
 }
-CIMGUI_API void ImDrawList_AddRect(ImDrawList* self,const ImVec2_c p_min,const ImVec2_c p_max,ImU32 col,float rounding,ImDrawFlags flags,float thickness)
+CIMGUI_API void ImDrawList_AddLineH(ImDrawList* self,float min_x,float max_x,float y,ImU32 col,float thickness)
 {
-    return self->AddRect(ConvertToCPP_ImVec2(p_min),ConvertToCPP_ImVec2(p_max),col,rounding,flags,thickness);
+    return self->AddLineH(min_x,max_x,y,col,thickness);
+}
+CIMGUI_API void ImDrawList_AddLineV(ImDrawList* self,float x,float min_y,float max_y,ImU32 col,float thickness)
+{
+    return self->AddLineV(x,min_y,max_y,col,thickness);
+}
+CIMGUI_API void ImDrawList_AddRect(ImDrawList* self,const ImVec2_c p_min,const ImVec2_c p_max,ImU32 col,float rounding,float thickness,ImDrawFlags flags)
+{
+    return self->AddRect(ConvertToCPP_ImVec2(p_min),ConvertToCPP_ImVec2(p_max),col,rounding,thickness,flags);
 }
 CIMGUI_API void ImDrawList_AddRectFilled(ImDrawList* self,const ImVec2_c p_min,const ImVec2_c p_max,ImU32 col,float rounding,ImDrawFlags flags)
 {
@@ -2527,9 +2539,9 @@ CIMGUI_API void ImDrawList_AddBezierQuadratic(ImDrawList* self,const ImVec2_c p1
 {
     return self->AddBezierQuadratic(ConvertToCPP_ImVec2(p1),ConvertToCPP_ImVec2(p2),ConvertToCPP_ImVec2(p3),col,thickness,num_segments);
 }
-CIMGUI_API void ImDrawList_AddPolyline(ImDrawList* self,const ImVec2_c* points,int num_points,ImU32 col,ImDrawFlags flags,float thickness)
+CIMGUI_API void ImDrawList_AddPolyline(ImDrawList* self,const ImVec2_c* points,int num_points,ImU32 col,float thickness,ImDrawFlags flags)
 {
-    return self->AddPolyline(reinterpret_cast<const ImVec2*>(points),num_points,col,flags,thickness);
+    return self->AddPolyline(reinterpret_cast<const ImVec2*>(points),num_points,col,thickness,flags);
 }
 CIMGUI_API void ImDrawList_AddConvexPolyFilled(ImDrawList* self,const ImVec2_c* points,int num_points,ImU32 col)
 {
@@ -2571,9 +2583,9 @@ CIMGUI_API void ImDrawList_PathFillConcave(ImDrawList* self,ImU32 col)
 {
     return self->PathFillConcave(col);
 }
-CIMGUI_API void ImDrawList_PathStroke(ImDrawList* self,ImU32 col,ImDrawFlags flags,float thickness)
+CIMGUI_API void ImDrawList_PathStroke(ImDrawList* self,ImU32 col,float thickness,ImDrawFlags flags)
 {
-    return self->PathStroke(col,flags,thickness);
+    return self->PathStroke(col,thickness,flags);
 }
 CIMGUI_API void ImDrawList_PathArcTo(ImDrawList* self,const ImVec2_c center,float radius,float a_min,float a_max,int num_segments)
 {
@@ -2879,10 +2891,6 @@ CIMGUI_API void ImFontAtlas_RemoveFont(ImFontAtlas* self,ImFont* font)
 {
     return self->RemoveFont(font);
 }
-CIMGUI_API void ImFontAtlas_Clear(ImFontAtlas* self)
-{
-    return self->Clear();
-}
 CIMGUI_API void ImFontAtlas_CompactCache(ImFontAtlas* self)
 {
     return self->CompactCache();
@@ -2891,14 +2899,18 @@ CIMGUI_API void ImFontAtlas_SetFontLoader(ImFontAtlas* self,const ImFontLoader*
 {
     return self->SetFontLoader(font_loader);
 }
-CIMGUI_API void ImFontAtlas_ClearInputData(ImFontAtlas* self)
+CIMGUI_API void ImFontAtlas_Clear(ImFontAtlas* self)
 {
-    return self->ClearInputData();
+    return self->Clear();
 }
 CIMGUI_API void ImFontAtlas_ClearFonts(ImFontAtlas* self)
 {
     return self->ClearFonts();
 }
+CIMGUI_API void ImFontAtlas_ClearInputData(ImFontAtlas* self)
+{
+    return self->ClearInputData();
+}
 CIMGUI_API void ImFontAtlas_ClearTexData(ImFontAtlas* self)
 {
     return self->ClearTexData();
@@ -3015,6 +3027,10 @@ CIMGUI_API ImVec2_c ImGuiViewport_GetWorkCenter(ImGuiViewport* self)
 {
     return ConvertFromCPP_ImVec2(self->GetWorkCenter());
 }
+CIMGUI_API const char* ImGuiViewport_GetDebugName(ImGuiViewport* self)
+{
+    return self->GetDebugName();
+}
 CIMGUI_API ImGuiPlatformIO* ImGuiPlatformIO_ImGuiPlatformIO(void)
 {
     return IM_NEW(ImGuiPlatformIO)();
@@ -3410,6 +3426,10 @@ CIMGUI_API float igImRound64(float f)
 {
     return ImRound64(f);
 }
+CIMGUI_API float igImCeilFast(float f)
+{
+    return ImCeilFast(f);
+}
 CIMGUI_API int igImModPositive(int a,int b)
 {
     return ImModPositive(a,b);
@@ -3602,6 +3622,14 @@ CIMGUI_API void ImRect_Add_Rect(ImRect* self,const ImRect_c r)
 {
     return self->Add(ConvertToCPP_ImRect(r));
 }
+CIMGUI_API void ImRect_AddX(ImRect* self,float x)
+{
+    return self->AddX(x);
+}
+CIMGUI_API void ImRect_AddY(ImRect* self,float y)
+{
+    return self->AddY(y);
+}
 CIMGUI_API void ImRect_Expand_Float(ImRect* self,const float amount)
 {
     return self->Expand(amount);
@@ -3706,6 +3734,30 @@ CIMGUI_API void ImGuiTextIndex_append(ImGuiTextIndex* self,const char* base,int
 {
     return self->append(base,old_size,new_size);
 }
+CIMGUI_API ImGuiPackedDate* ImGuiPackedDate_ImGuiPackedDate_Nil(void)
+{
+    return IM_NEW(ImGuiPackedDate)();
+}
+CIMGUI_API void ImGuiPackedDate_destroy(ImGuiPackedDate* self)
+{
+    IM_DELETE(self);
+}
+CIMGUI_API ImGuiPackedDate* ImGuiPackedDate_ImGuiPackedDate_Int(int yyyymmdd)
+{
+    return IM_NEW(ImGuiPackedDate)(yyyymmdd);
+}
+CIMGUI_API bool ImGuiPackedDate_IsValid(ImGuiPackedDate* self)
+{
+    return self->IsValid();
+}
+CIMGUI_API int ImGuiPackedDate_Unpack(ImGuiPackedDate* self)
+{
+    return self->Unpack();
+}
+CIMGUI_API void ImGuiPackedDate_SubtractMonths(ImGuiPackedDate* self,int m)
+{
+    return self->SubtractMonths(m);
+}
 CIMGUI_API ImGuiStoragePair* igImLowerBound(ImGuiStoragePair* in_begin,ImGuiStoragePair* in_end,ImGuiID key)
 {
     return ImLowerBound(in_begin,in_end,key);
@@ -3818,6 +3870,10 @@ CIMGUI_API float ImGuiInputTextState_GetPreferredOffsetX(ImGuiInputTextState* se
 {
     return self->GetPreferredOffsetX();
 }
+CIMGUI_API const char* ImGuiInputTextState_GetText(ImGuiInputTextState* self)
+{
+    return self->GetText();
+}
 CIMGUI_API void ImGuiInputTextState_CursorAnimReset(ImGuiInputTextState* self)
 {
     return self->CursorAnimReset();
@@ -4330,6 +4386,286 @@ CIMGUI_API ImGuiTableColumnSettings* ImGuiTableSettings_GetColumnSettings(ImGuiT
 {
     return self->GetColumnSettings();
 }
+CIMGUI_API void igTableOpenContextMenu(int column_n)
+{
+    return ImGui::TableOpenContextMenu(column_n);
+}
+CIMGUI_API void igTableSetColumnWidth(int column_n,float width)
+{
+    return ImGui::TableSetColumnWidth(column_n,width);
+}
+CIMGUI_API void igTableSetColumnSortDirection(int column_n,ImGuiSortDirection sort_direction,bool append_to_sort_specs)
+{
+    return ImGui::TableSetColumnSortDirection(column_n,sort_direction,append_to_sort_specs);
+}
+CIMGUI_API int igTableGetHoveredRow()
+{
+    return ImGui::TableGetHoveredRow();
+}
+CIMGUI_API float igTableGetHeaderRowHeight()
+{
+    return ImGui::TableGetHeaderRowHeight();
+}
+CIMGUI_API float igTableGetHeaderAngledMaxLabelWidth()
+{
+    return ImGui::TableGetHeaderAngledMaxLabelWidth();
+}
+CIMGUI_API void igTablePushBackgroundChannel()
+{
+    return ImGui::TablePushBackgroundChannel();
+}
+CIMGUI_API void igTablePopBackgroundChannel()
+{
+    return ImGui::TablePopBackgroundChannel();
+}
+CIMGUI_API void igTablePushColumnChannel(int column_n)
+{
+    return ImGui::TablePushColumnChannel(column_n);
+}
+CIMGUI_API void igTablePopColumnChannel()
+{
+    return ImGui::TablePopColumnChannel();
+}
+CIMGUI_API void igTableAngledHeadersRowEx(ImGuiID row_id,float angle,float max_label_width,const ImGuiTableHeaderData* data,int data_count)
+{
+    return ImGui::TableAngledHeadersRowEx(row_id,angle,max_label_width,data,data_count);
+}
+CIMGUI_API ImGuiTable* igGetCurrentTable()
+{
+    return ImGui::GetCurrentTable();
+}
+CIMGUI_API ImGuiTable* igTableFindByID(ImGuiID id)
+{
+    return ImGui::TableFindByID(id);
+}
+CIMGUI_API bool igBeginTableEx(const char* name,ImGuiID id,int columns_count,ImGuiTableFlags flags,const ImVec2_c outer_size,float inner_width)
+{
+    return ImGui::BeginTableEx(name,id,columns_count,flags,ConvertToCPP_ImVec2(outer_size),inner_width);
+}
+CIMGUI_API void igTableBeginInitMemory(ImGuiTable* table,int columns_count)
+{
+    return ImGui::TableBeginInitMemory(table,columns_count);
+}
+CIMGUI_API void igTableApplyQueuedRequests(ImGuiTable* table)
+{
+    return ImGui::TableApplyQueuedRequests(table);
+}
+CIMGUI_API void igTableSetupDrawChannels(ImGuiTable* table)
+{
+    return ImGui::TableSetupDrawChannels(table);
+}
+CIMGUI_API void igTableReconcileColumns(ImGuiTable* table)
+{
+    return ImGui::TableReconcileColumns(table);
+}
+CIMGUI_API void igTableUpdateLayout(ImGuiTable* table)
+{
+    return ImGui::TableUpdateLayout(table);
+}
+CIMGUI_API void igTableUpdateBorders(ImGuiTable* table)
+{
+    return ImGui::TableUpdateBorders(table);
+}
+CIMGUI_API void igTableUpdateColumnsWeightFromWidth(ImGuiTable* table)
+{
+    return ImGui::TableUpdateColumnsWeightFromWidth(table);
+}
+CIMGUI_API void igTableApplyExternalUnclipRect(ImGuiTable* table,ImRect* rect)
+{
+    return ImGui::TableApplyExternalUnclipRect(table,*rect);
+}
+CIMGUI_API void igTableDrawBorders(ImGuiTable* table)
+{
+    return ImGui::TableDrawBorders(table);
+}
+CIMGUI_API void igTableDrawDefaultContextMenu(ImGuiTable* table,ImGuiTableFlags flags_for_section_to_display)
+{
+    return ImGui::TableDrawDefaultContextMenu(table,flags_for_section_to_display);
+}
+CIMGUI_API bool igTableBeginContextMenuPopup(ImGuiTable* table)
+{
+    return ImGui::TableBeginContextMenuPopup(table);
+}
+CIMGUI_API void igTableMergeDrawChannels(ImGuiTable* table)
+{
+    return ImGui::TableMergeDrawChannels(table);
+}
+CIMGUI_API ImGuiTableInstanceData* igTableGetInstanceData(ImGuiTable* table,int instance_no)
+{
+    return ImGui::TableGetInstanceData(table,instance_no);
+}
+CIMGUI_API ImGuiID igTableGetInstanceID(ImGuiTable* table,int instance_no)
+{
+    return ImGui::TableGetInstanceID(table,instance_no);
+}
+CIMGUI_API void igTableFixDisplayOrder(ImGuiTable* table)
+{
+    return ImGui::TableFixDisplayOrder(table);
+}
+CIMGUI_API void igTableSortSpecsSanitize(ImGuiTable* table)
+{
+    return ImGui::TableSortSpecsSanitize(table);
+}
+CIMGUI_API void igTableSortSpecsBuild(ImGuiTable* table)
+{
+    return ImGui::TableSortSpecsBuild(table);
+}
+CIMGUI_API void igTableInitColumnDefaults(ImGuiTable* table,ImGuiTableColumn* column,ImGuiTableColumnFlags init_mask)
+{
+    return ImGui::TableInitColumnDefaults(table,column,init_mask);
+}
+CIMGUI_API ImGuiSortDirection igTableGetColumnNextSortDirection(ImGuiTableColumn* column)
+{
+    return ImGui::TableGetColumnNextSortDirection(column);
+}
+CIMGUI_API void igTableFixColumnSortDirection(ImGuiTable* table,ImGuiTableColumn* column)
+{
+    return ImGui::TableFixColumnSortDirection(table,column);
+}
+CIMGUI_API float igTableGetColumnWidthAuto(ImGuiTable* table,ImGuiTableColumn* column)
+{
+    return ImGui::TableGetColumnWidthAuto(table,column);
+}
+CIMGUI_API void igTableBeginRow(ImGuiTable* table)
+{
+    return ImGui::TableBeginRow(table);
+}
+CIMGUI_API void igTableEndRow(ImGuiTable* table)
+{
+    return ImGui::TableEndRow(table);
+}
+CIMGUI_API void igTableBeginCell(ImGuiTable* table,int column_n)
+{
+    return ImGui::TableBeginCell(table,column_n);
+}
+CIMGUI_API void igTableEndCell(ImGuiTable* table)
+{
+    return ImGui::TableEndCell(table);
+}
+CIMGUI_API ImRect_c igTableGetCellBgRect(const ImGuiTable* table,int column_n)
+{
+    return ConvertFromCPP_ImRect(ImGui::TableGetCellBgRect(table,column_n));
+}
+CIMGUI_API const char* igTableGetColumnName_TablePtr(const ImGuiTable* table,int column_n)
+{
+    return ImGui::TableGetColumnName(table,column_n);
+}
+CIMGUI_API ImGuiID igTableGetColumnResizeID(ImGuiTable* table,int column_n,int instance_no)
+{
+    return ImGui::TableGetColumnResizeID(table,column_n,instance_no);
+}
+CIMGUI_API float igTableCalcMaxColumnWidth(const ImGuiTable* table,int column_n)
+{
+    return ImGui::TableCalcMaxColumnWidth(table,column_n);
+}
+CIMGUI_API void igTableSetColumnWidthAutoSingle(ImGuiTable* table,int column_n)
+{
+    return ImGui::TableSetColumnWidthAutoSingle(table,column_n);
+}
+CIMGUI_API void igTableSetColumnWidthAutoAll(ImGuiTable* table)
+{
+    return ImGui::TableSetColumnWidthAutoAll(table);
+}
+CIMGUI_API void igTableSetColumnDisplayOrder(ImGuiTable* table,int column_n,int dst_order)
+{
+    return ImGui::TableSetColumnDisplayOrder(table,column_n,dst_order);
+}
+CIMGUI_API void igTableQueueSetColumnDisplayOrder(ImGuiTable* table,int column_n,int dst_order)
+{
+    return ImGui::TableQueueSetColumnDisplayOrder(table,column_n,dst_order);
+}
+CIMGUI_API void igTableRemove(ImGuiTable* table)
+{
+    return ImGui::TableRemove(table);
+}
+CIMGUI_API void igTableGcCompactTransientBuffers_TablePtr(ImGuiTable* table)
+{
+    return ImGui::TableGcCompactTransientBuffers(table);
+}
+CIMGUI_API void igTableGcCompactTransientBuffers_TableTempDataPtr(ImGuiTableTempData* table)
+{
+    return ImGui::TableGcCompactTransientBuffers(table);
+}
+CIMGUI_API void igTableGcCompactSettings()
+{
+    return ImGui::TableGcCompactSettings();
+}
+CIMGUI_API void igTableLoadSettings(ImGuiTable* table)
+{
+    return ImGui::TableLoadSettings(table);
+}
+CIMGUI_API void igTableLoadSettingsForColumns(ImGuiTable* table)
+{
+    return ImGui::TableLoadSettingsForColumns(table);
+}
+CIMGUI_API void igTableLoadSettingsForColumn(ImGuiTableColumn* column,ImGuiTableColumnSettings* column_settings,ImGuiTableFlags load_flags)
+{
+    return ImGui::TableLoadSettingsForColumn(column,column_settings,load_flags);
+}
+CIMGUI_API void igTableSaveSettings(ImGuiTable* table)
+{
+    return ImGui::TableSaveSettings(table);
+}
+CIMGUI_API void igTableResetSettings(ImGuiTable* table)
+{
+    return ImGui::TableResetSettings(table);
+}
+CIMGUI_API ImGuiTableSettings* igTableGetBoundSettings(ImGuiTable* table)
+{
+    return ImGui::TableGetBoundSettings(table);
+}
+CIMGUI_API void igTableSettingsAddSettingsHandler()
+{
+    return ImGui::TableSettingsAddSettingsHandler();
+}
+CIMGUI_API ImGuiTableSettings* igTableSettingsCreate(ImGuiID id,int columns_count)
+{
+    return ImGui::TableSettingsCreate(id,columns_count);
+}
+CIMGUI_API ImGuiTableSettings* igTableSettingsFindByID(ImGuiID id)
+{
+    return ImGui::TableSettingsFindByID(id);
+}
+CIMGUI_API void igSetWindowClipRectBeforeSetChannel(ImGuiWindow* window,const ImRect_c clip_rect)
+{
+    return ImGui::SetWindowClipRectBeforeSetChannel(window,ConvertToCPP_ImRect(clip_rect));
+}
+CIMGUI_API void igBeginColumns(const char* str_id,int count,ImGuiOldColumnFlags flags)
+{
+    return ImGui::BeginColumns(str_id,count,flags);
+}
+CIMGUI_API void igEndColumns()
+{
+    return ImGui::EndColumns();
+}
+CIMGUI_API void igPushColumnClipRect(int column_index)
+{
+    return ImGui::PushColumnClipRect(column_index);
+}
+CIMGUI_API void igPushColumnsBackground()
+{
+    return ImGui::PushColumnsBackground();
+}
+CIMGUI_API void igPopColumnsBackground()
+{
+    return ImGui::PopColumnsBackground();
+}
+CIMGUI_API ImGuiID igGetColumnsID(const char* str_id,int count)
+{
+    return ImGui::GetColumnsID(str_id,count);
+}
+CIMGUI_API ImGuiOldColumns* igFindOrCreateColumns(ImGuiWindow* window,ImGuiID id)
+{
+    return ImGui::FindOrCreateColumns(window,id);
+}
+CIMGUI_API float igGetColumnOffsetFromNorm(const ImGuiOldColumns* columns,float offset_norm)
+{
+    return ImGui::GetColumnOffsetFromNorm(columns,offset_norm);
+}
+CIMGUI_API float igGetColumnNormFromOffset(const ImGuiOldColumns* columns,float offset)
+{
+    return ImGui::GetColumnNormFromOffset(columns,offset);
+}
 CIMGUI_API ImGuiIO* igGetIO_ContextPtr(ImGuiContext* ctx)
 {
     return &ImGui::GetIO(ctx);
@@ -4618,6 +4954,10 @@ CIMGUI_API void igClearIniSettings()
 {
     return ImGui::ClearIniSettings();
 }
+CIMGUI_API void igCleanupIniSettings(ImGuiSettingsCleanupArgs* args)
+{
+    return ImGui::CleanupIniSettings(args);
+}
 CIMGUI_API void igAddSettingsHandler(const ImGuiSettingsHandler* handler)
 {
     return ImGui::AddSettingsHandler(handler);
@@ -4818,6 +5158,10 @@ CIMGUI_API bool igBeginChildEx(const char* name,ImGuiID id,const ImVec2_c size_a
 {
     return ImGui::BeginChildEx(name,id,ConvertToCPP_ImVec2(size_arg),child_flags,window_flags);
 }
+CIMGUI_API ImGuiWindow* igFindFrontMostVisibleChildWindow(ImGuiWindow* window)
+{
+    return ImGui::FindFrontMostVisibleChildWindow(window);
+}
 CIMGUI_API bool igBeginPopupEx(ImGuiID id,ImGuiWindowFlags extra_window_flags)
 {
     return ImGui::BeginPopupEx(id,extra_window_flags);
@@ -4826,7 +5170,7 @@ CIMGUI_API bool igBeginPopupMenuEx(ImGuiID id,const char* label,ImGuiWindowFlags
 {
     return ImGui::BeginPopupMenuEx(id,label,extra_window_flags);
 }
-CIMGUI_API void igOpenPopupEx(ImGuiID id,ImGuiPopupFlags popup_flags)
+CIMGUI_API bool igOpenPopupEx(ImGuiID id,ImGuiPopupFlags popup_flags)
 {
     return ImGui::OpenPopupEx(id,popup_flags);
 }
@@ -4874,6 +5218,14 @@ CIMGUI_API ImGuiMouseButton igGetMouseButtonFromPopupFlags(ImGuiPopupFlags flags
 {
     return ImGui::GetMouseButtonFromPopupFlags(flags);
 }
+CIMGUI_API bool igIsPopupOpenRequestForItem(ImGuiPopupFlags flags,ImGuiID id)
+{
+    return ImGui::IsPopupOpenRequestForItem(flags,id);
+}
+CIMGUI_API bool igIsPopupOpenRequestForWindow(ImGuiPopupFlags flags)
+{
+    return ImGui::IsPopupOpenRequestForWindow(flags);
+}
 CIMGUI_API bool igBeginTooltipEx(ImGuiTooltipFlags tooltip_flags,ImGuiWindowFlags extra_window_flags)
 {
     return ImGui::BeginTooltipEx(tooltip_flags,extra_window_flags);
@@ -5082,7 +5434,7 @@ CIMGUI_API void igSetKeyOwnersForKeyChord(ImGuiKeyChord key,ImGuiID owner_id,ImG
 {
     return ImGui::SetKeyOwnersForKeyChord(key,owner_id,flags);
 }
-CIMGUI_API void igSetItemKeyOwner_InputFlags(ImGuiKey key,ImGuiInputFlags flags)
+CIMGUI_API bool igSetItemKeyOwner_InputFlags(ImGuiKey key,ImGuiInputFlags flags)
 {
     return ImGui::SetItemKeyOwner(key,flags);
 }
@@ -5318,6 +5670,10 @@ CIMGUI_API void igPopFocusScope()
 {
     return ImGui::PopFocusScope();
 }
+CIMGUI_API bool igIsInNavFocusRoute(ImGuiID focus_scope_id)
+{
+    return ImGui::IsInNavFocusRoute(focus_scope_id);
+}
 CIMGUI_API ImGuiID igGetCurrentFocusScope()
 {
     return ImGui::GetCurrentFocusScope();
@@ -5346,9 +5702,9 @@ CIMGUI_API void igRenderDragDropTargetRectForItem(const ImRect_c bb)
 {
     return ImGui::RenderDragDropTargetRectForItem(ConvertToCPP_ImRect(bb));
 }
-CIMGUI_API void igRenderDragDropTargetRectEx(ImDrawList* draw_list,const ImRect_c bb)
+CIMGUI_API void igRenderDragDropTargetRectEx(ImDrawList* draw_list,const ImRect_c bb,float rounding)
 {
-    return ImGui::RenderDragDropTargetRectEx(draw_list,ConvertToCPP_ImRect(bb));
+    return ImGui::RenderDragDropTargetRectEx(draw_list,ConvertToCPP_ImRect(bb),rounding);
 }
 CIMGUI_API ImGuiTypingSelectRequest* igGetTypingSelectRequest(ImGuiTypingSelectFlags flags)
 {
@@ -5378,9 +5734,9 @@ CIMGUI_API void igMultiSelectItemHeader(ImGuiID id,bool* p_selected,ImGuiButtonF
 {
     return ImGui::MultiSelectItemHeader(id,p_selected,p_button_flags);
 }
-CIMGUI_API void igMultiSelectItemFooter(ImGuiID id,bool* p_selected,bool* p_pressed)
+CIMGUI_API void igMultiSelectItemFooter(ImGuiID id,bool* p_selected,bool* p_pressed,ImGuiMultiSelectFlags extra_flags)
 {
-    return ImGui::MultiSelectItemFooter(id,p_selected,p_pressed);
+    return ImGui::MultiSelectItemFooter(id,p_selected,p_pressed,extra_flags);
 }
 CIMGUI_API void igMultiSelectAddSetAll(ImGuiMultiSelectTempData* ms,bool selected)
 {
@@ -5398,262 +5754,6 @@ CIMGUI_API ImGuiMultiSelectState* igGetMultiSelectState(ImGuiID id)
 {
     return ImGui::GetMultiSelectState(id);
 }
-CIMGUI_API void igSetWindowClipRectBeforeSetChannel(ImGuiWindow* window,const ImRect_c clip_rect)
-{
-    return ImGui::SetWindowClipRectBeforeSetChannel(window,ConvertToCPP_ImRect(clip_rect));
-}
-CIMGUI_API void igBeginColumns(const char* str_id,int count,ImGuiOldColumnFlags flags)
-{
-    return ImGui::BeginColumns(str_id,count,flags);
-}
-CIMGUI_API void igEndColumns()
-{
-    return ImGui::EndColumns();
-}
-CIMGUI_API void igPushColumnClipRect(int column_index)
-{
-    return ImGui::PushColumnClipRect(column_index);
-}
-CIMGUI_API void igPushColumnsBackground()
-{
-    return ImGui::PushColumnsBackground();
-}
-CIMGUI_API void igPopColumnsBackground()
-{
-    return ImGui::PopColumnsBackground();
-}
-CIMGUI_API ImGuiID igGetColumnsID(const char* str_id,int count)
-{
-    return ImGui::GetColumnsID(str_id,count);
-}
-CIMGUI_API ImGuiOldColumns* igFindOrCreateColumns(ImGuiWindow* window,ImGuiID id)
-{
-    return ImGui::FindOrCreateColumns(window,id);
-}
-CIMGUI_API float igGetColumnOffsetFromNorm(const ImGuiOldColumns* columns,float offset_norm)
-{
-    return ImGui::GetColumnOffsetFromNorm(columns,offset_norm);
-}
-CIMGUI_API float igGetColumnNormFromOffset(const ImGuiOldColumns* columns,float offset)
-{
-    return ImGui::GetColumnNormFromOffset(columns,offset);
-}
-CIMGUI_API void igTableOpenContextMenu(int column_n)
-{
-    return ImGui::TableOpenContextMenu(column_n);
-}
-CIMGUI_API void igTableSetColumnWidth(int column_n,float width)
-{
-    return ImGui::TableSetColumnWidth(column_n,width);
-}
-CIMGUI_API void igTableSetColumnSortDirection(int column_n,ImGuiSortDirection sort_direction,bool append_to_sort_specs)
-{
-    return ImGui::TableSetColumnSortDirection(column_n,sort_direction,append_to_sort_specs);
-}
-CIMGUI_API int igTableGetHoveredRow()
-{
-    return ImGui::TableGetHoveredRow();
-}
-CIMGUI_API float igTableGetHeaderRowHeight()
-{
-    return ImGui::TableGetHeaderRowHeight();
-}
-CIMGUI_API float igTableGetHeaderAngledMaxLabelWidth()
-{
-    return ImGui::TableGetHeaderAngledMaxLabelWidth();
-}
-CIMGUI_API void igTablePushBackgroundChannel()
-{
-    return ImGui::TablePushBackgroundChannel();
-}
-CIMGUI_API void igTablePopBackgroundChannel()
-{
-    return ImGui::TablePopBackgroundChannel();
-}
-CIMGUI_API void igTablePushColumnChannel(int column_n)
-{
-    return ImGui::TablePushColumnChannel(column_n);
-}
-CIMGUI_API void igTablePopColumnChannel()
-{
-    return ImGui::TablePopColumnChannel();
-}
-CIMGUI_API void igTableAngledHeadersRowEx(ImGuiID row_id,float angle,float max_label_width,const ImGuiTableHeaderData* data,int data_count)
-{
-    return ImGui::TableAngledHeadersRowEx(row_id,angle,max_label_width,data,data_count);
-}
-CIMGUI_API ImGuiTable* igGetCurrentTable()
-{
-    return ImGui::GetCurrentTable();
-}
-CIMGUI_API ImGuiTable* igTableFindByID(ImGuiID id)
-{
-    return ImGui::TableFindByID(id);
-}
-CIMGUI_API bool igBeginTableEx(const char* name,ImGuiID id,int columns_count,ImGuiTableFlags flags,const ImVec2_c outer_size,float inner_width)
-{
-    return ImGui::BeginTableEx(name,id,columns_count,flags,ConvertToCPP_ImVec2(outer_size),inner_width);
-}
-CIMGUI_API void igTableBeginInitMemory(ImGuiTable* table,int columns_count)
-{
-    return ImGui::TableBeginInitMemory(table,columns_count);
-}
-CIMGUI_API void igTableBeginApplyRequests(ImGuiTable* table)
-{
-    return ImGui::TableBeginApplyRequests(table);
-}
-CIMGUI_API void igTableSetupDrawChannels(ImGuiTable* table)
-{
-    return ImGui::TableSetupDrawChannels(table);
-}
-CIMGUI_API void igTableUpdateLayout(ImGuiTable* table)
-{
-    return ImGui::TableUpdateLayout(table);
-}
-CIMGUI_API void igTableUpdateBorders(ImGuiTable* table)
-{
-    return ImGui::TableUpdateBorders(table);
-}
-CIMGUI_API void igTableUpdateColumnsWeightFromWidth(ImGuiTable* table)
-{
-    return ImGui::TableUpdateColumnsWeightFromWidth(table);
-}
-CIMGUI_API void igTableDrawBorders(ImGuiTable* table)
-{
-    return ImGui::TableDrawBorders(table);
-}
-CIMGUI_API void igTableDrawDefaultContextMenu(ImGuiTable* table,ImGuiTableFlags flags_for_section_to_display)
-{
-    return ImGui::TableDrawDefaultContextMenu(table,flags_for_section_to_display);
-}
-CIMGUI_API bool igTableBeginContextMenuPopup(ImGuiTable* table)
-{
-    return ImGui::TableBeginContextMenuPopup(table);
-}
-CIMGUI_API void igTableMergeDrawChannels(ImGuiTable* table)
-{
-    return ImGui::TableMergeDrawChannels(table);
-}
-CIMGUI_API ImGuiTableInstanceData* igTableGetInstanceData(ImGuiTable* table,int instance_no)
-{
-    return ImGui::TableGetInstanceData(table,instance_no);
-}
-CIMGUI_API ImGuiID igTableGetInstanceID(ImGuiTable* table,int instance_no)
-{
-    return ImGui::TableGetInstanceID(table,instance_no);
-}
-CIMGUI_API void igTableFixDisplayOrder(ImGuiTable* table)
-{
-    return ImGui::TableFixDisplayOrder(table);
-}
-CIMGUI_API void igTableSortSpecsSanitize(ImGuiTable* table)
-{
-    return ImGui::TableSortSpecsSanitize(table);
-}
-CIMGUI_API void igTableSortSpecsBuild(ImGuiTable* table)
-{
-    return ImGui::TableSortSpecsBuild(table);
-}
-CIMGUI_API ImGuiSortDirection igTableGetColumnNextSortDirection(ImGuiTableColumn* column)
-{
-    return ImGui::TableGetColumnNextSortDirection(column);
-}
-CIMGUI_API void igTableFixColumnSortDirection(ImGuiTable* table,ImGuiTableColumn* column)
-{
-    return ImGui::TableFixColumnSortDirection(table,column);
-}
-CIMGUI_API float igTableGetColumnWidthAuto(ImGuiTable* table,ImGuiTableColumn* column)
-{
-    return ImGui::TableGetColumnWidthAuto(table,column);
-}
-CIMGUI_API void igTableBeginRow(ImGuiTable* table)
-{
-    return ImGui::TableBeginRow(table);
-}
-CIMGUI_API void igTableEndRow(ImGuiTable* table)
-{
-    return ImGui::TableEndRow(table);
-}
-CIMGUI_API void igTableBeginCell(ImGuiTable* table,int column_n)
-{
-    return ImGui::TableBeginCell(table,column_n);
-}
-CIMGUI_API void igTableEndCell(ImGuiTable* table)
-{
-    return ImGui::TableEndCell(table);
-}
-CIMGUI_API ImRect_c igTableGetCellBgRect(const ImGuiTable* table,int column_n)
-{
-    return ConvertFromCPP_ImRect(ImGui::TableGetCellBgRect(table,column_n));
-}
-CIMGUI_API const char* igTableGetColumnName_TablePtr(const ImGuiTable* table,int column_n)
-{
-    return ImGui::TableGetColumnName(table,column_n);
-}
-CIMGUI_API ImGuiID igTableGetColumnResizeID(ImGuiTable* table,int column_n,int instance_no)
-{
-    return ImGui::TableGetColumnResizeID(table,column_n,instance_no);
-}
-CIMGUI_API float igTableCalcMaxColumnWidth(const ImGuiTable* table,int column_n)
-{
-    return ImGui::TableCalcMaxColumnWidth(table,column_n);
-}
-CIMGUI_API void igTableSetColumnWidthAutoSingle(ImGuiTable* table,int column_n)
-{
-    return ImGui::TableSetColumnWidthAutoSingle(table,column_n);
-}
-CIMGUI_API void igTableSetColumnWidthAutoAll(ImGuiTable* table)
-{
-    return ImGui::TableSetColumnWidthAutoAll(table);
-}
-CIMGUI_API void igTableSetColumnDisplayOrder(ImGuiTable* table,int column_n,int dst_order)
-{
-    return ImGui::TableSetColumnDisplayOrder(table,column_n,dst_order);
-}
-CIMGUI_API void igTableRemove(ImGuiTable* table)
-{
-    return ImGui::TableRemove(table);
-}
-CIMGUI_API void igTableGcCompactTransientBuffers_TablePtr(ImGuiTable* table)
-{
-    return ImGui::TableGcCompactTransientBuffers(table);
-}
-CIMGUI_API void igTableGcCompactTransientBuffers_TableTempDataPtr(ImGuiTableTempData* table)
-{
-    return ImGui::TableGcCompactTransientBuffers(table);
-}
-CIMGUI_API void igTableGcCompactSettings()
-{
-    return ImGui::TableGcCompactSettings();
-}
-CIMGUI_API void igTableLoadSettings(ImGuiTable* table)
-{
-    return ImGui::TableLoadSettings(table);
-}
-CIMGUI_API void igTableSaveSettings(ImGuiTable* table)
-{
-    return ImGui::TableSaveSettings(table);
-}
-CIMGUI_API void igTableResetSettings(ImGuiTable* table)
-{
-    return ImGui::TableResetSettings(table);
-}
-CIMGUI_API ImGuiTableSettings* igTableGetBoundSettings(ImGuiTable* table)
-{
-    return ImGui::TableGetBoundSettings(table);
-}
-CIMGUI_API void igTableSettingsAddSettingsHandler()
-{
-    return ImGui::TableSettingsAddSettingsHandler();
-}
-CIMGUI_API ImGuiTableSettings* igTableSettingsCreate(ImGuiID id,int columns_count)
-{
-    return ImGui::TableSettingsCreate(id,columns_count);
-}
-CIMGUI_API ImGuiTableSettings* igTableSettingsFindByID(ImGuiID id)
-{
-    return ImGui::TableSettingsFindByID(id);
-}
 CIMGUI_API ImGuiTabBar* igGetCurrentTabBar()
 {
     return ImGui::GetCurrentTabBar();
@@ -5786,9 +5886,9 @@ CIMGUI_API void igRenderColorRectWithAlphaCheckerboard(ImDrawList* draw_list,ImV
 {
     return ImGui::RenderColorRectWithAlphaCheckerboard(draw_list,ConvertToCPP_ImVec2(p_min),ConvertToCPP_ImVec2(p_max),fill_col,grid_step,ConvertToCPP_ImVec2(grid_off),rounding,flags);
 }
-CIMGUI_API void igRenderNavCursor(const ImRect_c bb,ImGuiID id,ImGuiNavRenderCursorFlags flags)
+CIMGUI_API void igRenderNavCursor(const ImRect_c bb,ImGuiID id,ImGuiNavRenderCursorFlags flags,float rounding)
 {
-    return ImGui::RenderNavCursor(ConvertToCPP_ImRect(bb),id,flags);
+    return ImGui::RenderNavCursor(ConvertToCPP_ImRect(bb),id,flags,rounding);
 }
 CIMGUI_API const char* igFindRenderedTextEnd(const char* text,const char* text_end)
 {
@@ -5911,6 +6011,10 @@ CIMGUI_API ImGuiID igGetWindowResizeBorderID(ImGuiWindow* window,ImGuiDir dir)
 {
     return ImGui::GetWindowResizeBorderID(window,dir);
 }
+CIMGUI_API void igExtendHitBoxWhenNearViewportEdge(ImGuiWindow* window,ImRect* bb,float threshold,ImGuiAxis axis)
+{
+    return ImGui::ExtendHitBoxWhenNearViewportEdge(window,bb,threshold,axis);
+}
 CIMGUI_API bool igButtonBehavior(const ImRect_c bb,ImGuiID id,bool* out_hovered,bool* out_held,ImGuiButtonFlags flags)
 {
     return ImGui::ButtonBehavior(ConvertToCPP_ImRect(bb),id,out_hovered,out_held,flags);
@@ -5943,10 +6047,6 @@ CIMGUI_API void igTreePushOverrideID(ImGuiID id)
 {
     return ImGui::TreePushOverrideID(id);
 }
-CIMGUI_API bool igTreeNodeGetOpen(ImGuiID storage_id)
-{
-    return ImGui::TreeNodeGetOpen(storage_id);
-}
 CIMGUI_API void igTreeNodeSetOpen(ImGuiID storage_id,bool open)
 {
     return ImGui::TreeNodeSetOpen(storage_id,open);
@@ -5991,9 +6091,9 @@ CIMGUI_API void igInputTextDeactivateHook(ImGuiID id)
 {
     return ImGui::InputTextDeactivateHook(id);
 }
-CIMGUI_API bool igTempInputText(const ImRect_c bb,ImGuiID id,const char* label,char* buf,int buf_size,ImGuiInputTextFlags flags)
+CIMGUI_API bool igTempInputText(const ImRect_c bb,ImGuiID id,const char* label,char* buf,size_t buf_size,ImGuiInputTextFlags flags,ImGuiInputTextCallback callback,void* user_data)
 {
-    return ImGui::TempInputText(ConvertToCPP_ImRect(bb),id,label,buf,buf_size,flags);
+    return ImGui::TempInputText(ConvertToCPP_ImRect(bb),id,label,buf,buf_size,flags,callback,user_data);
 }
 CIMGUI_API bool igTempInputScalar(const ImRect_c bb,ImGuiID id,const char* label,ImGuiDataType data_type,void* p_data,const char* format,const void* p_clamp_min,const void* p_clamp_max)
 {
@@ -6091,6 +6191,10 @@ CIMGUI_API void igEndErrorTooltip()
 {
     return ImGui::EndErrorTooltip();
 }
+CIMGUI_API void igDemoMarker(const char* file,int line,const char* section)
+{
+    return ImGui::DemoMarker(file,line,section);
+}
 CIMGUI_API void igDebugAllocHook(ImGuiDebugAllocInfo* info,int frame_count,void* ptr,size_t size)
 {
     return ImGui::DebugAllocHook(info,frame_count,ptr,size);
@@ -6167,9 +6271,9 @@ CIMGUI_API void igDebugNodeFont(ImFont* font)
 {
     return ImGui::DebugNodeFont(font);
 }
-CIMGUI_API void igDebugNodeFontGlyphesForSrcMask(ImFont* font,ImFontBaked* baked,int src_mask)
+CIMGUI_API void igDebugNodeFontGlyphsForSrcMask(ImFont* font,ImFontBaked* baked,int src_mask)
 {
-    return ImGui::DebugNodeFontGlyphesForSrcMask(font,baked,src_mask);
+    return ImGui::DebugNodeFontGlyphsForSrcMask(font,baked,src_mask);
 }
 CIMGUI_API void igDebugNodeFontGlyph(ImFont* font,const ImFontGlyph* glyph)
 {
@@ -6191,9 +6295,9 @@ CIMGUI_API void igDebugNodeTable(ImGuiTable* table)
 {
     return ImGui::DebugNodeTable(table);
 }
-CIMGUI_API void igDebugNodeTableSettings(ImGuiTableSettings* settings)
+CIMGUI_API void igDebugNodeTableSettings(ImGuiTableSettings* settings,ImGuiTable* table)
 {
-    return ImGui::DebugNodeTableSettings(settings);
+    return ImGui::DebugNodeTableSettings(settings,table);
 }
 CIMGUI_API void igDebugNodeInputTextState(ImGuiInputTextState* state)
 {
@@ -6471,6 +6575,14 @@ CIMGUI_API void igImFontAtlasTextureBlockQueueUpload(ImFontAtlas* atlas,ImTextur
 {
     return ImFontAtlasTextureBlockQueueUpload(atlas,tex,x,y,w,h);
 }
+CIMGUI_API bool igImTextureDataUpdateNewFrame(ImTextureData* tex)
+{
+    return ImTextureDataUpdateNewFrame(tex);
+}
+CIMGUI_API void igImTextureDataQueueUpload(ImTextureData* tex,int x,int y,int w,int h)
+{
+    return ImTextureDataQueueUpload(tex,x,y,w,h);
+}
 CIMGUI_API int igImTextureDataGetFormatBytesPerPixel(ImTextureFormat format)
 {
     return ImTextureDataGetFormatBytesPerPixel(format);

cimgui_impl.h

@@ -30,8 +30,20 @@ CIMGUI_API void ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window,int focuse
 
 #endif
 #ifdef CIMGUI_USE_OPENGL3
+#ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+
+typedef struct ImGui_ImplOpenGL3_RenderState ImGui_ImplOpenGL3_RenderState;
+struct ImGui_ImplOpenGL3_RenderState
+{
+    bool UseBindSampler;
+    bool UseTexParameterFilter;
+    unsigned int CurrentSampler;
+    unsigned int CurrentTexParameterFilter;
+};
+#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
 CIMGUI_API bool ImGui_ImplOpenGL3_CreateDeviceObjects(void);
 CIMGUI_API void ImGui_ImplOpenGL3_DestroyDeviceObjects(void);
+CIMGUI_API ImGui_ImplOpenGL3_RenderState* ImGui_ImplOpenGL3_GetRenderState(void);
 CIMGUI_API bool ImGui_ImplOpenGL3_Init(const char* glsl_version);
 CIMGUI_API void ImGui_ImplOpenGL3_NewFrame(void);
 CIMGUI_API void ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data);
@@ -110,11 +122,14 @@ CIMGUI_API void ImGui_ImplSDL3_Shutdown(void);
 typedef struct ImGui_ImplVulkanH_Frame ImGui_ImplVulkanH_Frame;
 typedef struct ImGui_ImplVulkanH_Window ImGui_ImplVulkanH_Window;
 typedef struct ImGui_ImplVulkan_PipelineInfo ImGui_ImplVulkan_PipelineInfo;
+typedef struct ImVector_VkDynamicState {int Size;int Capacity;VkDynamicState* Data;} ImVector_VkDynamicState;
+
 struct ImGui_ImplVulkan_PipelineInfo
 {
     VkRenderPass RenderPass;
     uint32_t Subpass;
     VkSampleCountFlagBits MSAASamples;
+    ImVector_VkDynamicState ExtraDynamicStates;
     VkPipelineRenderingCreateInfoKHR PipelineRenderingCreateInfo;
     VkImageUsageFlags SwapChainImageUsage;
 };
@@ -192,7 +207,10 @@ struct ImGui_ImplVulkanH_Window
 #ifndef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
 typedef ImVector<ImGui_ImplVulkanH_Frame> ImVector_ImGui_ImplVulkanH_Frame;
 typedef ImVector<ImGui_ImplVulkanH_FrameSemaphores> ImVector_ImGui_ImplVulkanH_FrameSemaphores;
+typedef ImVector<VkDynamicState> ImVector_VkDynamicState;
 #endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+#define IMGUI_IMPL_VULKAN_MINIMUM_SAMPLED_IMAGE_POOL_SIZE (8)
+#define IMGUI_IMPL_VULKAN_MINIMUM_SAMPLER_POOL_SIZE (2)
 CIMGUI_API void ImGui_ImplVulkanH_CreateOrResizeWindow(VkInstance instance,VkPhysicalDevice physical_device,VkDevice device,ImGui_ImplVulkanH_Window* wd,uint32_t queue_family,const VkAllocationCallbacks* allocator,int w,int h,uint32_t min_image_count,VkImageUsageFlags image_usage);
 CIMGUI_API void ImGui_ImplVulkanH_DestroyWindow(VkInstance instance,VkDevice device,ImGui_ImplVulkanH_Window* wd,const VkAllocationCallbacks* allocator);
 CIMGUI_API int ImGui_ImplVulkanH_GetMinImageCountFromPresentMode(VkPresentModeKHR present_mode);
@@ -202,7 +220,7 @@ CIMGUI_API VkPresentModeKHR ImGui_ImplVulkanH_SelectPresentMode(VkPhysicalDevice
 CIMGUI_API uint32_t ImGui_ImplVulkanH_SelectQueueFamilyIndex(VkPhysicalDevice physical_device);
 CIMGUI_API VkSurfaceFormatKHR ImGui_ImplVulkanH_SelectSurfaceFormat(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkFormat* request_formats,int request_formats_count,VkColorSpaceKHR request_color_space);
 CIMGUI_API ImGui_ImplVulkanH_Window* ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window(void);
-CIMGUI_API VkDescriptorSet ImGui_ImplVulkan_AddTexture(VkSampler sampler,VkImageView image_view,VkImageLayout image_layout);
+CIMGUI_API VkDescriptorSet ImGui_ImplVulkan_AddTexture(VkImageView image_view,VkImageLayout image_layout);
 CIMGUI_API void ImGui_ImplVulkan_CreateMainPipeline(const ImGui_ImplVulkan_PipelineInfo* info);
 CIMGUI_API bool ImGui_ImplVulkan_Init(ImGui_ImplVulkan_InitInfo* info);
 CIMGUI_API bool ImGui_ImplVulkan_LoadFunctions(uint32_t api_version,PFN_vkVoidFunction(*loader_func)(const char* function_name,void* user_data),void* user_data);

generator/generator.lua

@@ -39,10 +39,10 @@ if FREETYPE_GENERATION then
 end
 
 if COMPILER == "gcc" or COMPILER == "clang" or COMPILER == "zig cc" then
-    CPRE = COMPILER..[[ -E -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS -DIMGUI_API="" -DIMGUI_IMPL_API=""  ]] .. CFLAGS
+    CPRE = COMPILER..[[ -E -dD -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS -DIMGUI_API="" -DIMGUI_IMPL_API=""  ]] .. CFLAGS
     CTEST = COMPILER.." --version"
 elseif COMPILER == "cl" then
-    CPRE = COMPILER..[[ /E /DIMGUI_DISABLE_OBSOLETE_FUNCTIONS /DIMGUI_DEBUG_PARANOID /DIMGUI_API="" /DIMGUI_IMPL_API="" ]] .. CFLAGS
+    CPRE = COMPILER..[[ /E /d1PP /DIMGUI_DISABLE_OBSOLETE_FUNCTIONS /DIMGUI_DEBUG_PARANOID /DIMGUI_API="" /DIMGUI_IMPL_API="" ]] .. CFLAGS
     CTEST = COMPILER
 else
     print("Working without compiler ")
@@ -120,10 +120,13 @@ local save_data = cpp2ffi.save_data
 local copyfile = cpp2ffi.copyfile
 local serializeTableF = cpp2ffi.serializeTableF
 
-local function func_header_impl_generate(FP)
+local function func_header_impl_generate(FP, defines)
 
     local outtab = {}
-    
+	--may be key sorting is not enough and declaration order needed 
+    cpp2ffi.table_do_sorted(defines, function(k,v)
+		table.insert(outtab,"#define "..k.." "..v.."\n")
+	end)
     -- for _,t in ipairs(FP.funcdefs) do
         -- if t.cimguiname then
             -- local cimf = FP.defsT[t.cimguiname]
@@ -286,6 +289,7 @@ local function cimgui_generation(parser)
 	
 
 	local  tdt = parser:generate_templates()
+	cpp2ffi.prtable("generate_templates",tdt)
 	local cstructsstr = outpre..tdt..outpost 
     
 	if gdefines.IMGUI_HAS_DOCK then
@@ -379,16 +383,15 @@ end
 local function parseImGuiHeader(header,names)
 	--prepare parser
 	local parser = cpp2ffi.Parser()
-	
+	parser.modulename = "cimgui"
 	parser.getCname = function(stname,funcname,namespace)
 		local pre = (stname == "") and (namespace and (namespace=="ImGui" and "ig" or namespace.."_") or "ig") or stname.."_"
 		return pre..funcname
 	end
 	parser.cname_overloads = cimgui_overloads
-	--parser.manuals = cimgui_manuals
 	parser:set_manuals(cimgui_manuals, "cimgui")
 	parser.skipped = cimgui_skipped
-	parser.UDTs = {"ImVec2","ImVec4","ImColor","ImRect"}
+	--parser.UDTs = {"ImVec2","ImVec4","ImColor","ImRect"}
 	--parser.gen_template_typedef = gen_template_typedef --use auto
 	parser.COMMENTS_GENERATION = COMMENTS_GENERATION
 	parser.CONSTRUCTORS_GENERATION = CONSTRUCTORS_GENERATION
@@ -398,7 +401,7 @@ local function parseImGuiHeader(header,names)
 	parser.custom_function_post = custom_function_post
 	parser.header_text_insert = header_text_insert
 	local defines = parser:take_lines(CPRE..header,names,COMPILER)
-	
+	--cpp2ffi.prtable("defines",defines)
 	return parser
 end
 --generation
@@ -438,14 +441,8 @@ structs_and_enums_table.templated_structs = parser1.templated_structs
 structs_and_enums_table.typenames = parser1.typenames
 structs_and_enums_table.templates_done = parser1.templates_done
 --structs_and_enums_table.nonPOD_used = parser1.nP_used
-
-save_data("./output/structs_and_enums.lua",serializeTableF(structs_and_enums_table))
-save_data("./output/typedefs_dict.lua",serializeTableF(parser1.typedefs_dict))
-
-----------save fundefs in definitions.lua for using in bindings
---DefsByStruct(pFP)
 set_defines(parser1.defsT) 
-save_data("./output/definitions.lua",serializeTableF(parser1.defsT))
+parser1:save_output()
 
 --check every function has ov_cimguiname
 -- for k,v in pairs(parser1.defsT) do
@@ -463,7 +460,11 @@ if ff then
 else
 	backends_folder = IMGUI_PATH .. "/backends/"
 end
- 
+local function getCname(stname,funcname, namespace)
+		if #stname == 0 then return funcname end --top level
+		local pre = stname.."_"
+		return pre..funcname
+	end
 local parser2
 
 if #implementations > 0 then
@@ -495,13 +496,15 @@ if #implementations > 0 then
 			end
 		end
 		parser2.cimgui_inherited =  dofile([[./output/structs_and_enums.lua]])
+		parser2.getCname = getCname
 		local defines = parser2:take_lines(CPRE..extra_defines..extra_includes..source, {locati}, COMPILER)
-		
+
 		local parser3 = cpp2ffi.Parser()
+		parser3.getCname = getCname
 		parser3.cimgui_inherited =  dofile([[./output/structs_and_enums.lua]])
-		parser3:take_lines(CPRE..extra_defines..extra_includes..source, {locati}, COMPILER)
+		local defines = parser3:take_lines(CPRE..extra_defines..extra_includes..source, {locati}, COMPILER)
 		parser3:do_parse()
-		local cfuncsstr = func_header_impl_generate(parser3) 
+		local cfuncsstr = func_header_impl_generate(parser3, defines) 
 		local cstructstr1,cstructstr2 = parser3.structs_and_enums[1], parser3.structs_and_enums[2]
 		local cstru = cstructstr1 .. cstructstr2
 		if cstru ~="" then
@@ -549,20 +552,9 @@ local function json_prepare(defs)
 end
 ---[[
 local json = require"json"
-save_data("./output/definitions.json",json.encode(json_prepare(parser1.defsT),{dict_on_empty={defaults=true}}))
---delete extra info for json
---structs_and_enums_table.templated_structs = nil
---structs_and_enums_table.typenames = nil
---structs_and_enums_table.templates_done = nil
-save_data("./output/structs_and_enums.json",json.encode(structs_and_enums_table))
-save_data("./output/typedefs_dict.json",json.encode(parser1.typedefs_dict))
 if parser2 then
     save_data("./output/impl_definitions.json",json.encode(json_prepare(parser2.defsT),{dict_on_empty={defaults=true}}))
 end
 --]]
--------------------copy C files to repo root
+
-copyfile("./output/cimgui.h", "../cimgui.h")
-copyfile("./output/cimgui.cpp", "../cimgui.cpp")
-os.remove("./output/cimgui.h")
-os.remove("./output/cimgui.cpp")
 print"all done!!"

generator/output/constants.json

@@ -0,0 +1,124 @@
+{
+  "DOCKING_HOST_DRAW_CHANNEL_BG": "0",
+  "DOCKING_HOST_DRAW_CHANNEL_FG": "1",
+  "IMGUI_CHECKVERSION()": "ImGui::DebugCheckVersionAndDataLayout(IMGUI_VERSION, sizeof(ImGuiIO), sizeof(ImGuiStyle), sizeof(ImVec2), sizeof(ImVec4), sizeof(ImDrawVert), sizeof(ImDrawIdx))",
+  "IMGUI_DEBUG_LOG(...)": "ImGui::DebugLog(__VA_ARGS__)",
+  "IMGUI_DEBUG_LOG_ACTIVEID(...)": "do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventActiveId) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  "IMGUI_DEBUG_LOG_CLIPPER(...)": "do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventClipper) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  "IMGUI_DEBUG_LOG_DOCKING(...)": "do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventDocking) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  "IMGUI_DEBUG_LOG_ERROR(...)": "do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventError) IMGUI_DEBUG_LOG(__VA_ARGS__); else g.DebugLogSkippedErrors++; } while (0)",
+  "IMGUI_DEBUG_LOG_FOCUS(...)": "do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventFocus) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  "IMGUI_DEBUG_LOG_FONT(...)": "do { ImGuiContext* g2 = GImGui; if (g2 && g2->DebugLogFlags & ImGuiDebugLogFlags_EventFont) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  "IMGUI_DEBUG_LOG_INPUTROUTING(...)": "do{if (g.DebugLogFlags & ImGuiDebugLogFlags_EventInputRouting)IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  "IMGUI_DEBUG_LOG_IO(...)": "do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventIO) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  "IMGUI_DEBUG_LOG_NAV(...)": "do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventNav) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  "IMGUI_DEBUG_LOG_POPUP(...)": "do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventPopup) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  "IMGUI_DEBUG_LOG_SELECTION(...)": "do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventSelection) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  "IMGUI_DEBUG_LOG_TABLE(...)": "do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventTable) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  "IMGUI_DEBUG_LOG_VIEWPORT(...)": "do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventViewport) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  "IMGUI_DEBUG_PRINTF(_FMT,...)": "printf(_FMT, __VA_ARGS__)",
+  "IMGUI_FONT_SIZE_MAX": "(512.0f)",
+  "IMGUI_FONT_SIZE_THRESHOLD_FOR_LOADADVANCEXONLYMODE": "(128.0f)",
+  "IMGUI_PAYLOAD_TYPE_COLOR_3F": "\"_COL3F\"",
+  "IMGUI_PAYLOAD_TYPE_COLOR_4F": "\"_COL4F\"",
+  "IMGUI_PAYLOAD_TYPE_WINDOW": "\"_IMWINDOW\"",
+  "IMGUI_TABLE_MAX_COLUMNS": "512",
+  "IMGUI_TEST_ENGINE_ITEM_ADD(_ID,_BB,_ITEM_DATA)": "((void)0)",
+  "IMGUI_TEST_ENGINE_ITEM_INFO(_ID,_LABEL,_FLAGS)": "((void)g)",
+  "IMGUI_VERSION": "\"1.92.9\"",
+  "IMGUI_VERSION_NUM": "19290",
+  "IMGUI_WINDOW_HARD_MIN_SIZE": "4.0f",
+  "IMSTB_TEXTEDIT_CHARTYPE": "char",
+  "IMSTB_TEXTEDIT_GETWIDTH_NEWLINE": "(-1.0f)",
+  "IMSTB_TEXTEDIT_STRING": "ImGuiInputTextState",
+  "IMSTB_TEXTEDIT_UNDOCHARCOUNT": "999",
+  "IMSTB_TEXTEDIT_UNDOSTATECOUNT": "99",
+  "IM_ALLOC(_SIZE)": "ImGui::MemAlloc(_SIZE)",
+  "IM_ARRAYSIZE": "IM_COUNTOF",
+  "IM_ASSERT(_EXPR)": "assert(_EXPR)",
+  "IM_ASSERT_USER_ERROR(_EXPR,_MSG)": "do { if (!(_EXPR)) { if (ImGui::ErrorLog(_MSG)) { IM_ASSERT((_EXPR) && _MSG); } } } while (0)",
+  "IM_ASSERT_USER_ERROR_RET(_EXPR,_MSG)": "do { if (!(_EXPR)) { if (ImGui::ErrorLog(_MSG)) { IM_ASSERT((_EXPR) && _MSG); } return; } } while (0)",
+  "IM_ASSERT_USER_ERROR_RETV(_EXPR,_RETV,_MSG)": "do { if (!(_EXPR)) { if (ImGui::ErrorLog(_MSG)) { IM_ASSERT((_EXPR) && _MSG); } return _RETV; } } while (0)",
+  "IM_BITARRAY_CLEARBIT(_ARRAY,_N)": "((_ARRAY[(_N) >> 5] &= ~((ImU32)1 << ((_N) & 31))))",
+  "IM_BITARRAY_TESTBIT(_ARRAY,_N)": "((_ARRAY[(_N) >> 5] & ((ImU32)1 << ((_N) & 31))) != 0)",
+  "IM_COL32(R,G,B,A)": "(((ImU32)(A)<<IM_COL32_A_SHIFT) | ((ImU32)(B)<<IM_COL32_B_SHIFT) | ((ImU32)(G)<<IM_COL32_G_SHIFT) | ((ImU32)(R)<<IM_COL32_R_SHIFT))",
+  "IM_COL32_A_MASK": "0xFF000000",
+  "IM_COL32_A_SHIFT": "24",
+  "IM_COL32_BLACK": "IM_COL32(0,0,0,255)",
+  "IM_COL32_BLACK_TRANS": "IM_COL32(0,0,0,0)",
+  "IM_COL32_B_SHIFT": "16",
+  "IM_COL32_DISABLE": "IM_COL32(0,0,0,1)",
+  "IM_COL32_G_SHIFT": "8",
+  "IM_COL32_R_SHIFT": "0",
+  "IM_COL32_WHITE": "IM_COL32(255,255,255,255)",
+  "IM_COUNTOF(_ARR)": "((int)(sizeof(_ARR) / sizeof(*(_ARR))))",
+  "IM_DEBUG_BREAK()": "__asm__ volatile(\"int3;nop\")",
+  "IM_DRAWLIST_ARCFAST_SAMPLE_MAX": "IM_DRAWLIST_ARCFAST_TABLE_SIZE",
+  "IM_DRAWLIST_ARCFAST_TABLE_SIZE": "48",
+  "IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC(_RAD,_MAXERROR)": "ImClamp(IM_ROUNDUP_TO_EVEN((int)ImCeil(IM_PI / ImAcos(1 - ImMin((_MAXERROR), (_RAD)) / (_RAD)))), IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MIN, IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX)",
+  "IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC_ERROR(_N,_RAD)": "((1 - ImCos(IM_PI / ImMax((float)(_N), IM_PI))) / (_RAD))",
+  "IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC_R(_N,_MAXERROR)": "((_MAXERROR) / (1 - ImCos(IM_PI / ImMax((float)(_N), IM_PI))))",
+  "IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX": "512",
+  "IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MIN": "4",
+  "IM_DRAWLIST_TEX_LINES_WIDTH_MAX": "(32)",
+  "IM_F32_TO_INT8_SAT(_VAL)": "((int)(ImSaturate(_VAL) * 255.0f + 0.5f))",
+  "IM_F32_TO_INT8_UNBOUND(_VAL)": "((int)((_VAL) * 255.0f + ((_VAL)>=0 ? 0.5f : -0.5f)))",
+  "IM_FMTARGS(FMT)": "__attribute__((format(gnu_printf, FMT, FMT+1)))",
+  "IM_FMTLIST(FMT)": "__attribute__((format(gnu_printf, FMT, 0)))",
+  "IM_FREE(_PTR)": "ImGui::MemFree(_PTR)",
+  "IM_MEMALIGN(_OFF,_ALIGN)": "(((_OFF) + ((_ALIGN) - 1)) & ~((_ALIGN) - 1))",
+  "IM_NEW(_TYPE)": "new(ImNewWrapper(), ImGui::MemAlloc(sizeof(_TYPE))) _TYPE",
+  "IM_NEWLINE": "\"\\r\\n\"",
+  "IM_PI": "3.14159265358979323846f",
+  "IM_PLACEMENT_NEW(_PTR)": "new(ImNewWrapper(), _PTR)",
+  "IM_PRIX64": "\"llX\"",
+  "IM_PRId64": "\"lld\"",
+  "IM_PRIu64": "\"llu\"",
+  "IM_ROUND(_VAL)": "((float)(int)((_VAL) + 0.5f))",
+  "IM_ROUNDUP_TO_EVEN(_V)": "((((_V) + 1) / 2) * 2)",
+  "IM_STATIC_ASSERT(_COND)": "static_assert(_COND, \"\")",
+  "IM_STRINGIFY(_EXPR)": "IM_STRINGIFY_HELPER(_EXPR)",
+  "IM_STRINGIFY_HELPER(_EXPR)": "#_EXPR",
+  "IM_TABSIZE": "(4)",
+  "IM_TRUNC(_VAL)": "((float)(int)(_VAL))",
+  "IM_UNICODE_CODEPOINT_INVALID": "0xFFFD",
+  "IM_UNICODE_CODEPOINT_MAX": "0xFFFF",
+  "IM_UNUSED(_VAR)": "((void)(_VAR))",
+  "ImAcos(X)": "acosf(X)",
+  "ImAtan2(Y,X)": "atan2f((Y), (X))",
+  "ImAtof(STR)": "atof(STR)",
+  "ImCeil(X)": "ceilf(X)",
+  "ImCos(X)": "cosf(X)",
+  "ImFabs(X)": "fabsf(X)",
+  "ImFmod(X,Y)": "fmodf((X), (Y))",
+  "ImFontAtlasRectId_GenerationMask_": "(0x3FF00000)",
+  "ImFontAtlasRectId_GenerationShift_": "(20)",
+  "ImFontAtlasRectId_IndexMask_": "(0x0007FFFF)",
+  "ImFontAtlasRectId_Invalid": "-1",
+  "ImGuiKeyOwner_Any": "((ImGuiID)0)",
+  "ImGuiKeyOwner_NoOwner": "((ImGuiID)-1)",
+  "ImGuiKey_Aliases_BEGIN": "(ImGuiKey_Mouse_BEGIN)",
+  "ImGuiKey_Aliases_END": "(ImGuiKey_Mouse_END)",
+  "ImGuiKey_Gamepad_BEGIN": "(ImGuiKey_GamepadStart)",
+  "ImGuiKey_Gamepad_END": "(ImGuiKey_GamepadRStickDown + 1)",
+  "ImGuiKey_Keyboard_BEGIN": "(ImGuiKey_NamedKey_BEGIN)",
+  "ImGuiKey_Keyboard_END": "(ImGuiKey_GamepadStart)",
+  "ImGuiKey_LegacyNativeKey_BEGIN": "0",
+  "ImGuiKey_LegacyNativeKey_END": "512",
+  "ImGuiKey_Mouse_BEGIN": "(ImGuiKey_MouseLeft)",
+  "ImGuiKey_Mouse_END": "(ImGuiKey_MouseWheelY + 1)",
+  "ImGuiKey_NavGamepadActivate": "(g.IO.ConfigNavSwapGamepadButtons ? ImGuiKey_GamepadFaceRight : ImGuiKey_GamepadFaceDown)",
+  "ImGuiKey_NavGamepadCancel": "(g.IO.ConfigNavSwapGamepadButtons ? ImGuiKey_GamepadFaceDown : ImGuiKey_GamepadFaceRight)",
+  "ImGuiKey_NavGamepadContextMenu": "ImGuiKey_GamepadFaceUp",
+  "ImGuiKey_NavGamepadMenu": "ImGuiKey_GamepadFaceLeft",
+  "ImGuiKey_NavGamepadTweakFast": "ImGuiKey_GamepadR1",
+  "ImGuiKey_NavGamepadTweakSlow": "ImGuiKey_GamepadL1",
+  "ImGuiKey_NavKeyboardTweakFast": "ImGuiMod_Shift",
+  "ImGuiKey_NavKeyboardTweakSlow": "ImGuiMod_Ctrl",
+  "ImGuiSelectionUserData_Invalid": "((ImGuiSelectionUserData)-1)",
+  "ImMemchr": "memchr",
+  "ImSin(X)": "sinf(X)",
+  "ImSqrt(X)": "sqrtf(X)",
+  "ImStrlen": "strlen",
+  "ImTextureID_Invalid": "((ImTextureID)0)"
+}

generator/output/constants.lua

@@ -0,0 +1,124 @@
+local t={
+  DOCKING_HOST_DRAW_CHANNEL_BG="0",
+  DOCKING_HOST_DRAW_CHANNEL_FG="1",
+  ["IMGUI_CHECKVERSION()"]="ImGui::DebugCheckVersionAndDataLayout(IMGUI_VERSION, sizeof(ImGuiIO), sizeof(ImGuiStyle), sizeof(ImVec2), sizeof(ImVec4), sizeof(ImDrawVert), sizeof(ImDrawIdx))",
+  ["IMGUI_DEBUG_LOG(...)"]="ImGui::DebugLog(__VA_ARGS__)",
+  ["IMGUI_DEBUG_LOG_ACTIVEID(...)"]="do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventActiveId) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  ["IMGUI_DEBUG_LOG_CLIPPER(...)"]="do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventClipper) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  ["IMGUI_DEBUG_LOG_DOCKING(...)"]="do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventDocking) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  ["IMGUI_DEBUG_LOG_ERROR(...)"]="do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventError) IMGUI_DEBUG_LOG(__VA_ARGS__); else g.DebugLogSkippedErrors++; } while (0)",
+  ["IMGUI_DEBUG_LOG_FOCUS(...)"]="do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventFocus) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  ["IMGUI_DEBUG_LOG_FONT(...)"]="do { ImGuiContext* g2 = GImGui; if (g2 && g2->DebugLogFlags & ImGuiDebugLogFlags_EventFont) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  ["IMGUI_DEBUG_LOG_INPUTROUTING(...)"]="do{if (g.DebugLogFlags & ImGuiDebugLogFlags_EventInputRouting)IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  ["IMGUI_DEBUG_LOG_IO(...)"]="do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventIO) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  ["IMGUI_DEBUG_LOG_NAV(...)"]="do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventNav) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  ["IMGUI_DEBUG_LOG_POPUP(...)"]="do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventPopup) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  ["IMGUI_DEBUG_LOG_SELECTION(...)"]="do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventSelection) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  ["IMGUI_DEBUG_LOG_TABLE(...)"]="do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventTable) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  ["IMGUI_DEBUG_LOG_VIEWPORT(...)"]="do { if (g.DebugLogFlags & ImGuiDebugLogFlags_EventViewport) IMGUI_DEBUG_LOG(__VA_ARGS__); } while (0)",
+  ["IMGUI_DEBUG_PRINTF(_FMT,...)"]="printf(_FMT, __VA_ARGS__)",
+  IMGUI_FONT_SIZE_MAX="(512.0f)",
+  IMGUI_FONT_SIZE_THRESHOLD_FOR_LOADADVANCEXONLYMODE="(128.0f)",
+  IMGUI_PAYLOAD_TYPE_COLOR_3F="\"_COL3F\"",
+  IMGUI_PAYLOAD_TYPE_COLOR_4F="\"_COL4F\"",
+  IMGUI_PAYLOAD_TYPE_WINDOW="\"_IMWINDOW\"",
+  IMGUI_TABLE_MAX_COLUMNS="512",
+  ["IMGUI_TEST_ENGINE_ITEM_ADD(_ID,_BB,_ITEM_DATA)"]="((void)0)",
+  ["IMGUI_TEST_ENGINE_ITEM_INFO(_ID,_LABEL,_FLAGS)"]="((void)g)",
+  IMGUI_VERSION="\"1.92.9\"",
+  IMGUI_VERSION_NUM="19290",
+  IMGUI_WINDOW_HARD_MIN_SIZE="4.0f",
+  IMSTB_TEXTEDIT_CHARTYPE="char",
+  IMSTB_TEXTEDIT_GETWIDTH_NEWLINE="(-1.0f)",
+  IMSTB_TEXTEDIT_STRING="ImGuiInputTextState",
+  IMSTB_TEXTEDIT_UNDOCHARCOUNT="999",
+  IMSTB_TEXTEDIT_UNDOSTATECOUNT="99",
+  ["IM_ALLOC(_SIZE)"]="ImGui::MemAlloc(_SIZE)",
+  IM_ARRAYSIZE="IM_COUNTOF",
+  ["IM_ASSERT(_EXPR)"]="assert(_EXPR)",
+  ["IM_ASSERT_USER_ERROR(_EXPR,_MSG)"]="do { if (!(_EXPR)) { if (ImGui::ErrorLog(_MSG)) { IM_ASSERT((_EXPR) && _MSG); } } } while (0)",
+  ["IM_ASSERT_USER_ERROR_RET(_EXPR,_MSG)"]="do { if (!(_EXPR)) { if (ImGui::ErrorLog(_MSG)) { IM_ASSERT((_EXPR) && _MSG); } return; } } while (0)",
+  ["IM_ASSERT_USER_ERROR_RETV(_EXPR,_RETV,_MSG)"]="do { if (!(_EXPR)) { if (ImGui::ErrorLog(_MSG)) { IM_ASSERT((_EXPR) && _MSG); } return _RETV; } } while (0)",
+  ["IM_BITARRAY_CLEARBIT(_ARRAY,_N)"]="((_ARRAY[(_N) >> 5] &= ~((ImU32)1 << ((_N) & 31))))",
+  ["IM_BITARRAY_TESTBIT(_ARRAY,_N)"]="((_ARRAY[(_N) >> 5] & ((ImU32)1 << ((_N) & 31))) != 0)",
+  ["IM_COL32(R,G,B,A)"]="(((ImU32)(A)<<IM_COL32_A_SHIFT) | ((ImU32)(B)<<IM_COL32_B_SHIFT) | ((ImU32)(G)<<IM_COL32_G_SHIFT) | ((ImU32)(R)<<IM_COL32_R_SHIFT))",
+  IM_COL32_A_MASK="0xFF000000",
+  IM_COL32_A_SHIFT="24",
+  IM_COL32_BLACK="IM_COL32(0,0,0,255)",
+  IM_COL32_BLACK_TRANS="IM_COL32(0,0,0,0)",
+  IM_COL32_B_SHIFT="16",
+  IM_COL32_DISABLE="IM_COL32(0,0,0,1)",
+  IM_COL32_G_SHIFT="8",
+  IM_COL32_R_SHIFT="0",
+  IM_COL32_WHITE="IM_COL32(255,255,255,255)",
+  ["IM_COUNTOF(_ARR)"]="((int)(sizeof(_ARR) / sizeof(*(_ARR))))",
+  ["IM_DEBUG_BREAK()"]="__asm__ volatile(\"int3;nop\")",
+  IM_DRAWLIST_ARCFAST_SAMPLE_MAX="IM_DRAWLIST_ARCFAST_TABLE_SIZE",
+  IM_DRAWLIST_ARCFAST_TABLE_SIZE="48",
+  ["IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC(_RAD,_MAXERROR)"]="ImClamp(IM_ROUNDUP_TO_EVEN((int)ImCeil(IM_PI / ImAcos(1 - ImMin((_MAXERROR), (_RAD)) / (_RAD)))), IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MIN, IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX)",
+  ["IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC_ERROR(_N,_RAD)"]="((1 - ImCos(IM_PI / ImMax((float)(_N), IM_PI))) / (_RAD))",
+  ["IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC_R(_N,_MAXERROR)"]="((_MAXERROR) / (1 - ImCos(IM_PI / ImMax((float)(_N), IM_PI))))",
+  IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MAX="512",
+  IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_MIN="4",
+  IM_DRAWLIST_TEX_LINES_WIDTH_MAX="(32)",
+  ["IM_F32_TO_INT8_SAT(_VAL)"]="((int)(ImSaturate(_VAL) * 255.0f + 0.5f))",
+  ["IM_F32_TO_INT8_UNBOUND(_VAL)"]="((int)((_VAL) * 255.0f + ((_VAL)>=0 ? 0.5f : -0.5f)))",
+  ["IM_FMTARGS(FMT)"]="__attribute__((format(gnu_printf, FMT, FMT+1)))",
+  ["IM_FMTLIST(FMT)"]="__attribute__((format(gnu_printf, FMT, 0)))",
+  ["IM_FREE(_PTR)"]="ImGui::MemFree(_PTR)",
+  ["IM_MEMALIGN(_OFF,_ALIGN)"]="(((_OFF) + ((_ALIGN) - 1)) & ~((_ALIGN) - 1))",
+  ["IM_NEW(_TYPE)"]="new(ImNewWrapper(), ImGui::MemAlloc(sizeof(_TYPE))) _TYPE",
+  IM_NEWLINE="\"\\r\\n\"",
+  IM_PI="3.14159265358979323846f",
+  ["IM_PLACEMENT_NEW(_PTR)"]="new(ImNewWrapper(), _PTR)",
+  IM_PRIX64="\"llX\"",
+  IM_PRId64="\"lld\"",
+  IM_PRIu64="\"llu\"",
+  ["IM_ROUND(_VAL)"]="((float)(int)((_VAL) + 0.5f))",
+  ["IM_ROUNDUP_TO_EVEN(_V)"]="((((_V) + 1) / 2) * 2)",
+  ["IM_STATIC_ASSERT(_COND)"]="static_assert(_COND, \"\")",
+  ["IM_STRINGIFY(_EXPR)"]="IM_STRINGIFY_HELPER(_EXPR)",
+  ["IM_STRINGIFY_HELPER(_EXPR)"]="#_EXPR",
+  IM_TABSIZE="(4)",
+  ["IM_TRUNC(_VAL)"]="((float)(int)(_VAL))",
+  IM_UNICODE_CODEPOINT_INVALID="0xFFFD",
+  IM_UNICODE_CODEPOINT_MAX="0xFFFF",
+  ["IM_UNUSED(_VAR)"]="((void)(_VAR))",
+  ["ImAcos(X)"]="acosf(X)",
+  ["ImAtan2(Y,X)"]="atan2f((Y), (X))",
+  ["ImAtof(STR)"]="atof(STR)",
+  ["ImCeil(X)"]="ceilf(X)",
+  ["ImCos(X)"]="cosf(X)",
+  ["ImFabs(X)"]="fabsf(X)",
+  ["ImFmod(X,Y)"]="fmodf((X), (Y))",
+  ImFontAtlasRectId_GenerationMask_="(0x3FF00000)",
+  ImFontAtlasRectId_GenerationShift_="(20)",
+  ImFontAtlasRectId_IndexMask_="(0x0007FFFF)",
+  ImFontAtlasRectId_Invalid="-1",
+  ImGuiKeyOwner_Any="((ImGuiID)0)",
+  ImGuiKeyOwner_NoOwner="((ImGuiID)-1)",
+  ImGuiKey_Aliases_BEGIN="(ImGuiKey_Mouse_BEGIN)",
+  ImGuiKey_Aliases_END="(ImGuiKey_Mouse_END)",
+  ImGuiKey_Gamepad_BEGIN="(ImGuiKey_GamepadStart)",
+  ImGuiKey_Gamepad_END="(ImGuiKey_GamepadRStickDown + 1)",
+  ImGuiKey_Keyboard_BEGIN="(ImGuiKey_NamedKey_BEGIN)",
+  ImGuiKey_Keyboard_END="(ImGuiKey_GamepadStart)",
+  ImGuiKey_LegacyNativeKey_BEGIN="0",
+  ImGuiKey_LegacyNativeKey_END="512",
+  ImGuiKey_Mouse_BEGIN="(ImGuiKey_MouseLeft)",
+  ImGuiKey_Mouse_END="(ImGuiKey_MouseWheelY + 1)",
+  ImGuiKey_NavGamepadActivate="(g.IO.ConfigNavSwapGamepadButtons ? ImGuiKey_GamepadFaceRight : ImGuiKey_GamepadFaceDown)",
+  ImGuiKey_NavGamepadCancel="(g.IO.ConfigNavSwapGamepadButtons ? ImGuiKey_GamepadFaceDown : ImGuiKey_GamepadFaceRight)",
+  ImGuiKey_NavGamepadContextMenu="ImGuiKey_GamepadFaceUp",
+  ImGuiKey_NavGamepadMenu="ImGuiKey_GamepadFaceLeft",
+  ImGuiKey_NavGamepadTweakFast="ImGuiKey_GamepadR1",
+  ImGuiKey_NavGamepadTweakSlow="ImGuiKey_GamepadL1",
+  ImGuiKey_NavKeyboardTweakFast="ImGuiMod_Shift",
+  ImGuiKey_NavKeyboardTweakSlow="ImGuiMod_Ctrl",
+  ImGuiSelectionUserData_Invalid="((ImGuiSelectionUserData)-1)",
+  ImMemchr="memchr",
+  ["ImSin(X)"]="sinf(X)",
+  ["ImSqrt(X)"]="sqrtf(X)",
+  ImStrlen="strlen",
+  ImTextureID_Invalid="((ImTextureID)0)"}
+ return t

generator/output/impl_definitions.json

@@ -489,7 +489,7 @@
       "cimguiname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
-      "location": "imgui_impl_opengl2:38",
+      "location": "imgui_impl_opengl2:39",
       "ov_cimguiname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
       "ret": "bool",
       "signature": "()",
@@ -506,7 +506,7 @@
       "cimguiname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
-      "location": "imgui_impl_opengl2:39",
+      "location": "imgui_impl_opengl2:40",
       "ov_cimguiname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
       "ret": "void",
       "signature": "()",
@@ -523,7 +523,7 @@
       "cimguiname": "ImGui_ImplOpenGL2_Init",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_Init",
-      "location": "imgui_impl_opengl2:32",
+      "location": "imgui_impl_opengl2:33",
       "ov_cimguiname": "ImGui_ImplOpenGL2_Init",
       "ret": "bool",
       "signature": "()",
@@ -540,7 +540,7 @@
       "cimguiname": "ImGui_ImplOpenGL2_NewFrame",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_NewFrame",
-      "location": "imgui_impl_opengl2:34",
+      "location": "imgui_impl_opengl2:35",
       "ov_cimguiname": "ImGui_ImplOpenGL2_NewFrame",
       "ret": "void",
       "signature": "()",
@@ -562,7 +562,7 @@
       "cimguiname": "ImGui_ImplOpenGL2_RenderDrawData",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_RenderDrawData",
-      "location": "imgui_impl_opengl2:35",
+      "location": "imgui_impl_opengl2:36",
       "ov_cimguiname": "ImGui_ImplOpenGL2_RenderDrawData",
       "ret": "void",
       "signature": "(ImDrawData*)",
@@ -579,7 +579,7 @@
       "cimguiname": "ImGui_ImplOpenGL2_Shutdown",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_Shutdown",
-      "location": "imgui_impl_opengl2:33",
+      "location": "imgui_impl_opengl2:34",
       "ov_cimguiname": "ImGui_ImplOpenGL2_Shutdown",
       "ret": "void",
       "signature": "()",
@@ -601,7 +601,7 @@
       "cimguiname": "ImGui_ImplOpenGL2_UpdateTexture",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_UpdateTexture",
-      "location": "imgui_impl_opengl2:42",
+      "location": "imgui_impl_opengl2:43",
       "ov_cimguiname": "ImGui_ImplOpenGL2_UpdateTexture",
       "ret": "void",
       "signature": "(ImTextureData*)",
@@ -642,6 +642,23 @@
       "stname": ""
     }
   ],
+  "ImGui_ImplOpenGL3_GetRenderState": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "call_args_old": "()",
+      "cimguiname": "ImGui_ImplOpenGL3_GetRenderState",
+      "defaults": {},
+      "funcname": "ImGui_ImplOpenGL3_GetRenderState",
+      "location": "imgui_impl_opengl3:80",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_GetRenderState",
+      "ret": "ImGui_ImplOpenGL3_RenderState*",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
   "ImGui_ImplOpenGL3_Init": [
     {
       "args": "(const char* glsl_version)",
@@ -1363,7 +1380,7 @@
       "cimguiname": "ImGui_ImplVulkanH_CreateOrResizeWindow",
       "defaults": {},
       "funcname": "ImGui_ImplVulkanH_CreateOrResizeWindow",
-      "location": "imgui_impl_vulkan:207",
+      "location": "imgui_impl_vulkan:212",
       "ov_cimguiname": "ImGui_ImplVulkanH_CreateOrResizeWindow",
       "ret": "void",
       "signature": "(VkInstance,VkPhysicalDevice,VkDevice,ImGui_ImplVulkanH_Window*,uint32_t,const VkAllocationCallbacks*,int,int,uint32_t,VkImageUsageFlags)",
@@ -1397,7 +1414,7 @@
       "cimguiname": "ImGui_ImplVulkanH_DestroyWindow",
       "defaults": {},
       "funcname": "ImGui_ImplVulkanH_DestroyWindow",
-      "location": "imgui_impl_vulkan:208",
+      "location": "imgui_impl_vulkan:213",
       "ov_cimguiname": "ImGui_ImplVulkanH_DestroyWindow",
       "ret": "void",
       "signature": "(VkInstance,VkDevice,ImGui_ImplVulkanH_Window*,const VkAllocationCallbacks*)",
@@ -1419,7 +1436,7 @@
       "cimguiname": "ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
       "defaults": {},
       "funcname": "ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
-      "location": "imgui_impl_vulkan:213",
+      "location": "imgui_impl_vulkan:218",
       "ov_cimguiname": "ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
       "ret": "int",
       "signature": "(VkPresentModeKHR)",
@@ -1441,7 +1458,7 @@
       "cimguiname": "ImGui_ImplVulkanH_GetWindowDataFromViewport",
       "defaults": {},
       "funcname": "ImGui_ImplVulkanH_GetWindowDataFromViewport",
-      "location": "imgui_impl_vulkan:214",
+      "location": "imgui_impl_vulkan:219",
       "ov_cimguiname": "ImGui_ImplVulkanH_GetWindowDataFromViewport",
       "ret": "ImGui_ImplVulkanH_Window*",
       "signature": "(ImGuiViewport*)",
@@ -1463,7 +1480,7 @@
       "cimguiname": "ImGui_ImplVulkanH_SelectPhysicalDevice",
       "defaults": {},
       "funcname": "ImGui_ImplVulkanH_SelectPhysicalDevice",
-      "location": "imgui_impl_vulkan:211",
+      "location": "imgui_impl_vulkan:216",
       "ov_cimguiname": "ImGui_ImplVulkanH_SelectPhysicalDevice",
       "ret": "VkPhysicalDevice",
       "signature": "(VkInstance)",
@@ -1497,7 +1514,7 @@
       "cimguiname": "ImGui_ImplVulkanH_SelectPresentMode",
       "defaults": {},
       "funcname": "ImGui_ImplVulkanH_SelectPresentMode",
-      "location": "imgui_impl_vulkan:210",
+      "location": "imgui_impl_vulkan:215",
       "ov_cimguiname": "ImGui_ImplVulkanH_SelectPresentMode",
       "ret": "VkPresentModeKHR",
       "signature": "(VkPhysicalDevice,VkSurfaceKHR,const VkPresentModeKHR*,int)",
@@ -1519,7 +1536,7 @@
       "cimguiname": "ImGui_ImplVulkanH_SelectQueueFamilyIndex",
       "defaults": {},
       "funcname": "ImGui_ImplVulkanH_SelectQueueFamilyIndex",
-      "location": "imgui_impl_vulkan:212",
+      "location": "imgui_impl_vulkan:217",
       "ov_cimguiname": "ImGui_ImplVulkanH_SelectQueueFamilyIndex",
       "ret": "uint32_t",
       "signature": "(VkPhysicalDevice)",
@@ -1557,7 +1574,7 @@
       "cimguiname": "ImGui_ImplVulkanH_SelectSurfaceFormat",
       "defaults": {},
       "funcname": "ImGui_ImplVulkanH_SelectSurfaceFormat",
-      "location": "imgui_impl_vulkan:209",
+      "location": "imgui_impl_vulkan:214",
       "ov_cimguiname": "ImGui_ImplVulkanH_SelectSurfaceFormat",
       "ret": "VkSurfaceFormatKHR",
       "signature": "(VkPhysicalDevice,VkSurfaceKHR,const VkFormat*,int,VkColorSpaceKHR)",
@@ -1575,7 +1592,8 @@
       "constructor": true,
       "defaults": {},
       "funcname": "ImGui_ImplVulkanH_Window",
-      "location": "imgui_impl_vulkan:259",
+      "location": "imgui_impl_vulkan:264",
+      "namespace": "ImGui_ImplVulkanH_Window",
       "ov_cimguiname": "ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window",
       "signature": "()",
       "stname": "ImGui_ImplVulkanH_Window"
@@ -1594,7 +1612,7 @@
       "cimguiname": "ImGui_ImplVulkanH_Window_destroy",
       "defaults": {},
       "destructor": true,
-      "location": "imgui_impl_vulkan:259",
+      "location": "imgui_impl_vulkan:264",
       "ov_cimguiname": "ImGui_ImplVulkanH_Window_destroy",
       "ret": "void",
       "signature": "(ImGui_ImplVulkanH_Window*)",
@@ -1603,12 +1621,8 @@
   ],
   "ImGui_ImplVulkan_AddTexture": [
     {
-      "args": "(VkSampler sampler,VkImageView image_view,VkImageLayout image_layout)",
+      "args": "(VkImageView image_view,VkImageLayout image_layout)",
       "argsT": [
-        {
-          "name": "sampler",
-          "type": "VkSampler"
-        },
         {
           "name": "image_view",
           "type": "VkImageView"
@@ -1618,16 +1632,16 @@
           "type": "VkImageLayout"
         }
       ],
-      "argsoriginal": "(VkSampler sampler,VkImageView image_view,VkImageLayout image_layout)",
+      "argsoriginal": "(VkImageView image_view,VkImageLayout image_layout)",
-      "call_args": "(sampler,image_view,image_layout)",
+      "call_args": "(image_view,image_layout)",
-      "call_args_old": "(sampler,image_view,image_layout)",
+      "call_args_old": "(image_view,image_layout)",
       "cimguiname": "ImGui_ImplVulkan_AddTexture",
       "defaults": {},
       "funcname": "ImGui_ImplVulkan_AddTexture",
       "location": "imgui_impl_vulkan:165",
       "ov_cimguiname": "ImGui_ImplVulkan_AddTexture",
       "ret": "VkDescriptorSet",
-      "signature": "(VkSampler,VkImageView,VkImageLayout)",
+      "signature": "(VkImageView,VkImageLayout)",
       "stname": ""
     }
   ],
@@ -1646,7 +1660,7 @@
       "cimguiname": "ImGui_ImplVulkan_CreateMainPipeline",
       "defaults": {},
       "funcname": "ImGui_ImplVulkan_CreateMainPipeline",
-      "location": "imgui_impl_vulkan:157",
+      "location": "imgui_impl_vulkan:159",
       "ov_cimguiname": "ImGui_ImplVulkan_CreateMainPipeline",
       "ret": "void",
       "signature": "(const ImGui_ImplVulkan_PipelineInfo*)",
@@ -1668,7 +1682,7 @@
       "cimguiname": "ImGui_ImplVulkan_Init",
       "defaults": {},
       "funcname": "ImGui_ImplVulkan_Init",
-      "location": "imgui_impl_vulkan:148",
+      "location": "imgui_impl_vulkan:150",
       "ov_cimguiname": "ImGui_ImplVulkan_Init",
       "ret": "bool",
       "signature": "(ImGui_ImplVulkan_InitInfo*)",
@@ -1700,7 +1714,7 @@
         "user_data": "nullptr"
       },
       "funcname": "ImGui_ImplVulkan_LoadFunctions",
-      "location": "imgui_impl_vulkan:170",
+      "location": "imgui_impl_vulkan:174",
       "ov_cimguiname": "ImGui_ImplVulkan_LoadFunctions",
       "ret": "bool",
       "signature": "(uint32_t,PFN_vkVoidFunction(*loader_func)(const char* function_name,void*,void*)",
@@ -1717,7 +1731,7 @@
       "cimguiname": "ImGui_ImplVulkan_NewFrame",
       "defaults": {},
       "funcname": "ImGui_ImplVulkan_NewFrame",
-      "location": "imgui_impl_vulkan:150",
+      "location": "imgui_impl_vulkan:152",
       "ov_cimguiname": "ImGui_ImplVulkan_NewFrame",
       "ret": "void",
       "signature": "()",
@@ -1771,7 +1785,7 @@
         "pipeline": "0ULL"
       },
       "funcname": "ImGui_ImplVulkan_RenderDrawData",
-      "location": "imgui_impl_vulkan:151",
+      "location": "imgui_impl_vulkan:153",
       "ov_cimguiname": "ImGui_ImplVulkan_RenderDrawData",
       "ret": "void",
       "signature": "(ImDrawData*,VkCommandBuffer,VkPipeline)",
@@ -1793,7 +1807,7 @@
       "cimguiname": "ImGui_ImplVulkan_SetMinImageCount",
       "defaults": {},
       "funcname": "ImGui_ImplVulkan_SetMinImageCount",
-      "location": "imgui_impl_vulkan:152",
+      "location": "imgui_impl_vulkan:154",
       "ov_cimguiname": "ImGui_ImplVulkan_SetMinImageCount",
       "ret": "void",
       "signature": "(uint32_t)",
@@ -1810,7 +1824,7 @@
       "cimguiname": "ImGui_ImplVulkan_Shutdown",
       "defaults": {},
       "funcname": "ImGui_ImplVulkan_Shutdown",
-      "location": "imgui_impl_vulkan:149",
+      "location": "imgui_impl_vulkan:151",
       "ov_cimguiname": "ImGui_ImplVulkan_Shutdown",
       "ret": "void",
       "signature": "()",
@@ -1832,7 +1846,7 @@
       "cimguiname": "ImGui_ImplVulkan_UpdateTexture",
       "defaults": {},
       "funcname": "ImGui_ImplVulkan_UpdateTexture",
-      "location": "imgui_impl_vulkan:160",
+      "location": "imgui_impl_vulkan:162",
       "ov_cimguiname": "ImGui_ImplVulkan_UpdateTexture",
       "ret": "void",
       "signature": "(ImTextureData*)",

generator/output/impl_definitions.lua

@@ -418,7 +418,7 @@ local t={
       cimguiname="ImGui_ImplOpenGL2_CreateDeviceObjects",
       defaults={},
       funcname="ImGui_ImplOpenGL2_CreateDeviceObjects",
-      location="imgui_impl_opengl2:38",
+      location="imgui_impl_opengl2:39",
       ov_cimguiname="ImGui_ImplOpenGL2_CreateDeviceObjects",
       ret="bool",
       signature="()",
@@ -434,7 +434,7 @@ local t={
       cimguiname="ImGui_ImplOpenGL2_DestroyDeviceObjects",
       defaults={},
       funcname="ImGui_ImplOpenGL2_DestroyDeviceObjects",
-      location="imgui_impl_opengl2:39",
+      location="imgui_impl_opengl2:40",
       ov_cimguiname="ImGui_ImplOpenGL2_DestroyDeviceObjects",
       ret="void",
       signature="()",
@@ -450,7 +450,7 @@ local t={
       cimguiname="ImGui_ImplOpenGL2_Init",
       defaults={},
       funcname="ImGui_ImplOpenGL2_Init",
-      location="imgui_impl_opengl2:32",
+      location="imgui_impl_opengl2:33",
       ov_cimguiname="ImGui_ImplOpenGL2_Init",
       ret="bool",
       signature="()",
@@ -466,7 +466,7 @@ local t={
       cimguiname="ImGui_ImplOpenGL2_NewFrame",
       defaults={},
       funcname="ImGui_ImplOpenGL2_NewFrame",
-      location="imgui_impl_opengl2:34",
+      location="imgui_impl_opengl2:35",
       ov_cimguiname="ImGui_ImplOpenGL2_NewFrame",
       ret="void",
       signature="()",
@@ -485,7 +485,7 @@ local t={
       cimguiname="ImGui_ImplOpenGL2_RenderDrawData",
       defaults={},
       funcname="ImGui_ImplOpenGL2_RenderDrawData",
-      location="imgui_impl_opengl2:35",
+      location="imgui_impl_opengl2:36",
       ov_cimguiname="ImGui_ImplOpenGL2_RenderDrawData",
       ret="void",
       signature="(ImDrawData*)",
@@ -501,7 +501,7 @@ local t={
       cimguiname="ImGui_ImplOpenGL2_Shutdown",
       defaults={},
       funcname="ImGui_ImplOpenGL2_Shutdown",
-      location="imgui_impl_opengl2:33",
+      location="imgui_impl_opengl2:34",
       ov_cimguiname="ImGui_ImplOpenGL2_Shutdown",
       ret="void",
       signature="()",
@@ -520,7 +520,7 @@ local t={
       cimguiname="ImGui_ImplOpenGL2_UpdateTexture",
       defaults={},
       funcname="ImGui_ImplOpenGL2_UpdateTexture",
-      location="imgui_impl_opengl2:42",
+      location="imgui_impl_opengl2:43",
       ov_cimguiname="ImGui_ImplOpenGL2_UpdateTexture",
       ret="void",
       signature="(ImTextureData*)",
@@ -558,6 +558,22 @@ local t={
       signature="()",
       stname=""},
     ["()"]=nil},
+  ImGui_ImplOpenGL3_GetRenderState={
+    [1]={
+      args="()",
+      argsT={},
+      argsoriginal="()",
+      call_args="()",
+      call_args_old="()",
+      cimguiname="ImGui_ImplOpenGL3_GetRenderState",
+      defaults={},
+      funcname="ImGui_ImplOpenGL3_GetRenderState",
+      location="imgui_impl_opengl3:80",
+      ov_cimguiname="ImGui_ImplOpenGL3_GetRenderState",
+      ret="ImGui_ImplOpenGL3_RenderState*",
+      signature="()",
+      stname=""},
+    ["()"]=nil},
   ImGui_ImplOpenGL3_Init={
     [1]={
       args="(const char* glsl_version)",
@@ -1179,7 +1195,7 @@ local t={
       cimguiname="ImGui_ImplVulkanH_CreateOrResizeWindow",
       defaults={},
       funcname="ImGui_ImplVulkanH_CreateOrResizeWindow",
-      location="imgui_impl_vulkan:207",
+      location="imgui_impl_vulkan:212",
       ov_cimguiname="ImGui_ImplVulkanH_CreateOrResizeWindow",
       ret="void",
       signature="(VkInstance,VkPhysicalDevice,VkDevice,ImGui_ImplVulkanH_Window*,uint32_t,const VkAllocationCallbacks*,int,int,uint32_t,VkImageUsageFlags)",
@@ -1207,7 +1223,7 @@ local t={
       cimguiname="ImGui_ImplVulkanH_DestroyWindow",
       defaults={},
       funcname="ImGui_ImplVulkanH_DestroyWindow",
-      location="imgui_impl_vulkan:208",
+      location="imgui_impl_vulkan:213",
       ov_cimguiname="ImGui_ImplVulkanH_DestroyWindow",
       ret="void",
       signature="(VkInstance,VkDevice,ImGui_ImplVulkanH_Window*,const VkAllocationCallbacks*)",
@@ -1226,7 +1242,7 @@ local t={
       cimguiname="ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
       defaults={},
       funcname="ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
-      location="imgui_impl_vulkan:213",
+      location="imgui_impl_vulkan:218",
       ov_cimguiname="ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
       ret="int",
       signature="(VkPresentModeKHR)",
@@ -1245,7 +1261,7 @@ local t={
       cimguiname="ImGui_ImplVulkanH_GetWindowDataFromViewport",
       defaults={},
       funcname="ImGui_ImplVulkanH_GetWindowDataFromViewport",
-      location="imgui_impl_vulkan:214",
+      location="imgui_impl_vulkan:219",
       ov_cimguiname="ImGui_ImplVulkanH_GetWindowDataFromViewport",
       ret="ImGui_ImplVulkanH_Window*",
       signature="(ImGuiViewport*)",
@@ -1264,7 +1280,7 @@ local t={
       cimguiname="ImGui_ImplVulkanH_SelectPhysicalDevice",
       defaults={},
       funcname="ImGui_ImplVulkanH_SelectPhysicalDevice",
-      location="imgui_impl_vulkan:211",
+      location="imgui_impl_vulkan:216",
       ov_cimguiname="ImGui_ImplVulkanH_SelectPhysicalDevice",
       ret="VkPhysicalDevice",
       signature="(VkInstance)",
@@ -1292,7 +1308,7 @@ local t={
       cimguiname="ImGui_ImplVulkanH_SelectPresentMode",
       defaults={},
       funcname="ImGui_ImplVulkanH_SelectPresentMode",
-      location="imgui_impl_vulkan:210",
+      location="imgui_impl_vulkan:215",
       ov_cimguiname="ImGui_ImplVulkanH_SelectPresentMode",
       ret="VkPresentModeKHR",
       signature="(VkPhysicalDevice,VkSurfaceKHR,const VkPresentModeKHR*,int)",
@@ -1311,7 +1327,7 @@ local t={
       cimguiname="ImGui_ImplVulkanH_SelectQueueFamilyIndex",
       defaults={},
       funcname="ImGui_ImplVulkanH_SelectQueueFamilyIndex",
-      location="imgui_impl_vulkan:212",
+      location="imgui_impl_vulkan:217",
       ov_cimguiname="ImGui_ImplVulkanH_SelectQueueFamilyIndex",
       ret="uint32_t",
       signature="(VkPhysicalDevice)",
@@ -1342,7 +1358,7 @@ local t={
       cimguiname="ImGui_ImplVulkanH_SelectSurfaceFormat",
       defaults={},
       funcname="ImGui_ImplVulkanH_SelectSurfaceFormat",
-      location="imgui_impl_vulkan:209",
+      location="imgui_impl_vulkan:214",
       ov_cimguiname="ImGui_ImplVulkanH_SelectSurfaceFormat",
       ret="VkSurfaceFormatKHR",
       signature="(VkPhysicalDevice,VkSurfaceKHR,const VkFormat*,int,VkColorSpaceKHR)",
@@ -1359,7 +1375,8 @@ local t={
       constructor=true,
       defaults={},
       funcname="ImGui_ImplVulkanH_Window",
-      location="imgui_impl_vulkan:259",
+      location="imgui_impl_vulkan:264",
+      namespace="ImGui_ImplVulkanH_Window",
       ov_cimguiname="ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window",
       signature="()",
       stname="ImGui_ImplVulkanH_Window"},
@@ -1375,7 +1392,7 @@ local t={
       cimguiname="ImGui_ImplVulkanH_Window_destroy",
       defaults={},
       destructor=true,
-      location="imgui_impl_vulkan:259",
+      location="imgui_impl_vulkan:264",
       ov_cimguiname="ImGui_ImplVulkanH_Window_destroy",
       ret="void",
       signature="(ImGui_ImplVulkanH_Window*)",
@@ -1383,29 +1400,26 @@ local t={
     ["(ImGui_ImplVulkanH_Window*)"]=nil},
   ImGui_ImplVulkan_AddTexture={
     [1]={
-      args="(VkSampler sampler,VkImageView image_view,VkImageLayout image_layout)",
+      args="(VkImageView image_view,VkImageLayout image_layout)",
       argsT={
         [1]={
-          name="sampler",
-          type="VkSampler"},
-        [2]={
           name="image_view",
           type="VkImageView"},
-        [3]={
+        [2]={
           name="image_layout",
           type="VkImageLayout"}},
-      argsoriginal="(VkSampler sampler,VkImageView image_view,VkImageLayout image_layout)",
+      argsoriginal="(VkImageView image_view,VkImageLayout image_layout)",
-      call_args="(sampler,image_view,image_layout)",
+      call_args="(image_view,image_layout)",
-      call_args_old="(sampler,image_view,image_layout)",
+      call_args_old="(image_view,image_layout)",
       cimguiname="ImGui_ImplVulkan_AddTexture",
       defaults={},
       funcname="ImGui_ImplVulkan_AddTexture",
       location="imgui_impl_vulkan:165",
       ov_cimguiname="ImGui_ImplVulkan_AddTexture",
       ret="VkDescriptorSet",
-      signature="(VkSampler,VkImageView,VkImageLayout)",
+      signature="(VkImageView,VkImageLayout)",
       stname=""},
-    ["(VkSampler,VkImageView,VkImageLayout)"]=nil},
+    ["(VkImageView,VkImageLayout)"]=nil},
   ImGui_ImplVulkan_CreateMainPipeline={
     [1]={
       args="(const ImGui_ImplVulkan_PipelineInfo* info)",
@@ -1419,7 +1433,7 @@ local t={
       cimguiname="ImGui_ImplVulkan_CreateMainPipeline",
       defaults={},
       funcname="ImGui_ImplVulkan_CreateMainPipeline",
-      location="imgui_impl_vulkan:157",
+      location="imgui_impl_vulkan:159",
       ov_cimguiname="ImGui_ImplVulkan_CreateMainPipeline",
       ret="void",
       signature="(const ImGui_ImplVulkan_PipelineInfo*)",
@@ -1438,7 +1452,7 @@ local t={
       cimguiname="ImGui_ImplVulkan_Init",
       defaults={},
       funcname="ImGui_ImplVulkan_Init",
-      location="imgui_impl_vulkan:148",
+      location="imgui_impl_vulkan:150",
       ov_cimguiname="ImGui_ImplVulkan_Init",
       ret="bool",
       signature="(ImGui_ImplVulkan_InitInfo*)",
@@ -1464,7 +1478,7 @@ local t={
       defaults={
         user_data="nullptr"},
       funcname="ImGui_ImplVulkan_LoadFunctions",
-      location="imgui_impl_vulkan:170",
+      location="imgui_impl_vulkan:174",
       ov_cimguiname="ImGui_ImplVulkan_LoadFunctions",
       ret="bool",
       signature="(uint32_t,PFN_vkVoidFunction(*loader_func)(const char* function_name,void*,void*)",
@@ -1480,7 +1494,7 @@ local t={
       cimguiname="ImGui_ImplVulkan_NewFrame",
       defaults={},
       funcname="ImGui_ImplVulkan_NewFrame",
-      location="imgui_impl_vulkan:150",
+      location="imgui_impl_vulkan:152",
       ov_cimguiname="ImGui_ImplVulkan_NewFrame",
       ret="void",
       signature="()",
@@ -1525,7 +1539,7 @@ local t={
       defaults={
         pipeline="0ULL"},
       funcname="ImGui_ImplVulkan_RenderDrawData",
-      location="imgui_impl_vulkan:151",
+      location="imgui_impl_vulkan:153",
       ov_cimguiname="ImGui_ImplVulkan_RenderDrawData",
       ret="void",
       signature="(ImDrawData*,VkCommandBuffer,VkPipeline)",
@@ -1544,7 +1558,7 @@ local t={
       cimguiname="ImGui_ImplVulkan_SetMinImageCount",
       defaults={},
       funcname="ImGui_ImplVulkan_SetMinImageCount",
-      location="imgui_impl_vulkan:152",
+      location="imgui_impl_vulkan:154",
       ov_cimguiname="ImGui_ImplVulkan_SetMinImageCount",
       ret="void",
       signature="(uint32_t)",
@@ -1560,7 +1574,7 @@ local t={
       cimguiname="ImGui_ImplVulkan_Shutdown",
       defaults={},
       funcname="ImGui_ImplVulkan_Shutdown",
-      location="imgui_impl_vulkan:149",
+      location="imgui_impl_vulkan:151",
       ov_cimguiname="ImGui_ImplVulkan_Shutdown",
       ret="void",
       signature="()",
@@ -1579,7 +1593,7 @@ local t={
       cimguiname="ImGui_ImplVulkan_UpdateTexture",
       defaults={},
       funcname="ImGui_ImplVulkan_UpdateTexture",
-      location="imgui_impl_vulkan:160",
+      location="imgui_impl_vulkan:162",
       ov_cimguiname="ImGui_ImplVulkan_UpdateTexture",
       ret="void",
       signature="(ImTextureData*)",
@@ -1613,6 +1627,7 @@ t.ImGui_ImplOpenGL2_Shutdown["()"]=t.ImGui_ImplOpenGL2_Shutdown[1]
 t.ImGui_ImplOpenGL2_UpdateTexture["(ImTextureData*)"]=t.ImGui_ImplOpenGL2_UpdateTexture[1]
 t.ImGui_ImplOpenGL3_CreateDeviceObjects["()"]=t.ImGui_ImplOpenGL3_CreateDeviceObjects[1]
 t.ImGui_ImplOpenGL3_DestroyDeviceObjects["()"]=t.ImGui_ImplOpenGL3_DestroyDeviceObjects[1]
+t.ImGui_ImplOpenGL3_GetRenderState["()"]=t.ImGui_ImplOpenGL3_GetRenderState[1]
 t.ImGui_ImplOpenGL3_Init["(const char*)"]=t.ImGui_ImplOpenGL3_Init[1]
 t.ImGui_ImplOpenGL3_NewFrame["()"]=t.ImGui_ImplOpenGL3_NewFrame[1]
 t.ImGui_ImplOpenGL3_RenderDrawData["(ImDrawData*)"]=t.ImGui_ImplOpenGL3_RenderDrawData[1]
@@ -1653,7 +1668,7 @@ t.ImGui_ImplVulkanH_SelectQueueFamilyIndex["(VkPhysicalDevice)"]=t.ImGui_ImplVul
 t.ImGui_ImplVulkanH_SelectSurfaceFormat["(VkPhysicalDevice,VkSurfaceKHR,const VkFormat*,int,VkColorSpaceKHR)"]=t.ImGui_ImplVulkanH_SelectSurfaceFormat[1]
 t.ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window["()"]=t.ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window[1]
 t.ImGui_ImplVulkanH_Window_destroy["(ImGui_ImplVulkanH_Window*)"]=t.ImGui_ImplVulkanH_Window_destroy[1]
-t.ImGui_ImplVulkan_AddTexture["(VkSampler,VkImageView,VkImageLayout)"]=t.ImGui_ImplVulkan_AddTexture[1]
+t.ImGui_ImplVulkan_AddTexture["(VkImageView,VkImageLayout)"]=t.ImGui_ImplVulkan_AddTexture[1]
 t.ImGui_ImplVulkan_CreateMainPipeline["(const ImGui_ImplVulkan_PipelineInfo*)"]=t.ImGui_ImplVulkan_CreateMainPipeline[1]
 t.ImGui_ImplVulkan_Init["(ImGui_ImplVulkan_InitInfo*)"]=t.ImGui_ImplVulkan_Init[1]
 t.ImGui_ImplVulkan_LoadFunctions["(uint32_t,PFN_vkVoidFunction(*loader_func)(const char* function_name,void*,void*)"]=t.ImGui_ImplVulkan_LoadFunctions[1]

generator/output/overloads.txt

@@ -8,6 +8,9 @@ ImColor_ImColor	5
 ImDrawList_AddText	2
 1	void	ImDrawList_AddText_Vec2 (const ImVec2,ImU32,const char*,const char*)
 2	void	ImDrawList_AddText_FontPtr (ImFont*,float,const ImVec2,ImU32,const char*,const char*,float,const ImVec4*)
+ImGuiPackedDate_ImGuiPackedDate	2
+1	nil	ImGuiPackedDate_ImGuiPackedDate_Nil ()
+2	nil	ImGuiPackedDate_ImGuiPackedDate_Int (int)
 ImGuiPtrOrIndex_ImGuiPtrOrIndex	2
 1	nil	ImGuiPtrOrIndex_ImGuiPtrOrIndex_Ptr (void*)
 2	nil	ImGuiPtrOrIndex_ImGuiPtrOrIndex_Int (int)
@@ -213,8 +216,8 @@ igMenuItem	2
 1	bool	igMenuItem_Bool (const char*,const char*,bool,bool)
 2	bool	igMenuItem_BoolPtr (const char*,const char*,bool*,bool)
 igOpenPopup	2
-1	void	igOpenPopup_Str (const char*,ImGuiPopupFlags)
+1	bool	igOpenPopup_Str (const char*,ImGuiPopupFlags)
-2	void	igOpenPopup_ID (ImGuiID,ImGuiPopupFlags)
+2	bool	igOpenPopup_ID (ImGuiID,ImGuiPopupFlags)
 igPlotHistogram	2
 1	void	igPlotHistogram_FloatPtr (const char*,const float*,int,int,const char*,float,float,ImVec2,int)
 2	void	igPlotHistogram_FnFloatPtr (const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2)
@@ -239,8 +242,8 @@ igSelectable	2
 1	bool	igSelectable_Bool (const char*,bool,ImGuiSelectableFlags,const ImVec2)
 2	bool	igSelectable_BoolPtr (const char*,bool*,ImGuiSelectableFlags,const ImVec2)
 igSetItemKeyOwner	2
-1	void	igSetItemKeyOwner_Nil (ImGuiKey)
+1	bool	igSetItemKeyOwner_Nil (ImGuiKey)
-2	void	igSetItemKeyOwner_InputFlags (ImGuiKey,ImGuiInputFlags)
+2	bool	igSetItemKeyOwner_InputFlags (ImGuiKey,ImGuiInputFlags)
 igSetScrollFromPosX	2
 1	void	igSetScrollFromPosX_Float (float,float)
 2	void	igSetScrollFromPosX_WindowPtr (ImGuiWindow*,float,float)
@@ -305,4 +308,4 @@ igValue	4
 2	void	igValue_Int (const char*,int)
 3	void	igValue_Uint (const char*,unsigned int)
 4	void	igValue_Float (const char*,float,const char*)
-213 overloaded
+215 overloaded

generator/output/typedefs_dict.json

@@ -48,7 +48,7 @@
   "ImGuiContext": "struct ImGuiContext",
   "ImGuiContextHook": "struct ImGuiContextHook",
   "ImGuiContextHookCallback": "void (*)(ImGuiContext* ctx, ImGuiContextHook* hook);",
-  "ImGuiDataAuthority": "int",
+  "ImGuiDataAuthority": "unsigned int",
   "ImGuiDataType": "int",
   "ImGuiDataTypeInfo": "struct ImGuiDataTypeInfo",
   "ImGuiDataTypeStorage": "struct ImGuiDataTypeStorage",
@@ -57,6 +57,7 @@
   "ImGuiDebugAllocInfo": "struct ImGuiDebugAllocInfo",
   "ImGuiDebugItemPathQuery": "struct ImGuiDebugItemPathQuery",
   "ImGuiDebugLogFlags": "int",
+  "ImGuiDemoMarkerCallback": "void (*)(const char* file, int line, const char* section);",
   "ImGuiDockContext": "struct ImGuiDockContext",
   "ImGuiDockNode": "struct ImGuiDockNode",
   "ImGuiDockNodeFlags": "int",
@@ -126,6 +127,7 @@
   "ImGuiOldColumnFlags": "int",
   "ImGuiOldColumns": "struct ImGuiOldColumns",
   "ImGuiOnceUponAFrame": "struct ImGuiOnceUponAFrame",
+  "ImGuiPackedDate": "struct ImGuiPackedDate",
   "ImGuiPayload": "struct ImGuiPayload",
   "ImGuiPlatformIO": "struct ImGuiPlatformIO",
   "ImGuiPlatformImeData": "struct ImGuiPlatformImeData",
@@ -140,6 +142,7 @@
   "ImGuiSelectionRequest": "struct ImGuiSelectionRequest",
   "ImGuiSelectionUserData": "ImS64",
   "ImGuiSeparatorFlags": "int",
+  "ImGuiSettingsCleanupArgs": "struct ImGuiSettingsCleanupArgs",
   "ImGuiSettingsHandler": "struct ImGuiSettingsHandler",
   "ImGuiShrinkWidthItem": "struct ImGuiShrinkWidthItem",
   "ImGuiSizeCallback": "void (*)(ImGuiSizeCallbackData* data);",
@@ -169,6 +172,7 @@
   "ImGuiTableFlags": "int",
   "ImGuiTableHeaderData": "struct ImGuiTableHeaderData",
   "ImGuiTableInstanceData": "struct ImGuiTableInstanceData",
+  "ImGuiTableReconcileColumnData": "struct ImGuiTableReconcileColumnData",
   "ImGuiTableRowFlags": "int",
   "ImGuiTableSettings": "struct ImGuiTableSettings",
   "ImGuiTableSortSpecs": "struct ImGuiTableSortSpecs",

generator/output/typedefs_dict.lua

@@ -48,7 +48,7 @@ local t={
   ImGuiContext="struct ImGuiContext",
   ImGuiContextHook="struct ImGuiContextHook",
   ImGuiContextHookCallback="void (*)(ImGuiContext* ctx, ImGuiContextHook* hook);",
-  ImGuiDataAuthority="int",
+  ImGuiDataAuthority="unsigned int",
   ImGuiDataType="int",
   ImGuiDataTypeInfo="struct ImGuiDataTypeInfo",
   ImGuiDataTypeStorage="struct ImGuiDataTypeStorage",
@@ -57,6 +57,7 @@ local t={
   ImGuiDebugAllocInfo="struct ImGuiDebugAllocInfo",
   ImGuiDebugItemPathQuery="struct ImGuiDebugItemPathQuery",
   ImGuiDebugLogFlags="int",
+  ImGuiDemoMarkerCallback="void (*)(const char* file, int line, const char* section);",
   ImGuiDockContext="struct ImGuiDockContext",
   ImGuiDockNode="struct ImGuiDockNode",
   ImGuiDockNodeFlags="int",
@@ -126,6 +127,7 @@ local t={
   ImGuiOldColumnFlags="int",
   ImGuiOldColumns="struct ImGuiOldColumns",
   ImGuiOnceUponAFrame="struct ImGuiOnceUponAFrame",
+  ImGuiPackedDate="struct ImGuiPackedDate",
   ImGuiPayload="struct ImGuiPayload",
   ImGuiPlatformIO="struct ImGuiPlatformIO",
   ImGuiPlatformImeData="struct ImGuiPlatformImeData",
@@ -140,6 +142,7 @@ local t={
   ImGuiSelectionRequest="struct ImGuiSelectionRequest",
   ImGuiSelectionUserData="ImS64",
   ImGuiSeparatorFlags="int",
+  ImGuiSettingsCleanupArgs="struct ImGuiSettingsCleanupArgs",
   ImGuiSettingsHandler="struct ImGuiSettingsHandler",
   ImGuiShrinkWidthItem="struct ImGuiShrinkWidthItem",
   ImGuiSizeCallback="void (*)(ImGuiSizeCallbackData* data);",
@@ -169,6 +172,7 @@ local t={
   ImGuiTableFlags="int",
   ImGuiTableHeaderData="struct ImGuiTableHeaderData",
   ImGuiTableInstanceData="struct ImGuiTableInstanceData",
+  ImGuiTableReconcileColumnData="struct ImGuiTableReconcileColumnData",
   ImGuiTableRowFlags="int",
   ImGuiTableSettings="struct ImGuiTableSettings",
   ImGuiTableSortSpecs="struct ImGuiTableSortSpecs",