Merge branch 'docking_inter'

pull imgui 1.92.0 - docking and generate

CMakeLists.txt

@@ -48,6 +48,10 @@ if(IMGUI_WCHAR32)
 	target_compile_definitions(cimgui PUBLIC IMGUI_USE_WCHAR32)
 endif(IMGUI_WCHAR32)
 
+if(CIMGUI_VARGS0)
+	target_compile_definitions(cimgui PUBLIC CIMGUI_VARGS0)
+endif(CIMGUI_VARGS0)
+
 add_definitions("-DIMGUI_USER_CONFIG=\"../cimconfig.h\"")
 target_compile_definitions(cimgui PUBLIC IMGUI_DISABLE_OBSOLETE_FUNCTIONS=1)
 if (WIN32)

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.91.9 of Dear ImGui with internal api]
+* currently this wrapper is based on version [1.92.0 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.
@@ -24,7 +24,7 @@ Notes:
   * `git submodule update --init --recursive` (If already cloned)
 * compile 
   * using makefile on linux/macOS/mingw (Or use CMake to generate project)
-  * cmake options are IMGUI_STATIC (compiling as static library), IMGUI_FREETYPE (for using Freetype2) and FREETYPE_PATH (Freetype2 cmake install location) and IMGUI_WCHAR32
+  * cmake options are IMGUI_STATIC (compiling as static library), IMGUI_FREETYPE (for using Freetype2) and FREETYPE_PATH (Freetype2 cmake install location), IMGUI_WCHAR32 and CIMGUI_VARGS0 for compiling a function version without varargs for vararg functions (function name with 0 sufix)
   * or as in https://github.com/sonoro1234/LuaJIT-ImGui/tree/master/build
   
   For compiling with backends there are now examples with SDL2 and opengl3/vulkan in folder backend_test.

backend_test/cmake/GenerateCimguiBindings.cmake

@@ -0,0 +1,94 @@
+# This downloads cimgui, configures it to generate the SDL3 and SDLGPU3 bindings, 
+# and adds it as a cmake target for you to link to. Feel free to copy this file
+# into your project, or refit it to your needs.
+
+#include(CMakePrintHelpers)
+
+function(IncludesStr comp includes)
+	#cmake_print_variables(includes)
+	if("${comp}" STREQUAL "cl")
+		set(Ist "/I")
+	else()
+		set(Ist "-I")
+	endif()
+	set(incstr "")
+	foreach(inc ${${includes}})
+		set(incstr ${incstr} ${Ist}${inc})
+	endforeach()
+	set(incstr ${incstr} PARENT_SCOPE)
+endfunction()
+
+
+
+function(GenerateCimguiBindings target platbk rendbk _inclist)
+	include(FetchContent)
+	set(FETCHCONTENT_QUIET OFF)
+	#cmake_print_variables(_inclist)
+	set(__inclist ${${_inclist}})
+	#cmake_print_variables(__inclist)
+	# NOTE: In your own project, you may want to pin this project to a particular commit
+	FetchContent_Declare(
+		cimgui
+		EXCLUDE_FROM_ALL
+		GIT_REPOSITORY https://github.com/cimgui/cimgui.git 
+		GIT_TAG docking_inter
+		GIT_SUBMODULES_RECURSE true
+		GIT_PROGRESS true
+		GIT_SHALLOW true
+	)
+
+	FetchContent_MakeAvailable(cimgui)
+
+	file(READ ${cimgui_SOURCE_DIR}/cimgui_impl.h cimgui_impl)
+
+	# We're checking to see if the cimgui_impl.h file already has required bindings,
+	# since this will be executed on each "configure" (whenever you run cmake)
+	string(TOUPPER ${platbk} PLATBK)
+	string(TOUPPER ${rendbk} RENDBK)
+	string(FIND "${cimgui_impl}" CIMGUI_USE_${RENDBK} rendbk_position)
+	string(FIND "${cimgui_impl}" CIMGUI_USE_${PLATBK} platbk_position)
+	# If we don't find it, rendbk_position will be -1
+	if(rendbk_position EQUAL -1 OR platbk_position EQUAL -1)
+		#get compiler name
+		cmake_path(GET CMAKE_C_COMPILER FILENAME C_COMP)
+		cmake_path(REMOVE_EXTENSION C_COMP)
+		#get includes string
+		IncludesStr(${C_COMP} __inclist)
+		message(STATUS "incstr is ${incstr}")
+		execute_process(
+		COMMAND luajit generator.lua ${C_COMP} "internal noimstrv" ${platbk} ${rendbk} ${incstr}
+		WORKING_DIRECTORY ${cimgui_SOURCE_DIR}/generator
+		ERROR_VARIABLE error_command
+		RESULT_VARIABLE build_command_result
+		)
+		if(NOT ${build_command_result} EQUAL 0)
+			message(STATUS "cimgui generation failed: Do you have LuaJIT?")
+			message(STATUS "cimgui generation failed: ${build_command_result}")
+			message(FATAL_ERROR "error_command: ${error_command}")
+		endif()
+	endif()
+
+	add_library(${target} SHARED 
+		${cimgui_SOURCE_DIR}/cimgui.cpp
+		${cimgui_SOURCE_DIR}/cimgui_impl.cpp
+		${cimgui_SOURCE_DIR}/imgui/imgui.cpp
+		${cimgui_SOURCE_DIR}/imgui/imgui_draw.cpp
+		${cimgui_SOURCE_DIR}/imgui/imgui_demo.cpp
+		${cimgui_SOURCE_DIR}/imgui/imgui_widgets.cpp
+		${cimgui_SOURCE_DIR}/imgui/imgui_tables.cpp
+		${cimgui_SOURCE_DIR}/imgui/backends/imgui_impl_${platbk}.cpp
+		${cimgui_SOURCE_DIR}/imgui/backends/imgui_impl_${rendbk}.cpp
+	)
+
+	target_include_directories(${target} PUBLIC ${cimgui_SOURCE_DIR} ${cimgui_SOURCE_DIR}/generator/output)
+	target_include_directories(${target} PRIVATE ${cimgui_SOURCE_DIR}/imgui ${cimgui_SOURCE_DIR}/imgui/backends)
+	#for ASSERT working on Release mode
+	target_compile_definitions(${target} PUBLIC "-DIMGUI_USER_CONFIG=\"../cimconfig.h\"")
+	target_compile_definitions(${target} PUBLIC "-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
+	if (WIN32)
+		target_compile_definitions(${target} PUBLIC "-DIMGUI_IMPL_API=extern \"C\" __declspec\(dllexport\)")
+	else(WIN32)
+		target_compile_definitions(${target} PUBLIC "-DIMGUI_IMPL_API=extern \"C\" ")
+	endif(WIN32)
+	target_compile_features(${target} PRIVATE cxx_std_11)
+endfunction()

backend_test/example_glfw_dx11/CMakeLists.txt

@@ -1,109 +1,45 @@
-Project(cimgui_glfwdx11)
 cmake_minimum_required(VERSION 3.11)
-if(WIN32) # to mingw work as all the others
-	set(CMAKE_SHARED_LIBRARY_PREFIX "")
-endif(WIN32)
+project(cimgui_glfwdx11 LANGUAGES C CXX)
 
-#run in build dir
-set (CMAKE_INSTALL_PREFIX ${CMAKE_CURRENT_BINARY_DIR})
+set(CMAKE_C_STANDARD 11)
 
-set (CMAKE_CXX_STANDARD 11)
-
-# general settings
-if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/../../imgui/backends)
-	set(BAKENDS_FOLDER "../../imgui/backends/")
-else()
-	set(BAKENDS_FOLDER "../../imgui/examples/")
-endif()
-
-if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/../../imgui/imgui_tables.cpp)
-	set(TABLES_SOURCE "../../imgui/imgui_tables.cpp")
-else()
-	set(TABLES_SOURCE "")
-endif()
-
-include_directories(../../imgui)
-add_definitions("-DIMGUI_USER_CONFIG=\"../cimconfig.h\"")
-add_definitions("-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
-
-include_directories(../../)
-set(IMGUI_SOURCES 
-../../cimgui.cpp 
-../../imgui/imgui.cpp 
-../../imgui/imgui_draw.cpp 
-../../imgui/imgui_demo.cpp 
-../../imgui/imgui_widgets.cpp
-${TABLES_SOURCE} 
-)
-
-set(IMGUI_LIBRARIES )
-
-if (WIN32)
-    add_definitions("-DIMGUI_IMPL_API=extern \"C\" __declspec\(dllexport\)")
-else(WIN32)
-    add_definitions("-DIMGUI_IMPL_API=extern \"C\" ")
-endif(WIN32)
-
-add_compile_definitions("IMGUI_IMPL_OPENGL_LOADER_GL3W")
-
-# optional adding freetype
-option(IMGUI_FREETYPE "add Freetype2" OFF)
-
-if(IMGUI_FREETYPE)
-	FIND_PACKAGE(freetype REQUIRED PATHS ${FREETYPE_PATH})
-	list(APPEND IMGUI_LIBRARIES freetype)
-	list(APPEND IMGUI_SOURCES ../../imgui/misc/freetype/imgui_freetype.cpp)
-	add_definitions("-DCIMGUI_FREETYPE=1")
-endif(IMGUI_FREETYPE)
-
-# dx11
-list(APPEND IMGUI_SOURCES ${BAKENDS_FOLDER}imgui_impl_dx11.cpp)
-
-if(WIN32)
-       list(APPEND IMGUI_LIBRARIES opengl32)
-else(WIN32) # Unix
-       list(APPEND IMGUI_LIBRARIES GL)
-endif(WIN32)
-
-# GLFW
-list(APPEND IMGUI_SOURCES ${BAKENDS_FOLDER}imgui_impl_glfw.cpp)
+include(FetchContent)
 
 set(GLFW_VERSION 3.3.8)
-include(FetchContent)
-	FetchContent_Declare(
+FetchContent_Declare(
     glfw
-    URL https://github.com/glfw/glfw/archive/refs/tags/${GLFW_VERSION}.tar.gz)
+    EXCLUDE_FROM_ALL
+    URL https://github.com/glfw/glfw/archive/refs/tags/${GLFW_VERSION}.tar.gz
+    GIT_PROGRESS true)
 
-FetchContent_GetProperties(glfw)
-if (NOT glfw_POPULATED)
-	set(FETCHCONTENT_QUIET NO)
-    FetchContent_Populate(glfw)
-	set(GLFW_BUILD_DOCS OFF CACHE BOOL "" FORCE)
-	set(GLFW_BUILD_TESTS OFF CACHE BOOL "" FORCE)
-	set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
-	if (NOT STATIC_BUILD)
+set(GLFW_BUILD_DOCS OFF CACHE BOOL "" FORCE)
+set(GLFW_BUILD_TESTS OFF CACHE BOOL "" FORCE)
+set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
+if (NOT STATIC_BUILD)
 	set(BUILD_SHARED_LIBS ON CACHE BOOL "" FORCE)
-	endif()
-	add_subdirectory(${glfw_SOURCE_DIR} ${glfw_BINARY_DIR} EXCLUDE_FROM_ALL)
 endif()
 
+
+FetchContent_MakeAvailable(glfw)
 install(TARGETS glfw RUNTIME DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
 					LIBRARY DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
 )
-#FIND_PACKAGE(glfw3 PATHS "C:/LuaGL/gitsources/BUILDS/GLFW/install")
 
-if (NOT STATIC_BUILD)
-  add_library(cimgui SHARED ${IMGUI_SOURCES})
-else()
-  add_library(cimgui STATIC ${IMGUI_SOURCES})
-endif()
+include(../cmake/GenerateCimguiBindings.cmake)
 
-target_link_libraries(cimgui ${IMGUI_LIBRARIES} glfw)
-
-
-# using library
-add_executable(${PROJECT_NAME} main.c)
-target_compile_definitions(${PROJECT_NAME} PUBLIC -DCIMGUI_USE_DX11 -DCIMGUI_USE_GLFW)
-target_link_libraries(${PROJECT_NAME} d3d11 d3dcompiler.lib cimgui)
+set(inclulist "")
+GenerateCimguiBindings(cimgui_with_backend "glfw" dx11 inclulist)
+target_link_libraries(cimgui_with_backend PRIVATE glfw d3dcompiler dwmapi)
 
+add_executable(${PROJECT_NAME} 
+	main.c
+)
 
+target_link_libraries(${PROJECT_NAME} PRIVATE glfw cimgui_with_backend d3d11 d3dcompiler dwmapi)
+target_compile_definitions(
+	${PROJECT_NAME}
+	PRIVATE 
+	CIMGUI_DEFINE_ENUMS_AND_STRUCTS=1
+	CIMGUI_USE_GLFW=1
+	CIMGUI_USE_DX11=1
+)

backend_test/example_glfw_dx11/README.md

@@ -1,6 +1,7 @@
+# GLFWDX11
 
-This example needs dx11 in generation before compile. (add dx11 to generator.bat(sh) and generate)
+This example needs dx11 in generation before compile.
+Generation will be done from cmake but you need LuaJIT in the system.
 
 `STATIC_BUILD` is the cmake variable to do static linking
 
-Only tested with VC nmake.

backend_test/example_glfw_dx11/main.c

@@ -1,4 +1,4 @@
-#define CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+//#define CIMGUI_DEFINE_ENUMS_AND_STRUCTS is done in cmake
 #include "cimgui.h"
 #include "cimgui_impl.h"
 #define D3D11_NO_HELPERS
@@ -24,6 +24,8 @@
 #define igButton igButton_Str
 #endif
 
+#define igGetIO igGetIO_Nil
+
 GLFWwindow *window;
 
 // Data

backend_test/example_glfw_opengl3/CMakeLists.txt

@@ -45,10 +45,13 @@ add_compile_definitions("IMGUI_IMPL_OPENGL_LOADER_GL3W")
 option(IMGUI_FREETYPE "add Freetype2" OFF)
 
 if(IMGUI_FREETYPE)
+	message("building with freetype")
 	FIND_PACKAGE(freetype REQUIRED PATHS ${FREETYPE_PATH})
 	list(APPEND IMGUI_LIBRARIES freetype)
 	list(APPEND IMGUI_SOURCES ../../imgui/misc/freetype/imgui_freetype.cpp)
-	add_definitions("-DCIMGUI_FREETYPE=1")
+	#add_definitions("-DCIMGUI_FREETYPE=1")
+	add_definitions("-DIMGUI_ENABLE_FREETYPE=1")
+	add_definitions("-DIMGUI_ENABLE_STB_TRUETYPE=1")
 endif(IMGUI_FREETYPE)
 
 # opengl3

backend_test/example_glfw_opengl3/main.c

@@ -17,6 +17,8 @@
 #define igButton igButton_Str
 #endif
 
+#define igGetIO igGetIO_Nil
+
 GLFWwindow *window;
 
 int main(int argc, char *argv[])
@@ -41,8 +43,9 @@ int main(int argc, char *argv[])
 
   // just an extra window hint for resize
   glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
+  float main_scale = ImGui_ImplGlfw_GetContentScaleForMonitor(glfwGetPrimaryMonitor()); // Valid on GLFW 3.3+ only
+  window = glfwCreateWindow((int)(1280 * main_scale), (int)(800 * main_scale), "Dear ImGui GLFW+OpenGL3 example", NULL, NULL);
 
-  window = glfwCreateWindow(1024, 768, "Hello World!", NULL, NULL);
   if (!window) 
   {
     printf("Failed to create window! Terminating!\n");
@@ -70,6 +73,15 @@ int main(int argc, char *argv[])
   ioptr->ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;     // Enable Multi-Viewport / Platform Windows
 #endif
 
+
+    // Setup scaling
+    ImGuiStyle* style = igGetStyle();
+    ImGuiStyle_ScaleAllSizes(style, main_scale);        // Bake a fixed style scale. (until we have a solution for dynamic style scaling, changing this requires resetting Style + calling this again)
+    style->FontScaleDpi = main_scale;        // Set initial font scale. (using io.ConfigDpiScaleFonts=true makes this unnecessary. We leave both here for documentation purpose)
+#if GLFW_VERSION_MAJOR >= 3 && GLFW_VERSION_MINOR >= 3
+    ioptr->ConfigDpiScaleFonts = true;          // [Experimental] Automatically overwrite style.FontScaleDpi in Begin() when Monitor DPI changes. This will scale fonts but _NOT_ scale sizes/padding for now.
+    ioptr->ConfigDpiScaleViewports = true;      // [Experimental] Scale Dear ImGui and Platform Windows when Monitor DPI changes.
+#endif
   ImGui_ImplGlfw_InitForOpenGL(window, true);
   ImGui_ImplOpenGL3_Init(glsl_version);
 

backend_test/example_sdl3_vulkan/CMakeLists.txt

@@ -0,0 +1,100 @@
+cmake_minimum_required(VERSION 2.8)
+Project(cimgui_sdl3_vk)
+if(WIN32) # to make mingw work as all the others
+set(CMAKE_SHARED_LIBRARY_PREFIX "")
+endif(WIN32)
+# general settings
+
+
+if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/../../imgui/backends)
+	set(BACKENDS_FOLDER "../../imgui/backends/")
+else()
+	set(BACKENDS_FOLDER "../../imgui/examples/")
+endif()
+
+if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/../../imgui/imgui_tables.cpp)
+	set(TABLES_SOURCE "../../imgui/imgui_tables.cpp")
+else()
+	set(TABLES_SOURCE "")
+endif()
+
+include_directories(../../imgui ../../imgui/backends)
+
+
+include_directories(../../)
+set(IMGUI_SOURCES ../../cimgui.cpp
+../../cimgui_impl.cpp
+../../imgui/imgui.cpp
+../../imgui/imgui_draw.cpp
+../../imgui/imgui_demo.cpp
+../../imgui/imgui_widgets.cpp
+${TABLES_SOURCE}
+)
+
+set(IMGUI_SOURCES_sdl)
+set(IMGUI_LIBRARIES )
+
+
+#optional adding freetype
+option(IMGUI_FREETYPE "add Freetype2" OFF)
+
+if(IMGUI_FREETYPE)
+	FIND_PACKAGE(freetype REQUIRED PATHS ${FREETYPE_PATH})
+	list(APPEND IMGUI_LIBRARIES freetype)
+	list(APPEND IMGUI_SOURCES ../../imgui/misc/freetype/imgui_freetype.cpp)
+	add_definitions("-DCIMGUI_FREETYPE=1")
+endif(IMGUI_FREETYPE)
+
+# vulkan
+find_package(Vulkan REQUIRED FATAL_ERROR)
+list(APPEND IMGUI_LIBRARIES Vulkan::Vulkan)
+list(APPEND IMGUI_SOURCES ${BACKENDS_FOLDER}imgui_impl_vulkan.cpp)
+include_directories(${Vulkan_INCLUDE_DIRS})
+
+#sdl3
+list(APPEND IMGUI_SOURCES ${BACKENDS_FOLDER}imgui_impl_sdl3.cpp)
+include(FetchContent)
+Set(FETCHCONTENT_QUIET FALSE)
+
+FetchContent_Declare(
+        SDL3
+        GIT_REPOSITORY https://github.com/libsdl-org/SDL.git
+        GIT_TAG release-3.2.8
+        #GIT_SHALLOW TRUE
+        GIT_PROGRESS TRUE
+)
+FetchContent_GetProperties(SDL3)
+if (NOT sdl3_POPULATED)
+	set(FETCHCONTENT_QUIET NO)
+    FetchContent_Populate(SDL3)
+	set(SDL_TEST OFF CACHE BOOL "" FORCE)
+	set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
+	add_subdirectory(${sdl3_SOURCE_DIR} ${sdl3_BINARY_DIR})
+endif()
+include_directories(${SDL3_SOURCE_DIR}/include)
+
+
+#if dynamic SDL3 then install
+# install(TARGETS SDL3 RUNTIME DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
+					# LIBRARY DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
+# )
+
+add_library(cimgui_sdl STATIC ${IMGUI_SOURCES})
+target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_USER_CONFIG=\"../cimconfig.h\"")
+target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
+target_compile_definitions(cimgui_sdl PUBLIC -DCIMGUI_USE_VULKAN -DCIMGUI_USE_SDL3)
+if (WIN32)
+    target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_IMPL_API=extern \"C\" __declspec\(dllexport\)")
+else(WIN32)
+    target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_IMPL_API=extern \"C\" ")
+endif(WIN32)
+#target_link_libraries(cimgui_sdl ${IMGUI_LIBRARIES} SDL3-static)
+
+#using library
+add_executable(test_sdl main.c)
+target_compile_definitions(test_sdl PUBLIC -DCIMGUI_USE_VULKAN -DCIMGUI_USE_SDL3)
+if (MINGW)
+target_link_options(test_sdl PRIVATE "-mconsole")
+endif()
+target_link_libraries(test_sdl SDL3-static cimgui_sdl ${IMGUI_LIBRARIES})
+

