Merge branch 'docking_inter'

pull imgui 1.92.3 docking and generate
pull imgui 1.92.1 and generate
2025-10-09 11:21:38 +01:00 · 2025-09-22 12:40:43 +02:00 · 2025-09-22 12:26:57 +02:00 · 2025-07-14 09:41:32 +02:00 · 2025-07-14 09:24:51 +02:00 · 2025-07-14 09:21:39 +02:00
34 changed files with 15067 additions and 14176 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.9 of Dear ImGui with internal api]
+* currently this wrapper is based on version [1.92.3 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.
--- a/backend_test/example_sdlgpu3/GenerateCimguiBindings.cmake
+++ b/backend_test/example_sdlgpu3/GenerateCimguiBindings.cmake
@@ -2,9 +2,30 @@
 # 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.

-function(GenerateCimguiBindings target)
-	include(FetchContent)
+#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
@@ -20,22 +41,28 @@ function(GenerateCimguiBindings target)

 	file(READ ${cimgui_SOURCE_DIR}/cimgui_impl.h cimgui_impl)

-	# We're checking to see if the cimgui_impl.h file already has SDLGPU3 bindings,
+	# 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(FIND "${cimgui_impl}" "SDLGPU3" sdlgpu_position)
-	# If we don't find it, sdlgpu_position will be -1
-	if(sdlgpu_position EQUAL -1)
-		# NOTE: This requires a luajit on your path. If your binary is named different, you will
-		# need to modify this command
+	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 sdl3 sdlgpu3 -I../imgui -I${sdl3_SOURCE_DIR}/include
+		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()
@@ -49,8 +76,8 @@ function(GenerateCimguiBindings target)
 		${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_sdl3.cpp
-		${cimgui_SOURCE_DIR}/imgui/backends/imgui_impl_sdlgpu3.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)
@@ -64,5 +91,4 @@ function(GenerateCimguiBindings target)
 		target_compile_definitions(${target} PUBLIC "-DIMGUI_IMPL_API=extern \"C\" ")
 	endif(WIN32)
 	target_compile_features(${target} PRIVATE cxx_std_11)
-	target_link_libraries(${target} PRIVATE SDL3::SDL3)
 endfunction()
--- a/backend_test/example_glfw_dx11/CMakeLists.txt
+++ b/backend_test/example_glfw_dx11/CMakeLists.txt
@@ -1,109 +1,45 @@
-Project(cimgui_glfwdx11)
 cmake_minimum_required(VERSION 3.11)
-if(WIN32) # to mingw work as all the others
-	set(CMAKE_SHARED_LIBRARY_PREFIX "")
-endif(WIN32)
+project(cimgui_glfwdx11 LANGUAGES C CXX)

-#run in build dir
-set (CMAKE_INSTALL_PREFIX ${CMAKE_CURRENT_BINARY_DIR})
+set(CMAKE_C_STANDARD 11)

-set (CMAKE_CXX_STANDARD 11)
-
-# general settings
-if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/../../imgui/backends)
-	set(BAKENDS_FOLDER "../../imgui/backends/")
-else()
-	set(BAKENDS_FOLDER "../../imgui/examples/")
-endif()
-
-if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/../../imgui/imgui_tables.cpp)
-	set(TABLES_SOURCE "../../imgui/imgui_tables.cpp")
-else()
-	set(TABLES_SOURCE "")
-endif()
-
-include_directories(../../imgui)
-add_definitions("-DIMGUI_USER_CONFIG=\"../cimconfig.h\"")
-add_definitions("-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
-
-include_directories(../../)
-set(IMGUI_SOURCES 
-../../cimgui.cpp 
-../../imgui/imgui.cpp 
-../../imgui/imgui_draw.cpp 
-../../imgui/imgui_demo.cpp 
-../../imgui/imgui_widgets.cpp
-${TABLES_SOURCE} 
-)
-
-set(IMGUI_LIBRARIES )
-
-if (WIN32)
-    add_definitions("-DIMGUI_IMPL_API=extern \"C\" __declspec\(dllexport\)")
-else(WIN32)
-    add_definitions("-DIMGUI_IMPL_API=extern \"C\" ")
-endif(WIN32)
-
-add_compile_definitions("IMGUI_IMPL_OPENGL_LOADER_GL3W")
-
-# optional adding freetype
-option(IMGUI_FREETYPE "add Freetype2" OFF)
-
-if(IMGUI_FREETYPE)
-	FIND_PACKAGE(freetype REQUIRED PATHS ${FREETYPE_PATH})
-	list(APPEND IMGUI_LIBRARIES freetype)
-	list(APPEND IMGUI_SOURCES ../../imgui/misc/freetype/imgui_freetype.cpp)
-	add_definitions("-DCIMGUI_FREETYPE=1")
-endif(IMGUI_FREETYPE)
-
-# dx11
-list(APPEND IMGUI_SOURCES ${BAKENDS_FOLDER}imgui_impl_dx11.cpp)
-
-if(WIN32)
-       list(APPEND IMGUI_LIBRARIES opengl32)
-else(WIN32) # Unix
-       list(APPEND IMGUI_LIBRARIES GL)
-endif(WIN32)
-
-# GLFW
-list(APPEND IMGUI_SOURCES ${BAKENDS_FOLDER}imgui_impl_glfw.cpp)
+include(FetchContent)

 set(GLFW_VERSION 3.3.8)
-include(FetchContent)
-	FetchContent_Declare(
+FetchContent_Declare(
    glfw
-    URL https://github.com/glfw/glfw/archive/refs/tags/${GLFW_VERSION}.tar.gz)
+    EXCLUDE_FROM_ALL
+    URL https://github.com/glfw/glfw/archive/refs/tags/${GLFW_VERSION}.tar.gz
+    GIT_PROGRESS true)

-FetchContent_GetProperties(glfw)
-if (NOT glfw_POPULATED)
-	set(FETCHCONTENT_QUIET NO)
-    FetchContent_Populate(glfw)
-	set(GLFW_BUILD_DOCS OFF CACHE BOOL "" FORCE)
-	set(GLFW_BUILD_TESTS OFF CACHE BOOL "" FORCE)
-	set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
-	if (NOT STATIC_BUILD)
+set(GLFW_BUILD_DOCS OFF CACHE BOOL "" FORCE)
+set(GLFW_BUILD_TESTS OFF CACHE BOOL "" FORCE)
+set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
+if (NOT STATIC_BUILD)
 	set(BUILD_SHARED_LIBS ON CACHE BOOL "" FORCE)
-	endif()
-	add_subdirectory(${glfw_SOURCE_DIR} ${glfw_BINARY_DIR} EXCLUDE_FROM_ALL)
 endif()

+
+FetchContent_MakeAvailable(glfw)
 install(TARGETS glfw RUNTIME DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
 					LIBRARY DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
 )
-#FIND_PACKAGE(glfw3 PATHS "C:/LuaGL/gitsources/BUILDS/GLFW/install")

-if (NOT STATIC_BUILD)
-  add_library(cimgui SHARED ${IMGUI_SOURCES})
-else()
-  add_library(cimgui STATIC ${IMGUI_SOURCES})
-endif()
+include(../cmake/GenerateCimguiBindings.cmake)

-target_link_libraries(cimgui ${IMGUI_LIBRARIES} glfw)
-
-
-# using library
-add_executable(${PROJECT_NAME} main.c)
-target_compile_definitions(${PROJECT_NAME} PUBLIC -DCIMGUI_USE_DX11 -DCIMGUI_USE_GLFW)
-target_link_libraries(${PROJECT_NAME} d3d11 d3dcompiler.lib cimgui)
+set(inclulist "")
+GenerateCimguiBindings(cimgui_with_backend "glfw" dx11 inclulist)
+target_link_libraries(cimgui_with_backend PRIVATE glfw d3dcompiler dwmapi)

+add_executable(${PROJECT_NAME} 
+	main.c
+)

+target_link_libraries(${PROJECT_NAME} PRIVATE glfw cimgui_with_backend d3d11 d3dcompiler dwmapi)
+target_compile_definitions(
+	${PROJECT_NAME}
+	PRIVATE 
+	CIMGUI_DEFINE_ENUMS_AND_STRUCTS=1
+	CIMGUI_USE_GLFW=1
+	CIMGUI_USE_DX11=1
+)
--- 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
--- 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
--- a/backend_test/example_glfw_opengl3/main.c
+++ b/backend_test/example_glfw_opengl3/main.c
@@ -43,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");
@@ -72,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/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
@@ -24,6 +28,9 @@ 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());
@@ -54,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;
@@ -83,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/main.c
+++ b/backend_test/example_sdl_vulkan/main.c
@@ -11,6 +11,10 @@
 #include <volk.h>
 #endif

+#ifdef _WIN32
+#include <windows.h>        // SetProcessDPIAware()
+#endif
+
 //this must be equal to that in imgui_impl_vulkan.h
 #define IMGUI_IMPL_VULKAN_MINIMUM_IMAGE_SAMPLER_POOL_SIZE   (1)     // Minimum per atlas

@@ -376,6 +380,9 @@ static void FramePresent(ImGui_ImplVulkanH_Window* wd)
 // Main code
 int main(int argc, char* argv[])
 {
+#ifdef _WIN32
+    SetProcessDPIAware();
+#endif
    //g_MainWindowData.ClearEnable = true;
 	//ImGui_ImplVulkanH_Window_Construct(&g_MainWindowData);
 	g_MainWindowData = *ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window();
@@ -391,9 +398,10 @@ int main(int argc, char* argv[])
    SDL_SetHint(SDL_HINT_IME_SHOW_UI, "1");
 #endif

-    // Create window with Vulkan graphics context
+    float main_scale = ImGui_ImplSDL2_GetContentScaleForDisplay(0);
    SDL_WindowFlags window_flags = (SDL_WindowFlags)(SDL_WINDOW_VULKAN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
-    SDL_Window* window = SDL_CreateWindow("Dear ImGui SDL2+Vulkan example", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1280, 720, window_flags);
+    SDL_Window* window = SDL_CreateWindow("Dear ImGui SDL2+Vulkan example", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, (int)(1280 * main_scale), (int)(720 * main_scale), window_flags);
+    
    if (window == NULL)
    {
        printf("Error: SDL_CreateWindow(): %s\n", SDL_GetError());
@@ -445,6 +453,10 @@ int main(int argc, char* argv[])
        style->Colors[ImGuiCol_WindowBg].w = 1.0f;
    }

+    // Setup scaling
+    ImGuiStyle_ScaleAllSizes(style, main_scale);        // Bake a fixed style scale. (until we have a solution for dynamic style scaling, changing this requires resetting Style + calling this again)
+    style->FontScaleDpi = main_scale;        // Set initial font scale. (using io.ConfigDpiScaleFonts=true makes this unnecessary. We leave both here for documentation purpose)
+
    // Setup Platform/Renderer backends
    ImGui_ImplSDL2_InitForVulkan(window);
    ImGui_ImplVulkan_InitInfo init_info = {};
--- a/backend_test/example_sdlgpu3/CMakeLists.txt
+++ b/backend_test/example_sdlgpu3/CMakeLists.txt
@@ -13,9 +13,11 @@ FetchContent_Declare(
 set(SDL_TEST_LIBRARY OFF CACHE BOOL "" FORCE)
 FetchContent_MakeAvailable(sdl3)

-include(GenerateCimguiBindings.cmake)
+include(../cmake/GenerateCimguiBindings.cmake)

-GenerateCimguiBindings(cimgui_with_backend)
+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
--- a/backend_test/example_sdlgpu3/main.c
+++ b/backend_test/example_sdlgpu3/main.c
@@ -13,18 +13,22 @@
 #define igGetIO igGetIO_Nil

 int main() {
-    if (!SDL_Init(SDL_INIT_VIDEO)) {
+    if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMEPAD)) {
      fprintf(stderr, "Failed to init video! %s", SDL_GetError());
      return 1;
    };
    
-    SDL_Window *window = NULL;
-    window = SDL_CreateWindow("cimgui SDL3+SDL_GPU example", 1280, 720, SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIGH_PIXEL_DENSITY);
+    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);
@@ -52,10 +56,16 @@ int main() {
    // 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 = {};
+    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;
@@ -158,10 +168,10 @@ int main() {
        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);
+            ImGui_ImplSDLGPU3_PrepareDrawData(draw_data, command_buffer);

            // Setup and start a render pass
-            SDL_GPUColorTargetInfo target_info = {};
+            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;
@@ -172,6 +182,12 @@ int main() {
            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
--- a/cimgui.cpp
+++ b/cimgui.cpp
--- a/cimgui.h
+++ b/cimgui.h
--- a/cimgui_impl.h
+++ b/cimgui_impl.h
@@ -1,3 +1,5 @@
+#ifndef CIMGUI_IMPL_DEFINED
+#define CIMGUI_IMPL_DEFINED
 #ifdef CIMGUI_USE_GLFW
 #ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS

@@ -23,6 +25,8 @@ CIMGUI_API void ImGui_ImplGlfw_KeyCallback(GLFWwindow* window,int key,int scanco
 CIMGUI_API void ImGui_ImplGlfw_CharCallback(GLFWwindow* window,unsigned int c);
 CIMGUI_API void ImGui_ImplGlfw_MonitorCallback(GLFWmonitor* monitor,int event);
 CIMGUI_API void ImGui_ImplGlfw_Sleep(int milliseconds);
+CIMGUI_API float ImGui_ImplGlfw_GetContentScaleForWindow(GLFWwindow* window);
+CIMGUI_API float ImGui_ImplGlfw_GetContentScaleForMonitor(GLFWmonitor* monitor);

 #endif
 #ifdef CIMGUI_USE_OPENGL3
@@ -30,10 +34,9 @@ CIMGUI_API bool ImGui_ImplOpenGL3_Init(const char* glsl_version);
 CIMGUI_API void ImGui_ImplOpenGL3_Shutdown(void);
 CIMGUI_API void ImGui_ImplOpenGL3_NewFrame(void);
 CIMGUI_API void ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data);
-CIMGUI_API bool ImGui_ImplOpenGL3_CreateFontsTexture(void);
-CIMGUI_API void ImGui_ImplOpenGL3_DestroyFontsTexture(void);
 CIMGUI_API bool ImGui_ImplOpenGL3_CreateDeviceObjects(void);
 CIMGUI_API void ImGui_ImplOpenGL3_DestroyDeviceObjects(void);
+CIMGUI_API void ImGui_ImplOpenGL3_UpdateTexture(ImTextureData* tex);

 #endif
 #ifdef CIMGUI_USE_OPENGL2
@@ -41,10 +44,9 @@ CIMGUI_API bool ImGui_ImplOpenGL2_Init(void);
 CIMGUI_API void ImGui_ImplOpenGL2_Shutdown(void);
 CIMGUI_API void ImGui_ImplOpenGL2_NewFrame(void);
 CIMGUI_API void ImGui_ImplOpenGL2_RenderDrawData(ImDrawData* draw_data);
-CIMGUI_API bool ImGui_ImplOpenGL2_CreateFontsTexture(void);
-CIMGUI_API void ImGui_ImplOpenGL2_DestroyFontsTexture(void);
 CIMGUI_API bool ImGui_ImplOpenGL2_CreateDeviceObjects(void);
 CIMGUI_API void ImGui_ImplOpenGL2_DestroyDeviceObjects(void);
+CIMGUI_API void ImGui_ImplOpenGL2_UpdateTexture(ImTextureData* tex);

 #endif
 #ifdef CIMGUI_USE_SDL2
@@ -68,6 +70,8 @@ CIMGUI_API bool ImGui_ImplSDL2_InitForOther(SDL_Window* window);
 CIMGUI_API void ImGui_ImplSDL2_Shutdown(void);
 CIMGUI_API void ImGui_ImplSDL2_NewFrame(void);
 CIMGUI_API bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event);
+CIMGUI_API float ImGui_ImplSDL2_GetContentScaleForWindow(SDL_Window* window);
+CIMGUI_API float ImGui_ImplSDL2_GetContentScaleForDisplay(int display_index);
 CIMGUI_API void ImGui_ImplSDL2_SetGamepadMode(ImGui_ImplSDL2_GamepadMode mode,struct _SDL_GameController** manual_gamepads_array,int manual_gamepads_count);

 #endif
@@ -111,19 +115,27 @@ struct ImGui_ImplVulkan_InitInfo
    uint32_t QueueFamily;
    VkQueue Queue;
    VkDescriptorPool DescriptorPool;
-    VkRenderPass RenderPass;
+    uint32_t DescriptorPoolSize;
    uint32_t MinImageCount;
    uint32_t ImageCount;
-    VkSampleCountFlagBits MSAASamples;
    VkPipelineCache PipelineCache;
+    VkRenderPass RenderPass;
    uint32_t Subpass;
-    uint32_t DescriptorPoolSize;
+    VkSampleCountFlagBits MSAASamples;
    bool UseDynamicRendering;
    VkPipelineRenderingCreateInfoKHR PipelineRenderingCreateInfo;
    const VkAllocationCallbacks* Allocator;
    void (*CheckVkResultFn)(VkResult err);
    VkDeviceSize MinAllocationSize;
 };
+typedef struct ImGui_ImplVulkan_MainPipelineCreateInfo ImGui_ImplVulkan_MainPipelineCreateInfo;
+struct ImGui_ImplVulkan_MainPipelineCreateInfo
+{
+    VkRenderPass RenderPass;
+    uint32_t Subpass;
+    VkSampleCountFlagBits MSAASamples;
+    VkPipelineRenderingCreateInfoKHR PipelineRenderingCreateInfo;
+};
 typedef struct ImGui_ImplVulkan_RenderState ImGui_ImplVulkan_RenderState;
 struct ImGui_ImplVulkan_RenderState
 {
@@ -161,6 +173,7 @@ struct ImGui_ImplVulkanH_Window
    VkSurfaceFormatKHR SurfaceFormat;
    VkPresentModeKHR PresentMode;
    VkRenderPass RenderPass;
+    VkPipeline Pipeline;
    bool UseDynamicRendering;
    bool ClearEnable;
    VkClearValue ClearValue;
@@ -180,14 +193,14 @@ CIMGUI_API bool ImGui_ImplVulkan_Init(ImGui_ImplVulkan_InitInfo* info);
 CIMGUI_API void ImGui_ImplVulkan_Shutdown(void);
 CIMGUI_API void ImGui_ImplVulkan_NewFrame(void);
 CIMGUI_API void ImGui_ImplVulkan_RenderDrawData(ImDrawData* draw_data,VkCommandBuffer command_buffer,VkPipeline pipeline);
-CIMGUI_API bool ImGui_ImplVulkan_CreateFontsTexture(void);
-CIMGUI_API void ImGui_ImplVulkan_DestroyFontsTexture(void);
 CIMGUI_API void ImGui_ImplVulkan_SetMinImageCount(uint32_t min_image_count);
+CIMGUI_API void ImGui_ImplVulkan_CreateMainPipeline(const ImGui_ImplVulkan_MainPipelineCreateInfo info);
+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* wd,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* wd,const VkAllocationCallbacks* allocator);
+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);
@@ -196,3 +209,4 @@ CIMGUI_API int ImGui_ImplVulkanH_GetMinImageCountFromPresentMode(VkPresentModeKH
 CIMGUI_API ImGui_ImplVulkanH_Window* ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window(void);

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

                if def.stname == "" or def.is_static_function then --ImGui namespace or top level
                    table.insert(outtab,"CIMGUI_API "..def.ret.." ".. def.ov_cimguiname ..(empty and "(void)" or def.args)..";"..addcoment.."\n")
+					if def.isvararg then
+						-- For variadic functions we add a function implementation with zero argumets, for compatibility with languages such as C#.
+						table.insert(outtab, "#ifdef CIMGUI_VARGS0\n")
+						table.insert(outtab, "CIMGUI_API".." "..def.ret.." "..def.ov_cimguiname.."0"..paramListWithoutDots(def.args)..";\n")
+						table.insert(outtab, "#endif\n")
+					end
                else
                    table.insert(outtab,"CIMGUI_API "..def.ret.." "..def.ov_cimguiname..def.args..";"..addcoment.."\n")
                end
--- a/generator/generator.lua
+++ b/generator/generator.lua
@@ -78,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
@@ -460,7 +460,7 @@ if #implementations > 0 then
    parser2 = cpp2ffi.Parser()
 	
 	local config = dofile(CONFIG_GENERATOR_PATH) --"./config_generator.lua"
-    local impl_str = ""
+    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)
@@ -502,7 +502,7 @@ if #implementations > 0 then
 		end
 		impl_str = impl_str.. table.concat(outtab)..cfuncsstr .. "\n#endif\n"
    end
-	
+	impl_str = impl_str .. "#endif //CIMGUI_IMPL_DEFINED\n"
    parser2:do_parse()
 	save_data("./output/cimgui_impl.h",impl_str)

@@ -513,6 +513,11 @@ if #implementations > 0 then
 	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

@@ -544,11 +549,7 @@ end
 --]]
 -------------------copy C files to repo root
 copyfile("./output/cimgui.h", "../cimgui.h")
