Merge branch 'docking_inter' conv3

cpp2ffi: take care of CIMGUI_VARGS0
generator.lua: ImTextureID_Invalid define for cl compiler
2025-12-01 06:01:38 +00:00 · 2025-11-18 16:45:22 +01:00 · 2025-11-14 09:42:56 +01:00 · 2025-11-13 19:14:43 +01:00 · 2025-11-11 11:06:46 +01:00 · 2025-11-10 14:08:08 +01:00
39 changed files with 21363 additions and 16752 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,12 +11,16 @@ 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.4 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.
 * Current overloaded function names can be found in (https://github.com/cimgui/cimgui/blob/master/generator/output/overloads.txt)

+#changes
+
+* 10/11/2025: Functions returning and taking as argument no POD structs is now doing a conversion internally to allow ARM64 compilation.
+
 # compilation

 * clone 
@@ -24,7 +28,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.
@@ -60,7 +64,8 @@ Notes:
  * retref : is set if original return type is a reference. (will be a pointer in cimgui)
  * argsT : an array of collections (each one with type: argument type and name: the argument name, when the argument is a function pointer also ret: return type and signature: the function signature)
  * args : a string of argsT concatenated and separated by commas
-  * call_args : a string with the argument names separated by commas for calling imgui function
+  * call_args_old : a string with the argument names separated by commas for calling imgui function
+  * call_args : call_args_old with conversion added.
  * defaults : a collection in which key is argument name and value is the default value.
  * manual : will be true if this function is hand-written (not generated)
  * skipped : will be true if this function is not generated (and not hand-written)
@@ -70,7 +75,7 @@ Notes:
  * realdestructor : is set if the function is a destructor for a class
  * templated : is set if the function belongs to a templated class (ImVector)
  * templatedgen: is set if the function belongs to a struct generated from template (ImVector_ImWchar)
-  * nonUDT : if present the original function was returning a user defined type so that signature has been changed to accept a pointer to the UDT as first argument.
+  * nonUDT : if present the original function was returning a user defined type.
  * location : name of the header file and linenumber this function comes from. (imgui:000, internal:123, imgui_impl_xxx:123)
  * is_static_function : is setted when it is an struct static function.
 ### structs_and_enums description
@@ -91,7 +96,6 @@ Notes:
 * use whatever method is in ImGui c++ namespace in the original [imgui.h](https://github.com/ocornut/imgui/blob/master/imgui.h) by prepending `ig`
 * methods have the same parameter list and return values (where possible)
 * functions that belong to a struct have an extra first argument with a pointer to the struct.
-* where a function returns UDT (user defined type) by value some compilers complain so the function is generated accepting a pointer to the UDT type as the first argument (or second if belongs to a struct).
 * constructors return pointer to struct and has been named Struct_name_Struct_name
 # usage with backends

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

+#define igGetIO igGetIO_Nil
+
 GLFWwindow *window;

 // Data
--- a/backend_test/example_glfw_opengl3/CMakeLists.txt
+++ b/backend_test/example_glfw_opengl3/CMakeLists.txt
@@ -45,10 +45,13 @@ add_compile_definitions("IMGUI_IMPL_OPENGL_LOADER_GL3W")
 option(IMGUI_FREETYPE "add Freetype2" OFF)

 if(IMGUI_FREETYPE)
+	message("building with freetype")
 	FIND_PACKAGE(freetype REQUIRED PATHS ${FREETYPE_PATH})
 	list(APPEND IMGUI_LIBRARIES freetype)
 	list(APPEND IMGUI_SOURCES ../../imgui/misc/freetype/imgui_freetype.cpp)
-	add_definitions("-DCIMGUI_FREETYPE=1")
+	#add_definitions("-DCIMGUI_FREETYPE=1")
+	add_definitions("-DIMGUI_ENABLE_FREETYPE=1")
+	add_definitions("-DIMGUI_ENABLE_STB_TRUETYPE=1")
 endif(IMGUI_FREETYPE)

 # opengl3
--- a/backend_test/example_glfw_opengl3/main.c
+++ b/backend_test/example_glfw_opengl3/main.c
@@ -17,6 +17,8 @@
 #define igButton igButton_Str
 #endif

+#define igGetIO igGetIO_Nil
+
 GLFWwindow *window;

 int main(int argc, char *argv[])
@@ -41,8 +43,9 @@ int main(int argc, char *argv[])

  // just an extra window hint for resize
  glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
+  float main_scale = ImGui_ImplGlfw_GetContentScaleForMonitor(glfwGetPrimaryMonitor()); // Valid on GLFW 3.3+ only
+  window = glfwCreateWindow((int)(1280 * main_scale), (int)(800 * main_scale), "Dear ImGui GLFW+OpenGL3 example", NULL, NULL);

-  window = glfwCreateWindow(1024, 768, "Hello World!", NULL, NULL);
  if (!window) 
  {
    printf("Failed to create window! Terminating!\n");
@@ -70,6 +73,15 @@ int main(int argc, char *argv[])
  ioptr->ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;     // Enable Multi-Viewport / Platform Windows
 #endif

+
+    // Setup scaling
+    ImGuiStyle* style = igGetStyle();
+    ImGuiStyle_ScaleAllSizes(style, main_scale);        // Bake a fixed style scale. (until we have a solution for dynamic style scaling, changing this requires resetting Style + calling this again)
+    style->FontScaleDpi = main_scale;        // Set initial font scale. (using io.ConfigDpiScaleFonts=true makes this unnecessary. We leave both here for documentation purpose)
+#if GLFW_VERSION_MAJOR >= 3 && GLFW_VERSION_MINOR >= 3
+    ioptr->ConfigDpiScaleFonts = true;          // [Experimental] Automatically overwrite style.FontScaleDpi in Begin() when Monitor DPI changes. This will scale fonts but _NOT_ scale sizes/padding for now.
+    ioptr->ConfigDpiScaleViewports = true;      // [Experimental] Scale Dear ImGui and Platform Windows when Monitor DPI changes.
+#endif
  ImGui_ImplGlfw_InitForOpenGL(window, true);
  ImGui_ImplOpenGL3_Init(glsl_version);

--- a/backend_test/example_sdl3_vulkan/CMakeLists.txt
+++ b/backend_test/example_sdl3_vulkan/CMakeLists.txt
@@ -0,0 +1,100 @@
+cmake_minimum_required(VERSION 2.8)
+Project(cimgui_sdl3_vk)
+if(WIN32) # to make mingw work as all the others
+set(CMAKE_SHARED_LIBRARY_PREFIX "")
+endif(WIN32)
+# general settings
+
+
+if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/../../imgui/backends)
+	set(BACKENDS_FOLDER "../../imgui/backends/")
+else()
+	set(BACKENDS_FOLDER "../../imgui/examples/")
+endif()
+
+if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/../../imgui/imgui_tables.cpp)
+	set(TABLES_SOURCE "../../imgui/imgui_tables.cpp")
+else()
+	set(TABLES_SOURCE "")
+endif()
+
+include_directories(../../imgui ../../imgui/backends)
+
+
+include_directories(../../)
+set(IMGUI_SOURCES ../../cimgui.cpp
+../../cimgui_impl.cpp
+../../imgui/imgui.cpp
+../../imgui/imgui_draw.cpp
+../../imgui/imgui_demo.cpp
+../../imgui/imgui_widgets.cpp
+${TABLES_SOURCE}
+)
+
+set(IMGUI_SOURCES_sdl)
+set(IMGUI_LIBRARIES )
+
+
+#optional adding freetype
+option(IMGUI_FREETYPE "add Freetype2" OFF)
+
+if(IMGUI_FREETYPE)
+	FIND_PACKAGE(freetype REQUIRED PATHS ${FREETYPE_PATH})
+	list(APPEND IMGUI_LIBRARIES freetype)
+	list(APPEND IMGUI_SOURCES ../../imgui/misc/freetype/imgui_freetype.cpp)
+	add_definitions("-DCIMGUI_FREETYPE=1")
+endif(IMGUI_FREETYPE)
+
+# vulkan
+find_package(Vulkan REQUIRED FATAL_ERROR)
+list(APPEND IMGUI_LIBRARIES Vulkan::Vulkan)
+list(APPEND IMGUI_SOURCES ${BACKENDS_FOLDER}imgui_impl_vulkan.cpp)
+include_directories(${Vulkan_INCLUDE_DIRS})
+
+#sdl3
+list(APPEND IMGUI_SOURCES ${BACKENDS_FOLDER}imgui_impl_sdl3.cpp)
+include(FetchContent)
+Set(FETCHCONTENT_QUIET FALSE)
+
+FetchContent_Declare(
+        SDL3
+        GIT_REPOSITORY https://github.com/libsdl-org/SDL.git
+        GIT_TAG release-3.2.8
+        #GIT_SHALLOW TRUE
+        GIT_PROGRESS TRUE
+)
+FetchContent_GetProperties(SDL3)
+if (NOT sdl3_POPULATED)
+	set(FETCHCONTENT_QUIET NO)
+    FetchContent_Populate(SDL3)
+	set(SDL_TEST OFF CACHE BOOL "" FORCE)
+	set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
+	add_subdirectory(${sdl3_SOURCE_DIR} ${sdl3_BINARY_DIR})
+endif()
+include_directories(${SDL3_SOURCE_DIR}/include)
+
+
+#if dynamic SDL3 then install
+# install(TARGETS SDL3 RUNTIME DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
+					# LIBRARY DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
+# )
+
+add_library(cimgui_sdl STATIC ${IMGUI_SOURCES})
+target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_USER_CONFIG=\"../cimconfig.h\"")
+target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
+target_compile_definitions(cimgui_sdl PUBLIC -DCIMGUI_USE_VULKAN -DCIMGUI_USE_SDL3)
+if (WIN32)
+    target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_IMPL_API=extern \"C\" __declspec\(dllexport\)")
+else(WIN32)
+    target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_IMPL_API=extern \"C\" ")
+endif(WIN32)
+#target_link_libraries(cimgui_sdl ${IMGUI_LIBRARIES} SDL3-static)
+
+#using library
+add_executable(test_sdl main.c)
+target_compile_definitions(test_sdl PUBLIC -DCIMGUI_USE_VULKAN -DCIMGUI_USE_SDL3)
+if (MINGW)
+target_link_options(test_sdl PRIVATE "-mconsole")
+endif()
+target_link_libraries(test_sdl SDL3-static cimgui_sdl ${IMGUI_LIBRARIES})
+
--- a/backend_test/example_sdl3_vulkan/README.md
+++ b/backend_test/example_sdl3_vulkan/README.md
@@ -0,0 +1,2 @@
+
+To build use `cmake path_to_example_sdl3_vulkan` and then `make install`
--- a/backend_test/example_sdl3_vulkan/main.c
+++ b/backend_test/example_sdl3_vulkan/main.c
@@ -0,0 +1,630 @@
+#include <stdio.h>          // printf, fprintf
+#include <stdlib.h>         // abort
+#include <assert.h>
+#define SDL_MAIN_HANDLED
+#include <SDL3/SDL.h>
+#include <SDL3/SDL_vulkan.h>
+#include <vulkan/vulkan.h>
+// Volk headers
+#ifdef IMGUI_IMPL_VULKAN_USE_VOLK
+#define VOLK_IMPLEMENTATION
+#include <volk.h>
+#endif
+
+//this must be equal to that in imgui_impl_vulkan.h
+#define IMGUI_IMPL_VULKAN_MINIMUM_IMAGE_SAMPLER_POOL_SIZE   (1)     // Minimum per atlas
+
+#define CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+#include <cimgui.h>
+#include <cimgui_impl.h>
+
+#ifdef IMGUI_HAS_IMSTR
+#define igBegin igBegin_Str
+#define igSliderFloat igSliderFloat_Str
+#define igCheckbox igCheckbox_Str
+#define igColorEdit3 igColorEdit3_Str
+#define igButton igButton_Str
+#endif
+
+#define igGetIO igGetIO_Nil
+
+#define IM_UNUSED(_VAR)  ((void)(_VAR))
+#define IM_ASSERT(_EXPR) assert(_EXPR)
+#define IM_ARRAYSIZE(_ARR) ((int)(sizeof(_ARR) / sizeof(*(_ARR))))
+
+//#define APP_USE_UNLIMITED_FRAME_RATE
+#ifdef _DEBUG
+#define APP_USE_VULKAN_DEBUG_REPORT
+#endif
+#define APP_USE_VULKAN_DEBUG_REPORT
+// Data
+static VkAllocationCallbacks*   g_Allocator = NULL;
+static VkInstance               g_Instance = VK_NULL_HANDLE;
+static VkPhysicalDevice         g_PhysicalDevice = VK_NULL_HANDLE;
+static VkDevice                 g_Device = VK_NULL_HANDLE;
+static uint32_t                 g_QueueFamily = (uint32_t)-1;
+static VkQueue                  g_Queue = VK_NULL_HANDLE;
+static VkDebugReportCallbackEXT g_DebugReport = VK_NULL_HANDLE;
+static VkPipelineCache          g_PipelineCache = VK_NULL_HANDLE;
+static VkDescriptorPool         g_DescriptorPool = VK_NULL_HANDLE;
+
+static ImGui_ImplVulkanH_Window g_MainWindowData;
+static uint32_t                 g_MinImageCount = 2;
+static bool                     g_SwapChainRebuild = false;
+
+static void check_vk_result(VkResult err)
+{
+    if (err == VK_SUCCESS)
+        return;
+    fprintf(stderr, "[vulkan] Error: VkResult = %d\n", err);
+    if (err < 0)
+        abort();
+}
+
+static void check_vk_result_line(VkResult err,int line)
+{
+    if (err == VK_SUCCESS)
+        return;
+    fprintf(stderr, "[vulkan] Error: VkResult = %d in line: (%d)\n", err, line);
+    if (err < 0)
+        abort();
+}
+
+#ifdef APP_USE_VULKAN_DEBUG_REPORT
+static VKAPI_ATTR VkBool32 VKAPI_CALL debug_report(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, void* pUserData)
+{
+    (void)flags; (void)object; (void)location; (void)messageCode; (void)pUserData; (void)pLayerPrefix; // Unused arguments
+    fprintf(stderr, "[vulkan] Debug report from ObjectType: %i\nMessage: %s\n\n", objectType, pMessage);
+    return VK_FALSE;
+}
+#endif // APP_USE_VULKAN_DEBUG_REPORT
+//*
+static bool IsExtensionAvailable(VkExtensionProperties* properties, uint32_t properties_count, const char* extension)
+{
+    for(uint32_t i = 0 ; i < properties_count; i++){
+        if (strcmp(properties[i].extensionName, extension) == 0)
+            return true;
+    }
+    return false;
+}
+
+static void SetupVulkan(const char** extensions, uint32_t extensions_count)
+{
+    VkResult err;
+#ifdef IMGUI_IMPL_VULKAN_USE_VOLK
+    volkInitialize();
+#endif
+
+    // Create Vulkan Instance
+    {
+        VkInstanceCreateInfo create_info = {};
+        create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+
+        // Enumerate available extensions
+        uint32_t properties_count;
+        vkEnumerateInstanceExtensionProperties(NULL, &properties_count, NULL);
+        VkExtensionProperties* properties = (VkExtensionProperties*)malloc(properties_count * sizeof(VkExtensionProperties));
+        err = vkEnumerateInstanceExtensionProperties(NULL, &properties_count, properties);
+        check_vk_result_line(err, __LINE__);
+
+        // Enable required extensions
+        if (IsExtensionAvailable(properties, properties_count, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)){
+            //instance_extensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+            extensions_count++;
+            extensions = realloc(extensions, extensions_count * sizeof(char*));
+            assert(extensions);
+            extensions[extensions_count-1] = VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME;
+        }
+#ifdef VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME
+        if (IsExtensionAvailable(properties, properties_count, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME))
+        {
+            //instance_extensions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
+            extensions_count++;
+            extensions = realloc(extensions, extensions_count * sizeof(char*));
+            assert(extensions);
+            extensions[extensions_count-1] = VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME;
+            create_info.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
+        }
+#endif
+        free(properties);
+        // Enabling validation layers
+#ifdef APP_USE_VULKAN_DEBUG_REPORT
+        const char* layers[] = { "VK_LAYER_KHRONOS_validation" };
+        create_info.enabledLayerCount = 1;
+        create_info.ppEnabledLayerNames = layers;
+        //instance_extensions.push_back("VK_EXT_debug_report");
+        extensions_count++;
+        extensions = realloc(extensions, extensions_count * sizeof(char*));
+        assert(extensions);
+        extensions[extensions_count-1] = "VK_EXT_debug_report";
+#endif
+
+        // Create Vulkan Instance
+        create_info.enabledExtensionCount = extensions_count;//(uint32_t)instance_extensions.Size;
+        create_info.ppEnabledExtensionNames = extensions;//instance_extensions.Data;
+        err = vkCreateInstance(&create_info, g_Allocator, &g_Instance);
+        check_vk_result_line(err, __LINE__);
+#ifdef IMGUI_IMPL_VULKAN_USE_VOLK
+        volkLoadInstance(g_Instance);
+#endif
+
+        // Setup the debug report callback
+#ifdef APP_USE_VULKAN_DEBUG_REPORT
+        PFN_vkCreateDebugReportCallbackEXT f_vkCreateDebugReportCallbackEXT = (PFN_vkCreateDebugReportCallbackEXT)vkGetInstanceProcAddr(g_Instance, "vkCreateDebugReportCallbackEXT");
+        IM_ASSERT(f_vkCreateDebugReportCallbackEXT != NULL);
+        VkDebugReportCallbackCreateInfoEXT debug_report_ci = {};
+        debug_report_ci.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
+        debug_report_ci.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT | VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT;
+        debug_report_ci.pfnCallback = debug_report;
+        debug_report_ci.pUserData = NULL;
+        err = f_vkCreateDebugReportCallbackEXT(g_Instance, &debug_report_ci, g_Allocator, &g_DebugReport);
+        check_vk_result_line(err, __LINE__);
+#endif
+    }
+    // Select Physical Device (GPU)
+    g_PhysicalDevice = ImGui_ImplVulkanH_SelectPhysicalDevice(g_Instance);
+    IM_ASSERT(g_PhysicalDevice != VK_NULL_HANDLE);
+    // Select graphics queue family
+    g_QueueFamily = ImGui_ImplVulkanH_SelectQueueFamilyIndex(g_PhysicalDevice);
+    IM_ASSERT(g_QueueFamily != (uint32_t)-1);
+
+    // Create Logical Device (with 1 queue)
+    {
+        //ImVector<const char*> device_extensions;
+        //device_extensions.push_back("VK_KHR_swapchain");
+        uint32_t device_extensions_count = 1;
+        const char** device_extensions = (const char**)malloc(device_extensions_count * sizeof(char*));
+        device_extensions[0] = "VK_KHR_swapchain";
+
+        // Enumerate physical device extension
+        uint32_t properties_count;
+        //ImVector<VkExtensionProperties> properties;
+        vkEnumerateDeviceExtensionProperties(g_PhysicalDevice, NULL, &properties_count, NULL);
+        //properties.resize(properties_count);
+        VkExtensionProperties* properties = (VkExtensionProperties*)malloc(properties_count * sizeof(VkExtensionProperties));
+        vkEnumerateDeviceExtensionProperties(g_PhysicalDevice, NULL, &properties_count, properties);
+#ifdef VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME
+        if (IsExtensionAvailable(properties, properties_count, VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME)){
+            //device_extensions.push_back(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME);
+            device_extensions_count++;
+            device_extensions = realloc(device_extensions, device_extensions_count * sizeof(const char*));
+            assert(device_extensions);
+            device_extensions[device_extensions_count-1] = VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME;
+        }
+#endif
+
+        const float queue_priority[] = { 1.0f };
+        VkDeviceQueueCreateInfo queue_info[1] = {};
+        queue_info[0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+        queue_info[0].queueFamilyIndex = g_QueueFamily;
+        queue_info[0].queueCount = 1;
+        queue_info[0].pQueuePriorities = queue_priority;
+        VkDeviceCreateInfo create_info = {};
+        create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+        create_info.queueCreateInfoCount = sizeof(queue_info) / sizeof(queue_info[0]);
+        create_info.pQueueCreateInfos = queue_info;
+        create_info.enabledExtensionCount = device_extensions_count; //(uint32_t)device_extensions.Size;
+        create_info.ppEnabledExtensionNames = device_extensions;//device_extensions.Data;
+        err = vkCreateDevice(g_PhysicalDevice, &create_info, g_Allocator, &g_Device);
+        check_vk_result_line(err, __LINE__);
+        vkGetDeviceQueue(g_Device, g_QueueFamily, 0, &g_Queue);
+    }
+    // Create Descriptor Pool
+    // If you wish to load e.g. additional textures you may need to alter pools sizes and maxSets.
+    {
+        VkDescriptorPoolSize pool_sizes[] =
+        {
+            { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, IMGUI_IMPL_VULKAN_MINIMUM_IMAGE_SAMPLER_POOL_SIZE },
+        };
+        VkDescriptorPoolCreateInfo pool_info = {};
+        pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+        pool_info.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
+        pool_info.maxSets = 0;
+        //for (VkDescriptorPoolSize& pool_size : pool_sizes)
+        //    pool_info.maxSets += pool_size.descriptorCount;
+        for(int i = 0; i < IM_ARRAYSIZE(pool_sizes); i++){
+            VkDescriptorPoolSize pool_size = pool_sizes[i];
+            pool_info.maxSets += pool_size.descriptorCount;
+        }
+        pool_info.poolSizeCount = (uint32_t)IM_ARRAYSIZE(pool_sizes);
+        pool_info.pPoolSizes = pool_sizes;
+        err = vkCreateDescriptorPool(g_Device, &pool_info, g_Allocator, &g_DescriptorPool);
+        check_vk_result_line(err, __LINE__);
+    }
+}
+//*/
+// All the ImGui_ImplVulkanH_XXX structures/functions are optional helpers used by the demo.
+// Your real engine/app may not use them.
+static void SetupVulkanWindow(ImGui_ImplVulkanH_Window* wd, VkSurfaceKHR surface, int width, int height)
+{
+    wd->Surface = surface;
+
+    // Check for WSI support
+    VkBool32 res;
+    vkGetPhysicalDeviceSurfaceSupportKHR(g_PhysicalDevice, g_QueueFamily, wd->Surface, &res);
+    if (res != VK_TRUE)
+    {
+        fprintf(stderr, "Error no WSI support on physical device 0\n");
+        exit(-1);
+    }
+
+    // Select Surface Format
+    const VkFormat requestSurfaceImageFormat[] = { VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_B8G8R8_UNORM, VK_FORMAT_R8G8B8_UNORM };
+    const VkColorSpaceKHR requestSurfaceColorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
+    wd->SurfaceFormat = ImGui_ImplVulkanH_SelectSurfaceFormat(g_PhysicalDevice, wd->Surface, requestSurfaceImageFormat, (size_t)IM_ARRAYSIZE(requestSurfaceImageFormat), requestSurfaceColorSpace);
+
+    // Select Present Mode
+#ifdef APP_USE_UNLIMITED_FRAME_RATE
+    VkPresentModeKHR present_modes[] = { VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_FIFO_KHR };
+#else
+    VkPresentModeKHR present_modes[] = { VK_PRESENT_MODE_FIFO_KHR };
+#endif
+    wd->PresentMode = ImGui_ImplVulkanH_SelectPresentMode(g_PhysicalDevice, wd->Surface, &present_modes[0], IM_ARRAYSIZE(present_modes));
+    //printf("[vulkan] Selected PresentMode = %d\n", wd->PresentMode);
+
+    // Create SwapChain, RenderPass, Framebuffer, etc.
+    IM_ASSERT(g_MinImageCount >= 2);
+    ImGui_ImplVulkanH_CreateOrResizeWindow(g_Instance, g_PhysicalDevice, g_Device, wd, g_QueueFamily, g_Allocator, width, height, g_MinImageCount, 0);
+}
+
+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)(800 * 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.MinImageCount = g_MinImageCount;
+    init_info.ImageCount = wd->ImageCount;
+    init_info.Allocator = g_Allocator;
+    init_info.PipelineInfoMain.RenderPass = wd->RenderPass;
+    init_info.PipelineInfoMain.Subpass = 0;
+    init_info.PipelineInfoMain.MSAASamples = VK_SAMPLE_COUNT_1_BIT;
+    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, 0);
+            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
@@ -18,10 +22,15 @@
 #define igButton igButton_Str
 #endif