backend_test/example_sdl3_vulkan/README.md

@@ -0,0 +1,2 @@
+
+To build use `cmake path_to_example_sdl3_vulkan` and then `make install`

backend_test/example_sdl3_vulkan/main.c

@@ -0,0 +1,630 @@
+#include <stdio.h>          // printf, fprintf
+#include <stdlib.h>         // abort
+#include <assert.h>
+#define SDL_MAIN_HANDLED
+#include <SDL3/SDL.h>
+#include <SDL3/SDL_vulkan.h>
+#include <vulkan/vulkan.h>
+// Volk headers
+#ifdef IMGUI_IMPL_VULKAN_USE_VOLK
+#define VOLK_IMPLEMENTATION
+#include <volk.h>
+#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 CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+#include <cimgui.h>
+#include <cimgui_impl.h>
+
+#ifdef IMGUI_HAS_IMSTR
+#define igBegin igBegin_Str
+#define igSliderFloat igSliderFloat_Str
+#define igCheckbox igCheckbox_Str
+#define igColorEdit3 igColorEdit3_Str
+#define igButton igButton_Str
+#endif
+
+#define igGetIO igGetIO_Nil
+
+#define IM_UNUSED(_VAR)  ((void)(_VAR))
+#define IM_ASSERT(_EXPR) assert(_EXPR)
+#define IM_ARRAYSIZE(_ARR) ((int)(sizeof(_ARR) / sizeof(*(_ARR))))
+
+//#define APP_USE_UNLIMITED_FRAME_RATE
+#ifdef _DEBUG
+#define APP_USE_VULKAN_DEBUG_REPORT
+#endif
+#define APP_USE_VULKAN_DEBUG_REPORT
+// Data
+static VkAllocationCallbacks*   g_Allocator = NULL;
+static VkInstance               g_Instance = VK_NULL_HANDLE;
+static VkPhysicalDevice         g_PhysicalDevice = VK_NULL_HANDLE;
+static VkDevice                 g_Device = VK_NULL_HANDLE;
+static uint32_t                 g_QueueFamily = (uint32_t)-1;
+static VkQueue                  g_Queue = VK_NULL_HANDLE;
+static VkDebugReportCallbackEXT g_DebugReport = VK_NULL_HANDLE;
+static VkPipelineCache          g_PipelineCache = VK_NULL_HANDLE;
+static VkDescriptorPool         g_DescriptorPool = VK_NULL_HANDLE;
+
+static ImGui_ImplVulkanH_Window g_MainWindowData;
+static uint32_t                 g_MinImageCount = 2;
+static bool                     g_SwapChainRebuild = false;
+
+static void check_vk_result(VkResult err)
+{
+    if (err == VK_SUCCESS)
+        return;
+    fprintf(stderr, "[vulkan] Error: VkResult = %d\n", err);
+    if (err < 0)
+        abort();
+}
+
+static void check_vk_result_line(VkResult err,int line)
+{
+    if (err == VK_SUCCESS)
+        return;
+    fprintf(stderr, "[vulkan] Error: VkResult = %d in line: (%d)\n", err, line);
+    if (err < 0)
+        abort();
+}
+
+#ifdef APP_USE_VULKAN_DEBUG_REPORT
+static VKAPI_ATTR VkBool32 VKAPI_CALL debug_report(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, void* pUserData)
+{
+    (void)flags; (void)object; (void)location; (void)messageCode; (void)pUserData; (void)pLayerPrefix; // Unused arguments
+    fprintf(stderr, "[vulkan] Debug report from ObjectType: %i\nMessage: %s\n\n", objectType, pMessage);
+    return VK_FALSE;
+}
+#endif // APP_USE_VULKAN_DEBUG_REPORT
+//*
+static bool IsExtensionAvailable(VkExtensionProperties* properties, uint32_t properties_count, const char* extension)
+{
+    for(uint32_t i = 0 ; i < properties_count; i++){
+        if (strcmp(properties[i].extensionName, extension) == 0)
+            return true;
+    }
+    return false;
+}
+
+static void SetupVulkan(const char** extensions, uint32_t extensions_count)
+{
+    VkResult err;
+#ifdef IMGUI_IMPL_VULKAN_USE_VOLK
+    volkInitialize();
+#endif
+
+    // Create Vulkan Instance
+    {
+        VkInstanceCreateInfo create_info = {};
+        create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+
+        // Enumerate available extensions
+        uint32_t properties_count;
+        vkEnumerateInstanceExtensionProperties(NULL, &properties_count, NULL);
+        VkExtensionProperties* properties = (VkExtensionProperties*)malloc(properties_count * sizeof(VkExtensionProperties));
+        err = vkEnumerateInstanceExtensionProperties(NULL, &properties_count, properties);
+        check_vk_result_line(err, __LINE__);
+
+        // Enable required extensions
+        if (IsExtensionAvailable(properties, properties_count, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)){
+            //instance_extensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+            extensions_count++;
+            extensions = realloc(extensions, extensions_count * sizeof(char*));
+            assert(extensions);
+            extensions[extensions_count-1] = VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME;
+        }
+#ifdef VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME
+        if (IsExtensionAvailable(properties, properties_count, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME))
+        {
+            //instance_extensions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
+            extensions_count++;
+            extensions = realloc(extensions, extensions_count * sizeof(char*));
+            assert(extensions);
+            extensions[extensions_count-1] = VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME;
+            create_info.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
+        }
+#endif
+        free(properties);
+        // Enabling validation layers
+#ifdef APP_USE_VULKAN_DEBUG_REPORT
+        const char* layers[] = { "VK_LAYER_KHRONOS_validation" };
+        create_info.enabledLayerCount = 1;
+        create_info.ppEnabledLayerNames = layers;
+        //instance_extensions.push_back("VK_EXT_debug_report");
+        extensions_count++;
+        extensions = realloc(extensions, extensions_count * sizeof(char*));
+        assert(extensions);
+        extensions[extensions_count-1] = "VK_EXT_debug_report";
+#endif
+
+        // Create Vulkan Instance
+        create_info.enabledExtensionCount = extensions_count;//(uint32_t)instance_extensions.Size;
+        create_info.ppEnabledExtensionNames = extensions;//instance_extensions.Data;
+        err = vkCreateInstance(&create_info, g_Allocator, &g_Instance);
+        check_vk_result_line(err, __LINE__);
+#ifdef IMGUI_IMPL_VULKAN_USE_VOLK
+        volkLoadInstance(g_Instance);
+#endif
+
+        // Setup the debug report callback
+#ifdef APP_USE_VULKAN_DEBUG_REPORT
+        PFN_vkCreateDebugReportCallbackEXT f_vkCreateDebugReportCallbackEXT = (PFN_vkCreateDebugReportCallbackEXT)vkGetInstanceProcAddr(g_Instance, "vkCreateDebugReportCallbackEXT");
+        IM_ASSERT(f_vkCreateDebugReportCallbackEXT != NULL);
+        VkDebugReportCallbackCreateInfoEXT debug_report_ci = {};
+        debug_report_ci.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
+        debug_report_ci.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT | VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT;
+        debug_report_ci.pfnCallback = debug_report;
+        debug_report_ci.pUserData = NULL;
+        err = f_vkCreateDebugReportCallbackEXT(g_Instance, &debug_report_ci, g_Allocator, &g_DebugReport);
+        check_vk_result_line(err, __LINE__);
+#endif
+    }
+    // Select Physical Device (GPU)
+    g_PhysicalDevice = ImGui_ImplVulkanH_SelectPhysicalDevice(g_Instance);
+    IM_ASSERT(g_PhysicalDevice != VK_NULL_HANDLE);
+    // Select graphics queue family
+    g_QueueFamily = ImGui_ImplVulkanH_SelectQueueFamilyIndex(g_PhysicalDevice);
+    IM_ASSERT(g_QueueFamily != (uint32_t)-1);
+
+    // Create Logical Device (with 1 queue)
+    {
+        //ImVector<const char*> device_extensions;
+        //device_extensions.push_back("VK_KHR_swapchain");
+        uint32_t device_extensions_count = 1;
+        const char** device_extensions = (const char**)malloc(device_extensions_count * sizeof(char*));
+        device_extensions[0] = "VK_KHR_swapchain";
+
+        // Enumerate physical device extension
+        uint32_t properties_count;
+        //ImVector<VkExtensionProperties> properties;
+        vkEnumerateDeviceExtensionProperties(g_PhysicalDevice, NULL, &properties_count, NULL);
+        //properties.resize(properties_count);
+        VkExtensionProperties* properties = (VkExtensionProperties*)malloc(properties_count * sizeof(VkExtensionProperties));
+        vkEnumerateDeviceExtensionProperties(g_PhysicalDevice, NULL, &properties_count, properties);
+#ifdef VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME
+        if (IsExtensionAvailable(properties, properties_count, VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME)){
+            //device_extensions.push_back(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME);
+            device_extensions_count++;
+            device_extensions = realloc(device_extensions, device_extensions_count * sizeof(const char*));
+            assert(device_extensions);
+            device_extensions[device_extensions_count-1] = VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME;
+        }
+#endif
+
+        const float queue_priority[] = { 1.0f };
+        VkDeviceQueueCreateInfo queue_info[1] = {};
+        queue_info[0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+        queue_info[0].queueFamilyIndex = g_QueueFamily;
+        queue_info[0].queueCount = 1;
+        queue_info[0].pQueuePriorities = queue_priority;
+        VkDeviceCreateInfo create_info = {};
+        create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+        create_info.queueCreateInfoCount = sizeof(queue_info) / sizeof(queue_info[0]);
+        create_info.pQueueCreateInfos = queue_info;
+        create_info.enabledExtensionCount = device_extensions_count; //(uint32_t)device_extensions.Size;
+        create_info.ppEnabledExtensionNames = device_extensions;//device_extensions.Data;
+        err = vkCreateDevice(g_PhysicalDevice, &create_info, g_Allocator, &g_Device);
+        check_vk_result_line(err, __LINE__);
+        vkGetDeviceQueue(g_Device, g_QueueFamily, 0, &g_Queue);
+    }
+    // Create Descriptor Pool
+    // If you wish to load e.g. additional textures you may need to alter pools sizes and maxSets.
+    {
+        VkDescriptorPoolSize pool_sizes[] =
+        {
+            { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, IMGUI_IMPL_VULKAN_MINIMUM_IMAGE_SAMPLER_POOL_SIZE },
+        };
+        VkDescriptorPoolCreateInfo pool_info = {};
+        pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+        pool_info.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
+        pool_info.maxSets = 0;
+        //for (VkDescriptorPoolSize& pool_size : pool_sizes)
+        //    pool_info.maxSets += pool_size.descriptorCount;
+        for(int i = 0; i < IM_ARRAYSIZE(pool_sizes); i++){
+            VkDescriptorPoolSize pool_size = pool_sizes[i];
+            pool_info.maxSets += pool_size.descriptorCount;
+        }
+        pool_info.poolSizeCount = (uint32_t)IM_ARRAYSIZE(pool_sizes);
+        pool_info.pPoolSizes = pool_sizes;
+        err = vkCreateDescriptorPool(g_Device, &pool_info, g_Allocator, &g_DescriptorPool);
+        check_vk_result_line(err, __LINE__);
+    }
+}
+//*/
+// All the ImGui_ImplVulkanH_XXX structures/functions are optional helpers used by the demo.
+// Your real engine/app may not use them.
+static void SetupVulkanWindow(ImGui_ImplVulkanH_Window* wd, VkSurfaceKHR surface, int width, int height)
+{
+    wd->Surface = surface;
+
+    // Check for WSI support
+    VkBool32 res;
+    vkGetPhysicalDeviceSurfaceSupportKHR(g_PhysicalDevice, g_QueueFamily, wd->Surface, &res);
+    if (res != VK_TRUE)
+    {
+        fprintf(stderr, "Error no WSI support on physical device 0\n");
+        exit(-1);
+    }
+
+    // Select Surface Format
+    const VkFormat requestSurfaceImageFormat[] = { VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_B8G8R8_UNORM, VK_FORMAT_R8G8B8_UNORM };
+    const VkColorSpaceKHR requestSurfaceColorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
+    wd->SurfaceFormat = ImGui_ImplVulkanH_SelectSurfaceFormat(g_PhysicalDevice, wd->Surface, requestSurfaceImageFormat, (size_t)IM_ARRAYSIZE(requestSurfaceImageFormat), requestSurfaceColorSpace);
+
+    // Select Present Mode
+#ifdef APP_USE_UNLIMITED_FRAME_RATE
+    VkPresentModeKHR present_modes[] = { VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_FIFO_KHR };
+#else
+    VkPresentModeKHR present_modes[] = { VK_PRESENT_MODE_FIFO_KHR };
+#endif
+    wd->PresentMode = ImGui_ImplVulkanH_SelectPresentMode(g_PhysicalDevice, wd->Surface, &present_modes[0], IM_ARRAYSIZE(present_modes));
+    //printf("[vulkan] Selected PresentMode = %d\n", wd->PresentMode);
+
+    // Create SwapChain, RenderPass, Framebuffer, etc.
+    IM_ASSERT(g_MinImageCount >= 2);
+    ImGui_ImplVulkanH_CreateOrResizeWindow(g_Instance, g_PhysicalDevice, g_Device, wd, g_QueueFamily, g_Allocator, width, height, g_MinImageCount);
+}
+
+static void CleanupVulkan()
+{
+    vkDestroyDescriptorPool(g_Device, g_DescriptorPool, g_Allocator);
+
+#ifdef APP_USE_VULKAN_DEBUG_REPORT
+    // Remove the debug report callback
+    PFN_vkDestroyDebugReportCallbackEXT f_vkDestroyDebugReportCallbackEXT = (PFN_vkDestroyDebugReportCallbackEXT)vkGetInstanceProcAddr(g_Instance, "vkDestroyDebugReportCallbackEXT");
+    f_vkDestroyDebugReportCallbackEXT(g_Instance, g_DebugReport, g_Allocator);
+#endif // APP_USE_VULKAN_DEBUG_REPORT
+
+    vkDestroyDevice(g_Device, g_Allocator);
+    vkDestroyInstance(g_Instance, g_Allocator);
+}
+
+static void CleanupVulkanWindow()
+{
+    ImGui_ImplVulkanH_DestroyWindow(g_Instance, g_Device, &g_MainWindowData, g_Allocator);
+}
+
+static void FrameRender(ImGui_ImplVulkanH_Window* wd, ImDrawData* draw_data)
+{
+    VkSemaphore image_acquired_semaphore  = wd->FrameSemaphores.Data[wd->SemaphoreIndex].ImageAcquiredSemaphore;
+    VkSemaphore render_complete_semaphore = wd->FrameSemaphores.Data[wd->SemaphoreIndex].RenderCompleteSemaphore;
+    VkResult err = vkAcquireNextImageKHR(g_Device, wd->Swapchain, UINT64_MAX, image_acquired_semaphore, VK_NULL_HANDLE, &wd->FrameIndex);
+    if (err == VK_ERROR_OUT_OF_DATE_KHR || err == VK_SUBOPTIMAL_KHR)
+        g_SwapChainRebuild = true;
+    if (err == VK_ERROR_OUT_OF_DATE_KHR)
+        return;
+    if (err != VK_SUBOPTIMAL_KHR)
+        check_vk_result_line(err, __LINE__);
+
+    ImGui_ImplVulkanH_Frame* fd = &wd->Frames.Data[wd->FrameIndex];
+    {
+        err = vkWaitForFences(g_Device, 1, &fd->Fence, VK_TRUE, UINT64_MAX);    // wait indefinitely instead of periodically checking
+        check_vk_result_line(err, __LINE__);
+
+        err = vkResetFences(g_Device, 1, &fd->Fence);
+        check_vk_result_line(err, __LINE__);
+    }
+    {
+        err = vkResetCommandPool(g_Device, fd->CommandPool, 0);
+        check_vk_result_line(err, __LINE__);
+        VkCommandBufferBeginInfo info = {};
+        info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+        info.flags |= VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+        err = vkBeginCommandBuffer(fd->CommandBuffer, &info);
+        check_vk_result_line(err, __LINE__);
+    }
+    {
+        VkRenderPassBeginInfo info = {};
+        info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
+        info.renderPass = wd->RenderPass;
+        info.framebuffer = fd->Framebuffer;
+        info.renderArea.extent.width = wd->Width;
+        info.renderArea.extent.height = wd->Height;
+        info.clearValueCount = 1;
+        info.pClearValues = &wd->ClearValue;
+        vkCmdBeginRenderPass(fd->CommandBuffer, &info, VK_SUBPASS_CONTENTS_INLINE);
+    }
+
+    // Record dear imgui primitives into command buffer
+    ImGui_ImplVulkan_RenderDrawData(draw_data, fd->CommandBuffer, VK_NULL_HANDLE);
+
+    // Submit command buffer
+    vkCmdEndRenderPass(fd->CommandBuffer);
+    {
+        VkPipelineStageFlags wait_stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+        VkSubmitInfo info = {};
+        info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+        info.waitSemaphoreCount = 1;
+        info.pWaitSemaphores = &image_acquired_semaphore;
+        info.pWaitDstStageMask = &wait_stage;
+        info.commandBufferCount = 1;
+        info.pCommandBuffers = &fd->CommandBuffer;
+        info.signalSemaphoreCount = 1;
+        info.pSignalSemaphores = &render_complete_semaphore;
+
+        err = vkEndCommandBuffer(fd->CommandBuffer);
+        check_vk_result_line(err, __LINE__);
+        err = vkQueueSubmit(g_Queue, 1, &info, fd->Fence);
+        check_vk_result_line(err, __LINE__);
+    }
+}
+
+static void FramePresent(ImGui_ImplVulkanH_Window* wd)
+{
+    if (g_SwapChainRebuild)
+        return;
+    VkSemaphore render_complete_semaphore = wd->FrameSemaphores.Data[wd->SemaphoreIndex].RenderCompleteSemaphore;
+    VkPresentInfoKHR info = {};
+    info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
+    info.waitSemaphoreCount = 1;
+    info.pWaitSemaphores = &render_complete_semaphore;
+    info.swapchainCount = 1;
+    info.pSwapchains = &wd->Swapchain;
+    info.pImageIndices = &wd->FrameIndex;
+    VkResult err = vkQueuePresentKHR(g_Queue, &info);
+    if (err == VK_ERROR_OUT_OF_DATE_KHR || err == VK_SUBOPTIMAL_KHR)
+        g_SwapChainRebuild = true;
+    if (err == VK_ERROR_OUT_OF_DATE_KHR)
+        return;
+    if (err != VK_SUBOPTIMAL_KHR)
+        check_vk_result_line(err, __LINE__);
+    wd->SemaphoreIndex = (wd->SemaphoreIndex + 1) % wd->SemaphoreCount; // Now we can use the next set of semaphores
+}
+
+// Main code
+int main(int argc, char* argv[])
+{
+    //g_MainWindowData.ClearEnable = true;
+	//ImGui_ImplVulkanH_Window_Construct(&g_MainWindowData);
+	g_MainWindowData = *ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window();
+    // Setup SDL
+    if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMEPAD))
+    {
+        printf("Error: SDL_Init(): %s\n", SDL_GetError());
+        return -1;
+    }
+
+    // From 2.0.18: Enable native IME.
+#ifdef SDL_HINT_IME_SHOW_UI
+    SDL_SetHint(SDL_HINT_IME_SHOW_UI, "1");
+#endif
+
+    // Create window with Vulkan graphics context
+    float main_scale = SDL_GetDisplayContentScale(SDL_GetPrimaryDisplay());
+    SDL_WindowFlags window_flags = SDL_WINDOW_VULKAN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIDDEN | SDL_WINDOW_HIGH_PIXEL_DENSITY;
+    SDL_Window* window = SDL_CreateWindow("Dear ImGui SDL3+Vulkan example", (int)(1280 * main_scale), (int)(720 * main_scale), window_flags);
+    if (window == NULL)
+    {
+        printf("Error: SDL_CreateWindow(): %s\n", SDL_GetError());
+        return -1;
+    }
+  // Setup Vulkan
+  uint32_t extensions_count = 0;
+  const char *const *extensions_nude = SDL_Vulkan_GetInstanceExtensions(&extensions_count);
+  if (extensions_nude == NULL) {
+    printf("Error: SDL_Vulkan_GetInstanceExtensions(): %s\n", SDL_GetError());
+    return -1;
+  }
+  const char** extensions = (const char**)malloc(extensions_count * sizeof(const char*));
+  if (extensions == NULL) {
+    printf("Error allocating space for extensions array\n");
+    return -1;
+  }
+  for (int i = 0; i < extensions_count; i++) {
+    extensions[i] = extensions_nude[i];
+  }
+  SetupVulkan(extensions, extensions_count);
+  //leak?? but free crashes
+  // free(extensions);
+    // Create Window Surface
+    VkSurfaceKHR surface;
+    VkResult err;
+    if (SDL_Vulkan_CreateSurface(window, g_Instance, g_Allocator, &surface) == 0)
+    {
+        printf("Failed to create Vulkan surface.\n");
+        return 1;
+    }
+
+    // Create Framebuffers
+    int w, h;
+    SDL_GetWindowSize(window, &w, &h);
+    ImGui_ImplVulkanH_Window* wd = &g_MainWindowData;
+    SetupVulkanWindow(wd, surface, w, h);
+    SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
+    SDL_ShowWindow(window);
+
+    // Setup Dear ImGui context
+    //IMGUI_CHECKVERSION();
+    igCreateContext(NULL);
+    ImGuiIO* io = igGetIO(); (void)io;
+    io->ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;     // Enable Keyboard Controls
+    io->ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;      // Enable Gamepad Controls
+    io->ConfigFlags |= ImGuiConfigFlags_DockingEnable;         // Enable Docking
+    io->ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;       // Enable Multi-Viewport / Platform Windows
+    //io.ConfigFlags |= ImGuiConfigFlags_ViewportsNoTaskBarIcons;
+    //io.ConfigFlags |= ImGuiConfigFlags_ViewportsNoMerge;
+
+    // Setup Dear ImGui style
+    igStyleColorsDark(NULL);
+    //ImGui::StyleColorsLight();
+
+    // When viewports are enabled we tweak WindowRounding/WindowBg so platform windows can look identical to regular ones.
+    ImGuiStyle* style = igGetStyle();
+    ImGuiStyle_ScaleAllSizes(style, main_scale);        // Bake a fixed style scale. (until we have a solution for dynamic style scaling, changing this requires resetting Style + calling this again)
+    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.
+    if (io->ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+    {
+        style->WindowRounding = 0.0f;
+        style->Colors[ImGuiCol_WindowBg].w = 1.0f;
+    }
+
+    // Setup Platform/Renderer backends
+    ImGui_ImplSDL3_InitForVulkan(window);
+    ImGui_ImplVulkan_InitInfo init_info = {};
+    init_info.Instance = g_Instance;
+    init_info.PhysicalDevice = g_PhysicalDevice;
+    init_info.Device = g_Device;
+    init_info.QueueFamily = g_QueueFamily;
+    init_info.Queue = g_Queue;
+    init_info.PipelineCache = g_PipelineCache;
+    init_info.DescriptorPool = g_DescriptorPool;
+    init_info.RenderPass = wd->RenderPass;
+    init_info.Subpass = 0;
+    init_info.MinImageCount = g_MinImageCount;
+    init_info.ImageCount = wd->ImageCount;
+    init_info.MSAASamples = VK_SAMPLE_COUNT_1_BIT;
+    init_info.Allocator = g_Allocator;
+    init_info.CheckVkResultFn = check_vk_result;
+    ImGui_ImplVulkan_Init(&init_info);
+
+    // Load Fonts
+    // - If no fonts are loaded, dear imgui will use the default font. You can also load multiple fonts and use ImGui::PushFont()/PopFont() to select them.
+    // - AddFontFromFileTTF() will return the ImFont* so you can store it if you need to select the font among multiple.
+    // - If the file cannot be loaded, the function will return a nullptr. Please handle those errors in your application (e.g. use an assertion, or display an error and quit).
+    // - The fonts will be rasterized at a given size (w/ oversampling) and stored into a texture when calling ImFontAtlas::Build()/GetTexDataAsXXXX(), which ImGui_ImplXXXX_NewFrame below will call.
+    // - Use '#define IMGUI_ENABLE_FREETYPE' in your imconfig file to use Freetype for higher quality font rendering.
+    // - Read 'docs/FONTS.md' for more instructions and details.
+    // - Remember that in C/C++ if you want to include a backslash \ in a string literal you need to write a double backslash \\ !
+    //io.Fonts->AddFontDefault();
+    //io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\segoeui.ttf", 18.0f);
+    //io.Fonts->AddFontFromFileTTF("../../misc/fonts/DroidSans.ttf", 16.0f);
+    //io.Fonts->AddFontFromFileTTF("../../misc/fonts/Roboto-Medium.ttf", 16.0f);
+    //io.Fonts->AddFontFromFileTTF("../../misc/fonts/Cousine-Regular.ttf", 15.0f);
+    //ImFont* font = io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, nullptr, io.Fonts->GetGlyphRangesJapanese());
+    //IM_ASSERT(font != nullptr);
+
+    // 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.
+        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 (SDL_GetWindowFlags(window) & SDL_WINDOW_MINIMIZED)
+        {
+            SDL_Delay(10);
+            continue;
+        }
+
+        // Resize swap chain?
+        int fb_width, fb_height;
+        SDL_GetWindowSize(window, &fb_width, &fb_height);
+        if (fb_width > 0 && fb_height > 0 && (g_SwapChainRebuild || g_MainWindowData.Width != fb_width || g_MainWindowData.Height != fb_height))
+        {
+            ImGui_ImplVulkan_SetMinImageCount(g_MinImageCount);
+            ImGui_ImplVulkanH_CreateOrResizeWindow(g_Instance, g_PhysicalDevice, g_Device, &g_MainWindowData, g_QueueFamily, g_Allocator, fb_width, fb_height, g_MinImageCount);
+            g_MainWindowData.FrameIndex = 0;
+            g_SwapChainRebuild = false;
+        }
+
+        // Start the Dear ImGui frame
+        ImGui_ImplVulkan_NewFrame();
+        ImGui_ImplSDL3_NewFrame();
+        igNewFrame();
+
+        // 1. Show the big demo window (Most of the sample code is in ImGui::ShowDemoWindow()! 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);
+            igText("This is some useful text");
+            igCheckbox("Demo window", &show_demo_window);
+            igCheckbox("Another window", &show_another_window);
+
+            igSliderFloat("Float", &f, 0.0f, 1.0f, "%.3f", 0);
+            igColorEdit3("clear color", (float*)&clear_color, 0);
+
+            ImVec2 buttonSize;
+            buttonSize.x = 0;
+            buttonSize.y = 0;
+            if (igButton("Button", buttonSize))
+              counter++;
+            igSameLine(0.0f, -1.0f);
+            igText("counter = %d", counter);
+
+            igText("Application average %.3f ms/frame (%.1f FPS)",
+                   1000.0f / igGetIO()->Framerate, igGetIO()->Framerate);
+            igEnd();
+        }
+
+        // 3. Show another simple window.
+        if (show_another_window)
+        {
+           igBegin("imgui Another Window", &show_another_window, 0);
+           igText("Hello from imgui");
+           ImVec2 buttonSize;
+           buttonSize.x = 0; buttonSize.y = 0;
+           if (igButton("Close me", buttonSize))
+           {
+               show_another_window = false;
+           }
+           igEnd();
+        }
+
+        // Rendering
+        igRender();
+        ImDrawData* main_draw_data = igGetDrawData();
+        const bool main_is_minimized = (main_draw_data->DisplaySize.x <= 0.0f || main_draw_data->DisplaySize.y <= 0.0f);
+        wd->ClearValue.color.float32[0] = clear_color.x * clear_color.w;
+        wd->ClearValue.color.float32[1] = clear_color.y * clear_color.w;
+        wd->ClearValue.color.float32[2] = clear_color.z * clear_color.w;
+        wd->ClearValue.color.float32[3] = clear_color.w;
+        if (!main_is_minimized)
+            FrameRender(wd, main_draw_data);
+
+        // Update and Render additional Platform Windows
+        if (io->ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+        {
+            igUpdatePlatformWindows();
+            igRenderPlatformWindowsDefault(NULL, NULL);
+        }
+
+        // Present Main Platform Window
+        if (!main_is_minimized)
+            FramePresent(wd);
+    }
+
+    // Cleanup
+    err = vkDeviceWaitIdle(g_Device);
+    check_vk_result_line(err, __LINE__);
+    ImGui_ImplVulkan_Shutdown();
+    ImGui_ImplSDL3_Shutdown();
+    igDestroyContext(NULL);
+
+    CleanupVulkanWindow();
+    CleanupVulkan();
+
+    SDL_DestroyWindow(window);
+    SDL_Quit();
+
+    return 0;
+}

