Merge branch 'docking_inter'

cpp2ffi.lua: clean = default in constructor (appears in implot3d)
move imgui_freetype include from cimgui.cpp to cimgui.h
2025-08-10 20:08:31 +01:00 · 2025-07-01 11:34:22 +02:00 · 2025-06-27 18:00:19 +02:00 · 2025-06-27 17:10:26 +02:00 · 2025-06-27 11:51:33 +02:00 · 2025-06-27 11:40:08 +02:00
43 changed files with 16583 additions and 7973 deletions
--- a/CMakeLists.txt
+++ b/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)
--- a/README.md
+++ b/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.8 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.
@@ -92,10 +92,10 @@ Notes:
 * methods have the same parameter list and return values (where possible)
 * functions that belong to a struct have an extra first argument with a pointer to the struct.
 * where a function returns UDT (user defined type) by value some compilers complain so the function is generated accepting a pointer to the UDT type as the first argument (or second if belongs to a struct).
-
+* constructors return pointer to struct and has been named Struct_name_Struct_name
 # usage with backends

-* look at backend_test folder for a cmake module building with SDL and opengl3, glfw and opengl3, SDL and Vulkan
+* look at backend_test folder for a cmake module building with SDL and opengl3, glfw and opengl3, SDL and Vulkan, glfw and dx11
 * read [How can cimgui backends be used](https://github.com/cimgui/cimgui/issues/157)

 # example bindings based on cimgui
--- a/backend_test/cmake/GenerateCimguiBindings.cmake
+++ b/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()
--- a/backend_test/example_glfw_dx11/CMakeLists.txt
+++ b/backend_test/example_glfw_dx11/CMakeLists.txt
@@ -1,110 +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
-include_directories(../../generator/output/)
-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
+)
--- a/backend_test/example_glfw_dx11/README.md
+++ b/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.
--- a/backend_test/example_glfw_dx11/main.c
+++ b/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
--- a/backend_test/example_glfw_opengl3/CMakeLists.txt
+++ b/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
@@ -106,7 +109,6 @@ target_link_libraries(cimgui ${IMGUI_LIBRARIES} glfw)


 # using library
-include_directories(../../generator/output/)
 add_executable(${PROJECT_NAME} main.c)
 target_compile_definitions(${PROJECT_NAME} PUBLIC -DCIMGUI_USE_OPENGL3 -DCIMGUI_USE_GLFW)
 target_link_libraries(${PROJECT_NAME} cimgui)
--- a/backend_test/example_glfw_opengl3/main.c
+++ b/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);

--- a/backend_test/example_sdl3_vulkan/CMakeLists.txt
+++ b/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})
+
--- a/backend_test/example_sdl3_vulkan/README.md
+++ b/backend_test/example_sdl3_vulkan/README.md
@@ -0,0 +1,2 @@
+
+To build use `cmake path_to_example_sdl3_vulkan` and then `make install`
--- a/backend_test/example_sdl3_vulkan/main.c
+++ b/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;
+}
--- a/backend_test/example_sdl_opengl3/CMakeLists.txt
+++ b/backend_test/example_sdl_opengl3/CMakeLists.txt
@@ -22,8 +22,6 @@ else()
 endif()

 include_directories(../../imgui)
-add_definitions("-DIMGUI_USER_CONFIG=\"../cimconfig.h\"")
-add_definitions("-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")

 include_directories(../../)
 set(IMGUI_SOURCES 
@@ -38,11 +36,7 @@ ${TABLES_SOURCE}
 set(IMGUI_SOURCES_sdl)
 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")

@@ -66,47 +60,46 @@ else(WIN32)#Unix
 endif(WIN32)


-#sdl2
 list(APPEND IMGUI_SOURCES ${BAKENDS_FOLDER}imgui_impl_sdl2.cpp)
-if(DEFINED SDL_PATH)
-	message(STATUS "SDL_PATH defined as " ${SDL_PATH})
-	FIND_PACKAGE(SDL2 PATHS ${SDL_PATH})
-else(DEFINED SDL_PATH)
-	# If SDL_PATH is not set, fallback and attempt to find SDL cmake script at a default location
-	find_package(SDL2)
-endif(DEFINED SDL_PATH)
+include(FetchContent)
+Set(FETCHCONTENT_QUIET FALSE)

-if(SDL2_FOUND)
-	get_target_property(SDL_INCLUDE SDL2::SDL2 INTERFACE_INCLUDE_DIRECTORIES)
-	message(STATUS "sdlinclude is " ${SDL_INCLUDE})
-	if ("${SDL_INCLUDE}" STREQUAL "" OR "${SDL_INCLUDE}" STREQUAL "SDL_INCLUDE-NOTFOUND") #if not found latest SDL2 cmake config use older
-		message(STATUS "sdlinclude2 is " ${SDL2_INCLUDE_DIRS})
-		include_directories(${SDL2_INCLUDE_DIRS})
-		set(IMGUI_SDL_LIBRARY ${SDL2_LIBRARIES})
-		message(STATUS IMGUI_SDL_LIBRARY ${SDL2_LIBRARIES})
-	else()#use new one SDL2 config
-		include_directories(${SDL_INCLUDE})
-		set(IMGUI_SDL_LIBRARY SDL2::SDL2)
-		set(SDL_MAIN SDL2::SDL2main)
-		message(STATUS ${SDL_MAIN} ${IMGUI_SDL_LIBRARY})
-	endif()
-else(SDL2_FOUND)
-	if(DEFINED SDL_PATH)
-		message(FATAL_ERROR "Cannot find SDL at SDL_PATH")
-	else(DEFINED SDL_PATH)
-		message(FATAL_ERROR "Cannot find SDL. Maybe try specifying SDL_PATH?")
-	endif(DEFINED SDL_PATH)
-endif(SDL2_FOUND)
+FetchContent_Declare(
+        SDL2
+        GIT_REPOSITORY https://github.com/libsdl-org/SDL.git
+        GIT_TAG release-2.30.12
+        #GIT_SHALLOW TRUE
+        GIT_PROGRESS TRUE
+)
+#FetchContent_MakeAvailable(SDL2)
+FetchContent_GetProperties(SDL2)
+if (NOT sdl2_POPULATED)
+	set(FETCHCONTENT_QUIET NO)
+    FetchContent_Populate(SDL2)
+	set(SDL_TEST OFF CACHE BOOL "" FORCE)
+	set(BUILD_SHARED_LIBS ON CACHE BOOL "" FORCE)
+	add_subdirectory(${sdl2_SOURCE_DIR} ${sdl2_BINARY_DIR})
+endif()
+include_directories(${SDL2_SOURCE_DIR}/include})
+
+#if dynamic SDL2 then install
+install(TARGETS SDL2 RUNTIME DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
+					LIBRARY DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
+)

 add_library(cimgui_sdl SHARED ${IMGUI_SOURCES})
-target_link_libraries(cimgui_sdl ${IMGUI_LIBRARIES} ${IMGUI_SDL_LIBRARY})
+target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
+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} SDL2)

 #using library
-include_directories(../../generator/output/)
 add_executable(test_sdl main.c)
 target_compile_definitions(test_sdl PUBLIC -DCIMGUI_USE_OPENGL3 -DCIMGUI_USE_SDL2)
 if (MINGW)
 target_link_options(test_sdl PRIVATE "-mconsole")
 endif()
-target_link_libraries(test_sdl ${IMGUI_SDL_LIBRARY} cimgui_sdl)
-
+target_link_libraries(test_sdl SDL2 cimgui_sdl)
--- a/backend_test/example_sdl_opengl3/README.md
+++ b/backend_test/example_sdl_opengl3/README.md
@@ -0,0 +1,2 @@
+
+To build use `cmake path_to_example_sdl_opengl3` and then `make install`
--- a/backend_test/example_sdl_opengl3/main.c
+++ b/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);

--- a/backend_test/example_sdl_vulkan/CMakeLists.txt
+++ b/backend_test/example_sdl_vulkan/CMakeLists.txt
@@ -18,12 +18,12 @@ else()
 	set(TABLES_SOURCE "")
 endif()

-include_directories(../../imgui)
-add_definitions("-DIMGUI_USER_CONFIG=\"../cimconfig.h\"")
-add_definitions("-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
+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
@@ -34,11 +34,6 @@ ${TABLES_SOURCE}
 set(IMGUI_SOURCES_sdl)
 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)

 #optional adding freetype
 option(IMGUI_FREETYPE "add Freetype2" OFF)
@@ -54,48 +49,52 @@ endif(IMGUI_FREETYPE)
 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})

 #sdl2
 list(APPEND IMGUI_SOURCES ${BACKENDS_FOLDER}imgui_impl_sdl2.cpp)
-if(DEFINED SDL_PATH)
-	message(STATUS "SDL_PATH defined as " ${SDL_PATH})
-	FIND_PACKAGE(SDL2 PATHS ${SDL_PATH})
-else(DEFINED SDL_PATH)
-	# If SDL_PATH is not set, fallback and attempt to find SDL cmake script at a default location
-	find_package(SDL2)
-endif(DEFINED SDL_PATH)
+include(FetchContent)
+Set(FETCHCONTENT_QUIET FALSE)