+#define igGetIO igGetIO_Nil
+
 SDL_Window *window = NULL;

 int main(int argc, char* argv[])
 {
+#ifdef _WIN32
+    SetProcessDPIAware();
+#endif

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

--- a/backend_test/example_sdl_vulkan/README.md
+++ b/backend_test/example_sdl_vulkan/README.md
@@ -1,3 +1,2 @@
-This example needs vulkan generation before compilation: Vulkan SDK should be installed and then add "vulkan" to generator.bat and generate.

 To build use `cmake path_to_example_sdl_vulkan` and then `make install`
--- 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

@@ -26,6 +30,8 @@
 #define igButton igButton_Str
 #endif

+#define igGetIO igGetIO_Nil
+
 #define IM_UNUSED(_VAR)  ((void)(_VAR))
 #define IM_ASSERT(_EXPR) assert(_EXPR)
 #define IM_ARRAYSIZE(_ARR) ((int)(sizeof(_ARR) / sizeof(*(_ARR))))
@@ -262,7 +268,7 @@ static void SetupVulkanWindow(ImGui_ImplVulkanH_Window* wd, VkSurfaceKHR surface

    // 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);
+    ImGui_ImplVulkanH_CreateOrResizeWindow(g_Instance, g_PhysicalDevice, g_Device, wd, g_QueueFamily, g_Allocator, width, height, g_MinImageCount, 0);
 }

 static void CleanupVulkan()
@@ -374,6 +380,9 @@ static void FramePresent(ImGui_ImplVulkanH_Window* wd)
 // Main code
 int main(int argc, char* argv[])
 {
+#ifdef _WIN32
+    SetProcessDPIAware();
+#endif
    //g_MainWindowData.ClearEnable = true;
 	//ImGui_ImplVulkanH_Window_Construct(&g_MainWindowData);
 	g_MainWindowData = *ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window();
@@ -381,7 +390,7 @@ int main(int argc, char* argv[])
    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_GAMECONTROLLER) != 0)
    {
        printf("Error: %s\n", SDL_GetError());
-        return -1;
+        return 1;
    }

    // From 2.0.18: Enable native IME.
