pull imgui 1.92.1 and generate

pull imgui 1.92.0 - docking and generate

.github/workflows/build.yml

@@ -29,7 +29,9 @@ jobs:
           sudo apt-get install -y luajit
         elif [ "$GITHUB_OS" == "windows-latest" ];
         then
-          vcpkg install luajit
+          vcpkg install luajit:x64-windows
+          echo "/C/vcpkg/installed/x64-windows/tools/luajit" >> $GITHUB_PATH
+          echo "/C/vcpkg/installed/x64-windows/bin"   >> $GITHUB_PATH
         fi
 
     - name: Download Submodules
@@ -47,7 +49,6 @@ jobs:
     - name: Generate Bindings
       shell: bash
       run: |
-        export PATH=$PATH:/C/vcpkg/packages/luajit_x86-windows/tools/:/C/vcpkg/packages/luajit_x86-windows/bin/
         cd ./generator
         bash ./generator.sh
 

.gitmodules

@@ -1,4 +1,4 @@
 [submodule "imgui"]
 	path = imgui
 	url = https://github.com/ocornut/imgui.git
-	branch = master
+	branch = docking

CMakeLists.txt

@@ -1,7 +1,9 @@
-cmake_minimum_required(VERSION 3.1)
+cmake_minimum_required(VERSION 3.15)
-
+cmake_policy(SET CMP0091 NEW)
 project(cimgui)
 
+set (CMAKE_CXX_STANDARD 11)
+
 if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/imgui/imgui_tables.cpp)
 	set(TABLES_SOURCE "imgui/imgui_tables.cpp")
 else()
@@ -24,10 +26,10 @@ set(IMGUI_FREETYPE "no" CACHE STRING "Build with freetype library")
 set(IMGUI_LIBRARIES )
 
 if(IMGUI_FREETYPE)
+	message(STATUS "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")
 endif(IMGUI_FREETYPE)
 
 #add library and link
@@ -37,6 +39,20 @@ else (IMGUI_STATIC)
     add_library(cimgui SHARED ${IMGUI_SOURCES})
 endif (IMGUI_STATIC)
 
+if(IMGUI_FREETYPE)
+	target_compile_definitions(cimgui PUBLIC IMGUI_ENABLE_FREETYPE)
+	target_compile_definitions(cimgui PUBLIC IMGUI_ENABLE_STB_TRUETYPE)
+endif(IMGUI_FREETYPE)
+
+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)
     target_compile_definitions(cimgui PUBLIC IMGUI_IMPL_API=extern\t\"C\"\t__declspec\(dllexport\))

Makefile

@@ -59,10 +59,18 @@ $(OUTPUTNAME):$(OBJS)
 	$(CXX) -o $(OUTPUTNAME) $(OBJS) $(CXXFLAGS) $(LINKFLAGS)
 
 clean:
+ifeq ($(OS),Windows_NT)
+	del /q $(subst /,\,$(OBJS))
+else
 	rm -f $(OBJS)
+endif
 
 fclean: clean
+ifeq ($(OS),Windows_NT)
+	del /q $(subst /,\,$(OUTPUTNAME))
+else
 	rm -f $(OUTPUTNAME)
+endif
 
 re: fclean all
 

README.md

@@ -11,7 +11,7 @@ History:
 Initially cimgui was developed by Stephan Dilly as hand-written code but lately turned into an auto-generated version by sonoro1234 in order to keep up with imgui more easily (letting the user select the desired branch and commit)
 
 Notes:
-* currently this wrapper is based on version [1.82 of Dear ImGui with internal api]
+* currently this wrapper is based on version [1.92.0 of Dear ImGui with internal api]
 * only functions, structs and enums from imgui.h (an optionally imgui_internal.h) are wrapped.
 * if you are interested in imgui backends you should look [LuaJIT-ImGui](https://github.com/sonoro1234/LuaJIT-ImGui) project.
 * All naming is algorithmic except for those names that were coded in cimgui_overloads table (https://github.com/cimgui/cimgui/blob/master/generator/generator.lua#L60). In the official version this table is empty.
@@ -24,10 +24,11 @@ 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)
+  * 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 is now an example with SDL2 and opengl3 in folder backend_test. It will generate a cimgui_sdl module and a test_sdl executable. You only need to provide SDL_PATH telling cmake where to look for SDL2 cmake installation.
+  For compiling with backends there are now examples with SDL2 and opengl3/vulkan in folder backend_test.
+  They'll generate a cimgui_sdl module and a test_sdl executable.
 
 # using generator
 
@@ -36,13 +37,14 @@ Notes:
 * you will need LuaJIT (https://github.com/LuaJIT/LuaJIT.git better 2.1 branch) or precompiled for linux/macOS/windows in https://luapower.com/luajit/download
 * you need to use also a C++ compiler for doing preprocessing: gcc (In windows MinGW-W64-builds for example), clang or cl (MSVC). (this repo was done with gcc)
 * update `imgui` folder to the version you desire.
-* edit `generator/generator.bat` on windows, or `generator/generator.sh` on linux, to choose between gcc, clang, or cl and to choose desired backends and whether imgui_internal is generated or not and Freetype2 is used or not. 
+* edit `generator/generator.bat` on windows, or `generator/generator.sh` on linux, to choose between gcc, clang, or cl and to choose desired backends and whether imgui_internal is generated or not, comments are generated or not and if constructors are generated also with versions performing just initialization of structs provided by yourself (_Construct is added to the constructor names)
-* the defaults of generator are gcc as compiler, imgui_internal included and sdl, glfw, opengl2 and opengl3 as backends.
+* the defaults of generator are gcc as compiler, imgui_internal included and sdl, glfw, vulkan, opengl2 and opengl3 as backends.
 * edit config_generator.lua for adding includes needed by your chosen backends (vulkan needs that).
 * Run generator.bat or generator.sh with gcc, clang or cl and LuaJIT on your PATH.
 * as a result some files are generated: `cimgui.cpp`, `cimgui.h` and `cimgui_impl.h` for compiling and some lua/json files with information about the binding: `definitions.json` with function info, `structs_and_enums.json` with struct and enum info, `impl_definitions.json` with functions from the backends info. 
-* You can pass compiler flags to generator.sh or generator.bat at the end of the call to further specify the compiler behavior. (e.g. -DIMGUI_USER_CONFIG or -DIMGUI_USE_WCHAR32)
+* You can pass compiler flags to generator.sh or generator.bat by editing them at the end of the call to further specify the compiler behavior. (e.g. -DIMGUI_USER_CONFIG)
-
+* You are able to pass any extra argument to generator.sh (.bat) in the command-line.
+* If you are using different options than cimgui repo and if you want to keep them after a cimgui update, you can keep them in a copy of generator.sh (.bat) outside of cimgui folder where `cd cimgui/generator` is used before luajit call. See https://github.com/cimgui/cimgui/issues/232#issuecomment-1497059497
 # generate binding
 * C interface is exposed by cimgui.h when you define CIMGUI_DEFINE_ENUMS_AND_STRUCTS
 * with your prefered language you can use the lua or json files generated as in:
@@ -90,10 +92,11 @@ Notes:
 * methods have the same parameter list and return values (where possible)
 * functions that belong to a struct have an extra first argument with a pointer to the struct.
 * where a function returns UDT (user defined type) by value some compilers complain so the function is generated accepting a pointer to the UDT type as the first argument (or second if belongs to a struct).
-
+* constructors return pointer to struct and has been named Struct_name_Struct_name
 # usage with backends
 
-* look at backend_test folder for a cmake module building with SDL and opengl3.
+* look at backend_test folder for a cmake module building with SDL and opengl3, glfw and opengl3, SDL and Vulkan, glfw and dx11
+* read [How can cimgui backends be used](https://github.com/cimgui/cimgui/issues/157)
 
 # example bindings based on cimgui
 
@@ -115,3 +118,4 @@ Notes:
 * [sdl2-cimgui-demo](https://github.com/haxpor/sdl2-cimgui-demo)
 * [cimgui_c_sdl2_example](https://github.com/canoi12/cimgui_c_sdl2_example/)
 * [cimgui-c-example](https://github.com/peko/cimgui-c-example) with GLFW
+* [raylib-cimgui](https://github.com/alfredbaudisch/raylib-cimgui)

backend_test/CMakeLists.txt

@@ -1,98 +0,0 @@
-Project(cimgui_sdl)
-cmake_minimum_required(VERSION 2.8)
-if(WIN32) #to mingw work as all the others
-set(CMAKE_SHARED_LIBRARY_PREFIX "")
-endif(WIN32)
-#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_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_SOURCES_sdl)
-set(IMGUI_LIBRARIES )
-
-if (WIN32)
-    add_definitions("-DIMGUI_IMPL_API=extern \"C\" __declspec\(dllexport\)")
-else(WIN32)
-    add_definitions("-DIMGUI_IMPL_API=extern \"C\" ")
-endif(WIN32)
-
-add_compile_definitions("IMGUI_IMPL_OPENGL_LOADER_GL3W")
-
-#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)
-
-#opengl3
-list(APPEND IMGUI_SOURCES ${BAKENDS_FOLDER}imgui_impl_opengl3.cpp ../imgui/examples/libs/gl3w/GL/gl3w.c)
-list(APPEND IMGUI_SOURCES ./cimgui_extras.cpp)
-include_directories(../imgui/examples/libs/gl3w)
-if(WIN32)
-       list(APPEND IMGUI_LIBRARIES opengl32)
-else(WIN32)#Unix
-       list(APPEND IMGUI_LIBRARIES GL)
-endif(WIN32)
-
-
-#sdl2
-list(APPEND IMGUI_SOURCES ${BAKENDS_FOLDER}imgui_impl_sdl.cpp)
-if(DEFINED SDL_PATH)
-	message(STATUS "SDL_PATH defined as " ${SDL_PATH})
-	FIND_PACKAGE(SDL2 REQUIRED PATHS ${SDL_PATH})
-	get_target_property(SDL_INCLUDE SDL2::SDL2 INTERFACE_INCLUDE_DIRECTORIES)
-	message(STATUS "sdlinclude is " ${SDL_INCLUDE})
-	if ("${SDL_INCLUDE}" STREQUAL "" OR "${SDL_INCLUDE}" STREQUAL "SDL_INCLUDE-NOTFOUND") #if not found latest SDL2 cmake config use older
-		message(STATUS "sdlinclude2 is " ${SDL2_INCLUDE_DIRS})
-		include_directories(${SDL2_INCLUDE_DIRS})
-		set(IMGUI_SDL_LIBRARY ${SDL2_LIBRARIES})
-		message(STATUS IMGUI_SDL_LIBRARY ${SDL2_LIBRARIES})
-	else()#use new one SDL2 config
-		include_directories(${SDL_INCLUDE})
-		set(IMGUI_SDL_LIBRARY SDL2::SDL2)
-		set(SDL_MAIN SDL2::SDL2main)
-		message(STATUS ${SDL_MAIN} ${IMGUI_SDL_LIBRARY})
-	endif()
-else(DEFINED SDL_PATH)
-	message(STATUS "SDL_PATH not defined")
-	set(IMGUI_SDL_LIBRARY SDL2)
-endif(DEFINED SDL_PATH)
-
-add_library(cimgui_sdl SHARED ${IMGUI_SOURCES})
-target_link_libraries(cimgui_sdl ${IMGUI_LIBRARIES} ${IMGUI_SDL_LIBRARY})
-
-#using library
-include_directories(../generator/output/)
-add_executable(test_sdl main.c)
-if (MINGW)
-target_link_options(test_sdl PRIVATE "-mconsole")
-endif()
-target_link_libraries(test_sdl ${IMGUI_SDL_LIBRARY} cimgui_sdl)
-

backend_test/cimgui_extras.cpp

@@ -1,11 +0,0 @@
-#include "../imgui/imgui.h"
-
-// GL3W/GLFW
-#include <GL/gl3w.h>    // This example is using gl3w to access OpenGL functions (because it is small). You may use glew/glad/glLoadGen/etc. whatever already works for you.
-
-//making it accesible for luajit
-#ifdef _WIN32
-extern "C" __declspec( dllexport ) int Do_gl3wInit(void){ return gl3wInit();};
-#else
-extern "C"	int Do_gl3wInit(void){ return gl3wInit();};
-#endif

backend_test/cimgui_extras.h

@@ -1,8 +0,0 @@
-
-
-//making it accesible for main
-#ifdef _WIN32
-__declspec( dllexport ) int Do_gl3wInit(void);
-#else
-int Do_gl3wInit(void);
-#endif

backend_test/cmake/GenerateCimguiBindings.cmake

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

backend_test/example_glfw_dx11/CMakeLists.txt

@@ -0,0 +1,45 @@
+cmake_minimum_required(VERSION 3.11)
+project(cimgui_glfwdx11 LANGUAGES C CXX)
+
+set(CMAKE_C_STANDARD 11)
+
+include(FetchContent)
+
+set(GLFW_VERSION 3.3.8)
+FetchContent_Declare(
+    glfw
+    EXCLUDE_FROM_ALL
+    URL https://github.com/glfw/glfw/archive/refs/tags/${GLFW_VERSION}.tar.gz
+    GIT_PROGRESS true)
+
+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()
+
+
+FetchContent_MakeAvailable(glfw)
+install(TARGETS glfw RUNTIME DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
+					LIBRARY DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
+)
+
+include(../cmake/GenerateCimguiBindings.cmake)
+
+set(inclulist "")
+GenerateCimguiBindings(cimgui_with_backend "glfw" dx11 inclulist)
+target_link_libraries(cimgui_with_backend PRIVATE glfw d3dcompiler dwmapi)
+
+add_executable(${PROJECT_NAME} 
+	main.c
+)
+
+target_link_libraries(${PROJECT_NAME} PRIVATE glfw cimgui_with_backend d3d11 d3dcompiler dwmapi)
+target_compile_definitions(
+	${PROJECT_NAME}
+	PRIVATE 
+	CIMGUI_DEFINE_ENUMS_AND_STRUCTS=1
+	CIMGUI_USE_GLFW=1
+	CIMGUI_USE_DX11=1
+)

backend_test/example_glfw_dx11/README.md

@@ -0,0 +1,7 @@
+# GLFWDX11
+
+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
+

backend_test/example_glfw_dx11/main.c

@@ -0,0 +1,249 @@
+//#define CIMGUI_DEFINE_ENUMS_AND_STRUCTS is done in cmake
+#include "cimgui.h"
+#include "cimgui_impl.h"
+#define D3D11_NO_HELPERS
+#define CINTERFACE
+#define COBJMACROS
+#define WIN32_LEAN_AND_MEAN
+#include <d3d11.h>
+#include <GLFW/glfw3.h>
+#define GLFW_EXPOSE_NATIVE_WIN32
+#include <GLFW/glfw3native.h>
+#include <stdio.h>
+#ifdef _MSC_VER
+#include <windows.h>
+#endif
+
+#pragma comment(lib, "dxguid.lib")
+
+#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
+
+GLFWwindow *window;
+
+// Data
+static ID3D11Device*            g_pd3dDevice = NULL;
+static ID3D11DeviceContext*     g_pd3dDeviceContext = NULL;
+static IDXGISwapChain*          g_pSwapChain = NULL;
+static ID3D11RenderTargetView*  g_mainRenderTargetView = NULL;
+
+// Forward declarations of helper functions
+bool CreateDeviceD3D(HWND hWnd);
+void CleanupDeviceD3D();
+void CreateRenderTarget();
+void CleanupRenderTarget();
+
+void window_size_callback(GLFWwindow* window, int width, int height)
+{
+	CleanupRenderTarget();
+    IDXGISwapChain_ResizeBuffers(g_pSwapChain, 0, width, height, DXGI_FORMAT_UNKNOWN, 0);
+    CreateRenderTarget();
+}
+
+int main(int argc, char *argv[])
+{
+
+  if (!glfwInit())
+    return -1;
+
+  // Decide GL+GLSL versions
+  glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
+
+
+
+  // just an extra window hint for resize
+  glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
+
+  window = glfwCreateWindow(1024, 768, "Hello World!", NULL, NULL);
+  if (!window) 
+  {
+    printf("Failed to create window! Terminating!\n");
+    glfwTerminate();
+    return -1;
+  }
+  
+  //
+  HWND hwnd = glfwGetWin32Window(window);
+  if (hwnd == NULL)
+  {
+	  printf("Failed to get win32 window! Terminating!\n");
+	  glfwTerminate();
+		return -1;
+  }
+	 // Initialize Direct3D
+    if (!CreateDeviceD3D(hwnd))
+    {
+        CleanupDeviceD3D();
+        return 1;
+    }
+	
+	glfwSetWindowSizeCallback(window, window_size_callback);
+
+  // setup imgui
+  igCreateContext(NULL);
+
+  // set docking
+  ImGuiIO *ioptr = igGetIO();
+  ioptr->ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;   // Enable Keyboard Controls
+  //ioptr->ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;  // Enable Gamepad Controls
+#ifdef IMGUI_HAS_DOCK
+  ioptr->ConfigFlags |= ImGuiConfigFlags_DockingEnable;       // Enable Docking
+  ioptr->ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;     // Enable Multi-Viewport / Platform Windows
+#endif
+
+  ImGui_ImplGlfw_InitForOther(window, true);
+  ImGui_ImplDX11_Init(g_pd3dDevice, g_pd3dDeviceContext);
+
+  igStyleColorsDark(NULL);
+  // ImFontAtlas_AddFontDefault(io.Fonts, NULL);
+
+  bool showDemoWindow = true;
+  bool showAnotherWindow = false;
+  ImVec4 clearColor;
+  clearColor.x = 0.45f;
+  clearColor.y = 0.55f;
+  clearColor.z = 0.60f;
+  clearColor.w = 1.00f;
+	
+  // main event loop
+  bool quit = false;
+  while (!glfwWindowShouldClose(window))
+  {
+
+    glfwPollEvents();
+
+    // start imgui frame
+    ImGui_ImplDX11_NewFrame();
+    ImGui_ImplGlfw_NewFrame();
+    igNewFrame();
+
+    if (showDemoWindow)
+      igShowDemoWindow(&showDemoWindow);
+
+    // show a simple window that we created ourselves.
+    {
+      static float f = 0.0f;
+      static int counter = 0;
+
+      igBegin("Hello, world!", NULL, 0);
+      igText("This is some useful text");
+      igCheckbox("Demo window", &showDemoWindow);
+      igCheckbox("Another window", &showAnotherWindow);
+
+      igSliderFloat("Float", &f, 0.0f, 1.0f, "%.3f", 0);
+      igColorEdit3("clear color", (float *)&clearColor, 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();
+    }
+
+    if (showAnotherWindow) 
+    {
+      igBegin("imgui Another Window", &showAnotherWindow, 0);
+      igText("Hello from imgui");
+      ImVec2 buttonSize;
+      buttonSize.x = 0;
+      buttonSize.y = 0;
+      if (igButton("Close me", buttonSize)) {
+        showAnotherWindow = false;
+      }
+      igEnd();
+    }
+
+    // render
+    igRender();
+	const float clear_color_with_alpha[4] = { clearColor.x * clearColor.w, clearColor.y * clearColor.w, clearColor.z * clearColor.w, clearColor.w };
+        ID3D11DeviceContext_OMSetRenderTargets(g_pd3dDeviceContext, 1, &g_mainRenderTargetView, NULL);
+        ID3D11DeviceContext_ClearRenderTargetView(g_pd3dDeviceContext, g_mainRenderTargetView, clear_color_with_alpha);
+	ImGui_ImplDX11_RenderDrawData(igGetDrawData());
+#ifdef IMGUI_HAS_DOCK
+    if (ioptr->ConfigFlags & ImGuiConfigFlags_ViewportsEnable) 
+    {
+      igUpdatePlatformWindows();
+      igRenderPlatformWindowsDefault(NULL, NULL);
+    }
+#endif
+    IDXGISwapChain_Present(g_pSwapChain,1, 0); // Present with vsync
+    //g_pSwapChain->Present(0, 0); // Present without vsync
+  }
+
+  // clean up
+  ImGui_ImplDX11_Shutdown();
+  ImGui_ImplGlfw_Shutdown();
+  igDestroyContext(NULL);
+	
+CleanupDeviceD3D();
+  glfwDestroyWindow(window);
+  glfwTerminate();
+
+  return 0;
+}
+
+// Helper functions to use DirectX11
+bool CreateDeviceD3D(HWND hWnd)
+{
+    // Setup swap chain
+    DXGI_SWAP_CHAIN_DESC sd;
+    ZeroMemory(&sd, sizeof(sd));
+    sd.BufferCount = 2;
+    sd.BufferDesc.Width = 0;
+    sd.BufferDesc.Height = 0;
+    sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+    sd.BufferDesc.RefreshRate.Numerator = 60;
+    sd.BufferDesc.RefreshRate.Denominator = 1;
+    sd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
+    sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+    sd.OutputWindow = hWnd;
+    sd.SampleDesc.Count = 1;
+    sd.SampleDesc.Quality = 0;
+    sd.Windowed = TRUE;
+    sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
+
+    UINT createDeviceFlags = 0;
+    //createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
+    D3D_FEATURE_LEVEL featureLevel;
+    const D3D_FEATURE_LEVEL featureLevelArray[2] = { D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_0, };
+    if (D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, createDeviceFlags, featureLevelArray, 2, D3D11_SDK_VERSION, &sd, &g_pSwapChain, &g_pd3dDevice, &featureLevel, &g_pd3dDeviceContext) != S_OK)
+        return false;
+
+    CreateRenderTarget();
+    return true;
+}
+
+void CleanupDeviceD3D()
+{
+    CleanupRenderTarget();
+    if (g_pSwapChain) { IDXGISwapChain_Release(g_pSwapChain); g_pSwapChain = NULL; }
+    if (g_pd3dDeviceContext) { ID3D11DeviceContext_Release(g_pd3dDeviceContext); g_pd3dDeviceContext = NULL; }
+    if (g_pd3dDevice) { ID3D11Device_Release(g_pd3dDevice); g_pd3dDevice = NULL; }
+}
+
+void CreateRenderTarget()
+{
+    ID3D11Resource* pBackBuffer;
+    IDXGISwapChain_GetBuffer(g_pSwapChain, 0, &IID_ID3D11Texture2D, (void**)&pBackBuffer);
+    ID3D11Device_CreateRenderTargetView(g_pd3dDevice, pBackBuffer, NULL, &g_mainRenderTargetView);
+    ID3D11Texture2D_Release(pBackBuffer);
+}
+
+void CleanupRenderTarget()
+{
+    if (g_mainRenderTargetView) { ID3D11RenderTargetView_Release(g_mainRenderTargetView); g_mainRenderTargetView = NULL; }
+}
+

backend_test/example_glfw_opengl3/CMakeLists.txt

@@ -0,0 +1,116 @@
+Project(cimgui_glfw)
+cmake_minimum_required(VERSION 3.11)
+if(WIN32) # to mingw work as all the others
+	set(CMAKE_SHARED_LIBRARY_PREFIX "")
+endif(WIN32)
+
+#run in build dir
+set (CMAKE_INSTALL_PREFIX ${CMAKE_CURRENT_BINARY_DIR})
+
+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 )
+
+
+add_compile_definitions("IMGUI_IMPL_OPENGL_LOADER_GL3W")
+
+# optional adding freetype
+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("-DIMGUI_ENABLE_FREETYPE=1")
+	add_definitions("-DIMGUI_ENABLE_STB_TRUETYPE=1")
+endif(IMGUI_FREETYPE)
+
+# opengl3
+list(APPEND IMGUI_SOURCES ${BAKENDS_FOLDER}imgui_impl_opengl3.cpp)
+include_directories(../../imgui/examples/libs/gl3w)
+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)
+
+set(GLFW_VERSION 3.4)
+include(FetchContent)
+	FetchContent_Declare(
+    glfw
+    URL https://github.com/glfw/glfw/archive/refs/tags/${GLFW_VERSION}.tar.gz)
+	#GIT_REPOSITORY https://github.com/glfw/glfw )
+
+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(BUILD_SHARED_LIBS ON CACHE BOOL "" FORCE)
+	endif()
+	add_subdirectory(${glfw_SOURCE_DIR} ${glfw_BINARY_DIR} EXCLUDE_FROM_ALL)
+endif()
+
+#if dynamic glfw then install
+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" REQUIRED)
+
+
+if (NOT STATIC_BUILD)
+  add_library(cimgui SHARED ${IMGUI_SOURCES})
+else()
+  add_library(cimgui STATIC ${IMGUI_SOURCES})
+endif()
+
+if (WIN32)
+    target_compile_definitions(cimgui PUBLIC "-DIMGUI_IMPL_API=extern \"C\" __declspec\(dllexport\)")
+else(WIN32)
+    target_compile_definitions(cimgui PUBLIC "-DIMGUI_IMPL_API=extern \"C\" ")
+endif(WIN32)
+
+target_link_libraries(cimgui ${IMGUI_LIBRARIES} glfw)
+
+
+# using library
+add_executable(${PROJECT_NAME} main.c)
+target_compile_definitions(${PROJECT_NAME} PUBLIC -DCIMGUI_USE_OPENGL3 -DCIMGUI_USE_GLFW)
+target_link_libraries(${PROJECT_NAME} cimgui)
+
+

backend_test/example_glfw_opengl3/README.md

@@ -0,0 +1,4 @@
+
+To build use `cmake path_to_example_glfw_opengl3` and then `make install`
+
+`STATIC_BUILD` is a cmake variable if you want to do static linking.

backend_test/example_glfw_opengl3/main.c

@@ -0,0 +1,181 @@
+#define CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+#include "cimgui.h"
+#include "cimgui_impl.h"
+#include <GLFW/glfw3.h>
+#include <stdio.h>
+#ifdef _MSC_VER
+#include <windows.h>
+#endif
+#include <GL/gl.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
+
+GLFWwindow *window;
+
+int main(int argc, char *argv[])
+{
+
+  if (!glfwInit())
+    return -1;
+
+  // Decide GL+GLSL versions
+  glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE);
+  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
+
+#if __APPLE__
+  // GL 3.2 Core + GLSL 150
+  const char *glsl_version = "#version 150";
+#else
+  // GL 3.2 + GLSL 130
+  const char *glsl_version = "#version 130";
+#endif
+
+  // 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);
+
+  if (!window) 
+  {
+    printf("Failed to create window! Terminating!\n");
+    glfwTerminate();
+    return -1;
+  }
+
+  glfwMakeContextCurrent(window);
+
+  // enable vsync
+  glfwSwapInterval(1);
+
+  // check opengl version sdl uses
+  printf("opengl version: %s\n", (char *)glGetString(GL_VERSION));
+
+  // setup imgui
+  igCreateContext(NULL);
+
+  // set docking
+  ImGuiIO *ioptr = igGetIO();
+  ioptr->ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;   // Enable Keyboard Controls
+  //ioptr->ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;  // Enable Gamepad Controls
+#ifdef IMGUI_HAS_DOCK
+  ioptr->ConfigFlags |= ImGuiConfigFlags_DockingEnable;       // Enable Docking
+  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);
+
+  igStyleColorsDark(NULL);
+  // ImFontAtlas_AddFontDefault(io.Fonts, NULL);
+
+  bool showDemoWindow = true;
+  bool showAnotherWindow = false;
+  ImVec4 clearColor;
+  clearColor.x = 0.45f;
+  clearColor.y = 0.55f;
+  clearColor.z = 0.60f;
+  clearColor.w = 1.00f;
+
+  // main event loop
+  bool quit = false;
+  while (!glfwWindowShouldClose(window))
+  {
+
+    glfwPollEvents();
+
+    // start imgui frame
+    ImGui_ImplOpenGL3_NewFrame();
+    ImGui_ImplGlfw_NewFrame();
+    igNewFrame();
+
+    if (showDemoWindow)
+      igShowDemoWindow(&showDemoWindow);
+
+    // show a simple window that we created ourselves.
+    {
+      static float f = 0.0f;
+      static int counter = 0;
+
+      igBegin("Hello, world!", NULL, 0);
+      igText("This is some useful text");
+      igCheckbox("Demo window", &showDemoWindow);
+      igCheckbox("Another window", &showAnotherWindow);
+
+      igSliderFloat("Float", &f, 0.0f, 1.0f, "%.3f", 0);
+      igColorEdit3("clear color", (float *)&clearColor, 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();
+    }
+
+    if (showAnotherWindow) 
+    {
+      igBegin("imgui Another Window", &showAnotherWindow, 0);
+      igText("Hello from imgui");
+      ImVec2 buttonSize;
+      buttonSize.x = 0;
+      buttonSize.y = 0;
+      if (igButton("Close me", buttonSize)) {
+        showAnotherWindow = false;
+      }
+      igEnd();
+    }
+
+    // render
+    igRender();
+    glfwMakeContextCurrent(window);
+    glViewport(0, 0, (int)ioptr->DisplaySize.x, (int)ioptr->DisplaySize.y);
+    glClearColor(clearColor.x, clearColor.y, clearColor.z, clearColor.w);
+    glClear(GL_COLOR_BUFFER_BIT);
+    ImGui_ImplOpenGL3_RenderDrawData(igGetDrawData());
+#ifdef IMGUI_HAS_DOCK
+    if (ioptr->ConfigFlags & ImGuiConfigFlags_ViewportsEnable) 
+    {
+      GLFWwindow *backup_current_window = glfwGetCurrentContext();
+      igUpdatePlatformWindows();
+      igRenderPlatformWindowsDefault(NULL, NULL);
+      glfwMakeContextCurrent(backup_current_window);
+    }
+#endif
+    glfwSwapBuffers(window);
+  }
+
+  // clean up
+  ImGui_ImplOpenGL3_Shutdown();
+  ImGui_ImplGlfw_Shutdown();
+  igDestroyContext(NULL);
+
+  glfwDestroyWindow(window);
+  glfwTerminate();
+
+  return 0;
+}

backend_test/example_sdl3_vulkan/CMakeLists.txt

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

backend_test/example_sdl3_vulkan/README.md

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

backend_test/example_sdl3_vulkan/main.c

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

backend_test/example_sdl_opengl3/CMakeLists.txt

@@ -0,0 +1,105 @@
+Project(cimgui_sdl)
+cmake_minimum_required(VERSION 2.8)
+if(WIN32) #to mingw work as all the others
+set(CMAKE_SHARED_LIBRARY_PREFIX "")
+endif(WIN32)
+
+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)
+
+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_SOURCES_sdl)
+set(IMGUI_LIBRARIES )
+
+
+
+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)
+
+#opengl3
+list(APPEND IMGUI_SOURCES ${BAKENDS_FOLDER}imgui_impl_opengl3.cpp)
+include_directories(../../imgui/examples/libs/gl3w)
+if(WIN32)
+       list(APPEND IMGUI_LIBRARIES opengl32)
+else(WIN32)#Unix
+       list(APPEND IMGUI_LIBRARIES GL)
+endif(WIN32)
+
+
+list(APPEND IMGUI_SOURCES ${BAKENDS_FOLDER}imgui_impl_sdl2.cpp)
+include(FetchContent)
+Set(FETCHCONTENT_QUIET FALSE)
+
+FetchContent_Declare(
+        SDL2
+        GIT_REPOSITORY https://github.com/libsdl-org/SDL.git
+        GIT_TAG release-2.30.12
+        #GIT_SHALLOW TRUE
+        GIT_PROGRESS TRUE
+)
+#FetchContent_MakeAvailable(SDL2)
+FetchContent_GetProperties(SDL2)
+if (NOT sdl2_POPULATED)
+	set(FETCHCONTENT_QUIET NO)
+    FetchContent_Populate(SDL2)
+	set(SDL_TEST OFF CACHE BOOL "" FORCE)
+	set(BUILD_SHARED_LIBS ON CACHE BOOL "" FORCE)
+	add_subdirectory(${sdl2_SOURCE_DIR} ${sdl2_BINARY_DIR})
+endif()
+include_directories(${SDL2_SOURCE_DIR}/include})
+
+#if dynamic SDL2 then install
+install(TARGETS SDL2 RUNTIME DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
+					LIBRARY DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
+)
+
+add_library(cimgui_sdl SHARED ${IMGUI_SOURCES})
+target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
+if (WIN32)
+    target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_IMPL_API=extern \"C\" __declspec\(dllexport\)")
+else(WIN32)
+    target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_IMPL_API=extern \"C\" ")
+endif(WIN32)
+target_link_libraries(cimgui_sdl ${IMGUI_LIBRARIES} SDL2)
+
+#using library
+add_executable(test_sdl main.c)
+target_compile_definitions(test_sdl PUBLIC -DCIMGUI_USE_OPENGL3 -DCIMGUI_USE_SDL2)
+if (MINGW)
+target_link_options(test_sdl PRIVATE "-mconsole")
+endif()
+target_link_libraries(test_sdl SDL2 cimgui_sdl)