-copyfile("./output/cimgui_impl.h", "../cimgui_impl.h")
-copyfile("./output/cimgui_impl.cpp", "../cimgui_impl.cpp")
 copyfile("./output/cimgui.cpp", "../cimgui.cpp")
 os.remove("./output/cimgui.h")
-os.remove("./output/cimgui_impl.h")
-os.remove("./output/cimgui_impl.cpp")
 os.remove("./output/cimgui.cpp")
 print"all done!!"
--- a/generator/generator.sh
+++ b/generator/generator.sh
@@ -25,7 +25,7 @@
 POSITIONAL_ARGS=()

 TARGETS="internal noimstrv"
-CFLAGS="glfw opengl3 opengl2 sdl2 sdl3 vulkan"
+CFLAGS="glfw opengl3 opengl2 sdl2 sdl3"

 help() {
        cat <<EOF
--- 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:63",
+      "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:58",
+      "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:59",
+      "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:34",
+      "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:36",
+      "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:35",
+      "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:49",
+      "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:62",
+      "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:64",
+      "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:60",
+      "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:38",
+      "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:50",
+      "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:61",
+      "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:54",
+      "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:37",
+      "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:67",
+      "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:57",
+      "location": "imgui_impl_glfw:55",
      "ov_cimguiname": "ImGui_ImplGlfw_WindowFocusCallback",
      "ret": "void",
      "signature": "(GLFWwindow*,int)",
@@ -427,24 +469,8 @@
      "cimguiname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
      "defaults": {},
      "funcname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
-      "location": "imgui_impl_opengl2:39",
-      "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:37",
-      "ov_cimguiname": "ImGui_ImplOpenGL2_CreateFontsTexture",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_CreateDeviceObjects",
      "ret": "bool",
      "signature": "()",
      "stname": ""
@@ -459,24 +485,8 @@
      "cimguiname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
      "defaults": {},
      "funcname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
-      "location": "imgui_impl_opengl2:40",
-      "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:38",
-      "ov_cimguiname": "ImGui_ImplOpenGL2_DestroyFontsTexture",
+      "ov_cimguiname": "ImGui_ImplOpenGL2_DestroyDeviceObjects",
      "ret": "void",
      "signature": "()",
      "stname": ""
@@ -551,6 +561,27 @@
      "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,24 +591,8 @@
      "cimguiname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
      "defaults": {},
      "funcname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
-      "location": "imgui_impl_opengl3:42",
-      "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:40",
-      "ov_cimguiname": "ImGui_ImplOpenGL3_CreateFontsTexture",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_CreateDeviceObjects",
      "ret": "bool",
      "signature": "()",
      "stname": ""
@@ -592,24 +607,8 @@
      "cimguiname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
      "defaults": {},
      "funcname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
-      "location": "imgui_impl_opengl3:43",
-      "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:41",
-      "ov_cimguiname": "ImGui_ImplOpenGL3_DestroyFontsTexture",
+      "ov_cimguiname": "ImGui_ImplOpenGL3_DestroyDeviceObjects",
      "ret": "void",
      "signature": "()",
      "stname": ""
@@ -691,6 +690,69 @@
      "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)",
@@ -705,7 +767,7 @@
      "cimguiname": "ImGui_ImplSDL2_InitForD3D",
      "defaults": {},
      "funcname": "ImGui_ImplSDL2_InitForD3D",
-      "location": "imgui_impl_sdl2:37",
+      "location": "imgui_impl_sdl2:33",
      "ov_cimguiname": "ImGui_ImplSDL2_InitForD3D",
      "ret": "bool",
      "signature": "(SDL_Window*)",
@@ -726,7 +788,7 @@
      "cimguiname": "ImGui_ImplSDL2_InitForMetal",
      "defaults": {},
      "funcname": "ImGui_ImplSDL2_InitForMetal",
-      "location": "imgui_impl_sdl2:38",
+      "location": "imgui_impl_sdl2:34",
      "ov_cimguiname": "ImGui_ImplSDL2_InitForMetal",
      "ret": "bool",
      "signature": "(SDL_Window*)",
@@ -751,7 +813,7 @@
      "cimguiname": "ImGui_ImplSDL2_InitForOpenGL",
      "defaults": {},
      "funcname": "ImGui_ImplSDL2_InitForOpenGL",
-      "location": "imgui_impl_sdl2:35",
+      "location": "imgui_impl_sdl2:31",
      "ov_cimguiname": "ImGui_ImplSDL2_InitForOpenGL",
      "ret": "bool",
      "signature": "(SDL_Window*,void*)",
@@ -772,7 +834,7 @@
      "cimguiname": "ImGui_ImplSDL2_InitForOther",
      "defaults": {},
      "funcname": "ImGui_ImplSDL2_InitForOther",
-      "location": "imgui_impl_sdl2:40",
+      "location": "imgui_impl_sdl2:36",
      "ov_cimguiname": "ImGui_ImplSDL2_InitForOther",
      "ret": "bool",
      "signature": "(SDL_Window*)",
@@ -797,7 +859,7 @@
      "cimguiname": "ImGui_ImplSDL2_InitForSDLRenderer",
      "defaults": {},
      "funcname": "ImGui_ImplSDL2_InitForSDLRenderer",
-      "location": "imgui_impl_sdl2:39",
+      "location": "imgui_impl_sdl2:35",
      "ov_cimguiname": "ImGui_ImplSDL2_InitForSDLRenderer",
      "ret": "bool",
      "signature": "(SDL_Window*,SDL_Renderer*)",
@@ -818,7 +880,7 @@
      "cimguiname": "ImGui_ImplSDL2_InitForVulkan",
      "defaults": {},
      "funcname": "ImGui_ImplSDL2_InitForVulkan",
-      "location": "imgui_impl_sdl2:36",
+      "location": "imgui_impl_sdl2:32",
      "ov_cimguiname": "ImGui_ImplSDL2_InitForVulkan",
      "ret": "bool",
      "signature": "(SDL_Window*)",
@@ -834,7 +896,7 @@
      "cimguiname": "ImGui_ImplSDL2_NewFrame",
      "defaults": {},
      "funcname": "ImGui_ImplSDL2_NewFrame",
-      "location": "imgui_impl_sdl2:42",
+      "location": "imgui_impl_sdl2:38",
      "ov_cimguiname": "ImGui_ImplSDL2_NewFrame",
      "ret": "void",
      "signature": "()",
@@ -855,7 +917,7 @@
      "cimguiname": "ImGui_ImplSDL2_ProcessEvent",
      "defaults": {},
      "funcname": "ImGui_ImplSDL2_ProcessEvent",
-      "location": "imgui_impl_sdl2:43",
+      "location": "imgui_impl_sdl2:39",
      "ov_cimguiname": "ImGui_ImplSDL2_ProcessEvent",
      "ret": "bool",
      "signature": "(const SDL_Event*)",
@@ -903,7 +965,7 @@
      "cimguiname": "ImGui_ImplSDL2_Shutdown",
      "defaults": {},
      "funcname": "ImGui_ImplSDL2_Shutdown",
-      "location": "imgui_impl_sdl2:41",
+      "location": "imgui_impl_sdl2:37",
      "ov_cimguiname": "ImGui_ImplSDL2_Shutdown",
      "ret": "void",
      "signature": "()",
@@ -924,7 +986,7 @@
      "cimguiname": "ImGui_ImplSDL3_InitForD3D",
      "defaults": {},
      "funcname": "ImGui_ImplSDL3_InitForD3D",
-      "location": "imgui_impl_sdl3:36",
+      "location": "imgui_impl_sdl3:33",
      "ov_cimguiname": "ImGui_ImplSDL3_InitForD3D",
      "ret": "bool",
      "signature": "(SDL_Window*)",
@@ -945,7 +1007,7 @@
      "cimguiname": "ImGui_ImplSDL3_InitForMetal",
      "defaults": {},
      "funcname": "ImGui_ImplSDL3_InitForMetal",
-      "location": "imgui_impl_sdl3:37",
+      "location": "imgui_impl_sdl3:34",
      "ov_cimguiname": "ImGui_ImplSDL3_InitForMetal",
      "ret": "bool",
      "signature": "(SDL_Window*)",
@@ -970,7 +1032,7 @@
      "cimguiname": "ImGui_ImplSDL3_InitForOpenGL",
      "defaults": {},
      "funcname": "ImGui_ImplSDL3_InitForOpenGL",
-      "location": "imgui_impl_sdl3:34",
+      "location": "imgui_impl_sdl3:31",
      "ov_cimguiname": "ImGui_ImplSDL3_InitForOpenGL",
      "ret": "bool",
      "signature": "(SDL_Window*,void*)",
@@ -991,7 +1053,7 @@
      "cimguiname": "ImGui_ImplSDL3_InitForOther",
      "defaults": {},
      "funcname": "ImGui_ImplSDL3_InitForOther",
-      "location": "imgui_impl_sdl3:40",
+      "location": "imgui_impl_sdl3:37",
      "ov_cimguiname": "ImGui_ImplSDL3_InitForOther",
      "ret": "bool",
      "signature": "(SDL_Window*)",
@@ -1012,7 +1074,7 @@
      "cimguiname": "ImGui_ImplSDL3_InitForSDLGPU",
      "defaults": {},
      "funcname": "ImGui_ImplSDL3_InitForSDLGPU",
-      "location": "imgui_impl_sdl3:39",
+      "location": "imgui_impl_sdl3:36",
      "ov_cimguiname": "ImGui_ImplSDL3_InitForSDLGPU",
      "ret": "bool",
      "signature": "(SDL_Window*)",
@@ -1037,7 +1099,7 @@
      "cimguiname": "ImGui_ImplSDL3_InitForSDLRenderer",
      "defaults": {},
      "funcname": "ImGui_ImplSDL3_InitForSDLRenderer",
-      "location": "imgui_impl_sdl3:38",
+      "location": "imgui_impl_sdl3:35",
      "ov_cimguiname": "ImGui_ImplSDL3_InitForSDLRenderer",
      "ret": "bool",
      "signature": "(SDL_Window*,SDL_Renderer*)",
@@ -1058,7 +1120,7 @@
      "cimguiname": "ImGui_ImplSDL3_InitForVulkan",
      "defaults": {},
      "funcname": "ImGui_ImplSDL3_InitForVulkan",
-      "location": "imgui_impl_sdl3:35",
+      "location": "imgui_impl_sdl3:32",
      "ov_cimguiname": "ImGui_ImplSDL3_InitForVulkan",
      "ret": "bool",
      "signature": "(SDL_Window*)",
@@ -1074,7 +1136,7 @@
      "cimguiname": "ImGui_ImplSDL3_NewFrame",
      "defaults": {},
      "funcname": "ImGui_ImplSDL3_NewFrame",
-      "location": "imgui_impl_sdl3:42",
+      "location": "imgui_impl_sdl3:39",
      "ov_cimguiname": "ImGui_ImplSDL3_NewFrame",
      "ret": "void",
      "signature": "()",
@@ -1095,7 +1157,7 @@
      "cimguiname": "ImGui_ImplSDL3_ProcessEvent",
      "defaults": {},
      "funcname": "ImGui_ImplSDL3_ProcessEvent",
-      "location": "imgui_impl_sdl3:43",
+      "location": "imgui_impl_sdl3:40",
      "ov_cimguiname": "ImGui_ImplSDL3_ProcessEvent",
      "ret": "bool",
      "signature": "(const SDL_Event*)",
@@ -1127,7 +1189,7 @@
        "manual_gamepads_count": "-1"
      },
      "funcname": "ImGui_ImplSDL3_SetGamepadMode",