-if(SDL2_FOUND)
-	get_target_property(SDL_INCLUDE SDL2::SDL2 INTERFACE_INCLUDE_DIRECTORIES)
-	message(STATUS "sdlinclude is " ${SDL_INCLUDE})
-	if ("${SDL_INCLUDE}" STREQUAL "" OR "${SDL_INCLUDE}" STREQUAL "SDL_INCLUDE-NOTFOUND") #if not found latest SDL2 cmake config use older
-		message(STATUS "sdlinclude2 is " ${SDL2_INCLUDE_DIRS})
-		include_directories(${SDL2_INCLUDE_DIRS})
-		set(IMGUI_SDL_LIBRARY ${SDL2_LIBRARIES})
-		message(STATUS IMGUI_SDL_LIBRARY ${SDL2_LIBRARIES})
-	else()#use new one SDL2 config
-		include_directories(${SDL_INCLUDE})
-		set(IMGUI_SDL_LIBRARY SDL2::SDL2)
-		set(SDL_MAIN SDL2::SDL2main)
-		message(STATUS ${SDL_MAIN} ${IMGUI_SDL_LIBRARY})
-	endif()
-else(SDL2_FOUND)
-	if(DEFINED SDL_PATH)
-		message(FATAL_ERROR "Cannot find SDL at SDL_PATH")
-	else(DEFINED SDL_PATH)
-		message(FATAL_ERROR "Cannot find SDL. Maybe try specifying SDL_PATH?")
-	endif(DEFINED SDL_PATH)
-endif(SDL2_FOUND)
+FetchContent_Declare(
+        SDL2
+        GIT_REPOSITORY https://github.com/libsdl-org/SDL.git
+        GIT_TAG release-2.30.12
+        #GIT_SHALLOW TRUE
+        GIT_PROGRESS TRUE
+)
+FetchContent_GetProperties(SDL2)
+if (NOT sdl2_POPULATED)
+	set(FETCHCONTENT_QUIET NO)
+    FetchContent_Populate(SDL2)
+	set(SDL_TEST OFF CACHE BOOL "" FORCE)
+	set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
+	add_subdirectory(${sdl2_SOURCE_DIR} ${sdl2_BINARY_DIR})
+endif()
+include_directories(${SDL2_SOURCE_DIR}/include)

-add_library(cimgui_sdl SHARED ${IMGUI_SOURCES})
-target_link_libraries(cimgui_sdl ${IMGUI_LIBRARIES} ${IMGUI_SDL_LIBRARY})
+
+#if dynamic SDL2 then install
+# install(TARGETS SDL2 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_SDL2)
+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} SDL2-static)

 #using library
-include_directories(../../generator/output/)
 add_executable(test_sdl main.c)
 target_compile_definitions(test_sdl PUBLIC -DCIMGUI_USE_VULKAN -DCIMGUI_USE_SDL2)
 if (MINGW)
 target_link_options(test_sdl PRIVATE "-mconsole")
 endif()
-target_link_libraries(test_sdl ${IMGUI_SDL_LIBRARY} cimgui_sdl)
+target_link_libraries(test_sdl SDL2-static cimgui_sdl ${IMGUI_LIBRARIES})