backend_test/example_sdl_opengl3/main.c

@@ -10,6 +10,10 @@
 #include <GL/gl.h>
 #include <GL/glu.h>
 
+#ifdef _WIN32
+#include <windows.h>        // SetProcessDPIAware()
+#endif
+
 #ifdef IMGUI_HAS_IMSTR
 #define igBegin igBegin_Str
 #define igSliderFloat igSliderFloat_Str
@@ -18,10 +22,15 @@
 #define igButton igButton_Str
 #endif
 
+#define igGetIO igGetIO_Nil
+
 SDL_Window *window = NULL;
 
 int main(int argc, char* argv[])
 {
+#ifdef _WIN32
+    SetProcessDPIAware();
+#endif
 
   if (SDL_Init(SDL_INIT_VIDEO) < 0) {
     SDL_Log("failed to init: %s", SDL_GetError());
@@ -52,11 +61,10 @@ int main(int argc, char* argv[])
   SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
   SDL_DisplayMode current;
   SDL_GetCurrentDisplayMode(0, &current);
-  
-  window = SDL_CreateWindow(
-      "Hello", 0, 0, 1024, 768,
-      SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE
-      );
+  float main_scale = ImGui_ImplSDL2_GetContentScaleForDisplay(0);
+  SDL_WindowFlags window_flags = (SDL_WindowFlags)(SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
+  window = SDL_CreateWindow("Dear ImGui SDL2+OpenGL3 example", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, (int)(1280 * main_scale), (int)(720 * main_scale), window_flags);
+ 
   if (window == NULL) {
     SDL_Log("Failed to create window: %s", SDL_GetError());
     return -1;
@@ -81,6 +89,14 @@ int main(int argc, char* argv[])
   ioptr->ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;         // Enable Multi-Viewport / Platform Windows
 #endif
   
+    // Setup scaling
+    ImGuiStyle* style = igGetStyle();
+    ImGuiStyle_ScaleAllSizes(style, main_scale);        // Bake a fixed style scale. (until we have a solution for dynamic style scaling, changing this requires resetting Style + calling this again)
+    style->FontScaleDpi = main_scale;        // Set initial font scale. (using io.ConfigDpiScaleFonts=true makes this unnecessary. We leave both here for documentation purpose)
+    ioptr->ConfigDpiScaleFonts = true;          // [Experimental] Automatically overwrite style.FontScaleDpi in Begin() when Monitor DPI changes. This will scale fonts but _NOT_ scale sizes/padding for now.
+    ioptr->ConfigDpiScaleViewports = true;      // [Experimental] Scale Dear ImGui and Platform Windows when Monitor DPI changes.
+
+
   ImGui_ImplSDL2_InitForOpenGL(window, gl_context);
   ImGui_ImplOpenGL3_Init(glsl_version);
 

backend_test/example_sdl_vulkan/README.md

@@ -1,3 +1,2 @@
-This example needs vulkan generation before compilation: Vulkan SDK should be installed and then add "vulkan" to generator.bat and generate.
 
 To build use `cmake path_to_example_sdl_vulkan` and then `make install`

backend_test/example_sdl_vulkan/main.c

@@ -11,6 +11,10 @@
 #include <volk.h>
 #endif
 
+#ifdef _WIN32
+#include <windows.h>        // SetProcessDPIAware()
+#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
 
@@ -26,6 +30,8 @@
 #define igButton igButton_Str
 #endif
 
+#define igGetIO igGetIO_Nil
+
 #define IM_UNUSED(_VAR)  ((void)(_VAR))
 #define IM_ASSERT(_EXPR) assert(_EXPR)
 #define IM_ARRAYSIZE(_ARR) ((int)(sizeof(_ARR) / sizeof(*(_ARR))))
@@ -374,6 +380,9 @@ static void FramePresent(ImGui_ImplVulkanH_Window* wd)
 // Main code
 int main(int argc, char* argv[])
 {
+#ifdef _WIN32
+    SetProcessDPIAware();
+#endif
     //g_MainWindowData.ClearEnable = true;
 	//ImGui_ImplVulkanH_Window_Construct(&g_MainWindowData);
 	g_MainWindowData = *ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window();
@@ -389,9 +398,10 @@ int main(int argc, char* argv[])
     SDL_SetHint(SDL_HINT_IME_SHOW_UI, "1");
 #endif
 
-    // Create window with Vulkan graphics context
+    float main_scale = ImGui_ImplSDL2_GetContentScaleForDisplay(0);
     SDL_WindowFlags window_flags = (SDL_WindowFlags)(SDL_WINDOW_VULKAN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
-    SDL_Window* window = SDL_CreateWindow("Dear ImGui SDL2+Vulkan example", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1280, 720, window_flags);
+    SDL_Window* window = SDL_CreateWindow("Dear ImGui SDL2+Vulkan example", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, (int)(1280 * main_scale), (int)(720 * main_scale), window_flags);
+    
     if (window == NULL)
     {
         printf("Error: SDL_CreateWindow(): %s\n", SDL_GetError());
@@ -443,6 +453,10 @@ int main(int argc, char* argv[])
         style->Colors[ImGuiCol_WindowBg].w = 1.0f;
     }
 
+    // Setup scaling
+    ImGuiStyle_ScaleAllSizes(style, main_scale);        // Bake a fixed style scale. (until we have a solution for dynamic style scaling, changing this requires resetting Style + calling this again)
+    style->FontScaleDpi = main_scale;        // Set initial font scale. (using io.ConfigDpiScaleFonts=true makes this unnecessary. We leave both here for documentation purpose)
+
     // Setup Platform/Renderer backends
     ImGui_ImplSDL2_InitForVulkan(window);
     ImGui_ImplVulkan_InitInfo init_info = {};

backend_test/example_sdlgpu3/CMakeLists.txt

@@ -0,0 +1,33 @@
+cmake_minimum_required(VERSION 3.30)
+project(cimgui_sdlgpu3 LANGUAGES C CXX)
+
+set(CMAKE_C_STANDARD 11)
+
+include(FetchContent)
+
+FetchContent_Declare(
+	sdl3
+	URL https://github.com/libsdl-org/SDL/releases/download/release-3.2.8/SDL3-3.2.8.tar.gz
+)
+
+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 sdlgpu3 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_SDLGPU3=1
+)

backend_test/example_sdlgpu3/README.md

@@ -0,0 +1,16 @@
+# SDLGPU3
+
+This example is a little different from the others, because `cimgui` doesn't come with bindings for the SDLGPU3 backend out of the box. Instead, this example shows how to generate the necessary bindings during cmake's configure time, then add the compiled library as a target for your application to link to.
+
+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`
+
+and after
+
+`make`
+

backend_test/example_sdlgpu3/main.c

@@ -0,0 +1,216 @@
+#include <assert.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <SDL3/SDL.h>
+#include <SDL3/SDL_gpu.h>
+
+#include <cimgui.h>
+#include <cimgui_impl.h>
+
+
+#define igGetIO igGetIO_Nil
+
+int main() {
+    if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMEPAD)) {
+      fprintf(stderr, "Failed to init video! %s", SDL_GetError());
+      return 1;
+    };
+    
+    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;
+    window = SDL_CreateWindow("Dear ImGui SDL3+SDL_GPU example", (int)(1280 * main_scale), (int)(720 * main_scale), window_flags);
+    if (window == NULL)
+    {
+        printf("Error: SDL_CreateWindow(): %s\n", SDL_GetError());
+        return -1;
+    }
+    SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
+    SDL_ShowWindow(window);
+
+    // Create GPU Device
+    SDL_GPUDevice* gpu_device = SDL_CreateGPUDevice(SDL_GPU_SHADERFORMAT_SPIRV | SDL_GPU_SHADERFORMAT_DXIL | SDL_GPU_SHADERFORMAT_METALLIB,true,NULL);
+    if (gpu_device == NULL)
+    {
+        printf("Error: SDL_CreateGPUDevice(): %s\n", SDL_GetError());
+        return -1;
+    }
+
+    // Claim window for GPU Device
+    if (!SDL_ClaimWindowForGPUDevice(gpu_device, window))
+    {
+        printf("Error: SDL_ClaimWindowForGPUDevice(): %s\n", SDL_GetError());
+        return -1;
+    }
+    SDL_SetGPUSwapchainParameters(gpu_device, window, SDL_GPU_SWAPCHAINCOMPOSITION_SDR, SDL_GPU_PRESENTMODE_MAILBOX);
+
+  // Setup Dear ImGui context
+    //IMGUI_CHECKVERSION();
+    igCreateContext(NULL);
+    ImGuiIO* io = igGetIO(); (void)io;
+    io->ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;     // Enable Keyboard Controls
+    io->ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;      // Enable Gamepad Controls
+
+    // Setup Dear ImGui style
+    igStyleColorsDark(NULL);
+    //igStyleColorsLight(NULL);
+    // Setup scaling
+    ImGuiStyle* style = igGetStyle();
+    ImGuiStyle_ScaleAllSizes(style, main_scale);        // Bake a fixed style scale. (until we have a solution for dynamic style scaling, changing this requires resetting Style + calling this again)
+    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_InitForSDLGPU(window);
+    ImGui_ImplSDLGPU3_InitInfo init_info;//= {};
+    init_info.Device = gpu_device;
+    init_info.ColorTargetFormat = SDL_GetGPUSwapchainTextureFormat(gpu_device, window);
+    init_info.MSAASamples = SDL_GPU_SAMPLECOUNT_1;
+    ImGui_ImplSDLGPU3_Init(&init_info);
+  // finish loading data
+
+    // 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;
+        }
+
+        // Start the Dear ImGui frame
+        ImGui_ImplSDLGPU3_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);
+
+        SDL_GPUCommandBuffer* command_buffer = SDL_AcquireGPUCommandBuffer(gpu_device); // Acquire a GPU command buffer
+
+        SDL_GPUTexture* swapchain_texture;
+        SDL_AcquireGPUSwapchainTexture(command_buffer, window, &swapchain_texture, NULL, NULL); // Acquire a swapchain texture
+
+        if (swapchain_texture != NULL && !is_minimized)
+        {
+            // This is mandatory: call Imgui_ImplSDLGPU3_PrepareDrawData() to upload the vertex/index buffer!
+            ImGui_ImplSDLGPU3_PrepareDrawData(draw_data, command_buffer);
+
+            // Setup and start a render pass
+            SDL_GPUColorTargetInfo target_info ;//= {};
+            target_info.texture = swapchain_texture;
+            target_info.clear_color.r = clear_color.x;
+			target_info.clear_color.g = clear_color.y;
+			target_info.clear_color.b = clear_color.z;
+			target_info.clear_color.a = clear_color.w;
+            target_info.load_op = SDL_GPU_LOADOP_CLEAR;
+            target_info.store_op = SDL_GPU_STOREOP_STORE;
+            target_info.mip_level = 0;
+            target_info.layer_or_depth_plane = 0;
+            target_info.cycle = false;
+			target_info.resolve_texture = NULL;
+			target_info.resolve_mip_level = 0;
+			target_info.resolve_layer = 0;
+			target_info.cycle_resolve_texture = false;
+			target_info.padding1 = 0;
+			target_info.padding2 = 0;
+            SDL_GPURenderPass* render_pass = SDL_BeginGPURenderPass(command_buffer, &target_info, 1, NULL);
+
+            // Render ImGui
+            ImGui_ImplSDLGPU3_RenderDrawData(draw_data, command_buffer, render_pass, NULL);
+
+            SDL_EndGPURenderPass(render_pass);
+        }
+
+        // Submit the command buffer
+        SDL_SubmitGPUCommandBuffer(command_buffer);
+    }
+
+    // Cleanup
+    // [If using SDL_MAIN_USE_CALLBACKS: all code below would likely be your SDL_AppQuit() function]
+    SDL_WaitForGPUIdle(gpu_device);
+    ImGui_ImplSDL3_Shutdown();
+    ImGui_ImplSDLGPU3_Shutdown();
+    igDestroyContext(NULL);
+
+    SDL_ReleaseWindowFromGPUDevice(gpu_device, window);
+    SDL_DestroyGPUDevice(gpu_device);
+    SDL_DestroyWindow(window);
+    SDL_Quit();
+
+    return 0;
+}

cimgui_impl.cpp

@@ -5,34 +5,19 @@
 #include "./imgui/imgui_internal.h"
 #include "cimgui.h"
 
-#ifdef CIMGUI_USE_DX9
-#include "imgui_impl_dx9.h"
-#endif
-
-#ifdef CIMGUI_USE_DX10
-#include "imgui_impl_dx10.h"
-#endif
-
-#ifdef CIMGUI_USE_DX11
-#include "imgui_impl_dx11.h"
-#endif
-
-#ifdef CIMGUI_USE_DX12
-#include "imgui_impl_dx12.h"
-#endif
 
 #ifdef CIMGUI_USE_GLFW
 #include "imgui_impl_glfw.h"
 #endif
 
-#ifdef CIMGUI_USE_OPENGL2
-#include "imgui_impl_opengl2.h"
-#endif
-
 #ifdef CIMGUI_USE_OPENGL3
 #include "imgui_impl_opengl3.h"
 #endif
 
+#ifdef CIMGUI_USE_OPENGL2
+#include "imgui_impl_opengl2.h"
+#endif
+
 #ifdef CIMGUI_USE_SDL2
 #include "imgui_impl_sdl2.h"
 #endif
@@ -45,10 +30,6 @@
 #include "imgui_impl_vulkan.h"
 #endif
 
-#ifdef CIMGUI_USE_WIN32
-#include "imgui_impl_win32.h"
-#endif
-
 #include "cimgui_impl.h"
 
 #ifdef CIMGUI_USE_VULKAN

cimgui_impl.h

@@ -1,3 +1,5 @@
+#ifndef CIMGUI_IMPL_DEFINED
+#define CIMGUI_IMPL_DEFINED
 #ifdef CIMGUI_USE_GLFW
 #ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
 
@@ -23,6 +25,8 @@ CIMGUI_API void ImGui_ImplGlfw_KeyCallback(GLFWwindow* window,int key,int scanco
 CIMGUI_API void ImGui_ImplGlfw_CharCallback(GLFWwindow* window,unsigned int c);
 CIMGUI_API void ImGui_ImplGlfw_MonitorCallback(GLFWmonitor* monitor,int event);
 CIMGUI_API void ImGui_ImplGlfw_Sleep(int milliseconds);
+CIMGUI_API float ImGui_ImplGlfw_GetContentScaleForWindow(GLFWwindow* window);
+CIMGUI_API float ImGui_ImplGlfw_GetContentScaleForMonitor(GLFWmonitor* monitor);
 
 #endif
 #ifdef CIMGUI_USE_OPENGL3
@@ -30,10 +34,9 @@ CIMGUI_API bool ImGui_ImplOpenGL3_Init(const char* glsl_version);
 CIMGUI_API void ImGui_ImplOpenGL3_Shutdown(void);
 CIMGUI_API void ImGui_ImplOpenGL3_NewFrame(void);
 CIMGUI_API void ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data);
-CIMGUI_API bool ImGui_ImplOpenGL3_CreateFontsTexture(void);
-CIMGUI_API void ImGui_ImplOpenGL3_DestroyFontsTexture(void);
 CIMGUI_API bool ImGui_ImplOpenGL3_CreateDeviceObjects(void);
 CIMGUI_API void ImGui_ImplOpenGL3_DestroyDeviceObjects(void);
+CIMGUI_API void ImGui_ImplOpenGL3_UpdateTexture(ImTextureData* tex);
 
 #endif
 #ifdef CIMGUI_USE_OPENGL2
@@ -41,10 +44,9 @@ CIMGUI_API bool ImGui_ImplOpenGL2_Init(void);
 CIMGUI_API void ImGui_ImplOpenGL2_Shutdown(void);
 CIMGUI_API void ImGui_ImplOpenGL2_NewFrame(void);
 CIMGUI_API void ImGui_ImplOpenGL2_RenderDrawData(ImDrawData* draw_data);
-CIMGUI_API bool ImGui_ImplOpenGL2_CreateFontsTexture(void);
-CIMGUI_API void ImGui_ImplOpenGL2_DestroyFontsTexture(void);
 CIMGUI_API bool ImGui_ImplOpenGL2_CreateDeviceObjects(void);
 CIMGUI_API void ImGui_ImplOpenGL2_DestroyDeviceObjects(void);
+CIMGUI_API void ImGui_ImplOpenGL2_UpdateTexture(ImTextureData* tex);
 
 #endif
 #ifdef CIMGUI_USE_SDL2
@@ -68,6 +70,8 @@ CIMGUI_API bool ImGui_ImplSDL2_InitForOther(SDL_Window* window);
 CIMGUI_API void ImGui_ImplSDL2_Shutdown(void);
 CIMGUI_API void ImGui_ImplSDL2_NewFrame(void);
 CIMGUI_API bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event);
+CIMGUI_API float ImGui_ImplSDL2_GetContentScaleForWindow(SDL_Window* window);
+CIMGUI_API float ImGui_ImplSDL2_GetContentScaleForDisplay(int display_index);
 CIMGUI_API void ImGui_ImplSDL2_SetGamepadMode(ImGui_ImplSDL2_GamepadMode mode,struct _SDL_GameController** manual_gamepads_array,int manual_gamepads_count);
 
 #endif
@@ -181,9 +185,8 @@ CIMGUI_API bool ImGui_ImplVulkan_Init(ImGui_ImplVulkan_InitInfo* info);
 CIMGUI_API void ImGui_ImplVulkan_Shutdown(void);
 CIMGUI_API void ImGui_ImplVulkan_NewFrame(void);
 CIMGUI_API void ImGui_ImplVulkan_RenderDrawData(ImDrawData* draw_data,VkCommandBuffer command_buffer,VkPipeline pipeline);
-CIMGUI_API bool ImGui_ImplVulkan_CreateFontsTexture(void);
-CIMGUI_API void ImGui_ImplVulkan_DestroyFontsTexture(void);
 CIMGUI_API void ImGui_ImplVulkan_SetMinImageCount(uint32_t min_image_count);
+CIMGUI_API void ImGui_ImplVulkan_UpdateTexture(ImTextureData* tex);
 CIMGUI_API VkDescriptorSet ImGui_ImplVulkan_AddTexture(VkSampler sampler,VkImageView image_view,VkImageLayout image_layout);
 CIMGUI_API void ImGui_ImplVulkan_RemoveTexture(VkDescriptorSet descriptor_set);
 CIMGUI_API bool ImGui_ImplVulkan_LoadFunctions(uint32_t api_version,PFN_vkVoidFunction(*loader_func)(const char* function_name,void* user_data),void* user_data);
@@ -194,6 +197,7 @@ CIMGUI_API VkPresentModeKHR ImGui_ImplVulkanH_SelectPresentMode(VkPhysicalDevice
 CIMGUI_API VkPhysicalDevice ImGui_ImplVulkanH_SelectPhysicalDevice(VkInstance instance);
 CIMGUI_API uint32_t ImGui_ImplVulkanH_SelectQueueFamilyIndex(VkPhysicalDevice physical_device);
 CIMGUI_API int ImGui_ImplVulkanH_GetMinImageCountFromPresentMode(VkPresentModeKHR present_mode);
-CIMGUI_API ImGui_ImplVulkanH_Window* ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window();
+CIMGUI_API ImGui_ImplVulkanH_Window* ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window(void);
 
 #endif
+#endif //CIMGUI_IMPL_DEFINED

generator/cimgui_impl_template.cpp

@@ -0,0 +1,23 @@
+#include "./imgui/imgui.h"
+#ifdef IMGUI_ENABLE_FREETYPE
+#include "./imgui/misc/freetype/imgui_freetype.h"
+#endif
+#include "./imgui/imgui_internal.h"
+#include "cimgui.h"
+
+GENERATED_PLACEHOLDER
+
+#include "cimgui_impl.h"
+
+#ifdef CIMGUI_USE_VULKAN
+
+CIMGUI_API ImGui_ImplVulkanH_Window* ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window()
+{
+	return IM_NEW(ImGui_ImplVulkanH_Window)();
+}
+CIMGUI_API void ImGui_ImplVulkanH_Window_Construct(ImGui_ImplVulkanH_Window* self)
+{
+	IM_PLACEMENT_NEW(self) ImGui_ImplVulkanH_Window();
+}
+
+#endif

generator/cimgui_template.cpp

@@ -1,8 +1,5 @@
 
 #include "./imgui/imgui.h"
-#ifdef IMGUI_ENABLE_FREETYPE
-#include "./imgui/misc/freetype/imgui_freetype.h"
-#endif
 #include "./imgui/imgui_internal.h"
 #include "cimgui.h"
 
@@ -12,16 +9,7 @@
 
 
 /////////////////////////////manual written functions
-CIMGUI_API void igLogText(const char *fmt, ...)
-{
-    char buffer[256];
-    va_list args;
-    va_start(args, fmt);
-    vsnprintf(buffer, 256, fmt, args);
-    va_end(args);
 
-    ImGui::LogText("%s", buffer);
-}
 CIMGUI_API void ImGuiTextBuffer_appendf(ImGuiTextBuffer *self, const char *fmt, ...)
 {
     va_list args;

generator/cimgui_template.h

@@ -34,6 +34,12 @@ typedef unsigned __int64 ImU64;
 //typedef unsigned long long ImU64;
 #endif
 
+#ifndef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+#ifdef IMGUI_ENABLE_FREETYPE
+#include "./imgui/misc/freetype/imgui_freetype.h"
+#endif
+#endif
+
 
 #ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
 #include "imgui_structs.h"
@@ -46,8 +52,6 @@ typedef union SDL_Event SDL_Event;
 #include "auto_funcs.h"
 
 /////////////////////////hand written functions
-//no LogTextV
-CIMGUI_API void igLogText(const char *fmt, ...);
 //no appendfV
 CIMGUI_API void ImGuiTextBuffer_appendf(ImGuiTextBuffer *self, const char *fmt, ...);
 //for getting FLT_MAX in bindings

generator/cpp2ffi.lua

@@ -774,7 +774,9 @@ local function parseFunction(self,stname,itt,namespace,locat)
 	local noname_counter = 0
 	for i,ar in ipairs(argsTa) do
 		--avoid var name without space type&name -> type& name
-		ar = ar:gsub("(%S)&(%S)","%1& %2")
+		-- also do type &name -> type& name
+		--ar = ar:gsub("(%S)&(%S)","%1& %2")
+		ar = ar:gsub("(%S)%s*&(%S)","%1& %2")
 		local typ,name,retf,sigf,reftoptr,defa,ar1
 		local has_cdecl = ar:match"__cdecl"
 		if has_cdecl then ar = ar:gsub("__cdecl","") end
@@ -974,6 +976,7 @@ local function REPLACE_TEXTUREID(FP)
 		end
 	end
 end
+
 local function ADDIMSTR_S(FP)
     local defsT = FP.defsT
     local newcdefs = {}
@@ -1267,6 +1270,7 @@ local function printItems(items)
 	end
 end
 -------------
+local numerr = 0 --for popen error file
 function M.Parser()
 	local par = {}
 	local cdefs ={}
@@ -1310,7 +1314,9 @@ function M.Parser()
 		if self.COMMENTS_GENERATION then
 			cmd_line = cmd_line .. (compiler=="cl" and " /C " or " -C ")
 		end
-		local pipe,err = io.popen(cmd_line,"r")
+		numerr = numerr + 1
+		local errfile = "err"..numerr..".txt"
+		local pipe,err = io.popen(cmd_line.." 2>"..errfile,"r")
 		if not pipe then
 			error("could not execute COMPILER "..err)
 		end
@@ -1320,8 +1326,18 @@ function M.Parser()
 			self:insert(line, tostring(loca)..":"..tostring(loca2))
 			table.insert(preprocessed,line)--
 		end
-		save_data("preprocesed.h",table.concat(preprocessed,"\n"))
 		pipe:close()
+		--print(#preprocessed, "lines processed")
+		save_data("preprocesed.h",table.concat(preprocessed,"\n"))
+		
+		local f = assert(io.open(errfile,"r"))
+		local errstr = f:read"*a"
+		f:close()
+		--print(#errstr,"errstr")
+		print(errstr)
+		--try to guess a compiler error
+		assert(not errstr:match" error")
+		os.remove(errfile)
 		return defines
 	end
 	function par:do_parse()
@@ -1459,6 +1475,8 @@ function M.Parser()
 				txt = txt:gsub(k,v)
 			end
 		end
+		--clean = default in constructor (implot3d)
+		txt = txt:gsub("=%s*default","")
 		--save_data("./preprocode"..tostring(self):gsub("table: ","")..".c",txt)
 		--clean bad positioned comments inside functionD_re
 		if self.COMMENTS_GENERATION then
@@ -1541,6 +1559,7 @@ function M.Parser()
 		local inistruct = clean_spaces(stru:match("(.-)%b{}"))
 		--clean final:
 		inistruct = inistruct:gsub("%s*final%s*:",":")
+
 		--local stname = stru:match("struct%s*(%S+)%s*%b{}")
 		local stname, derived
 		if inistruct:match":" then
@@ -2139,12 +2158,13 @@ function M.Parser()
     function par:dump_alltypes()
         for k,v in pairs(self.alltypes) do print(k, typetoStr(k) ) end
     end
+	
     function par:compute_overloads()
-		if self.IMGUI_HAS_TEXTURES then
-			print"----------replacing ImTextureID with ImTextureUserID"
-			REPLACE_TEXTUREID(self)
-			print"----------end replacing ImTextureID with ImTextureUserID"
-		end
+		-- if self.IMGUI_HAS_TEXTURES then
+			-- print"----------replacing ImTextureID with ImTextureUserID"
+			-- REPLACE_TEXTUREID(self)
+			-- print"----------end replacing ImTextureID with ImTextureUserID"
+		-- end
 		ADDIMSTR_S(self)
         local strt = {}
         local numoverloaded = 0
@@ -2618,6 +2638,21 @@ local function location(file,locpathT,defines,COMPILER,keepemptylines)
 end
 M.location = location
 ---------------------- C writing functions
+local function paramListWithoutDots(params)
+	i, j = string.find(params, "%.%.%.")
+	while i > 1 do
+		i = i - 1
+		c = string.sub(params,i,i)
+		if c == "," then
+			return string.sub(params, 1, i-1) .. params:sub(j+1)
+		elseif c == "(" then
+			return string.sub(params, 1, i) .. params:sub(j+1)
+		end
+	end
+
+	error("paramListWithoutDots failed")
+	return "()"
+end
 local function ImGui_f_implementation(def)
 	local outtab = {}
     local ptret = def.retref and "&" or ""
@@ -2638,14 +2673,24 @@ local function ImGui_f_implementation(def)
         if def.ret~="void" then
             table.insert(outtab,"    return ret;\n")
         end
+		table.insert(outtab,"}\n")
+		-- For variadic functions we add a function implementation with zero argumets, for compatibility with languages such as C#.
+		table.insert(outtab, "#ifdef CIMGUI_VARGS0\n")
+		table.insert(outtab, "CIMGUI_API".." "..def.ret.." "..def.ov_cimguiname.."0"..paramListWithoutDots(def.args).."\n")
+		table.insert(outtab, "{\n")
+		table.insert(outtab, "    return "..def.ov_cimguiname..paramListWithoutDots(def.call_args)..";\n")
+		table.insert(outtab, "}\n")
+		table.insert(outtab, "#endif\n")
     elseif def.nonUDT then
         if def.nonUDT == 1 then
             table.insert(outtab,"    *pOut = "..namespace..def.funcname..def.call_args..";\n")
         end
+		table.insert(outtab,"}\n")
     else --standard ImGui
         table.insert(outtab,"    return "..ptret..namespace..def.funcname..def.call_args..";\n")
+		table.insert(outtab,"}\n")
     end
-    table.insert(outtab,"}\n")
+    --table.insert(outtab,"}\n")
 	return table.concat(outtab, "")
 end
 local function struct_f_implementation(def)
@@ -2797,6 +2842,12 @@ local function func_header_generate_funcs(FP)
 
                 if def.stname == "" or def.is_static_function then --ImGui namespace or top level
                     table.insert(outtab,"CIMGUI_API "..def.ret.." ".. def.ov_cimguiname ..(empty and "(void)" or def.args)..";"..addcoment.."\n")
+					if def.isvararg then
+						-- For variadic functions we add a function implementation with zero argumets, for compatibility with languages such as C#.
+						table.insert(outtab, "#ifdef CIMGUI_VARGS0\n")
+						table.insert(outtab, "CIMGUI_API".." "..def.ret.." "..def.ov_cimguiname.."0"..paramListWithoutDots(def.args)..";\n")
+						table.insert(outtab, "#endif\n")
+					end
                 else
                     table.insert(outtab,"CIMGUI_API "..def.ret.." "..def.ov_cimguiname..def.args..";"..addcoment.."\n")
                 end

generator/generator.bat

@@ -20,7 +20,7 @@ set PATH=%PATH%;C:\anima;C:\mingws\i686-7.2.0-release-posix-dwarf-rt_v5-rev1\min
 :: examples: "" "internal" "internal comments"
 :: arg[3..n] name of implementations to generate and/or CFLAGS (e.g. -DIMGUI_USER_CONFIG) 
 ::-DIMGUI_USE_WCHAR32 should not be used (is discarded)
-luajit ./generator.lua gcc "internal noimstrv" glfw opengl3 opengl2 sdl2 sdl3 vulkan -DIMGUI_USE_WCHAR32 %*
+luajit ./generator.lua gcc "internal noimstrv" glfw opengl3 opengl2 sdl2 sdl3 vulkan %*
 
 ::leave console open
 cmd /k

generator/generator.lua

@@ -13,6 +13,7 @@ local CONSTRUCTORS_GENERATION = script_args[2]:match("constructors") and true or
 local NOCHAR = script_args[2]:match("nochar") and true or false
 local NOIMSTRV = script_args[2]:match("noimstrv") and true or false
 local IMGUI_PATH = os.getenv"IMGUI_PATH" or "../imgui"
+local CONFIG_GENERATOR_PATH = os.getenv"CONFIG_GENERATOR_PATH" or "./config_generator.lua"
 local CFLAGS = ""
 local CPRE,CTEST
 --get implementations
@@ -77,7 +78,7 @@ print("CPRE",CPRE)
 --this table has the functions to be skipped in generation
 --------------------------------------------------------------------------
 local cimgui_manuals = {
-    igLogText = true,
+   -- igLogText = true,
     ImGuiTextBuffer_appendf = true,
     --igColorConvertRGBtoHSV = true,
     --igColorConvertHSVtoRGB = true
@@ -91,10 +92,10 @@ local cimgui_skipped = {
 --desired name
 ---------------------------------------------------------------------------
 local cimgui_overloads = {
-	igGetIO = {
-		["()"] = "igGetIO",
-		["(ImGuiContext*)"] = "igGetIOEx",
-	},
+	-- igGetIO = {
+		-- ["()"] = "igGetIO",
+		-- ["(ImGuiContext*)"] = "igGetIOEx",
+	-- },
     --igPushID = {
         --["(const char*)"] =           "igPushIDStr",
         --["(const char*,const char*)"] = "igPushIDRange",
@@ -128,6 +129,7 @@ local function func_header_impl_generate(FP)
             local cimf = FP.defsT[t.cimguiname]
             local def = cimf[t.signature]
 			local addcoment = def.comment or ""
+			local empty = def.args:match("^%(%)") --no args
 			if def.constructor then
 				-- only vulkan is manually created
 				assert(def.ov_cimguiname=="ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window" or
@@ -139,7 +141,6 @@ local function func_header_impl_generate(FP)
 			else
                 
                 if def.stname == "" then --ImGui namespace or top level
-                    local empty = def.args:match("^%(%)") --no args
                     table.insert(outtab,"CIMGUI_API".." "..def.ret.." "..def.ov_cimguiname..(empty and "(void)" or def.args)..";"..addcoment.."\n")
                 else
 					cpp2ffi.prtable(def)
@@ -454,11 +455,19 @@ local parser2
 
 if #implementations > 0 then
 	print("------------------implementations generation with "..COMPILER.."------------------------")
+	--parser2 for function defs
+	--parser3 for separated structs and enums in cimgui_impl.h
     parser2 = cpp2ffi.Parser()
 	
-	local config = require"config_generator"
-    local impl_str = ""
+	local config = dofile(CONFIG_GENERATOR_PATH) --"./config_generator.lua"
+    local impl_str = "#ifndef CIMGUI_IMPL_DEFINED\n#define CIMGUI_IMPL_DEFINED\n"
+	local impl_str_cpp = {}
     for i,impl in ipairs(implementations) do
+		print("------------implementation:",impl)
+		table.insert(impl_str_cpp, "\n#ifdef CIMGUI_USE_" .. string.upper(impl))
+		table.insert(impl_str_cpp, [[#include "imgui_impl_]]..impl..[[.h"]])
+		table.insert(impl_str_cpp, "#endif")
+
         local source = backends_folder .. [[imgui_impl_]].. impl .. ".h "
         local locati = [[imgui_impl_]].. impl
 
@@ -472,11 +481,11 @@ if #implementations > 0 then
 				extra_includes = extra_includes .. include_cmd .. inc .. " "
 			end
 		end
-		parser2.cimgui_inherited =  dofile([[../../cimgui/generator/output/structs_and_enums.lua]])
+		parser2.cimgui_inherited =  dofile([[./output/structs_and_enums.lua]])
 		local defines = parser2:take_lines(CPRE..extra_defines..extra_includes..source, {locati}, COMPILER)
 		
 		local parser3 = cpp2ffi.Parser()
-		parser3.cimgui_inherited =  dofile([[../../cimgui/generator/output/structs_and_enums.lua]])
+		parser3.cimgui_inherited =  dofile([[./output/structs_and_enums.lua]])
 		parser3:take_lines(CPRE..extra_defines..extra_includes..source, {locati}, COMPILER)
 		parser3:do_parse()
 		local cfuncsstr = func_header_impl_generate(parser3) 
@@ -493,17 +502,22 @@ if #implementations > 0 then
 		end
 		impl_str = impl_str.. table.concat(outtab)..cfuncsstr .. "\n#endif\n"
     end
-	
+	impl_str = impl_str .. "#endif //CIMGUI_IMPL_DEFINED\n"
     parser2:do_parse()
-
-    -- save ./cimgui_impl.h
-    --local cfuncsstr = func_header_impl_generate(parser2) 
-	--local cstructstr1,cstructstr2 = parser2.structs_and_enums[1], parser2.structs_and_enums[2]
-    --save_data("./output/cimgui_impl.h",cstructstr1,cstructstr2,cfuncsstr)
 	save_data("./output/cimgui_impl.h",impl_str)
 
     ----------save fundefs in impl_definitions.lua for using in bindings
     save_data("./output/impl_definitions.lua",serializeTableF(parser2.defsT))
+	--impl cpp
+	impl_str_cpp = table.concat(impl_str_cpp, "\n")
+	local cppstr = read_data"./cimgui_impl_template.cpp"
+	cppstr = cppstr:gsub("GENERATED_PLACEHOLDER", impl_str_cpp)
+	save_data("./output/cimgui_impl.cpp",cppstr)
+	
+	copyfile("./output/cimgui_impl.h", "../cimgui_impl.h")
+	copyfile("./output/cimgui_impl.cpp", "../cimgui_impl.cpp")
+	os.remove("./output/cimgui_impl.h")
+	os.remove("./output/cimgui_impl.cpp")
 
 end -- #implementations > 0 then
 
@@ -535,9 +549,7 @@ end
 --]]
 -------------------copy C files to repo root
 copyfile("./output/cimgui.h", "../cimgui.h")
-copyfile("./output/cimgui_impl.h", "../cimgui_impl.h")
 copyfile("./output/cimgui.cpp", "../cimgui.cpp")
 os.remove("./output/cimgui.h")
-os.remove("./output/cimgui_impl.h")
 os.remove("./output/cimgui.cpp")
 print"all done!!"

generator/output/impl_definitions.json

@@ -17,7 +17,7 @@
       "cimguiname": "ImGui_ImplGlfw_CharCallback",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_CharCallback",
-      "location": "imgui_impl_glfw:60",
+      "location": "imgui_impl_glfw:61",
       "ov_cimguiname": "ImGui_ImplGlfw_CharCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,unsigned int)",
@@ -42,7 +42,7 @@
       "cimguiname": "ImGui_ImplGlfw_CursorEnterCallback",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_CursorEnterCallback",
-      "location": "imgui_impl_glfw:55",
+      "location": "imgui_impl_glfw:56",
       "ov_cimguiname": "ImGui_ImplGlfw_CursorEnterCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,int)",
@@ -71,13 +71,55 @@
       "cimguiname": "ImGui_ImplGlfw_CursorPosCallback",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_CursorPosCallback",
-      "location": "imgui_impl_glfw:56",
+      "location": "imgui_impl_glfw:57",
       "ov_cimguiname": "ImGui_ImplGlfw_CursorPosCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,double,double)",
       "stname": ""
     }
   ],
+  "ImGui_ImplGlfw_GetContentScaleForMonitor": [
+    {
+      "args": "(GLFWmonitor* monitor)",
+      "argsT": [
+        {
+          "name": "monitor",
+          "type": "GLFWmonitor*"
+        }
+      ],
+      "argsoriginal": "(GLFWmonitor* monitor)",
+      "call_args": "(monitor)",
+      "cimguiname": "ImGui_ImplGlfw_GetContentScaleForMonitor",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_GetContentScaleForMonitor",
+      "location": "imgui_impl_glfw:67",
+      "ov_cimguiname": "ImGui_ImplGlfw_GetContentScaleForMonitor",
+      "ret": "float",
+      "signature": "(GLFWmonitor*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplGlfw_GetContentScaleForWindow": [
+    {
+      "args": "(GLFWwindow* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "GLFWwindow*"
+        }
+      ],
+      "argsoriginal": "(GLFWwindow* window)",
+      "call_args": "(window)",
+      "cimguiname": "ImGui_ImplGlfw_GetContentScaleForWindow",
+      "defaults": {},
+      "funcname": "ImGui_ImplGlfw_GetContentScaleForWindow",
+      "location": "imgui_impl_glfw:66",
+      "ov_cimguiname": "ImGui_ImplGlfw_GetContentScaleForWindow",
+      "ret": "float",
+      "signature": "(GLFWwindow*)",
+      "stname": ""
+    }
+  ],
   "ImGui_ImplGlfw_InitForOpenGL": [
     {
       "args": "(GLFWwindow* window,bool install_callbacks)",
@@ -96,7 +138,7 @@
       "cimguiname": "ImGui_ImplGlfw_InitForOpenGL",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_InitForOpenGL",
-      "location": "imgui_impl_glfw:31",
+      "location": "imgui_impl_glfw:32",
       "ov_cimguiname": "ImGui_ImplGlfw_InitForOpenGL",
       "ret": "bool",
       "signature": "(GLFWwindow*,bool)",
@@ -121,7 +163,7 @@
       "cimguiname": "ImGui_ImplGlfw_InitForOther",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_InitForOther",
-      "location": "imgui_impl_glfw:33",
+      "location": "imgui_impl_glfw:34",
       "ov_cimguiname": "ImGui_ImplGlfw_InitForOther",
       "ret": "bool",
       "signature": "(GLFWwindow*,bool)",
@@ -146,7 +188,7 @@
       "cimguiname": "ImGui_ImplGlfw_InitForVulkan",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_InitForVulkan",
-      "location": "imgui_impl_glfw:32",
+      "location": "imgui_impl_glfw:33",
       "ov_cimguiname": "ImGui_ImplGlfw_InitForVulkan",
       "ret": "bool",
       "signature": "(GLFWwindow*,bool)",
@@ -167,7 +209,7 @@
       "cimguiname": "ImGui_ImplGlfw_InstallCallbacks",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_InstallCallbacks",
-      "location": "imgui_impl_glfw:46",
+      "location": "imgui_impl_glfw:47",
       "ov_cimguiname": "ImGui_ImplGlfw_InstallCallbacks",
       "ret": "void",
       "signature": "(GLFWwindow*)",
@@ -204,7 +246,7 @@
       "cimguiname": "ImGui_ImplGlfw_KeyCallback",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_KeyCallback",
-      "location": "imgui_impl_glfw:59",
+      "location": "imgui_impl_glfw:60",
       "ov_cimguiname": "ImGui_ImplGlfw_KeyCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,int,int,int,int)",
@@ -229,7 +271,7 @@
       "cimguiname": "ImGui_ImplGlfw_MonitorCallback",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_MonitorCallback",
-      "location": "imgui_impl_glfw:61",
+      "location": "imgui_impl_glfw:62",
       "ov_cimguiname": "ImGui_ImplGlfw_MonitorCallback",
       "ret": "void",
       "signature": "(GLFWmonitor*,int)",
@@ -262,7 +304,7 @@
       "cimguiname": "ImGui_ImplGlfw_MouseButtonCallback",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_MouseButtonCallback",
-      "location": "imgui_impl_glfw:57",
+      "location": "imgui_impl_glfw:58",
       "ov_cimguiname": "ImGui_ImplGlfw_MouseButtonCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,int,int,int)",
@@ -278,7 +320,7 @@
       "cimguiname": "ImGui_ImplGlfw_NewFrame",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_NewFrame",
-      "location": "imgui_impl_glfw:35",
+      "location": "imgui_impl_glfw:36",
       "ov_cimguiname": "ImGui_ImplGlfw_NewFrame",
       "ret": "void",
       "signature": "()",
@@ -299,7 +341,7 @@
       "cimguiname": "ImGui_ImplGlfw_RestoreCallbacks",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_RestoreCallbacks",
-      "location": "imgui_impl_glfw:47",
+      "location": "imgui_impl_glfw:48",
       "ov_cimguiname": "ImGui_ImplGlfw_RestoreCallbacks",
       "ret": "void",
       "signature": "(GLFWwindow*)",
@@ -328,7 +370,7 @@
       "cimguiname": "ImGui_ImplGlfw_ScrollCallback",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_ScrollCallback",
-      "location": "imgui_impl_glfw:58",
+      "location": "imgui_impl_glfw:59",
       "ov_cimguiname": "ImGui_ImplGlfw_ScrollCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,double,double)",
@@ -349,7 +391,7 @@
       "cimguiname": "ImGui_ImplGlfw_SetCallbacksChainForAllWindows",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_SetCallbacksChainForAllWindows",
-      "location": "imgui_impl_glfw:51",
+      "location": "imgui_impl_glfw:52",
       "ov_cimguiname": "ImGui_ImplGlfw_SetCallbacksChainForAllWindows",
       "ret": "void",
       "signature": "(bool)",
@@ -365,7 +407,7 @@
       "cimguiname": "ImGui_ImplGlfw_Shutdown",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_Shutdown",
-      "location": "imgui_impl_glfw:34",
+      "location": "imgui_impl_glfw:35",
       "ov_cimguiname": "ImGui_ImplGlfw_Shutdown",
       "ret": "void",
       "signature": "()",
@@ -386,7 +428,7 @@
       "cimguiname": "ImGui_ImplGlfw_Sleep",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_Sleep",
-      "location": "imgui_impl_glfw:64",
+      "location": "imgui_impl_glfw:65",
       "ov_cimguiname": "ImGui_ImplGlfw_Sleep",
       "ret": "void",
       "signature": "(int)",
@@ -411,7 +453,7 @@
       "cimguiname": "ImGui_ImplGlfw_WindowFocusCallback",
       "defaults": {},
       "funcname": "ImGui_ImplGlfw_WindowFocusCallback",
-      "location": "imgui_impl_glfw:54",
+      "location": "imgui_impl_glfw:55",
       "ov_cimguiname": "ImGui_ImplGlfw_WindowFocusCallback",
       "ret": "void",
       "signature": "(GLFWwindow*,int)",
@@ -427,29 +469,13 @@
       "cimguiname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
-      "location": "imgui_impl_opengl2:38",
+      "location": "imgui_impl_opengl2:37",
       "ov_cimguiname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
       "ret": "bool",
       "signature": "()",
       "stname": ""
     }
   ],
-  "ImGui_ImplOpenGL2_CreateFontsTexture": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGui_ImplOpenGL2_CreateFontsTexture",
-      "defaults": {},
-      "funcname": "ImGui_ImplOpenGL2_CreateFontsTexture",
-      "location": "imgui_impl_opengl2:36",
-      "ov_cimguiname": "ImGui_ImplOpenGL2_CreateFontsTexture",
-      "ret": "bool",
-      "signature": "()",
-      "stname": ""
-    }
-  ],
   "ImGui_ImplOpenGL2_DestroyDeviceObjects": [
     {
       "args": "()",
@@ -459,29 +485,13 @@
       "cimguiname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
-      "location": "imgui_impl_opengl2:39",
+      "location": "imgui_impl_opengl2:38",
       "ov_cimguiname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
       "ret": "void",
       "signature": "()",
       "stname": ""
     }
   ],
-  "ImGui_ImplOpenGL2_DestroyFontsTexture": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGui_ImplOpenGL2_DestroyFontsTexture",
-      "defaults": {},
-      "funcname": "ImGui_ImplOpenGL2_DestroyFontsTexture",
-      "location": "imgui_impl_opengl2:37",
-      "ov_cimguiname": "ImGui_ImplOpenGL2_DestroyFontsTexture",
-      "ret": "void",
-      "signature": "()",
-      "stname": ""
-    }
-  ],
   "ImGui_ImplOpenGL2_Init": [
     {
       "args": "()",
@@ -491,7 +501,7 @@
       "cimguiname": "ImGui_ImplOpenGL2_Init",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_Init",
-      "location": "imgui_impl_opengl2:30",
+      "location": "imgui_impl_opengl2:31",
       "ov_cimguiname": "ImGui_ImplOpenGL2_Init",
       "ret": "bool",
       "signature": "()",
@@ -507,7 +517,7 @@
       "cimguiname": "ImGui_ImplOpenGL2_NewFrame",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_NewFrame",
-      "location": "imgui_impl_opengl2:32",
+      "location": "imgui_impl_opengl2:33",
       "ov_cimguiname": "ImGui_ImplOpenGL2_NewFrame",
       "ret": "void",
       "signature": "()",
@@ -528,7 +538,7 @@
       "cimguiname": "ImGui_ImplOpenGL2_RenderDrawData",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_RenderDrawData",
-      "location": "imgui_impl_opengl2:33",
+      "location": "imgui_impl_opengl2:34",
       "ov_cimguiname": "ImGui_ImplOpenGL2_RenderDrawData",
       "ret": "void",
       "signature": "(ImDrawData*)",
@@ -544,13 +554,34 @@
       "cimguiname": "ImGui_ImplOpenGL2_Shutdown",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL2_Shutdown",
-      "location": "imgui_impl_opengl2:31",
+      "location": "imgui_impl_opengl2:32",
       "ov_cimguiname": "ImGui_ImplOpenGL2_Shutdown",
       "ret": "void",
       "signature": "()",
       "stname": ""
     }
   ],
+  "ImGui_ImplOpenGL2_UpdateTexture": [
+    {
+      "args": "(ImTextureData* tex)",
+      "argsT": [
+        {
+          "name": "tex",
+          "type": "ImTextureData*"
+        }
+      ],
+      "argsoriginal": "(ImTextureData* tex)",
+      "call_args": "(tex)",
+      "cimguiname": "ImGui_ImplOpenGL2_UpdateTexture",
+      "defaults": {},
+      "funcname": "ImGui_ImplOpenGL2_UpdateTexture",
+      "location": "imgui_impl_opengl2:41",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_UpdateTexture",
+      "ret": "void",
+      "signature": "(ImTextureData*)",
+      "stname": ""
+    }
+  ],
   "ImGui_ImplOpenGL3_CreateDeviceObjects": [
     {
       "args": "()",
@@ -560,29 +591,13 @@
       "cimguiname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
-      "location": "imgui_impl_opengl3:41",
+      "location": "imgui_impl_opengl3:40",
       "ov_cimguiname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
       "ret": "bool",
       "signature": "()",
       "stname": ""
     }
   ],
-  "ImGui_ImplOpenGL3_CreateFontsTexture": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGui_ImplOpenGL3_CreateFontsTexture",
-      "defaults": {},
-      "funcname": "ImGui_ImplOpenGL3_CreateFontsTexture",
-      "location": "imgui_impl_opengl3:39",
-      "ov_cimguiname": "ImGui_ImplOpenGL3_CreateFontsTexture",
-      "ret": "bool",
-      "signature": "()",
-      "stname": ""
-    }
-  ],
   "ImGui_ImplOpenGL3_DestroyDeviceObjects": [
     {
       "args": "()",
@@ -592,29 +607,13 @@
       "cimguiname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
-      "location": "imgui_impl_opengl3:42",
+      "location": "imgui_impl_opengl3:41",
       "ov_cimguiname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
       "ret": "void",
       "signature": "()",
       "stname": ""
     }
   ],
-  "ImGui_ImplOpenGL3_DestroyFontsTexture": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGui_ImplOpenGL3_DestroyFontsTexture",
-      "defaults": {},
-      "funcname": "ImGui_ImplOpenGL3_DestroyFontsTexture",
-      "location": "imgui_impl_opengl3:40",
-      "ov_cimguiname": "ImGui_ImplOpenGL3_DestroyFontsTexture",
-      "ret": "void",
-      "signature": "()",
-      "stname": ""
-    }
-  ],
   "ImGui_ImplOpenGL3_Init": [
     {
       "args": "(const char* glsl_version)",
@@ -631,7 +630,7 @@
         "glsl_version": "nullptr"
       },
       "funcname": "ImGui_ImplOpenGL3_Init",
-      "location": "imgui_impl_opengl3:33",
+      "location": "imgui_impl_opengl3:34",
       "ov_cimguiname": "ImGui_ImplOpenGL3_Init",
       "ret": "bool",
       "signature": "(const char*)",
@@ -647,7 +646,7 @@
       "cimguiname": "ImGui_ImplOpenGL3_NewFrame",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL3_NewFrame",
-      "location": "imgui_impl_opengl3:35",
+      "location": "imgui_impl_opengl3:36",
       "ov_cimguiname": "ImGui_ImplOpenGL3_NewFrame",
       "ret": "void",
       "signature": "()",
@@ -668,7 +667,7 @@
       "cimguiname": "ImGui_ImplOpenGL3_RenderDrawData",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL3_RenderDrawData",
-      "location": "imgui_impl_opengl3:36",
+      "location": "imgui_impl_opengl3:37",
       "ov_cimguiname": "ImGui_ImplOpenGL3_RenderDrawData",
       "ret": "void",
       "signature": "(ImDrawData*)",
@@ -684,13 +683,76 @@
       "cimguiname": "ImGui_ImplOpenGL3_Shutdown",
       "defaults": {},
       "funcname": "ImGui_ImplOpenGL3_Shutdown",
-      "location": "imgui_impl_opengl3:34",
+      "location": "imgui_impl_opengl3:35",
       "ov_cimguiname": "ImGui_ImplOpenGL3_Shutdown",
       "ret": "void",
       "signature": "()",
       "stname": ""
     }
   ],
+  "ImGui_ImplOpenGL3_UpdateTexture": [
+    {
+      "args": "(ImTextureData* tex)",
+      "argsT": [
+        {
+          "name": "tex",
+          "type": "ImTextureData*"
+        }
+      ],
+      "argsoriginal": "(ImTextureData* tex)",
+      "call_args": "(tex)",
+      "cimguiname": "ImGui_ImplOpenGL3_UpdateTexture",
+      "defaults": {},
+      "funcname": "ImGui_ImplOpenGL3_UpdateTexture",
+      "location": "imgui_impl_opengl3:44",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_UpdateTexture",
+      "ret": "void",
+      "signature": "(ImTextureData*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplSDL2_GetContentScaleForDisplay": [
+    {
+      "args": "(int display_index)",
+      "argsT": [
+        {
+          "name": "display_index",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(int display_index)",
+      "call_args": "(display_index)",
+      "cimguiname": "ImGui_ImplSDL2_GetContentScaleForDisplay",
+      "defaults": {},
+      "funcname": "ImGui_ImplSDL2_GetContentScaleForDisplay",
+      "location": "imgui_impl_sdl2:43",
+      "ov_cimguiname": "ImGui_ImplSDL2_GetContentScaleForDisplay",
+      "ret": "float",
+      "signature": "(int)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplSDL2_GetContentScaleForWindow": [
+    {
+      "args": "(SDL_Window* window)",
+      "argsT": [
+        {
+          "name": "window",
+          "type": "SDL_Window*"
+        }
+      ],
+      "argsoriginal": "(SDL_Window* window)",
+      "call_args": "(window)",
+      "cimguiname": "ImGui_ImplSDL2_GetContentScaleForWindow",
+      "defaults": {},
+      "funcname": "ImGui_ImplSDL2_GetContentScaleForWindow",
+      "location": "imgui_impl_sdl2:42",
+      "ov_cimguiname": "ImGui_ImplSDL2_GetContentScaleForWindow",
+      "ret": "float",
+      "signature": "(SDL_Window*)",
+      "stname": ""
+    }
+  ],
   "ImGui_ImplSDL2_InitForD3D": [
     {
       "args": "(SDL_Window* window)",
@@ -887,7 +949,7 @@
         "manual_gamepads_count": "-1"
       },
       "funcname": "ImGui_ImplSDL2_SetGamepadMode",
-      "location": "imgui_impl_sdl2:44",
+      "location": "imgui_impl_sdl2:48",
       "ov_cimguiname": "ImGui_ImplSDL2_SetGamepadMode",
       "ret": "void",
       "signature": "(ImGui_ImplSDL2_GamepadMode,struct _SDL_GameController**,int)",
@@ -1196,7 +1258,7 @@
       "cimguiname": "ImGui_ImplVulkanH_CreateOrResizeWindow",
       "defaults": {},
       "funcname": "ImGui_ImplVulkanH_CreateOrResizeWindow",
-      "location": "imgui_impl_vulkan:165",
+      "location": "imgui_impl_vulkan:166",
       "ov_cimguiname": "ImGui_ImplVulkanH_CreateOrResizeWindow",
       "ret": "void",
       "signature": "(VkInstance,VkPhysicalDevice,VkDevice,ImGui_ImplVulkanH_Window*,uint32_t,const VkAllocationCallbacks*,int,int,uint32_t)",
@@ -1229,7 +1291,7 @@
       "cimguiname": "ImGui_ImplVulkanH_DestroyWindow",
       "defaults": {},
       "funcname": "ImGui_ImplVulkanH_DestroyWindow",
-      "location": "imgui_impl_vulkan:166",
+      "location": "imgui_impl_vulkan:167",
       "ov_cimguiname": "ImGui_ImplVulkanH_DestroyWindow",
       "ret": "void",
       "signature": "(VkInstance,VkDevice,ImGui_ImplVulkanH_Window*,const VkAllocationCallbacks*)",
@@ -1250,7 +1312,7 @@
       "cimguiname": "ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
       "defaults": {},
       "funcname": "ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
-      "location": "imgui_impl_vulkan:171",
+      "location": "imgui_impl_vulkan:172",
       "ov_cimguiname": "ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
       "ret": "int",
       "signature": "(VkPresentModeKHR)",
@@ -1271,7 +1333,7 @@
       "cimguiname": "ImGui_ImplVulkanH_SelectPhysicalDevice",
       "defaults": {},
       "funcname": "ImGui_ImplVulkanH_SelectPhysicalDevice",
-      "location": "imgui_impl_vulkan:169",
+      "location": "imgui_impl_vulkan:170",
       "ov_cimguiname": "ImGui_ImplVulkanH_SelectPhysicalDevice",
       "ret": "VkPhysicalDevice",
       "signature": "(VkInstance)",
@@ -1304,7 +1366,7 @@
       "cimguiname": "ImGui_ImplVulkanH_SelectPresentMode",
       "defaults": {},
       "funcname": "ImGui_ImplVulkanH_SelectPresentMode",
-      "location": "imgui_impl_vulkan:168",
+      "location": "imgui_impl_vulkan:169",
       "ov_cimguiname": "ImGui_ImplVulkanH_SelectPresentMode",
       "ret": "VkPresentModeKHR",
       "signature": "(VkPhysicalDevice,VkSurfaceKHR,const VkPresentModeKHR*,int)",
@@ -1325,7 +1387,7 @@
       "cimguiname": "ImGui_ImplVulkanH_SelectQueueFamilyIndex",
       "defaults": {},
       "funcname": "ImGui_ImplVulkanH_SelectQueueFamilyIndex",
-      "location": "imgui_impl_vulkan:170",
+      "location": "imgui_impl_vulkan:171",
       "ov_cimguiname": "ImGui_ImplVulkanH_SelectQueueFamilyIndex",
       "ret": "uint32_t",
       "signature": "(VkPhysicalDevice)",
@@ -1362,7 +1424,7 @@
       "cimguiname": "ImGui_ImplVulkanH_SelectSurfaceFormat",
       "defaults": {},
       "funcname": "ImGui_ImplVulkanH_SelectSurfaceFormat",
-      "location": "imgui_impl_vulkan:167",
+      "location": "imgui_impl_vulkan:168",
       "ov_cimguiname": "ImGui_ImplVulkanH_SelectSurfaceFormat",
       "ret": "VkSurfaceFormatKHR",
       "signature": "(VkPhysicalDevice,VkSurfaceKHR,const VkFormat*,int,VkColorSpaceKHR)",
@@ -1379,7 +1441,7 @@
       "constructor": true,
       "defaults": {},
       "funcname": "ImGui_ImplVulkanH_Window",
-      "location": "imgui_impl_vulkan:214",
+      "location": "imgui_impl_vulkan:215",
       "ov_cimguiname": "ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window",
       "signature": "()",
       "stname": "ImGui_ImplVulkanH_Window"
@@ -1398,7 +1460,7 @@
       "cimguiname": "ImGui_ImplVulkanH_Window_destroy",
       "defaults": {},
       "destructor": true,
-      "location": "imgui_impl_vulkan:214",
+      "location": "imgui_impl_vulkan:215",
       "ov_cimguiname": "ImGui_ImplVulkanH_Window_destroy",
       "ret": "void",
       "signature": "(ImGui_ImplVulkanH_Window*)",
@@ -1427,45 +1489,13 @@
       "cimguiname": "ImGui_ImplVulkan_AddTexture",
       "defaults": {},
       "funcname": "ImGui_ImplVulkan_AddTexture",
-      "location": "imgui_impl_vulkan:122",
+      "location": "imgui_impl_vulkan:123",
       "ov_cimguiname": "ImGui_ImplVulkan_AddTexture",
       "ret": "VkDescriptorSet",
       "signature": "(VkSampler,VkImageView,VkImageLayout)",
       "stname": ""
     }
   ],
-  "ImGui_ImplVulkan_CreateFontsTexture": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGui_ImplVulkan_CreateFontsTexture",
-      "defaults": {},
-      "funcname": "ImGui_ImplVulkan_CreateFontsTexture",
-      "location": "imgui_impl_vulkan:115",
-      "ov_cimguiname": "ImGui_ImplVulkan_CreateFontsTexture",
-      "ret": "bool",
-      "signature": "()",
-      "stname": ""
-    }
-  ],
-  "ImGui_ImplVulkan_DestroyFontsTexture": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGui_ImplVulkan_DestroyFontsTexture",
-      "defaults": {},
-      "funcname": "ImGui_ImplVulkan_DestroyFontsTexture",
-      "location": "imgui_impl_vulkan:116",
-      "ov_cimguiname": "ImGui_ImplVulkan_DestroyFontsTexture",
-      "ret": "void",
-      "signature": "()",
-      "stname": ""
-    }
-  ],
   "ImGui_ImplVulkan_Init": [
     {
       "args": "(ImGui_ImplVulkan_InitInfo* info)",
@@ -1511,7 +1541,7 @@
         "user_data": "nullptr"
       },
       "funcname": "ImGui_ImplVulkan_LoadFunctions",
-      "location": "imgui_impl_vulkan:127",
+      "location": "imgui_impl_vulkan:128",
       "ov_cimguiname": "ImGui_ImplVulkan_LoadFunctions",
       "ret": "bool",
       "signature": "(uint32_t,PFN_vkVoidFunction(*loader_func)(const char* function_name,void*,void*)",
@@ -1548,7 +1578,7 @@
       "cimguiname": "ImGui_ImplVulkan_RemoveTexture",
       "defaults": {},
       "funcname": "ImGui_ImplVulkan_RemoveTexture",
-      "location": "imgui_impl_vulkan:123",
+      "location": "imgui_impl_vulkan:124",
       "ov_cimguiname": "ImGui_ImplVulkan_RemoveTexture",
       "ret": "void",
       "signature": "(VkDescriptorSet)",
@@ -1600,7 +1630,7 @@
       "cimguiname": "ImGui_ImplVulkan_SetMinImageCount",
       "defaults": {},
       "funcname": "ImGui_ImplVulkan_SetMinImageCount",
-      "location": "imgui_impl_vulkan:117",
+      "location": "imgui_impl_vulkan:115",
       "ov_cimguiname": "ImGui_ImplVulkan_SetMinImageCount",
       "ret": "void",
       "signature": "(uint32_t)",
@@ -1622,5 +1652,26 @@
       "signature": "()",
       "stname": ""
     }
+  ],
+  "ImGui_ImplVulkan_UpdateTexture": [
+    {
+      "args": "(ImTextureData* tex)",
+      "argsT": [
+        {
+          "name": "tex",
+          "type": "ImTextureData*"
+        }
+      ],
+      "argsoriginal": "(ImTextureData* tex)",
+      "call_args": "(tex)",
+      "cimguiname": "ImGui_ImplVulkan_UpdateTexture",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkan_UpdateTexture",
+      "location": "imgui_impl_vulkan:118",
+      "ov_cimguiname": "ImGui_ImplVulkan_UpdateTexture",
+      "ret": "void",
+      "signature": "(ImTextureData*)",
+      "stname": ""
+    }
   ]
 }

generator/output/impl_definitions.lua

@@ -14,7 +14,7 @@ local t={
       cimguiname="ImGui_ImplGlfw_CharCallback",
       defaults={},
       funcname="ImGui_ImplGlfw_CharCallback",
-      location="imgui_impl_glfw:60",
+      location="imgui_impl_glfw:61",
       ov_cimguiname="ImGui_ImplGlfw_CharCallback",
       ret="void",
       signature="(GLFWwindow*,unsigned int)",
@@ -35,7 +35,7 @@ local t={
       cimguiname="ImGui_ImplGlfw_CursorEnterCallback",
       defaults={},
       funcname="ImGui_ImplGlfw_CursorEnterCallback",
-      location="imgui_impl_glfw:55",
+      location="imgui_impl_glfw:56",
       ov_cimguiname="ImGui_ImplGlfw_CursorEnterCallback",
       ret="void",
       signature="(GLFWwindow*,int)",
@@ -59,12 +59,48 @@ local t={
       cimguiname="ImGui_ImplGlfw_CursorPosCallback",
       defaults={},
       funcname="ImGui_ImplGlfw_CursorPosCallback",
-      location="imgui_impl_glfw:56",
+      location="imgui_impl_glfw:57",
       ov_cimguiname="ImGui_ImplGlfw_CursorPosCallback",
       ret="void",
       signature="(GLFWwindow*,double,double)",
       stname=""},
     ["(GLFWwindow*,double,double)"]=nil},
+  ImGui_ImplGlfw_GetContentScaleForMonitor={
+    [1]={
+      args="(GLFWmonitor* monitor)",
+      argsT={
+        [1]={
+          name="monitor",
+          type="GLFWmonitor*"}},
+      argsoriginal="(GLFWmonitor* monitor)",
+      call_args="(monitor)",
+      cimguiname="ImGui_ImplGlfw_GetContentScaleForMonitor",
+      defaults={},
+      funcname="ImGui_ImplGlfw_GetContentScaleForMonitor",
+      location="imgui_impl_glfw:67",
+      ov_cimguiname="ImGui_ImplGlfw_GetContentScaleForMonitor",
+      ret="float",
+      signature="(GLFWmonitor*)",
+      stname=""},
+    ["(GLFWmonitor*)"]=nil},
+  ImGui_ImplGlfw_GetContentScaleForWindow={
+    [1]={
+      args="(GLFWwindow* window)",
+      argsT={
+        [1]={
+          name="window",
+          type="GLFWwindow*"}},
+      argsoriginal="(GLFWwindow* window)",
+      call_args="(window)",
+      cimguiname="ImGui_ImplGlfw_GetContentScaleForWindow",
+      defaults={},
+      funcname="ImGui_ImplGlfw_GetContentScaleForWindow",
+      location="imgui_impl_glfw:66",
+      ov_cimguiname="ImGui_ImplGlfw_GetContentScaleForWindow",
+      ret="float",
+      signature="(GLFWwindow*)",
+      stname=""},
+    ["(GLFWwindow*)"]=nil},
   ImGui_ImplGlfw_InitForOpenGL={
     [1]={
       args="(GLFWwindow* window,bool install_callbacks)",
@@ -80,7 +116,7 @@ local t={
       cimguiname="ImGui_ImplGlfw_InitForOpenGL",
       defaults={},
       funcname="ImGui_ImplGlfw_InitForOpenGL",
-      location="imgui_impl_glfw:31",
+      location="imgui_impl_glfw:32",
       ov_cimguiname="ImGui_ImplGlfw_InitForOpenGL",
       ret="bool",
       signature="(GLFWwindow*,bool)",
@@ -101,7 +137,7 @@ local t={
       cimguiname="ImGui_ImplGlfw_InitForOther",
       defaults={},
       funcname="ImGui_ImplGlfw_InitForOther",
-      location="imgui_impl_glfw:33",
+      location="imgui_impl_glfw:34",
       ov_cimguiname="ImGui_ImplGlfw_InitForOther",
       ret="bool",
       signature="(GLFWwindow*,bool)",
@@ -122,7 +158,7 @@ local t={
       cimguiname="ImGui_ImplGlfw_InitForVulkan",
       defaults={},
       funcname="ImGui_ImplGlfw_InitForVulkan",
-      location="imgui_impl_glfw:32",
+      location="imgui_impl_glfw:33",
       ov_cimguiname="ImGui_ImplGlfw_InitForVulkan",
       ret="bool",
       signature="(GLFWwindow*,bool)",
@@ -140,7 +176,7 @@ local t={
       cimguiname="ImGui_ImplGlfw_InstallCallbacks",
       defaults={},
       funcname="ImGui_ImplGlfw_InstallCallbacks",
-      location="imgui_impl_glfw:46",
+      location="imgui_impl_glfw:47",
       ov_cimguiname="ImGui_ImplGlfw_InstallCallbacks",
       ret="void",
       signature="(GLFWwindow*)",
@@ -170,7 +206,7 @@ local t={
       cimguiname="ImGui_ImplGlfw_KeyCallback",
       defaults={},
       funcname="ImGui_ImplGlfw_KeyCallback",
-      location="imgui_impl_glfw:59",
+      location="imgui_impl_glfw:60",
       ov_cimguiname="ImGui_ImplGlfw_KeyCallback",
       ret="void",
       signature="(GLFWwindow*,int,int,int,int)",
@@ -191,7 +227,7 @@ local t={
       cimguiname="ImGui_ImplGlfw_MonitorCallback",
       defaults={},
       funcname="ImGui_ImplGlfw_MonitorCallback",
-      location="imgui_impl_glfw:61",
+      location="imgui_impl_glfw:62",
       ov_cimguiname="ImGui_ImplGlfw_MonitorCallback",
       ret="void",
       signature="(GLFWmonitor*,int)",
@@ -218,7 +254,7 @@ local t={
       cimguiname="ImGui_ImplGlfw_MouseButtonCallback",
       defaults={},
       funcname="ImGui_ImplGlfw_MouseButtonCallback",
-      location="imgui_impl_glfw:57",
+      location="imgui_impl_glfw:58",
       ov_cimguiname="ImGui_ImplGlfw_MouseButtonCallback",
       ret="void",
       signature="(GLFWwindow*,int,int,int)",
@@ -233,7 +269,7 @@ local t={
       cimguiname="ImGui_ImplGlfw_NewFrame",
       defaults={},
       funcname="ImGui_ImplGlfw_NewFrame",
-      location="imgui_impl_glfw:35",
+      location="imgui_impl_glfw:36",
       ov_cimguiname="ImGui_ImplGlfw_NewFrame",
       ret="void",
       signature="()",
@@ -251,7 +287,7 @@ local t={
       cimguiname="ImGui_ImplGlfw_RestoreCallbacks",
       defaults={},
       funcname="ImGui_ImplGlfw_RestoreCallbacks",
-      location="imgui_impl_glfw:47",
+      location="imgui_impl_glfw:48",
       ov_cimguiname="ImGui_ImplGlfw_RestoreCallbacks",
       ret="void",
       signature="(GLFWwindow*)",
@@ -275,7 +311,7 @@ local t={
       cimguiname="ImGui_ImplGlfw_ScrollCallback",
       defaults={},
       funcname="ImGui_ImplGlfw_ScrollCallback",
-      location="imgui_impl_glfw:58",
+      location="imgui_impl_glfw:59",
       ov_cimguiname="ImGui_ImplGlfw_ScrollCallback",
       ret="void",
       signature="(GLFWwindow*,double,double)",
@@ -293,7 +329,7 @@ local t={
       cimguiname="ImGui_ImplGlfw_SetCallbacksChainForAllWindows",
       defaults={},
       funcname="ImGui_ImplGlfw_SetCallbacksChainForAllWindows",
-      location="imgui_impl_glfw:51",
+      location="imgui_impl_glfw:52",
       ov_cimguiname="ImGui_ImplGlfw_SetCallbacksChainForAllWindows",
       ret="void",
       signature="(bool)",
@@ -308,7 +344,7 @@ local t={
       cimguiname="ImGui_ImplGlfw_Shutdown",
       defaults={},
       funcname="ImGui_ImplGlfw_Shutdown",
-      location="imgui_impl_glfw:34",
+      location="imgui_impl_glfw:35",
       ov_cimguiname="ImGui_ImplGlfw_Shutdown",
       ret="void",
       signature="()",
@@ -326,7 +362,7 @@ local t={
       cimguiname="ImGui_ImplGlfw_Sleep",
       defaults={},
       funcname="ImGui_ImplGlfw_Sleep",
-      location="imgui_impl_glfw:64",
+      location="imgui_impl_glfw:65",
       ov_cimguiname="ImGui_ImplGlfw_Sleep",
       ret="void",
       signature="(int)",
@@ -347,7 +383,7 @@ local t={
       cimguiname="ImGui_ImplGlfw_WindowFocusCallback",
       defaults={},
       funcname="ImGui_ImplGlfw_WindowFocusCallback",
-      location="imgui_impl_glfw:54",
+      location="imgui_impl_glfw:55",
       ov_cimguiname="ImGui_ImplGlfw_WindowFocusCallback",
       ret="void",
       signature="(GLFWwindow*,int)",
@@ -362,27 +398,12 @@ local t={
       cimguiname="ImGui_ImplOpenGL2_CreateDeviceObjects",
       defaults={},
       funcname="ImGui_ImplOpenGL2_CreateDeviceObjects",
-      location="imgui_impl_opengl2:38",
+      location="imgui_impl_opengl2:37",
       ov_cimguiname="ImGui_ImplOpenGL2_CreateDeviceObjects",
       ret="bool",
       signature="()",
       stname=""},
     ["()"]=nil},
-  ImGui_ImplOpenGL2_CreateFontsTexture={
-    [1]={
-      args="()",
-      argsT={},
-      argsoriginal="()",
-      call_args="()",
-      cimguiname="ImGui_ImplOpenGL2_CreateFontsTexture",
-      defaults={},
-      funcname="ImGui_ImplOpenGL2_CreateFontsTexture",
-      location="imgui_impl_opengl2:36",
-      ov_cimguiname="ImGui_ImplOpenGL2_CreateFontsTexture",
-      ret="bool",
-      signature="()",
-      stname=""},
-    ["()"]=nil},
   ImGui_ImplOpenGL2_DestroyDeviceObjects={
     [1]={
       args="()",
@@ -392,27 +413,12 @@ local t={
       cimguiname="ImGui_ImplOpenGL2_DestroyDeviceObjects",
       defaults={},
       funcname="ImGui_ImplOpenGL2_DestroyDeviceObjects",
-      location="imgui_impl_opengl2:39",
+      location="imgui_impl_opengl2:38",
       ov_cimguiname="ImGui_ImplOpenGL2_DestroyDeviceObjects",
       ret="void",
       signature="()",
       stname=""},
     ["()"]=nil},
-  ImGui_ImplOpenGL2_DestroyFontsTexture={
-    [1]={
-      args="()",
-      argsT={},
-      argsoriginal="()",
-      call_args="()",
-      cimguiname="ImGui_ImplOpenGL2_DestroyFontsTexture",
-      defaults={},
-      funcname="ImGui_ImplOpenGL2_DestroyFontsTexture",
-      location="imgui_impl_opengl2:37",
-      ov_cimguiname="ImGui_ImplOpenGL2_DestroyFontsTexture",
-      ret="void",
-      signature="()",
-      stname=""},
-    ["()"]=nil},
   ImGui_ImplOpenGL2_Init={
     [1]={
       args="()",
@@ -422,7 +428,7 @@ local t={
       cimguiname="ImGui_ImplOpenGL2_Init",
       defaults={},
       funcname="ImGui_ImplOpenGL2_Init",
-      location="imgui_impl_opengl2:30",
+      location="imgui_impl_opengl2:31",
       ov_cimguiname="ImGui_ImplOpenGL2_Init",
       ret="bool",
       signature="()",
@@ -437,7 +443,7 @@ local t={
       cimguiname="ImGui_ImplOpenGL2_NewFrame",
       defaults={},
       funcname="ImGui_ImplOpenGL2_NewFrame",
-      location="imgui_impl_opengl2:32",
+      location="imgui_impl_opengl2:33",
       ov_cimguiname="ImGui_ImplOpenGL2_NewFrame",
       ret="void",
       signature="()",
@@ -455,7 +461,7 @@ local t={
       cimguiname="ImGui_ImplOpenGL2_RenderDrawData",
       defaults={},
       funcname="ImGui_ImplOpenGL2_RenderDrawData",
-      location="imgui_impl_opengl2:33",
+      location="imgui_impl_opengl2:34",
       ov_cimguiname="ImGui_ImplOpenGL2_RenderDrawData",
       ret="void",
       signature="(ImDrawData*)",
@@ -470,12 +476,30 @@ local t={
       cimguiname="ImGui_ImplOpenGL2_Shutdown",
       defaults={},
       funcname="ImGui_ImplOpenGL2_Shutdown",
-      location="imgui_impl_opengl2:31",
+      location="imgui_impl_opengl2:32",
       ov_cimguiname="ImGui_ImplOpenGL2_Shutdown",
       ret="void",
       signature="()",
       stname=""},
     ["()"]=nil},
+  ImGui_ImplOpenGL2_UpdateTexture={
+    [1]={
+      args="(ImTextureData* tex)",
+      argsT={
+        [1]={
+          name="tex",
+          type="ImTextureData*"}},
+      argsoriginal="(ImTextureData* tex)",
+      call_args="(tex)",
+      cimguiname="ImGui_ImplOpenGL2_UpdateTexture",
+      defaults={},
+      funcname="ImGui_ImplOpenGL2_UpdateTexture",
+      location="imgui_impl_opengl2:41",
+      ov_cimguiname="ImGui_ImplOpenGL2_UpdateTexture",
+      ret="void",
+      signature="(ImTextureData*)",
+      stname=""},
+    ["(ImTextureData*)"]=nil},
   ImGui_ImplOpenGL3_CreateDeviceObjects={
     [1]={
       args="()",
@@ -485,27 +509,12 @@ local t={
       cimguiname="ImGui_ImplOpenGL3_CreateDeviceObjects",
       defaults={},
       funcname="ImGui_ImplOpenGL3_CreateDeviceObjects",
-      location="imgui_impl_opengl3:41",
+      location="imgui_impl_opengl3:40",
       ov_cimguiname="ImGui_ImplOpenGL3_CreateDeviceObjects",
       ret="bool",
       signature="()",
       stname=""},
     ["()"]=nil},
-  ImGui_ImplOpenGL3_CreateFontsTexture={
-    [1]={
-      args="()",
-      argsT={},
-      argsoriginal="()",
-      call_args="()",
-      cimguiname="ImGui_ImplOpenGL3_CreateFontsTexture",
-      defaults={},
-      funcname="ImGui_ImplOpenGL3_CreateFontsTexture",
-      location="imgui_impl_opengl3:39",
-      ov_cimguiname="ImGui_ImplOpenGL3_CreateFontsTexture",
-      ret="bool",
-      signature="()",
-      stname=""},
-    ["()"]=nil},
   ImGui_ImplOpenGL3_DestroyDeviceObjects={
     [1]={
       args="()",
@@ -515,27 +524,12 @@ local t={
       cimguiname="ImGui_ImplOpenGL3_DestroyDeviceObjects",
       defaults={},
       funcname="ImGui_ImplOpenGL3_DestroyDeviceObjects",
-      location="imgui_impl_opengl3:42",
+      location="imgui_impl_opengl3:41",
       ov_cimguiname="ImGui_ImplOpenGL3_DestroyDeviceObjects",
       ret="void",
       signature="()",
       stname=""},
     ["()"]=nil},
-  ImGui_ImplOpenGL3_DestroyFontsTexture={
-    [1]={
-      args="()",
-      argsT={},
-      argsoriginal="()",
-      call_args="()",
-      cimguiname="ImGui_ImplOpenGL3_DestroyFontsTexture",
-      defaults={},
-      funcname="ImGui_ImplOpenGL3_DestroyFontsTexture",
-      location="imgui_impl_opengl3:40",
-      ov_cimguiname="ImGui_ImplOpenGL3_DestroyFontsTexture",
-      ret="void",
-      signature="()",
-      stname=""},
-    ["()"]=nil},
   ImGui_ImplOpenGL3_Init={
     [1]={
       args="(const char* glsl_version)",
@@ -549,7 +543,7 @@ local t={
       defaults={
         glsl_version="nullptr"},
       funcname="ImGui_ImplOpenGL3_Init",
-      location="imgui_impl_opengl3:33",
+      location="imgui_impl_opengl3:34",
       ov_cimguiname="ImGui_ImplOpenGL3_Init",
       ret="bool",
       signature="(const char*)",
@@ -564,7 +558,7 @@ local t={
       cimguiname="ImGui_ImplOpenGL3_NewFrame",
       defaults={},
       funcname="ImGui_ImplOpenGL3_NewFrame",
-      location="imgui_impl_opengl3:35",
+      location="imgui_impl_opengl3:36",
       ov_cimguiname="ImGui_ImplOpenGL3_NewFrame",
       ret="void",
       signature="()",
@@ -582,7 +576,7 @@ local t={
       cimguiname="ImGui_ImplOpenGL3_RenderDrawData",
       defaults={},
       funcname="ImGui_ImplOpenGL3_RenderDrawData",
-      location="imgui_impl_opengl3:36",
+      location="imgui_impl_opengl3:37",
       ov_cimguiname="ImGui_ImplOpenGL3_RenderDrawData",
       ret="void",
       signature="(ImDrawData*)",
@@ -597,12 +591,66 @@ local t={
       cimguiname="ImGui_ImplOpenGL3_Shutdown",
       defaults={},
       funcname="ImGui_ImplOpenGL3_Shutdown",
-      location="imgui_impl_opengl3:34",
+      location="imgui_impl_opengl3:35",
       ov_cimguiname="ImGui_ImplOpenGL3_Shutdown",
       ret="void",
       signature="()",
       stname=""},
     ["()"]=nil},
+  ImGui_ImplOpenGL3_UpdateTexture={
+    [1]={
+      args="(ImTextureData* tex)",
+      argsT={
+        [1]={
+          name="tex",
+          type="ImTextureData*"}},
+      argsoriginal="(ImTextureData* tex)",
+      call_args="(tex)",
+      cimguiname="ImGui_ImplOpenGL3_UpdateTexture",
+      defaults={},
+      funcname="ImGui_ImplOpenGL3_UpdateTexture",
+      location="imgui_impl_opengl3:44",
+      ov_cimguiname="ImGui_ImplOpenGL3_UpdateTexture",
+      ret="void",
+      signature="(ImTextureData*)",
+      stname=""},
+    ["(ImTextureData*)"]=nil},
+  ImGui_ImplSDL2_GetContentScaleForDisplay={
+    [1]={
+      args="(int display_index)",
+      argsT={
+        [1]={
+          name="display_index",
+          type="int"}},
+      argsoriginal="(int display_index)",
+      call_args="(display_index)",
+      cimguiname="ImGui_ImplSDL2_GetContentScaleForDisplay",
+      defaults={},
+      funcname="ImGui_ImplSDL2_GetContentScaleForDisplay",
+      location="imgui_impl_sdl2:43",
+      ov_cimguiname="ImGui_ImplSDL2_GetContentScaleForDisplay",
+      ret="float",
+      signature="(int)",
+      stname=""},
+    ["(int)"]=nil},
+  ImGui_ImplSDL2_GetContentScaleForWindow={
+    [1]={
+      args="(SDL_Window* window)",
+      argsT={
+        [1]={
+          name="window",
+          type="SDL_Window*"}},
+      argsoriginal="(SDL_Window* window)",
+      call_args="(window)",
+      cimguiname="ImGui_ImplSDL2_GetContentScaleForWindow",
+      defaults={},
+      funcname="ImGui_ImplSDL2_GetContentScaleForWindow",
+      location="imgui_impl_sdl2:42",
+      ov_cimguiname="ImGui_ImplSDL2_GetContentScaleForWindow",
+      ret="float",
+      signature="(SDL_Window*)",
+      stname=""},
+    ["(SDL_Window*)"]=nil},
   ImGui_ImplSDL2_InitForD3D={
     [1]={
       args="(SDL_Window* window)",
@@ -770,7 +818,7 @@ local t={
         manual_gamepads_array="nullptr",
         manual_gamepads_count="-1"},
       funcname="ImGui_ImplSDL2_SetGamepadMode",
-      location="imgui_impl_sdl2:44",
+      location="imgui_impl_sdl2:48",
       ov_cimguiname="ImGui_ImplSDL2_SetGamepadMode",
       ret="void",
       signature="(ImGui_ImplSDL2_GamepadMode,struct _SDL_GameController**,int)",
@@ -1033,7 +1081,7 @@ local t={
       cimguiname="ImGui_ImplVulkanH_CreateOrResizeWindow",
       defaults={},
       funcname="ImGui_ImplVulkanH_CreateOrResizeWindow",
-      location="imgui_impl_vulkan:165",
+      location="imgui_impl_vulkan:166",
       ov_cimguiname="ImGui_ImplVulkanH_CreateOrResizeWindow",
       ret="void",
       signature="(VkInstance,VkPhysicalDevice,VkDevice,ImGui_ImplVulkanH_Window*,uint32_t,const VkAllocationCallbacks*,int,int,uint32_t)",
@@ -1060,7 +1108,7 @@ local t={
       cimguiname="ImGui_ImplVulkanH_DestroyWindow",
       defaults={},
       funcname="ImGui_ImplVulkanH_DestroyWindow",
-      location="imgui_impl_vulkan:166",
+      location="imgui_impl_vulkan:167",
       ov_cimguiname="ImGui_ImplVulkanH_DestroyWindow",
       ret="void",
       signature="(VkInstance,VkDevice,ImGui_ImplVulkanH_Window*,const VkAllocationCallbacks*)",
@@ -1078,7 +1126,7 @@ local t={
       cimguiname="ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
       defaults={},
       funcname="ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
-      location="imgui_impl_vulkan:171",
+      location="imgui_impl_vulkan:172",
       ov_cimguiname="ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
       ret="int",
       signature="(VkPresentModeKHR)",
@@ -1096,7 +1144,7 @@ local t={
       cimguiname="ImGui_ImplVulkanH_SelectPhysicalDevice",
       defaults={},
       funcname="ImGui_ImplVulkanH_SelectPhysicalDevice",
-      location="imgui_impl_vulkan:169",
+      location="imgui_impl_vulkan:170",
       ov_cimguiname="ImGui_ImplVulkanH_SelectPhysicalDevice",
       ret="VkPhysicalDevice",
       signature="(VkInstance)",
@@ -1123,7 +1171,7 @@ local t={
       cimguiname="ImGui_ImplVulkanH_SelectPresentMode",
       defaults={},
       funcname="ImGui_ImplVulkanH_SelectPresentMode",
-      location="imgui_impl_vulkan:168",
+      location="imgui_impl_vulkan:169",
       ov_cimguiname="ImGui_ImplVulkanH_SelectPresentMode",
       ret="VkPresentModeKHR",
       signature="(VkPhysicalDevice,VkSurfaceKHR,const VkPresentModeKHR*,int)",
@@ -1141,7 +1189,7 @@ local t={
       cimguiname="ImGui_ImplVulkanH_SelectQueueFamilyIndex",
       defaults={},
       funcname="ImGui_ImplVulkanH_SelectQueueFamilyIndex",
-      location="imgui_impl_vulkan:170",
+      location="imgui_impl_vulkan:171",
       ov_cimguiname="ImGui_ImplVulkanH_SelectQueueFamilyIndex",
       ret="uint32_t",
       signature="(VkPhysicalDevice)",
@@ -1171,7 +1219,7 @@ local t={
       cimguiname="ImGui_ImplVulkanH_SelectSurfaceFormat",
       defaults={},
       funcname="ImGui_ImplVulkanH_SelectSurfaceFormat",
-      location="imgui_impl_vulkan:167",
+      location="imgui_impl_vulkan:168",
       ov_cimguiname="ImGui_ImplVulkanH_SelectSurfaceFormat",
       ret="VkSurfaceFormatKHR",
       signature="(VkPhysicalDevice,VkSurfaceKHR,const VkFormat*,int,VkColorSpaceKHR)",
@@ -1187,7 +1235,7 @@ local t={
       constructor=true,
       defaults={},
       funcname="ImGui_ImplVulkanH_Window",
-      location="imgui_impl_vulkan:214",
+      location="imgui_impl_vulkan:215",
       ov_cimguiname="ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window",
       signature="()",
       stname="ImGui_ImplVulkanH_Window"},
@@ -1203,7 +1251,7 @@ local t={
       cimguiname="ImGui_ImplVulkanH_Window_destroy",
       defaults={},
       destructor=true,
-      location="imgui_impl_vulkan:214",
+      location="imgui_impl_vulkan:215",
       ov_cimguiname="ImGui_ImplVulkanH_Window_destroy",
       ret="void",
       signature="(ImGui_ImplVulkanH_Window*)",
@@ -1227,42 +1275,12 @@ local t={
       cimguiname="ImGui_ImplVulkan_AddTexture",
       defaults={},
       funcname="ImGui_ImplVulkan_AddTexture",
-      location="imgui_impl_vulkan:122",
+      location="imgui_impl_vulkan:123",
       ov_cimguiname="ImGui_ImplVulkan_AddTexture",
       ret="VkDescriptorSet",
       signature="(VkSampler,VkImageView,VkImageLayout)",
       stname=""},
     ["(VkSampler,VkImageView,VkImageLayout)"]=nil},
-  ImGui_ImplVulkan_CreateFontsTexture={
-    [1]={
-      args="()",
-      argsT={},
-      argsoriginal="()",
-      call_args="()",
-      cimguiname="ImGui_ImplVulkan_CreateFontsTexture",
-      defaults={},
-      funcname="ImGui_ImplVulkan_CreateFontsTexture",
-      location="imgui_impl_vulkan:115",
-      ov_cimguiname="ImGui_ImplVulkan_CreateFontsTexture",
-      ret="bool",
-      signature="()",
-      stname=""},
-    ["()"]=nil},
-  ImGui_ImplVulkan_DestroyFontsTexture={
-    [1]={
-      args="()",
-      argsT={},
-      argsoriginal="()",
-      call_args="()",
-      cimguiname="ImGui_ImplVulkan_DestroyFontsTexture",
-      defaults={},
-      funcname="ImGui_ImplVulkan_DestroyFontsTexture",
-      location="imgui_impl_vulkan:116",
-      ov_cimguiname="ImGui_ImplVulkan_DestroyFontsTexture",
-      ret="void",
-      signature="()",
-      stname=""},
-    ["()"]=nil},
   ImGui_ImplVulkan_Init={
     [1]={
       args="(ImGui_ImplVulkan_InitInfo* info)",
@@ -1300,7 +1318,7 @@ local t={
       defaults={
         user_data="nullptr"},
       funcname="ImGui_ImplVulkan_LoadFunctions",
-      location="imgui_impl_vulkan:127",
+      location="imgui_impl_vulkan:128",
       ov_cimguiname="ImGui_ImplVulkan_LoadFunctions",
       ret="bool",
       signature="(uint32_t,PFN_vkVoidFunction(*loader_func)(const char* function_name,void*,void*)",
@@ -1333,7 +1351,7 @@ local t={
       cimguiname="ImGui_ImplVulkan_RemoveTexture",
       defaults={},
       funcname="ImGui_ImplVulkan_RemoveTexture",
-      location="imgui_impl_vulkan:123",
+      location="imgui_impl_vulkan:124",
       ov_cimguiname="ImGui_ImplVulkan_RemoveTexture",
       ret="void",
       signature="(VkDescriptorSet)",
@@ -1376,7 +1394,7 @@ local t={
       cimguiname="ImGui_ImplVulkan_SetMinImageCount",
       defaults={},
       funcname="ImGui_ImplVulkan_SetMinImageCount",
-      location="imgui_impl_vulkan:117",
+      location="imgui_impl_vulkan:115",
       ov_cimguiname="ImGui_ImplVulkan_SetMinImageCount",
       ret="void",
       signature="(uint32_t)",
@@ -1396,10 +1414,30 @@ local t={
       ret="void",
       signature="()",
       stname=""},
-    ["()"]=nil}}
+    ["()"]=nil},
+  ImGui_ImplVulkan_UpdateTexture={
+    [1]={
+      args="(ImTextureData* tex)",
+      argsT={
+        [1]={
+          name="tex",
+          type="ImTextureData*"}},
+      argsoriginal="(ImTextureData* tex)",
+      call_args="(tex)",
+      cimguiname="ImGui_ImplVulkan_UpdateTexture",
+      defaults={},
+      funcname="ImGui_ImplVulkan_UpdateTexture",
+      location="imgui_impl_vulkan:118",
+      ov_cimguiname="ImGui_ImplVulkan_UpdateTexture",
+      ret="void",
+      signature="(ImTextureData*)",
+      stname=""},
+    ["(ImTextureData*)"]=nil}}
 t.ImGui_ImplGlfw_CharCallback["(GLFWwindow*,unsigned int)"]=t.ImGui_ImplGlfw_CharCallback[1]
 t.ImGui_ImplGlfw_CursorEnterCallback["(GLFWwindow*,int)"]=t.ImGui_ImplGlfw_CursorEnterCallback[1]
 t.ImGui_ImplGlfw_CursorPosCallback["(GLFWwindow*,double,double)"]=t.ImGui_ImplGlfw_CursorPosCallback[1]
+t.ImGui_ImplGlfw_GetContentScaleForMonitor["(GLFWmonitor*)"]=t.ImGui_ImplGlfw_GetContentScaleForMonitor[1]
+t.ImGui_ImplGlfw_GetContentScaleForWindow["(GLFWwindow*)"]=t.ImGui_ImplGlfw_GetContentScaleForWindow[1]
 t.ImGui_ImplGlfw_InitForOpenGL["(GLFWwindow*,bool)"]=t.ImGui_ImplGlfw_InitForOpenGL[1]
 t.ImGui_ImplGlfw_InitForOther["(GLFWwindow*,bool)"]=t.ImGui_ImplGlfw_InitForOther[1]
 t.ImGui_ImplGlfw_InitForVulkan["(GLFWwindow*,bool)"]=t.ImGui_ImplGlfw_InitForVulkan[1]
@@ -1415,21 +1453,21 @@ t.ImGui_ImplGlfw_Shutdown["()"]=t.ImGui_ImplGlfw_Shutdown[1]
 t.ImGui_ImplGlfw_Sleep["(int)"]=t.ImGui_ImplGlfw_Sleep[1]
 t.ImGui_ImplGlfw_WindowFocusCallback["(GLFWwindow*,int)"]=t.ImGui_ImplGlfw_WindowFocusCallback[1]
 t.ImGui_ImplOpenGL2_CreateDeviceObjects["()"]=t.ImGui_ImplOpenGL2_CreateDeviceObjects[1]
-t.ImGui_ImplOpenGL2_CreateFontsTexture["()"]=t.ImGui_ImplOpenGL2_CreateFontsTexture[1]
 t.ImGui_ImplOpenGL2_DestroyDeviceObjects["()"]=t.ImGui_ImplOpenGL2_DestroyDeviceObjects[1]
-t.ImGui_ImplOpenGL2_DestroyFontsTexture["()"]=t.ImGui_ImplOpenGL2_DestroyFontsTexture[1]
 t.ImGui_ImplOpenGL2_Init["()"]=t.ImGui_ImplOpenGL2_Init[1]
 t.ImGui_ImplOpenGL2_NewFrame["()"]=t.ImGui_ImplOpenGL2_NewFrame[1]
 t.ImGui_ImplOpenGL2_RenderDrawData["(ImDrawData*)"]=t.ImGui_ImplOpenGL2_RenderDrawData[1]
 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_CreateFontsTexture["()"]=t.ImGui_ImplOpenGL3_CreateFontsTexture[1]
 t.ImGui_ImplOpenGL3_DestroyDeviceObjects["()"]=t.ImGui_ImplOpenGL3_DestroyDeviceObjects[1]
-t.ImGui_ImplOpenGL3_DestroyFontsTexture["()"]=t.ImGui_ImplOpenGL3_DestroyFontsTexture[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]
 t.ImGui_ImplOpenGL3_Shutdown["()"]=t.ImGui_ImplOpenGL3_Shutdown[1]
+t.ImGui_ImplOpenGL3_UpdateTexture["(ImTextureData*)"]=t.ImGui_ImplOpenGL3_UpdateTexture[1]
+t.ImGui_ImplSDL2_GetContentScaleForDisplay["(int)"]=t.ImGui_ImplSDL2_GetContentScaleForDisplay[1]
+t.ImGui_ImplSDL2_GetContentScaleForWindow["(SDL_Window*)"]=t.ImGui_ImplSDL2_GetContentScaleForWindow[1]
 t.ImGui_ImplSDL2_InitForD3D["(SDL_Window*)"]=t.ImGui_ImplSDL2_InitForD3D[1]
 t.ImGui_ImplSDL2_InitForMetal["(SDL_Window*)"]=t.ImGui_ImplSDL2_InitForMetal[1]
 t.ImGui_ImplSDL2_InitForOpenGL["(SDL_Window*,void*)"]=t.ImGui_ImplSDL2_InitForOpenGL[1]
@@ -1461,8 +1499,6 @@ t.ImGui_ImplVulkanH_SelectSurfaceFormat["(VkPhysicalDevice,VkSurfaceKHR,const Vk
 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_CreateFontsTexture["()"]=t.ImGui_ImplVulkan_CreateFontsTexture[1]
-t.ImGui_ImplVulkan_DestroyFontsTexture["()"]=t.ImGui_ImplVulkan_DestroyFontsTexture[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]
 t.ImGui_ImplVulkan_NewFrame["()"]=t.ImGui_ImplVulkan_NewFrame[1]
@@ -1470,4 +1506,5 @@ t.ImGui_ImplVulkan_RemoveTexture["(VkDescriptorSet)"]=t.ImGui_ImplVulkan_RemoveT
 t.ImGui_ImplVulkan_RenderDrawData["(ImDrawData*,VkCommandBuffer,VkPipeline)"]=t.ImGui_ImplVulkan_RenderDrawData[1]
 t.ImGui_ImplVulkan_SetMinImageCount["(uint32_t)"]=t.ImGui_ImplVulkan_SetMinImageCount[1]
 t.ImGui_ImplVulkan_Shutdown["()"]=t.ImGui_ImplVulkan_Shutdown[1]
+t.ImGui_ImplVulkan_UpdateTexture["(ImTextureData*)"]=t.ImGui_ImplVulkan_UpdateTexture[1]
  return t

generator/output/overloads.txt

@@ -56,12 +56,18 @@ ImSpan_end	2
 ImSpan_set	2
 1	void	ImSpan_set_Int (T*,int)
 2	void	ImSpan_set_TPtr (T*,T*)
+ImTextureRef_ImTextureRef	2
+1	nil	ImTextureRef_ImTextureRef_Nil ()
+2	nil	ImTextureRef_ImTextureRef_TextureID (ImTextureID)
 ImVec1_ImVec1	2
 1	nil	ImVec1_ImVec1_Nil ()
 2	nil	ImVec1_ImVec1_Float (float)
 ImVec2_ImVec2	2
 1	nil	ImVec2_ImVec2_Nil ()
 2	nil	ImVec2_ImVec2_Float (float,float)
+ImVec2i_ImVec2i	2
+1	nil	ImVec2i_ImVec2i_Nil ()
+2	nil	ImVec2i_ImVec2i_Int (int,int)
 ImVec2ih_ImVec2ih	3
 1	nil	ImVec2ih_ImVec2ih_Nil ()
 2	nil	ImVec2ih_ImVec2ih_short (short,short)
@@ -128,8 +134,8 @@ igGetIDWithSeed	2
 1	ImGuiID	igGetIDWithSeed_Str (const char*,const char*,ImGuiID)
 2	ImGuiID	igGetIDWithSeed_Int (int,ImGuiID)
 igGetIO	2
-1	ImGuiIO*	igGetIO ()
-2	ImGuiIO*	igGetIOEx (ImGuiContext*)
+1	ImGuiIO*	igGetIO_Nil ()
+2	ImGuiIO*	igGetIO_ContextPtr (ImGuiContext*)
 igGetKeyData	2
 1	ImGuiKeyData*	igGetKeyData_ContextPtr (ImGuiContext*,ImGuiKey)
 2	ImGuiKeyData*	igGetKeyData_Key (ImGuiKey)
@@ -303,4 +309,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*)
-212 overloaded
+216 overloaded

generator/output/typedefs_dict.json

@@ -19,12 +19,19 @@
   "ImFileHandle": "FILE*",
   "ImFont": "struct ImFont",
   "ImFontAtlas": "struct ImFontAtlas",
-  "ImFontAtlasCustomRect": "struct ImFontAtlasCustomRect",
+  "ImFontAtlasBuilder": "struct ImFontAtlasBuilder",
   "ImFontAtlasFlags": "int",
-  "ImFontBuilderIO": "struct ImFontBuilderIO",
+  "ImFontAtlasPostProcessData": "struct ImFontAtlasPostProcessData",
+  "ImFontAtlasRect": "struct ImFontAtlasRect",
+  "ImFontAtlasRectEntry": "struct ImFontAtlasRectEntry",
+  "ImFontAtlasRectId": "int",
+  "ImFontBaked": "struct ImFontBaked",
   "ImFontConfig": "struct ImFontConfig",
+  "ImFontFlags": "int",
   "ImFontGlyph": "struct ImFontGlyph",
   "ImFontGlyphRangesBuilder": "struct ImFontGlyphRangesBuilder",
+  "ImFontLoader": "struct ImFontLoader",
+  "ImFontStackData": "struct ImFontStackData",
   "ImGuiActivateFlags": "int",
   "ImGuiBackendFlags": "int",
   "ImGuiBoxSelectState": "struct ImGuiBoxSelectState",
@@ -53,6 +60,7 @@
   "ImGuiFocusRequestFlags": "int",
   "ImGuiFocusScopeData": "struct ImGuiFocusScopeData",
   "ImGuiFocusedFlags": "int",
+  "ImGuiFreeTypeLoaderFlags": "unsigned int",
   "ImGuiGroupData": "struct ImGuiGroupData",
   "ImGuiHoveredFlags": "int",
   "ImGuiID": "unsigned int",
@@ -181,17 +189,24 @@
   "ImS64": "signed long long",
   "ImS8": "signed char",
   "ImStbTexteditState": "ImStb::STB_TexteditState",
+  "ImTextureData": "struct ImTextureData",
   "ImTextureID": "ImU64",
+  "ImTextureRect": "struct ImTextureRect",
+  "ImTextureRef": "struct ImTextureRef",
   "ImU16": "unsigned short",
   "ImU32": "unsigned int",
   "ImU64": "unsigned long long",
   "ImU8": "unsigned char",
   "ImVec1": "struct ImVec1",
   "ImVec2": "struct ImVec2",
+  "ImVec2i": "struct ImVec2i",
   "ImVec2ih": "struct ImVec2ih",
   "ImVec4": "struct ImVec4",
   "ImWchar": "ImWchar16",
   "ImWchar16": "unsigned short",
   "ImWchar32": "unsigned int",
-  "STB_TexteditState": "struct STB_TexteditState"
+  "STB_TexteditState": "struct STB_TexteditState",
+  "stbrp_context_opaque": "struct stbrp_context_opaque",
+  "stbrp_node": "struct stbrp_node",
+  "stbrp_node_im": "stbrp_node"
 }

generator/output/typedefs_dict.lua

@@ -19,12 +19,19 @@ local t={
   ImFileHandle="FILE*",
   ImFont="struct ImFont",
   ImFontAtlas="struct ImFontAtlas",
-  ImFontAtlasCustomRect="struct ImFontAtlasCustomRect",
+  ImFontAtlasBuilder="struct ImFontAtlasBuilder",
   ImFontAtlasFlags="int",
-  ImFontBuilderIO="struct ImFontBuilderIO",
+  ImFontAtlasPostProcessData="struct ImFontAtlasPostProcessData",
+  ImFontAtlasRect="struct ImFontAtlasRect",
+  ImFontAtlasRectEntry="struct ImFontAtlasRectEntry",
+  ImFontAtlasRectId="int",
+  ImFontBaked="struct ImFontBaked",
   ImFontConfig="struct ImFontConfig",
+  ImFontFlags="int",
   ImFontGlyph="struct ImFontGlyph",
   ImFontGlyphRangesBuilder="struct ImFontGlyphRangesBuilder",
+  ImFontLoader="struct ImFontLoader",
+  ImFontStackData="struct ImFontStackData",
   ImGuiActivateFlags="int",
   ImGuiBackendFlags="int",
   ImGuiBoxSelectState="struct ImGuiBoxSelectState",
@@ -53,6 +60,7 @@ local t={
   ImGuiFocusRequestFlags="int",
   ImGuiFocusScopeData="struct ImGuiFocusScopeData",
   ImGuiFocusedFlags="int",
+  ImGuiFreeTypeLoaderFlags="unsigned int",
   ImGuiGroupData="struct ImGuiGroupData",
   ImGuiHoveredFlags="int",
   ImGuiID="unsigned int",
@@ -181,17 +189,24 @@ local t={
   ImS64="signed long long",
   ImS8="signed char",
   ImStbTexteditState="ImStb::STB_TexteditState",
+  ImTextureData="struct ImTextureData",
   ImTextureID="ImU64",
+  ImTextureRect="struct ImTextureRect",
+  ImTextureRef="struct ImTextureRef",
   ImU16="unsigned short",
   ImU32="unsigned int",
   ImU64="unsigned long long",
   ImU8="unsigned char",
   ImVec1="struct ImVec1",
   ImVec2="struct ImVec2",
+  ImVec2i="struct ImVec2i",
   ImVec2ih="struct ImVec2ih",
   ImVec4="struct ImVec4",
   ImWchar="ImWchar16",
   ImWchar16="unsigned short",
   ImWchar32="unsigned int",
-  STB_TexteditState="struct STB_TexteditState"}
+  STB_TexteditState="struct STB_TexteditState",
+  stbrp_context_opaque="struct stbrp_context_opaque",
+  stbrp_node="struct stbrp_node",
+  stbrp_node_im="stbrp_node"}
  return t

test/main.c

@@ -11,6 +11,8 @@
 #define igDebugCheckVersionAndDataLayout igDebugCheckVersionAndDataLayout_Str
 #endif
 
+#define igGetIO igGetIO_Nil
+
 int main(void)
 {
   assert(igDebugCheckVersionAndDataLayout(igGetVersion(), sizeof(ImGuiIO), sizeof(ImGuiStyle),
@@ -20,9 +22,10 @@ int main(void)
   igCreateContext(NULL);
   ImGuiIO *io = igGetIO();
 
-  unsigned char *text_pixels = NULL;
-  int text_w, text_h;
-  ImFontAtlas_GetTexDataAsRGBA32(io->Fonts, &text_pixels, &text_w, &text_h, NULL);
+  // unsigned char *text_pixels = NULL;
+  // int text_w, text_h;
+  // ImFontAtlas_GetTexDataAsRGBA32(io->Fonts, &text_pixels, &text_w, &text_h, NULL);
+  io->BackendFlags |= ImGuiBackendFlags_RendererHasTextures;
 
   for (int n = 0; n < 20; n++) {
     printf("NewFrame() %d\n", n);