-      "location": "imgui_impl_sdl3:48",
+      "location": "imgui_impl_sdl3:45",
      "ov_cimguiname": "ImGui_ImplSDL3_SetGamepadMode",
      "ret": "void",
      "signature": "(ImGui_ImplSDL3_GamepadMode,SDL_Gamepad**,int)",
@@ -1143,7 +1205,7 @@
      "cimguiname": "ImGui_ImplSDL3_Shutdown",
      "defaults": {},
      "funcname": "ImGui_ImplSDL3_Shutdown",
-      "location": "imgui_impl_sdl3:41",
+      "location": "imgui_impl_sdl3:38",
      "ov_cimguiname": "ImGui_ImplSDL3_Shutdown",
      "ret": "void",
      "signature": "()",
@@ -1152,7 +1214,7 @@
  ],
  "ImGui_ImplVulkanH_CreateOrResizeWindow": [
    {
-      "args": "(VkInstance instance,VkPhysicalDevice physical_device,VkDevice device,ImGui_ImplVulkanH_Window* wd,uint32_t queue_family,const VkAllocationCallbacks* allocator,int w,int h,uint32_t min_image_count)",
+      "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",
@@ -1167,7 +1229,7 @@
          "type": "VkDevice"
        },
        {
-          "name": "wd",
+          "name": "wnd",
          "type": "ImGui_ImplVulkanH_Window*"
        },
        {
@@ -1191,12 +1253,12 @@
          "type": "uint32_t"
        }
      ],