--- a/backend_test/example_sdl_vulkan/README.md
+++ b/backend_test/example_sdl_vulkan/README.md
@@ -0,0 +1,2 @@
+
+To build use `cmake path_to_example_sdl_vulkan` and then `make install`
--- a/backend_test/example_sdl_vulkan/main.c
+++ b/backend_test/example_sdl_vulkan/main.c
--- a/backend_test/example_sdlgpu3/CMakeLists.txt
+++ b/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
+)
--- a/backend_test/example_sdlgpu3/README.md
+++ b/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`
+
--- a/backend_test/example_sdlgpu3/main.c
+++ b/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;
+}
--- a/cimgui.cpp
+++ b/cimgui.cpp
--- a/cimgui.h
+++ b/cimgui.h
--- a/cimgui_impl.cpp
+++ b/cimgui_impl.cpp
@@ -0,0 +1,46 @@
+#include "./imgui/imgui.h"
+#ifdef IMGUI_ENABLE_FREETYPE
+#include "./imgui/misc/freetype/imgui_freetype.h"
+#endif
+#include "./imgui/imgui_internal.h"
+#include "cimgui.h"
+
+
+#ifdef CIMGUI_USE_GLFW
+#include "imgui_impl_glfw.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
+
+#ifdef CIMGUI_USE_SDL3
+#include "imgui_impl_sdl3.h"
+#endif
+
+#ifdef CIMGUI_USE_VULKAN
+#include "imgui_impl_vulkan.h"
+#endif
+
+#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
--- a/cimgui_impl.h
+++ b/cimgui_impl.h
@@ -0,0 +1,203 @@
+#ifndef CIMGUI_IMPL_DEFINED
+#define CIMGUI_IMPL_DEFINED
+#ifdef CIMGUI_USE_GLFW
+#ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+
+typedef struct GLFWwindow GLFWwindow;
+typedef struct GLFWmonitor GLFWmonitor;
+struct GLFWwindow;
+struct GLFWmonitor;
+#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+CIMGUI_API bool ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window,bool install_callbacks);
+CIMGUI_API bool ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window,bool install_callbacks);
+CIMGUI_API bool ImGui_ImplGlfw_InitForOther(GLFWwindow* window,bool install_callbacks);
+CIMGUI_API void ImGui_ImplGlfw_Shutdown(void);
+CIMGUI_API void ImGui_ImplGlfw_NewFrame(void);
+CIMGUI_API void ImGui_ImplGlfw_InstallCallbacks(GLFWwindow* window);
+CIMGUI_API void ImGui_ImplGlfw_RestoreCallbacks(GLFWwindow* window);
+CIMGUI_API void ImGui_ImplGlfw_SetCallbacksChainForAllWindows(bool chain_for_all_windows);
+CIMGUI_API void ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window,int focused);
+CIMGUI_API void ImGui_ImplGlfw_CursorEnterCallback(GLFWwindow* window,int entered);
+CIMGUI_API void ImGui_ImplGlfw_CursorPosCallback(GLFWwindow* window,double x,double y);
+CIMGUI_API void ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window,int button,int action,int mods);
+CIMGUI_API void ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window,double xoffset,double yoffset);
+CIMGUI_API void ImGui_ImplGlfw_KeyCallback(GLFWwindow* window,int key,int scancode,int action,int mods);
+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
+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_CreateDeviceObjects(void);
+CIMGUI_API void ImGui_ImplOpenGL3_DestroyDeviceObjects(void);
+CIMGUI_API void ImGui_ImplOpenGL3_UpdateTexture(ImTextureData* tex);
+
+#endif
+#ifdef CIMGUI_USE_OPENGL2
+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_CreateDeviceObjects(void);
+CIMGUI_API void ImGui_ImplOpenGL2_DestroyDeviceObjects(void);
+CIMGUI_API void ImGui_ImplOpenGL2_UpdateTexture(ImTextureData* tex);
+
+#endif
+#ifdef CIMGUI_USE_SDL2
+#ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+
+typedef struct SDL_Window SDL_Window;
+typedef struct SDL_Renderer SDL_Renderer;
+typedef struct _SDL_GameController _SDL_GameController;
+struct SDL_Window;
+struct SDL_Renderer;
+struct _SDL_GameController;
+typedef union SDL_Event SDL_Event;
+typedef enum { ImGui_ImplSDL2_GamepadMode_AutoFirst, ImGui_ImplSDL2_GamepadMode_AutoAll, ImGui_ImplSDL2_GamepadMode_Manual }ImGui_ImplSDL2_GamepadMode;
+#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+CIMGUI_API bool ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
+CIMGUI_API bool ImGui_ImplSDL2_InitForVulkan(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL2_InitForD3D(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL2_InitForMetal(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL2_InitForSDLRenderer(SDL_Window* window,SDL_Renderer* renderer);
+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
+#ifdef CIMGUI_USE_SDL3
+#ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+
+typedef struct SDL_Window SDL_Window;
+typedef struct SDL_Renderer SDL_Renderer;
+typedef struct SDL_Gamepad SDL_Gamepad;
+struct SDL_Window;
+struct SDL_Renderer;
+struct SDL_Gamepad;
+typedef union SDL_Event SDL_Event;
+typedef enum { ImGui_ImplSDL3_GamepadMode_AutoFirst, ImGui_ImplSDL3_GamepadMode_AutoAll, ImGui_ImplSDL3_GamepadMode_Manual }ImGui_ImplSDL3_GamepadMode;
+#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+CIMGUI_API bool ImGui_ImplSDL3_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
+CIMGUI_API bool ImGui_ImplSDL3_InitForVulkan(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL3_InitForD3D(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL3_InitForMetal(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL3_InitForSDLRenderer(SDL_Window* window,SDL_Renderer* renderer);
+CIMGUI_API bool ImGui_ImplSDL3_InitForSDLGPU(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL3_InitForOther(SDL_Window* window);
+CIMGUI_API void ImGui_ImplSDL3_Shutdown(void);
+CIMGUI_API void ImGui_ImplSDL3_NewFrame(void);
+CIMGUI_API bool ImGui_ImplSDL3_ProcessEvent(const SDL_Event* event);
+CIMGUI_API void ImGui_ImplSDL3_SetGamepadMode(ImGui_ImplSDL3_GamepadMode mode,SDL_Gamepad** manual_gamepads_array,int manual_gamepads_count);
+
+#endif
+#ifdef CIMGUI_USE_VULKAN
+#ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+
+typedef struct ImGui_ImplVulkanH_Frame ImGui_ImplVulkanH_Frame;
+typedef struct ImGui_ImplVulkanH_Window ImGui_ImplVulkanH_Window;
+typedef struct ImGui_ImplVulkan_InitInfo ImGui_ImplVulkan_InitInfo;
+struct ImGui_ImplVulkan_InitInfo
+{
+    uint32_t ApiVersion;
+    VkInstance Instance;
+    VkPhysicalDevice PhysicalDevice;
+    VkDevice Device;
+    uint32_t QueueFamily;
+    VkQueue Queue;
+    VkDescriptorPool DescriptorPool;
+    VkRenderPass RenderPass;
+    uint32_t MinImageCount;
+    uint32_t ImageCount;
+    VkSampleCountFlagBits MSAASamples;
+    VkPipelineCache PipelineCache;
+    uint32_t Subpass;
+    uint32_t DescriptorPoolSize;
+    bool UseDynamicRendering;
+    VkPipelineRenderingCreateInfoKHR PipelineRenderingCreateInfo;
+    const VkAllocationCallbacks* Allocator;
+    void (*CheckVkResultFn)(VkResult err);
+    VkDeviceSize MinAllocationSize;
+};
+typedef struct ImGui_ImplVulkan_RenderState ImGui_ImplVulkan_RenderState;
+struct ImGui_ImplVulkan_RenderState
+{
+    VkCommandBuffer CommandBuffer;
+    VkPipeline Pipeline;
+    VkPipelineLayout PipelineLayout;
+};
+struct ImGui_ImplVulkanH_Frame;
+struct ImGui_ImplVulkanH_Window;
+struct ImGui_ImplVulkanH_Frame
+{
+    VkCommandPool CommandPool;
+    VkCommandBuffer CommandBuffer;
+    VkFence Fence;
+    VkImage Backbuffer;
+    VkImageView BackbufferView;
+    VkFramebuffer Framebuffer;
+};
+typedef struct ImGui_ImplVulkanH_FrameSemaphores ImGui_ImplVulkanH_FrameSemaphores;
+struct ImGui_ImplVulkanH_FrameSemaphores
+{
+    VkSemaphore ImageAcquiredSemaphore;
+    VkSemaphore RenderCompleteSemaphore;
+};
+typedef struct ImVector_ImGui_ImplVulkanH_Frame {int Size;int Capacity;ImGui_ImplVulkanH_Frame* Data;} ImVector_ImGui_ImplVulkanH_Frame;
+
+typedef struct ImVector_ImGui_ImplVulkanH_FrameSemaphores {int Size;int Capacity;ImGui_ImplVulkanH_FrameSemaphores* Data;} ImVector_ImGui_ImplVulkanH_FrameSemaphores;
+
+struct ImGui_ImplVulkanH_Window
+{
+    int Width;
+    int Height;
+    VkSwapchainKHR Swapchain;
+    VkSurfaceKHR Surface;
+    VkSurfaceFormatKHR SurfaceFormat;
+    VkPresentModeKHR PresentMode;
+    VkRenderPass RenderPass;
+    VkPipeline Pipeline;
+    bool UseDynamicRendering;
+    bool ClearEnable;
+    VkClearValue ClearValue;
+    uint32_t FrameIndex;
+    uint32_t ImageCount;
+    uint32_t SemaphoreCount;
+    uint32_t SemaphoreIndex;
+    ImVector_ImGui_ImplVulkanH_Frame Frames;
+    ImVector_ImGui_ImplVulkanH_FrameSemaphores FrameSemaphores;
+};
+#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+#ifndef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+typedef ImVector<ImGui_ImplVulkanH_Frame> ImVector_ImGui_ImplVulkanH_Frame;
+typedef ImVector<ImGui_ImplVulkanH_FrameSemaphores> ImVector_ImGui_ImplVulkanH_FrameSemaphores;
+#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+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 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);
+CIMGUI_API void ImGui_ImplVulkanH_CreateOrResizeWindow(VkInstance instance,VkPhysicalDevice physical_device,VkDevice device,ImGui_ImplVulkanH_Window* wnd,uint32_t queue_family,const VkAllocationCallbacks* allocator,int w,int h,uint32_t min_image_count);
+CIMGUI_API void ImGui_ImplVulkanH_DestroyWindow(VkInstance instance,VkDevice device,ImGui_ImplVulkanH_Window* wnd,const VkAllocationCallbacks* allocator);
+CIMGUI_API VkSurfaceFormatKHR ImGui_ImplVulkanH_SelectSurfaceFormat(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkFormat* request_formats,int request_formats_count,VkColorSpaceKHR request_color_space);
+CIMGUI_API VkPresentModeKHR ImGui_ImplVulkanH_SelectPresentMode(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkPresentModeKHR* request_modes,int request_modes_count);
+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(void);
+
+#endif
+#endif //CIMGUI_IMPL_DEFINED
--- a/generator/cimgui_impl_template.cpp
+++ b/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
--- a/generator/cimgui_template.cpp
+++ b/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;
--- a/generator/cimgui_template.h
+++ b/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
--- a/generator/cpp2ffi.lua
+++ b/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
@@ -949,6 +951,32 @@ local function AdjustArguments(FP)
        end
    end
 end
+local function REPLACE_TEXTUREID(FP)
+	local defsT = FP.defsT
+	for numcdef,t in ipairs(FP.funcdefs) do
+		assert(t.cimguiname)
+		local cimf = defsT[t.cimguiname]
+		local defT = cimf[t.signature]
+		local hasTextureID = false
+		for i,arg in ipairs(defT.argsT) do
+			if arg.type == "ImTextureID" then print(t.cimguiname,t.signature);hasTextureID = true; break end
+		end
+		if hasTextureID then
+			for i,v in ipairs(defT.argsT) do
+				v.type = (v.type == "ImTextureID") and "ImTextureUserID" or v.type
+            end
+			--defaults table
+			for k,v in pairs(defT.defaults) do
+				if v:match"ImTextureID" then
+					error"default ImTextureID not implemented"
+				end
+            end
+			defT.args = defT.args:gsub("ImTextureID","ImTextureUserID")
+			defT.signature = defT.signature:gsub("ImTextureID","ImTextureUserID")
+		end
+	end
+end
+
 local function ADDIMSTR_S(FP)
    local defsT = FP.defsT
    local newcdefs = {}
@@ -1242,6 +1270,7 @@ local function printItems(items)
 	end
 end
 -------------
+local numerr = 0 --for popen error file
 function M.Parser()
 	local par = {}
 	local cdefs ={}
@@ -1285,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
@@ -1295,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()
@@ -1434,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
@@ -1516,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
@@ -1575,8 +1619,8 @@ function M.Parser()
 					--local ttype,template = it.item:match("([^%s,%(%)]+)%s*<(.+)>")
 					local ttype,template,te,code2 =  check_template(it2)  --it.item:match"([^%s,%(%)]+)%s*<(.+)>"
 					if template then
-						--print("not doheader",ttype,template,te)
-						if self.typenames[ttype] ~= template then --rule out T (template typename)
+						--print("not doheader",ttype,template,te, self.typenames[ttype])
+						if self.typenames[ttype] ~= template and self.typenames[ttype].."*" ~= template then --rule out T (template typename)
 							self.templates[ttype] = self.templates[ttype] or {}
 							self.templates[ttype][template] = te
 							it2=code2
@@ -2114,7 +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
 		ADDIMSTR_S(self)
        local strt = {}
        local numoverloaded = 0
@@ -2588,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 ""
@@ -2608,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)
@@ -2767,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
--- a/generator/generator.bat
+++ b/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 -DIMGUI_USE_WCHAR32 %*
+luajit ./generator.lua gcc "internal noimstrv" glfw opengl3 opengl2 sdl2 sdl3 vulkan %*

 ::leave console open
 cmd /k
--- a/generator/generator.lua
+++ b/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,6 +92,10 @@ local cimgui_skipped = {
 --desired name
 ---------------------------------------------------------------------------
 local cimgui_overloads = {
+	-- igGetIO = {
+		-- ["()"] = "igGetIO",
+		-- ["(ImGuiContext*)"] = "igGetIOEx",
+	-- },
    --igPushID = {
        --["(const char*)"] =           "igPushIDStr",
        --["(const char*,const char*)"] = "igPushIDRange",
@@ -124,16 +129,18 @@ 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
-				-- it happens with vulkan impl but constructor ImGui_ImplVulkanH_Window is not needed
-			    --assert(def.stname ~= "","constructor without struct")
-                --table.insert(outtab,"CIMGUI_API "..def.stname.."* "..def.ov_cimguiname ..(empty and "(void)" or --def.args)..";"..addcoment.."\n")
+				-- only vulkan is manually created
+				assert(def.ov_cimguiname=="ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window" or
+				def.ov_cimguiname=="ImGui_ImplVulkanH_Window_Construct", "not cpp for "..def.ov_cimguiname)
+			    assert(def.stname ~= "","constructor without struct")
+                table.insert(outtab,"CIMGUI_API "..def.stname.."* "..def.ov_cimguiname ..(empty and "(void)" or def.args)..";"..addcoment.."\n")
            elseif def.destructor then
                --table.insert(outtab,"CIMGUI_API void "..def.ov_cimguiname..def.args..";"..addcoment.."\n")
 			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)
@@ -314,8 +321,8 @@ end
 --------------------------------------------------------
 --get imgui.h version and IMGUI_HAS_DOCK--------------------------
 --defines for the cl compiler must be present in the print_defines.cpp file
-gdefines = get_defines{"IMGUI_VERSION","IMGUI_VERSION_NUM","FLT_MAX","FLT_MIN","IMGUI_HAS_DOCK","IMGUI_HAS_IMSTR","ImDrawCallback_ResetRenderState"}
--cpp2ffi.prtable(gdefines)
+gdefines = get_defines{"IMGUI_VERSION","IMGUI_VERSION_NUM","FLT_MAX","FLT_MIN","IMGUI_HAS_DOCK","IMGUI_HAS_IMSTR","ImDrawCallback_ResetRenderState","IMGUI_HAS_TEXTURES"}
+cpp2ffi.prtable(gdefines)
 if gdefines.IMGUI_HAS_DOCK then gdefines.IMGUI_HAS_DOCK = true end
 if gdefines.IMGUI_HAS_IMSTR then gdefines.IMGUI_HAS_IMSTR = true end

@@ -335,6 +342,7 @@ if gdefines.IMGUI_HAS_DOCK then
 end
 assert(not NOCHAR or not NOIMSTRV,"nochar and noimstrv cant be set at the same time")
 print("IMGUI_HAS_IMSTR",gdefines.IMGUI_HAS_IMSTR)
+print("IMGUI_HAS_TEXTURES",gdefines.IMGUI_HAS_TEXTURES and true)
 print("NOCHAR",NOCHAR)
 print("NOIMSTRV",NOIMSTRV)
 print("IMGUI_HAS_DOCK",gdefines.IMGUI_HAS_DOCK)
@@ -374,6 +382,7 @@ local function parseImGuiHeader(header,names)
 	parser.CONSTRUCTORS_GENERATION = CONSTRUCTORS_GENERATION
 	parser.NOCHAR = NOCHAR
 	parser.NOIMSTRV = NOIMSTRV
+	parser.IMGUI_HAS_TEXTURES = gdefines.IMGUI_HAS_TEXTURES
 	parser.custom_function_post = custom_function_post
 	parser.header_text_insert = header_text_insert
 	local defines = parser:take_lines(CPRE..header,names,COMPILER)
@@ -446,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

@@ -464,27 +481,43 @@ if #implementations > 0 then
 				extra_includes = extra_includes .. include_cmd .. inc .. " "
 			end
 		end
-		
+		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([[./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) 
 		local cstructstr1,cstructstr2 = parser3.structs_and_enums[1], parser3.structs_and_enums[2]
-		impl_str = impl_str .. "#ifdef CIMGUI_USE_".. string.upper(impl).."\n" .. cstructstr1 .. cstructstr2 .. cfuncsstr .. "\n#endif\n"
+		local cstru = cstructstr1 .. cstructstr2
+		if cstru ~="" then
+			cstru = "#ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS\n"..cstru .."\n#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS\n"
+		end
+		impl_str = impl_str .. "#ifdef CIMGUI_USE_".. string.upper(impl).."\n".. cstru
+		local outtab = cpp2ffi.func_header_generate_structs(parser3)
+		if #outtab > 0 then
+			table.insert(outtab, 1, "#ifndef CIMGUI_DEFINE_ENUMS_AND_STRUCTS\n")
+			table.insert(outtab,"#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS\n")
+		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

--- a/generator/output/cimgui_impl.h
+++ b/generator/output/cimgui_impl.h
@@ -1,89 +0,0 @@
-#ifdef CIMGUI_USE_GLFW
-
-typedef struct GLFWwindow GLFWwindow;
-typedef struct GLFWmonitor GLFWmonitor;
-struct GLFWwindow;
-struct GLFWmonitor;CIMGUI_API bool ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window,bool install_callbacks);
-CIMGUI_API bool ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window,bool install_callbacks);
-CIMGUI_API bool ImGui_ImplGlfw_InitForOther(GLFWwindow* window,bool install_callbacks);
-CIMGUI_API void ImGui_ImplGlfw_Shutdown(void);
-CIMGUI_API void ImGui_ImplGlfw_NewFrame(void);
-CIMGUI_API void ImGui_ImplGlfw_InstallCallbacks(GLFWwindow* window);
-CIMGUI_API void ImGui_ImplGlfw_RestoreCallbacks(GLFWwindow* window);
-CIMGUI_API void ImGui_ImplGlfw_SetCallbacksChainForAllWindows(bool chain_for_all_windows);
-CIMGUI_API void ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window,int focused);
-CIMGUI_API void ImGui_ImplGlfw_CursorEnterCallback(GLFWwindow* window,int entered);
-CIMGUI_API void ImGui_ImplGlfw_CursorPosCallback(GLFWwindow* window,double x,double y);
-CIMGUI_API void ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window,int button,int action,int mods);
-CIMGUI_API void ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window,double xoffset,double yoffset);
-CIMGUI_API void ImGui_ImplGlfw_KeyCallback(GLFWwindow* window,int key,int scancode,int action,int mods);
-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);
-
-#endif
-#ifdef CIMGUI_USE_OPENGL3
-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);
-
-#endif
-#ifdef CIMGUI_USE_OPENGL2
-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);
-
-#endif
-#ifdef CIMGUI_USE_SDL2
-
-typedef struct SDL_Window SDL_Window;
-typedef struct SDL_Renderer SDL_Renderer;
-typedef struct _SDL_GameController _SDL_GameController;
-struct SDL_Window;
-struct SDL_Renderer;
-struct _SDL_GameController;
-typedef union SDL_Event SDL_Event;
-typedef enum { ImGui_ImplSDL2_GamepadMode_AutoFirst, ImGui_ImplSDL2_GamepadMode_AutoAll, ImGui_ImplSDL2_GamepadMode_Manual }ImGui_ImplSDL2_GamepadMode;CIMGUI_API bool ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
-CIMGUI_API bool ImGui_ImplSDL2_InitForVulkan(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL2_InitForD3D(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL2_InitForMetal(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL2_InitForSDLRenderer(SDL_Window* window,SDL_Renderer* renderer);
-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 void ImGui_ImplSDL2_SetGamepadMode(ImGui_ImplSDL2_GamepadMode mode,struct _SDL_GameController** manual_gamepads_array,int manual_gamepads_count);
-
-#endif
-#ifdef CIMGUI_USE_SDL3
-
-typedef struct SDL_Window SDL_Window;
-typedef struct SDL_Renderer SDL_Renderer;
-typedef struct SDL_Gamepad SDL_Gamepad;
-struct SDL_Window;
-struct SDL_Renderer;
-struct SDL_Gamepad;
-typedef union SDL_Event SDL_Event;
-typedef enum { ImGui_ImplSDL3_GamepadMode_AutoFirst, ImGui_ImplSDL3_GamepadMode_AutoAll, ImGui_ImplSDL3_GamepadMode_Manual }ImGui_ImplSDL3_GamepadMode;CIMGUI_API bool ImGui_ImplSDL3_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
-CIMGUI_API bool ImGui_ImplSDL3_InitForVulkan(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL3_InitForD3D(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL3_InitForMetal(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL3_InitForSDLRenderer(SDL_Window* window,SDL_Renderer* renderer);
-CIMGUI_API bool ImGui_ImplSDL3_InitForSDLGPU(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL3_InitForOther(SDL_Window* window);
-CIMGUI_API void ImGui_ImplSDL3_Shutdown(void);
-CIMGUI_API void ImGui_ImplSDL3_NewFrame(void);
-CIMGUI_API bool ImGui_ImplSDL3_ProcessEvent(const SDL_Event* event);
-CIMGUI_API void ImGui_ImplSDL3_SetGamepadMode(ImGui_ImplSDL3_GamepadMode mode,SDL_Gamepad** manual_gamepads_array,int manual_gamepads_count);
-
-#endif
--- a/generator/output/definitions.json
+++ b/generator/output/definitions.json
--- a/generator/output/definitions.lua
+++ b/generator/output/definitions.lua
--- a/generator/output/impl_definitions.json
+++ b/generator/output/impl_definitions.json
@@ -17,7 +17,7 @@
      "cimguiname": "ImGui_ImplGlfw_CharCallback",
      "defaults": {},
      "funcname": "ImGui_ImplGlfw_CharCallback",
-      "location": "imgui_impl_glfw:57",
+      "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:52",
+      "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:53",
+      "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:28",
+      "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:30",
+      "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:29",
+      "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:43",
+      "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:56",
+      "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:58",
+      "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:54",
+      "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:32",
+      "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:44",
+      "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:55",
+      "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:48",
+      "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:31",
+      "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:61",
+      "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:51",
+      "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)",
@@ -1149,5 +1211,467 @@
      "signature": "()",
      "stname": ""
    }
+  ],
+  "ImGui_ImplVulkanH_CreateOrResizeWindow": [
+    {
+      "args": "(VkInstance instance,VkPhysicalDevice physical_device,VkDevice device,ImGui_ImplVulkanH_Window* wnd,uint32_t queue_family,const VkAllocationCallbacks* allocator,int w,int h,uint32_t min_image_count)",
+      "argsT": [
+        {
+          "name": "instance",
+          "type": "VkInstance"
+        },
+        {
+          "name": "physical_device",
+          "type": "VkPhysicalDevice"
+        },
+        {
+          "name": "device",
+          "type": "VkDevice"
+        },
+        {
+          "name": "wnd",
+          "type": "ImGui_ImplVulkanH_Window*"
+        },
+        {
+          "name": "queue_family",
+          "type": "uint32_t"
+        },
+        {
+          "name": "allocator",
+          "type": "const VkAllocationCallbacks*"
+        },
+        {
+          "name": "w",
+          "type": "int"
+        },
+        {
+          "name": "h",
+          "type": "int"
+        },
+        {
+          "name": "min_image_count",
+          "type": "uint32_t"
+        }
+      ],
+      "argsoriginal": "(VkInstance instance,VkPhysicalDevice physical_device,VkDevice device,ImGui_ImplVulkanH_Window* wnd,uint32_t queue_family,const VkAllocationCallbacks* allocator,int w,int h,uint32_t min_image_count)",
+      "call_args": "(instance,physical_device,device,wnd,queue_family,allocator,w,h,min_image_count)",
+      "cimguiname": "ImGui_ImplVulkanH_CreateOrResizeWindow",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkanH_CreateOrResizeWindow",
+      "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)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkanH_DestroyWindow": [
+    {
+      "args": "(VkInstance instance,VkDevice device,ImGui_ImplVulkanH_Window* wnd,const VkAllocationCallbacks* allocator)",
+      "argsT": [
+        {
+          "name": "instance",
+          "type": "VkInstance"
+        },
+        {
+          "name": "device",
+          "type": "VkDevice"
+        },
+        {
+          "name": "wnd",
+          "type": "ImGui_ImplVulkanH_Window*"
+        },
+        {
+          "name": "allocator",
+          "type": "const VkAllocationCallbacks*"
+        }
+      ],
+      "argsoriginal": "(VkInstance instance,VkDevice device,ImGui_ImplVulkanH_Window* wnd,const VkAllocationCallbacks* allocator)",
+      "call_args": "(instance,device,wnd,allocator)",
+      "cimguiname": "ImGui_ImplVulkanH_DestroyWindow",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkanH_DestroyWindow",
+      "location": "imgui_impl_vulkan:167",
+      "ov_cimguiname": "ImGui_ImplVulkanH_DestroyWindow",
+      "ret": "void",
+      "signature": "(VkInstance,VkDevice,ImGui_ImplVulkanH_Window*,const VkAllocationCallbacks*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkanH_GetMinImageCountFromPresentMode": [
+    {
+      "args": "(VkPresentModeKHR present_mode)",
+      "argsT": [
+        {
+          "name": "present_mode",
+          "type": "VkPresentModeKHR"
+        }
+      ],
+      "argsoriginal": "(VkPresentModeKHR present_mode)",
+      "call_args": "(present_mode)",
+      "cimguiname": "ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
+      "location": "imgui_impl_vulkan:172",
+      "ov_cimguiname": "ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
+      "ret": "int",
+      "signature": "(VkPresentModeKHR)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkanH_SelectPhysicalDevice": [
+    {
+      "args": "(VkInstance instance)",
+      "argsT": [
+        {
+          "name": "instance",
+          "type": "VkInstance"
+        }
+      ],
+      "argsoriginal": "(VkInstance instance)",
+      "call_args": "(instance)",
+      "cimguiname": "ImGui_ImplVulkanH_SelectPhysicalDevice",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkanH_SelectPhysicalDevice",
+      "location": "imgui_impl_vulkan:170",
+      "ov_cimguiname": "ImGui_ImplVulkanH_SelectPhysicalDevice",
+      "ret": "VkPhysicalDevice",
+      "signature": "(VkInstance)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkanH_SelectPresentMode": [
+    {
+      "args": "(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkPresentModeKHR* request_modes,int request_modes_count)",
+      "argsT": [
+        {
+          "name": "physical_device",
+          "type": "VkPhysicalDevice"
+        },
+        {
+          "name": "surface",
+          "type": "VkSurfaceKHR"
+        },
+        {
+          "name": "request_modes",
+          "type": "const VkPresentModeKHR*"
+        },
+        {
+          "name": "request_modes_count",
+          "type": "int"
+        }
+      ],
+      "argsoriginal": "(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkPresentModeKHR* request_modes,int request_modes_count)",
+      "call_args": "(physical_device,surface,request_modes,request_modes_count)",
+      "cimguiname": "ImGui_ImplVulkanH_SelectPresentMode",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkanH_SelectPresentMode",
+      "location": "imgui_impl_vulkan:169",
+      "ov_cimguiname": "ImGui_ImplVulkanH_SelectPresentMode",
+      "ret": "VkPresentModeKHR",
+      "signature": "(VkPhysicalDevice,VkSurfaceKHR,const VkPresentModeKHR*,int)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkanH_SelectQueueFamilyIndex": [
+    {
+      "args": "(VkPhysicalDevice physical_device)",
+      "argsT": [
+        {
+          "name": "physical_device",
+          "type": "VkPhysicalDevice"
+        }
+      ],
+      "argsoriginal": "(VkPhysicalDevice physical_device)",
+      "call_args": "(physical_device)",
+      "cimguiname": "ImGui_ImplVulkanH_SelectQueueFamilyIndex",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkanH_SelectQueueFamilyIndex",
+      "location": "imgui_impl_vulkan:171",
+      "ov_cimguiname": "ImGui_ImplVulkanH_SelectQueueFamilyIndex",
+      "ret": "uint32_t",
+      "signature": "(VkPhysicalDevice)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkanH_SelectSurfaceFormat": [
+    {
+      "args": "(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkFormat* request_formats,int request_formats_count,VkColorSpaceKHR request_color_space)",
+      "argsT": [
+        {
+          "name": "physical_device",
+          "type": "VkPhysicalDevice"
+        },
+        {
+          "name": "surface",
+          "type": "VkSurfaceKHR"
+        },
+        {
+          "name": "request_formats",
+          "type": "const VkFormat*"
+        },
+        {
+          "name": "request_formats_count",
+          "type": "int"
+        },
+        {
+          "name": "request_color_space",
+          "type": "VkColorSpaceKHR"
+        }
+      ],
+      "argsoriginal": "(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkFormat* request_formats,int request_formats_count,VkColorSpaceKHR request_color_space)",
+      "call_args": "(physical_device,surface,request_formats,request_formats_count,request_color_space)",
+      "cimguiname": "ImGui_ImplVulkanH_SelectSurfaceFormat",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkanH_SelectSurfaceFormat",
+      "location": "imgui_impl_vulkan:168",
+      "ov_cimguiname": "ImGui_ImplVulkanH_SelectSurfaceFormat",
+      "ret": "VkSurfaceFormatKHR",
+      "signature": "(VkPhysicalDevice,VkSurfaceKHR,const VkFormat*,int,VkColorSpaceKHR)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window",
+      "constructor": true,
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkanH_Window",
+      "location": "imgui_impl_vulkan:215",
+      "ov_cimguiname": "ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window",
+      "signature": "()",
+      "stname": "ImGui_ImplVulkanH_Window"
+    }
+  ],
+  "ImGui_ImplVulkanH_Window_destroy": [
+    {
+      "args": "(ImGui_ImplVulkanH_Window* self)",
+      "argsT": [
+        {
+          "name": "self",
+          "type": "ImGui_ImplVulkanH_Window*"
+        }
+      ],
+      "call_args": "(self)",
+      "cimguiname": "ImGui_ImplVulkanH_Window_destroy",
+      "defaults": {},
+      "destructor": true,
+      "location": "imgui_impl_vulkan:215",
+      "ov_cimguiname": "ImGui_ImplVulkanH_Window_destroy",
+      "ret": "void",
+      "signature": "(ImGui_ImplVulkanH_Window*)",
+      "stname": "ImGui_ImplVulkanH_Window"
+    }
+  ],
+  "ImGui_ImplVulkan_AddTexture": [
+    {
+      "args": "(VkSampler sampler,VkImageView image_view,VkImageLayout image_layout)",
+      "argsT": [
+        {
+          "name": "sampler",
+          "type": "VkSampler"
+        },
+        {
+          "name": "image_view",
+          "type": "VkImageView"
+        },
+        {
+          "name": "image_layout",
+          "type": "VkImageLayout"
+        }
+      ],
+      "argsoriginal": "(VkSampler sampler,VkImageView image_view,VkImageLayout image_layout)",
+      "call_args": "(sampler,image_view,image_layout)",
+      "cimguiname": "ImGui_ImplVulkan_AddTexture",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkan_AddTexture",
+      "location": "imgui_impl_vulkan:123",
+      "ov_cimguiname": "ImGui_ImplVulkan_AddTexture",
+      "ret": "VkDescriptorSet",
+      "signature": "(VkSampler,VkImageView,VkImageLayout)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkan_Init": [
+    {
+      "args": "(ImGui_ImplVulkan_InitInfo* info)",
+      "argsT": [
+        {
+          "name": "info",
+          "type": "ImGui_ImplVulkan_InitInfo*"
+        }
+      ],
+      "argsoriginal": "(ImGui_ImplVulkan_InitInfo* info)",
+      "call_args": "(info)",
+      "cimguiname": "ImGui_ImplVulkan_Init",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkan_Init",
+      "location": "imgui_impl_vulkan:111",
+      "ov_cimguiname": "ImGui_ImplVulkan_Init",
+      "ret": "bool",
+      "signature": "(ImGui_ImplVulkan_InitInfo*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkan_LoadFunctions": [
+    {
+      "args": "(uint32_t api_version,PFN_vkVoidFunction(*loader_func)(const char* function_name,void* user_data),void* user_data)",
+      "argsT": [
+        {
+          "name": "api_version",
+          "type": "uint32_t"
+        },
+        {
+          "name": "user_data)",
+          "type": "PFN_vkVoidFunction(*loader_func)(const char* function_name,void*"
+        },
+        {
+          "name": "user_data",
+          "type": "void*"
+        }
+      ],
+      "argsoriginal": "(uint32_t api_version,PFN_vkVoidFunction(*loader_func)(const char* function_name,void* user_data),void* user_data=nullptr)",
+      "call_args": "(api_version,user_data),user_data)",
+      "cimguiname": "ImGui_ImplVulkan_LoadFunctions",
+      "defaults": {
+        "user_data": "nullptr"
+      },
+      "funcname": "ImGui_ImplVulkan_LoadFunctions",
+      "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*)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkan_NewFrame": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplVulkan_NewFrame",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkan_NewFrame",
+      "location": "imgui_impl_vulkan:113",
+      "ov_cimguiname": "ImGui_ImplVulkan_NewFrame",
+      "ret": "void",
+      "signature": "()",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkan_RemoveTexture": [
+    {
+      "args": "(VkDescriptorSet descriptor_set)",
+      "argsT": [
+        {
+          "name": "descriptor_set",
+          "type": "VkDescriptorSet"
+        }
+      ],
+      "argsoriginal": "(VkDescriptorSet descriptor_set)",
+      "call_args": "(descriptor_set)",
+      "cimguiname": "ImGui_ImplVulkan_RemoveTexture",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkan_RemoveTexture",
+      "location": "imgui_impl_vulkan:124",
+      "ov_cimguiname": "ImGui_ImplVulkan_RemoveTexture",
+      "ret": "void",
+      "signature": "(VkDescriptorSet)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkan_RenderDrawData": [
+    {
+      "args": "(ImDrawData* draw_data,VkCommandBuffer command_buffer,VkPipeline pipeline)",
+      "argsT": [
+        {
+          "name": "draw_data",
+          "type": "ImDrawData*"
+        },
+        {
+          "name": "command_buffer",
+          "type": "VkCommandBuffer"
+        },
+        {
+          "name": "pipeline",
+          "type": "VkPipeline"
+        }
+      ],
+      "argsoriginal": "(ImDrawData* draw_data,VkCommandBuffer command_buffer,VkPipeline pipeline=0ULL)",
+      "call_args": "(draw_data,command_buffer,pipeline)",
+      "cimguiname": "ImGui_ImplVulkan_RenderDrawData",
+      "defaults": {
+        "pipeline": "0ULL"
+      },
+      "funcname": "ImGui_ImplVulkan_RenderDrawData",
+      "location": "imgui_impl_vulkan:114",
+      "ov_cimguiname": "ImGui_ImplVulkan_RenderDrawData",
+      "ret": "void",
+      "signature": "(ImDrawData*,VkCommandBuffer,VkPipeline)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkan_SetMinImageCount": [
+    {
+      "args": "(uint32_t min_image_count)",
+      "argsT": [
+        {
+          "name": "min_image_count",
+          "type": "uint32_t"
+        }
+      ],
+      "argsoriginal": "(uint32_t min_image_count)",
+      "call_args": "(min_image_count)",
+      "cimguiname": "ImGui_ImplVulkan_SetMinImageCount",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkan_SetMinImageCount",
+      "location": "imgui_impl_vulkan:115",
+      "ov_cimguiname": "ImGui_ImplVulkan_SetMinImageCount",
+      "ret": "void",
+      "signature": "(uint32_t)",
+      "stname": ""
+    }
+  ],
+  "ImGui_ImplVulkan_Shutdown": [
+    {
+      "args": "()",
+      "argsT": [],
+      "argsoriginal": "()",
+      "call_args": "()",
+      "cimguiname": "ImGui_ImplVulkan_Shutdown",
+      "defaults": {},
+      "funcname": "ImGui_ImplVulkan_Shutdown",
+      "location": "imgui_impl_vulkan:112",
+      "ov_cimguiname": "ImGui_ImplVulkan_Shutdown",
+      "ret": "void",
+      "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": ""
+    }
  ]
 }
--- a/generator/output/impl_definitions.lua
+++ b/generator/output/impl_definitions.lua
@@ -14,7 +14,7 @@ local t={
      cimguiname="ImGui_ImplGlfw_CharCallback",
      defaults={},
      funcname="ImGui_ImplGlfw_CharCallback",
-      location="imgui_impl_glfw:57",
+      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:52",
+      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:53",
+      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:28",
+      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:30",
+      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:29",
+      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:43",
+      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:56",
+      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:58",
+      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:54",
+      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:32",
+      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:44",
+      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:55",
+      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:48",
+      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:31",
+      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:61",
+      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:51",
+      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)",
@@ -996,10 +1044,400 @@ local t={
      ret="void",
      signature="()",
      stname=""},
-    ["()"]=nil}}
+    ["()"]=nil},
+  ImGui_ImplVulkanH_CreateOrResizeWindow={
+    [1]={
+      args="(VkInstance instance,VkPhysicalDevice physical_device,VkDevice device,ImGui_ImplVulkanH_Window* wnd,uint32_t queue_family,const VkAllocationCallbacks* allocator,int w,int h,uint32_t min_image_count)",
+      argsT={
+        [1]={
+          name="instance",
+          type="VkInstance"},
+        [2]={
+          name="physical_device",
+          type="VkPhysicalDevice"},
+        [3]={
+          name="device",
+          type="VkDevice"},
+        [4]={
+          name="wnd",
+          type="ImGui_ImplVulkanH_Window*"},
+        [5]={
+          name="queue_family",
+          type="uint32_t"},
+        [6]={
+          name="allocator",
+          type="const VkAllocationCallbacks*"},
+        [7]={
+          name="w",
+          type="int"},
+        [8]={
+          name="h",
+          type="int"},
+        [9]={
+          name="min_image_count",
+          type="uint32_t"}},
+      argsoriginal="(VkInstance instance,VkPhysicalDevice physical_device,VkDevice device,ImGui_ImplVulkanH_Window* wnd,uint32_t queue_family,const VkAllocationCallbacks* allocator,int w,int h,uint32_t min_image_count)",
+      call_args="(instance,physical_device,device,wnd,queue_family,allocator,w,h,min_image_count)",
+      cimguiname="ImGui_ImplVulkanH_CreateOrResizeWindow",
+      defaults={},
+      funcname="ImGui_ImplVulkanH_CreateOrResizeWindow",
+      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)",
+      stname=""},
+    ["(VkInstance,VkPhysicalDevice,VkDevice,ImGui_ImplVulkanH_Window*,uint32_t,const VkAllocationCallbacks*,int,int,uint32_t)"]=nil},
+  ImGui_ImplVulkanH_DestroyWindow={
+    [1]={
+      args="(VkInstance instance,VkDevice device,ImGui_ImplVulkanH_Window* wnd,const VkAllocationCallbacks* allocator)",
+      argsT={
+        [1]={
+          name="instance",
+          type="VkInstance"},
+        [2]={
+          name="device",
+          type="VkDevice"},
+        [3]={
+          name="wnd",
+          type="ImGui_ImplVulkanH_Window*"},
+        [4]={
+          name="allocator",
+          type="const VkAllocationCallbacks*"}},
+      argsoriginal="(VkInstance instance,VkDevice device,ImGui_ImplVulkanH_Window* wnd,const VkAllocationCallbacks* allocator)",
+      call_args="(instance,device,wnd,allocator)",
+      cimguiname="ImGui_ImplVulkanH_DestroyWindow",
+      defaults={},
+      funcname="ImGui_ImplVulkanH_DestroyWindow",
+      location="imgui_impl_vulkan:167",
+      ov_cimguiname="ImGui_ImplVulkanH_DestroyWindow",
+      ret="void",
+      signature="(VkInstance,VkDevice,ImGui_ImplVulkanH_Window*,const VkAllocationCallbacks*)",
+      stname=""},
+    ["(VkInstance,VkDevice,ImGui_ImplVulkanH_Window*,const VkAllocationCallbacks*)"]=nil},
+  ImGui_ImplVulkanH_GetMinImageCountFromPresentMode={
+    [1]={
+      args="(VkPresentModeKHR present_mode)",
+      argsT={
+        [1]={
+          name="present_mode",
+          type="VkPresentModeKHR"}},
+      argsoriginal="(VkPresentModeKHR present_mode)",
+      call_args="(present_mode)",
+      cimguiname="ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
+      defaults={},
+      funcname="ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
+      location="imgui_impl_vulkan:172",
+      ov_cimguiname="ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
+      ret="int",
+      signature="(VkPresentModeKHR)",
+      stname=""},
+    ["(VkPresentModeKHR)"]=nil},
+  ImGui_ImplVulkanH_SelectPhysicalDevice={
+    [1]={
+      args="(VkInstance instance)",
+      argsT={
+        [1]={
+          name="instance",
+          type="VkInstance"}},
+      argsoriginal="(VkInstance instance)",
+      call_args="(instance)",
+      cimguiname="ImGui_ImplVulkanH_SelectPhysicalDevice",
+      defaults={},
+      funcname="ImGui_ImplVulkanH_SelectPhysicalDevice",
+      location="imgui_impl_vulkan:170",
+      ov_cimguiname="ImGui_ImplVulkanH_SelectPhysicalDevice",
+      ret="VkPhysicalDevice",
+      signature="(VkInstance)",
+      stname=""},
+    ["(VkInstance)"]=nil},
+  ImGui_ImplVulkanH_SelectPresentMode={
+    [1]={
+      args="(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkPresentModeKHR* request_modes,int request_modes_count)",
+      argsT={
+        [1]={
+          name="physical_device",
+          type="VkPhysicalDevice"},
+        [2]={
+          name="surface",
+          type="VkSurfaceKHR"},
+        [3]={
+          name="request_modes",
+          type="const VkPresentModeKHR*"},
+        [4]={
+          name="request_modes_count",
+          type="int"}},
+      argsoriginal="(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkPresentModeKHR* request_modes,int request_modes_count)",
+      call_args="(physical_device,surface,request_modes,request_modes_count)",
+      cimguiname="ImGui_ImplVulkanH_SelectPresentMode",
+      defaults={},
+      funcname="ImGui_ImplVulkanH_SelectPresentMode",
+      location="imgui_impl_vulkan:169",
+      ov_cimguiname="ImGui_ImplVulkanH_SelectPresentMode",
+      ret="VkPresentModeKHR",
+      signature="(VkPhysicalDevice,VkSurfaceKHR,const VkPresentModeKHR*,int)",
+      stname=""},
+    ["(VkPhysicalDevice,VkSurfaceKHR,const VkPresentModeKHR*,int)"]=nil},
+  ImGui_ImplVulkanH_SelectQueueFamilyIndex={
+    [1]={
+      args="(VkPhysicalDevice physical_device)",
+      argsT={
+        [1]={
+          name="physical_device",
+          type="VkPhysicalDevice"}},
+      argsoriginal="(VkPhysicalDevice physical_device)",
+      call_args="(physical_device)",
+      cimguiname="ImGui_ImplVulkanH_SelectQueueFamilyIndex",
+      defaults={},
+      funcname="ImGui_ImplVulkanH_SelectQueueFamilyIndex",
+      location="imgui_impl_vulkan:171",
+      ov_cimguiname="ImGui_ImplVulkanH_SelectQueueFamilyIndex",
+      ret="uint32_t",
+      signature="(VkPhysicalDevice)",
+      stname=""},
+    ["(VkPhysicalDevice)"]=nil},
+  ImGui_ImplVulkanH_SelectSurfaceFormat={
+    [1]={
+      args="(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkFormat* request_formats,int request_formats_count,VkColorSpaceKHR request_color_space)",
+      argsT={
+        [1]={
+          name="physical_device",
+          type="VkPhysicalDevice"},
+        [2]={
+          name="surface",
+          type="VkSurfaceKHR"},
+        [3]={
+          name="request_formats",
+          type="const VkFormat*"},
+        [4]={
+          name="request_formats_count",
+          type="int"},
+        [5]={
+          name="request_color_space",
+          type="VkColorSpaceKHR"}},
+      argsoriginal="(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkFormat* request_formats,int request_formats_count,VkColorSpaceKHR request_color_space)",
+      call_args="(physical_device,surface,request_formats,request_formats_count,request_color_space)",
+      cimguiname="ImGui_ImplVulkanH_SelectSurfaceFormat",
+      defaults={},
+      funcname="ImGui_ImplVulkanH_SelectSurfaceFormat",
+      location="imgui_impl_vulkan:168",
+      ov_cimguiname="ImGui_ImplVulkanH_SelectSurfaceFormat",
+      ret="VkSurfaceFormatKHR",
+      signature="(VkPhysicalDevice,VkSurfaceKHR,const VkFormat*,int,VkColorSpaceKHR)",
+      stname=""},
+    ["(VkPhysicalDevice,VkSurfaceKHR,const VkFormat*,int,VkColorSpaceKHR)"]=nil},
+  ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window={
+    [1]={
+      args="()",
+      argsT={},
+      argsoriginal="()",
+      call_args="()",
+      cimguiname="ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window",
+      constructor=true,
+      defaults={},
+      funcname="ImGui_ImplVulkanH_Window",
+      location="imgui_impl_vulkan:215",
+      ov_cimguiname="ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window",
+      signature="()",
+      stname="ImGui_ImplVulkanH_Window"},
+    ["()"]=nil},
+  ImGui_ImplVulkanH_Window_destroy={
+    [1]={
+      args="(ImGui_ImplVulkanH_Window* self)",
+      argsT={
+        [1]={
+          name="self",
+          type="ImGui_ImplVulkanH_Window*"}},
+      call_args="(self)",
+      cimguiname="ImGui_ImplVulkanH_Window_destroy",
+      defaults={},
+      destructor=true,
+      location="imgui_impl_vulkan:215",
+      ov_cimguiname="ImGui_ImplVulkanH_Window_destroy",
+      ret="void",
+      signature="(ImGui_ImplVulkanH_Window*)",
+      stname="ImGui_ImplVulkanH_Window"},
+    ["(ImGui_ImplVulkanH_Window*)"]=nil},
+  ImGui_ImplVulkan_AddTexture={
+    [1]={
+      args="(VkSampler sampler,VkImageView image_view,VkImageLayout image_layout)",
+      argsT={
+        [1]={
+          name="sampler",
+          type="VkSampler"},
+        [2]={
+          name="image_view",
+          type="VkImageView"},
+        [3]={
+          name="image_layout",
+          type="VkImageLayout"}},
+      argsoriginal="(VkSampler sampler,VkImageView image_view,VkImageLayout image_layout)",
+      call_args="(sampler,image_view,image_layout)",
+      cimguiname="ImGui_ImplVulkan_AddTexture",
+      defaults={},
+      funcname="ImGui_ImplVulkan_AddTexture",
+      location="imgui_impl_vulkan:123",
+      ov_cimguiname="ImGui_ImplVulkan_AddTexture",
+      ret="VkDescriptorSet",
+      signature="(VkSampler,VkImageView,VkImageLayout)",
+      stname=""},
+    ["(VkSampler,VkImageView,VkImageLayout)"]=nil},
+  ImGui_ImplVulkan_Init={
+    [1]={
+      args="(ImGui_ImplVulkan_InitInfo* info)",
+      argsT={
+        [1]={
+          name="info",
+          type="ImGui_ImplVulkan_InitInfo*"}},
+      argsoriginal="(ImGui_ImplVulkan_InitInfo* info)",
+      call_args="(info)",
+      cimguiname="ImGui_ImplVulkan_Init",
+      defaults={},
+      funcname="ImGui_ImplVulkan_Init",
+      location="imgui_impl_vulkan:111",
+      ov_cimguiname="ImGui_ImplVulkan_Init",
+      ret="bool",
+      signature="(ImGui_ImplVulkan_InitInfo*)",
+      stname=""},
+    ["(ImGui_ImplVulkan_InitInfo*)"]=nil},
+  ImGui_ImplVulkan_LoadFunctions={
+    [1]={
+      args="(uint32_t api_version,PFN_vkVoidFunction(*loader_func)(const char* function_name,void* user_data),void* user_data)",
+      argsT={
+        [1]={
+          name="api_version",
+          type="uint32_t"},
+        [2]={
+          name="user_data)",
+          type="PFN_vkVoidFunction(*loader_func)(const char* function_name,void*"},
+        [3]={
+          name="user_data",
+          type="void*"}},
+      argsoriginal="(uint32_t api_version,PFN_vkVoidFunction(*loader_func)(const char* function_name,void* user_data),void* user_data=nullptr)",
+      call_args="(api_version,user_data),user_data)",
+      cimguiname="ImGui_ImplVulkan_LoadFunctions",
+      defaults={
+        user_data="nullptr"},
+      funcname="ImGui_ImplVulkan_LoadFunctions",
+      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*)",
+      stname=""},
+    ["(uint32_t,PFN_vkVoidFunction(*loader_func)(const char* function_name,void*,void*)"]=nil},
+  ImGui_ImplVulkan_NewFrame={
+    [1]={
+      args="()",
+      argsT={},
+      argsoriginal="()",
+      call_args="()",
+      cimguiname="ImGui_ImplVulkan_NewFrame",
+      defaults={},
+      funcname="ImGui_ImplVulkan_NewFrame",
+      location="imgui_impl_vulkan:113",
+      ov_cimguiname="ImGui_ImplVulkan_NewFrame",
+      ret="void",
+      signature="()",
+      stname=""},
+    ["()"]=nil},
+  ImGui_ImplVulkan_RemoveTexture={
+    [1]={
+      args="(VkDescriptorSet descriptor_set)",
+      argsT={
+        [1]={
+          name="descriptor_set",
+          type="VkDescriptorSet"}},
+      argsoriginal="(VkDescriptorSet descriptor_set)",
+      call_args="(descriptor_set)",
+      cimguiname="ImGui_ImplVulkan_RemoveTexture",
+      defaults={},
+      funcname="ImGui_ImplVulkan_RemoveTexture",
+      location="imgui_impl_vulkan:124",
+      ov_cimguiname="ImGui_ImplVulkan_RemoveTexture",
+      ret="void",
+      signature="(VkDescriptorSet)",
+      stname=""},
+    ["(VkDescriptorSet)"]=nil},
+  ImGui_ImplVulkan_RenderDrawData={
+    [1]={
+      args="(ImDrawData* draw_data,VkCommandBuffer command_buffer,VkPipeline pipeline)",
+      argsT={
+        [1]={
+          name="draw_data",
+          type="ImDrawData*"},
+        [2]={
+          name="command_buffer",
+          type="VkCommandBuffer"},
+        [3]={
+          name="pipeline",
+          type="VkPipeline"}},
+      argsoriginal="(ImDrawData* draw_data,VkCommandBuffer command_buffer,VkPipeline pipeline=0ULL)",
+      call_args="(draw_data,command_buffer,pipeline)",
+      cimguiname="ImGui_ImplVulkan_RenderDrawData",
+      defaults={
+        pipeline="0ULL"},
+      funcname="ImGui_ImplVulkan_RenderDrawData",
+      location="imgui_impl_vulkan:114",
+      ov_cimguiname="ImGui_ImplVulkan_RenderDrawData",
+      ret="void",
+      signature="(ImDrawData*,VkCommandBuffer,VkPipeline)",
+      stname=""},
+    ["(ImDrawData*,VkCommandBuffer,VkPipeline)"]=nil},
+  ImGui_ImplVulkan_SetMinImageCount={
+    [1]={
+      args="(uint32_t min_image_count)",
+      argsT={
+        [1]={
+          name="min_image_count",
+          type="uint32_t"}},
+      argsoriginal="(uint32_t min_image_count)",
+      call_args="(min_image_count)",
+      cimguiname="ImGui_ImplVulkan_SetMinImageCount",
+      defaults={},
+      funcname="ImGui_ImplVulkan_SetMinImageCount",
+      location="imgui_impl_vulkan:115",
+      ov_cimguiname="ImGui_ImplVulkan_SetMinImageCount",
+      ret="void",
+      signature="(uint32_t)",
+      stname=""},
+    ["(uint32_t)"]=nil},
+  ImGui_ImplVulkan_Shutdown={
+    [1]={
+      args="()",
+      argsT={},
+      argsoriginal="()",
+      call_args="()",
+      cimguiname="ImGui_ImplVulkan_Shutdown",
+      defaults={},
+      funcname="ImGui_ImplVulkan_Shutdown",
+      location="imgui_impl_vulkan:112",
+      ov_cimguiname="ImGui_ImplVulkan_Shutdown",
+      ret="void",
+      signature="()",
+      stname=""},
+    ["()"]=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]
@@ -1015,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]
@@ -1051,4 +1489,22 @@ t.ImGui_ImplSDL3_NewFrame["()"]=t.ImGui_ImplSDL3_NewFrame[1]
 t.ImGui_ImplSDL3_ProcessEvent["(const SDL_Event*)"]=t.ImGui_ImplSDL3_ProcessEvent[1]
 t.ImGui_ImplSDL3_SetGamepadMode["(ImGui_ImplSDL3_GamepadMode,SDL_Gamepad**,int)"]=t.ImGui_ImplSDL3_SetGamepadMode[1]
 t.ImGui_ImplSDL3_Shutdown["()"]=t.ImGui_ImplSDL3_Shutdown[1]
+t.ImGui_ImplVulkanH_CreateOrResizeWindow["(VkInstance,VkPhysicalDevice,VkDevice,ImGui_ImplVulkanH_Window*,uint32_t,const VkAllocationCallbacks*,int,int,uint32_t)"]=t.ImGui_ImplVulkanH_CreateOrResizeWindow[1]
+t.ImGui_ImplVulkanH_DestroyWindow["(VkInstance,VkDevice,ImGui_ImplVulkanH_Window*,const VkAllocationCallbacks*)"]=t.ImGui_ImplVulkanH_DestroyWindow[1]
+t.ImGui_ImplVulkanH_GetMinImageCountFromPresentMode["(VkPresentModeKHR)"]=t.ImGui_ImplVulkanH_GetMinImageCountFromPresentMode[1]
+t.ImGui_ImplVulkanH_SelectPhysicalDevice["(VkInstance)"]=t.ImGui_ImplVulkanH_SelectPhysicalDevice[1]
+t.ImGui_ImplVulkanH_SelectPresentMode["(VkPhysicalDevice,VkSurfaceKHR,const VkPresentModeKHR*,int)"]=t.ImGui_ImplVulkanH_SelectPresentMode[1]
+t.ImGui_ImplVulkanH_SelectQueueFamilyIndex["(VkPhysicalDevice)"]=t.ImGui_ImplVulkanH_SelectQueueFamilyIndex[1]
+t.ImGui_ImplVulkanH_SelectSurfaceFormat["(VkPhysicalDevice,VkSurfaceKHR,const VkFormat*,int,VkColorSpaceKHR)"]=t.ImGui_ImplVulkanH_SelectSurfaceFormat[1]
+t.ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window["()"]=t.ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window[1]
+t.ImGui_ImplVulkanH_Window_destroy["(ImGui_ImplVulkanH_Window*)"]=t.ImGui_ImplVulkanH_Window_destroy[1]
+t.ImGui_ImplVulkan_AddTexture["(VkSampler,VkImageView,VkImageLayout)"]=t.ImGui_ImplVulkan_AddTexture[1]
+t.ImGui_ImplVulkan_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]
+t.ImGui_ImplVulkan_RemoveTexture["(VkDescriptorSet)"]=t.ImGui_ImplVulkan_RemoveTexture[1]
+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
--- a/generator/output/overloads.txt
+++ b/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)
@@ -127,9 +133,15 @@ igGetID	4
 igGetIDWithSeed	2
 1	ImGuiID	igGetIDWithSeed_Str (const char*,const char*,ImGuiID)
 2	ImGuiID	igGetIDWithSeed_Int (int,ImGuiID)
+igGetIO	2
+1	ImGuiIO*	igGetIO_Nil ()
+2	ImGuiIO*	igGetIO_ContextPtr (ImGuiContext*)
 igGetKeyData	2
 1	ImGuiKeyData*	igGetKeyData_ContextPtr (ImGuiContext*,ImGuiKey)
 2	ImGuiKeyData*	igGetKeyData_Key (ImGuiKey)
+igGetPlatformIO	2
+1	ImGuiPlatformIO*	igGetPlatformIO_Nil ()
+2	ImGuiPlatformIO*	igGetPlatformIO_ContextPtr (ImGuiContext*)
 igImAbs	3
 1	int	igImAbs_Int (int)
 2	float	igImAbs_Float (float)
@@ -297,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*)
-208 overloaded
+216 overloaded
--- a/generator/output/structs_and_enums.json
+++ b/generator/output/structs_and_enums.json
--- a/generator/output/structs_and_enums.lua
+++ b/generator/output/structs_and_enums.lua
--- a/generator/output/typedefs_dict.json
+++ b/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",
@@ -43,7 +50,6 @@
  "ImGuiDataType": "int",
  "ImGuiDataTypeInfo": "struct ImGuiDataTypeInfo",
  "ImGuiDataTypeStorage": "struct ImGuiDataTypeStorage",
-  "ImGuiDataVarInfo": "struct ImGuiDataVarInfo",
  "ImGuiDeactivatedItemData": "struct ImGuiDeactivatedItemData",
  "ImGuiDebugAllocEntry": "struct ImGuiDebugAllocEntry",
  "ImGuiDebugAllocInfo": "struct ImGuiDebugAllocInfo",
@@ -54,6 +60,7 @@
  "ImGuiFocusRequestFlags": "int",
  "ImGuiFocusScopeData": "struct ImGuiFocusScopeData",
  "ImGuiFocusedFlags": "int",
+  "ImGuiFreeTypeLoaderFlags": "unsigned int",
  "ImGuiGroupData": "struct ImGuiGroupData",
  "ImGuiHoveredFlags": "int",
  "ImGuiID": "unsigned int",
@@ -133,6 +140,7 @@
  "ImGuiStyle": "struct ImGuiStyle",
  "ImGuiStyleMod": "struct ImGuiStyleMod",
  "ImGuiStyleVar": "int",
+  "ImGuiStyleVarInfo": "struct ImGuiStyleVarInfo",
  "ImGuiTabBar": "struct ImGuiTabBar",
  "ImGuiTabBarFlags": "int",
  "ImGuiTabItem": "struct ImGuiTabItem",
@@ -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"
 }
--- a/generator/output/typedefs_dict.lua
+++ b/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",
@@ -43,7 +50,6 @@ local t={
  ImGuiDataType="int",
  ImGuiDataTypeInfo="struct ImGuiDataTypeInfo",
  ImGuiDataTypeStorage="struct ImGuiDataTypeStorage",
-  ImGuiDataVarInfo="struct ImGuiDataVarInfo",
  ImGuiDeactivatedItemData="struct ImGuiDeactivatedItemData",
  ImGuiDebugAllocEntry="struct ImGuiDebugAllocEntry",
  ImGuiDebugAllocInfo="struct ImGuiDebugAllocInfo",
@@ -54,6 +60,7 @@ local t={
  ImGuiFocusRequestFlags="int",
  ImGuiFocusScopeData="struct ImGuiFocusScopeData",
  ImGuiFocusedFlags="int",
+  ImGuiFreeTypeLoaderFlags="unsigned int",
  ImGuiGroupData="struct ImGuiGroupData",
  ImGuiHoveredFlags="int",
  ImGuiID="unsigned int",
@@ -133,6 +140,7 @@ local t={
  ImGuiStyle="struct ImGuiStyle",
  ImGuiStyleMod="struct ImGuiStyleMod",
  ImGuiStyleVar="int",
+  ImGuiStyleVarInfo="struct ImGuiStyleVarInfo",
  ImGuiTabBar="struct ImGuiTabBar",
  ImGuiTabBarFlags="int",
  ImGuiTabItem="struct ImGuiTabItem",
@@ -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
--- a/generator/print_defines.cpp
+++ b/generator/print_defines.cpp
@@ -31,3 +31,7 @@
 #ifdef ImDrawCallback_ResetRenderState
 #pragma message(CIMGUI_DEFSTRING(ImDrawCallback_ResetRenderState))
 #endif
+
+#ifdef IMGUI_HAS_TEXTURES
+#pragma message(CIMGUI_DEFSTRING(IMGUI_HAS_TEXTURES))
+#endif
--- a/2
+++ b/2
--- a/test/main.c
+++ b/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);
Author	SHA1	Message	Date
sonoro1234	ce46a36843	Merge branch 'docking_inter'	2025-07-01 11:34:22 +02:00
sonoro1234	bcb179376b	cpp2ffi.lua: clean `= default` in constructor (appears in implot3d)	2025-06-27 18:00:19 +02:00
sonoro1234	dd9196a19b	move imgui_freetype include from cimgui.cpp to cimgui.h	2025-06-27 17:10:26 +02:00
sonoro1234	cf8523f31f	Merge branch 'docking_inter' 1.92.0dock_b	2025-06-27 11:51:33 +02:00
sonoro1234	439e8073c2	backends_test for 1.92.0	2025-06-27 11:40:08 +02:00
sonoro1234	63e6dd0ef3	backend tests adapted for 1.92.0 pull imgui 1.92.0 - docking and generate	2025-06-27 11:11:55 +02:00
sonoro1234	85d6d12ec6	pull imgui 1.92.0 - docking and generate	2025-06-27 09:58:32 +02:00
sonoro1234	8e95247e63	cpp2ffi: type &name -> type& name	2025-06-26 19:34:47 +02:00
sonoro1234	92b0239554	add preprocesor ifndef for including only once in cimgui_impl.h	2025-06-25 18:44:25 +02:00
sonoro1234	094a55523a	add CIMGUI_VARGS0 versions as explained in PR#297 by @tuket	2025-05-16 20:09:01 +02:00
sonoro1234	c561c6a6e5	generator.lua: allow generation without implementations	2025-05-14 08:56:49 +02:00
sonoro1234	5ba6ea3fc0	complete last commit	2025-04-16 16:38:35 +02:00
sonoro1234	623cbefe49	LogTextV was present from 2021 so igLogText does not have to be manual	2025-04-15 17:25:02 +02:00
Victor Bombi	a007c438f0	Merge pull request #293 from Cragady/feature/add-sdl3-vulkan-backend feat: add sdl3 vulkan backend	2025-04-13 11:27:15 +02:00
Cragady	f6e14c22eb	feat: add sdl3 vulkan backend * fix: rename project in cmake * fix: move new backend to new dir * fix: restore old sdl example	2025-04-12 13:23:14 -06:00
sonoro1234	205107640d	a little more	2025-03-24 18:18:52 +01:00
sonoro1234	08677d259c	GenerateCimguiBindings is now a module available for several backend_tests	2025-03-24 10:34:25 +01:00
sonoro1234	8f15ab3f80	example_sdlgpu3: small changes (less crazy includes arg)	2025-03-24 09:25:09 +01:00
sonoro1234	0992dbf89c	example_sdlgpu3: some fixes	2025-03-23 20:02:17 +01:00
sonoro1234	dad6366d9b	drop vulkan to make github macOSX actions happy	2025-03-23 07:01:35 +01:00
sonoro1234	abc0ea66b5	cpp2ffi: guess compiler error	2025-03-22 21:16:23 +01:00
sonoro1234	4e3e9b5fb2	backend_test/example_sdlgpu3: thanks to @hgranthorner PR #291 with generation from cmake	2025-03-22 17:36:09 +01:00
sonoro1234	334c9fa140	generator: correct structs_and_enums.lua path	2025-03-22 11:27:36 +01:00
sonoro1234	0b0a04de25	Merge branch 'docking_inter'	2025-03-22 10:23:01 +01:00
sonoro1234	03e6c8d1f2	pull imgui 1.91.9bdock and generate	2025-03-20 01:39:06 +01:00
sonoro1234	50c60f3da6	IMGUI_HAS_TEXTURES do nothing	2025-03-20 01:34:34 +01:00
sonoro1234	140d107be5	improve customization (see PR #290 )	2025-03-18 13:20:46 +01:00
sonoro1234	c32d1c0c9b	dont name igGetIO overload as the generic name of function (C++ name) solves issue #289	2025-03-15 17:51:30 +01:00
sonoro1234	3530b937f1	generation	2025-03-15 17:03:47 +01:00
Victor Bombi	bb6f212993	Merge pull request #288 from spencercw/vulkan generator.lua: fix missing void in Vulkan function generation	2025-03-15 16:57:30 +01:00
Chris Spencer	e3af31fb9c	generator.lua: fix missing void in Vulkan function generation	2025-03-15 11:57:14 +00:00
sonoro1234	e9a4157067	Merge remote-tracking branch 'remotes/origin/docking_inter'	2025-03-15 08:23:45 +01:00
sonoro1234	de213c9105	pull imgui 1.91.9 docking and generate	2025-03-15 08:17:37 +01:00
sonoro1234	4bd8b6dbbd	get defines also for cl	2025-03-12 02:35:06 +01:00
sonoro1234	a1dbf23597	IMGUI_HAS_TEXTURES ImTextureID -> ImTextureUserID	2025-03-07 10:51:45 +01:00
sonoro1234	f2e203b05a	cpp2ffi: rule out T* in templates	2025-03-07 08:53:51 +01:00
sonoro1234	429ffc930d	update README.md	2025-02-22 12:32:10 +01:00
sonoro1234	95dec01325	cimgui_impl: reworked	2025-02-22 12:11:25 +01:00
sonoro1234	79504e6f7c	ClearEnable = true	2025-02-21 20:30:58 +01:00
sonoro1234	4edec25945	generation for vulkan	2025-02-21 16:57:56 +01:00
sonoro1234	daac7262b3	example_sdl_vulkan tries to emulate imgui	2025-02-21 16:56:14 +01:00
sonoro1234	2e5db87e99	backends: use cmake FetchContent for SDL2 examples	2025-02-05 17:53:05 +01:00
sonoro1234	387e5e0d8b	generator.lua: corrections for Vulkan generation as now needs ImVector, also corrections in example_sdl_vulkan/main.c for last breaking changes.	2025-02-04 18:51:13 +01:00
				`@@ -0,0 +1,2 @@`

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

				To build use `cmake path_to_example_sdl_opengl3` and then `make install`