backend_test/example_sdl_opengl3/README.md

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

backend_test/example_sdl_opengl3/main.c

@@ -1,6 +1,5 @@
 #define CIMGUI_DEFINE_ENUMS_AND_STRUCTS
 #include "cimgui.h"
-#include "cimgui_extras.h"
 #include "cimgui_impl.h"
 #include <stdio.h>
 #define SDL_MAIN_HANDLED
@@ -11,18 +10,27 @@
 #include <GL/gl.h>
 #include <GL/glu.h>
 
-#ifdef IMGUI_HAS_IMSTR
+#ifdef _WIN32
-#define igBegin igBegin_Strv
+#include <windows.h>        // SetProcessDPIAware()
-#define igSliderFloat igSliderFloat_Strv
-#define igCheckbox igCheckbox_Strv
-#define igColorEdit3 igColorEdit3_Strv
-#define igButton igButton_Strv
 #endif
 
+#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
+
 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());
@@ -53,11 +61,10 @@ int main(int argc, char* argv[])
   SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
   SDL_DisplayMode current;
   SDL_GetCurrentDisplayMode(0, &current);
-  
+  float main_scale = ImGui_ImplSDL2_GetContentScaleForDisplay(0);
-  window = SDL_CreateWindow(
+  SDL_WindowFlags window_flags = (SDL_WindowFlags)(SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
-      "Hello", 0, 0, 1024, 768,
+  window = SDL_CreateWindow("Dear ImGui SDL2+OpenGL3 example", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, (int)(1280 * main_scale), (int)(720 * main_scale), window_flags);
-      SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE
+ 
-      );
   if (window == NULL) {
     SDL_Log("Failed to create window: %s", SDL_GetError());
     return -1;
@@ -66,13 +73,6 @@ int main(int argc, char* argv[])
   SDL_GLContext gl_context = SDL_GL_CreateContext(window);
   SDL_GL_SetSwapInterval(1);  // enable vsync
 
-  // Initialize OpenGL loader for cimgui_sdl
-  bool err = Do_gl3wInit() != 0;
-  if (err)
-  {
-    SDL_Log("Failed to initialize OpenGL loader for cimgui_sdl!");
-    return 1;
-  }
 
   // check opengl version sdl uses
   SDL_Log("opengl version: %s", (char*)glGetString(GL_VERSION));
@@ -89,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);
 
@@ -122,7 +130,7 @@ int main(int argc, char* argv[])
     
     // start imgui frame
     ImGui_ImplOpenGL3_NewFrame();
-    ImGui_ImplSDL2_NewFrame(window);
+    ImGui_ImplSDL2_NewFrame();
     igNewFrame();
 
     if (showDemoWindow)

backend_test/example_sdl_vulkan/CMakeLists.txt

@@ -0,0 +1,100 @@
+Project(cimgui_sdl_vk)
+cmake_minimum_required(VERSION 2.8)
+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})
+
+#sdl2
+list(APPEND IMGUI_SOURCES ${BACKENDS_FOLDER}imgui_impl_sdl2.cpp)
+include(FetchContent)
+Set(FETCHCONTENT_QUIET FALSE)
+
+FetchContent_Declare(
+        SDL2
+        GIT_REPOSITORY https://github.com/libsdl-org/SDL.git
+        GIT_TAG release-2.30.12
+        #GIT_SHALLOW TRUE
+        GIT_PROGRESS TRUE
+)
+FetchContent_GetProperties(SDL2)
+if (NOT sdl2_POPULATED)
+	set(FETCHCONTENT_QUIET NO)
+    FetchContent_Populate(SDL2)
+	set(SDL_TEST OFF CACHE BOOL "" FORCE)
+	set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
+	add_subdirectory(${sdl2_SOURCE_DIR} ${sdl2_BINARY_DIR})
+endif()
+include_directories(${SDL2_SOURCE_DIR}/include)
+
+
+#if dynamic SDL2 then install
+# install(TARGETS SDL2 RUNTIME DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
+					# LIBRARY DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
+# )
+
+add_library(cimgui_sdl STATIC ${IMGUI_SOURCES})
+target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_USER_CONFIG=\"../cimconfig.h\"")
+target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_DISABLE_OBSOLETE_FUNCTIONS=1")
+target_compile_definitions(cimgui_sdl PUBLIC -DCIMGUI_USE_VULKAN -DCIMGUI_USE_SDL2)
+if (WIN32)
+    target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_IMPL_API=extern \"C\" __declspec\(dllexport\)")
+else(WIN32)
+    target_compile_definitions(cimgui_sdl PUBLIC "-DIMGUI_IMPL_API=extern \"C\" ")
+endif(WIN32)
+#target_link_libraries(cimgui_sdl ${IMGUI_LIBRARIES} SDL2-static)
+
+#using library
+add_executable(test_sdl main.c)
+target_compile_definitions(test_sdl PUBLIC -DCIMGUI_USE_VULKAN -DCIMGUI_USE_SDL2)
+if (MINGW)
+target_link_options(test_sdl PRIVATE "-mconsole")
+endif()
+target_link_libraries(test_sdl SDL2-static cimgui_sdl ${IMGUI_LIBRARIES})
+

backend_test/example_sdl_vulkan/README.md

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

backend_test/example_sdl_vulkan/main.c