-      "argsoriginal": "(VkInstance instance,VkPhysicalDevice physical_device,VkDevice device,ImGui_ImplVulkanH_Window* wd,uint32_t queue_family,const VkAllocationCallbacks* allocator,int w,int h,uint32_t min_image_count)",
-      "call_args": "(instance,physical_device,device,wd,queue_family,allocator,w,h,min_image_count)",
+      "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",
+      "location": "imgui_impl_vulkan:178",
      "ov_cimguiname": "ImGui_ImplVulkanH_CreateOrResizeWindow",
      "ret": "void",
      "signature": "(VkInstance,VkPhysicalDevice,VkDevice,ImGui_ImplVulkanH_Window*,uint32_t,const VkAllocationCallbacks*,int,int,uint32_t)",
@@ -1205,7 +1267,7 @@
  ],
  "ImGui_ImplVulkanH_DestroyWindow": [
    {
-      "args": "(VkInstance instance,VkDevice device,ImGui_ImplVulkanH_Window* wd,const VkAllocationCallbacks* allocator)",
+      "args": "(VkInstance instance,VkDevice device,ImGui_ImplVulkanH_Window* wnd,const VkAllocationCallbacks* allocator)",
      "argsT": [
        {
          "name": "instance",
@@ -1216,7 +1278,7 @@
          "type": "VkDevice"
        },
        {
-          "name": "wd",
+          "name": "wnd",
          "type": "ImGui_ImplVulkanH_Window*"
        },
        {
@@ -1224,12 +1286,12 @@
          "type": "const VkAllocationCallbacks*"
        }
      ],
-      "argsoriginal": "(VkInstance instance,VkDevice device,ImGui_ImplVulkanH_Window* wd,const VkAllocationCallbacks* allocator)",
-      "call_args": "(instance,device,wd,allocator)",
+      "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",
+      "location": "imgui_impl_vulkan:179",
      "ov_cimguiname": "ImGui_ImplVulkanH_DestroyWindow",
      "ret": "void",
      "signature": "(VkInstance,VkDevice,ImGui_ImplVulkanH_Window*,const VkAllocationCallbacks*)",
@@ -1250,7 +1312,7 @@
      "cimguiname": "ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
      "defaults": {},
      "funcname": "ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
-      "location": "imgui_impl_vulkan:172",
+      "location": "imgui_impl_vulkan:184",
      "ov_cimguiname": "ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
      "ret": "int",
      "signature": "(VkPresentModeKHR)",
@@ -1271,7 +1333,7 @@
      "cimguiname": "ImGui_ImplVulkanH_SelectPhysicalDevice",
      "defaults": {},
      "funcname": "ImGui_ImplVulkanH_SelectPhysicalDevice",
-      "location": "imgui_impl_vulkan:170",
+      "location": "imgui_impl_vulkan:182",
      "ov_cimguiname": "ImGui_ImplVulkanH_SelectPhysicalDevice",
      "ret": "VkPhysicalDevice",
      "signature": "(VkInstance)",
@@ -1304,7 +1366,7 @@
      "cimguiname": "ImGui_ImplVulkanH_SelectPresentMode",
      "defaults": {},
      "funcname": "ImGui_ImplVulkanH_SelectPresentMode",
-      "location": "imgui_impl_vulkan:169",
+      "location": "imgui_impl_vulkan:181",
      "ov_cimguiname": "ImGui_ImplVulkanH_SelectPresentMode",
      "ret": "VkPresentModeKHR",
      "signature": "(VkPhysicalDevice,VkSurfaceKHR,const VkPresentModeKHR*,int)",
@@ -1325,7 +1387,7 @@
      "cimguiname": "ImGui_ImplVulkanH_SelectQueueFamilyIndex",
      "defaults": {},
      "funcname": "ImGui_ImplVulkanH_SelectQueueFamilyIndex",
-      "location": "imgui_impl_vulkan:171",
+      "location": "imgui_impl_vulkan:183",
      "ov_cimguiname": "ImGui_ImplVulkanH_SelectQueueFamilyIndex",
      "ret": "uint32_t",
      "signature": "(VkPhysicalDevice)",
@@ -1362,7 +1424,7 @@
      "cimguiname": "ImGui_ImplVulkanH_SelectSurfaceFormat",
      "defaults": {},
      "funcname": "ImGui_ImplVulkanH_SelectSurfaceFormat",
-      "location": "imgui_impl_vulkan:168",
+      "location": "imgui_impl_vulkan:180",
      "ov_cimguiname": "ImGui_ImplVulkanH_SelectSurfaceFormat",
      "ret": "VkSurfaceFormatKHR",
      "signature": "(VkPhysicalDevice,VkSurfaceKHR,const VkFormat*,int,VkColorSpaceKHR)",
@@ -1379,7 +1441,7 @@
      "constructor": true,
      "defaults": {},
      "funcname": "ImGui_ImplVulkanH_Window",
-      "location": "imgui_impl_vulkan:214",
+      "location": "imgui_impl_vulkan:227",
      "ov_cimguiname": "ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window",
      "signature": "()",
      "stname": "ImGui_ImplVulkanH_Window"
@@ -1398,7 +1460,7 @@
      "cimguiname": "ImGui_ImplVulkanH_Window_destroy",
      "defaults": {},
      "destructor": true,
-      "location": "imgui_impl_vulkan:214",
+      "location": "imgui_impl_vulkan:227",
      "ov_cimguiname": "ImGui_ImplVulkanH_Window_destroy",
      "ret": "void",
      "signature": "(ImGui_ImplVulkanH_Window*)",
@@ -1427,42 +1489,31 @@
      "cimguiname": "ImGui_ImplVulkan_AddTexture",
      "defaults": {},
      "funcname": "ImGui_ImplVulkan_AddTexture",
-      "location": "imgui_impl_vulkan:123",
+      "location": "imgui_impl_vulkan:135",
      "ov_cimguiname": "ImGui_ImplVulkan_AddTexture",
      "ret": "VkDescriptorSet",
      "signature": "(VkSampler,VkImageView,VkImageLayout)",
      "stname": ""
    }
  ],
-  "ImGui_ImplVulkan_CreateFontsTexture": [
+  "ImGui_ImplVulkan_CreateMainPipeline": [
    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGui_ImplVulkan_CreateFontsTexture",
+      "args": "(const ImGui_ImplVulkan_MainPipelineCreateInfo info)",
+      "argsT": [
+        {
+          "name": "info",
+          "type": "const ImGui_ImplVulkan_MainPipelineCreateInfo"
+        }
+      ],
+      "argsoriginal": "(const ImGui_ImplVulkan_MainPipelineCreateInfo& info)",
+      "call_args": "(info)",
+      "cimguiname": "ImGui_ImplVulkan_CreateMainPipeline",
      "defaults": {},
-      "funcname": "ImGui_ImplVulkan_CreateFontsTexture",
-      "location": "imgui_impl_vulkan:116",
-      "ov_cimguiname": "ImGui_ImplVulkan_CreateFontsTexture",
-      "ret": "bool",
-      "signature": "()",
-      "stname": ""
-    }
-  ],
-  "ImGui_ImplVulkan_DestroyFontsTexture": [
-    {
-      "args": "()",
-      "argsT": [],
-      "argsoriginal": "()",
-      "call_args": "()",
-      "cimguiname": "ImGui_ImplVulkan_DestroyFontsTexture",
-      "defaults": {},
-      "funcname": "ImGui_ImplVulkan_DestroyFontsTexture",
-      "location": "imgui_impl_vulkan:117",
-      "ov_cimguiname": "ImGui_ImplVulkan_DestroyFontsTexture",
+      "funcname": "ImGui_ImplVulkan_CreateMainPipeline",
+      "location": "imgui_impl_vulkan:127",
+      "ov_cimguiname": "ImGui_ImplVulkan_CreateMainPipeline",
      "ret": "void",
-      "signature": "()",
+      "signature": "(const ImGui_ImplVulkan_MainPipelineCreateInfo)",
      "stname": ""
    }
  ],
@@ -1480,7 +1531,7 @@
      "cimguiname": "ImGui_ImplVulkan_Init",
      "defaults": {},
      "funcname": "ImGui_ImplVulkan_Init",
-      "location": "imgui_impl_vulkan:112",
+      "location": "imgui_impl_vulkan:109",
      "ov_cimguiname": "ImGui_ImplVulkan_Init",
      "ret": "bool",
      "signature": "(ImGui_ImplVulkan_InitInfo*)",
@@ -1511,7 +1562,7 @@
        "user_data": "nullptr"
      },
      "funcname": "ImGui_ImplVulkan_LoadFunctions",
-      "location": "imgui_impl_vulkan:128",
+      "location": "imgui_impl_vulkan:140",
      "ov_cimguiname": "ImGui_ImplVulkan_LoadFunctions",
      "ret": "bool",
      "signature": "(uint32_t,PFN_vkVoidFunction(*loader_func)(const char* function_name,void*,void*)",
@@ -1527,7 +1578,7 @@
      "cimguiname": "ImGui_ImplVulkan_NewFrame",
      "defaults": {},
      "funcname": "ImGui_ImplVulkan_NewFrame",
-      "location": "imgui_impl_vulkan:114",
+      "location": "imgui_impl_vulkan:111",
      "ov_cimguiname": "ImGui_ImplVulkan_NewFrame",
      "ret": "void",
      "signature": "()",
@@ -1548,7 +1599,7 @@
      "cimguiname": "ImGui_ImplVulkan_RemoveTexture",
      "defaults": {},
      "funcname": "ImGui_ImplVulkan_RemoveTexture",
-      "location": "imgui_impl_vulkan:124",
+      "location": "imgui_impl_vulkan:136",
      "ov_cimguiname": "ImGui_ImplVulkan_RemoveTexture",
      "ret": "void",
      "signature": "(VkDescriptorSet)",
@@ -1579,7 +1630,7 @@
        "pipeline": "0ULL"
      },
      "funcname": "ImGui_ImplVulkan_RenderDrawData",
-      "location": "imgui_impl_vulkan:115",
+      "location": "imgui_impl_vulkan:112",
      "ov_cimguiname": "ImGui_ImplVulkan_RenderDrawData",
      "ret": "void",
      "signature": "(ImDrawData*,VkCommandBuffer,VkPipeline)",
@@ -1600,7 +1651,7 @@
      "cimguiname": "ImGui_ImplVulkan_SetMinImageCount",
      "defaults": {},
      "funcname": "ImGui_ImplVulkan_SetMinImageCount",
-      "location": "imgui_impl_vulkan:118",
+      "location": "imgui_impl_vulkan:113",
      "ov_cimguiname": "ImGui_ImplVulkan_SetMinImageCount",
      "ret": "void",
      "signature": "(uint32_t)",