@@ -389,13 +398,14 @@ 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());
-        return -1;
+        return 1;
    }
  // Setup Vulkan
  uint32_t extensions_count = 0;
@@ -443,6 +453,10 @@ int main(int argc, char* argv[])
        style->Colors[ImGuiCol_WindowBg].w = 1.0f;
    }

+    // Setup scaling
+    ImGuiStyle_ScaleAllSizes(style, main_scale);        // Bake a fixed style scale. (until we have a solution for dynamic style scaling, changing this requires resetting Style + calling this again)
+    style->FontScaleDpi = main_scale;        // Set initial font scale. (using io.ConfigDpiScaleFonts=true makes this unnecessary. We leave both here for documentation purpose)
+
    // Setup Platform/Renderer backends
    ImGui_ImplSDL2_InitForVulkan(window);
    ImGui_ImplVulkan_InitInfo init_info = {};
@@ -453,12 +467,12 @@ int main(int argc, char* argv[])
    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.PipelineInfoMain.RenderPass = wd->RenderPass;
+    init_info.PipelineInfoMain.Subpass = 0;
+    init_info.PipelineInfoMain.MSAASamples = VK_SAMPLE_COUNT_1_BIT;
    init_info.CheckVkResultFn = check_vk_result;
    ImGui_ImplVulkan_Init(&init_info);

@@ -517,7 +531,7 @@ int main(int argc, char* argv[])
        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);
+            ImGui_ImplVulkanH_CreateOrResizeWindow(g_Instance, g_PhysicalDevice, g_Device, &g_MainWindowData, g_QueueFamily, g_Allocator, fb_width, fb_height, g_MinImageCount, 0);
            g_MainWindowData.FrameIndex = 0;
            g_SwapChainRebuild = false;
        }
--- a/backend_test/example_sdlgpu3/CMakeLists.txt
+++ b/backend_test/example_sdlgpu3/CMakeLists.txt
@@ -0,0 +1,33 @@
+cmake_minimum_required(VERSION 3.30)
+project(cimgui_sdlgpu3 LANGUAGES C CXX)
+
+set(CMAKE_C_STANDARD 11)
+
+include(FetchContent)
+
+FetchContent_Declare(
+	sdl3
+	URL https://github.com/libsdl-org/SDL/releases/download/release-3.2.8/SDL3-3.2.8.tar.gz
+)
+
+set(SDL_TEST_LIBRARY OFF CACHE BOOL "" FORCE)
+FetchContent_MakeAvailable(sdl3)
+
+include(../cmake/GenerateCimguiBindings.cmake)
+
+set(inclulist ${sdl3_SOURCE_DIR}/include)
+GenerateCimguiBindings(cimgui_with_backend sdl3 sdlgpu3 inclulist)
+target_link_libraries(cimgui_with_backend PRIVATE SDL3::SDL3)
+
+add_executable(${PROJECT_NAME} 
+	main.c
+)
+
+target_link_libraries(${PROJECT_NAME} PRIVATE SDL3::SDL3 cimgui_with_backend)
+target_compile_definitions(
+	${PROJECT_NAME}
+	PRIVATE 
+	CIMGUI_DEFINE_ENUMS_AND_STRUCTS=1
+	CIMGUI_USE_SDL3=1
+	CIMGUI_USE_SDLGPU3=1
+)
--- a/backend_test/example_sdlgpu3/README.md
+++ b/backend_test/example_sdlgpu3/README.md
@@ -0,0 +1,16 @@
+# SDLGPU3
+
+This example is a little different from the others, because `cimgui` doesn't come with bindings for the SDLGPU3 backend out of the box. Instead, this example shows how to generate the necessary bindings during cmake's configure time, then add the compiled library as a target for your application to link to.
+
+For the generation phase from cmake you need LuaJIT to be present.
+
+## Building
+
+From the build directory of your choice:
+
+`cmake path_to_example_sdlgpu3`
+
+and after
+
+`make`
+
--- a/backend_test/example_sdlgpu3/main.c
+++ b/backend_test/example_sdlgpu3/main.c
@@ -0,0 +1,216 @@
+#include <assert.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <SDL3/SDL.h>
+#include <SDL3/SDL_gpu.h>
+
+#include <cimgui.h>
+#include <cimgui_impl.h>
+
+
+#define igGetIO igGetIO_Nil
+
+int main() {
+    if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMEPAD)) {
+      fprintf(stderr, "Failed to init video! %s", SDL_GetError());
+      return 1;
+    };
+    
+    float main_scale = SDL_GetDisplayContentScale(SDL_GetPrimaryDisplay());
+    SDL_WindowFlags window_flags = SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIDDEN | SDL_WINDOW_HIGH_PIXEL_DENSITY;
+    SDL_Window* window = NULL;
+    window = SDL_CreateWindow("Dear ImGui SDL3+SDL_GPU example", (int)(1280 * main_scale), (int)(720 * main_scale), window_flags);
+    if (window == NULL)
+    {
+        printf("Error: SDL_CreateWindow(): %s\n", SDL_GetError());
+        return -1;
+    }
+    SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
+    SDL_ShowWindow(window);
+
+    // Create GPU Device
+    SDL_GPUDevice* gpu_device = SDL_CreateGPUDevice(SDL_GPU_SHADERFORMAT_SPIRV | SDL_GPU_SHADERFORMAT_DXIL | SDL_GPU_SHADERFORMAT_METALLIB,true,NULL);
+    if (gpu_device == NULL)
+    {
+        printf("Error: SDL_CreateGPUDevice(): %s\n", SDL_GetError());
+        return -1;
+    }
+
+    // Claim window for GPU Device
+    if (!SDL_ClaimWindowForGPUDevice(gpu_device, window))
+    {
+        printf("Error: SDL_ClaimWindowForGPUDevice(): %s\n", SDL_GetError());
+        return -1;
+    }
+    SDL_SetGPUSwapchainParameters(gpu_device, window, SDL_GPU_SWAPCHAINCOMPOSITION_SDR, SDL_GPU_PRESENTMODE_MAILBOX);
+
+  // Setup Dear ImGui context
+    //IMGUI_CHECKVERSION();
+    igCreateContext(NULL);
+    ImGuiIO* io = igGetIO(); (void)io;
+    io->ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;     // Enable Keyboard Controls
+    io->ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;      // Enable Gamepad Controls
+
+    // Setup Dear ImGui style
+    igStyleColorsDark(NULL);
+    //igStyleColorsLight(NULL);
+    // Setup scaling
+    ImGuiStyle* style = igGetStyle();
+    ImGuiStyle_ScaleAllSizes(style, main_scale);        // Bake a fixed style scale. (until we have a solution for dynamic style scaling, changing this requires resetting Style + calling this again)
+    style->FontScaleDpi = main_scale;        // Set initial font scale. (using io.ConfigDpiScaleFonts=true makes this unnecessary. We leave both here for documentation purpose)
+    io->ConfigDpiScaleFonts = true;          // [Experimental] Automatically overwrite style.FontScaleDpi in Begin() when Monitor DPI changes. This will scale fonts but _NOT_ scale sizes/padding for now.
+    io->ConfigDpiScaleViewports = true;      // [Experimental] Scale Dear ImGui and Platform Windows when Monitor DPI changes.
+
+    // Setup Platform/Renderer backends
+    ImGui_ImplSDL3_InitForSDLGPU(window);
+    ImGui_ImplSDLGPU3_InitInfo init_info;//= {};
+    init_info.Device = gpu_device;
+    init_info.ColorTargetFormat = SDL_GetGPUSwapchainTextureFormat(gpu_device, window);
+    init_info.MSAASamples = SDL_GPU_SAMPLECOUNT_1;
+    ImGui_ImplSDLGPU3_Init(&init_info);
+  // finish loading data
+
+    // Our state
+    bool show_demo_window = true;
+    bool show_another_window = false;
+    ImVec4 clear_color;
+    clear_color.x = 0.45f;
+    clear_color.y = 0.55f;
+    clear_color.z = 0.60f;
+    clear_color.w = 1.00f;
+
+    // Main loop
+    bool done = false;
+    while (!done)
+    {
+        // Poll and handle events (inputs, window resize, etc.)
+        // You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
+        // - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application, or clear/overwrite your copy of the mouse data.
+        // - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application, or clear/overwrite your copy of the keyboard data.
+        // Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
+        // [If using SDL_MAIN_USE_CALLBACKS: call ImGui_ImplSDL3_ProcessEvent() from your SDL_AppEvent() function]
+        SDL_Event event;
+        while (SDL_PollEvent(&event))
+        {
+            ImGui_ImplSDL3_ProcessEvent(&event);
+            if (event.type == SDL_EVENT_QUIT)
+                done = true;
+            if (event.type == SDL_EVENT_WINDOW_CLOSE_REQUESTED && event.window.windowID == SDL_GetWindowID(window))
+                done = true;
+        }
+
+        // [If using SDL_MAIN_USE_CALLBACKS: all code below would likely be your SDL_AppIterate() function]
+        if (SDL_GetWindowFlags(window) & SDL_WINDOW_MINIMIZED)
+        {
+            SDL_Delay(10);
+            continue;
+        }
+
+        // Start the Dear ImGui frame
+        ImGui_ImplSDLGPU3_NewFrame();
+        ImGui_ImplSDL3_NewFrame();
+        igNewFrame();
+
+        // 1. Show the big demo window (Most of the sample code is in igShowDemoWindow()! You can browse its code to learn more about Dear ImGui!).
+        if (show_demo_window)
+            igShowDemoWindow(&show_demo_window);
+
+        // 2. Show a simple window that we create ourselves. We use a Begin/End pair to create a named window.
+        {
+            static float f = 0.0f;
+            static int counter = 0;
+
+            igBegin("Hello, world!", NULL, 0);                          // Create a window called "Hello, world!" and append into it.
+
+            igText("This is some useful text.");               // Display some text (you can use a format strings too)
+            igCheckbox("Demo Window", &show_demo_window);      // Edit bools storing our window open/close state
+            igCheckbox("Another Window", &show_another_window);
+
+            igSliderFloat("float", &f, 0.0f, 1.0f, "%.3f", 0);            // Edit 1 float using a slider from 0.0f to 1.0f
+            igColorEdit4("clear color", (float*)&clear_color, 0); // Edit 3 floats representing a color
+
+            ImVec2 buttonSize;
+            buttonSize.x = 0;
+            buttonSize.y = 0;
+            if (igButton("Button", buttonSize))                            // Buttons return true when clicked (most widgets return true when edited/activated)
+                counter++;
+            igSameLine(0.0f, -1.0f);
+            igText("counter = %d", counter);
+
+            igText("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / io->Framerate, io->Framerate);
+            igEnd();
+        }
+
+        // 3. Show another simple window.
+        if (show_another_window)
+        {
+            igBegin("Another Window", &show_another_window, 0);   // Pass a pointer to our bool variable (the window will have a closing button that will clear the bool when clicked)
+            igText("Hello from another window!");
+            ImVec2 buttonSize;
+            buttonSize.x = 0; buttonSize.y = 0;
+            if (igButton("Close Me", buttonSize))
+                show_another_window = false;
+            igEnd();
+        }
+
+        // Rendering
+        igRender();
+        ImDrawData* draw_data = igGetDrawData();
+        const bool is_minimized = (draw_data->DisplaySize.x <= 0.0f || draw_data->DisplaySize.y <= 0.0f);
+
+        SDL_GPUCommandBuffer* command_buffer = SDL_AcquireGPUCommandBuffer(gpu_device); // Acquire a GPU command buffer
+
+        SDL_GPUTexture* swapchain_texture;
+        SDL_AcquireGPUSwapchainTexture(command_buffer, window, &swapchain_texture, NULL, NULL); // Acquire a swapchain texture
+
+        if (swapchain_texture != NULL && !is_minimized)
+        {
+            // This is mandatory: call Imgui_ImplSDLGPU3_PrepareDrawData() to upload the vertex/index buffer!
+            ImGui_ImplSDLGPU3_PrepareDrawData(draw_data, command_buffer);
+
+            // Setup and start a render pass
+            SDL_GPUColorTargetInfo target_info ;//= {};
+            target_info.texture = swapchain_texture;
+            target_info.clear_color.r = clear_color.x;
+			target_info.clear_color.g = clear_color.y;
+			target_info.clear_color.b = clear_color.z;
+			target_info.clear_color.a = clear_color.w;
+            target_info.load_op = SDL_GPU_LOADOP_CLEAR;
+            target_info.store_op = SDL_GPU_STOREOP_STORE;
+            target_info.mip_level = 0;
+            target_info.layer_or_depth_plane = 0;
+            target_info.cycle = false;
+			target_info.resolve_texture = NULL;
+			target_info.resolve_mip_level = 0;
+			target_info.resolve_layer = 0;
+			target_info.cycle_resolve_texture = false;
+			target_info.padding1 = 0;
+			target_info.padding2 = 0;
+            SDL_GPURenderPass* render_pass = SDL_BeginGPURenderPass(command_buffer, &target_info, 1, NULL);
+
+            // Render ImGui
+            ImGui_ImplSDLGPU3_RenderDrawData(draw_data, command_buffer, render_pass, NULL);
+
+            SDL_EndGPURenderPass(render_pass);
+        }
+
+        // Submit the command buffer
+        SDL_SubmitGPUCommandBuffer(command_buffer);
+    }
+
+    // Cleanup
+    // [If using SDL_MAIN_USE_CALLBACKS: all code below would likely be your SDL_AppQuit() function]
+    SDL_WaitForGPUIdle(gpu_device);
+    ImGui_ImplSDL3_Shutdown();
+    ImGui_ImplSDLGPU3_Shutdown();
+    igDestroyContext(NULL);
+
+    SDL_ReleaseWindowFromGPUDevice(gpu_device, window);
+    SDL_DestroyGPUDevice(gpu_device);
+    SDL_DestroyWindow(window);
+    SDL_Quit();
+
+    return 0;
+}
--- a/cimgui.cpp
+++ b/cimgui.cpp
--- a/cimgui.h
+++ b/cimgui.h
--- a/cimgui_impl.cpp
+++ b/cimgui_impl.cpp
@@ -5,34 +5,19 @@
 #include "./imgui/imgui_internal.h"
 #include "cimgui.h"