@@ -0,0 +1,625 @@
+#include <stdio.h>          // printf, fprintf
+#include <stdlib.h>         // abort
+#include <assert.h>
+#define SDL_MAIN_HANDLED
+#include <SDL.h>
+#include <SDL_vulkan.h>
+#include <vulkan/vulkan.h>
+// Volk headers
+#ifdef IMGUI_IMPL_VULKAN_USE_VOLK
+#define VOLK_IMPLEMENTATION
+#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
+
+#define CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+#include "cimgui.h"
+#include "cimgui_impl.h"
+
+#ifdef IMGUI_HAS_IMSTR
+#define igBegin igBegin_Str
+#define igSliderFloat igSliderFloat_Str
+#define igCheckbox igCheckbox_Str
+#define igColorEdit3 igColorEdit3_Str
+#define igButton igButton_Str
+#endif
+
+#define igGetIO igGetIO_Nil
+
+#define IM_UNUSED(_VAR)  ((void)(_VAR))
+#define IM_ASSERT(_EXPR) assert(_EXPR)
+#define IM_ARRAYSIZE(_ARR) ((int)(sizeof(_ARR) / sizeof(*(_ARR))))
+
+//#define APP_USE_UNLIMITED_FRAME_RATE
+#ifdef _DEBUG
+#define APP_USE_VULKAN_DEBUG_REPORT
+#endif
+#define APP_USE_VULKAN_DEBUG_REPORT
+// Data
+static VkAllocationCallbacks*   g_Allocator = NULL;
+static VkInstance               g_Instance = VK_NULL_HANDLE;
+static VkPhysicalDevice         g_PhysicalDevice = VK_NULL_HANDLE;
+static VkDevice                 g_Device = VK_NULL_HANDLE;
+static uint32_t                 g_QueueFamily = (uint32_t)-1;
+static VkQueue                  g_Queue = VK_NULL_HANDLE;
+static VkDebugReportCallbackEXT g_DebugReport = VK_NULL_HANDLE;
+static VkPipelineCache          g_PipelineCache = VK_NULL_HANDLE;
+static VkDescriptorPool         g_DescriptorPool = VK_NULL_HANDLE;
+
+static ImGui_ImplVulkanH_Window g_MainWindowData;
+static uint32_t                 g_MinImageCount = 2;
+static bool                     g_SwapChainRebuild = false;
+
+static void check_vk_result(VkResult err)
+{
+    if (err == VK_SUCCESS)
+        return;
+    fprintf(stderr, "[vulkan] Error: VkResult = %d\n", err);
+    if (err < 0)
+        abort();
+}
+
+static void check_vk_result_line(VkResult err,int line)
+{
+    if (err == VK_SUCCESS)
+        return;
+    fprintf(stderr, "[vulkan] Error: VkResult = %d in line: (%d)\n", err, line);
+    if (err < 0)
+        abort();
+}
+
+#ifdef APP_USE_VULKAN_DEBUG_REPORT
+static VKAPI_ATTR VkBool32 VKAPI_CALL debug_report(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, void* pUserData)
+{
+    (void)flags; (void)object; (void)location; (void)messageCode; (void)pUserData; (void)pLayerPrefix; // Unused arguments
+    fprintf(stderr, "[vulkan] Debug report from ObjectType: %i\nMessage: %s\n\n", objectType, pMessage);
+    return VK_FALSE;
+}
+#endif // APP_USE_VULKAN_DEBUG_REPORT
+//*
+static bool IsExtensionAvailable(VkExtensionProperties* properties, uint32_t properties_count, const char* extension)
+{
+    for(uint32_t i = 0 ; i < properties_count; i++){
+        if (strcmp(properties[i].extensionName, extension) == 0)
+            return true;
+    }
+    return false;
+}
+
+static void SetupVulkan(const char** extensions, uint32_t extensions_count)
+{
+    VkResult err;
+#ifdef IMGUI_IMPL_VULKAN_USE_VOLK
+    volkInitialize();
+#endif
+
+    // Create Vulkan Instance
+    {
+        VkInstanceCreateInfo create_info = {};
+        create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+
+        // Enumerate available extensions
+        uint32_t properties_count;
+        vkEnumerateInstanceExtensionProperties(NULL, &properties_count, NULL);
+        VkExtensionProperties* properties = (VkExtensionProperties*)malloc(properties_count * sizeof(VkExtensionProperties));
+        err = vkEnumerateInstanceExtensionProperties(NULL, &properties_count, properties);
+        check_vk_result_line(err, __LINE__);
+
+        // Enable required extensions
+        if (IsExtensionAvailable(properties, properties_count, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)){
+            //instance_extensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+            extensions_count++;
+            extensions = realloc(extensions, extensions_count * sizeof(char*));
+            assert(extensions);
+            extensions[extensions_count-1] = VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME;
+        }
+#ifdef VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME
+        if (IsExtensionAvailable(properties, properties_count, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME))
+        {
+            //instance_extensions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
+            extensions_count++;
+            extensions = realloc(extensions, extensions_count * sizeof(char*));
+            assert(extensions);
+            extensions[extensions_count-1] = VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME;
+            create_info.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
+        }
+#endif
+        free(properties);
+        // Enabling validation layers
+#ifdef APP_USE_VULKAN_DEBUG_REPORT
+        const char* layers[] = { "VK_LAYER_KHRONOS_validation" };
+        create_info.enabledLayerCount = 1;
+        create_info.ppEnabledLayerNames = layers;
+        //instance_extensions.push_back("VK_EXT_debug_report");
+        extensions_count++;
+        extensions = realloc(extensions, extensions_count * sizeof(char*));
+        assert(extensions);
+        extensions[extensions_count-1] = "VK_EXT_debug_report";
+#endif
+
+        // Create Vulkan Instance
+        create_info.enabledExtensionCount = extensions_count;//(uint32_t)instance_extensions.Size;
+        create_info.ppEnabledExtensionNames = extensions;//instance_extensions.Data;
+        err = vkCreateInstance(&create_info, g_Allocator, &g_Instance);
+        check_vk_result_line(err, __LINE__);
+#ifdef IMGUI_IMPL_VULKAN_USE_VOLK
+        volkLoadInstance(g_Instance);
+#endif
+
+        // Setup the debug report callback
+#ifdef APP_USE_VULKAN_DEBUG_REPORT
+        PFN_vkCreateDebugReportCallbackEXT f_vkCreateDebugReportCallbackEXT = (PFN_vkCreateDebugReportCallbackEXT)vkGetInstanceProcAddr(g_Instance, "vkCreateDebugReportCallbackEXT");
+        IM_ASSERT(f_vkCreateDebugReportCallbackEXT != NULL);
+        VkDebugReportCallbackCreateInfoEXT debug_report_ci = {};
+        debug_report_ci.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
+        debug_report_ci.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT | VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT;
+        debug_report_ci.pfnCallback = debug_report;
+        debug_report_ci.pUserData = NULL;
+        err = f_vkCreateDebugReportCallbackEXT(g_Instance, &debug_report_ci, g_Allocator, &g_DebugReport);
+        check_vk_result_line(err, __LINE__);
+#endif
+    }
+    // Select Physical Device (GPU)
+    g_PhysicalDevice = ImGui_ImplVulkanH_SelectPhysicalDevice(g_Instance);
+    IM_ASSERT(g_PhysicalDevice != VK_NULL_HANDLE);
+    // Select graphics queue family
+    g_QueueFamily = ImGui_ImplVulkanH_SelectQueueFamilyIndex(g_PhysicalDevice);
+    IM_ASSERT(g_QueueFamily != (uint32_t)-1);
+
+    // Create Logical Device (with 1 queue)
+    {
+        //ImVector<const char*> device_extensions;
+        //device_extensions.push_back("VK_KHR_swapchain");
+        uint32_t device_extensions_count = 1;
+        const char** device_extensions = (const char**)malloc(device_extensions_count * sizeof(char*));
+        device_extensions[0] = "VK_KHR_swapchain";
+
+        // Enumerate physical device extension
+        uint32_t properties_count;
+        //ImVector<VkExtensionProperties> properties;
+        vkEnumerateDeviceExtensionProperties(g_PhysicalDevice, NULL, &properties_count, NULL);
+        //properties.resize(properties_count);
+        VkExtensionProperties* properties = (VkExtensionProperties*)malloc(properties_count * sizeof(VkExtensionProperties));
+        vkEnumerateDeviceExtensionProperties(g_PhysicalDevice, NULL, &properties_count, properties);
+#ifdef VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME
+        if (IsExtensionAvailable(properties, properties_count, VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME)){
+            //device_extensions.push_back(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME);
+            device_extensions_count++;
+            device_extensions = realloc(device_extensions, device_extensions_count * sizeof(const char*)); 
+            assert(device_extensions);
+            device_extensions[device_extensions_count-1] = VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME;
+        }
+#endif
+
+        const float queue_priority[] = { 1.0f };
+        VkDeviceQueueCreateInfo queue_info[1] = {};
+        queue_info[0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+        queue_info[0].queueFamilyIndex = g_QueueFamily;
+        queue_info[0].queueCount = 1;
+        queue_info[0].pQueuePriorities = queue_priority;
+        VkDeviceCreateInfo create_info = {};
+        create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+        create_info.queueCreateInfoCount = sizeof(queue_info) / sizeof(queue_info[0]);
+        create_info.pQueueCreateInfos = queue_info;
+        create_info.enabledExtensionCount = device_extensions_count; //(uint32_t)device_extensions.Size;
+        create_info.ppEnabledExtensionNames = device_extensions;//device_extensions.Data;
+        err = vkCreateDevice(g_PhysicalDevice, &create_info, g_Allocator, &g_Device);
+        check_vk_result_line(err, __LINE__);
+        vkGetDeviceQueue(g_Device, g_QueueFamily, 0, &g_Queue);
+    }
+    // Create Descriptor Pool
+    // If you wish to load e.g. additional textures you may need to alter pools sizes and maxSets.
+    {
+        VkDescriptorPoolSize pool_sizes[] =
+        {
+            { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, IMGUI_IMPL_VULKAN_MINIMUM_IMAGE_SAMPLER_POOL_SIZE },
+        };
+        VkDescriptorPoolCreateInfo pool_info = {};
+        pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+        pool_info.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
+        pool_info.maxSets = 0;
+        //for (VkDescriptorPoolSize& pool_size : pool_sizes)
+        //    pool_info.maxSets += pool_size.descriptorCount;
+        for(int i = 0; i < IM_ARRAYSIZE(pool_sizes); i++){
+            VkDescriptorPoolSize pool_size = pool_sizes[i];
+            pool_info.maxSets += pool_size.descriptorCount;
+        }
+        pool_info.poolSizeCount = (uint32_t)IM_ARRAYSIZE(pool_sizes);
+        pool_info.pPoolSizes = pool_sizes;
+        err = vkCreateDescriptorPool(g_Device, &pool_info, g_Allocator, &g_DescriptorPool);
+        check_vk_result_line(err, __LINE__);
+    }
+}
+//*/
+// All the ImGui_ImplVulkanH_XXX structures/functions are optional helpers used by the demo.
+// Your real engine/app may not use them.
+static void SetupVulkanWindow(ImGui_ImplVulkanH_Window* wd, VkSurfaceKHR surface, int width, int height)
+{
+    wd->Surface = surface;
+
+    // Check for WSI support
+    VkBool32 res;
+    vkGetPhysicalDeviceSurfaceSupportKHR(g_PhysicalDevice, g_QueueFamily, wd->Surface, &res);
+    if (res != VK_TRUE)
+    {
+        fprintf(stderr, "Error no WSI support on physical device 0\n");
+        exit(-1);
+    }
+
+    // Select Surface Format
+    const VkFormat requestSurfaceImageFormat[] = { VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_B8G8R8_UNORM, VK_FORMAT_R8G8B8_UNORM };
+    const VkColorSpaceKHR requestSurfaceColorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
+    wd->SurfaceFormat = ImGui_ImplVulkanH_SelectSurfaceFormat(g_PhysicalDevice, wd->Surface, requestSurfaceImageFormat, (size_t)IM_ARRAYSIZE(requestSurfaceImageFormat), requestSurfaceColorSpace);
+
+    // Select Present Mode
+#ifdef APP_USE_UNLIMITED_FRAME_RATE
+    VkPresentModeKHR present_modes[] = { VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_FIFO_KHR };
+#else
+    VkPresentModeKHR present_modes[] = { VK_PRESENT_MODE_FIFO_KHR };
+#endif
+    wd->PresentMode = ImGui_ImplVulkanH_SelectPresentMode(g_PhysicalDevice, wd->Surface, &present_modes[0], IM_ARRAYSIZE(present_modes));
+    //printf("[vulkan] Selected PresentMode = %d\n", wd->PresentMode);
+
+    // Create SwapChain, RenderPass, Framebuffer, etc.
+    IM_ASSERT(g_MinImageCount >= 2);
+    ImGui_ImplVulkanH_CreateOrResizeWindow(g_Instance, g_PhysicalDevice, g_Device, wd, g_QueueFamily, g_Allocator, width, height, g_MinImageCount);
+}
+
+static void CleanupVulkan()
+{
+    vkDestroyDescriptorPool(g_Device, g_DescriptorPool, g_Allocator);
+
+#ifdef APP_USE_VULKAN_DEBUG_REPORT
+    // Remove the debug report callback
+    PFN_vkDestroyDebugReportCallbackEXT f_vkDestroyDebugReportCallbackEXT = (PFN_vkDestroyDebugReportCallbackEXT)vkGetInstanceProcAddr(g_Instance, "vkDestroyDebugReportCallbackEXT");
+    f_vkDestroyDebugReportCallbackEXT(g_Instance, g_DebugReport, g_Allocator);
+#endif // APP_USE_VULKAN_DEBUG_REPORT
+
+    vkDestroyDevice(g_Device, g_Allocator);
+    vkDestroyInstance(g_Instance, g_Allocator);
+}
+
+static void CleanupVulkanWindow()
+{
+    ImGui_ImplVulkanH_DestroyWindow(g_Instance, g_Device, &g_MainWindowData, g_Allocator);
+}
+
+static void FrameRender(ImGui_ImplVulkanH_Window* wd, ImDrawData* draw_data)
+{
+    VkSemaphore image_acquired_semaphore  = wd->FrameSemaphores.Data[wd->SemaphoreIndex].ImageAcquiredSemaphore;
+    VkSemaphore render_complete_semaphore = wd->FrameSemaphores.Data[wd->SemaphoreIndex].RenderCompleteSemaphore;
+    VkResult err = vkAcquireNextImageKHR(g_Device, wd->Swapchain, UINT64_MAX, image_acquired_semaphore, VK_NULL_HANDLE, &wd->FrameIndex);
+    if (err == VK_ERROR_OUT_OF_DATE_KHR || err == VK_SUBOPTIMAL_KHR)
+        g_SwapChainRebuild = true;
+    if (err == VK_ERROR_OUT_OF_DATE_KHR)
+        return;
+    if (err != VK_SUBOPTIMAL_KHR)
+        check_vk_result_line(err, __LINE__);
+
+    ImGui_ImplVulkanH_Frame* fd = &wd->Frames.Data[wd->FrameIndex];
+    {
+        err = vkWaitForFences(g_Device, 1, &fd->Fence, VK_TRUE, UINT64_MAX);    // wait indefinitely instead of periodically checking
+        check_vk_result_line(err, __LINE__);
+
+        err = vkResetFences(g_Device, 1, &fd->Fence);
+        check_vk_result_line(err, __LINE__);
+    }
+    {
+        err = vkResetCommandPool(g_Device, fd->CommandPool, 0);
+        check_vk_result_line(err, __LINE__);
+        VkCommandBufferBeginInfo info = {};
+        info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+        info.flags |= VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+        err = vkBeginCommandBuffer(fd->CommandBuffer, &info);
+        check_vk_result_line(err, __LINE__);
+    }
+    {
+        VkRenderPassBeginInfo info = {};
+        info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
+        info.renderPass = wd->RenderPass;
+        info.framebuffer = fd->Framebuffer;
+        info.renderArea.extent.width = wd->Width;
+        info.renderArea.extent.height = wd->Height;
+        info.clearValueCount = 1;
+        info.pClearValues = &wd->ClearValue;
+        vkCmdBeginRenderPass(fd->CommandBuffer, &info, VK_SUBPASS_CONTENTS_INLINE);
+    }
+
+    // Record dear imgui primitives into command buffer
+    ImGui_ImplVulkan_RenderDrawData(draw_data, fd->CommandBuffer, VK_NULL_HANDLE);
+
+    // Submit command buffer
+    vkCmdEndRenderPass(fd->CommandBuffer);
+    {
+        VkPipelineStageFlags wait_stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+        VkSubmitInfo info = {};
+        info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+        info.waitSemaphoreCount = 1;
+        info.pWaitSemaphores = &image_acquired_semaphore;
+        info.pWaitDstStageMask = &wait_stage;
+        info.commandBufferCount = 1;
+        info.pCommandBuffers = &fd->CommandBuffer;
+        info.signalSemaphoreCount = 1;
+        info.pSignalSemaphores = &render_complete_semaphore;
+
+        err = vkEndCommandBuffer(fd->CommandBuffer);
+        check_vk_result_line(err, __LINE__);
+        err = vkQueueSubmit(g_Queue, 1, &info, fd->Fence);
+        check_vk_result_line(err, __LINE__);
+    }
+}
+
+static void FramePresent(ImGui_ImplVulkanH_Window* wd)
+{
+    if (g_SwapChainRebuild)
+        return;
+    VkSemaphore render_complete_semaphore = wd->FrameSemaphores.Data[wd->SemaphoreIndex].RenderCompleteSemaphore;
+    VkPresentInfoKHR info = {};
+    info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
+    info.waitSemaphoreCount = 1;
+    info.pWaitSemaphores = &render_complete_semaphore;
+    info.swapchainCount = 1;
+    info.pSwapchains = &wd->Swapchain;
+    info.pImageIndices = &wd->FrameIndex;
+    VkResult err = vkQueuePresentKHR(g_Queue, &info);
+    if (err == VK_ERROR_OUT_OF_DATE_KHR || err == VK_SUBOPTIMAL_KHR)
+        g_SwapChainRebuild = true;
+    if (err == VK_ERROR_OUT_OF_DATE_KHR)
+        return;
+    if (err != VK_SUBOPTIMAL_KHR)
+        check_vk_result_line(err, __LINE__);
+    wd->SemaphoreIndex = (wd->SemaphoreIndex + 1) % wd->SemaphoreCount; // Now we can use the next set of semaphores
+}
+
+// Main code
+int main(int argc, char* argv[])
+{
+#ifdef _WIN32
+    SetProcessDPIAware();
+#endif
+    //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_TIMER | SDL_INIT_GAMECONTROLLER) != 0)
+    {
+        printf("Error: %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
+
+    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, (int)(1280 * main_scale), (int)(720 * main_scale), window_flags);
+    
+    if (window == NULL)
+    {
+        printf("Error: SDL_CreateWindow(): %s\n", SDL_GetError());
+        return -1;
+    }
+  // Setup Vulkan
+  uint32_t extensions_count = 0;
+  SDL_Vulkan_GetInstanceExtensions(window, &extensions_count, NULL);
+  const char** extensions = (const char**)malloc(extensions_count * sizeof(const char*));
+  SDL_Vulkan_GetInstanceExtensions(window, &extensions_count, extensions);
+  SetupVulkan(extensions, extensions_count);
+  //leak?? but free crashes
+  // free(extensions);
+    // Create Window Surface
+    VkSurfaceKHR surface;
+    VkResult err;
+    if (SDL_Vulkan_CreateSurface(window, g_Instance, &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);
+
+    // 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();
+    if (io->ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+    {
+        style->WindowRounding = 0.0f;
+        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 = {};
+    init_info.Instance = g_Instance;
+    init_info.PhysicalDevice = g_PhysicalDevice;
+    init_info.Device = g_Device;
+    init_info.QueueFamily = g_QueueFamily;
+    init_info.Queue = g_Queue;
+    init_info.PipelineCache = g_PipelineCache;
+    init_info.DescriptorPool = g_DescriptorPool;
+    init_info.RenderPass = wd->RenderPass;
+    init_info.Subpass = 0;
+    init_info.MinImageCount = g_MinImageCount;
+    init_info.ImageCount = wd->ImageCount;
+    init_info.MSAASamples = VK_SAMPLE_COUNT_1_BIT;
+    init_info.Allocator = g_Allocator;
+    init_info.CheckVkResultFn = check_vk_result;
+    ImGui_ImplVulkan_Init(&init_info);
+
+    // Load Fonts
+    // - If no fonts are loaded, dear imgui will use the default font. You can also load multiple fonts and use ImGui::PushFont()/PopFont() to select them.
+    // - AddFontFromFileTTF() will return the ImFont* so you can store it if you need to select the font among multiple.
+    // - If the file cannot be loaded, the function will return a nullptr. Please handle those errors in your application (e.g. use an assertion, or display an error and quit).
+    // - The fonts will be rasterized at a given size (w/ oversampling) and stored into a texture when calling ImFontAtlas::Build()/GetTexDataAsXXXX(), which ImGui_ImplXXXX_NewFrame below will call.
+    // - Use '#define IMGUI_ENABLE_FREETYPE' in your imconfig file to use Freetype for higher quality font rendering.
+    // - Read 'docs/FONTS.md' for more instructions and details.
+    // - Remember that in C/C++ if you want to include a backslash \ in a string literal you need to write a double backslash \\ !
+    //io.Fonts->AddFontDefault();
+    //io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\segoeui.ttf", 18.0f);
+    //io.Fonts->AddFontFromFileTTF("../../misc/fonts/DroidSans.ttf", 16.0f);
+    //io.Fonts->AddFontFromFileTTF("../../misc/fonts/Roboto-Medium.ttf", 16.0f);
+    //io.Fonts->AddFontFromFileTTF("../../misc/fonts/Cousine-Regular.ttf", 15.0f);
+    //ImFont* font = io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, nullptr, io.Fonts->GetGlyphRangesJapanese());
+    //IM_ASSERT(font != nullptr);
+
+    // Our state
+    bool show_demo_window = true;
+    bool show_another_window = false;
+    ImVec4 clear_color;
+    clear_color.x = 0.45f;
+    clear_color.y = 0.55f;
+    clear_color.z = 0.60f;
+    clear_color.w = 1.00f;
+
+    // Main loop
+    bool done = false;
+    while (!done)
+    {
+        // Poll and handle events (inputs, window resize, etc.)
+        // You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
+        // - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application, or clear/overwrite your copy of the mouse data.
+        // - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application, or clear/overwrite your copy of the keyboard data.
+        // Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
+        SDL_Event event;
+        while (SDL_PollEvent(&event))
+        {
+            ImGui_ImplSDL2_ProcessEvent(&event);
+            if (event.type == SDL_QUIT)
+                done = true;
+            if (event.type == SDL_WINDOWEVENT && event.window.event == SDL_WINDOWEVENT_CLOSE && event.window.windowID == SDL_GetWindowID(window))
+                done = true;
+        }
+        if (SDL_GetWindowFlags(window) & SDL_WINDOW_MINIMIZED)
+        {
+            SDL_Delay(10);
+            continue;
+        }
+
+        // Resize swap chain?
+        int fb_width, fb_height;
+        SDL_GetWindowSize(window, &fb_width, &fb_height);
+        if (fb_width > 0 && fb_height > 0 && (g_SwapChainRebuild || g_MainWindowData.Width != fb_width || g_MainWindowData.Height != fb_height))
+        {
+            ImGui_ImplVulkan_SetMinImageCount(g_MinImageCount);
+            ImGui_ImplVulkanH_CreateOrResizeWindow(g_Instance, g_PhysicalDevice, g_Device, &g_MainWindowData, g_QueueFamily, g_Allocator, fb_width, fb_height, g_MinImageCount);
+            g_MainWindowData.FrameIndex = 0;
+            g_SwapChainRebuild = false;
+        }
+
+        // Start the Dear ImGui frame
+        ImGui_ImplVulkan_NewFrame();
+        ImGui_ImplSDL2_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_ImplSDL2_Shutdown();
+    igDestroyContext(NULL);
+
+    CleanupVulkanWindow();
+    CleanupVulkan();
+
+    SDL_DestroyWindow(window);
+    SDL_Quit();
+
+    return 0;
+}

backend_test/example_sdlgpu3/CMakeLists.txt

@@ -0,0 +1,33 @@
+cmake_minimum_required(VERSION 3.30)
+project(cimgui_sdlgpu3 LANGUAGES C CXX)
+
+set(CMAKE_C_STANDARD 11)
+
+include(FetchContent)
+
+FetchContent_Declare(
+	sdl3
+	URL https://github.com/libsdl-org/SDL/releases/download/release-3.2.8/SDL3-3.2.8.tar.gz
+)
+
+set(SDL_TEST_LIBRARY OFF CACHE BOOL "" FORCE)
+FetchContent_MakeAvailable(sdl3)
+
+include(../cmake/GenerateCimguiBindings.cmake)
+
+set(inclulist ${sdl3_SOURCE_DIR}/include)
+GenerateCimguiBindings(cimgui_with_backend sdl3 sdlgpu3 inclulist)
+target_link_libraries(cimgui_with_backend PRIVATE SDL3::SDL3)
+
+add_executable(${PROJECT_NAME} 
+	main.c
+)
+
+target_link_libraries(${PROJECT_NAME} PRIVATE SDL3::SDL3 cimgui_with_backend)
+target_compile_definitions(
+	${PROJECT_NAME}
+	PRIVATE 
+	CIMGUI_DEFINE_ENUMS_AND_STRUCTS=1
+	CIMGUI_USE_SDL3=1
+	CIMGUI_USE_SDLGPU3=1
+)

backend_test/example_sdlgpu3/README.md

@@ -0,0 +1,16 @@
+# SDLGPU3
+
+This example is a little different from the others, because `cimgui` doesn't come with bindings for the SDLGPU3 backend out of the box. Instead, this example shows how to generate the necessary bindings during cmake's configure time, then add the compiled library as a target for your application to link to.
+
+For the generation phase from cmake you need LuaJIT to be present.
+
+## Building
+
+From the build directory of your choice:
+
+`cmake path_to_example_sdlgpu3`
+
+and after
+
+`make`
+

backend_test/example_sdlgpu3/main.c

@@ -0,0 +1,216 @@
+#include <assert.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <SDL3/SDL.h>
+#include <SDL3/SDL_gpu.h>
+
+#include <cimgui.h>
+#include <cimgui_impl.h>
+
+
+#define igGetIO igGetIO_Nil
+
+int main() {
+    if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMEPAD)) {
+      fprintf(stderr, "Failed to init video! %s", SDL_GetError());
+      return 1;
+    };
+    
+    float main_scale = SDL_GetDisplayContentScale(SDL_GetPrimaryDisplay());
+    SDL_WindowFlags window_flags = SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIDDEN | SDL_WINDOW_HIGH_PIXEL_DENSITY;
+    SDL_Window* window = NULL;
+    window = SDL_CreateWindow("Dear ImGui SDL3+SDL_GPU example", (int)(1280 * main_scale), (int)(720 * main_scale), window_flags);
+    if (window == NULL)
+    {
+        printf("Error: SDL_CreateWindow(): %s\n", SDL_GetError());
+        return -1;
+    }
+    SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
+    SDL_ShowWindow(window);
+
+    // Create GPU Device
+    SDL_GPUDevice* gpu_device = SDL_CreateGPUDevice(SDL_GPU_SHADERFORMAT_SPIRV | SDL_GPU_SHADERFORMAT_DXIL | SDL_GPU_SHADERFORMAT_METALLIB,true,NULL);
+    if (gpu_device == NULL)
+    {
+        printf("Error: SDL_CreateGPUDevice(): %s\n", SDL_GetError());
+        return -1;
+    }
+
+    // Claim window for GPU Device
+    if (!SDL_ClaimWindowForGPUDevice(gpu_device, window))
+    {
+        printf("Error: SDL_ClaimWindowForGPUDevice(): %s\n", SDL_GetError());
+        return -1;
+    }
+    SDL_SetGPUSwapchainParameters(gpu_device, window, SDL_GPU_SWAPCHAINCOMPOSITION_SDR, SDL_GPU_PRESENTMODE_MAILBOX);
+
+  // Setup Dear ImGui context
+    //IMGUI_CHECKVERSION();
+    igCreateContext(NULL);
+    ImGuiIO* io = igGetIO(); (void)io;
+    io->ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;     // Enable Keyboard Controls
+    io->ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;      // Enable Gamepad Controls
+
+    // Setup Dear ImGui style
+    igStyleColorsDark(NULL);
+    //igStyleColorsLight(NULL);
+    // Setup scaling
+    ImGuiStyle* style = igGetStyle();
+    ImGuiStyle_ScaleAllSizes(style, main_scale);        // Bake a fixed style scale. (until we have a solution for dynamic style scaling, changing this requires resetting Style + calling this again)
+    style->FontScaleDpi = main_scale;        // Set initial font scale. (using io.ConfigDpiScaleFonts=true makes this unnecessary. We leave both here for documentation purpose)
+    io->ConfigDpiScaleFonts = true;          // [Experimental] Automatically overwrite style.FontScaleDpi in Begin() when Monitor DPI changes. This will scale fonts but _NOT_ scale sizes/padding for now.
+    io->ConfigDpiScaleViewports = true;      // [Experimental] Scale Dear ImGui and Platform Windows when Monitor DPI changes.
+
+    // Setup Platform/Renderer backends
+    ImGui_ImplSDL3_InitForSDLGPU(window);
+    ImGui_ImplSDLGPU3_InitInfo init_info;//= {};
+    init_info.Device = gpu_device;
+    init_info.ColorTargetFormat = SDL_GetGPUSwapchainTextureFormat(gpu_device, window);
+    init_info.MSAASamples = SDL_GPU_SAMPLECOUNT_1;
+    ImGui_ImplSDLGPU3_Init(&init_info);
+  // finish loading data
+
+    // Our state
+    bool show_demo_window = true;
+    bool show_another_window = false;
+    ImVec4 clear_color;
+    clear_color.x = 0.45f;
+    clear_color.y = 0.55f;
+    clear_color.z = 0.60f;
+    clear_color.w = 1.00f;
+
+    // Main loop
+    bool done = false;
+    while (!done)
+    {
+        // Poll and handle events (inputs, window resize, etc.)
+        // You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
+        // - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application, or clear/overwrite your copy of the mouse data.
+        // - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application, or clear/overwrite your copy of the keyboard data.
+        // Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
+        // [If using SDL_MAIN_USE_CALLBACKS: call ImGui_ImplSDL3_ProcessEvent() from your SDL_AppEvent() function]
+        SDL_Event event;
+        while (SDL_PollEvent(&event))
+        {
+            ImGui_ImplSDL3_ProcessEvent(&event);
+            if (event.type == SDL_EVENT_QUIT)
+                done = true;
+            if (event.type == SDL_EVENT_WINDOW_CLOSE_REQUESTED && event.window.windowID == SDL_GetWindowID(window))
+                done = true;
+        }
+
+        // [If using SDL_MAIN_USE_CALLBACKS: all code below would likely be your SDL_AppIterate() function]
+        if (SDL_GetWindowFlags(window) & SDL_WINDOW_MINIMIZED)
+        {
+            SDL_Delay(10);
+            continue;
+        }
+
+        // Start the Dear ImGui frame
+        ImGui_ImplSDLGPU3_NewFrame();
+        ImGui_ImplSDL3_NewFrame();
+        igNewFrame();
+
+        // 1. Show the big demo window (Most of the sample code is in igShowDemoWindow()! You can browse its code to learn more about Dear ImGui!).
+        if (show_demo_window)
+            igShowDemoWindow(&show_demo_window);
+
+        // 2. Show a simple window that we create ourselves. We use a Begin/End pair to create a named window.
+        {
+            static float f = 0.0f;
+            static int counter = 0;
+
+            igBegin("Hello, world!", NULL, 0);                          // Create a window called "Hello, world!" and append into it.
+
+            igText("This is some useful text.");               // Display some text (you can use a format strings too)
+            igCheckbox("Demo Window", &show_demo_window);      // Edit bools storing our window open/close state
+            igCheckbox("Another Window", &show_another_window);
+
+            igSliderFloat("float", &f, 0.0f, 1.0f, "%.3f", 0);            // Edit 1 float using a slider from 0.0f to 1.0f
+            igColorEdit4("clear color", (float*)&clear_color, 0); // Edit 3 floats representing a color
+
+            ImVec2 buttonSize;
+            buttonSize.x = 0;
+            buttonSize.y = 0;
+            if (igButton("Button", buttonSize))                            // Buttons return true when clicked (most widgets return true when edited/activated)
+                counter++;
+            igSameLine(0.0f, -1.0f);
+            igText("counter = %d", counter);
+
+            igText("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / io->Framerate, io->Framerate);
+            igEnd();
+        }
+
+        // 3. Show another simple window.
+        if (show_another_window)
+        {
+            igBegin("Another Window", &show_another_window, 0);   // Pass a pointer to our bool variable (the window will have a closing button that will clear the bool when clicked)
+            igText("Hello from another window!");
+            ImVec2 buttonSize;
+            buttonSize.x = 0; buttonSize.y = 0;
+            if (igButton("Close Me", buttonSize))
+                show_another_window = false;
+            igEnd();
+        }
+
+        // Rendering
+        igRender();
+        ImDrawData* draw_data = igGetDrawData();
+        const bool is_minimized = (draw_data->DisplaySize.x <= 0.0f || draw_data->DisplaySize.y <= 0.0f);
+
+        SDL_GPUCommandBuffer* command_buffer = SDL_AcquireGPUCommandBuffer(gpu_device); // Acquire a GPU command buffer
+
+        SDL_GPUTexture* swapchain_texture;
+        SDL_AcquireGPUSwapchainTexture(command_buffer, window, &swapchain_texture, NULL, NULL); // Acquire a swapchain texture
+
+        if (swapchain_texture != NULL && !is_minimized)
+        {
+            // This is mandatory: call Imgui_ImplSDLGPU3_PrepareDrawData() to upload the vertex/index buffer!
+            ImGui_ImplSDLGPU3_PrepareDrawData(draw_data, command_buffer);
+
+            // Setup and start a render pass
+            SDL_GPUColorTargetInfo target_info ;//= {};
+            target_info.texture = swapchain_texture;
+            target_info.clear_color.r = clear_color.x;
+			target_info.clear_color.g = clear_color.y;
+			target_info.clear_color.b = clear_color.z;
+			target_info.clear_color.a = clear_color.w;
+            target_info.load_op = SDL_GPU_LOADOP_CLEAR;
+            target_info.store_op = SDL_GPU_STOREOP_STORE;
+            target_info.mip_level = 0;
+            target_info.layer_or_depth_plane = 0;
+            target_info.cycle = false;
+			target_info.resolve_texture = NULL;
+			target_info.resolve_mip_level = 0;
+			target_info.resolve_layer = 0;
+			target_info.cycle_resolve_texture = false;
+			target_info.padding1 = 0;
+			target_info.padding2 = 0;
+            SDL_GPURenderPass* render_pass = SDL_BeginGPURenderPass(command_buffer, &target_info, 1, NULL);
+
+            // Render ImGui
+            ImGui_ImplSDLGPU3_RenderDrawData(draw_data, command_buffer, render_pass, NULL);
+
+            SDL_EndGPURenderPass(render_pass);
+        }
+
+        // Submit the command buffer
+        SDL_SubmitGPUCommandBuffer(command_buffer);
+    }
+
+    // Cleanup
+    // [If using SDL_MAIN_USE_CALLBACKS: all code below would likely be your SDL_AppQuit() function]
+    SDL_WaitForGPUIdle(gpu_device);
+    ImGui_ImplSDL3_Shutdown();
+    ImGui_ImplSDLGPU3_Shutdown();
+    igDestroyContext(NULL);
+
+    SDL_ReleaseWindowFromGPUDevice(gpu_device, window);
+    SDL_DestroyGPUDevice(gpu_device);
+    SDL_DestroyWindow(window);
+    SDL_Quit();
+
+    return 0;
+}

cimconfig.h

@@ -0,0 +1 @@
+#undef NDEBUG

cimgui_impl.cpp

@@ -0,0 +1,46 @@
+#include "./imgui/imgui.h"
+#ifdef IMGUI_ENABLE_FREETYPE
+#include "./imgui/misc/freetype/imgui_freetype.h"
+#endif
+#include "./imgui/imgui_internal.h"
+#include "cimgui.h"
+
+
+#ifdef CIMGUI_USE_GLFW
+#include "imgui_impl_glfw.h"
+#endif
+
+#ifdef CIMGUI_USE_OPENGL3
+#include "imgui_impl_opengl3.h"
+#endif
+
+#ifdef CIMGUI_USE_OPENGL2
+#include "imgui_impl_opengl2.h"
+#endif
+
+#ifdef CIMGUI_USE_SDL2
+#include "imgui_impl_sdl2.h"
+#endif
+
+#ifdef CIMGUI_USE_SDL3
+#include "imgui_impl_sdl3.h"
+#endif
+
+#ifdef CIMGUI_USE_VULKAN
+#include "imgui_impl_vulkan.h"
+#endif
+
+#include "cimgui_impl.h"
+
+#ifdef CIMGUI_USE_VULKAN
+
+CIMGUI_API ImGui_ImplVulkanH_Window* ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window()
+{
+	return IM_NEW(ImGui_ImplVulkanH_Window)();
+}
+CIMGUI_API void ImGui_ImplVulkanH_Window_Construct(ImGui_ImplVulkanH_Window* self)
+{
+	IM_PLACEMENT_NEW(self) ImGui_ImplVulkanH_Window();
+}
+
+#endif

cimgui_impl.h

@@ -0,0 +1,203 @@
+#ifndef CIMGUI_IMPL_DEFINED
+#define CIMGUI_IMPL_DEFINED
+#ifdef CIMGUI_USE_GLFW
+#ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+
+typedef struct GLFWwindow GLFWwindow;
+typedef struct GLFWmonitor GLFWmonitor;
+struct GLFWwindow;
+struct GLFWmonitor;
+#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+CIMGUI_API bool ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window,bool install_callbacks);
+CIMGUI_API bool ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window,bool install_callbacks);
+CIMGUI_API bool ImGui_ImplGlfw_InitForOther(GLFWwindow* window,bool install_callbacks);
+CIMGUI_API void ImGui_ImplGlfw_Shutdown(void);
+CIMGUI_API void ImGui_ImplGlfw_NewFrame(void);
+CIMGUI_API void ImGui_ImplGlfw_InstallCallbacks(GLFWwindow* window);
+CIMGUI_API void ImGui_ImplGlfw_RestoreCallbacks(GLFWwindow* window);
+CIMGUI_API void ImGui_ImplGlfw_SetCallbacksChainForAllWindows(bool chain_for_all_windows);
+CIMGUI_API void ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window,int focused);
+CIMGUI_API void ImGui_ImplGlfw_CursorEnterCallback(GLFWwindow* window,int entered);
+CIMGUI_API void ImGui_ImplGlfw_CursorPosCallback(GLFWwindow* window,double x,double y);
+CIMGUI_API void ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window,int button,int action,int mods);
+CIMGUI_API void ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window,double xoffset,double yoffset);
+CIMGUI_API void ImGui_ImplGlfw_KeyCallback(GLFWwindow* window,int key,int scancode,int action,int mods);
+CIMGUI_API void ImGui_ImplGlfw_CharCallback(GLFWwindow* window,unsigned int c);
+CIMGUI_API void ImGui_ImplGlfw_MonitorCallback(GLFWmonitor* monitor,int event);
+CIMGUI_API void ImGui_ImplGlfw_Sleep(int milliseconds);
+CIMGUI_API float ImGui_ImplGlfw_GetContentScaleForWindow(GLFWwindow* window);
+CIMGUI_API float ImGui_ImplGlfw_GetContentScaleForMonitor(GLFWmonitor* monitor);
+
+#endif
+#ifdef CIMGUI_USE_OPENGL3
+CIMGUI_API bool ImGui_ImplOpenGL3_Init(const char* glsl_version);
+CIMGUI_API void ImGui_ImplOpenGL3_Shutdown(void);
+CIMGUI_API void ImGui_ImplOpenGL3_NewFrame(void);
+CIMGUI_API void ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data);
+CIMGUI_API bool ImGui_ImplOpenGL3_CreateDeviceObjects(void);
+CIMGUI_API void ImGui_ImplOpenGL3_DestroyDeviceObjects(void);
+CIMGUI_API void ImGui_ImplOpenGL3_UpdateTexture(ImTextureData* tex);
+
+#endif
+#ifdef CIMGUI_USE_OPENGL2
+CIMGUI_API bool ImGui_ImplOpenGL2_Init(void);
+CIMGUI_API void ImGui_ImplOpenGL2_Shutdown(void);
+CIMGUI_API void ImGui_ImplOpenGL2_NewFrame(void);
+CIMGUI_API void ImGui_ImplOpenGL2_RenderDrawData(ImDrawData* draw_data);
+CIMGUI_API bool ImGui_ImplOpenGL2_CreateDeviceObjects(void);
+CIMGUI_API void ImGui_ImplOpenGL2_DestroyDeviceObjects(void);
+CIMGUI_API void ImGui_ImplOpenGL2_UpdateTexture(ImTextureData* tex);
+
+#endif
+#ifdef CIMGUI_USE_SDL2
+#ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+
+typedef struct SDL_Window SDL_Window;
+typedef struct SDL_Renderer SDL_Renderer;
+typedef struct _SDL_GameController _SDL_GameController;
+struct SDL_Window;
+struct SDL_Renderer;
+struct _SDL_GameController;
+typedef union SDL_Event SDL_Event;
+typedef enum { ImGui_ImplSDL2_GamepadMode_AutoFirst, ImGui_ImplSDL2_GamepadMode_AutoAll, ImGui_ImplSDL2_GamepadMode_Manual }ImGui_ImplSDL2_GamepadMode;
+#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+CIMGUI_API bool ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
+CIMGUI_API bool ImGui_ImplSDL2_InitForVulkan(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL2_InitForD3D(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL2_InitForMetal(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL2_InitForSDLRenderer(SDL_Window* window,SDL_Renderer* renderer);
+CIMGUI_API bool ImGui_ImplSDL2_InitForOther(SDL_Window* window);
+CIMGUI_API void ImGui_ImplSDL2_Shutdown(void);
+CIMGUI_API void ImGui_ImplSDL2_NewFrame(void);
+CIMGUI_API bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event);
+CIMGUI_API float ImGui_ImplSDL2_GetContentScaleForWindow(SDL_Window* window);
+CIMGUI_API float ImGui_ImplSDL2_GetContentScaleForDisplay(int display_index);
+CIMGUI_API void ImGui_ImplSDL2_SetGamepadMode(ImGui_ImplSDL2_GamepadMode mode,struct _SDL_GameController** manual_gamepads_array,int manual_gamepads_count);
+
+#endif
+#ifdef CIMGUI_USE_SDL3
+#ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+
+typedef struct SDL_Window SDL_Window;
+typedef struct SDL_Renderer SDL_Renderer;
+typedef struct SDL_Gamepad SDL_Gamepad;
+struct SDL_Window;
+struct SDL_Renderer;
+struct SDL_Gamepad;
+typedef union SDL_Event SDL_Event;
+typedef enum { ImGui_ImplSDL3_GamepadMode_AutoFirst, ImGui_ImplSDL3_GamepadMode_AutoAll, ImGui_ImplSDL3_GamepadMode_Manual }ImGui_ImplSDL3_GamepadMode;
+#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+CIMGUI_API bool ImGui_ImplSDL3_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
+CIMGUI_API bool ImGui_ImplSDL3_InitForVulkan(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL3_InitForD3D(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL3_InitForMetal(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL3_InitForSDLRenderer(SDL_Window* window,SDL_Renderer* renderer);
+CIMGUI_API bool ImGui_ImplSDL3_InitForSDLGPU(SDL_Window* window);
+CIMGUI_API bool ImGui_ImplSDL3_InitForOther(SDL_Window* window);
+CIMGUI_API void ImGui_ImplSDL3_Shutdown(void);
+CIMGUI_API void ImGui_ImplSDL3_NewFrame(void);
+CIMGUI_API bool ImGui_ImplSDL3_ProcessEvent(const SDL_Event* event);
+CIMGUI_API void ImGui_ImplSDL3_SetGamepadMode(ImGui_ImplSDL3_GamepadMode mode,SDL_Gamepad** manual_gamepads_array,int manual_gamepads_count);
+
+#endif
+#ifdef CIMGUI_USE_VULKAN
+#ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+
+typedef struct ImGui_ImplVulkanH_Frame ImGui_ImplVulkanH_Frame;
+typedef struct ImGui_ImplVulkanH_Window ImGui_ImplVulkanH_Window;
+typedef struct ImGui_ImplVulkan_InitInfo ImGui_ImplVulkan_InitInfo;
+struct ImGui_ImplVulkan_InitInfo
+{
+    uint32_t ApiVersion;
+    VkInstance Instance;
+    VkPhysicalDevice PhysicalDevice;
+    VkDevice Device;
+    uint32_t QueueFamily;
+    VkQueue Queue;
+    VkDescriptorPool DescriptorPool;
+    VkRenderPass RenderPass;
+    uint32_t MinImageCount;
+    uint32_t ImageCount;
+    VkSampleCountFlagBits MSAASamples;
+    VkPipelineCache PipelineCache;
+    uint32_t Subpass;
+    uint32_t DescriptorPoolSize;
+    bool UseDynamicRendering;
+    VkPipelineRenderingCreateInfoKHR PipelineRenderingCreateInfo;
+    const VkAllocationCallbacks* Allocator;
+    void (*CheckVkResultFn)(VkResult err);
+    VkDeviceSize MinAllocationSize;
+};
+typedef struct ImGui_ImplVulkan_RenderState ImGui_ImplVulkan_RenderState;
+struct ImGui_ImplVulkan_RenderState
+{
+    VkCommandBuffer CommandBuffer;
+    VkPipeline Pipeline;
+    VkPipelineLayout PipelineLayout;
+};
+struct ImGui_ImplVulkanH_Frame;
+struct ImGui_ImplVulkanH_Window;
+struct ImGui_ImplVulkanH_Frame
+{
+    VkCommandPool CommandPool;
+    VkCommandBuffer CommandBuffer;
+    VkFence Fence;
+    VkImage Backbuffer;
+    VkImageView BackbufferView;
+    VkFramebuffer Framebuffer;
+};
+typedef struct ImGui_ImplVulkanH_FrameSemaphores ImGui_ImplVulkanH_FrameSemaphores;
+struct ImGui_ImplVulkanH_FrameSemaphores
+{
+    VkSemaphore ImageAcquiredSemaphore;
+    VkSemaphore RenderCompleteSemaphore;
+};
+typedef struct ImVector_ImGui_ImplVulkanH_Frame {int Size;int Capacity;ImGui_ImplVulkanH_Frame* Data;} ImVector_ImGui_ImplVulkanH_Frame;
+
+typedef struct ImVector_ImGui_ImplVulkanH_FrameSemaphores {int Size;int Capacity;ImGui_ImplVulkanH_FrameSemaphores* Data;} ImVector_ImGui_ImplVulkanH_FrameSemaphores;
+
+struct ImGui_ImplVulkanH_Window
+{
+    int Width;
+    int Height;
+    VkSwapchainKHR Swapchain;
+    VkSurfaceKHR Surface;
+    VkSurfaceFormatKHR SurfaceFormat;
+    VkPresentModeKHR PresentMode;
+    VkRenderPass RenderPass;
+    VkPipeline Pipeline;
+    bool UseDynamicRendering;
+    bool ClearEnable;
+    VkClearValue ClearValue;
+    uint32_t FrameIndex;
+    uint32_t ImageCount;
+    uint32_t SemaphoreCount;
+    uint32_t SemaphoreIndex;
+    ImVector_ImGui_ImplVulkanH_Frame Frames;
+    ImVector_ImGui_ImplVulkanH_FrameSemaphores FrameSemaphores;
+};
+#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+#ifndef CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+typedef ImVector<ImGui_ImplVulkanH_Frame> ImVector_ImGui_ImplVulkanH_Frame;
+typedef ImVector<ImGui_ImplVulkanH_FrameSemaphores> ImVector_ImGui_ImplVulkanH_FrameSemaphores;
+#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+CIMGUI_API bool ImGui_ImplVulkan_Init(ImGui_ImplVulkan_InitInfo* info);
+CIMGUI_API void ImGui_ImplVulkan_Shutdown(void);
+CIMGUI_API void ImGui_ImplVulkan_NewFrame(void);
+CIMGUI_API void ImGui_ImplVulkan_RenderDrawData(ImDrawData* draw_data,VkCommandBuffer command_buffer,VkPipeline pipeline);
+CIMGUI_API void ImGui_ImplVulkan_SetMinImageCount(uint32_t min_image_count);
+CIMGUI_API void ImGui_ImplVulkan_UpdateTexture(ImTextureData* tex);
+CIMGUI_API VkDescriptorSet ImGui_ImplVulkan_AddTexture(VkSampler sampler,VkImageView image_view,VkImageLayout image_layout);
+CIMGUI_API void ImGui_ImplVulkan_RemoveTexture(VkDescriptorSet descriptor_set);
+CIMGUI_API bool ImGui_ImplVulkan_LoadFunctions(uint32_t api_version,PFN_vkVoidFunction(*loader_func)(const char* function_name,void* user_data),void* user_data);
+CIMGUI_API void ImGui_ImplVulkanH_CreateOrResizeWindow(VkInstance instance,VkPhysicalDevice physical_device,VkDevice device,ImGui_ImplVulkanH_Window* wnd,uint32_t queue_family,const VkAllocationCallbacks* allocator,int w,int h,uint32_t min_image_count);
+CIMGUI_API void ImGui_ImplVulkanH_DestroyWindow(VkInstance instance,VkDevice device,ImGui_ImplVulkanH_Window* wnd,const VkAllocationCallbacks* allocator);
+CIMGUI_API VkSurfaceFormatKHR ImGui_ImplVulkanH_SelectSurfaceFormat(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkFormat* request_formats,int request_formats_count,VkColorSpaceKHR request_color_space);
+CIMGUI_API VkPresentModeKHR ImGui_ImplVulkanH_SelectPresentMode(VkPhysicalDevice physical_device,VkSurfaceKHR surface,const VkPresentModeKHR* request_modes,int request_modes_count);
+CIMGUI_API VkPhysicalDevice ImGui_ImplVulkanH_SelectPhysicalDevice(VkInstance instance);
+CIMGUI_API uint32_t ImGui_ImplVulkanH_SelectQueueFamilyIndex(VkPhysicalDevice physical_device);
+CIMGUI_API int ImGui_ImplVulkanH_GetMinImageCountFromPresentMode(VkPresentModeKHR present_mode);
+CIMGUI_API ImGui_ImplVulkanH_Window* ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window(void);
+
+#endif
+#endif //CIMGUI_IMPL_DEFINED

generator/cimgui_impl_template.cpp

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

generator/cimgui_template.cpp

@@ -1,8 +1,5 @@
 
 #include "./imgui/imgui.h"
-#ifdef CIMGUI_FREETYPE
-#include "./imgui/misc/freetype/imgui_freetype.h"
-#endif
 #include "./imgui/imgui_internal.h"
 #include "cimgui.h"
 
@@ -12,21 +9,12 @@
 
 
 /////////////////////////////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, ...)
-}
-CIMGUI_API void ImGuiTextBuffer_appendf(struct ImGuiTextBuffer *buffer, const char *fmt, ...)
 {
     va_list args;
     va_start(args, fmt);
-    buffer->appendfv(fmt, args);
+    self->appendfv(fmt, args);
     va_end(args);
 }
 
@@ -81,7 +69,7 @@ CimguiStorage& GetCimguiStorage()
     ImGuiIO& io = ImGui::GetIO();
     if (io.BackendLanguageUserData == NULL)
     {
-        io.BackendLanguageUserData = new CimguiStorage();
+        io.BackendLanguageUserData = IM_NEW(CimguiStorage)();
     }
 
     return *(CimguiStorage*)io.BackendLanguageUserData;

generator/cimgui_template.h

@@ -8,9 +8,6 @@
     #else
         #define API __declspec(dllexport)
     #endif
-    #ifndef __GNUC__
-    #define snprintf sprintf_s
-    #endif
 #else
     #ifdef __GNUC__
         #define API  __attribute__((__visibility__("default")))
@@ -37,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"
@@ -49,21 +52,23 @@ typedef union SDL_Event SDL_Event;
 #include "auto_funcs.h"
 
 /////////////////////////hand written functions
-//no LogTextV
-CIMGUI_API void igLogText(CONST char *fmt, ...);
 //no appendfV
-CIMGUI_API void ImGuiTextBuffer_appendf(struct ImGuiTextBuffer *buffer, const char *fmt, ...);
+CIMGUI_API void ImGuiTextBuffer_appendf(ImGuiTextBuffer *self, const char *fmt, ...);
 //for getting FLT_MAX in bindings
-CIMGUI_API float igGET_FLT_MAX();
+CIMGUI_API float igGET_FLT_MAX(void);
 //for getting FLT_MIN in bindings
-CIMGUI_API float igGET_FLT_MIN();
+CIMGUI_API float igGET_FLT_MIN(void);
 
 
-CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create();
+CIMGUI_API ImVector_ImWchar* ImVector_ImWchar_create(void);
 CIMGUI_API void ImVector_ImWchar_destroy(ImVector_ImWchar* self);
 CIMGUI_API void ImVector_ImWchar_Init(ImVector_ImWchar* p);
 CIMGUI_API void ImVector_ImWchar_UnInit(ImVector_ImWchar* p);
 
+#ifdef IMGUI_HAS_DOCK
+CIMGUI_API void ImGuiPlatformIO_Set_Platform_GetWindowPos(ImGuiPlatformIO* platform_io, void(*user_callback)(ImGuiViewport* vp, ImVec2* out_pos));
+CIMGUI_API void ImGuiPlatformIO_Set_Platform_GetWindowSize(ImGuiPlatformIO* platform_io, void(*user_callback)(ImGuiViewport* vp, ImVec2* out_size));
+#endif
 
 #endif //CIMGUI_INCLUDED
 

generator/config_generator.lua

@@ -1,3 +1,3 @@
 return {
-	vulkan = {[[C:\VulkanSDK\1.1.130.0\Include]]}
+	vulkan = {(os.getenv("VULKAN_SDK") or "vulkan_SDK_not_found").."/Include"}, --{[[C:\VulkanSDK\1.3.216.0\Include]]}
-}
+} 

generator/generator.bat

@@ -15,10 +15,12 @@ set PATH=%PATH%;C:\anima;C:\mingws\i686-7.2.0-release-posix-dwarf-rt_v5-rev1\min
 :: set PATH=%PATH%;C:\luaGL\sources\luajit-master\luajit-master\bin\mingw32;C:\mingw32\bin;
 ::process  files
 :: arg[1] compiler name gcc, clang or cl
-:: arg[2] options as words in one string: internal for imgui_internal generation, freetype for freetype generation
+:: arg[2] options as words in one string: internal for imgui_internal generation, comments for comments generation, nochar to skip char* function version, noimstrv to skip imstrv
-:: examples: "" "internal" "internal freetype"
+:: "constructors" adds the _Construct version of constructors
-:: arg[3..n] name of implementations to generate and/or CFLAGS (e.g. -DIMGUI_USER_CONFIG or -DIMGUI_USE_WCHAR32)
+:: examples: "" "internal" "internal comments"
-luajit ./generator.lua gcc "internal" glfw opengl3 opengl2 sdl
+:: 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 %*
 
 ::leave console open
 cmd /k

generator/generator.lua

@@ -7,13 +7,22 @@ assert(bit,"Must use LuaJIT")
 local script_args = {...}
 local COMPILER = script_args[1]
 local INTERNAL_GENERATION = script_args[2]:match("internal") and true or false
-local FREETYPE_GENERATION = script_args[2]:match("freetype") and true or false
+local FREETYPE_GENERATION = true --script_args[2]:match("freetype") and true or false
+local COMMENTS_GENERATION = script_args[2]:match("comments") and true or false
+local CONSTRUCTORS_GENERATION = script_args[2]:match("constructors") and true or false
+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
 local implementations = {}
 for i=3,#script_args do
-    if script_args[i]:match(COMPILER == cl and "^/" or "^%-") then
+    if script_args[i]:match(COMPILER == "cl" and "^/" or "^%-") then
+		if script_args[i]:match("IMGUI_USE_WCHAR32") then
+			script_args[i] = "" --dont use this define
+		end
         local key, value = script_args[i]:match("^(.+)=(.+)$")
         if key and value then
             CFLAGS = CFLAGS .. " " .. key .. "=\"" .. value:gsub("\"", "\\\"") .. "\"";
@@ -25,11 +34,15 @@ for i=3,#script_args do
     end
 end
 
-if COMPILER == "gcc" or COMPILER == "clang" then
+if FREETYPE_GENERATION then
-    CPRE = COMPILER..[[ -E -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS -DIMGUI_API="" -DIMGUI_IMPL_API="" ]] .. CFLAGS
+	CFLAGS = CFLAGS .. " -DIMGUI_ENABLE_FREETYPE -DIMGUI_ENABLE_STB_TRUETYPE" --both builders
+end
+
+if COMPILER == "gcc" or COMPILER == "clang" or COMPILER == "zig cc" then
+    CPRE = COMPILER..[[ -E -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS -DIMGUI_API="" -DIMGUI_IMPL_API=""  ]] .. CFLAGS
     CTEST = COMPILER.." --version"
 elseif COMPILER == "cl" then
-    CPRE = COMPILER..[[ /E /DIMGUI_DISABLE_OBSOLETE_FUNCTIONS /DIMGUI_API="" /DIMGUI_IMPL_API="" ]] .. CFLAGS
+    CPRE = COMPILER..[[ /E /DIMGUI_DISABLE_OBSOLETE_FUNCTIONS /DIMGUI_DEBUG_PARANOID /DIMGUI_API="" /DIMGUI_IMPL_API="" ]] .. CFLAGS
     CTEST = COMPILER
 else
     print("Working without compiler ")
@@ -58,21 +71,31 @@ assert(HAVE_COMPILER,"gcc, clang or cl needed to run script")
 print("HAVE_COMPILER",HAVE_COMPILER)
 print("INTERNAL_GENERATION",INTERNAL_GENERATION)
 print("FREETYPE_GENERATION",FREETYPE_GENERATION)
+print("COMMENTS_GENERATION",COMMENTS_GENERATION)
+print("CONSTRUCTORS_GENERATION",CONSTRUCTORS_GENERATION)
+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
 }
+local cimgui_skipped = {
+	 --igShowDemoWindow = true
+}
 --------------------------------------------------------------------------
 --this table is a dictionary to force a naming of function overloading (instead of algorythmic generated)
 --first level is cimguiname without postfix, second level is the signature of the function, value is the
 --desired name
 ---------------------------------------------------------------------------
 local cimgui_overloads = {
+	-- igGetIO = {
+		-- ["()"] = "igGetIO",
+		-- ["(ImGuiContext*)"] = "igGetIOEx",
+	-- },
     --igPushID = {
         --["(const char*)"] =           "igPushIDStr",
         --["(const char*,const char*)"] = "igPushIDRange",
@@ -106,16 +129,19 @@ local function func_header_impl_generate(FP)
             local cimf = FP.defsT[t.cimguiname]
             local def = cimf[t.signature]
 			local addcoment = def.comment or ""
+			local empty = def.args:match("^%(%)") --no args
 			if def.constructor then
-				-- it happens with vulkan impl but constructor ImGui_ImplVulkanH_Window is not needed
+				-- only vulkan is manually created
-			    --assert(def.stname ~= "","constructor without struct")
+				assert(def.ov_cimguiname=="ImGui_ImplVulkanH_Window_ImGui_ImplVulkanH_Window" or
-                --table.insert(outtab,"CIMGUI_API "..def.stname.."* "..def.ov_cimguiname ..(empty and "(void)" or --def.args)..";"..addcoment.."\n")
+				def.ov_cimguiname=="ImGui_ImplVulkanH_Window_Construct", "not cpp for "..def.ov_cimguiname)
+			    assert(def.stname ~= "","constructor without struct")
+                table.insert(outtab,"CIMGUI_API "..def.stname.."* "..def.ov_cimguiname ..(empty and "(void)" or def.args)..";"..addcoment.."\n")
             elseif def.destructor then
                 --table.insert(outtab,"CIMGUI_API void "..def.ov_cimguiname..def.args..";"..addcoment.."\n")
 			else
                 
                 if def.stname == "" then --ImGui namespace or top level
-                    table.insert(outtab,"CIMGUI_API".." "..def.ret.." "..def.ov_cimguiname..def.args..";"..addcoment.."\n")
+                    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")
@@ -135,15 +161,19 @@ local func_implementation = cpp2ffi.func_implementation
 
 -------------------functions for getting and setting defines
 local function get_defines(t)
-    if COMPILER == "cl" then print"can't get defines with cl compiler"; return {} end
+    local compiler_cmd = COMPILER == "cl"
-    print(COMPILER..[[ -E -dM -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS -DIMGUI_API="" -DIMGUI_IMPL_API="" ../imgui/imgui.h]] .. CFLAGS)
+                         and COMPILER..[[ /TP /nologo /c /Fo"NUL" /DIMGUI_DISABLE_OBSOLETE_FUNCTIONS ]]..CFLAGS..[[ /I"]]..IMGUI_PATH..[[" print_defines.cpp]]
-    local pipe,err = io.popen(COMPILER..[[ -E -dM -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS -DIMGUI_API="" -DIMGUI_IMPL_API="" ../imgui/imgui.h]] .. CFLAGS,"r")
+                         or COMPILER..[[ -E -dM -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS -DIMGUI_API="" -DIMGUI_IMPL_API="" ]]..IMGUI_PATH..[[/imgui.h]]..CFLAGS
+    print(compiler_cmd)
+    local pipe,err = io.popen(compiler_cmd,"r")
     local defines = {}
+    local compiler_output = {"There were fails in compilation."}
     while true do
         local line = pipe:read"*l"
         if not line then break end
-        local key,value = line:match([[#define%s+(%S+)%s*(.*)]])
+        local key,value = line:match([[^#define%s+(%S+)%s*(.*)]])
         if not key then --or not value then 
+			table.insert(compiler_output, line)
             --print(line)
         else
             defines[key]=value or ""
@@ -152,13 +182,13 @@ local function get_defines(t)
     pipe:close()
     --require"anima.utils"
     --prtable(defines)
-    --FLT_MAX
+	assert(next(defines), table.concat(compiler_output, "\n"))
     local ret = {}
     for i,v in ipairs(t) do
         local aa = defines[v]
         while true do
             local tmp = defines[aa]
-            if not tmp then 
+            if not tmp then
                 break
             else
                 aa = tmp
@@ -194,82 +224,28 @@ local function DefsByStruct(FP)
     FP.defsBystruct = structs
 end  
 
--- function for repairing funcdefs default values
+local function colapse_defines(str, define)
-local function repair_defaults(defsT,str_and_enu)
+	local num = 1
-	local function deleteOuterPars(def)
+	while num > 0 do
-		local w = def:match("^%b()$")
+		str,num = str:gsub("(#ifdef "..define..".+)".."(#endif\n+#ifdef "..define.."\n)", "%1")
-		if w then
-			w = w:gsub("^%((.+)%)$","%1")
-			return w
-		else 
-			return def 
-		end
-	end
-	local function CleanImU32(def)
-		def = def:gsub("%(ImU32%)","")
-		--quitar () de numeros
-		def = def:gsub("%((%d+)%)","%1")
-		def = deleteOuterPars(def)
-		local bb=cpp2ffi.strsplit(def,"|")
-		for i=1,#bb do
-			local val = deleteOuterPars(bb[i])
-			if val:match"<<" then
-				local v1,v2 = val:match("(%d+)%s*<<%s*(%d+)")
-				val = v1*2^v2
-				bb[i] = val
-			end
-			assert(type(bb[i])=="number")
-		end
-		local res = 0 
-		for i=1,#bb do res = res + bb[i] end 
-		return res
-	end
-	for k,defT in pairs(defsT) do
-		for i,def in ipairs(defT) do
-			for k,v in pairs(def.defaults) do
-				--do only if not a c string
-				local is_cstring = v:sub(1,1)=='"' and v:sub(-1,-1) =='"'
-				if not is_cstring then
-					def.defaults[k] = def.defaults[k]:gsub("%(%(void%s*%*%)0%)","NULL")
-					if def.defaults[k]:match"%(ImU32%)" then
-						def.defaults[k] = tostring(CleanImU32(def.defaults[k]))
-					end
-				end
-			end
-		end
 	end
+	return str
 end
+local wchardefine =
+[[
+
+#ifdef IMGUI_USE_WCHAR32            
+typedef ImWchar32 ImWchar;
+#else
+typedef ImWchar16 ImWchar;
+#endif
+#ifdef IMGUI_USE_WCHAR32
+#define IM_UNICODE_CODEPOINT_MAX     0x10FFFF   
+#else
+#define IM_UNICODE_CODEPOINT_MAX     0xFFFF  
+#endif
+	]]
 
-----------custom ImVector templates
-local table_do_sorted = cpp2ffi.table_do_sorted
-local function generate_templates(code,codeimpool,templates)
-    table.insert(code,"\n"..[[typedef struct ImVector{int Size;int Capacity;void* Data;} ImVector;]].."\n")
-	table_do_sorted(templates , function (ttype, v)
-		if ttype == "ImVector" then
-			table_do_sorted(v, function(te,newte)
-				table.insert(code,"typedef struct ImVector_"..newte.." {int Size;int Capacity;"..te.."* Data;} ImVector_"..newte..";\n")
-			end)
-		elseif ttype == "ImPool" then
-			--declare ImGuiStorage
-			table_do_sorted(v, function(te, newte)
-				table.insert(codeimpool,"typedef struct ImVector_"..newte.." {int Size;int Capacity;"..te.."* Data;} ImVector_"..newte..";\n")
-				table.insert(codeimpool,"typedef struct ImPool_"..newte.." {ImVector_"..te.." Buf;ImGuiStorage Map;ImPoolIdx FreeIdx;} ImPool_"..newte..";\n")
-			end)
-		elseif ttype == "ImChunkStream" then
-			table_do_sorted(v, function(te,newte)
-				table.insert(code,"typedef struct ImVector_"..newte.." {int Size;int Capacity;"..te.."* Data;} ImVector_"..newte..";\n")
-				table.insert(code,"typedef struct ImChunkStream_"..newte.." {ImVector_"..te.." Buf;} ImChunkStream_"..newte..";\n")
-			end)
-		elseif ttype == "ImSpan" then
-			table_do_sorted(v, function(te,newte)
-				table.insert(code,"typedef struct ImSpan_"..newte.." {"..te.."* Data;" ..te.."* DataEnd;} ImSpan_"..newte..";\n")
-			end)
-		else
-			print("generate_templates ttype not done",ttype)
-			error"generate templates"
-		end
-	end)
-end
 --generate cimgui.cpp cimgui.h 
 local function cimgui_generation(parser)
 
@@ -300,69 +276,57 @@ local function cimgui_generation(parser)
 	cpp2ffi.prtable(parser.templates)
 	cpp2ffi.prtable(parser.typenames)
 	
-	local outtab = {}
-	local outtabpool = {}
-    generate_templates(outtab, outtabpool, parser.templates)
-	
-	--move outtabpool after ImGuiStorage definition
-	local outpost1, outpost2 = outpost:match("^(.+struct ImGuiStorage%s*\n%b{};\n)(.+)$")
-	outpost = outpost1..table.concat(outtabpool)..outpost2
 
-	local cstructsstr = outpre..table.concat(outtab,"")..outpost --..(extra or "")
+	local  tdt = parser:generate_templates()
+	local cstructsstr = outpre..tdt..outpost 
     
 	if gdefines.IMGUI_HAS_DOCK then
 		cstructsstr = cstructsstr.."\n#define IMGUI_HAS_DOCK       1\n"
 	end
-	if gdefines.IMGUI_HAS_IMSTR then
+	if gdefines.ImDrawCallback_ResetRenderState then
-		cstructsstr = cstructsstr.."\n#define IMGUI_HAS_IMSTR       1\n"
+		cstructsstr = cstructsstr.."\n#define ImDrawCallback_ResetRenderState       "..gdefines.ImDrawCallback_ResetRenderState.."\n"
 	end
+	if gdefines.IMGUI_HAS_IMSTR then
+		if not (NOCHAR or NOIMSTRV) then
+		cstructsstr = cstructsstr.."\n#define IMGUI_HAS_IMSTR       1\n"
+		end
+	end
+	
+	cstructsstr = colapse_defines(cstructsstr, "IMGUI_ENABLE_FREETYPE")
 	
     hstrfile = hstrfile:gsub([[#include "imgui_structs%.h"]],cstructsstr)
     local cfuncsstr = func_header_generate(parser)
+	cfuncsstr = colapse_defines(cfuncsstr, "IMGUI_ENABLE_FREETYPE")
     hstrfile = hstrfile:gsub([[#include "auto_funcs%.h"]],cfuncsstr)
+	--patch hstrfile for ImWchar
+	local num
+	hstrfile, num = hstrfile:gsub("typedef ImWchar16 ImWchar;", wchardefine)
+	assert(num == 1)
+	hstrfile, num = hstrfile:gsub("kPagesMap%[%(0xFFFF", "kPagesMap[(IM_UNICODE_CODEPOINT_MAX")
+	assert(num == 1, "kPagesMap[(IM_UNICODE_CODEPOINT_MAX not found or found more than once")
     save_data("./output/cimgui.h",cimgui_header,hstrfile)
     
     --merge it in cimgui_template.cpp to cimgui.cpp
     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)
-    save_data("./output/cimgui.cpp",cimgui_header,hstrfile)
+	local ftdef = "" --FREETYPE_GENERATION and "#define IMGUI_ENABLE_FREETYPE\n" or ""
+    save_data("./output/cimgui.cpp",cimgui_header, ftdef, hstrfile)
 
 end
 --------------------------------------------------------
 -----------------------------do it----------------------
 --------------------------------------------------------
 --get imgui.h version and IMGUI_HAS_DOCK--------------------------
---get some defines wont work for cl ----------------
+--defines for the cl compiler must be present in the print_defines.cpp file
-gdefines = get_defines{"IMGUI_VERSION","FLT_MAX","FLT_MIN","IMGUI_HAS_DOCK","IMGUI_HAS_IMSTR"}
+gdefines = get_defines{"IMGUI_VERSION","IMGUI_VERSION_NUM","FLT_MAX","FLT_MIN","IMGUI_HAS_DOCK","IMGUI_HAS_IMSTR","ImDrawCallback_ResetRenderState","IMGUI_HAS_TEXTURES"}
---this will work for cl
+cpp2ffi.prtable(gdefines)
-local pipe,err = io.open("../imgui/imgui.h","r")
+if gdefines.IMGUI_HAS_DOCK then gdefines.IMGUI_HAS_DOCK = true end
-if not pipe then
+if gdefines.IMGUI_HAS_IMSTR then gdefines.IMGUI_HAS_IMSTR = true end
-    error("could not open file:"..err)
-end
-local imgui_version,has_dock,has_imstr 
-while true do
-    local line = pipe:read"*l"
-	if not line then break end
-	if not imgui_version then
-		imgui_version = line:match([[#define%s+IMGUI_VERSION%s+(".+")]])
-	end
-	if not has_dock then
-		has_dock = line:match([[#define%s+IMGUI_HAS_DOCK]])--%s*(".+")]])
-	end
-	if not has_imstr then
-		has_imstr = line:match([[#define%s+IMGUI_HAS_IMSTR]])--%s*(".+")]])
-	end
-    if imgui_version and has_dock and has_imstr then break end
-end
-pipe:close()
 
-if has_dock then gdefines.IMGUI_HAS_DOCK = true end
+cimgui_header = cimgui_header:gsub("XXX",gdefines.IMGUI_VERSION .. " "..(gdefines.IMGUI_VERSION_NUM or ""))
-if has_imstr then gdefines.IMGUI_HAS_IMSTR = true end
-
-cimgui_header = cimgui_header:gsub("XXX",imgui_version)
 if INTERNAL_GENERATION then
 	cimgui_header = cimgui_header..[[//with imgui_internal.h api
 ]]
@@ -376,10 +340,28 @@ if gdefines.IMGUI_HAS_DOCK then
 ]]
 	
 end
+assert(not NOCHAR or not NOIMSTRV,"nochar and noimstrv cant be set at the same time")
 print("IMGUI_HAS_IMSTR",gdefines.IMGUI_HAS_IMSTR)
+print("IMGUI_HAS_TEXTURES",gdefines.IMGUI_HAS_TEXTURES and true)
+print("NOCHAR",NOCHAR)
+print("NOIMSTRV",NOIMSTRV)
 print("IMGUI_HAS_DOCK",gdefines.IMGUI_HAS_DOCK)
-print("IMGUI_VERSION",imgui_version)
+print("IMGUI_VERSION",gdefines.IMGUI_VERSION)
 
+local function custom_function_post(self, outtab, def)
+	assert(def.location)
+	if def.location:match("imgui_freetype") then 
+		outtab[#outtab] = "#ifdef IMGUI_ENABLE_FREETYPE\n"..outtab[#outtab].."\n#endif\n"
+	end
+end
+local function header_text_insert(self, outtab, txt, it)
+	assert(it.locat)
+	if it.locat:match("imgui_freetype") then 
+		table.insert(outtab, "\n#ifdef IMGUI_ENABLE_FREETYPE"..txt.."\n#endif")
+	else
+		table.insert(outtab, txt)
+	end
+end
 
 --funtion for parsing imgui headers
 local function parseImGuiHeader(header,names)
@@ -391,9 +373,18 @@ local function parseImGuiHeader(header,names)
 		return pre..funcname
 	end
 	parser.cname_overloads = cimgui_overloads
-	parser.manuals = cimgui_manuals
+	--parser.manuals = cimgui_manuals
+	parser:set_manuals(cimgui_manuals, "cimgui")
+	parser.skipped = cimgui_skipped
 	parser.UDTs = {"ImVec2","ImVec4","ImColor","ImRect"}
-	
+	--parser.gen_template_typedef = gen_template_typedef --use auto
+	parser.COMMENTS_GENERATION = COMMENTS_GENERATION
+	parser.CONSTRUCTORS_GENERATION = CONSTRUCTORS_GENERATION
+	parser.NOCHAR = NOCHAR
+	parser.NOIMSTRV = NOIMSTRV
+	parser.IMGUI_HAS_TEXTURES = gdefines.IMGUI_HAS_TEXTURES
+	parser.custom_function_post = custom_function_post
+	parser.header_text_insert = header_text_insert
 	local defines = parser:take_lines(CPRE..header,names,COMPILER)
 	
 	return parser
@@ -401,41 +392,46 @@ end
 --generation
 print("------------------generation with "..COMPILER.."------------------------")
 local parser1
-local headers = [[#include "../imgui/imgui.h" 
+local headers = [[#include "]]..IMGUI_PATH..[[/imgui.h" 
 ]]
 local headersT = {[[imgui]]}
 if INTERNAL_GENERATION then
-	headers = headers .. [[#include "../imgui/imgui_internal.h"
+	headers = headers .. [[#include "]]..IMGUI_PATH..[[/imgui_internal.h"
 	]]
 	headersT[#headersT + 1] = [[imgui_internal]]
 	headersT[#headersT + 1] = [[imstb_textedit]]
 end
 if FREETYPE_GENERATION then
 	headers = headers .. [[
-	#include "../imgui/misc/freetype/imgui_freetype.h"
+	#include "]]..IMGUI_PATH..[[/misc/freetype/imgui_freetype.h"
 	]]
 	headersT[#headersT + 1] = [[imgui_freetype]]
 end
 save_data("headers.h",headers)
 local include_cmd = COMPILER=="cl" and [[ /I ]] or [[ -I ]]
-local extra_includes = include_cmd.." ../imgui "
+local extra_includes = include_cmd.." " ..IMGUI_PATH.." "
 local parser1 = parseImGuiHeader(extra_includes .. [[headers.h]],headersT)
 os.remove("headers.h")
 parser1:do_parse()
 
+--to debug items parsing
+--save_data("./itemsarr2.txt",cpp2ffi.ToStr(parser1.itemsarr))
 save_data("./output/overloads.txt",parser1.overloadstxt)
 cimgui_generation(parser1)
 
 ----------save struct and enums lua table in structs_and_enums.lua for using in bindings
 
 local structs_and_enums_table = parser1.structs_and_enums_table
+structs_and_enums_table.templated_structs = parser1.templated_structs
+structs_and_enums_table.typenames = parser1.typenames
+structs_and_enums_table.templates_done = parser1.templates_done
+
 save_data("./output/structs_and_enums.lua",serializeTableF(structs_and_enums_table))
 save_data("./output/typedefs_dict.lua",serializeTableF(parser1.typedefs_dict))
 
 ----------save fundefs in definitions.lua for using in bindings
 --DefsByStruct(pFP)
 set_defines(parser1.defsT) 
-repair_defaults(parser1.defsT, structs_and_enums_table)
 save_data("./output/definitions.lua",serializeTableF(parser1.defsT))
 
 --check every function has ov_cimguiname
@@ -447,23 +443,31 @@ save_data("./output/definitions.lua",serializeTableF(parser1.defsT))
 
 --=================================Now implementations
 local backends_folder 
-local ff,err = io.open ("../imgui/examples/imgui_impl_glfw.h" ,"r")
+local ff,err = io.open (IMGUI_PATH .. "/examples/imgui_impl_glfw.h" ,"r")
 if ff then
-	backends_folder = "../imgui/examples/"
+	backends_folder = IMGUI_PATH .. "/examples/"
 	ff:close()
 else
-	backends_folder = "../imgui/backends/"
+	backends_folder = IMGUI_PATH .. "/backends/"
 end
  
 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 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
 
@@ -471,26 +475,49 @@ if #implementations > 0 then
 		local extra_defines = ""
 		if impl == "opengl3" then extra_defines = define_cmd .. "IMGUI_IMPL_OPENGL_LOADER_GL3W " end
 		local include_cmd = COMPILER=="cl" and [[ /I ]] or [[ -I ]]
-		local extra_includes = include_cmd.." ../imgui "
+		local extra_includes = include_cmd.." ".. IMGUI_PATH .." "
 		if config[impl] then
 			for j,inc in ipairs(config[impl]) do
 				extra_includes = extra_includes .. include_cmd .. inc .. " "
 			end
 		end
-		
+		parser2.cimgui_inherited =  dofile([[./output/structs_and_enums.lua]])
 		local defines = parser2:take_lines(CPRE..extra_defines..extra_includes..source, {locati}, COMPILER)
-
+		
+		local parser3 = cpp2ffi.Parser()
+		parser3.cimgui_inherited =  dofile([[./output/structs_and_enums.lua]])
+		parser3:take_lines(CPRE..extra_defines..extra_includes..source, {locati}, COMPILER)
+		parser3:do_parse()
+		local cfuncsstr = func_header_impl_generate(parser3) 
+		local cstructstr1,cstructstr2 = parser3.structs_and_enums[1], parser3.structs_and_enums[2]
+		local cstru = cstructstr1 .. cstructstr2
+		if cstru ~="" then
+			cstru = "#ifdef CIMGUI_DEFINE_ENUMS_AND_STRUCTS\n"..cstru .."\n#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS\n"
+		end
+		impl_str = impl_str .. "#ifdef CIMGUI_USE_".. string.upper(impl).."\n".. cstru
+		local outtab = cpp2ffi.func_header_generate_structs(parser3)
+		if #outtab > 0 then
+			table.insert(outtab, 1, "#ifndef CIMGUI_DEFINE_ENUMS_AND_STRUCTS\n")
+			table.insert(outtab,"#endif //CIMGUI_DEFINE_ENUMS_AND_STRUCTS\n")
+		end
+		impl_str = impl_str.. table.concat(outtab)..cfuncsstr .. "\n#endif\n"
     end
-	
+	impl_str = impl_str .. "#endif //CIMGUI_IMPL_DEFINED\n"
     parser2:do_parse()
-
+	save_data("./output/cimgui_impl.h",impl_str)
-    -- 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 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
 
@@ -510,6 +537,10 @@ end
 ---[[
 local json = require"json"
 save_data("./output/definitions.json",json.encode(json_prepare(parser1.defsT),{dict_on_empty={defaults=true}}))
+--delete extra info for json
+--structs_and_enums_table.templated_structs = nil
+--structs_and_enums_table.typenames = nil
+--structs_and_enums_table.templates_done = nil
 save_data("./output/structs_and_enums.json",json.encode(structs_and_enums_table))
 save_data("./output/typedefs_dict.json",json.encode(parser1.typedefs_dict))
 if parser2 then

generator/generator.sh

@@ -1,4 +1,4 @@
-#!/usr/bin/sh
+#!/bin/bash
 
 # this script must be executed in this directory
 # all the output goes to generator/output folder
@@ -13,7 +13,67 @@
 
 #process  files
 # arg[1] compiler name gcc, clang, or cl
-# arg[2] options as words in one string: internal for imgui_internal generation, freetype for freetype generation
+# arg[2] options as words in one string: internal for imgui_internal generation, comments for comments generation, nochar to skip char* function version, noimstrv to skip imstrv
-# examples: "" "internal" "internal freetype"
+# "constructors" adds the _Construct version of constructors
-# arg[3..n] name of implementations to generate and/or CLFLAGS (e.g. -DIMGUI_USER_CONFIG or -DIMGUI_USE_WCHAR32)
+# examples: "" "internal" "comments internal"
-luajit ./generator.lua gcc "internal" glfw opengl3 opengl2 sdl
+# arg[3..n] name of implementations to generate and/or CLFLAGS (e.g. -DIMGUI_USER_CONFIG)
+# -DIMGUI_USE_WCHAR32 should not be used as it is generated for both ImWchar
+#
+
+# parse command line arguments
+# ref: https://stackoverflow.com/questions/192249/how-do-i-parse-command-line-arguments-in-bash
+POSITIONAL_ARGS=()
+
+TARGETS="internal noimstrv"
+CFLAGS="glfw opengl3 opengl2 sdl2 sdl3"
+
+help() {
+        cat <<EOF
+Usage of generator.sh:
+   -t --target    specify which imgui features should be generated
+                  (default: $TARGETS)
+   -c --cflags    specify additional gcc flags
+                  (default: $CFLAGS
+   -h --help      show this message and exit
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    -c|--cflags)
+      CFLAGS="$2"
+      shift # past argument
+      shift # past value
+      ;;
+    -t|--target)
+      TARGETS="$2"
+      shift # past argument
+      shift # past value
+      ;;
+    -h|--help)
+      help
+      exit 0
+      ;;
+    -*|--*)
+      echo "Unknown option $1"
+      help
+      exit 1
+      ;;
+    *)
+      POSITIONAL_ARGS+=("$1") # save positional arg
+      shift # past argument
+      ;;
+  esac
+done
+
+set -- "${POSITIONAL_ARGS[@]}" # restore positional parameters
+
+# if [[ "$OSTYPE" == "cygwin" || "$OSTYPE" == "msys" || "$OSTYPE" == "win32" ]];
+# then
+#   suffix='.exe'
+# fi
+
+echo "CFLAGS: " $CFLAGS
+echo "TARGETS: " $TARGETS
+
+luajit$suffix ./generator.lua gcc "$TARGETS" $CFLAGS

generator/output/cimgui_impl.h

@@ -1,38 +0,0 @@
-typedef struct SDL_Window SDL_Window;
-typedef struct GLFWwindow GLFWwindow;
-
-struct GLFWwindow;
-
-struct SDL_Window;
-typedef union SDL_Event SDL_Event;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();
-CIMGUI_API void ImGui_ImplGlfw_NewFrame();
-CIMGUI_API void ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window,int button,int action,int mods);
-CIMGUI_API void ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window,double xoffset,double yoffset);
-CIMGUI_API void ImGui_ImplGlfw_KeyCallback(GLFWwindow* window,int key,int scancode,int action,int mods);
-CIMGUI_API void ImGui_ImplGlfw_CharCallback(GLFWwindow* window,unsigned int c);
-CIMGUI_API bool ImGui_ImplOpenGL3_Init(const char* glsl_version);
-CIMGUI_API void ImGui_ImplOpenGL3_Shutdown();
-CIMGUI_API void ImGui_ImplOpenGL3_NewFrame();
-CIMGUI_API void ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data);
-CIMGUI_API bool ImGui_ImplOpenGL3_CreateFontsTexture();
-CIMGUI_API void ImGui_ImplOpenGL3_DestroyFontsTexture();
-CIMGUI_API bool ImGui_ImplOpenGL3_CreateDeviceObjects();
-CIMGUI_API void ImGui_ImplOpenGL3_DestroyDeviceObjects();
-CIMGUI_API bool ImGui_ImplOpenGL2_Init();
-CIMGUI_API void ImGui_ImplOpenGL2_Shutdown();
-CIMGUI_API void ImGui_ImplOpenGL2_NewFrame();
-CIMGUI_API void ImGui_ImplOpenGL2_RenderDrawData(ImDrawData* draw_data);
-CIMGUI_API bool ImGui_ImplOpenGL2_CreateFontsTexture();
-CIMGUI_API void ImGui_ImplOpenGL2_DestroyFontsTexture();
-CIMGUI_API bool ImGui_ImplOpenGL2_CreateDeviceObjects();
-CIMGUI_API void ImGui_ImplOpenGL2_DestroyDeviceObjects();
-CIMGUI_API bool ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window,void* sdl_gl_context);
-CIMGUI_API bool ImGui_ImplSDL2_InitForVulkan(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL2_InitForD3D(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL2_InitForMetal(SDL_Window* window);
-CIMGUI_API void ImGui_ImplSDL2_Shutdown();
-CIMGUI_API void ImGui_ImplSDL2_NewFrame(SDL_Window* window);
-CIMGUI_API bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event);

generator/output/overloads.txt

@@ -1,248 +1,312 @@
 ----------------overloadings---------------------------
 ImColor_ImColor	5
-1	nil	ImColor_ImColorNil ()
+1	nil	ImColor_ImColor_Nil ()
-2	nil	ImColor_ImColorInt (int,int,int,int)
+2	nil	ImColor_ImColor_Float (float,float,float,float)
-3	nil	ImColor_ImColorU32 (ImU32)
+3	nil	ImColor_ImColor_Vec4 (const ImVec4)
-4	nil	ImColor_ImColorFloat (float,float,float,float)
+4	nil	ImColor_ImColor_Int (int,int,int,int)
-5	nil	ImColor_ImColorVec4 (const ImVec4)
+5	nil	ImColor_ImColor_U32 (ImU32)
 ImDrawList_AddText	2
-1	void	ImDrawList_AddTextVec2 (const ImVec2,ImU32,const char*,const char*)
+1	void	ImDrawList_AddText_Vec2 (const ImVec2,ImU32,const char*,const char*)
-2	void	ImDrawList_AddTextFontPtr (const ImFont*,float,const ImVec2,ImU32,const char*,const char*,float,const ImVec4*)
+2	void	ImDrawList_AddText_FontPtr (ImFont*,float,const ImVec2,ImU32,const char*,const char*,float,const ImVec4*)
 ImGuiPtrOrIndex_ImGuiPtrOrIndex	2
-1	nil	ImGuiPtrOrIndex_ImGuiPtrOrIndexPtr (void*)
+1	nil	ImGuiPtrOrIndex_ImGuiPtrOrIndex_Ptr (void*)
-2	nil	ImGuiPtrOrIndex_ImGuiPtrOrIndexInt (int)
+2	nil	ImGuiPtrOrIndex_ImGuiPtrOrIndex_Int (int)
 ImGuiStoragePair_ImGuiStoragePair	3
-1	nil	ImGuiStoragePair_ImGuiStoragePairInt (ImGuiID,int)
+1	nil	ImGuiStoragePair_ImGuiStoragePair_Int (ImGuiID,int)
-2	nil	ImGuiStoragePair_ImGuiStoragePairFloat (ImGuiID,float)
+2	nil	ImGuiStoragePair_ImGuiStoragePair_Float (ImGuiID,float)
-3	nil	ImGuiStoragePair_ImGuiStoragePairPtr (ImGuiID,void*)
+3	nil	ImGuiStoragePair_ImGuiStoragePair_Ptr (ImGuiID,void*)
 ImGuiStyleMod_ImGuiStyleMod	3
-1	nil	ImGuiStyleMod_ImGuiStyleModInt (ImGuiStyleVar,int)
+1	nil	ImGuiStyleMod_ImGuiStyleMod_Int (ImGuiStyleVar,int)
-2	nil	ImGuiStyleMod_ImGuiStyleModFloat (ImGuiStyleVar,float)
+2	nil	ImGuiStyleMod_ImGuiStyleMod_Float (ImGuiStyleVar,float)
-3	nil	ImGuiStyleMod_ImGuiStyleModVec2 (ImGuiStyleVar,ImVec2)
+3	nil	ImGuiStyleMod_ImGuiStyleMod_Vec2 (ImGuiStyleVar,ImVec2)
 ImGuiTextRange_ImGuiTextRange	2
-1	nil	ImGuiTextRange_ImGuiTextRangeNil ()
+1	nil	ImGuiTextRange_ImGuiTextRange_Nil ()
-2	nil	ImGuiTextRange_ImGuiTextRangeStr (const char*,const char*)
+2	nil	ImGuiTextRange_ImGuiTextRange_Str (const char*,const char*)
 ImGuiWindow_GetID	3
-1	ImGuiID	ImGuiWindow_GetIDStr (const char*,const char*)
+1	ImGuiID	ImGuiWindow_GetID_Str (const char*,const char*)
-2	ImGuiID	ImGuiWindow_GetIDPtr (const void*)
+2	ImGuiID	ImGuiWindow_GetID_Ptr (const void*)
-3	ImGuiID	ImGuiWindow_GetIDInt (int)
+3	ImGuiID	ImGuiWindow_GetID_Int (int)
-ImGuiWindow_GetIDNoKeepAlive	3
-1	ImGuiID	ImGuiWindow_GetIDNoKeepAliveStr (const char*,const char*)
-2	ImGuiID	ImGuiWindow_GetIDNoKeepAlivePtr (const void*)
-3	ImGuiID	ImGuiWindow_GetIDNoKeepAliveInt (int)
 ImPool_Remove	2
-1	void	ImPool_RemoveTPtr (ImGuiID,const T*)
+1	void	ImPool_Remove_TPtr (ImGuiID,const T*)
-2	void	ImPool_RemovePoolIdx (ImGuiID,ImPoolIdx)
+2	void	ImPool_Remove_PoolIdx (ImGuiID,ImPoolIdx)
 ImRect_Add	2
-1	void	ImRect_AddVec2 (const ImVec2)
+1	void	ImRect_Add_Vec2 (const ImVec2)
-2	void	ImRect_AddRect (const ImRect)
+2	void	ImRect_Add_Rect (const ImRect)
 ImRect_Contains	2
-1	bool	ImRect_ContainsVec2 (const ImVec2)const
+1	bool	ImRect_Contains_Vec2 (const ImVec2)const
-2	bool	ImRect_ContainsRect (const ImRect)const
+2	bool	ImRect_Contains_Rect (const ImRect)const
 ImRect_Expand	2
-1	void	ImRect_ExpandFloat (const float)
+1	void	ImRect_Expand_Float (const float)
-2	void	ImRect_ExpandVec2 (const ImVec2)
+2	void	ImRect_Expand_Vec2 (const ImVec2)
 ImRect_ImRect	4
-1	nil	ImRect_ImRectNil ()
+1	nil	ImRect_ImRect_Nil ()
-2	nil	ImRect_ImRectVec2 (const ImVec2,const ImVec2)
+2	nil	ImRect_ImRect_Vec2 (const ImVec2,const ImVec2)
-3	nil	ImRect_ImRectVec4 (const ImVec4)
+3	nil	ImRect_ImRect_Vec4 (const ImVec4)
-4	nil	ImRect_ImRectFloat (float,float,float,float)
+4	nil	ImRect_ImRect_Float (float,float,float,float)
 ImSpan_ImSpan	3
-1	nil	ImSpan_ImSpanNil ()
+1	nil	ImSpan_ImSpan_Nil ()
-2	nil	ImSpan_ImSpanTPtrInt (T*,int)
+2	nil	ImSpan_ImSpan_TPtrInt (T*,int)
-3	nil	ImSpan_ImSpanTPtrTPtr (T*,T*)
+3	nil	ImSpan_ImSpan_TPtrTPtr (T*,T*)
 ImSpan_begin	2
-1	T*	ImSpan_beginNil ()
+1	T*	ImSpan_begin_Nil ()
-2	const T*	ImSpan_begin_const ()const
+2	const T*	ImSpan_begin__const ()const
 ImSpan_end	2
-1	T*	ImSpan_endNil ()
+1	T*	ImSpan_end_Nil ()
-2	const T*	ImSpan_end_const ()const
+2	const T*	ImSpan_end__const ()const
 ImSpan_set	2
-1	void	ImSpan_setInt (T*,int)
+1	void	ImSpan_set_Int (T*,int)
-2	void	ImSpan_setTPtr (T*,T*)
+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_ImVec1Nil ()
+1	nil	ImVec1_ImVec1_Nil ()
-2	nil	ImVec1_ImVec1Float (float)
+2	nil	ImVec1_ImVec1_Float (float)
 ImVec2_ImVec2	2
-1	nil	ImVec2_ImVec2Nil ()
+1	nil	ImVec2_ImVec2_Nil ()
-2	nil	ImVec2_ImVec2Float (float,float)
+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_ImVec2ihNil ()
+1	nil	ImVec2ih_ImVec2ih_Nil ()
-2	nil	ImVec2ih_ImVec2ihshort (short,short)
+2	nil	ImVec2ih_ImVec2ih_short (short,short)
-3	nil	ImVec2ih_ImVec2ihVec2 (const ImVec2)
+3	nil	ImVec2ih_ImVec2ih_Vec2 (const ImVec2)
 ImVec4_ImVec4	2
-1	nil	ImVec4_ImVec4Nil ()
+1	nil	ImVec4_ImVec4_Nil ()
-2	nil	ImVec4_ImVec4Float (float,float,float,float)
+2	nil	ImVec4_ImVec4_Float (float,float,float,float)
 ImVector_ImVector	2
-1	nil	ImVector_ImVectorNil ()
+1	nil	ImVector_ImVector_Nil ()
-2	nil	ImVector_ImVectorVector (const ImVector)
+2	nil	ImVector_ImVector_Vector_T_ (const ImVector_T )
 ImVector_back	2
-1	T*	ImVector_backNil ()
+1	T*	ImVector_back_Nil ()
-2	const T*	ImVector_back_const ()const
+2	const T*	ImVector_back__const ()const
 ImVector_begin	2
-1	T*	ImVector_beginNil ()
+1	T*	ImVector_begin_Nil ()
-2	const T*	ImVector_begin_const ()const
+2	const T*	ImVector_begin__const ()const
 ImVector_end	2
-1	T*	ImVector_endNil ()
+1	T*	ImVector_end_Nil ()
-2	const T*	ImVector_end_const ()const
+2	const T*	ImVector_end__const ()const
 ImVector_erase	2
-1	T*	ImVector_eraseNil (const T*)
+1	T*	ImVector_erase_Nil (const T*)
-2	T*	ImVector_eraseTPtr (const T*,const T*)
+2	T*	ImVector_erase_TPtr (const T*,const T*)
 ImVector_find	2
-1	T*	ImVector_findNil (const T)
+1	T*	ImVector_find_Nil (const T)
-2	const T*	ImVector_find_const (const T)const
+2	const T*	ImVector_find__const (const T)const
 ImVector_front	2
-1	T*	ImVector_frontNil ()
+1	T*	ImVector_front_Nil ()
-2	const T*	ImVector_front_const ()const
+2	const T*	ImVector_front__const ()const
 ImVector_resize	2
-1	void	ImVector_resizeNil (int)
+1	void	ImVector_resize_Nil (int)
-2	void	ImVector_resizeT (int,const T)
+2	void	ImVector_resize_T (int,const T)
 igBeginChild	2
-1	bool	igBeginChildStr (const char*,const ImVec2,bool,ImGuiWindowFlags)
+1	bool	igBeginChild_Str (const char*,const ImVec2,ImGuiChildFlags,ImGuiWindowFlags)
-2	bool	igBeginChildID (ImGuiID,const ImVec2,bool,ImGuiWindowFlags)
+2	bool	igBeginChild_ID (ImGuiID,const ImVec2,ImGuiChildFlags,ImGuiWindowFlags)
 igCheckboxFlags	4
-1	bool	igCheckboxFlagsIntPtr (const char*,int*,int)
+1	bool	igCheckboxFlags_IntPtr (const char*,int*,int)
-2	bool	igCheckboxFlagsUintPtr (const char*,unsigned int*,unsigned int)
+2	bool	igCheckboxFlags_UintPtr (const char*,unsigned int*,unsigned int)
-3	bool	igCheckboxFlagsS64Ptr (const char*,ImS64*,ImS64)
+3	bool	igCheckboxFlags_S64Ptr (const char*,ImS64*,ImS64)
-4	bool	igCheckboxFlagsU64Ptr (const char*,ImU64*,ImU64)
+4	bool	igCheckboxFlags_U64Ptr (const char*,ImU64*,ImU64)
 igCollapsingHeader	2
-1	bool	igCollapsingHeaderTreeNodeFlags (const char*,ImGuiTreeNodeFlags)
+1	bool	igCollapsingHeader_TreeNodeFlags (const char*,ImGuiTreeNodeFlags)
-2	bool	igCollapsingHeaderBoolPtr (const char*,bool*,ImGuiTreeNodeFlags)
+2	bool	igCollapsingHeader_BoolPtr (const char*,bool*,ImGuiTreeNodeFlags)
 igCombo	3
-1	bool	igComboStr_arr (const char*,int*,const char* const[],int,int)
+1	bool	igCombo_Str_arr (const char*,int*,const char* const[],int,int)
-2	bool	igComboStr (const char*,int*,const char*,int)
+2	bool	igCombo_Str (const char*,int*,const char*,int)
-3	bool	igComboFnBoolPtr (const char*,int*,bool(*)(void*,int,const char**),void*,int,int)
+3	bool	igCombo_FnStrPtr (const char*,int*,const char*(*)(void*,int),void*,int,int)
 igGetBackgroundDrawList	2
-1	ImDrawList*	igGetBackgroundDrawListNil ()
+1	ImDrawList*	igGetBackgroundDrawList_Nil ()
-2	ImDrawList*	igGetBackgroundDrawListViewportPtr (ImGuiViewport*)
+2	ImDrawList*	igGetBackgroundDrawList_ViewportPtr (ImGuiViewport*)
 igGetColorU32	3
-1	ImU32	igGetColorU32Col (ImGuiCol,float)
+1	ImU32	igGetColorU32_Col (ImGuiCol,float)
-2	ImU32	igGetColorU32Vec4 (const ImVec4)
+2	ImU32	igGetColorU32_Vec4 (const ImVec4)
-3	ImU32	igGetColorU32U32 (ImU32)
+3	ImU32	igGetColorU32_U32 (ImU32,float)
 igGetForegroundDrawList	3
-1	ImDrawList*	igGetForegroundDrawListNil ()
+1	ImDrawList*	igGetForegroundDrawList_Nil ()
-2	ImDrawList*	igGetForegroundDrawListWindowPtr (ImGuiWindow*)
+2	ImDrawList*	igGetForegroundDrawList_WindowPtr (ImGuiWindow*)
-3	ImDrawList*	igGetForegroundDrawListViewportPtr (ImGuiViewport*)
+3	ImDrawList*	igGetForegroundDrawList_ViewportPtr (ImGuiViewport*)
-igGetID	3
+igGetID	4
-1	ImGuiID	igGetIDStr (const char*)
+1	ImGuiID	igGetID_Str (const char*)
-2	ImGuiID	igGetIDStrStr (const char*,const char*)
+2	ImGuiID	igGetID_StrStr (const char*,const char*)
-3	ImGuiID	igGetIDPtr (const void*)
+3	ImGuiID	igGetID_Ptr (const void*)
-igImAbs	2
+4	ImGuiID	igGetID_Int (int)
-1	float	igImAbsFloat (float)
+igGetIDWithSeed	2
-2	double	igImAbsdouble (double)
+1	ImGuiID	igGetIDWithSeed_Str (const char*,const char*,ImGuiID)
+2	ImGuiID	igGetIDWithSeed_Int (int,ImGuiID)
+igGetIO	2
+1	ImGuiIO*	igGetIO_Nil ()
+2	ImGuiIO*	igGetIO_ContextPtr (ImGuiContext*)
+igGetKeyData	2
+1	ImGuiKeyData*	igGetKeyData_ContextPtr (ImGuiContext*,ImGuiKey)
+2	ImGuiKeyData*	igGetKeyData_Key (ImGuiKey)
+igGetPlatformIO	2
+1	ImGuiPlatformIO*	igGetPlatformIO_Nil ()
+2	ImGuiPlatformIO*	igGetPlatformIO_ContextPtr (ImGuiContext*)
+igImAbs	3
+1	int	igImAbs_Int (int)
+2	float	igImAbs_Float (float)
+3	double	igImAbs_double (double)
 igImFloor	2
-1	float	igImFloorFloat (float)
+1	float	igImFloor_Float (float)
-2	ImVec2	igImFloorVec2 (const ImVec2)
+2	ImVec2	igImFloor_Vec2 (const ImVec2)
 igImIsPowerOfTwo	2
-1	bool	igImIsPowerOfTwoInt (int)
+1	bool	igImIsPowerOfTwo_Int (int)
-2	bool	igImIsPowerOfTwoU64 (ImU64)
+2	bool	igImIsPowerOfTwo_U64 (ImU64)
 igImLengthSqr	2
-1	float	igImLengthSqrVec2 (const ImVec2)
+1	float	igImLengthSqr_Vec2 (const ImVec2)
-2	float	igImLengthSqrVec4 (const ImVec4)
+2	float	igImLengthSqr_Vec4 (const ImVec4)
 igImLerp	3
-1	ImVec2	igImLerpVec2Float (const ImVec2,const ImVec2,float)
+1	ImVec2	igImLerp_Vec2Float (const ImVec2,const ImVec2,float)
-2	ImVec2	igImLerpVec2Vec2 (const ImVec2,const ImVec2,const ImVec2)
+2	ImVec2	igImLerp_Vec2Vec2 (const ImVec2,const ImVec2,const ImVec2)
-3	ImVec4	igImLerpVec4 (const ImVec4,const ImVec4,float)
+3	ImVec4	igImLerp_Vec4 (const ImVec4,const ImVec4,float)
 igImLog	2
-1	float	igImLogFloat (float)
+1	float	igImLog_Float (float)
-2	double	igImLogdouble (double)
+2	double	igImLog_double (double)
 igImPow	2
-1	float	igImPowFloat (float,float)
+1	float	igImPow_Float (float,float)
-2	double	igImPowdouble (double,double)
+2	double	igImPow_double (double,double)
+igImRsqrt	2
+1	float	igImRsqrt_Float (float)
+2	double	igImRsqrt_double (double)
 igImSign	2
-1	float	igImSignFloat (float)
+1	float	igImSign_Float (float)
-2	double	igImSigndouble (double)
+2	double	igImSign_double (double)
+igImTrunc	2
+1	float	igImTrunc_Float (float)
+2	ImVec2	igImTrunc_Vec2 (const ImVec2)
+igIsKeyChordPressed	2
+1	bool	igIsKeyChordPressed_Nil (ImGuiKeyChord)
+2	bool	igIsKeyChordPressed_InputFlags (ImGuiKeyChord,ImGuiInputFlags,ImGuiID)
+igIsKeyDown	2
+1	bool	igIsKeyDown_Nil (ImGuiKey)
+2	bool	igIsKeyDown_ID (ImGuiKey,ImGuiID)
+igIsKeyPressed	2
+1	bool	igIsKeyPressed_Bool (ImGuiKey,bool)
+2	bool	igIsKeyPressed_InputFlags (ImGuiKey,ImGuiInputFlags,ImGuiID)
+igIsKeyReleased	2
+1	bool	igIsKeyReleased_Nil (ImGuiKey)
+2	bool	igIsKeyReleased_ID (ImGuiKey,ImGuiID)
+igIsMouseClicked	2
+1	bool	igIsMouseClicked_Bool (ImGuiMouseButton,bool)
+2	bool	igIsMouseClicked_InputFlags (ImGuiMouseButton,ImGuiInputFlags,ImGuiID)
+igIsMouseDoubleClicked	2
+1	bool	igIsMouseDoubleClicked_Nil (ImGuiMouseButton)
+2	bool	igIsMouseDoubleClicked_ID (ImGuiMouseButton,ImGuiID)
+igIsMouseDown	2
+1	bool	igIsMouseDown_Nil (ImGuiMouseButton)
+2	bool	igIsMouseDown_ID (ImGuiMouseButton,ImGuiID)
+igIsMouseReleased	2
+1	bool	igIsMouseReleased_Nil (ImGuiMouseButton)
+2	bool	igIsMouseReleased_ID (ImGuiMouseButton,ImGuiID)
 igIsPopupOpen	2
-1	bool	igIsPopupOpenStr (const char*,ImGuiPopupFlags)
+1	bool	igIsPopupOpen_Str (const char*,ImGuiPopupFlags)
-2	bool	igIsPopupOpenID (ImGuiID,ImGuiPopupFlags)
+2	bool	igIsPopupOpen_ID (ImGuiID,ImGuiPopupFlags)
 igIsRectVisible	2
-1	bool	igIsRectVisibleNil (const ImVec2)
+1	bool	igIsRectVisible_Nil (const ImVec2)
-2	bool	igIsRectVisibleVec2 (const ImVec2,const ImVec2)
+2	bool	igIsRectVisible_Vec2 (const ImVec2,const ImVec2)
 igItemSize	2
-1	void	igItemSizeVec2 (const ImVec2,float)
+1	void	igItemSize_Vec2 (const ImVec2,float)
-2	void	igItemSizeRect (const ImRect,float)
+2	void	igItemSize_Rect (const ImRect,float)
 igListBox	2
-1	bool	igListBoxStr_arr (const char*,int*,const char* const[],int,int)
+1	bool	igListBox_Str_arr (const char*,int*,const char* const[],int,int)
-2	bool	igListBoxFnBoolPtr (const char*,int*,bool(*)(void*,int,const char**),void*,int,int)
+2	bool	igListBox_FnStrPtr (const char*,int*,const char*(*)(void*,int),void*,int,int)
 igMarkIniSettingsDirty	2
-1	void	igMarkIniSettingsDirtyNil ()
+1	void	igMarkIniSettingsDirty_Nil ()
-2	void	igMarkIniSettingsDirtyWindowPtr (ImGuiWindow*)
+2	void	igMarkIniSettingsDirty_WindowPtr (ImGuiWindow*)
 igMenuItem	2
-1	bool	igMenuItemBool (const char*,const char*,bool,bool)
+1	bool	igMenuItem_Bool (const char*,const char*,bool,bool)
-2	bool	igMenuItemBoolPtr (const char*,const char*,bool*,bool)
+2	bool	igMenuItem_BoolPtr (const char*,const char*,bool*,bool)
+igOpenPopup	2
+1	void	igOpenPopup_Str (const char*,ImGuiPopupFlags)
+2	void	igOpenPopup_ID (ImGuiID,ImGuiPopupFlags)
 igPlotHistogram	2
-1	void	igPlotHistogramFloatPtr (const char*,const float*,int,int,const char*,float,float,ImVec2,int)
+1	void	igPlotHistogram_FloatPtr (const char*,const float*,int,int,const char*,float,float,ImVec2,int)
-2	void	igPlotHistogramFnFloatPtr (const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2)
+2	void	igPlotHistogram_FnFloatPtr (const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2)
 igPlotLines	2
-1	void	igPlotLinesFloatPtr (const char*,const float*,int,int,const char*,float,float,ImVec2,int)
+1	void	igPlotLines_FloatPtr (const char*,const float*,int,int,const char*,float,float,ImVec2,int)
-2	void	igPlotLinesFnFloatPtr (const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2)
+2	void	igPlotLines_FnFloatPtr (const char*,float(*)(void*,int),void*,int,int,const char*,float,float,ImVec2)
 igPushID	4
-1	void	igPushIDStr (const char*)
+1	void	igPushID_Str (const char*)
-2	void	igPushIDStrStr (const char*,const char*)
+2	void	igPushID_StrStr (const char*,const char*)
-3	void	igPushIDPtr (const void*)
+3	void	igPushID_Ptr (const void*)
-4	void	igPushIDInt (int)
+4	void	igPushID_Int (int)
 igPushStyleColor	2
-1	void	igPushStyleColorU32 (ImGuiCol,ImU32)
+1	void	igPushStyleColor_U32 (ImGuiCol,ImU32)
-2	void	igPushStyleColorVec4 (ImGuiCol,const ImVec4)
+2	void	igPushStyleColor_Vec4 (ImGuiCol,const ImVec4)
 igPushStyleVar	2
-1	void	igPushStyleVarFloat (ImGuiStyleVar,float)
+1	void	igPushStyleVar_Float (ImGuiStyleVar,float)
-2	void	igPushStyleVarVec2 (ImGuiStyleVar,const ImVec2)
+2	void	igPushStyleVar_Vec2 (ImGuiStyleVar,const ImVec2)
 igRadioButton	2
-1	bool	igRadioButtonBool (const char*,bool)
+1	bool	igRadioButton_Bool (const char*,bool)
-2	bool	igRadioButtonIntPtr (const char*,int*,int)
+2	bool	igRadioButton_IntPtr (const char*,int*,int)
 igSelectable	2
-1	bool	igSelectableBool (const char*,bool,ImGuiSelectableFlags,const ImVec2)
+1	bool	igSelectable_Bool (const char*,bool,ImGuiSelectableFlags,const ImVec2)
-2	bool	igSelectableBoolPtr (const char*,bool*,ImGuiSelectableFlags,const ImVec2)
+2	bool	igSelectable_BoolPtr (const char*,bool*,ImGuiSelectableFlags,const ImVec2)
+igSetItemKeyOwner	2
+1	void	igSetItemKeyOwner_Nil (ImGuiKey)
+2	void	igSetItemKeyOwner_InputFlags (ImGuiKey,ImGuiInputFlags)
 igSetScrollFromPosX	2
-1	void	igSetScrollFromPosXFloat (float,float)
+1	void	igSetScrollFromPosX_Float (float,float)
-2	void	igSetScrollFromPosXWindowPtr (ImGuiWindow*,float,float)
+2	void	igSetScrollFromPosX_WindowPtr (ImGuiWindow*,float,float)
 igSetScrollFromPosY	2
-1	void	igSetScrollFromPosYFloat (float,float)
+1	void	igSetScrollFromPosY_Float (float,float)
-2	void	igSetScrollFromPosYWindowPtr (ImGuiWindow*,float,float)
+2	void	igSetScrollFromPosY_WindowPtr (ImGuiWindow*,float,float)
 igSetScrollX	2
-1	void	igSetScrollXFloat (float)
+1	void	igSetScrollX_Float (float)
-2	void	igSetScrollXWindowPtr (ImGuiWindow*,float)
+2	void	igSetScrollX_WindowPtr (ImGuiWindow*,float)
 igSetScrollY	2
-1	void	igSetScrollYFloat (float)
+1	void	igSetScrollY_Float (float)
-2	void	igSetScrollYWindowPtr (ImGuiWindow*,float)
+2	void	igSetScrollY_WindowPtr (ImGuiWindow*,float)
 igSetWindowCollapsed	3
-1	void	igSetWindowCollapsedBool (bool,ImGuiCond)
+1	void	igSetWindowCollapsed_Bool (bool,ImGuiCond)
-2	void	igSetWindowCollapsedStr (const char*,bool,ImGuiCond)
+2	void	igSetWindowCollapsed_Str (const char*,bool,ImGuiCond)
-3	void	igSetWindowCollapsedWindowPtr (ImGuiWindow*,bool,ImGuiCond)
+3	void	igSetWindowCollapsed_WindowPtr (ImGuiWindow*,bool,ImGuiCond)
 igSetWindowFocus	2
-1	void	igSetWindowFocusNil ()
+1	void	igSetWindowFocus_Nil ()
-2	void	igSetWindowFocusStr (const char*)
+2	void	igSetWindowFocus_Str (const char*)
 igSetWindowPos	3
-1	void	igSetWindowPosVec2 (const ImVec2,ImGuiCond)
+1	void	igSetWindowPos_Vec2 (const ImVec2,ImGuiCond)
-2	void	igSetWindowPosStr (const char*,const ImVec2,ImGuiCond)
+2	void	igSetWindowPos_Str (const char*,const ImVec2,ImGuiCond)
-3	void	igSetWindowPosWindowPtr (ImGuiWindow*,const ImVec2,ImGuiCond)
+3	void	igSetWindowPos_WindowPtr (ImGuiWindow*,const ImVec2,ImGuiCond)
 igSetWindowSize	3
-1	void	igSetWindowSizeVec2 (const ImVec2,ImGuiCond)
+1	void	igSetWindowSize_Vec2 (const ImVec2,ImGuiCond)
-2	void	igSetWindowSizeStr (const char*,const ImVec2,ImGuiCond)
+2	void	igSetWindowSize_Str (const char*,const ImVec2,ImGuiCond)
-3	void	igSetWindowSizeWindowPtr (ImGuiWindow*,const ImVec2,ImGuiCond)
+3	void	igSetWindowSize_WindowPtr (ImGuiWindow*,const ImVec2,ImGuiCond)
+igShortcut	2
+1	bool	igShortcut_Nil (ImGuiKeyChord,ImGuiInputFlags)
+2	bool	igShortcut_ID (ImGuiKeyChord,ImGuiInputFlags,ImGuiID)
+igTabBarQueueFocus	2
+1	void	igTabBarQueueFocus_TabItemPtr (ImGuiTabBar*,ImGuiTabItem*)
+2	void	igTabBarQueueFocus_Str (ImGuiTabBar*,const char*)
+igTabItemCalcSize	2
+1	ImVec2	igTabItemCalcSize_Str (const char*,bool)
+2	ImVec2	igTabItemCalcSize_WindowPtr (ImGuiWindow*)
+igTableGcCompactTransientBuffers	2
+1	void	igTableGcCompactTransientBuffers_TablePtr (ImGuiTable*)
+2	void	igTableGcCompactTransientBuffers_TableTempDataPtr (ImGuiTableTempData*)
 igTableGetColumnName	2
-1	const char*	igTableGetColumnNameInt (int)
+1	const char*	igTableGetColumnName_Int (int)
-2	const char*	igTableGetColumnNameTablePtr (const ImGuiTable*,int)
+2	const char*	igTableGetColumnName_TablePtr (const ImGuiTable*,int)
 igTreeNode	3
-1	bool	igTreeNodeStr (const char*)
+1	bool	igTreeNode_Str (const char*)
-2	bool	igTreeNodeStrStr (const char*,const char*,...)
+2	bool	igTreeNode_StrStr (const char*,const char*,...)
-3	bool	igTreeNodePtr (const void*,const char*,...)
+3	bool	igTreeNode_Ptr (const void*,const char*,...)
 igTreeNodeEx	3
-1	bool	igTreeNodeExStr (const char*,ImGuiTreeNodeFlags)
+1	bool	igTreeNodeEx_Str (const char*,ImGuiTreeNodeFlags)
-2	bool	igTreeNodeExStrStr (const char*,ImGuiTreeNodeFlags,const char*,...)
+2	bool	igTreeNodeEx_StrStr (const char*,ImGuiTreeNodeFlags,const char*,...)
-3	bool	igTreeNodeExPtr (const void*,ImGuiTreeNodeFlags,const char*,...)
+3	bool	igTreeNodeEx_Ptr (const void*,ImGuiTreeNodeFlags,const char*,...)
 igTreeNodeExV	2
-1	bool	igTreeNodeExVStr (const char*,ImGuiTreeNodeFlags,const char*,va_list)
+1	bool	igTreeNodeExV_Str (const char*,ImGuiTreeNodeFlags,const char*,va_list)
-2	bool	igTreeNodeExVPtr (const void*,ImGuiTreeNodeFlags,const char*,va_list)
+2	bool	igTreeNodeExV_Ptr (const void*,ImGuiTreeNodeFlags,const char*,va_list)
 igTreeNodeV	2
-1	bool	igTreeNodeVStr (const char*,const char*,va_list)
+1	bool	igTreeNodeV_Str (const char*,const char*,va_list)
-2	bool	igTreeNodeVPtr (const void*,const char*,va_list)
+2	bool	igTreeNodeV_Ptr (const void*,const char*,va_list)
 igTreePush	2
-1	void	igTreePushStr (const char*)
+1	void	igTreePush_Str (const char*)
-2	void	igTreePushPtr (const void*)
+2	void	igTreePush_Ptr (const void*)
 igValue	4
-1	void	igValueBool (const char*,bool)
+1	void	igValue_Bool (const char*,bool)
-2	void	igValueInt (const char*,int)
+2	void	igValue_Int (const char*,int)
-3	void	igValueUint (const char*,unsigned int)
+3	void	igValue_Uint (const char*,unsigned int)
-4	void	igValueFloat (const char*,float,const char*)
+4	void	igValue_Float (const char*,float,const char*)
-173 overloaded
+216 overloaded

generator/output/typedefs_dict.json

@@ -1,7 +1,9 @@
 {
+  "ImBitArrayForNamedKeys": "ImBitArray<ImGuiKey_NamedKey_COUNT, -ImGuiKey_NamedKey_BEGIN>",
+  "ImBitArrayPtr": "ImU32*",
   "ImBitVector": "struct ImBitVector",
   "ImColor": "struct ImColor",
-  "ImDrawCallback": "void(*)(const ImDrawList* parent_list,const ImDrawCmd* cmd);",
+  "ImDrawCallback": "void (*)(const ImDrawList* parent_list, const ImDrawCmd* cmd);",
   "ImDrawChannel": "struct ImDrawChannel",
   "ImDrawCmd": "struct ImDrawCmd",
   "ImDrawCmdHeader": "struct ImDrawCmdHeader",
@@ -17,56 +19,95 @@
   "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",
   "ImGuiButtonFlags": "int",
+  "ImGuiChildFlags": "int",
   "ImGuiCol": "int",
   "ImGuiColorEditFlags": "int",
   "ImGuiColorMod": "struct ImGuiColorMod",
   "ImGuiComboFlags": "int",
+  "ImGuiComboPreviewData": "struct ImGuiComboPreviewData",
   "ImGuiCond": "int",
   "ImGuiConfigFlags": "int",
   "ImGuiContext": "struct ImGuiContext",
   "ImGuiContextHook": "struct ImGuiContextHook",
-  "ImGuiContextHookCallback": "void(*)(ImGuiContext* ctx,ImGuiContextHook* hook);",
+  "ImGuiContextHookCallback": "void (*)(ImGuiContext* ctx, ImGuiContextHook* hook);",
   "ImGuiDataType": "int",
   "ImGuiDataTypeInfo": "struct ImGuiDataTypeInfo",
-  "ImGuiDataTypeTempStorage": "struct ImGuiDataTypeTempStorage",
+  "ImGuiDataTypeStorage": "struct ImGuiDataTypeStorage",
-  "ImGuiDir": "int",
+  "ImGuiDeactivatedItemData": "struct ImGuiDeactivatedItemData",
+  "ImGuiDebugAllocEntry": "struct ImGuiDebugAllocEntry",
+  "ImGuiDebugAllocInfo": "struct ImGuiDebugAllocInfo",
+  "ImGuiDebugLogFlags": "int",
   "ImGuiDragDropFlags": "int",
-  "ImGuiErrorLogCallback": "void(*)(void* user_data,const char* fmt,...);",
+  "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",
+  "ImGuiIDStackTool": "struct ImGuiIDStackTool",
   "ImGuiIO": "struct ImGuiIO",
-  "ImGuiInputTextCallback": "int(*)(ImGuiInputTextCallbackData* data);",
+  "ImGuiInputEvent": "struct ImGuiInputEvent",
+  "ImGuiInputEventAppFocused": "struct ImGuiInputEventAppFocused",
+  "ImGuiInputEventKey": "struct ImGuiInputEventKey",
+  "ImGuiInputEventMouseButton": "struct ImGuiInputEventMouseButton",
+  "ImGuiInputEventMousePos": "struct ImGuiInputEventMousePos",
+  "ImGuiInputEventMouseWheel": "struct ImGuiInputEventMouseWheel",
+  "ImGuiInputEventText": "struct ImGuiInputEventText",
+  "ImGuiInputFlags": "int",
+  "ImGuiInputTextCallback": "int (*)(ImGuiInputTextCallbackData* data);",
   "ImGuiInputTextCallbackData": "struct ImGuiInputTextCallbackData",
+  "ImGuiInputTextDeactivateData": "struct ImGuiInputTextDeactivateData",
+  "ImGuiInputTextDeactivatedState": "struct ImGuiInputTextDeactivatedState",
   "ImGuiInputTextFlags": "int",
   "ImGuiInputTextState": "struct ImGuiInputTextState",
   "ImGuiItemFlags": "int",
   "ImGuiItemStatusFlags": "int",
-  "ImGuiKey": "int",
+  "ImGuiKeyChord": "int",
-  "ImGuiKeyModFlags": "int",
+  "ImGuiKeyData": "struct ImGuiKeyData",
-  "ImGuiLastItemDataBackup": "struct ImGuiLastItemDataBackup",
+  "ImGuiKeyOwnerData": "struct ImGuiKeyOwnerData",
+  "ImGuiKeyRoutingData": "struct ImGuiKeyRoutingData",
+  "ImGuiKeyRoutingIndex": "ImS16",
+  "ImGuiKeyRoutingTable": "struct ImGuiKeyRoutingTable",
+  "ImGuiLastItemData": "struct ImGuiLastItemData",
   "ImGuiLayoutType": "int",
   "ImGuiListClipper": "struct ImGuiListClipper",
-  "ImGuiMemAllocFunc": "void*(*)(size_t sz,void* user_data);",
+  "ImGuiListClipperData": "struct ImGuiListClipperData",
-  "ImGuiMemFreeFunc": "void(*)(void* ptr,void* user_data);",
+  "ImGuiListClipperRange": "struct ImGuiListClipperRange",
+  "ImGuiLocEntry": "struct ImGuiLocEntry",
+  "ImGuiLogFlags": "int",
+  "ImGuiMemAllocFunc": "void* (*)(size_t sz, void* user_data);",
+  "ImGuiMemFreeFunc": "void (*)(void* ptr, void* user_data);",
   "ImGuiMenuColumns": "struct ImGuiMenuColumns",
   "ImGuiMetricsConfig": "struct ImGuiMetricsConfig",
   "ImGuiMouseButton": "int",
   "ImGuiMouseCursor": "int",
-  "ImGuiNavDirSourceFlags": "int",
+  "ImGuiMultiSelectFlags": "int",
-  "ImGuiNavHighlightFlags": "int",
+  "ImGuiMultiSelectIO": "struct ImGuiMultiSelectIO",
-  "ImGuiNavInput": "int",
+  "ImGuiMultiSelectState": "struct ImGuiMultiSelectState",
+  "ImGuiMultiSelectTempData": "struct ImGuiMultiSelectTempData",
+  "ImGuiNavItemData": "struct ImGuiNavItemData",
   "ImGuiNavMoveFlags": "int",
-  "ImGuiNavMoveResult": "struct ImGuiNavMoveResult",
+  "ImGuiNavRenderCursorFlags": "int",
   "ImGuiNextItemData": "struct ImGuiNextItemData",
   "ImGuiNextItemDataFlags": "int",
   "ImGuiNextWindowData": "struct ImGuiNextWindowData",
@@ -76,23 +117,30 @@
   "ImGuiOldColumns": "struct ImGuiOldColumns",
   "ImGuiOnceUponAFrame": "struct ImGuiOnceUponAFrame",
   "ImGuiPayload": "struct ImGuiPayload",
+  "ImGuiPlatformIO": "struct ImGuiPlatformIO",
+  "ImGuiPlatformImeData": "struct ImGuiPlatformImeData",
   "ImGuiPopupData": "struct ImGuiPopupData",
   "ImGuiPopupFlags": "int",
   "ImGuiPtrOrIndex": "struct ImGuiPtrOrIndex",
+  "ImGuiScrollFlags": "int",
   "ImGuiSelectableFlags": "int",
+  "ImGuiSelectionBasicStorage": "struct ImGuiSelectionBasicStorage",
+  "ImGuiSelectionExternalStorage": "struct ImGuiSelectionExternalStorage",
+  "ImGuiSelectionRequest": "struct ImGuiSelectionRequest",
+  "ImGuiSelectionUserData": "ImS64",
   "ImGuiSeparatorFlags": "int",
   "ImGuiSettingsHandler": "struct ImGuiSettingsHandler",
   "ImGuiShrinkWidthItem": "struct ImGuiShrinkWidthItem",
-  "ImGuiSizeCallback": "void(*)(ImGuiSizeCallbackData* data);",
+  "ImGuiSizeCallback": "void (*)(ImGuiSizeCallbackData* data);",
   "ImGuiSizeCallbackData": "struct ImGuiSizeCallbackData",
   "ImGuiSliderFlags": "int",
-  "ImGuiSortDirection": "int",
+  "ImGuiStackLevelInfo": "struct ImGuiStackLevelInfo",
-  "ImGuiStackSizes": "struct ImGuiStackSizes",
   "ImGuiStorage": "struct ImGuiStorage",
   "ImGuiStoragePair": "struct ImGuiStoragePair",
   "ImGuiStyle": "struct ImGuiStyle",
   "ImGuiStyleMod": "struct ImGuiStyleMod",
   "ImGuiStyleVar": "int",
+  "ImGuiStyleVarInfo": "struct ImGuiStyleVarInfo",
   "ImGuiTabBar": "struct ImGuiTabBar",
   "ImGuiTabBarFlags": "int",
   "ImGuiTabItem": "struct ImGuiTabItem",
@@ -102,51 +150,63 @@
   "ImGuiTableCellData": "struct ImGuiTableCellData",
   "ImGuiTableColumn": "struct ImGuiTableColumn",
   "ImGuiTableColumnFlags": "int",
-  "ImGuiTableColumnIdx": "ImS8",
+  "ImGuiTableColumnIdx": "ImS16",
   "ImGuiTableColumnSettings": "struct ImGuiTableColumnSettings",
   "ImGuiTableColumnSortSpecs": "struct ImGuiTableColumnSortSpecs",
   "ImGuiTableColumnsSettings": "struct ImGuiTableColumnsSettings",
-  "ImGuiTableDrawChannelIdx": "ImU8",
+  "ImGuiTableDrawChannelIdx": "ImU16",
   "ImGuiTableFlags": "int",
+  "ImGuiTableHeaderData": "struct ImGuiTableHeaderData",
+  "ImGuiTableInstanceData": "struct ImGuiTableInstanceData",
   "ImGuiTableRowFlags": "int",
   "ImGuiTableSettings": "struct ImGuiTableSettings",
   "ImGuiTableSortSpecs": "struct ImGuiTableSortSpecs",
+  "ImGuiTableTempData": "struct ImGuiTableTempData",
   "ImGuiTextBuffer": "struct ImGuiTextBuffer",
   "ImGuiTextFilter": "struct ImGuiTextFilter",
   "ImGuiTextFlags": "int",
+  "ImGuiTextIndex": "struct ImGuiTextIndex",
   "ImGuiTextRange": "struct ImGuiTextRange",
   "ImGuiTooltipFlags": "int",
   "ImGuiTreeNodeFlags": "int",
+  "ImGuiTreeNodeStackData": "struct ImGuiTreeNodeStackData",
+  "ImGuiTypingSelectFlags": "int",
+  "ImGuiTypingSelectRequest": "struct ImGuiTypingSelectRequest",
+  "ImGuiTypingSelectState": "struct ImGuiTypingSelectState",
   "ImGuiViewport": "struct ImGuiViewport",
   "ImGuiViewportFlags": "int",
   "ImGuiViewportP": "struct ImGuiViewportP",
   "ImGuiWindow": "struct ImGuiWindow",
   "ImGuiWindowFlags": "int",
+  "ImGuiWindowRefreshFlags": "int",
   "ImGuiWindowSettings": "struct ImGuiWindowSettings",
+  "ImGuiWindowStackData": "struct ImGuiWindowStackData",
   "ImGuiWindowTempData": "struct ImGuiWindowTempData",
   "ImPoolIdx": "int",
   "ImRect": "struct ImRect",
   "ImS16": "signed short",
   "ImS32": "signed int",
-  "ImS64": "int64_t",
+  "ImS64": "signed long long",
   "ImS8": "signed char",
-  "ImTextureID": "void*",
+  "ImStbTexteditState": "ImStb::STB_TexteditState",
+  "ImTextureData": "struct ImTextureData",
+  "ImTextureID": "ImU64",
+  "ImTextureRect": "struct ImTextureRect",
+  "ImTextureRef": "struct ImTextureRef",
   "ImU16": "unsigned short",
   "ImU32": "unsigned int",
-  "ImU64": "uint64_t",
+  "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",
-  "StbTexteditRow": "struct StbTexteditRow",
+  "stbrp_context_opaque": "struct stbrp_context_opaque",
-  "StbUndoRecord": "struct StbUndoRecord",
+  "stbrp_node": "struct stbrp_node",
-  "StbUndoState": "struct StbUndoState",
+  "stbrp_node_im": "stbrp_node"
-  "const_iterator": "const value_type*",
-  "iterator": "value_type*",
-  "value_type": "T"
 }

generator/output/typedefs_dict.lua

@@ -1,153 +1,212 @@
-local defs = {}
+local t={
-defs["ImBitVector"] = "struct ImBitVector"
+  ImBitArrayForNamedKeys="ImBitArray<ImGuiKey_NamedKey_COUNT, -ImGuiKey_NamedKey_BEGIN>",
-defs["ImColor"] = "struct ImColor"
+  ImBitArrayPtr="ImU32*",
-defs["ImDrawCallback"] = "void(*)(const ImDrawList* parent_list,const ImDrawCmd* cmd);"
+  ImBitVector="struct ImBitVector",
-defs["ImDrawChannel"] = "struct ImDrawChannel"
+  ImColor="struct ImColor",
-defs["ImDrawCmd"] = "struct ImDrawCmd"
+  ImDrawCallback="void (*)(const ImDrawList* parent_list, const ImDrawCmd* cmd);",
-defs["ImDrawCmdHeader"] = "struct ImDrawCmdHeader"
+  ImDrawChannel="struct ImDrawChannel",
-defs["ImDrawData"] = "struct ImDrawData"
+  ImDrawCmd="struct ImDrawCmd",
-defs["ImDrawDataBuilder"] = "struct ImDrawDataBuilder"
+  ImDrawCmdHeader="struct ImDrawCmdHeader",
-defs["ImDrawFlags"] = "int"
+  ImDrawData="struct ImDrawData",
-defs["ImDrawIdx"] = "unsigned short"
+  ImDrawDataBuilder="struct ImDrawDataBuilder",
-defs["ImDrawList"] = "struct ImDrawList"
+  ImDrawFlags="int",
-defs["ImDrawListFlags"] = "int"
+  ImDrawIdx="unsigned short",
-defs["ImDrawListSharedData"] = "struct ImDrawListSharedData"
+  ImDrawList="struct ImDrawList",
-defs["ImDrawListSplitter"] = "struct ImDrawListSplitter"
+  ImDrawListFlags="int",
-defs["ImDrawVert"] = "struct ImDrawVert"
+  ImDrawListSharedData="struct ImDrawListSharedData",
-defs["ImFileHandle"] = "FILE*"
+  ImDrawListSplitter="struct ImDrawListSplitter",
-defs["ImFont"] = "struct ImFont"
+  ImDrawVert="struct ImDrawVert",
-defs["ImFontAtlas"] = "struct ImFontAtlas"
+  ImFileHandle="FILE*",
-defs["ImFontAtlasCustomRect"] = "struct ImFontAtlasCustomRect"
+  ImFont="struct ImFont",
-defs["ImFontAtlasFlags"] = "int"
+  ImFontAtlas="struct ImFontAtlas",
-defs["ImFontBuilderIO"] = "struct ImFontBuilderIO"
+  ImFontAtlasBuilder="struct ImFontAtlasBuilder",
-defs["ImFontConfig"] = "struct ImFontConfig"
+  ImFontAtlasFlags="int",
-defs["ImFontGlyph"] = "struct ImFontGlyph"
+  ImFontAtlasPostProcessData="struct ImFontAtlasPostProcessData",
-defs["ImFontGlyphRangesBuilder"] = "struct ImFontGlyphRangesBuilder"
+  ImFontAtlasRect="struct ImFontAtlasRect",
-defs["ImGuiBackendFlags"] = "int"
+  ImFontAtlasRectEntry="struct ImFontAtlasRectEntry",
-defs["ImGuiButtonFlags"] = "int"
+  ImFontAtlasRectId="int",
-defs["ImGuiCol"] = "int"
+  ImFontBaked="struct ImFontBaked",
-defs["ImGuiColorEditFlags"] = "int"
+  ImFontConfig="struct ImFontConfig",
-defs["ImGuiColorMod"] = "struct ImGuiColorMod"
+  ImFontFlags="int",
-defs["ImGuiComboFlags"] = "int"
+  ImFontGlyph="struct ImFontGlyph",
-defs["ImGuiCond"] = "int"
+  ImFontGlyphRangesBuilder="struct ImFontGlyphRangesBuilder",
-defs["ImGuiConfigFlags"] = "int"
+  ImFontLoader="struct ImFontLoader",
-defs["ImGuiContext"] = "struct ImGuiContext"
+  ImFontStackData="struct ImFontStackData",
-defs["ImGuiContextHook"] = "struct ImGuiContextHook"
+  ImGuiActivateFlags="int",
-defs["ImGuiContextHookCallback"] = "void(*)(ImGuiContext* ctx,ImGuiContextHook* hook);"
+  ImGuiBackendFlags="int",
-defs["ImGuiDataType"] = "int"
+  ImGuiBoxSelectState="struct ImGuiBoxSelectState",
-defs["ImGuiDataTypeInfo"] = "struct ImGuiDataTypeInfo"
+  ImGuiButtonFlags="int",
-defs["ImGuiDataTypeTempStorage"] = "struct ImGuiDataTypeTempStorage"
+  ImGuiChildFlags="int",
-defs["ImGuiDir"] = "int"
+  ImGuiCol="int",
-defs["ImGuiDragDropFlags"] = "int"
+  ImGuiColorEditFlags="int",
-defs["ImGuiErrorLogCallback"] = "void(*)(void* user_data,const char* fmt,...);"
+  ImGuiColorMod="struct ImGuiColorMod",
-defs["ImGuiFocusedFlags"] = "int"
+  ImGuiComboFlags="int",
-defs["ImGuiGroupData"] = "struct ImGuiGroupData"
+  ImGuiComboPreviewData="struct ImGuiComboPreviewData",
-defs["ImGuiHoveredFlags"] = "int"
+  ImGuiCond="int",
-defs["ImGuiID"] = "unsigned int"
+  ImGuiConfigFlags="int",
-defs["ImGuiIO"] = "struct ImGuiIO"
+  ImGuiContext="struct ImGuiContext",
-defs["ImGuiInputTextCallback"] = "int(*)(ImGuiInputTextCallbackData* data);"
+  ImGuiContextHook="struct ImGuiContextHook",
-defs["ImGuiInputTextCallbackData"] = "struct ImGuiInputTextCallbackData"
+  ImGuiContextHookCallback="void (*)(ImGuiContext* ctx, ImGuiContextHook* hook);",
-defs["ImGuiInputTextFlags"] = "int"
+  ImGuiDataType="int",
-defs["ImGuiInputTextState"] = "struct ImGuiInputTextState"
+  ImGuiDataTypeInfo="struct ImGuiDataTypeInfo",
-defs["ImGuiItemFlags"] = "int"
+  ImGuiDataTypeStorage="struct ImGuiDataTypeStorage",
-defs["ImGuiItemStatusFlags"] = "int"
+  ImGuiDeactivatedItemData="struct ImGuiDeactivatedItemData",
-defs["ImGuiKey"] = "int"
+  ImGuiDebugAllocEntry="struct ImGuiDebugAllocEntry",
-defs["ImGuiKeyModFlags"] = "int"
+  ImGuiDebugAllocInfo="struct ImGuiDebugAllocInfo",
-defs["ImGuiLastItemDataBackup"] = "struct ImGuiLastItemDataBackup"
+  ImGuiDebugLogFlags="int",
-defs["ImGuiLayoutType"] = "int"
+  ImGuiDragDropFlags="int",
-defs["ImGuiListClipper"] = "struct ImGuiListClipper"
+  ImGuiErrorCallback="void (*)(ImGuiContext* ctx, void* user_data, const char* msg);",
-defs["ImGuiMemAllocFunc"] = "void*(*)(size_t sz,void* user_data);"
+  ImGuiErrorRecoveryState="struct ImGuiErrorRecoveryState",
-defs["ImGuiMemFreeFunc"] = "void(*)(void* ptr,void* user_data);"
+  ImGuiFocusRequestFlags="int",
-defs["ImGuiMenuColumns"] = "struct ImGuiMenuColumns"
+  ImGuiFocusScopeData="struct ImGuiFocusScopeData",
-defs["ImGuiMetricsConfig"] = "struct ImGuiMetricsConfig"
+  ImGuiFocusedFlags="int",
-defs["ImGuiMouseButton"] = "int"
+  ImGuiFreeTypeLoaderFlags="unsigned int",
-defs["ImGuiMouseCursor"] = "int"
+  ImGuiGroupData="struct ImGuiGroupData",
-defs["ImGuiNavDirSourceFlags"] = "int"
+  ImGuiHoveredFlags="int",
-defs["ImGuiNavHighlightFlags"] = "int"
+  ImGuiID="unsigned int",
-defs["ImGuiNavInput"] = "int"
+  ImGuiIDStackTool="struct ImGuiIDStackTool",
-defs["ImGuiNavMoveFlags"] = "int"
+  ImGuiIO="struct ImGuiIO",
-defs["ImGuiNavMoveResult"] = "struct ImGuiNavMoveResult"
+  ImGuiInputEvent="struct ImGuiInputEvent",
-defs["ImGuiNextItemData"] = "struct ImGuiNextItemData"
+  ImGuiInputEventAppFocused="struct ImGuiInputEventAppFocused",
-defs["ImGuiNextItemDataFlags"] = "int"
+  ImGuiInputEventKey="struct ImGuiInputEventKey",
-defs["ImGuiNextWindowData"] = "struct ImGuiNextWindowData"
+  ImGuiInputEventMouseButton="struct ImGuiInputEventMouseButton",
-defs["ImGuiNextWindowDataFlags"] = "int"
+  ImGuiInputEventMousePos="struct ImGuiInputEventMousePos",
-defs["ImGuiOldColumnData"] = "struct ImGuiOldColumnData"
+  ImGuiInputEventMouseWheel="struct ImGuiInputEventMouseWheel",
-defs["ImGuiOldColumnFlags"] = "int"
+  ImGuiInputEventText="struct ImGuiInputEventText",
-defs["ImGuiOldColumns"] = "struct ImGuiOldColumns"
+  ImGuiInputFlags="int",
-defs["ImGuiOnceUponAFrame"] = "struct ImGuiOnceUponAFrame"
+  ImGuiInputTextCallback="int (*)(ImGuiInputTextCallbackData* data);",
-defs["ImGuiPayload"] = "struct ImGuiPayload"
+  ImGuiInputTextCallbackData="struct ImGuiInputTextCallbackData",
-defs["ImGuiPopupData"] = "struct ImGuiPopupData"
+  ImGuiInputTextDeactivateData="struct ImGuiInputTextDeactivateData",
-defs["ImGuiPopupFlags"] = "int"
+  ImGuiInputTextDeactivatedState="struct ImGuiInputTextDeactivatedState",
-defs["ImGuiPtrOrIndex"] = "struct ImGuiPtrOrIndex"
+  ImGuiInputTextFlags="int",
-defs["ImGuiSelectableFlags"] = "int"
+  ImGuiInputTextState="struct ImGuiInputTextState",
-defs["ImGuiSeparatorFlags"] = "int"
+  ImGuiItemFlags="int",
-defs["ImGuiSettingsHandler"] = "struct ImGuiSettingsHandler"
+  ImGuiItemStatusFlags="int",
-defs["ImGuiShrinkWidthItem"] = "struct ImGuiShrinkWidthItem"
+  ImGuiKeyChord="int",
-defs["ImGuiSizeCallback"] = "void(*)(ImGuiSizeCallbackData* data);"
+  ImGuiKeyData="struct ImGuiKeyData",
-defs["ImGuiSizeCallbackData"] = "struct ImGuiSizeCallbackData"
+  ImGuiKeyOwnerData="struct ImGuiKeyOwnerData",
-defs["ImGuiSliderFlags"] = "int"
+  ImGuiKeyRoutingData="struct ImGuiKeyRoutingData",
-defs["ImGuiSortDirection"] = "int"
+  ImGuiKeyRoutingIndex="ImS16",
-defs["ImGuiStackSizes"] = "struct ImGuiStackSizes"
+  ImGuiKeyRoutingTable="struct ImGuiKeyRoutingTable",
-defs["ImGuiStorage"] = "struct ImGuiStorage"
+  ImGuiLastItemData="struct ImGuiLastItemData",
-defs["ImGuiStoragePair"] = "struct ImGuiStoragePair"
+  ImGuiLayoutType="int",
-defs["ImGuiStyle"] = "struct ImGuiStyle"
+  ImGuiListClipper="struct ImGuiListClipper",
-defs["ImGuiStyleMod"] = "struct ImGuiStyleMod"
+  ImGuiListClipperData="struct ImGuiListClipperData",
-defs["ImGuiStyleVar"] = "int"
+  ImGuiListClipperRange="struct ImGuiListClipperRange",
-defs["ImGuiTabBar"] = "struct ImGuiTabBar"
+  ImGuiLocEntry="struct ImGuiLocEntry",
-defs["ImGuiTabBarFlags"] = "int"
+  ImGuiLogFlags="int",
-defs["ImGuiTabItem"] = "struct ImGuiTabItem"
+  ImGuiMemAllocFunc="void* (*)(size_t sz, void* user_data);",
-defs["ImGuiTabItemFlags"] = "int"
+  ImGuiMemFreeFunc="void (*)(void* ptr, void* user_data);",
-defs["ImGuiTable"] = "struct ImGuiTable"
+  ImGuiMenuColumns="struct ImGuiMenuColumns",
-defs["ImGuiTableBgTarget"] = "int"
+  ImGuiMetricsConfig="struct ImGuiMetricsConfig",
-defs["ImGuiTableCellData"] = "struct ImGuiTableCellData"
+  ImGuiMouseButton="int",
-defs["ImGuiTableColumn"] = "struct ImGuiTableColumn"
+  ImGuiMouseCursor="int",
-defs["ImGuiTableColumnFlags"] = "int"
+  ImGuiMultiSelectFlags="int",
-defs["ImGuiTableColumnIdx"] = "ImS8"
+  ImGuiMultiSelectIO="struct ImGuiMultiSelectIO",
-defs["ImGuiTableColumnSettings"] = "struct ImGuiTableColumnSettings"
+  ImGuiMultiSelectState="struct ImGuiMultiSelectState",
-defs["ImGuiTableColumnSortSpecs"] = "struct ImGuiTableColumnSortSpecs"
+  ImGuiMultiSelectTempData="struct ImGuiMultiSelectTempData",
-defs["ImGuiTableColumnsSettings"] = "struct ImGuiTableColumnsSettings"
+  ImGuiNavItemData="struct ImGuiNavItemData",
-defs["ImGuiTableDrawChannelIdx"] = "ImU8"
+  ImGuiNavMoveFlags="int",
-defs["ImGuiTableFlags"] = "int"
+  ImGuiNavRenderCursorFlags="int",
-defs["ImGuiTableRowFlags"] = "int"
+  ImGuiNextItemData="struct ImGuiNextItemData",
-defs["ImGuiTableSettings"] = "struct ImGuiTableSettings"
+  ImGuiNextItemDataFlags="int",
-defs["ImGuiTableSortSpecs"] = "struct ImGuiTableSortSpecs"
+  ImGuiNextWindowData="struct ImGuiNextWindowData",
-defs["ImGuiTextBuffer"] = "struct ImGuiTextBuffer"
+  ImGuiNextWindowDataFlags="int",
-defs["ImGuiTextFilter"] = "struct ImGuiTextFilter"
+  ImGuiOldColumnData="struct ImGuiOldColumnData",
-defs["ImGuiTextFlags"] = "int"
+  ImGuiOldColumnFlags="int",
-defs["ImGuiTextRange"] = "struct ImGuiTextRange"
+  ImGuiOldColumns="struct ImGuiOldColumns",
-defs["ImGuiTooltipFlags"] = "int"
+  ImGuiOnceUponAFrame="struct ImGuiOnceUponAFrame",
-defs["ImGuiTreeNodeFlags"] = "int"
+  ImGuiPayload="struct ImGuiPayload",
-defs["ImGuiViewport"] = "struct ImGuiViewport"
+  ImGuiPlatformIO="struct ImGuiPlatformIO",
-defs["ImGuiViewportFlags"] = "int"
+  ImGuiPlatformImeData="struct ImGuiPlatformImeData",
-defs["ImGuiViewportP"] = "struct ImGuiViewportP"
+  ImGuiPopupData="struct ImGuiPopupData",
-defs["ImGuiWindow"] = "struct ImGuiWindow"
+  ImGuiPopupFlags="int",
-defs["ImGuiWindowFlags"] = "int"
+  ImGuiPtrOrIndex="struct ImGuiPtrOrIndex",
-defs["ImGuiWindowSettings"] = "struct ImGuiWindowSettings"
+  ImGuiScrollFlags="int",
-defs["ImGuiWindowTempData"] = "struct ImGuiWindowTempData"
+  ImGuiSelectableFlags="int",
-defs["ImPoolIdx"] = "int"
+  ImGuiSelectionBasicStorage="struct ImGuiSelectionBasicStorage",
-defs["ImRect"] = "struct ImRect"
+  ImGuiSelectionExternalStorage="struct ImGuiSelectionExternalStorage",
-defs["ImS16"] = "signed short"
+  ImGuiSelectionRequest="struct ImGuiSelectionRequest",
-defs["ImS32"] = "signed int"
+  ImGuiSelectionUserData="ImS64",
-defs["ImS64"] = "int64_t"
+  ImGuiSeparatorFlags="int",
-defs["ImS8"] = "signed char"
+  ImGuiSettingsHandler="struct ImGuiSettingsHandler",
-defs["ImTextureID"] = "void*"
+  ImGuiShrinkWidthItem="struct ImGuiShrinkWidthItem",
-defs["ImU16"] = "unsigned short"
+  ImGuiSizeCallback="void (*)(ImGuiSizeCallbackData* data);",
-defs["ImU32"] = "unsigned int"
+  ImGuiSizeCallbackData="struct ImGuiSizeCallbackData",
-defs["ImU64"] = "uint64_t"
+  ImGuiSliderFlags="int",
-defs["ImU8"] = "unsigned char"
+  ImGuiStackLevelInfo="struct ImGuiStackLevelInfo",
-defs["ImVec1"] = "struct ImVec1"
+  ImGuiStorage="struct ImGuiStorage",
-defs["ImVec2"] = "struct ImVec2"
+  ImGuiStoragePair="struct ImGuiStoragePair",
-defs["ImVec2ih"] = "struct ImVec2ih"
+  ImGuiStyle="struct ImGuiStyle",
-defs["ImVec4"] = "struct ImVec4"
+  ImGuiStyleMod="struct ImGuiStyleMod",
-defs["ImWchar"] = "ImWchar16"
+  ImGuiStyleVar="int",
-defs["ImWchar16"] = "unsigned short"
+  ImGuiStyleVarInfo="struct ImGuiStyleVarInfo",
-defs["ImWchar32"] = "unsigned int"
+  ImGuiTabBar="struct ImGuiTabBar",
-defs["STB_TexteditState"] = "struct STB_TexteditState"
+  ImGuiTabBarFlags="int",
-defs["StbTexteditRow"] = "struct StbTexteditRow"
+  ImGuiTabItem="struct ImGuiTabItem",
-defs["StbUndoRecord"] = "struct StbUndoRecord"
+  ImGuiTabItemFlags="int",
-defs["StbUndoState"] = "struct StbUndoState"
+  ImGuiTable="struct ImGuiTable",
-defs["const_iterator"] = "const value_type*"
+  ImGuiTableBgTarget="int",
-defs["iterator"] = "value_type*"
+  ImGuiTableCellData="struct ImGuiTableCellData",
-defs["value_type"] = "T"
+  ImGuiTableColumn="struct ImGuiTableColumn",
-
+  ImGuiTableColumnFlags="int",
-return defs
+  ImGuiTableColumnIdx="ImS16",
+  ImGuiTableColumnSettings="struct ImGuiTableColumnSettings",
+  ImGuiTableColumnSortSpecs="struct ImGuiTableColumnSortSpecs",
+  ImGuiTableColumnsSettings="struct ImGuiTableColumnsSettings",
+  ImGuiTableDrawChannelIdx="ImU16",
+  ImGuiTableFlags="int",
+  ImGuiTableHeaderData="struct ImGuiTableHeaderData",
+  ImGuiTableInstanceData="struct ImGuiTableInstanceData",
+  ImGuiTableRowFlags="int",
+  ImGuiTableSettings="struct ImGuiTableSettings",
+  ImGuiTableSortSpecs="struct ImGuiTableSortSpecs",
+  ImGuiTableTempData="struct ImGuiTableTempData",
+  ImGuiTextBuffer="struct ImGuiTextBuffer",
+  ImGuiTextFilter="struct ImGuiTextFilter",
+  ImGuiTextFlags="int",
+  ImGuiTextIndex="struct ImGuiTextIndex",
+  ImGuiTextRange="struct ImGuiTextRange",
+  ImGuiTooltipFlags="int",
+  ImGuiTreeNodeFlags="int",
+  ImGuiTreeNodeStackData="struct ImGuiTreeNodeStackData",
+  ImGuiTypingSelectFlags="int",
+  ImGuiTypingSelectRequest="struct ImGuiTypingSelectRequest",
+  ImGuiTypingSelectState="struct ImGuiTypingSelectState",
+  ImGuiViewport="struct ImGuiViewport",
+  ImGuiViewportFlags="int",
+  ImGuiViewportP="struct ImGuiViewportP",
+  ImGuiWindow="struct ImGuiWindow",
+  ImGuiWindowFlags="int",
+  ImGuiWindowRefreshFlags="int",
+  ImGuiWindowSettings="struct ImGuiWindowSettings",
+  ImGuiWindowStackData="struct ImGuiWindowStackData",
+  ImGuiWindowTempData="struct ImGuiWindowTempData",
+  ImPoolIdx="int",
+  ImRect="struct ImRect",
+  ImS16="signed short",
+  ImS32="signed int",
+  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",
+  stbrp_context_opaque="struct stbrp_context_opaque",
+  stbrp_node="struct stbrp_node",
+  stbrp_node_im="stbrp_node"}
+ return t

generator/print_defines.cpp

@@ -0,0 +1,37 @@
+#include "imgui.h"
+
+#define CIMGUI_STRINGIZE_(x) #x
+#define CIMGUI_STRINGIZE(x) CIMGUI_STRINGIZE_(x)
+#define CIMGUI_DEFSTRING(x) "#define " #x " " CIMGUI_STRINGIZE(x)
+
+#ifdef IMGUI_VERSION
+#pragma message(CIMGUI_DEFSTRING(IMGUI_VERSION))
+#endif
+
+#ifdef IMGUI_VERSION_NUM
+#pragma message(CIMGUI_DEFSTRING(IMGUI_VERSION_NUM))
+#endif
+
+#ifdef IMGUI_HAS_DOCK
+#pragma message(CIMGUI_DEFSTRING(IMGUI_HAS_DOCK))
+#endif
+
+#ifdef IMGUI_HAS_IMSTR
+#pragma message(CIMGUI_DEFSTRING(IMGUI_HAS_IMSTR))
+#endif
+
+#ifdef FLT_MIN
+#pragma message(CIMGUI_DEFSTRING(FLT_MIN))
+#endif
+
+#ifdef FLT_MAX
+#pragma message(CIMGUI_DEFSTRING(FLT_MAX))
+#endif
+
+#ifdef ImDrawCallback_ResetRenderState
+#pragma message(CIMGUI_DEFSTRING(ImDrawCallback_ResetRenderState))
+#endif
+
+#ifdef IMGUI_HAS_TEXTURES
+#pragma message(CIMGUI_DEFSTRING(IMGUI_HAS_TEXTURES))
+#endif

test/main.c

@@ -3,13 +3,16 @@
 #include "../cimgui.h"
 
 #ifdef IMGUI_HAS_IMSTR
-#define igBegin igBegin_Strv
+#define igBegin igBegin_Str
-#define igSliderFloat igSliderFloat_Strv
+#define igSliderFloat igSliderFloat_Str
-#define igCheckbox igCheckbox_Strv
+#define igCheckbox igCheckbox_Str
-#define igColorEdit3 igColorEdit3_Strv
+#define igColorEdit3 igColorEdit3_Str
-#define igButton igButton_Strv
+#define igButton igButton_Str
+#define igDebugCheckVersionAndDataLayout igDebugCheckVersionAndDataLayout_Str
 #endif
 
+#define igGetIO igGetIO_Nil
+
 int main(void)
 {
   assert(igDebugCheckVersionAndDataLayout(igGetVersion(), sizeof(ImGuiIO), sizeof(ImGuiStyle),
@@ -19,9 +22,10 @@ int main(void)
   igCreateContext(NULL);
   ImGuiIO *io = igGetIO();
 
-  unsigned char *text_pixels = NULL;
+  // unsigned char *text_pixels = NULL;
-  int text_w, text_h;
+  // int text_w, text_h;
-  ImFontAtlas_GetTexDataAsRGBA32(io->Fonts, &text_pixels, &text_w, &text_h, NULL);
+  // 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);