@@ -1616,11 +1667,32 @@
      "cimguiname": "ImGui_ImplVulkan_Shutdown",
      "defaults": {},
      "funcname": "ImGui_ImplVulkan_Shutdown",
-      "location": "imgui_impl_vulkan:113",
+      "location": "imgui_impl_vulkan:110",
      "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:130",
+      "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:63",
+      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:58",
+      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:59",
+      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:34",
+      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:36",
+      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:35",
+      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:49",
+      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:62",
+      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:64",
+      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:60",
+      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:38",
+      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:50",
+      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:61",
+      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:54",
+      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:37",
+      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:67",
+      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:57",
+      location="imgui_impl_glfw:55",
      ov_cimguiname="ImGui_ImplGlfw_WindowFocusCallback",
      ret="void",
      signature="(GLFWwindow*,int)",
@@ -362,23 +398,8 @@ local t={
      cimguiname="ImGui_ImplOpenGL2_CreateDeviceObjects",
      defaults={},
      funcname="ImGui_ImplOpenGL2_CreateDeviceObjects",
-      location="imgui_impl_opengl2:39",
-      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:37",
-      ov_cimguiname="ImGui_ImplOpenGL2_CreateFontsTexture",
+      ov_cimguiname="ImGui_ImplOpenGL2_CreateDeviceObjects",
      ret="bool",
      signature="()",
      stname=""},
@@ -392,23 +413,8 @@ local t={
      cimguiname="ImGui_ImplOpenGL2_DestroyDeviceObjects",
      defaults={},
      funcname="ImGui_ImplOpenGL2_DestroyDeviceObjects",
-      location="imgui_impl_opengl2:40",
-      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:38",
-      ov_cimguiname="ImGui_ImplOpenGL2_DestroyFontsTexture",
+      ov_cimguiname="ImGui_ImplOpenGL2_DestroyDeviceObjects",
      ret="void",
      signature="()",
      stname=""},