-#ifdef CIMGUI_USE_DX9
-#include "imgui_impl_dx9.h"
-#endif
-
-#ifdef CIMGUI_USE_DX10
-#include "imgui_impl_dx10.h"
-#endif
-
-#ifdef CIMGUI_USE_DX11
-#include "imgui_impl_dx11.h"
-#endif
-
-#ifdef CIMGUI_USE_DX12
-#include "imgui_impl_dx12.h"
-#endif

 #ifdef CIMGUI_USE_GLFW
 #include "imgui_impl_glfw.h"
 #endif

-#ifdef CIMGUI_USE_OPENGL2
-#include "imgui_impl_opengl2.h"
-#endif
-
 #ifdef CIMGUI_USE_OPENGL3
 #include "imgui_impl_opengl3.h"
 #endif

+#ifdef CIMGUI_USE_OPENGL2
+#include "imgui_impl_opengl2.h"
+#endif
+
 #ifdef CIMGUI_USE_SDL2
 #include "imgui_impl_sdl2.h"
 #endif
@@ -45,10 +30,6 @@
 #include "imgui_impl_vulkan.h"
 #endif

-#ifdef CIMGUI_USE_WIN32
-#include "imgui_impl_win32.h"
-#endif
-
 #include "cimgui_impl.h"

 #ifdef CIMGUI_USE_VULKAN
--- 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

@@ -6,45 +8,45 @@ typedef struct GLFWmonitor GLFWmonitor;
 struct GLFWwindow;
 struct GLFWmonitor;
 #endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
-CIMGUI_API bool ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window,bool install_callbacks);
-CIMGUI_API bool ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window,bool install_callbacks);
-CIMGUI_API bool ImGui_ImplGlfw_InitForOther(GLFWwindow* window,bool install_callbacks);
-CIMGUI_API void ImGui_ImplGlfw_Shutdown(void);
-CIMGUI_API void ImGui_ImplGlfw_NewFrame(void);
-CIMGUI_API void ImGui_ImplGlfw_InstallCallbacks(GLFWwindow* window);
-CIMGUI_API void ImGui_ImplGlfw_RestoreCallbacks(GLFWwindow* window);
-CIMGUI_API void ImGui_ImplGlfw_SetCallbacksChainForAllWindows(bool chain_for_all_windows);
-CIMGUI_API void ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window,int focused);
+CIMGUI_API void ImGui_ImplGlfw_CharCallback(GLFWwindow* window,unsigned int c);
 CIMGUI_API void ImGui_ImplGlfw_CursorEnterCallback(GLFWwindow* window,int entered);
 CIMGUI_API void ImGui_ImplGlfw_CursorPosCallback(GLFWwindow* window,double x,double y);
-CIMGUI_API void ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window,int button,int action,int mods);
-CIMGUI_API void ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window,double xoffset,double yoffset);
+CIMGUI_API float ImGui_ImplGlfw_GetContentScaleForMonitor(GLFWmonitor* monitor);
+CIMGUI_API float ImGui_ImplGlfw_GetContentScaleForWindow(GLFWwindow* window);
+CIMGUI_API bool ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window,bool install_callbacks);
+CIMGUI_API bool ImGui_ImplGlfw_InitForOther(GLFWwindow* window,bool install_callbacks);
+CIMGUI_API bool ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window,bool install_callbacks);
+CIMGUI_API void ImGui_ImplGlfw_InstallCallbacks(GLFWwindow* window);
 CIMGUI_API void ImGui_ImplGlfw_KeyCallback(GLFWwindow* window,int key,int scancode,int action,int mods);
-CIMGUI_API void ImGui_ImplGlfw_CharCallback(GLFWwindow* window,unsigned int c);
 CIMGUI_API void ImGui_ImplGlfw_MonitorCallback(GLFWmonitor* monitor,int event);
+CIMGUI_API void ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window,int button,int action,int mods);
+CIMGUI_API void ImGui_ImplGlfw_NewFrame(void);
+CIMGUI_API void ImGui_ImplGlfw_RestoreCallbacks(GLFWwindow* window);
+CIMGUI_API void ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window,double xoffset,double yoffset);
+CIMGUI_API void ImGui_ImplGlfw_SetCallbacksChainForAllWindows(bool chain_for_all_windows);
+CIMGUI_API void ImGui_ImplGlfw_Shutdown(void);
 CIMGUI_API void ImGui_ImplGlfw_Sleep(int milliseconds);
+CIMGUI_API void ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window,int focused);

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

 #endif
 #ifdef CIMGUI_USE_OPENGL2
-CIMGUI_API bool ImGui_ImplOpenGL2_Init(void);
-CIMGUI_API void ImGui_ImplOpenGL2_Shutdown(void);
-CIMGUI_API void ImGui_ImplOpenGL2_NewFrame(void);
-CIMGUI_API void ImGui_ImplOpenGL2_RenderDrawData(ImDrawData* draw_data);
-CIMGUI_API bool ImGui_ImplOpenGL2_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 bool ImGui_ImplOpenGL2_Init(void);
+CIMGUI_API void ImGui_ImplOpenGL2_NewFrame(void);
+CIMGUI_API void ImGui_ImplOpenGL2_RenderDrawData(ImDrawData* draw_data);
+CIMGUI_API void ImGui_ImplOpenGL2_Shutdown(void);
+CIMGUI_API void ImGui_ImplOpenGL2_UpdateTexture(ImTextureData* tex);

 #endif
 #ifdef CIMGUI_USE_SDL2
@@ -59,16 +61,18 @@ struct _SDL_GameController;
 typedef union SDL_Event SDL_Event;
 typedef enum { ImGui_ImplSDL2_GamepadMode_AutoFirst, ImGui_ImplSDL2_GamepadMode_AutoAll, ImGui_ImplSDL2_GamepadMode_Manual }ImGui_ImplSDL2_GamepadMode;
 #endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
-CIMGUI_API bool ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
-CIMGUI_API bool ImGui_ImplSDL2_InitForVulkan(SDL_Window* window);
+CIMGUI_API float ImGui_ImplSDL2_GetContentScaleForDisplay(int display_index);
+CIMGUI_API float ImGui_ImplSDL2_GetContentScaleForWindow(SDL_Window* window);
 CIMGUI_API bool ImGui_ImplSDL2_InitForD3D(SDL_Window* window);
 CIMGUI_API bool ImGui_ImplSDL2_InitForMetal(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL2_InitForSDLRenderer(SDL_Window* window,SDL_Renderer* renderer);
+CIMGUI_API bool ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
 CIMGUI_API bool ImGui_ImplSDL2_InitForOther(SDL_Window* window);
-CIMGUI_API void ImGui_ImplSDL2_Shutdown(void);
+CIMGUI_API bool ImGui_ImplSDL2_InitForSDLRenderer(SDL_Window* window,SDL_Renderer* renderer);
+CIMGUI_API bool ImGui_ImplSDL2_InitForVulkan(SDL_Window* window);
 CIMGUI_API void ImGui_ImplSDL2_NewFrame(void);
 CIMGUI_API bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event);
 CIMGUI_API void ImGui_ImplSDL2_SetGamepadMode(ImGui_ImplSDL2_GamepadMode mode,struct _SDL_GameController** manual_gamepads_array,int manual_gamepads_count);
+CIMGUI_API void ImGui_ImplSDL2_Shutdown(void);

 #endif
 #ifdef CIMGUI_USE_SDL3
@@ -83,17 +87,17 @@ struct SDL_Gamepad;
 typedef union SDL_Event SDL_Event;
 typedef enum { ImGui_ImplSDL3_GamepadMode_AutoFirst, ImGui_ImplSDL3_GamepadMode_AutoAll, ImGui_ImplSDL3_GamepadMode_Manual }ImGui_ImplSDL3_GamepadMode;
 #endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