@@ -476,6 +482,24 @@ local t={
      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,23 +509,8 @@ local t={
      cimguiname="ImGui_ImplOpenGL3_CreateDeviceObjects",
      defaults={},
      funcname="ImGui_ImplOpenGL3_CreateDeviceObjects",
-      location="imgui_impl_opengl3:42",
-      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:40",
-      ov_cimguiname="ImGui_ImplOpenGL3_CreateFontsTexture",
+      ov_cimguiname="ImGui_ImplOpenGL3_CreateDeviceObjects",
      ret="bool",
      signature="()",
      stname=""},
@@ -515,23 +524,8 @@ local t={
      cimguiname="ImGui_ImplOpenGL3_DestroyDeviceObjects",
      defaults={},
      funcname="ImGui_ImplOpenGL3_DestroyDeviceObjects",
-      location="imgui_impl_opengl3:43",
-      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:41",
-      ov_cimguiname="ImGui_ImplOpenGL3_DestroyFontsTexture",
+      ov_cimguiname="ImGui_ImplOpenGL3_DestroyDeviceObjects",
      ret="void",
      signature="()",
      stname=""},
@@ -603,6 +597,60 @@ local t={
      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)",
@@ -615,7 +663,7 @@ local t={
      cimguiname="ImGui_ImplSDL2_InitForD3D",
      defaults={},
      funcname="ImGui_ImplSDL2_InitForD3D",
-      location="imgui_impl_sdl2:37",
+      location="imgui_impl_sdl2:33",
      ov_cimguiname="ImGui_ImplSDL2_InitForD3D",
      ret="bool",
      signature="(SDL_Window*)",
@@ -633,7 +681,7 @@ local t={
      cimguiname="ImGui_ImplSDL2_InitForMetal",
      defaults={},
      funcname="ImGui_ImplSDL2_InitForMetal",
-      location="imgui_impl_sdl2:38",
+      location="imgui_impl_sdl2:34",
      ov_cimguiname="ImGui_ImplSDL2_InitForMetal",
      ret="bool",
      signature="(SDL_Window*)",
@@ -654,7 +702,7 @@ local t={
      cimguiname="ImGui_ImplSDL2_InitForOpenGL",
      defaults={},
      funcname="ImGui_ImplSDL2_InitForOpenGL",
-      location="imgui_impl_sdl2:35",
+      location="imgui_impl_sdl2:31",
      ov_cimguiname="ImGui_ImplSDL2_InitForOpenGL",
      ret="bool",
      signature="(SDL_Window*,void*)",
@@ -672,7 +720,7 @@ local t={
      cimguiname="ImGui_ImplSDL2_InitForOther",
      defaults={},
      funcname="ImGui_ImplSDL2_InitForOther",
-      location="imgui_impl_sdl2:40",
+      location="imgui_impl_sdl2:36",
      ov_cimguiname="ImGui_ImplSDL2_InitForOther",
      ret="bool",
      signature="(SDL_Window*)",
@@ -693,7 +741,7 @@ local t={
      cimguiname="ImGui_ImplSDL2_InitForSDLRenderer",
      defaults={},
      funcname="ImGui_ImplSDL2_InitForSDLRenderer",
-      location="imgui_impl_sdl2:39",
+      location="imgui_impl_sdl2:35",
      ov_cimguiname="ImGui_ImplSDL2_InitForSDLRenderer",
      ret="bool",
      signature="(SDL_Window*,SDL_Renderer*)",
@@ -711,7 +759,7 @@ local t={
      cimguiname="ImGui_ImplSDL2_InitForVulkan",
      defaults={},
      funcname="ImGui_ImplSDL2_InitForVulkan",
-      location="imgui_impl_sdl2:36",
+      location="imgui_impl_sdl2:32",
      ov_cimguiname="ImGui_ImplSDL2_InitForVulkan",
      ret="bool",
      signature="(SDL_Window*)",
@@ -726,7 +774,7 @@ local t={
      cimguiname="ImGui_ImplSDL2_NewFrame",
      defaults={},
      funcname="ImGui_ImplSDL2_NewFrame",
-      location="imgui_impl_sdl2:42",
+      location="imgui_impl_sdl2:38",
      ov_cimguiname="ImGui_ImplSDL2_NewFrame",
      ret="void",
      signature="()",
@@ -744,7 +792,7 @@ local t={
      cimguiname="ImGui_ImplSDL2_ProcessEvent",
      defaults={},
      funcname="ImGui_ImplSDL2_ProcessEvent",
-      location="imgui_impl_sdl2:43",
+      location="imgui_impl_sdl2:39",
      ov_cimguiname="ImGui_ImplSDL2_ProcessEvent",
      ret="bool",
      signature="(const SDL_Event*)",
@@ -785,7 +833,7 @@ local t={
      cimguiname="ImGui_ImplSDL2_Shutdown",
      defaults={},
      funcname="ImGui_ImplSDL2_Shutdown",
-      location="imgui_impl_sdl2:41",
+      location="imgui_impl_sdl2:37",
      ov_cimguiname="ImGui_ImplSDL2_Shutdown",
      ret="void",
      signature="()",
@@ -803,7 +851,7 @@ local t={
      cimguiname="ImGui_ImplSDL3_InitForD3D",
      defaults={},
      funcname="ImGui_ImplSDL3_InitForD3D",
-      location="imgui_impl_sdl3:36",
+      location="imgui_impl_sdl3:33",
      ov_cimguiname="ImGui_ImplSDL3_InitForD3D",
      ret="bool",
      signature="(SDL_Window*)",
@@ -821,7 +869,7 @@ local t={
      cimguiname="ImGui_ImplSDL3_InitForMetal",
      defaults={},
      funcname="ImGui_ImplSDL3_InitForMetal",
-      location="imgui_impl_sdl3:37",
+      location="imgui_impl_sdl3:34",
      ov_cimguiname="ImGui_ImplSDL3_InitForMetal",
      ret="bool",
      signature="(SDL_Window*)",
@@ -842,7 +890,7 @@ local t={
      cimguiname="ImGui_ImplSDL3_InitForOpenGL",
      defaults={},
      funcname="ImGui_ImplSDL3_InitForOpenGL",
-      location="imgui_impl_sdl3:34",
+      location="imgui_impl_sdl3:31",
      ov_cimguiname="ImGui_ImplSDL3_InitForOpenGL",
      ret="bool",
      signature="(SDL_Window*,void*)",
@@ -860,7 +908,7 @@ local t={
      cimguiname="ImGui_ImplSDL3_InitForOther",
      defaults={},
      funcname="ImGui_ImplSDL3_InitForOther",
-      location="imgui_impl_sdl3:40",
+      location="imgui_impl_sdl3:37",
      ov_cimguiname="ImGui_ImplSDL3_InitForOther",
      ret="bool",
      signature="(SDL_Window*)",
@@ -878,7 +926,7 @@ local t={
      cimguiname="ImGui_ImplSDL3_InitForSDLGPU",
      defaults={},
      funcname="ImGui_ImplSDL3_InitForSDLGPU",
-      location="imgui_impl_sdl3:39",
+      location="imgui_impl_sdl3:36",
      ov_cimguiname="ImGui_ImplSDL3_InitForSDLGPU",
      ret="bool",
      signature="(SDL_Window*)",
@@ -899,7 +947,7 @@ local t={
      cimguiname="ImGui_ImplSDL3_InitForSDLRenderer",
      defaults={},
      funcname="ImGui_ImplSDL3_InitForSDLRenderer",
-      location="imgui_impl_sdl3:38",
+      location="imgui_impl_sdl3:35",
      ov_cimguiname="ImGui_ImplSDL3_InitForSDLRenderer",
      ret="bool",
      signature="(SDL_Window*,SDL_Renderer*)",
@@ -917,7 +965,7 @@ local t={
      cimguiname="ImGui_ImplSDL3_InitForVulkan",
      defaults={},
      funcname="ImGui_ImplSDL3_InitForVulkan",
-      location="imgui_impl_sdl3:35",
+      location="imgui_impl_sdl3:32",
      ov_cimguiname="ImGui_ImplSDL3_InitForVulkan",
      ret="bool",
      signature="(SDL_Window*)",
@@ -932,7 +980,7 @@ local t={
      cimguiname="ImGui_ImplSDL3_NewFrame",
      defaults={},
      funcname="ImGui_ImplSDL3_NewFrame",
-      location="imgui_impl_sdl3:42",
+      location="imgui_impl_sdl3:39",
      ov_cimguiname="ImGui_ImplSDL3_NewFrame",
      ret="void",
      signature="()",
@@ -950,7 +998,7 @@ local t={
      cimguiname="ImGui_ImplSDL3_ProcessEvent",
      defaults={},
      funcname="ImGui_ImplSDL3_ProcessEvent",
-      location="imgui_impl_sdl3:43",
+      location="imgui_impl_sdl3:40",
      ov_cimguiname="ImGui_ImplSDL3_ProcessEvent",
      ret="bool",
      signature="(const SDL_Event*)",
@@ -976,7 +1024,7 @@ local t={
        manual_gamepads_array="nullptr",
        manual_gamepads_count="-1"},
      funcname="ImGui_ImplSDL3_SetGamepadMode",
-      location="imgui_impl_sdl3:48",
+      location="imgui_impl_sdl3:45",
      ov_cimguiname="ImGui_ImplSDL3_SetGamepadMode",
      ret="void",
      signature="(ImGui_ImplSDL3_GamepadMode,SDL_Gamepad**,int)",
@@ -991,7 +1039,7 @@ local t={
      cimguiname="ImGui_ImplSDL3_Shutdown",
      defaults={},
      funcname="ImGui_ImplSDL3_Shutdown",
-      location="imgui_impl_sdl3:41",
+      location="imgui_impl_sdl3:38",
      ov_cimguiname="ImGui_ImplSDL3_Shutdown",
      ret="void",
      signature="()",
@@ -999,7 +1047,7 @@ local t={
    ["()"]=nil},
  ImGui_ImplVulkanH_CreateOrResizeWindow={
    [1]={
-      args="(VkInstance instance,VkPhysicalDevice physical_device,VkDevice device,ImGui_ImplVulkanH_Window* wd,uint32_t queue_family,const VkAllocationCallbacks* allocator,int w,int h,uint32_t min_image_count)",
+      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",
@@ -1011,7 +1059,7 @@ local t={
          name="device",
          type="VkDevice"},
        [4]={
-          name="wd",
+          name="wnd",
          type="ImGui_ImplVulkanH_Window*"},
        [5]={
          name="queue_family",
@@ -1028,12 +1076,12 @@ local t={
        [9]={
          name="min_image_count",
          type="uint32_t"}},
-      argsoriginal="(VkInstance instance,VkPhysicalDevice physical_device,VkDevice device,ImGui_ImplVulkanH_Window* wd,uint32_t queue_family,const VkAllocationCallbacks* allocator,int w,int h,uint32_t min_image_count)",
-      call_args="(instance,physical_device,device,wd,queue_family,allocator,w,h,min_image_count)",
+      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",
+      location="imgui_impl_vulkan:178",
      ov_cimguiname="ImGui_ImplVulkanH_CreateOrResizeWindow",
      ret="void",
      signature="(VkInstance,VkPhysicalDevice,VkDevice,ImGui_ImplVulkanH_Window*,uint32_t,const VkAllocationCallbacks*,int,int,uint32_t)",
@@ -1041,7 +1089,7 @@ local t={
    ["(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* wd,const VkAllocationCallbacks* allocator)",
+      args="(VkInstance instance,VkDevice device,ImGui_ImplVulkanH_Window* wnd,const VkAllocationCallbacks* allocator)",
      argsT={
        [1]={
          name="instance",
@@ -1050,17 +1098,17 @@ local t={
          name="device",
          type="VkDevice"},
        [3]={
-          name="wd",
+          name="wnd",
          type="ImGui_ImplVulkanH_Window*"},
        [4]={
          name="allocator",
          type="const VkAllocationCallbacks*"}},
-      argsoriginal="(VkInstance instance,VkDevice device,ImGui_ImplVulkanH_Window* wd,const VkAllocationCallbacks* allocator)",
-      call_args="(instance,device,wd,allocator)",
+      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",
+      location="imgui_impl_vulkan:179",
      ov_cimguiname="ImGui_ImplVulkanH_DestroyWindow",
      ret="void",
      signature="(VkInstance,VkDevice,ImGui_ImplVulkanH_Window*,const VkAllocationCallbacks*)",
@@ -1078,7 +1126,7 @@ local t={
      cimguiname="ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
      defaults={},
      funcname="ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
-      location="imgui_impl_vulkan:172",
+      location="imgui_impl_vulkan:184",
      ov_cimguiname="ImGui_ImplVulkanH_GetMinImageCountFromPresentMode",
      ret="int",
      signature="(VkPresentModeKHR)",
@@ -1096,7 +1144,7 @@ local t={
      cimguiname="ImGui_ImplVulkanH_SelectPhysicalDevice",
      defaults={},
      funcname="ImGui_ImplVulkanH_SelectPhysicalDevice",
-      location="imgui_impl_vulkan:170",
+      location="imgui_impl_vulkan:182",
      ov_cimguiname="ImGui_ImplVulkanH_SelectPhysicalDevice",
      ret="VkPhysicalDevice",
      signature="(VkInstance)",
@@ -1123,7 +1171,7 @@ local t={
      cimguiname="ImGui_ImplVulkanH_SelectPresentMode",
      defaults={},
      funcname="ImGui_ImplVulkanH_SelectPresentMode",
-      location="imgui_impl_vulkan:169",
+      location="imgui_impl_vulkan:181",
      ov_cimguiname="ImGui_ImplVulkanH_SelectPresentMode",
      ret="VkPresentModeKHR",
      signature="(VkPhysicalDevice,VkSurfaceKHR,const VkPresentModeKHR*,int)",
@@ -1141,7 +1189,7 @@ local t={
      cimguiname="ImGui_ImplVulkanH_SelectQueueFamilyIndex",
      defaults={},
      funcname="ImGui_ImplVulkanH_SelectQueueFamilyIndex",
-      location="imgui_impl_vulkan:171",
+      location="imgui_impl_vulkan:183",
      ov_cimguiname="ImGui_ImplVulkanH_SelectQueueFamilyIndex",
      ret="uint32_t",
      signature="(VkPhysicalDevice)",
@@ -1171,7 +1219,7 @@ local t={
      cimguiname="ImGui_ImplVulkanH_SelectSurfaceFormat",
      defaults={},
      funcname="ImGui_ImplVulkanH_SelectSurfaceFormat",
-      location="imgui_impl_vulkan:168",
+      location="imgui_impl_vulkan:180",
      ov_cimguiname="ImGui_ImplVulkanH_SelectSurfaceFormat",
      ret="VkSurfaceFormatKHR",
      signature="(VkPhysicalDevice,VkSurfaceKHR,const VkFormat*,int,VkColorSpaceKHR)",
@@ -1187,7 +1235,7 @@ local t={
      constructor=true,
      defaults={},
      funcname="ImGui_ImplVulkanH_Window",
-      location="imgui_impl_vulkan:214",
+      location="imgui_impl_vulkan:227",
      ov_cimguiname="ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window",
      signature="()",
      stname="ImGui_ImplVulkanH_Window"},
@@ -1203,7 +1251,7 @@ local t={
      cimguiname="ImGui_ImplVulkanH_Window_destroy",
      defaults={},
      destructor=true,
-      location="imgui_impl_vulkan:214",
+      location="imgui_impl_vulkan:227",
      ov_cimguiname="ImGui_ImplVulkanH_Window_destroy",
      ret="void",
      signature="(ImGui_ImplVulkanH_Window*)",
@@ -1227,42 +1275,30 @@ local t={
      cimguiname="ImGui_ImplVulkan_AddTexture",
      defaults={},
      funcname="ImGui_ImplVulkan_AddTexture",
-      location="imgui_impl_vulkan:123",
+      location="imgui_impl_vulkan:135",
      ov_cimguiname="ImGui_ImplVulkan_AddTexture",
      ret="VkDescriptorSet",
      signature="(VkSampler,VkImageView,VkImageLayout)",
      stname=""},
    ["(VkSampler,VkImageView,VkImageLayout)"]=nil},
-  ImGui_ImplVulkan_CreateFontsTexture={
+  ImGui_ImplVulkan_CreateMainPipeline={
    [1]={
-      args="()",
-      argsT={},
-      argsoriginal="()",
-      call_args="()",
-      cimguiname="ImGui_ImplVulkan_CreateFontsTexture",
+      args="(const ImGui_ImplVulkan_MainPipelineCreateInfo info)",
+      argsT={
+        [1]={
+          name="info",
+          type="const ImGui_ImplVulkan_MainPipelineCreateInfo"}},
+      argsoriginal="(const ImGui_ImplVulkan_MainPipelineCreateInfo& info)",
+      call_args="(info)",
+      cimguiname="ImGui_ImplVulkan_CreateMainPipeline",
      defaults={},
-      funcname="ImGui_ImplVulkan_CreateFontsTexture",
-      location="imgui_impl_vulkan:116",
-      ov_cimguiname="ImGui_ImplVulkan_CreateFontsTexture",
-      ret="bool",
-      signature="()",
-      stname=""},
-    ["()"]=nil},
-  ImGui_ImplVulkan_DestroyFontsTexture={
-    [1]={
-      args="()",
-      argsT={},
-      argsoriginal="()",
-      call_args="()",
-      cimguiname="ImGui_ImplVulkan_DestroyFontsTexture",
-      defaults={},
-      funcname="ImGui_ImplVulkan_DestroyFontsTexture",
-      location="imgui_impl_vulkan:117",
-      ov_cimguiname="ImGui_ImplVulkan_DestroyFontsTexture",
+      funcname="ImGui_ImplVulkan_CreateMainPipeline",
+      location="imgui_impl_vulkan:127",
+      ov_cimguiname="ImGui_ImplVulkan_CreateMainPipeline",
      ret="void",
-      signature="()",
+      signature="(const ImGui_ImplVulkan_MainPipelineCreateInfo)",
      stname=""},
-    ["()"]=nil},
+    ["(const ImGui_ImplVulkan_MainPipelineCreateInfo)"]=nil},
  ImGui_ImplVulkan_Init={
    [1]={
      args="(ImGui_ImplVulkan_InitInfo* info)",
@@ -1275,7 +1311,7 @@ local t={
      cimguiname="ImGui_ImplVulkan_Init",
      defaults={},
      funcname="ImGui_ImplVulkan_Init",
-      location="imgui_impl_vulkan:112",
+      location="imgui_impl_vulkan:109",
      ov_cimguiname="ImGui_ImplVulkan_Init",
      ret="bool",
      signature="(ImGui_ImplVulkan_InitInfo*)",
@@ -1300,7 +1336,7 @@ local t={
      defaults={
        user_data="nullptr"},
      funcname="ImGui_ImplVulkan_LoadFunctions",
-      location="imgui_impl_vulkan:128",
+      location="imgui_impl_vulkan:140",
      ov_cimguiname="ImGui_ImplVulkan_LoadFunctions",
      ret="bool",
      signature="(uint32_t,PFN_vkVoidFunction(*loader_func)(const char* function_name,void*,void*)",
@@ -1315,7 +1351,7 @@ local t={
      cimguiname="ImGui_ImplVulkan_NewFrame",
      defaults={},
      funcname="ImGui_ImplVulkan_NewFrame",
-      location="imgui_impl_vulkan:114",
+      location="imgui_impl_vulkan:111",
      ov_cimguiname="ImGui_ImplVulkan_NewFrame",
      ret="void",
      signature="()",
@@ -1333,7 +1369,7 @@ local t={
      cimguiname="ImGui_ImplVulkan_RemoveTexture",
      defaults={},
      funcname="ImGui_ImplVulkan_RemoveTexture",
-      location="imgui_impl_vulkan:124",
+      location="imgui_impl_vulkan:136",
      ov_cimguiname="ImGui_ImplVulkan_RemoveTexture",
      ret="void",
      signature="(VkDescriptorSet)",
@@ -1358,7 +1394,7 @@ local t={
      defaults={
        pipeline="0ULL"},
      funcname="ImGui_ImplVulkan_RenderDrawData",
-      location="imgui_impl_vulkan:115",
+      location="imgui_impl_vulkan:112",
      ov_cimguiname="ImGui_ImplVulkan_RenderDrawData",
      ret="void",
      signature="(ImDrawData*,VkCommandBuffer,VkPipeline)",
@@ -1376,7 +1412,7 @@ local t={
      cimguiname="ImGui_ImplVulkan_SetMinImageCount",
      defaults={},
      funcname="ImGui_ImplVulkan_SetMinImageCount",
-      location="imgui_impl_vulkan:118",
+      location="imgui_impl_vulkan:113",
      ov_cimguiname="ImGui_ImplVulkan_SetMinImageCount",
      ret="void",
      signature="(uint32_t)",
@@ -1391,15 +1427,35 @@ local t={
      cimguiname="ImGui_ImplVulkan_Shutdown",
      defaults={},
      funcname="ImGui_ImplVulkan_Shutdown",
-      location="imgui_impl_vulkan:113",
+      location="imgui_impl_vulkan:110",
      ov_cimguiname="ImGui_ImplVulkan_Shutdown",
      ret="void",
      signature="()",
      stname=""},
-    ["()"]=nil}}
+    ["()"]=nil},
+  ImGui_ImplVulkan_UpdateTexture={
+    [1]={
+      args="(ImTextureData* tex)",
+      argsT={
+        [1]={
+          name="tex",
+          type="ImTextureData*"}},
+      argsoriginal="(ImTextureData* tex)",
+      call_args="(tex)",
+      cimguiname="ImGui_ImplVulkan_UpdateTexture",
+      defaults={},
+      funcname="ImGui_ImplVulkan_UpdateTexture",
+      location="imgui_impl_vulkan:130",
+      ov_cimguiname="ImGui_ImplVulkan_UpdateTexture",
+      ret="void",
+      signature="(ImTextureData*)",
+      stname=""},
+    ["(ImTextureData*)"]=nil}}
 t.ImGui_ImplGlfw_CharCallback["(GLFWwindow*,unsigned int)"]=t.ImGui_ImplGlfw_CharCallback[1]
 t.ImGui_ImplGlfw_CursorEnterCallback["(GLFWwindow*,int)"]=t.ImGui_ImplGlfw_CursorEnterCallback[1]
 t.ImGui_ImplGlfw_CursorPosCallback["(GLFWwindow*,double,double)"]=t.ImGui_ImplGlfw_CursorPosCallback[1]
+t.ImGui_ImplGlfw_GetContentScaleForMonitor["(GLFWmonitor*)"]=t.ImGui_ImplGlfw_GetContentScaleForMonitor[1]
+t.ImGui_ImplGlfw_GetContentScaleForWindow["(GLFWwindow*)"]=t.ImGui_ImplGlfw_GetContentScaleForWindow[1]
 t.ImGui_ImplGlfw_InitForOpenGL["(GLFWwindow*,bool)"]=t.ImGui_ImplGlfw_InitForOpenGL[1]
 t.ImGui_ImplGlfw_InitForOther["(GLFWwindow*,bool)"]=t.ImGui_ImplGlfw_InitForOther[1]
 t.ImGui_ImplGlfw_InitForVulkan["(GLFWwindow*,bool)"]=t.ImGui_ImplGlfw_InitForVulkan[1]
@@ -1415,21 +1471,21 @@ t.ImGui_ImplGlfw_Shutdown["()"]=t.ImGui_ImplGlfw_Shutdown[1]
 t.ImGui_ImplGlfw_Sleep["(int)"]=t.ImGui_ImplGlfw_Sleep[1]
 t.ImGui_ImplGlfw_WindowFocusCallback["(GLFWwindow*,int)"]=t.ImGui_ImplGlfw_WindowFocusCallback[1]
 t.ImGui_ImplOpenGL2_CreateDeviceObjects["()"]=t.ImGui_ImplOpenGL2_CreateDeviceObjects[1]
-t.ImGui_ImplOpenGL2_CreateFontsTexture["()"]=t.ImGui_ImplOpenGL2_CreateFontsTexture[1]
 t.ImGui_ImplOpenGL2_DestroyDeviceObjects["()"]=t.ImGui_ImplOpenGL2_DestroyDeviceObjects[1]
-t.ImGui_ImplOpenGL2_DestroyFontsTexture["()"]=t.ImGui_ImplOpenGL2_DestroyFontsTexture[1]
 t.ImGui_ImplOpenGL2_Init["()"]=t.ImGui_ImplOpenGL2_Init[1]
 t.ImGui_ImplOpenGL2_NewFrame["()"]=t.ImGui_ImplOpenGL2_NewFrame[1]
 t.ImGui_ImplOpenGL2_RenderDrawData["(ImDrawData*)"]=t.ImGui_ImplOpenGL2_RenderDrawData[1]
 t.ImGui_ImplOpenGL2_Shutdown["()"]=t.ImGui_ImplOpenGL2_Shutdown[1]
+t.ImGui_ImplOpenGL2_UpdateTexture["(ImTextureData*)"]=t.ImGui_ImplOpenGL2_UpdateTexture[1]
 t.ImGui_ImplOpenGL3_CreateDeviceObjects["()"]=t.ImGui_ImplOpenGL3_CreateDeviceObjects[1]
-t.ImGui_ImplOpenGL3_CreateFontsTexture["()"]=t.ImGui_ImplOpenGL3_CreateFontsTexture[1]
 t.ImGui_ImplOpenGL3_DestroyDeviceObjects["()"]=t.ImGui_ImplOpenGL3_DestroyDeviceObjects[1]
-t.ImGui_ImplOpenGL3_DestroyFontsTexture["()"]=t.ImGui_ImplOpenGL3_DestroyFontsTexture[1]
 t.ImGui_ImplOpenGL3_Init["(const char*)"]=t.ImGui_ImplOpenGL3_Init[1]
 t.ImGui_ImplOpenGL3_NewFrame["()"]=t.ImGui_ImplOpenGL3_NewFrame[1]
 t.ImGui_ImplOpenGL3_RenderDrawData["(ImDrawData*)"]=t.ImGui_ImplOpenGL3_RenderDrawData[1]
 t.ImGui_ImplOpenGL3_Shutdown["()"]=t.ImGui_ImplOpenGL3_Shutdown[1]
+t.ImGui_ImplOpenGL3_UpdateTexture["(ImTextureData*)"]=t.ImGui_ImplOpenGL3_UpdateTexture[1]
+t.ImGui_ImplSDL2_GetContentScaleForDisplay["(int)"]=t.ImGui_ImplSDL2_GetContentScaleForDisplay[1]
+t.ImGui_ImplSDL2_GetContentScaleForWindow["(SDL_Window*)"]=t.ImGui_ImplSDL2_GetContentScaleForWindow[1]
 t.ImGui_ImplSDL2_InitForD3D["(SDL_Window*)"]=t.ImGui_ImplSDL2_InitForD3D[1]
 t.ImGui_ImplSDL2_InitForMetal["(SDL_Window*)"]=t.ImGui_ImplSDL2_InitForMetal[1]
 t.ImGui_ImplSDL2_InitForOpenGL["(SDL_Window*,void*)"]=t.ImGui_ImplSDL2_InitForOpenGL[1]
@@ -1461,8 +1517,7 @@ t.ImGui_ImplVulkanH_SelectSurfaceFormat["(VkPhysicalDevice,VkSurfaceKHR,const Vk
 t.ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window["()"]=t.ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window[1]
 t.ImGui_ImplVulkanH_Window_destroy["(ImGui_ImplVulkanH_Window*)"]=t.ImGui_ImplVulkanH_Window_destroy[1]
 t.ImGui_ImplVulkan_AddTexture["(VkSampler,VkImageView,VkImageLayout)"]=t.ImGui_ImplVulkan_AddTexture[1]
-t.ImGui_ImplVulkan_CreateFontsTexture["()"]=t.ImGui_ImplVulkan_CreateFontsTexture[1]
-t.ImGui_ImplVulkan_DestroyFontsTexture["()"]=t.ImGui_ImplVulkan_DestroyFontsTexture[1]
+t.ImGui_ImplVulkan_CreateMainPipeline["(const ImGui_ImplVulkan_MainPipelineCreateInfo)"]=t.ImGui_ImplVulkan_CreateMainPipeline[1]
 t.ImGui_ImplVulkan_Init["(ImGui_ImplVulkan_InitInfo*)"]=t.ImGui_ImplVulkan_Init[1]
 t.ImGui_ImplVulkan_LoadFunctions["(uint32_t,PFN_vkVoidFunction(*loader_func)(const char* function_name,void*,void*)"]=t.ImGui_ImplVulkan_LoadFunctions[1]
 t.ImGui_ImplVulkan_NewFrame["()"]=t.ImGui_ImplVulkan_NewFrame[1]
@@ -1470,4 +1525,5 @@ t.ImGui_ImplVulkan_RemoveTexture["(VkDescriptorSet)"]=t.ImGui_ImplVulkan_RemoveT
 t.ImGui_ImplVulkan_RenderDrawData["(ImDrawData*,VkCommandBuffer,VkPipeline)"]=t.ImGui_ImplVulkan_RenderDrawData[1]
 t.ImGui_ImplVulkan_SetMinImageCount["(uint32_t)"]=t.ImGui_ImplVulkan_SetMinImageCount[1]
 t.ImGui_ImplVulkan_Shutdown["()"]=t.ImGui_ImplVulkan_Shutdown[1]
+t.ImGui_ImplVulkan_UpdateTexture["(ImTextureData*)"]=t.ImGui_ImplVulkan_UpdateTexture[1]
 return t
--- 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)
@@ -108,13 +114,17 @@ igCombo	3
 1	bool	igCombo_Str_arr (const char*,int*,const char* const[],int,int)
 2	bool	igCombo_Str (const char*,int*,const char*,int)
 3	bool	igCombo_FnStrPtr (const char*,int*,const char*(*)(void*,int),void*,int,int)
+igGetBackgroundDrawList	2
+1	ImDrawList*	igGetBackgroundDrawList_Nil ()
+2	ImDrawList*	igGetBackgroundDrawList_ViewportPtr (ImGuiViewport*)
 igGetColorU32	3
 1	ImU32	igGetColorU32_Col (ImGuiCol,float)
 2	ImU32	igGetColorU32_Vec4 (const ImVec4)
 3	ImU32	igGetColorU32_U32 (ImU32,float)
-igGetForegroundDrawList	2
-1	ImDrawList*	igGetForegroundDrawList_ViewportPtr (ImGuiViewport*)
+igGetForegroundDrawList	3
+1	ImDrawList*	igGetForegroundDrawList_Nil ()
 2	ImDrawList*	igGetForegroundDrawList_WindowPtr (ImGuiWindow*)
+3	ImDrawList*	igGetForegroundDrawList_ViewportPtr (ImGuiViewport*)
 igGetID	4
 1	ImGuiID	igGetID_Str (const char*)
 2	ImGuiID	igGetID_StrStr (const char*,const char*)
@@ -299,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*)
-209 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
@@ -15,16 +15,24 @@
  "ImDrawListFlags": "int",
  "ImDrawListSharedData": "struct ImDrawListSharedData",
  "ImDrawListSplitter": "struct ImDrawListSplitter",
+  "ImDrawTextFlags": "int",
  "ImDrawVert": "struct ImDrawVert",
  "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",
@@ -40,7 +48,6 @@
  "ImGuiContext": "struct ImGuiContext",
  "ImGuiContextHook": "struct ImGuiContextHook",
  "ImGuiContextHookCallback": "void (*)(ImGuiContext* ctx, ImGuiContextHook* hook);",
-  "ImGuiDataAuthority": "int",
  "ImGuiDataType": "int",
  "ImGuiDataTypeInfo": "struct ImGuiDataTypeInfo",
  "ImGuiDataTypeStorage": "struct ImGuiDataTypeStorage",
@@ -48,17 +55,13 @@
  "ImGuiDebugAllocEntry": "struct ImGuiDebugAllocEntry",
  "ImGuiDebugAllocInfo": "struct ImGuiDebugAllocInfo",
  "ImGuiDebugLogFlags": "int",
-  "ImGuiDockContext": "struct ImGuiDockContext",
-  "ImGuiDockNode": "struct ImGuiDockNode",
-  "ImGuiDockNodeFlags": "int",
-  "ImGuiDockNodeSettings": "struct ImGuiDockNodeSettings",
-  "ImGuiDockRequest": "struct ImGuiDockRequest",
  "ImGuiDragDropFlags": "int",
  "ImGuiErrorCallback": "void (*)(ImGuiContext* ctx, void* user_data, const char* msg);",
  "ImGuiErrorRecoveryState": "struct ImGuiErrorRecoveryState",
  "ImGuiFocusRequestFlags": "int",
  "ImGuiFocusScopeData": "struct ImGuiFocusScopeData",
  "ImGuiFocusedFlags": "int",
+  "ImGuiFreeTypeLoaderFlags": "unsigned int",
  "ImGuiGroupData": "struct ImGuiGroupData",
  "ImGuiHoveredFlags": "int",
  "ImGuiID": "unsigned int",
@@ -69,7 +72,6 @@
  "ImGuiInputEventKey": "struct ImGuiInputEventKey",
  "ImGuiInputEventMouseButton": "struct ImGuiInputEventMouseButton",
  "ImGuiInputEventMousePos": "struct ImGuiInputEventMousePos",
-  "ImGuiInputEventMouseViewport": "struct ImGuiInputEventMouseViewport",
  "ImGuiInputEventMouseWheel": "struct ImGuiInputEventMouseWheel",
  "ImGuiInputEventText": "struct ImGuiInputEventText",
  "ImGuiInputFlags": "int",
@@ -91,6 +93,7 @@
  "ImGuiLayoutType": "int",
  "ImGuiListClipper": "struct ImGuiListClipper",
  "ImGuiListClipperData": "struct ImGuiListClipperData",
+  "ImGuiListClipperFlags": "int",
  "ImGuiListClipperRange": "struct ImGuiListClipperRange",
  "ImGuiLocEntry": "struct ImGuiLocEntry",
  "ImGuiLogFlags": "int",
@@ -118,7 +121,6 @@
  "ImGuiPayload": "struct ImGuiPayload",
  "ImGuiPlatformIO": "struct ImGuiPlatformIO",
  "ImGuiPlatformImeData": "struct ImGuiPlatformImeData",
-  "ImGuiPlatformMonitor": "struct ImGuiPlatformMonitor",
  "ImGuiPopupData": "struct ImGuiPopupData",
  "ImGuiPopupFlags": "int",
  "ImGuiPtrOrIndex": "struct ImGuiPtrOrIndex",
@@ -177,8 +179,6 @@
  "ImGuiViewportFlags": "int",
  "ImGuiViewportP": "struct ImGuiViewportP",
  "ImGuiWindow": "struct ImGuiWindow",
-  "ImGuiWindowClass": "struct ImGuiWindowClass",
-  "ImGuiWindowDockStyle": "struct ImGuiWindowDockStyle",
  "ImGuiWindowFlags": "int",
  "ImGuiWindowRefreshFlags": "int",
  "ImGuiWindowSettings": "struct ImGuiWindowSettings",
@@ -191,17 +191,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
@@ -15,16 +15,24 @@ local t={
  ImDrawListFlags="int",
  ImDrawListSharedData="struct ImDrawListSharedData",
  ImDrawListSplitter="struct ImDrawListSplitter",
+  ImDrawTextFlags="int",
  ImDrawVert="struct ImDrawVert",
  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",
@@ -40,7 +48,6 @@ local t={
  ImGuiContext="struct ImGuiContext",
  ImGuiContextHook="struct ImGuiContextHook",
  ImGuiContextHookCallback="void (*)(ImGuiContext* ctx, ImGuiContextHook* hook);",
-  ImGuiDataAuthority="int",
  ImGuiDataType="int",
  ImGuiDataTypeInfo="struct ImGuiDataTypeInfo",
  ImGuiDataTypeStorage="struct ImGuiDataTypeStorage",
@@ -48,17 +55,13 @@ local t={
  ImGuiDebugAllocEntry="struct ImGuiDebugAllocEntry",
  ImGuiDebugAllocInfo="struct ImGuiDebugAllocInfo",
  ImGuiDebugLogFlags="int",
-  ImGuiDockContext="struct ImGuiDockContext",
-  ImGuiDockNode="struct ImGuiDockNode",
-  ImGuiDockNodeFlags="int",
-  ImGuiDockNodeSettings="struct ImGuiDockNodeSettings",
-  ImGuiDockRequest="struct ImGuiDockRequest",
  ImGuiDragDropFlags="int",
  ImGuiErrorCallback="void (*)(ImGuiContext* ctx, void* user_data, const char* msg);",
  ImGuiErrorRecoveryState="struct ImGuiErrorRecoveryState",
  ImGuiFocusRequestFlags="int",
  ImGuiFocusScopeData="struct ImGuiFocusScopeData",
  ImGuiFocusedFlags="int",
+  ImGuiFreeTypeLoaderFlags="unsigned int",
  ImGuiGroupData="struct ImGuiGroupData",
  ImGuiHoveredFlags="int",
  ImGuiID="unsigned int",
@@ -69,7 +72,6 @@ local t={
  ImGuiInputEventKey="struct ImGuiInputEventKey",
  ImGuiInputEventMouseButton="struct ImGuiInputEventMouseButton",
  ImGuiInputEventMousePos="struct ImGuiInputEventMousePos",
-  ImGuiInputEventMouseViewport="struct ImGuiInputEventMouseViewport",
  ImGuiInputEventMouseWheel="struct ImGuiInputEventMouseWheel",
  ImGuiInputEventText="struct ImGuiInputEventText",
  ImGuiInputFlags="int",
@@ -91,6 +93,7 @@ local t={
  ImGuiLayoutType="int",
  ImGuiListClipper="struct ImGuiListClipper",
  ImGuiListClipperData="struct ImGuiListClipperData",
+  ImGuiListClipperFlags="int",
  ImGuiListClipperRange="struct ImGuiListClipperRange",
  ImGuiLocEntry="struct ImGuiLocEntry",
  ImGuiLogFlags="int",
@@ -118,7 +121,6 @@ local t={
  ImGuiPayload="struct ImGuiPayload",
  ImGuiPlatformIO="struct ImGuiPlatformIO",
  ImGuiPlatformImeData="struct ImGuiPlatformImeData",
-  ImGuiPlatformMonitor="struct ImGuiPlatformMonitor",
  ImGuiPopupData="struct ImGuiPopupData",
  ImGuiPopupFlags="int",
  ImGuiPtrOrIndex="struct ImGuiPtrOrIndex",
@@ -177,8 +179,6 @@ local t={
  ImGuiViewportFlags="int",
  ImGuiViewportP="struct ImGuiViewportP",
  ImGuiWindow="struct ImGuiWindow",
-  ImGuiWindowClass="struct ImGuiWindowClass",
-  ImGuiWindowDockStyle="struct ImGuiWindowDockStyle",
  ImGuiWindowFlags="int",
  ImGuiWindowRefreshFlags="int",
  ImGuiWindowSettings="struct ImGuiWindowSettings",
@@ -191,17 +191,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/2
+++ b/2
--- a/test/main.c
+++ b/test/main.c
@@ -22,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	3b6ca737bd	Merge branch 'docking_inter'	2025-09-22 12:40:43 +02:00
sonoro1234	207fca2d36	pull imgui 1.92.3 docking and generate	2025-09-22 12:26:57 +02:00
sonoro1234	6d0a376516	pull imgui 1.92.1 and generate	2025-07-14 09:41:32 +02:00
sonoro1234	d61baefa0c	update README.md	2025-07-14 09:24:51 +02:00
sonoro1234	7dc88bd031	pull imgui docking 1.92.1 and generate	2025-07-14 09:21:39 +02:00
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	0b0a04de25	Merge branch 'docking_inter'	2025-03-22 10:23:01 +01:00
sonoro1234	e9a4157067	Merge remote-tracking branch 'remotes/origin/docking_inter'	2025-03-15 08:23:45 +01:00
sonoro1234	d6b4ecda71	Merge branch 'docking_inter'	2025-02-04 16:42:14 +01:00
sonoro1234	1427639147	Merge branch 'docking_inter'	2025-01-21 16:06:26 +01:00
sonoro1234	e3b48a15f0	Merge branch 'docking_inter'	2024-12-12 13:20:21 +01:00
sonoro1234	8ec6558ecc	Merge branch 'docking_inter'	2024-11-18 18:26:51 +01:00
sonoro1234	43429513a8	Merge branch 'docking_inter'	2024-10-19 12:05:11 +02:00
sonoro1234	79e40b6657	Merge branch 'docking_inter'	2024-10-05 11:06:45 +02:00
sonoro1234	833e9366de	Merge branch 'docking_inter'	2024-10-01 13:05:38 +02:00
sonoro1234	74902e7392	Merge branch 'docking_inter'	2024-09-08 11:57:14 +02:00
sonoro1234	143c37b7ac	Merge branch 'docking_inter'	2024-07-31 11:27:49 +02:00
sonoro1234	7c79f59fa2	Merge branch 'docking_inter'	2024-07-03 11:14:11 +02:00
sonoro1234	35fdbf393f	Merge branch 'docking_inter'	2024-06-07 13:26:08 +02:00
sonoro1234	bf02a1552e	Merge branch 'docking_inter'	2024-05-28 10:18:05 +02:00
sonoro1234	481cd32543	Merge branch 'docking_inter'	2024-05-10 17:11:32 +02:00
sonoro1234	d222bc5a4e	Merge branch 'docking_inter'	2024-04-19 10:54:29 +02:00
sonoro1234	f0fb387921	Merge branch 'docking_inter'	2024-02-24 13:15:42 +01:00
sonoro1234	c7133969db	Merge branch 'docking_inter'	2024-02-16 11:36:05 +01:00
sonoro1234	0821a31dfe	Merge branch 'docking_inter'	2024-02-14 11:17:50 +01:00
sonoro1234	9009dd72e9	Merge branch 'docking_inter' 1.90.1	2024-01-12 11:27:04 +01:00
sonoro1234	b6e02f4131	Merge branch 'docking_inter'	2023-11-17 11:08:06 +01:00
sonoro1234	b28023c3f6	Merge branch 'docking_inter'	2023-09-08 18:09:15 +02:00
sonoro1234	1bb9cd7347	Merge branch 'docking_inter'	2023-04-18 10:43:06 +02:00
sonoro1234	d24246adfd	Merge branch 'docking_inter'	2023-02-15 10:18:15 +01:00
sonoro1234	6dba58d90f	merge from docking_inter	2023-01-07 11:34:35 +01:00
				`@@ -0,0 +1,2 @@`

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