-CIMGUI_API bool ImGui_ImplSDL3_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
-CIMGUI_API bool ImGui_ImplSDL3_InitForVulkan(SDL_Window* window);
 CIMGUI_API bool ImGui_ImplSDL3_InitForD3D(SDL_Window* window);
 CIMGUI_API bool ImGui_ImplSDL3_InitForMetal(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL3_InitForSDLRenderer(SDL_Window* window,SDL_Renderer* renderer);
-CIMGUI_API bool ImGui_ImplSDL3_InitForSDLGPU(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL3_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
 CIMGUI_API bool ImGui_ImplSDL3_InitForOther(SDL_Window* window);
-CIMGUI_API void ImGui_ImplSDL3_Shutdown(void);
+CIMGUI_API bool ImGui_ImplSDL3_InitForSDLGPU(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL3_InitForSDLRenderer(SDL_Window* window,SDL_Renderer* renderer);
+CIMGUI_API bool ImGui_ImplSDL3_InitForVulkan(SDL_Window* window);
 CIMGUI_API void ImGui_ImplSDL3_NewFrame(void);
 CIMGUI_API bool ImGui_ImplSDL3_ProcessEvent(const SDL_Event* event);
 CIMGUI_API void ImGui_ImplSDL3_SetGamepadMode(ImGui_ImplSDL3_GamepadMode mode,SDL_Gamepad** manual_gamepads_array,int manual_gamepads_count);
+CIMGUI_API void ImGui_ImplSDL3_Shutdown(void);

 #endif
 #ifdef CIMGUI_USE_VULKAN
@@ -101,6 +105,14 @@ CIMGUI_API void ImGui_ImplSDL3_SetGamepadMode(ImGui_ImplSDL3_GamepadMode mode,SD

 typedef struct ImGui_ImplVulkanH_Frame ImGui_ImplVulkanH_Frame;
 typedef struct ImGui_ImplVulkanH_Window ImGui_ImplVulkanH_Window;
+typedef struct ImGui_ImplVulkan_PipelineInfo ImGui_ImplVulkan_PipelineInfo;
+struct ImGui_ImplVulkan_PipelineInfo
+{
+    VkRenderPass RenderPass;
+    uint32_t Subpass;
+    VkSampleCountFlagBits MSAASamples;
+    VkPipelineRenderingCreateInfoKHR PipelineRenderingCreateInfo;
+};
 typedef struct ImGui_ImplVulkan_InitInfo ImGui_ImplVulkan_InitInfo;
 struct ImGui_ImplVulkan_InitInfo
 {
@@ -111,18 +123,17 @@ 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;
-    uint32_t Subpass;
-    uint32_t DescriptorPoolSize;
+    ImGui_ImplVulkan_PipelineInfo PipelineInfoMain;
    bool UseDynamicRendering;
-    VkPipelineRenderingCreateInfoKHR PipelineRenderingCreateInfo;
    const VkAllocationCallbacks* Allocator;
    void (*CheckVkResultFn)(VkResult err);
    VkDeviceSize MinAllocationSize;
+    VkShaderModuleCreateInfo CustomShaderVertCreateInfo;
+    VkShaderModuleCreateInfo CustomShaderFragCreateInfo;
 };
 typedef struct ImGui_ImplVulkan_RenderState ImGui_ImplVulkan_RenderState;
 struct ImGui_ImplVulkan_RenderState
@@ -161,6 +172,7 @@ struct ImGui_ImplVulkanH_Window
    VkSurfaceFormatKHR SurfaceFormat;
    VkPresentModeKHR PresentMode;
    VkRenderPass RenderPass;
+    VkPipeline Pipeline;
    bool UseDynamicRendering;
    bool ClearEnable;
    VkClearValue ClearValue;
@@ -176,23 +188,24 @@ struct ImGui_ImplVulkanH_Window
 typedef ImVector<ImGui_ImplVulkanH_Frame> ImVector_ImGui_ImplVulkanH_Frame;
 typedef ImVector<ImGui_ImplVulkanH_FrameSemaphores> ImVector_ImGui_ImplVulkanH_FrameSemaphores;
 #endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
-CIMGUI_API bool ImGui_ImplVulkan_Init(ImGui_ImplVulkan_InitInfo* info);
-CIMGUI_API void ImGui_ImplVulkan_Shutdown(void);
-CIMGUI_API void ImGui_ImplVulkan_NewFrame(void);
-CIMGUI_API void ImGui_ImplVulkan_RenderDrawData(ImDrawData* draw_data,VkCommandBuffer command_buffer,VkPipeline pipeline);
-CIMGUI_API 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 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_CreateOrResizeWindow(VkInstance instance,VkPhysicalDevice physical_device,VkDevice device,ImGui_ImplVulkanH_Window* wd,uint32_t queue_family,const VkAllocationCallbacks* allocator,int w,int h,uint32_t min_image_count,VkImageUsageFlags image_usage);
 CIMGUI_API void ImGui_ImplVulkanH_DestroyWindow(VkInstance instance,VkDevice device,ImGui_ImplVulkanH_Window* wd,const VkAllocationCallbacks* allocator);
-CIMGUI_API VkSurfaceFormatKHR ImGui_ImplVulkanH_SelectSurfaceFormat(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkFormat* request_formats,int request_formats_count,VkColorSpaceKHR request_color_space);
-CIMGUI_API VkPresentModeKHR ImGui_ImplVulkanH_SelectPresentMode(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkPresentModeKHR* request_modes,int request_modes_count);
-CIMGUI_API VkPhysicalDevice ImGui_ImplVulkanH_SelectPhysicalDevice(VkInstance instance);
-CIMGUI_API uint32_t ImGui_ImplVulkanH_SelectQueueFamilyIndex(VkPhysicalDevice physical_device);
 CIMGUI_API int ImGui_ImplVulkanH_GetMinImageCountFromPresentMode(VkPresentModeKHR present_mode);
-CIMGUI_API ImGui_ImplVulkanH_Window* ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window();
+CIMGUI_API VkPhysicalDevice ImGui_ImplVulkanH_SelectPhysicalDevice(VkInstance instance);
+CIMGUI_API VkPresentModeKHR ImGui_ImplVulkanH_SelectPresentMode(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkPresentModeKHR* request_modes,int request_modes_count);
+CIMGUI_API uint32_t ImGui_ImplVulkanH_SelectQueueFamilyIndex(VkPhysicalDevice physical_device);
+CIMGUI_API VkSurfaceFormatKHR ImGui_ImplVulkanH_SelectSurfaceFormat(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkFormat* request_formats,int request_formats_count,VkColorSpaceKHR request_color_space);
+CIMGUI_API ImGui_ImplVulkanH_Window* ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window(void);
+CIMGUI_API VkDescriptorSet ImGui_ImplVulkan_AddTexture(VkSampler sampler,VkImageView image_view,VkImageLayout image_layout);
+CIMGUI_API void ImGui_ImplVulkan_CreateMainPipeline(const ImGui_ImplVulkan_PipelineInfo* info);
+CIMGUI_API bool ImGui_ImplVulkan_Init(ImGui_ImplVulkan_InitInfo* info);
+CIMGUI_API bool ImGui_ImplVulkan_LoadFunctions(uint32_t api_version,PFN_vkVoidFunction(*loader_func)(const char* function_name,void* user_data),void* user_data);
+CIMGUI_API void ImGui_ImplVulkan_NewFrame(void);
+CIMGUI_API void ImGui_ImplVulkan_RemoveTexture(VkDescriptorSet descriptor_set);
+CIMGUI_API void ImGui_ImplVulkan_RenderDrawData(ImDrawData* draw_data,VkCommandBuffer command_buffer,VkPipeline pipeline);
+CIMGUI_API void ImGui_ImplVulkan_SetMinImageCount(uint32_t min_image_count);
+CIMGUI_API void ImGui_ImplVulkan_Shutdown(void);
+CIMGUI_API void ImGui_ImplVulkan_UpdateTexture(ImTextureData* tex);

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

 #include "./imgui/imgui.h"
-#ifdef IMGUI_ENABLE_FREETYPE
-#include "./imgui/misc/freetype/imgui_freetype.h"
-#endif
 #include "./imgui/imgui_internal.h"
 #include "cimgui.h"

@@ -12,16 +9,7 @@


 /////////////////////////////manual written functions
-CIMGUI_API void igLogText(const char *fmt, ...)
-{
-    char buffer[256];
-    va_list args;
-    va_start(args, fmt);
-    vsnprintf(buffer, 256, fmt, args);
-    va_end(args);

-    ImGui::LogText("%s", buffer);
-}
 CIMGUI_API void ImGuiTextBuffer_appendf(ImGuiTextBuffer *self, const char *fmt, ...)
 {
    va_list args;
--- a/generator/cimgui_template.h
+++ b/generator/cimgui_template.h
@@ -34,6 +34,12 @@ typedef unsigned __int64 ImU64;
 //typedef unsigned long long ImU64;
 #endif

+#ifndef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+#ifdef IMGUI_ENABLE_FREETYPE
+#include "./imgui/misc/freetype/imgui_freetype.h"
+#endif
+#endif
+

 #ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
 #include "imgui_structs.h"
@@ -43,11 +49,11 @@ struct SDL_Window;
 typedef union SDL_Event SDL_Event;
 #endif // CIMGUI_DEFINE_ENUMS_AND_STRUCTS

+PLACE_STRUCTS_C
+
 #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
@@ -1,5 +1,5 @@
 local M = {}
-
+local insert = table.insert
 local function ToStr(t,dometatables)
 	local function basicToStr (o)
 		if type(o) == "number" or type(o)=="boolean" then
@@ -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
@@ -934,7 +936,7 @@ local function itemsCount(items)
 		print(v,its and #its or 0)
 	end
 end
-
+--adding self argument for struct functions
 local function AdjustArguments(FP)
    for fun,defs in pairs(FP.defsT) do
        --struct function but no constructors or static functions or manuals
@@ -974,6 +976,7 @@ local function REPLACE_TEXTUREID(FP)
 		end
 	end
 end
+
 local function ADDIMSTR_S(FP)
    local defsT = FP.defsT
    local newcdefs = {}
@@ -1080,6 +1083,7 @@ local function DefsByStruct(FP)
    end
    return structs
 end  
+M.DefsByStruct = DefsByStruct
 local function get_nonPOD(FP)
 	local defbystruct = DefsByStruct(FP)
 	--M.prtable(defbystruct)
@@ -1099,8 +1103,259 @@ local function get_nonPOD(FP)
 	FP.structs_and_enums_table.nonPOD = nonPOD
 	return nonPOD
 end
+local function recur_calc_depth(FP, structs, k,n)
+	--print("recur_calc_depth",k,n)
+	local struct = structs[k] or FP.cimgui_inherited.structs[k]
+	local n1 = n
+	for i,field in ipairs(struct) do
+		local typ = field.type:gsub("const ","") 
+		typ = typ:gsub("*","")
+		if k~=typ and FP.nP_used[typ] then
+			n1 = math.max(n1,recur_calc_depth(FP, structs, typ,n+1))
+		end
+	end
+	return n1
+end
+local function gen_structs_c(FP)
+	local structs = FP.structs_and_enums_table.structs
+	local nonPOD = FP.structs_and_enums_table.nonPOD
+	--sort nP_used by dependencies and name
+	nP_used_sorted = {}
+	for k,v in pairs(FP.nP_used) do
+		nP_used_sorted[k] = recur_calc_depth(FP, structs, k, 1)
+	end
+	--M.prtable(nP_used_sorted)
+	local npsorted ={}
+	for k,n in pairs(nP_used_sorted) do insert(npsorted,k) end
+	table.sort(npsorted, function(a,b) return (nP_used_sorted[a] < nP_used_sorted[b]) or ((nP_used_sorted[a] == nP_used_sorted[b]) and (a<b)) end)
+	--M.prtable(npsorted)
+	--error"DEUG"
+	----------
+	local tabs = {}
+	local tabs_c = {}
+	--for k,v in pairs(FP.nP_used) do
+	--M.table_do_sorted(FP.nP_used, function(k,v)
+	for _,k in ipairs(npsorted) do
+		if nonPOD[k]~="inherited" then
+		insert(tabs,"typedef struct "..k.."_c "..k.."_c;")
+		insert(tabs_c,"typedef struct "..k.."_c "..k..";")
+		insert(tabs,"struct "..k.."_c {")
+		local struct = structs[k] or FP.cimgui_inherited.structs[k]
+		for i,field in ipairs(struct) do
+			local typ = field.type:gsub("const ","") 
+			typ = typ:gsub("*","")
+			if FP.nP_used[typ] then
+				local ftype = field.type:gsub(typ,typ.."_c")
+				insert(tabs,"    "..ftype.." "..field.name..";")
+			else
+				insert(tabs,"    "..field.type.." "..field.name..";")
+			end
+		end
+		insert(tabs,"};")
+		end
+	end --)
+	if #tabs > 0 then
+		insert(tabs,1,"#ifndef CIMGUI_DEFINE_ENUMS_AND_STRUCTS")
+		insert(tabs,"#endif")
+	end
+	if #tabs_c > 0 then
+		insert(tabs_c,1,"#ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS")
+		insert(tabs_c,"#endif")
+	end
+	--print(table.concat(tabs_c,"\n"))
+	--print(table.concat(tabs,"\n"))
+	return table.concat(tabs_c,"\n").."\n"..table.concat(tabs,"\n")
+	--return table.concat(tabs,"\n")
+end
+local function gen_field_conversion(tab, struct,structs, FP, to,prefix)
+	--M.prtable("gen_field_conversion",struct)
+	prefix = prefix or ""
+	--local structs = FP.structs_and_enums_table.structs
+	for i,field in ipairs(struct) do
+		local ftype = field.type:gsub("*","")
+		if FP.nP_used[field.type] then
+			gen_field_conversion(tab, structs[field.type],structs,FP, to,prefix..field.name..".")
+		elseif FP.nP_used[ftype] then
+			local ftypec = field.type:gsub(ftype,not to and (ftype.."_c") or ftype)
+			insert(tab, "    dest."..prefix..field.name.." = reinterpret_cast<"..ftypec..">(src."..prefix..field.name..");")
+		else
+			insert(tab,"    dest."..prefix..field.name.." = src."..prefix..field.name..";")
+		end
+	end
+end
+local function genConversions(FP)
+	local structs = FP.structs_and_enums_table.structs
+	if FP.cimgui_inherited then
+		structs = {}
+		for k,v in pairs(FP.cimgui_inherited.structs) do
+			assert(not structs[k])
+			structs[k] = v
+		end
+		for k,v in pairs(FP.structs_and_enums_table.structs) do
+			structs[k] = v
+		end
+	end
+	local convers = {}
+	--for k,v in pairs(FP.nP_used) do
+	M.table_do_sorted(FP.nP_used, function(k,v)
+		--print("genConversions",k)
+		insert(convers,"static inline "..k.." ConvertToCPP_"..k.."(const "..k.."_c& src)")
+		insert(convers,"{")
+		insert(convers,"    "..k.." dest;")
+		local struct = structs[k]
+		gen_field_conversion(convers,struct,structs,FP, true)
+		insert(convers,"    return dest;")
+		insert(convers,"}")
+		insert(convers,"static inline "..k.."_c ConvertFromCPP_"..k.."(const "..k.."& src)")
+		insert(convers,"{")
+		insert(convers,"    "..k.."_c dest;")
+		local struct = structs[k]
+		gen_field_conversion(convers,struct,structs,FP,  false)
+		insert(convers,"    return dest;")
+		insert(convers,"}")
+	end)
+	--print(table.concat(convers,"\n"))
+	return table.concat(convers,"\n")
+end
+local function get_nonPODused(FP)
+	--print("get_nonPODused-----------------------------")
+	local nonPOD = FP.structs_and_enums_table.nonPOD
+	if FP.cimgui_inherited then
+		for k,v in pairs(FP.cimgui_inherited.nonPOD) do
+			nonPOD[k] = "inherited"
+		end
+	end
+	--M.prtable(nonPOD)
+	local typeargs = {}
+	local typeargs_ret = {}
+	for k,defs in pairs(FP.defsT) do 
+		--print(k)
+		for i, w in ipairs(defs) do
+			if not w.templated then --and not w.location:match"internal" then
+			for ii,arg in ipairs(w.argsT) do
+				local typ = (arg.type):gsub("&","")
+				--typ = (typ):gsub("*","")
+				typ = (typ):gsub("const ","")
+				if nonPOD[typ] then
+					--print(arg.type,w.ov_cimguiname,w.location)
+					typeargs[arg.type] = (arg.type):gsub(typ,typ.."_c")
+				end
+			end
+			local typret = (w.ret or ""):gsub("&","")
+			--typret = (typret):gsub("*","")
+			typret = (typret):gsub("const ","")
+			--print(typret)
+			if nonPOD[typret] then
+				--print(w.ret,w.ov_cimguiname,w.location)
+				typeargs_ret[w.ret] = (w.ret):gsub(typret,typret.."_c")
+			end
+			end
+		end
+	end
+	--M.prtable(nonPOD)
+	local all_type_nP = {}
+	for k,v in pairs(typeargs) do 
+		local k2 = k:gsub("const ","")
+		all_type_nP[k2] = true
+	end
+	for k,v in pairs(typeargs_ret) do 
+		local k2 = k:gsub("const ","")
+		all_type_nP[k2] = true
+	end
+	FP.nP_used = all_type_nP
+	--M.prtable("FP.nP_used",FP.nP_used)
+	FP.nP_args = typeargs
+	FP.nP_ret = typeargs_ret
+	--genConversions(FP)
+	--M.prtable(typeargs,typeargs_ret,all_type_nP)
+	-- local typeargs2 = {}
+	-- for k,v in pairs(typeargs) do table.insert(typeargs2,k) end
+	-- table.sort(typeargs2)
+	-- print"------------typeargs2----------------"
+	-- M.prtable(typeargs2)
+	
+	-- local typeargs2_ret = {}
+	-- for k,v in pairs(typeargs_ret) do table.insert(typeargs2_ret,k) end
+	-- table.sort(typeargs2_ret)
+	-- print"------------typeargs2_ret----------------"
+	-- M.prtable(typeargs2_ret)
+
+end
+local function header_subs_nonPOD(FP,txt)
+	--print("----------header_subs_nonPOD")
+	--M.prtable(FP.nP_used)
+	for k,v in pairs(FP.nP_used) do
+		--txt = txt:gsub("([%s;])"..k,"%1"..k.."_c")
+		for i=1,2 do
+		txt = txt:gsub("([%s;])"..k.."([%s;%*])", "%1"..k.."_c%2")
+		end
+		--txt = txt:gsub("%s"..k..";", " "..k.."_c;")
+		--txt = txt:gsub("%s"..k.."%*", " "..k.."_c*")
+	end
+	return txt
+end
+M.header_subs_nonPOD = header_subs_nonPOD
 local function ADDnonUDT(FP)
 	local nonPOD = get_nonPOD(FP)
+	get_nonPODused(FP)
+	for k,defs in pairs(FP.defsT) do
+		for i, def in ipairs(defs) do 
+			--ret
+			local rets = (def.ret or ""):gsub("const ","")
+			rets = rets:gsub("*","")
+			if FP.nP_ret[def.ret] then
+				def.conv = (def.ret):gsub("const ","")
+				def.ret = FP.nP_ret[def.ret]
+				def.nonUDT = 1
+			elseif FP.nP_ret[rets] then
+				def.ret = def.ret:gsub(rets, FP.nP_ret[rets])
+				def.nonUDT = 2
+			end
+			--args
+			local caar,asp
+			if #def.argsT > 0 then
+				caar = "("
+				asp = "("
+				for i,v in ipairs(def.argsT) do
+					local name = v.name 
+					if v.ret then --function pointer
+						local f_ = v.has_cdecl and "(__cdecl*" or "(*"
+						asp = asp .. v.ret .. f_ .. v.name .. ")" .. v.signature .. ","
+						caar = caar .. name .. ","
+					else
+						local typ = v.type:gsub("const ","")
+						local typ2 = typ:gsub("*","")
+						if FP.nP_args[v.type] then
+							caar = caar .. "ConvertToCPP_"..typ.."("..name.."),"
+							asp = asp .. v.type:gsub(typ,typ.."_c").." "..v.name..","
+						elseif FP.nP_args[typ2] then
+							local typ3 = v.type:gsub(typ2,typ2.."_c")
+							caar = caar .. "reinterpret_cast<"..v.type..">("..name.."),"
+							asp = asp .. typ3 .." "..v.name..","
+						else
+							local siz = v.type:match("(%[%d*%])") or ""
+							local typ = v.type:gsub("(%[%d*%])","")
+							asp = asp .. typ .. (v.name~="..." and " "..v.name or "") .. siz .. ","
+							local callname = v.reftoptr and "*"..name or name 
+							caar = caar .. callname .. ","
+						end
+					end
+				end
+				caar = caar:sub(1,-2)..")"
+				asp = asp:sub(1,-2)..")"
+			else
+				caar = "()"
+				asp = "()"
+			end
+			def.call_args_old = def.call_args
+			def.call_args = caar
+			def.args = asp
+		end
+	end
+end
+local function ADDnonUDT_OLD(FP)
+	local nonPOD = get_nonPOD(FP)
+	get_nonPODused(FP)
 	--print"nonPOD"
 	--M.prtable(nonPOD)
    local defsT = FP.defsT
@@ -1122,6 +1377,7 @@ local function ADDnonUDT(FP)
 		if (not isUDT) and FP.cimgui_inherited and FP.cimgui_inherited.nonPOD[defT.ret] then
 			isUDT = true
 		end
+		--given in generator.lua , could be skipped
 		for _,udt_ret in ipairs(FP.UDTs) do
 			if udt_ret == defT.ret then isUDT=true; break end
 		end
@@ -1267,6 +1523,7 @@ local function printItems(items)
 	end
 end
 -------------
+local numerr = 0 --for popen error file
 function M.Parser()
 	local par = {}
 	local cdefs ={}
@@ -1284,7 +1541,9 @@ function M.Parser()
 	par.manuals = {}
 	par.skipped = {}
 	par.UDTs = {}
-
+	
+	par.genConversors = genConversions
+	par.gen_structs_c = gen_structs_c
 	function par:insert(line,loca)
 		--table.insert(cdefs,{line,loca})
 		--table.insert(cdefs,{line:gsub("^%s*(.-)%s*$", "%1"),loca})
@@ -1310,7 +1569,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,15 +1581,26 @@ 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()
 		self:parseItems()
 		self:gen_structs_and_enums_table()
-		self:gen_structs_and_enums()
 		self:compute_overloads()
+		self:gen_structs_and_enums()
+		--self:compute_overloads()
 		--self:compute_templated()
 		ADDdestructors(self)
 	end
@@ -1459,6 +1731,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 +1815,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
@@ -1695,6 +1970,30 @@ function M.Parser()
 	function par:header_text_insert(tab,txt,it)
 		table.insert(tab, txt)
 	end
+	local function function_parse(self,it)
+		local stname = ""
+		local namespace
+		if it.parent then
+			if it.parent.re_name == "struct_re" or it.parent.re_name == "typedef_st_re" or it.parent.re_name == "class_re" then
+				stname = it.parent.name
+			elseif it.parent.re_name == "namespace_re" then
+				namespace = get_parents_nameC(it) --it.parent.name
+			end
+		end
+		if it.item:match"^%s*template%s+<" then
+			local ttype,fun = it.item:match"^%s*template%s+<%s*typename%s+([^>]+)%s*>%s*(.+)$"
+			if self.ftemplate_list and self.ftemplate_list[ttype] then
+				for iT,vT in ipairs(self.ftemplate_list[ttype]) do
+					local funT = fun:gsub("([< %(])"..ttype,"%1"..vT)
+					--funT = funT:gsub("sizeof%("..ttype.."%)","sizeof("..vT..")")
+					--local funT = fun:gsub(ttype,vT)
+					self:parseFunction(stname,{item=funT},namespace,it.locat)
+				end
+			end
+		else
+			self:parseFunction(stname,it,namespace,it.locat)
+		end
+	end
 	function par:gen_structs_and_enums()
 		print"--------------gen_structs_and_enums"
 		--M.prtable(self.typenames)
@@ -1801,13 +2100,15 @@ function M.Parser()
 				if not structname then print("NO NAME",cleanst,it.item) end
 				--if not void stname or templated
 				if structname and not self.typenames[structname] then
-					
-					--table.insert(typedefs_table,"typedef struct "..structname.." "..structname..";\n")
-					local tst = "\ntypedef struct "..structname.." "..structname..";"
-						if check_unique_typedefs(tst,uniques) then
-							--table.insert(outtab,tst)
-							self:header_text_insert(outtab, tst, it)
-						end
+					--dont add typedef to non POD
+					local tst = ""
+					--if not self.nP_used[structname] then
+						tst = "\ntypedef struct "..structname.." "..structname..";"
+					--end
+					if check_unique_typedefs(tst,uniques) then
+						--table.insert(outtab,tst)
+						self:header_text_insert(outtab, tst, it)
+					end
 					self.typedefs_dict[structname]="struct "..structname
 					--dont insert child structs as they are inserted before parent struct
 					if not (it.parent and it.parent.re_name == "struct_re") then
@@ -1832,28 +2133,7 @@ function M.Parser()
 			elseif it.re_name == "namespace_re" or it.re_name == "union_re" or it.re_name == "functype_re" then
 				--nop
 			elseif it.re_name == "functionD_re" or it.re_name == "function_re" then
-				local stname = ""
-				local namespace
-				if it.parent then
-					if it.parent.re_name == "struct_re" or it.parent.re_name == "typedef_st_re" or it.parent.re_name == "class_re" then
-						stname = it.parent.name
-					elseif it.parent.re_name == "namespace_re" then
-						namespace = get_parents_nameC(it) --it.parent.name
-					end
-				end
-				if it.item:match"^%s*template%s+<" then
-					local ttype,fun = it.item:match"^%s*template%s+<%s*typename%s+([^>]+)%s*>%s*(.+)$"
-					if self.ftemplate_list and self.ftemplate_list[ttype] then
-						for iT,vT in ipairs(self.ftemplate_list[ttype]) do
-							local funT = fun:gsub("([< %(])"..ttype,"%1"..vT)
-							--funT = funT:gsub("sizeof%("..ttype.."%)","sizeof("..vT..")")
-							--local funT = fun:gsub(ttype,vT)
-							self:parseFunction(stname,{item=funT},namespace,it.locat)
-						end
-					end
-				else
-					self:parseFunction(stname,it,namespace,it.locat)
-				end
+				--function_parse(self,it)
 			else
 				if it.re_name~="operator_re" then
 				print("not processed gen",it.re_name,it.item:sub(1,20))
@@ -1873,7 +2153,10 @@ function M.Parser()
 		--check arg detection failure if no name in function declaration
 		check_arg_detection(self.defsT,self.typedefs_dict)
 		local outtabprest, outtabst = table.concat(outtabpre,""),table.concat(outtab,"")
+		outtabprest = M.header_subs_nonPOD(self,outtabprest)
+		outtabst = M.header_subs_nonPOD(self,outtabst)
 		self.structs_and_enums = {outtabprest, outtabst or ""}
+		
 		return outtabprest, outtabst
 	end
 	-----------
@@ -2067,7 +2350,9 @@ function M.Parser()
 				end
 			elseif it.re_name == "namespace_re" or it.re_name == "union_re" or it.re_name == "functype_re" then
 				--nop
-			elseif it.re_name ~= "functionD_re" and it.re_name ~= "function_re" and it.re_name ~= "operator_re" then
+			elseif it.re_name ~= "functionD_re" or it.re_name ~= "function_re" then
+				function_parse(self,it)
+			elseif it.re_name ~= "operator_re" then
 				print("not processed gen table",it.re_name)
 			end
 		end
@@ -2139,12 +2424,13 @@ function M.Parser()
    function par:dump_alltypes()
        for k,v in pairs(self.alltypes) do print(k, typetoStr(k) ) end
    end
+	
    function par:compute_overloads()
-		if self.IMGUI_HAS_TEXTURES then
-			print"----------replacing ImTextureID with ImTextureUserID"
-			REPLACE_TEXTUREID(self)
-			print"----------end replacing ImTextureID with ImTextureUserID"
-		end
+		-- if self.IMGUI_HAS_TEXTURES then
+			-- print"----------replacing ImTextureID with ImTextureUserID"
+			-- REPLACE_TEXTUREID(self)
+			-- print"----------end replacing ImTextureID with ImTextureUserID"
+		-- end
 		ADDIMSTR_S(self)
        local strt = {}
        local numoverloaded = 0
@@ -2195,9 +2481,9 @@ function M.Parser()
 		end)
        --print(numoverloaded, "overloaded")
        table.insert(strt,string.format("%d overloaded",numoverloaded))
-		--ADDIMSTR_S(self)
-		AdjustArguments(self)
 		ADDnonUDT(self)
+		AdjustArguments(self)
+		--ADDnonUDT(self)

 		--ADDdestructors(self)
        self.overloadstxt  = table.concat(strt,"\n")
@@ -2618,6 +2904,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 +2939,27 @@ 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_old)..";\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")
+            --table.insert(outtab,"    *pOut = "..namespace..def.funcname..def.call_args..";\n")
+			insert(outtab,"    return ConvertFromCPP_"..def.conv.."("..namespace..def.funcname..def.call_args..");\n")
+		elseif def.nonUDT == 2 then
+			insert(outtab,"    return reinterpret_cast<"..def.ret..">("..ptret..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)
@@ -2672,7 +2986,11 @@ local function struct_f_implementation(def)
        end
    elseif def.nonUDT then
        if def.nonUDT == 1 then
-            table.insert(outtab,"    *pOut = self->"..def.funcname..def.call_args..";\n")
+            --table.insert(outtab,"    *pOut = self->"..def.funcname..def.call_args..";\n")
+			--local typret = (def.ret):gsub("const ","")
+			insert(outtab,"    return ConvertFromCPP_"..def.conv.."(self->"..def.funcname..def.call_args..");\n")
+		elseif def.nonUDT == 2 then
+			insert(outtab,"    return reinterpret_cast<"..def.ret..">("..ptret.."self->"..def.funcname..def.call_args..");\n")
        end
    else --standard struct
        table.insert(outtab,"    return "..ptret.."self->"..def.funcname..def.call_args..";\n")
@@ -2730,7 +3048,9 @@ local function func_implementation(FP)
 		end
        until true
    end
-    return table.concat(outtab)
+	local conversors = FP:genConversors()
+	local cimplem = conversors .. table.concat(outtab)
+    return cimplem
 end

 M.func_implementation = func_implementation
@@ -2748,7 +3068,7 @@ M.table_do_sorted = table_do_sorted

 local function func_header_generate_structs(FP)

-    local outtab = {}
+    local outtab = {}--"\n/////func_header_generate_structs\n"}

 	table_do_sorted(FP.embeded_structs,function(k,v) 
 		table.insert(outtab,"typedef "..v.." "..k..";\n") 
@@ -2766,6 +3086,7 @@ local function func_header_generate_structs(FP)
 end
 M.func_header_generate_structs = func_header_generate_structs

+
 local function func_header_generate_funcs(FP)

    local outtab = {}
@@ -2794,11 +3115,18 @@ local function func_header_generate_funcs(FP)
            elseif def.destructor then
                table.insert(outtab,"CIMGUI_API void "..def.ov_cimguiname..def.args..";"..addcoment.."\n")
            else --not constructor
-
+				--local ret = FP.nP_ret[def.ret] or def.ret
+				local ret = def.ret
                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")
+                    table.insert(outtab,"CIMGUI_API "..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".." "..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")
+                    table.insert(outtab,"CIMGUI_API "..ret.." "..def.ov_cimguiname..def.args..";"..addcoment.."\n")
                end
            end 
        end
@@ -2818,13 +3146,16 @@ M.func_header_generate_funcs = func_header_generate_funcs
 local function func_header_generate(FP)

    local outtab = func_header_generate_structs(FP)
-    table.insert(outtab, 1, "#ifndef CIMGUI_DEFINE_ENUMS_AND_STRUCTS\n")
+    table.insert(outtab, 1, "\n#ifndef CIMGUI_DEFINE_ENUMS_AND_STRUCTS\n")
    table.insert(outtab,"#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS\n")
    
    local outtabf = func_header_generate_funcs(FP)
-    
-    local cfuncsstr = table.concat(outtab)..table.concat(outtabf)
+	outtabf = table.concat(outtabf)
+	assert(type(outtabf)=="string")
+    --outtabf = M.header_subs_nonPOD(FP,outtabf)
+    local cfuncsstr = table.concat(outtab)..outtabf
    cfuncsstr = cfuncsstr:gsub("\n+","\n") --several empty lines to one empty line
+
    return cfuncsstr
 end

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

 ::leave console open
 cmd /k
--- a/generator/generator.lua
+++ b/generator/generator.lua
@@ -13,6 +13,7 @@ local CONSTRUCTORS_GENERATION = script_args[2]:match("constructors") and true or
 local NOCHAR = script_args[2]:match("nochar") and true or false
 local NOIMSTRV = script_args[2]:match("noimstrv") and true or false
 local IMGUI_PATH = os.getenv"IMGUI_PATH" or "../imgui"
+local CONFIG_GENERATOR_PATH = os.getenv"CONFIG_GENERATOR_PATH" or "./config_generator.lua"
 local CFLAGS = ""
 local CPRE,CTEST
 --get implementations
@@ -77,7 +78,7 @@ print("CPRE",CPRE)
 --this table has the functions to be skipped in generation
 --------------------------------------------------------------------------
 local cimgui_manuals = {
-    igLogText = true,
+   -- igLogText = true,
    ImGuiTextBuffer_appendf = true,
    --igColorConvertRGBtoHSV = true,
    --igColorConvertHSVtoRGB = true
@@ -91,10 +92,10 @@ local cimgui_skipped = {
 --desired name
 ---------------------------------------------------------------------------
 local cimgui_overloads = {
-	igGetIO = {
-		["()"] = "igGetIO",
-		["(ImGuiContext*)"] = "igGetIOEx",
-	},
+	-- igGetIO = {
+		-- ["()"] = "igGetIO",
+		-- ["(ImGuiContext*)"] = "igGetIOEx",
+	-- },
    --igPushID = {
        --["(const char*)"] =           "igPushIDStr",
        --["(const char*,const char*)"] = "igPushIDRange",
@@ -123,11 +124,16 @@ local function func_header_impl_generate(FP)

    local outtab = {}
    
-    for _,t in ipairs(FP.funcdefs) do
-        if t.cimguiname then
-            local cimf = FP.defsT[t.cimguiname]
-            local def = cimf[t.signature]
+    -- for _,t in ipairs(FP.funcdefs) do
+        -- if t.cimguiname then
+            -- local cimf = FP.defsT[t.cimguiname]
+            -- local def = cimf[t.signature]
+		--for k,defs in pairs(FP.defsT) do
+		cpp2ffi.table_do_sorted(FP.defsT, function(i,defs)
+		   if true then
+		   for i, def in ipairs(defs) do
 			local addcoment = def.comment or ""
+			local empty = def.args:match("^%(%)") --no args
 			if def.constructor then
 				-- only vulkan is manually created
 				assert(def.ov_cimguiname=="ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window" or
@@ -139,17 +145,17 @@ local function func_header_impl_generate(FP)
 			else
                
                if def.stname == "" then --ImGui namespace or top level
-                    local empty = def.args:match("^%(%)") --no args
                    table.insert(outtab,"CIMGUI_API".." "..def.ret.." "..def.ov_cimguiname..(empty and "(void)" or def.args)..";"..addcoment.."\n")
                else
 					cpp2ffi.prtable(def)
                    error("class function in implementations")
                end
            end
+		end
        else --not cimguiname
            table.insert(outtab,t.comment:gsub("%%","%%%%").."\n")-- %% substitution for gsub
        end
-    end
+    end)
    local cfuncsstr = table.concat(outtab)
    cfuncsstr = cfuncsstr:gsub("\n+","\n") --several empty lines to one empty line
    return cfuncsstr
@@ -180,7 +186,7 @@ local function get_defines(t)
    end
    pipe:close()
    --require"anima.utils"
-    --prtable(defines)
+    --cpp2ffi.prtable(defines)
 	assert(next(defines), table.concat(compiler_output, "\n"))
    local ret = {}
    for i,v in ipairs(t) do
@@ -270,7 +276,10 @@ local function cimgui_generation(parser)
 --]]
 	--------------------------------------------------
    local hstrfile = read_data"./cimgui_template.h"
-
+	
+	
+	--hstrfile = hstrfile:gsub([[PLACE_STRUCTS_C]],parser:gen_structs_c())
+	
 	local outpre,outpost = parser.structs_and_enums[1],parser.structs_and_enums[2]
 	cpp2ffi.prtable(parser.templates)
 	cpp2ffi.prtable(parser.typenames)
@@ -285,6 +294,9 @@ local function cimgui_generation(parser)
 	if gdefines.ImDrawCallback_ResetRenderState then
 		cstructsstr = cstructsstr.."\n#define ImDrawCallback_ResetRenderState       "..gdefines.ImDrawCallback_ResetRenderState.."\n"
 	end
+	if gdefines.ImTextureID_Invalid then
+		cstructsstr = cstructsstr.."\n#define ImTextureID_Invalid       "..gdefines.ImTextureID_Invalid.."\n"
+	end
 	if gdefines.IMGUI_HAS_IMSTR then
 		if not (NOCHAR or NOIMSTRV) then
 		cstructsstr = cstructsstr.."\n#define IMGUI_HAS_IMSTR       1\n"
@@ -294,6 +306,7 @@ local function cimgui_generation(parser)
 	cstructsstr = colapse_defines(cstructsstr, "IMGUI_ENABLE_FREETYPE")
 	
    hstrfile = hstrfile:gsub([[#include "imgui_structs%.h"]],cstructsstr)
+	hstrfile = hstrfile:gsub([[PLACE_STRUCTS_C]],parser:gen_structs_c())
    local cfuncsstr = func_header_generate(parser)
 	cfuncsstr = colapse_defines(cfuncsstr, "IMGUI_ENABLE_FREETYPE")
    hstrfile = hstrfile:gsub([[#include "auto_funcs%.h"]],cfuncsstr)
@@ -309,7 +322,7 @@ local function cimgui_generation(parser)
    local cimplem = func_implementation(parser)
 	cimplem = colapse_defines(cimplem, "IMGUI_ENABLE_FREETYPE")
    local hstrfile = read_data"./cimgui_template.cpp"
-
+	
    hstrfile = hstrfile:gsub([[#include "auto_funcs%.cpp"]],cimplem)
 	local ftdef = "" --FREETYPE_GENERATION and "#define IMGUI_ENABLE_FREETYPE\n" or ""
    save_data("./output/cimgui.cpp",cimgui_header, ftdef, hstrfile)
@@ -320,7 +333,7 @@ end
 --------------------------------------------------------
 --get imgui.h version and IMGUI_HAS_DOCK--------------------------
 --defines for the cl compiler must be present in the print_defines.cpp file
-gdefines = get_defines{"IMGUI_VERSION","IMGUI_VERSION_NUM","FLT_MAX","FLT_MIN","IMGUI_HAS_DOCK","IMGUI_HAS_IMSTR","ImDrawCallback_ResetRenderState","IMGUI_HAS_TEXTURES"}
+gdefines = get_defines{"IMGUI_VERSION","IMGUI_VERSION_NUM","FLT_MAX","FLT_MIN","IMGUI_HAS_DOCK","IMGUI_HAS_IMSTR","ImDrawCallback_ResetRenderState","IMGUI_HAS_TEXTURES","ImTextureID_Invalid"}
 cpp2ffi.prtable(gdefines)
 if gdefines.IMGUI_HAS_DOCK then gdefines.IMGUI_HAS_DOCK = true end
 if gdefines.IMGUI_HAS_IMSTR then gdefines.IMGUI_HAS_IMSTR = true end
@@ -454,11 +467,19 @@ local parser2

 if #implementations > 0 then
 	print("------------------implementations generation with "..COMPILER.."------------------------")
+	--parser2 for function defs
+	--parser3 for separated structs and enums in cimgui_impl.h
    parser2 = cpp2ffi.Parser()
 	
-	local config = require"config_generator"
-    local impl_str = ""
+	local config = dofile(CONFIG_GENERATOR_PATH) --"./config_generator.lua"
+    local impl_str = "#ifndef CIMGUI_IMPL_DEFINED\n#define CIMGUI_IMPL_DEFINED\n"
+	local impl_str_cpp = {}
    for i,impl in ipairs(implementations) do
+		print("------------implementation:",impl)
+		table.insert(impl_str_cpp, "\n#ifdef CIMGUI_USE_" .. string.upper(impl))
+		table.insert(impl_str_cpp, [[#include "imgui_impl_]]..impl..[[.h"]])
+		table.insert(impl_str_cpp, "#endif")
+
        local source = backends_folder .. [[imgui_impl_]].. impl .. ".h "
        local locati = [[imgui_impl_]].. impl

@@ -472,11 +493,11 @@ if #implementations > 0 then
 				extra_includes = extra_includes .. include_cmd .. inc .. " "
 			end
 		end
-		parser2.cimgui_inherited =  dofile([[../../cimgui/generator/output/structs_and_enums.lua]])
+		parser2.cimgui_inherited =  dofile([[./output/structs_and_enums.lua]])
 		local defines = parser2:take_lines(CPRE..extra_defines..extra_includes..source, {locati}, COMPILER)
 		
 		local parser3 = cpp2ffi.Parser()
-		parser3.cimgui_inherited =  dofile([[../../cimgui/generator/output/structs_and_enums.lua]])
+		parser3.cimgui_inherited =  dofile([[./output/structs_and_enums.lua]])
 		parser3:take_lines(CPRE..extra_defines..extra_includes..source, {locati}, COMPILER)
 		parser3:do_parse()
 		local cfuncsstr = func_header_impl_generate(parser3) 
@@ -493,17 +514,22 @@ if #implementations > 0 then
 		end
 		impl_str = impl_str.. table.concat(outtab)..cfuncsstr .. "\n#endif\n"
    end
-	
+	impl_str = impl_str .. "#endif //CIMGUI_IMPL_DEFINED\n"
    parser2:do_parse()
-
-    -- save ./cimgui_impl.h
-    --local cfuncsstr = func_header_impl_generate(parser2) 
-	--local cstructstr1,cstructstr2 = parser2.structs_and_enums[1], parser2.structs_and_enums[2]
-    --save_data("./output/cimgui_impl.h",cstructstr1,cstructstr2,cfuncsstr)
 	save_data("./output/cimgui_impl.h",impl_str)

    ----------save fundefs in impl_definitions.lua for using in bindings
    save_data("./output/impl_definitions.lua",serializeTableF(parser2.defsT))
+	--impl cpp
+	impl_str_cpp = table.concat(impl_str_cpp, "\n")
+	local cppstr = read_data"./cimgui_impl_template.cpp"
+	cppstr = cppstr:gsub("GENERATED_PLACEHOLDER", impl_str_cpp)
+	save_data("./output/cimgui_impl.cpp",cppstr)
+	
+	copyfile("./output/cimgui_impl.h", "../cimgui_impl.h")
+	copyfile("./output/cimgui_impl.cpp", "../cimgui_impl.cpp")
+	os.remove("./output/cimgui_impl.h")
+	os.remove("./output/cimgui_impl.cpp")

 end -- #implementations > 0 then

@@ -535,9 +561,7 @@ end
 --]]
 -------------------copy C files to repo root
 copyfile("./output/cimgui.h", "../cimgui.h")
-copyfile("./output/cimgui_impl.h", "../cimgui_impl.h")
 copyfile("./output/cimgui.cpp", "../cimgui.cpp")
 os.remove("./output/cimgui.h")
-os.remove("./output/cimgui_impl.h")
 os.remove("./output/cimgui.cpp")
 print"all done!!"
--- 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
--- a/generator/output/impl_definitions.lua
+++ b/generator/output/impl_definitions.lua
--- 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*)
@@ -124,8 +134,8 @@ igGetIDWithSeed	2
 1	ImGuiID	igGetIDWithSeed_Str (const char*,const char*,ImGuiID)
 2	ImGuiID	igGetIDWithSeed_Int (int,ImGuiID)
 igGetIO	2
-1	ImGuiIO*	igGetIO ()
-2	ImGuiIO*	igGetIOEx (ImGuiContext*)
+1	ImGuiIO*	igGetIO_Nil ()
+2	ImGuiIO*	igGetIO_ContextPtr (ImGuiContext*)
 igGetKeyData	2
 1	ImGuiKeyData*	igGetKeyData_ContextPtr (ImGuiContext*,ImGuiKey)
 2	ImGuiKeyData*	igGetKeyData_Key (ImGuiKey)
@@ -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/generator/print_defines.cpp
+++ b/generator/print_defines.cpp
@@ -34,4 +34,8 @@

 #ifdef IMGUI_HAS_TEXTURES
 #pragma message(CIMGUI_DEFSTRING(IMGUI_HAS_TEXTURES))
+#endif
+
+#ifdef ImTextureID_Invalid
+#pragma message(CIMGUI_DEFSTRING(ImTextureID_Invalid))
 #endif
--- a/2
+++ b/2
--- a/test/main.c
+++ b/test/main.c
@@ -11,6 +11,8 @@
 #define igDebugCheckVersionAndDataLayout igDebugCheckVersionAndDataLayout_Str
 #endif

+#define igGetIO igGetIO_Nil
+
 int main(void)
 {
  assert(igDebugCheckVersionAndDataLayout(igGetVersion(), sizeof(ImGuiIO), sizeof(ImGuiStyle),
@@ -20,9 +22,10 @@ int main(void)
  igCreateContext(NULL);
  ImGuiIO *io = igGetIO();

-  unsigned char *text_pixels = NULL;
-  int text_w, text_h;
-  ImFontAtlas_GetTexDataAsRGBA32(io->Fonts, &text_pixels, &text_w, &text_h, NULL);
+  // unsigned char *text_pixels = NULL;
+  // int text_w, text_h;
+  // ImFontAtlas_GetTexDataAsRGBA32(io->Fonts, &text_pixels, &text_w, &text_h, NULL);
+  io->BackendFlags |= ImGuiBackendFlags_RendererHasTextures;

  for (int n = 0; n < 20; n++) {
    printf("NewFrame() %d\n", n);
@@ -31,6 +34,7 @@ int main(void)
    display_size.x = 1920;
    display_size.y = 1080;
    io->DisplaySize = display_size;
+	printf("DisplaySice %f, %f\n", io->DisplaySize.x, io->DisplaySize.y);
    io->DeltaTime = 1.0f / 60.0f;
    igNewFrame();
Author	SHA1	Message	Date
sonoro1234	649c38e150	Merge branch 'docking_inter' conv3	2025-11-18 16:45:22 +01:00
sonoro1234	363fb5869d	cpp2ffi: take care of CIMGUI_VARGS0	2025-11-14 09:42:56 +01:00
sonoro1234	c44d649bf5	generator.lua: ImTextureID_Invalid define for cl compiler	2025-11-13 19:14:43 +01:00
sonoro1234	9e036bb003	cpp2ffi: take care or cimgui_inherited	2025-11-11 11:06:46 +01:00
sonoro1234	22bcd46a7c	update README.md	2025-11-10 14:08:08 +01:00
sonoro1234	c4b7680882	cpp2ffi: genConversion take care of ptr to nonPOD fields, avoid infinite recursion on gen_structs_c	2025-11-10 13:53:03 +01:00
sonoro1234	794f63b480	cpp2ffi: gen_structs_c only used C types	2025-11-09 13:37:06 +01:00
sonoro1234	34550586d4	cpp2ffi: hide genConversors and gen_structs_c	2025-11-09 12:15:04 +01:00
sonoro1234	3c9eda8f1f	cpp2ffi:keep call_args_old	2025-11-09 11:37:28 +01:00
sonoro1234	26c3254fcb	ccc3	2025-11-08 09:53:51 +01:00
sonoro1234	0d6a84344c	add define ImTextureID_Invalid	2025-11-06 19:11:44 +01:00
sonoro1234	65f439f8b8	ccc2	2025-11-06 09:43:30 +01:00
sonoro1234	1407cd296d	ccc	2025-11-04 11:09:08 +01:00
sonoro1234	393cae9274	example_sdl3_vulkan/main.c correction	2025-10-29 18:42:28 +01:00
sonoro1234	bf4b240a51	Merge branch 'docking_inter'	2025-10-23 19:49:49 +02:00
sonoro1234	2d91c9d211	pull imgui docking 1.92.4 and generate	2025-10-23 19:46:22 +02:00
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	4e3e9b5fb2	backend_test/example_sdlgpu3: thanks to @hgranthorner PR #291 with generation from cmake	2025-03-22 17:36:09 +01:00
sonoro1234	334c9fa140	generator: correct structs_and_enums.lua path	2025-03-22 11:27:36 +01:00
sonoro1234	0b0a04de25	Merge branch 'docking_inter'	2025-03-22 10:23:01 +01:00
sonoro1234	03e6c8d1f2	pull imgui 1.91.9bdock and generate	2025-03-20 01:39:06 +01:00
sonoro1234	50c60f3da6	IMGUI_HAS_TEXTURES do nothing	2025-03-20 01:34:34 +01:00
sonoro1234	140d107be5	improve customization (see PR #290 )	2025-03-18 13:20:46 +01:00
sonoro1234	c32d1c0c9b	dont name igGetIO overload as the generic name of function (C++ name) solves issue #289	2025-03-15 17:51:30 +01:00
sonoro1234	3530b937f1	generation	2025-03-15 17:03:47 +01:00
Victor Bombi	bb6f212993	Merge pull request #288 from spencercw/vulkan generator.lua: fix missing void in Vulkan function generation	2025-03-15 16:57:30 +01:00
Chris Spencer	e3af31fb9c	generator.lua: fix missing void in Vulkan function generation	2025-03-15 11:57:14 +00:00
sonoro1234	e9a4157067	Merge remote-tracking branch 'remotes/origin/docking_inter'	2025-03-15 08:23:45 +01:00
sonoro1234	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`