imgui 1.0.0

data/ext/backend_function_bridge.cpp

@@ -0,0 +1,180 @@
+#include "backend_function_bridge.h"
+
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#if defined(_WIN32)
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#else
+#include <dlfcn.h>
+#endif
+
+namespace
+{
+std::mutex bridge_mutex;
+std::unordered_map<std::string, void*> library_handles;
+std::string bridge_error;
+
+const std::vector<const char*>& required_functions(const std::string& backend)
+{
+    static const std::vector<const char*> glfw = {
+        "glfwCreateStandardCursor", "glfwCreateWindow", "glfwCreateWindowSurface",
+        "glfwDestroyCursor", "glfwDestroyWindow", "glfwFocusWindow",
+        "glfwGetClipboardString", "glfwGetCursorPos", "glfwGetError",
+        "glfwGetFramebufferSize", "glfwGetGamepadState", "glfwGetInputMode",
+        "glfwGetJoystickAxes", "glfwGetJoystickButtons", "glfwGetKey", "glfwGetKeyName",
+        "glfwGetMonitorContentScale", "glfwGetMonitorPos", "glfwGetMonitorWorkarea",
+        "glfwGetMonitors", "glfwGetTime", "glfwGetVideoMode", "glfwGetWindowAttrib",
+        "glfwGetWindowPos", "glfwGetWindowSize", "glfwMakeContextCurrent",
+        "glfwSetCharCallback", "glfwSetClipboardString", "glfwSetCursor",
+        "glfwSetCursorEnterCallback", "glfwSetCursorPos", "glfwSetCursorPosCallback",
+        "glfwSetErrorCallback", "glfwSetInputMode", "glfwSetKeyCallback",
+        "glfwSetMonitorCallback", "glfwSetMouseButtonCallback", "glfwSetScrollCallback",
+        "glfwSetWindowAttrib", "glfwSetWindowCloseCallback", "glfwSetWindowFocusCallback",
+        "glfwSetWindowOpacity", "glfwSetWindowPos", "glfwSetWindowPosCallback",
+        "glfwSetWindowSize", "glfwSetWindowSizeCallback", "glfwSetWindowTitle",
+        "glfwShowWindow", "glfwSwapBuffers", "glfwSwapInterval", "glfwWindowHint",
+#if defined(_WIN32)
+        "glfwGetWin32Window",
+#elif defined(__APPLE__)
+        "glfwGetCocoaWindow",
+#endif
+    };
+    static const std::vector<const char*> sdl3 = {
+        "SDL_CaptureMouse", "SDL_CloseGamepad", "SDL_CreateSystemCursor", "SDL_CreateWindow",
+        "SDL_DestroyCursor", "SDL_DestroyWindow", "SDL_GL_CreateContext", "SDL_GL_DestroyContext",
+        "SDL_GL_GetCurrentContext", "SDL_GL_MakeCurrent", "SDL_GL_SetAttribute",
+        "SDL_GL_SetSwapInterval", "SDL_GL_SwapWindow", "SDL_GetClipboardText",
+        "SDL_GetCurrentVideoDriver", "SDL_GetDisplayBounds", "SDL_GetDisplayContentScale",
+        "SDL_GetDisplayUsableBounds", "SDL_GetDisplays", "SDL_GetGamepadAxis",
+        "SDL_GetGamepadButton", "SDL_GetGamepads", "SDL_GetGlobalMouseState",
+        "SDL_GetKeyboardFocus", "SDL_GetPerformanceCounter", "SDL_GetPerformanceFrequency",
+        "SDL_GetPointerProperty", "SDL_GetWindowFlags", "SDL_GetWindowFromID", "SDL_GetWindowID",
+        "SDL_GetWindowPosition", "SDL_GetWindowProperties", "SDL_GetWindowRelativeMouseMode",
+        "SDL_GetWindowSize", "SDL_GetWindowSizeInPixels", "SDL_HideCursor", "SDL_OpenGamepad",
+        "SDL_OpenURL", "SDL_RaiseWindow", "SDL_SetClipboardText", "SDL_SetCursor", "SDL_SetHint",
+        "SDL_SetTextInputArea", "SDL_SetWindowOpacity", "SDL_SetWindowParent",
+        "SDL_SetWindowPosition", "SDL_SetWindowSize", "SDL_SetWindowTitle", "SDL_ShowCursor",
+        "SDL_ShowWindow", "SDL_StartTextInput", "SDL_StopTextInput", "SDL_Vulkan_CreateSurface",
+        "SDL_WarpMouseGlobal", "SDL_WarpMouseInWindow", "SDL_free", "SDL_strdup",
+    };
+    static const std::vector<const char*> empty;
+
+    if (backend == "GLFW")
+        return glfw;
+    if (backend == "SDL3")
+        return sdl3;
+    return empty;
+}
+
+void set_error(const std::string& message)
+{
+    bridge_error = message;
+}
+
+void* open_library(const char* path)
+{
+#if defined(_WIN32)
+    HMODULE handle = LoadLibraryA(path);
+    if (handle == nullptr)
+        set_error("LoadLibrary failed for " + std::string(path) + " (error " + std::to_string(GetLastError()) + ")");
+    return reinterpret_cast<void*>(handle);
+#else
+    dlerror();
+    void* handle = dlopen(path, RTLD_LAZY | RTLD_LOCAL);
+    if (handle == nullptr)
+    {
+        const char* error = dlerror();
+        set_error(error != nullptr ? error : "dlopen failed for " + std::string(path));
+    }
+    return handle;
+#endif
+}
+
+void* find_symbol(void* handle, const char* name)
+{
+#if defined(_WIN32)
+    return reinterpret_cast<void*>(GetProcAddress(reinterpret_cast<HMODULE>(handle), name));
+#else
+    dlerror();
+    return dlsym(handle, name);
+#endif
+}
+} // namespace
+
+extern "C" IMGUI_RUBY_EXPORT bool imgui_ruby_backend_load_library(const char* backend, const char* path)
+{
+    if (backend == nullptr || path == nullptr || backend[0] == '\0' || path[0] == '\0')
+        return false;
+
+    std::lock_guard<std::mutex> lock(bridge_mutex);
+    if (library_handles.find(backend) != library_handles.end())
+        return true;
+
+    void* handle = open_library(path);
+    if (handle == nullptr)
+        return false;
+
+    library_handles.emplace(backend, handle);
+    bridge_error.clear();
+    return true;
+}
+
+extern "C" IMGUI_RUBY_EXPORT bool imgui_ruby_backend_library_ready(const char* backend)
+{
+    if (backend == nullptr)
+        return false;
+
+    std::lock_guard<std::mutex> lock(bridge_mutex);
+    return library_handles.find(backend) != library_handles.end();
+}
+
+extern "C" IMGUI_RUBY_EXPORT bool imgui_ruby_backend_has_function(const char* backend, const char* name)
+{
+    return imgui_ruby_backend_resolve_function(backend, name) != nullptr;
+}
+
+extern "C" IMGUI_RUBY_EXPORT size_t imgui_ruby_backend_required_function_count(const char* backend)
+{
+    return backend != nullptr ? required_functions(backend).size() : 0;
+}
+
+extern "C" IMGUI_RUBY_EXPORT const char* imgui_ruby_backend_required_function_name(
+    const char* backend,
+    size_t index)
+{
+    if (backend == nullptr)
+        return nullptr;
+    const auto& functions = required_functions(backend);
+    return index < functions.size() ? functions[index] : nullptr;
+}
+
+extern "C" IMGUI_RUBY_EXPORT const char* imgui_ruby_backend_library_error()
+{
+    std::lock_guard<std::mutex> lock(bridge_mutex);
+    return bridge_error.c_str();
+}
+
+void* imgui_ruby_backend_resolve_function(const char* backend, const char* name)
+{
+    if (backend == nullptr || name == nullptr)
+        return nullptr;
+
+    std::lock_guard<std::mutex> lock(bridge_mutex);
+    auto library = library_handles.find(backend);
+    if (library == library_handles.end())
+    {
+        set_error(std::string(backend) + " runtime library is not loaded");
+        return nullptr;
+    }
+
+    void* address = find_symbol(library->second, name);
+    if (address == nullptr)
+        set_error(std::string(backend) + " runtime library does not export " + name);
+    return address;
+}

data/ext/backend_function_bridge.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <cstdio>
+#include <cstdlib>
+
+#if defined(_WIN32)
+#define IMGUI_RUBY_EXPORT __declspec(dllexport)
+#else
+#define IMGUI_RUBY_EXPORT __attribute__((visibility("default")))
+#endif
+
+extern "C" {
+IMGUI_RUBY_EXPORT bool imgui_ruby_backend_load_library(const char* backend, const char* path);
+IMGUI_RUBY_EXPORT bool imgui_ruby_backend_library_ready(const char* backend);
+IMGUI_RUBY_EXPORT bool imgui_ruby_backend_has_function(const char* backend, const char* name);
+IMGUI_RUBY_EXPORT size_t imgui_ruby_backend_required_function_count(const char* backend);
+IMGUI_RUBY_EXPORT const char* imgui_ruby_backend_required_function_name(const char* backend, size_t index);
+IMGUI_RUBY_EXPORT const char* imgui_ruby_backend_library_error();
+}
+
+void* imgui_ruby_backend_resolve_function(const char* backend, const char* name);
+
+template <typename Function>
+Function imgui_ruby_backend_function(const char* backend, const char* name)
+{
+    void* address = imgui_ruby_backend_resolve_function(backend, name);
+    if (address == nullptr)
+    {
+        std::fprintf(stderr, "imgui-ruby: unresolved %s function %s\n", backend, name);
+        std::abort();
+    }
+    return reinterpret_cast<Function>(address);
+}
+
+#define IMGUI_RUBY_BACKEND_CALL(backend, function_name, ...)                                      \
+    ([]() -> decltype(&function_name) {                                                           \
+        static auto function = imgui_ruby_backend_function<decltype(&function_name)>(             \
+            backend, #function_name);                                                             \
+        return function;                                                                          \
+    }())(__VA_ARGS__)

data/ext/build_cimgui.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "open3"
+
+module ImGuiRuby
+  class NativeBuilder
+    def initialize(source_dir:, build_dir:, install_dir:)
+      @source_dir = source_dir
+      @build_dir = build_dir
+      @install_dir = install_dir
+    end
+
+    def build!
+      FileUtils.mkdir_p(@build_dir)
+      FileUtils.mkdir_p(@install_dir)
+      run("cmake", "-S", @source_dir, "-B", @build_dir, *cmake_options)
+      run("cmake", "--build", @build_dir, "--config", "Release", "--parallel")
+      run("cmake", "--install", @build_dir, "--config", "Release", "--prefix", @install_dir)
+    end
+
+    private
+
+    def cmake_options
+      backends = ENV.fetch("IMGUI_RUBY_BACKENDS", "").split(",").map(&:strip)
+      [
+        "-DCMAKE_BUILD_TYPE=Release",
+        "-DIMGUI_RUBY_WITH_GLFW=#{on_off(backends.include?("glfw"))}",
+        "-DIMGUI_RUBY_WITH_OPENGL3=#{on_off(backends.include?("opengl3"))}",
+        "-DIMGUI_RUBY_WITH_SDL3=#{on_off(backends.include?("sdl3"))}",
+        "-DIMGUI_RUBY_WITH_WGPU=#{on_off(backends.include?("wgpu"))}",
+        "-DIMGUI_RUBY_WITH_IMPLOT=#{on_off(!backends.include?("no-implot"))}"
+      ]
+    end
+
+    def on_off(value)
+      value ? "ON" : "OFF"
+    end
+
+    def run(*command)
+      output, status = Open3.capture2e(*command)
+      puts output
+      return if status.success?
+
+      raise "command failed (#{status.exitstatus}): #{command.join(" ")}"
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  build_dir, install_dir = ARGV
+  raise ArgumentError, "build and install directories are required" unless build_dir && install_dir
+
+  ImGuiRuby::NativeBuilder.new(
+    source_dir: __dir__,
+    build_dir: File.expand_path(build_dir),
+    install_dir: File.expand_path(install_dir)
+  ).build!
+end

data/ext/extconf.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+require "shellwords"
+
+ruby = Shellwords.escape(RbConfig.ruby)
+extension_dir = File.expand_path(__dir__)
+build_dir = File.join(extension_dir, "build")
+install_dir = File.join(build_dir, "install")
+
+makefile = <<~MAKEFILE
+  RUBY = #{ruby}
+  sitearchdir = #{Shellwords.escape(RbConfig::CONFIG.fetch("sitearchdir"))}
+
+  all:
+	$(RUBY) #{Shellwords.escape(File.join(extension_dir, "build_cimgui.rb"))} #{Shellwords.escape(build_dir)} #{Shellwords.escape(install_dir)}
+
+  install:
+	$(RUBY) #{Shellwords.escape(File.join(extension_dir, "install_cimgui.rb"))} #{Shellwords.escape(install_dir)} "$(DESTDIR)$(sitearchdir)"
+
+  clean:
+	@true
+MAKEFILE
+
+File.write(File.join(extension_dir, "Makefile"), makefile)

data/ext/glfw_vulkan_bridge.cpp

@@ -0,0 +1,14 @@
+#include <GLFW/glfw3.h>
+
+#include "backend_function_bridge.h"
+
+extern "C" int glfwCreateWindowSurface(
+    void* instance,
+    GLFWwindow* window,
+    const void* allocator,
+    void* surface)
+{
+    using Function = int (*)(void*, GLFWwindow*, const void*, void*);
+    static auto function = imgui_ruby_backend_function<Function>("GLFW", "glfwCreateWindowSurface");
+    return function(instance, window, allocator, surface);
+}

data/ext/imgui_ruby_build_config.h

@@ -0,0 +1,17 @@
+#pragma once
+
+// Keep backend declarations compatible with cimgui's exported C ABI on every
+// translation unit, including vendor sources compiled directly by CMake.
+#if !defined(IMGUI_IMPL_API)
+#if defined(_WIN32)
+#define IMGUI_IMPL_API extern "C" __declspec(dllexport)
+#else
+#define IMGUI_IMPL_API extern "C" __attribute__((visibility("default")))
+#endif
+#endif
+
+// GLFW includes the system OpenGL header by default, but the bundled backend
+// uses Dear ImGui's own OpenGL loader and does not require that header.
+#if !defined(GLFW_INCLUDE_NONE)
+#define GLFW_INCLUDE_NONE
+#endif

data/ext/imgui_ruby_glfw.cpp

@@ -0,0 +1,73 @@
+#include <GLFW/glfw3.h>
+
+#if defined(_WIN32)
+#define GLFW_EXPOSE_NATIVE_WIN32
+#include <GLFW/glfw3native.h>
+#elif defined(__APPLE__)
+#define GLFW_EXPOSE_NATIVE_COCOA
+#include <GLFW/glfw3native.h>
+#endif
+
+#include "backend_function_bridge.h"
+
+#define IMGUI_RUBY_GLFW(function_name, ...)                                                       \
+    IMGUI_RUBY_BACKEND_CALL("GLFW", function_name, __VA_ARGS__)
+
+#define glfwCreateStandardCursor(...) IMGUI_RUBY_GLFW(glfwCreateStandardCursor, __VA_ARGS__)
+#define glfwCreateWindow(...) IMGUI_RUBY_GLFW(glfwCreateWindow, __VA_ARGS__)
+#define glfwDestroyCursor(...) IMGUI_RUBY_GLFW(glfwDestroyCursor, __VA_ARGS__)
+#define glfwDestroyWindow(...) IMGUI_RUBY_GLFW(glfwDestroyWindow, __VA_ARGS__)
+#define glfwFocusWindow(...) IMGUI_RUBY_GLFW(glfwFocusWindow, __VA_ARGS__)
+#define glfwGetClipboardString(...) IMGUI_RUBY_GLFW(glfwGetClipboardString, __VA_ARGS__)
+#if defined(__APPLE__)
+#define glfwGetCocoaWindow(...) IMGUI_RUBY_GLFW(glfwGetCocoaWindow, __VA_ARGS__)
+#endif
+#define glfwGetCursorPos(...) IMGUI_RUBY_GLFW(glfwGetCursorPos, __VA_ARGS__)
+#define glfwGetError(...) IMGUI_RUBY_GLFW(glfwGetError, __VA_ARGS__)
+#define glfwGetFramebufferSize(...) IMGUI_RUBY_GLFW(glfwGetFramebufferSize, __VA_ARGS__)
+#define glfwGetGamepadState(...) IMGUI_RUBY_GLFW(glfwGetGamepadState, __VA_ARGS__)
+#define glfwGetInputMode(...) IMGUI_RUBY_GLFW(glfwGetInputMode, __VA_ARGS__)
+#define glfwGetJoystickAxes(...) IMGUI_RUBY_GLFW(glfwGetJoystickAxes, __VA_ARGS__)
+#define glfwGetJoystickButtons(...) IMGUI_RUBY_GLFW(glfwGetJoystickButtons, __VA_ARGS__)
+#define glfwGetKey(...) IMGUI_RUBY_GLFW(glfwGetKey, __VA_ARGS__)
+#define glfwGetKeyName(...) IMGUI_RUBY_GLFW(glfwGetKeyName, __VA_ARGS__)
+#define glfwGetMonitorContentScale(...) IMGUI_RUBY_GLFW(glfwGetMonitorContentScale, __VA_ARGS__)
+#define glfwGetMonitorPos(...) IMGUI_RUBY_GLFW(glfwGetMonitorPos, __VA_ARGS__)
+#define glfwGetMonitorWorkarea(...) IMGUI_RUBY_GLFW(glfwGetMonitorWorkarea, __VA_ARGS__)
+#define glfwGetMonitors(...) IMGUI_RUBY_GLFW(glfwGetMonitors, __VA_ARGS__)
+#define glfwGetTime(...) IMGUI_RUBY_GLFW(glfwGetTime, __VA_ARGS__)
+#define glfwGetVideoMode(...) IMGUI_RUBY_GLFW(glfwGetVideoMode, __VA_ARGS__)
+#if defined(_WIN32)
+#define glfwGetWin32Window(...) IMGUI_RUBY_GLFW(glfwGetWin32Window, __VA_ARGS__)
+#endif
+#define glfwGetWindowAttrib(...) IMGUI_RUBY_GLFW(glfwGetWindowAttrib, __VA_ARGS__)
+#define glfwGetWindowPos(...) IMGUI_RUBY_GLFW(glfwGetWindowPos, __VA_ARGS__)
+#define glfwGetWindowSize(...) IMGUI_RUBY_GLFW(glfwGetWindowSize, __VA_ARGS__)
+#define glfwMakeContextCurrent(...) IMGUI_RUBY_GLFW(glfwMakeContextCurrent, __VA_ARGS__)
+#define glfwSetCharCallback(...) IMGUI_RUBY_GLFW(glfwSetCharCallback, __VA_ARGS__)
+#define glfwSetClipboardString(...) IMGUI_RUBY_GLFW(glfwSetClipboardString, __VA_ARGS__)
+#define glfwSetCursor(...) IMGUI_RUBY_GLFW(glfwSetCursor, __VA_ARGS__)
+#define glfwSetCursorEnterCallback(...) IMGUI_RUBY_GLFW(glfwSetCursorEnterCallback, __VA_ARGS__)
+#define glfwSetCursorPos(...) IMGUI_RUBY_GLFW(glfwSetCursorPos, __VA_ARGS__)
+#define glfwSetCursorPosCallback(...) IMGUI_RUBY_GLFW(glfwSetCursorPosCallback, __VA_ARGS__)
+#define glfwSetErrorCallback(...) IMGUI_RUBY_GLFW(glfwSetErrorCallback, __VA_ARGS__)
+#define glfwSetInputMode(...) IMGUI_RUBY_GLFW(glfwSetInputMode, __VA_ARGS__)
+#define glfwSetKeyCallback(...) IMGUI_RUBY_GLFW(glfwSetKeyCallback, __VA_ARGS__)
+#define glfwSetMonitorCallback(...) IMGUI_RUBY_GLFW(glfwSetMonitorCallback, __VA_ARGS__)
+#define glfwSetMouseButtonCallback(...) IMGUI_RUBY_GLFW(glfwSetMouseButtonCallback, __VA_ARGS__)
+#define glfwSetScrollCallback(...) IMGUI_RUBY_GLFW(glfwSetScrollCallback, __VA_ARGS__)
+#define glfwSetWindowAttrib(...) IMGUI_RUBY_GLFW(glfwSetWindowAttrib, __VA_ARGS__)
+#define glfwSetWindowCloseCallback(...) IMGUI_RUBY_GLFW(glfwSetWindowCloseCallback, __VA_ARGS__)
+#define glfwSetWindowFocusCallback(...) IMGUI_RUBY_GLFW(glfwSetWindowFocusCallback, __VA_ARGS__)
+#define glfwSetWindowOpacity(...) IMGUI_RUBY_GLFW(glfwSetWindowOpacity, __VA_ARGS__)
+#define glfwSetWindowPos(...) IMGUI_RUBY_GLFW(glfwSetWindowPos, __VA_ARGS__)
+#define glfwSetWindowPosCallback(...) IMGUI_RUBY_GLFW(glfwSetWindowPosCallback, __VA_ARGS__)
+#define glfwSetWindowSize(...) IMGUI_RUBY_GLFW(glfwSetWindowSize, __VA_ARGS__)
+#define glfwSetWindowSizeCallback(...) IMGUI_RUBY_GLFW(glfwSetWindowSizeCallback, __VA_ARGS__)
+#define glfwSetWindowTitle(...) IMGUI_RUBY_GLFW(glfwSetWindowTitle, __VA_ARGS__)
+#define glfwShowWindow(...) IMGUI_RUBY_GLFW(glfwShowWindow, __VA_ARGS__)
+#define glfwSwapBuffers(...) IMGUI_RUBY_GLFW(glfwSwapBuffers, __VA_ARGS__)
+#define glfwSwapInterval(...) IMGUI_RUBY_GLFW(glfwSwapInterval, __VA_ARGS__)
+#define glfwWindowHint(...) IMGUI_RUBY_GLFW(glfwWindowHint, __VA_ARGS__)
+
+#include "imgui_impl_glfw.cpp"

data/ext/imgui_ruby_sdl3.cpp

@@ -0,0 +1,70 @@
+#include <SDL3/SDL.h>
+#include <SDL3/SDL_vulkan.h>
+
+#include "backend_function_bridge.h"
+
+#define IMGUI_RUBY_SDL3(function_name, ...)                                                       \
+    IMGUI_RUBY_BACKEND_CALL("SDL3", function_name, __VA_ARGS__)
+
+#undef SDL_free
+#undef SDL_strdup
+
+#define SDL_CaptureMouse(...) IMGUI_RUBY_SDL3(SDL_CaptureMouse, __VA_ARGS__)
+#define SDL_CloseGamepad(...) IMGUI_RUBY_SDL3(SDL_CloseGamepad, __VA_ARGS__)
+#define SDL_CreateSystemCursor(...) IMGUI_RUBY_SDL3(SDL_CreateSystemCursor, __VA_ARGS__)
+#define SDL_CreateWindow(...) IMGUI_RUBY_SDL3(SDL_CreateWindow, __VA_ARGS__)
+#define SDL_DestroyCursor(...) IMGUI_RUBY_SDL3(SDL_DestroyCursor, __VA_ARGS__)
+#define SDL_DestroyWindow(...) IMGUI_RUBY_SDL3(SDL_DestroyWindow, __VA_ARGS__)
+#define SDL_GL_CreateContext(...) IMGUI_RUBY_SDL3(SDL_GL_CreateContext, __VA_ARGS__)
+#define SDL_GL_DestroyContext(...) IMGUI_RUBY_SDL3(SDL_GL_DestroyContext, __VA_ARGS__)
+#define SDL_GL_GetCurrentContext(...) IMGUI_RUBY_SDL3(SDL_GL_GetCurrentContext, __VA_ARGS__)
+#define SDL_GL_MakeCurrent(...) IMGUI_RUBY_SDL3(SDL_GL_MakeCurrent, __VA_ARGS__)
+#define SDL_GL_SetAttribute(...) IMGUI_RUBY_SDL3(SDL_GL_SetAttribute, __VA_ARGS__)
+#define SDL_GL_SetSwapInterval(...) IMGUI_RUBY_SDL3(SDL_GL_SetSwapInterval, __VA_ARGS__)
+#define SDL_GL_SwapWindow(...) IMGUI_RUBY_SDL3(SDL_GL_SwapWindow, __VA_ARGS__)
+#define SDL_GetClipboardText(...) IMGUI_RUBY_SDL3(SDL_GetClipboardText, __VA_ARGS__)
+#define SDL_GetCurrentVideoDriver(...) IMGUI_RUBY_SDL3(SDL_GetCurrentVideoDriver, __VA_ARGS__)
+#define SDL_GetDisplayBounds(...) IMGUI_RUBY_SDL3(SDL_GetDisplayBounds, __VA_ARGS__)
+#define SDL_GetDisplayContentScale(...) IMGUI_RUBY_SDL3(SDL_GetDisplayContentScale, __VA_ARGS__)
+#define SDL_GetDisplayUsableBounds(...) IMGUI_RUBY_SDL3(SDL_GetDisplayUsableBounds, __VA_ARGS__)
+#define SDL_GetDisplays(...) IMGUI_RUBY_SDL3(SDL_GetDisplays, __VA_ARGS__)
+#define SDL_GetGamepadAxis(...) IMGUI_RUBY_SDL3(SDL_GetGamepadAxis, __VA_ARGS__)
+#define SDL_GetGamepadButton(...) IMGUI_RUBY_SDL3(SDL_GetGamepadButton, __VA_ARGS__)
+#define SDL_GetGamepads(...) IMGUI_RUBY_SDL3(SDL_GetGamepads, __VA_ARGS__)
+#define SDL_GetGlobalMouseState(...) IMGUI_RUBY_SDL3(SDL_GetGlobalMouseState, __VA_ARGS__)
+#define SDL_GetKeyboardFocus(...) IMGUI_RUBY_SDL3(SDL_GetKeyboardFocus, __VA_ARGS__)
+#define SDL_GetPerformanceCounter(...) IMGUI_RUBY_SDL3(SDL_GetPerformanceCounter, __VA_ARGS__)
+#define SDL_GetPerformanceFrequency(...) IMGUI_RUBY_SDL3(SDL_GetPerformanceFrequency, __VA_ARGS__)
+#define SDL_GetPointerProperty(...) IMGUI_RUBY_SDL3(SDL_GetPointerProperty, __VA_ARGS__)
+#define SDL_GetWindowFlags(...) IMGUI_RUBY_SDL3(SDL_GetWindowFlags, __VA_ARGS__)
+#define SDL_GetWindowFromID(...) IMGUI_RUBY_SDL3(SDL_GetWindowFromID, __VA_ARGS__)
+#define SDL_GetWindowID(...) IMGUI_RUBY_SDL3(SDL_GetWindowID, __VA_ARGS__)
+#define SDL_GetWindowPosition(...) IMGUI_RUBY_SDL3(SDL_GetWindowPosition, __VA_ARGS__)
+#define SDL_GetWindowProperties(...) IMGUI_RUBY_SDL3(SDL_GetWindowProperties, __VA_ARGS__)
+#define SDL_GetWindowRelativeMouseMode(...) IMGUI_RUBY_SDL3(SDL_GetWindowRelativeMouseMode, __VA_ARGS__)
+#define SDL_GetWindowSize(...) IMGUI_RUBY_SDL3(SDL_GetWindowSize, __VA_ARGS__)
+#define SDL_GetWindowSizeInPixels(...) IMGUI_RUBY_SDL3(SDL_GetWindowSizeInPixels, __VA_ARGS__)
+#define SDL_HideCursor(...) IMGUI_RUBY_SDL3(SDL_HideCursor, __VA_ARGS__)
+#define SDL_OpenGamepad(...) IMGUI_RUBY_SDL3(SDL_OpenGamepad, __VA_ARGS__)
+#define SDL_OpenURL(...) IMGUI_RUBY_SDL3(SDL_OpenURL, __VA_ARGS__)
+#define SDL_RaiseWindow(...) IMGUI_RUBY_SDL3(SDL_RaiseWindow, __VA_ARGS__)
+#define SDL_SetClipboardText(...) IMGUI_RUBY_SDL3(SDL_SetClipboardText, __VA_ARGS__)
+#define SDL_SetCursor(...) IMGUI_RUBY_SDL3(SDL_SetCursor, __VA_ARGS__)
+#define SDL_SetHint(...) IMGUI_RUBY_SDL3(SDL_SetHint, __VA_ARGS__)
+#define SDL_SetTextInputArea(...) IMGUI_RUBY_SDL3(SDL_SetTextInputArea, __VA_ARGS__)
+#define SDL_SetWindowOpacity(...) IMGUI_RUBY_SDL3(SDL_SetWindowOpacity, __VA_ARGS__)
+#define SDL_SetWindowParent(...) IMGUI_RUBY_SDL3(SDL_SetWindowParent, __VA_ARGS__)
+#define SDL_SetWindowPosition(...) IMGUI_RUBY_SDL3(SDL_SetWindowPosition, __VA_ARGS__)
+#define SDL_SetWindowSize(...) IMGUI_RUBY_SDL3(SDL_SetWindowSize, __VA_ARGS__)
+#define SDL_SetWindowTitle(...) IMGUI_RUBY_SDL3(SDL_SetWindowTitle, __VA_ARGS__)
+#define SDL_ShowCursor(...) IMGUI_RUBY_SDL3(SDL_ShowCursor, __VA_ARGS__)
+#define SDL_ShowWindow(...) IMGUI_RUBY_SDL3(SDL_ShowWindow, __VA_ARGS__)
+#define SDL_StartTextInput(...) IMGUI_RUBY_SDL3(SDL_StartTextInput, __VA_ARGS__)
+#define SDL_StopTextInput(...) IMGUI_RUBY_SDL3(SDL_StopTextInput, __VA_ARGS__)
+#define SDL_Vulkan_CreateSurface(...) IMGUI_RUBY_SDL3(SDL_Vulkan_CreateSurface, __VA_ARGS__)
+#define SDL_WarpMouseGlobal(...) IMGUI_RUBY_SDL3(SDL_WarpMouseGlobal, __VA_ARGS__)
+#define SDL_WarpMouseInWindow(...) IMGUI_RUBY_SDL3(SDL_WarpMouseInWindow, __VA_ARGS__)
+#define SDL_free(...) IMGUI_RUBY_SDL3(SDL_free, __VA_ARGS__)
+#define SDL_strdup(...) IMGUI_RUBY_SDL3(SDL_strdup, __VA_ARGS__)
+
+#include "imgui_impl_sdl3.cpp"

data/ext/imgui_ruby_wgpu.cpp

@@ -0,0 +1,75 @@
+#include "imgui.h"
+#include "backends/imgui_impl_wgpu.h"
+
+#include <webgpu/webgpu.h>
+
+#if defined(_WIN32)
+#define IMGUI_RUBY_EXPORT __declspec(dllexport)
+#else
+#define IMGUI_RUBY_EXPORT __attribute__((visibility("default")))
+#endif
+
+extern "C" {
+
+IMGUI_RUBY_EXPORT bool imgui_ruby_wgpu_init(
+    void* device,
+    int frames_in_flight,
+    int render_target_format,
+    int depth_format,
+    unsigned int sample_count,
+    unsigned int sample_mask,
+    bool alpha_to_coverage) {
+  ImGui_ImplWGPU_InitInfo info = {};
+  info.Device = static_cast<WGPUDevice>(device);
+  info.NumFramesInFlight = frames_in_flight;
+  info.RenderTargetFormat = static_cast<WGPUTextureFormat>(render_target_format);
+  info.DepthStencilFormat = static_cast<WGPUTextureFormat>(depth_format);
+  info.PipelineMultisampleState.count = sample_count;
+  info.PipelineMultisampleState.mask = sample_mask;
+  info.PipelineMultisampleState.alphaToCoverageEnabled = alpha_to_coverage;
+  return ImGui_ImplWGPU_Init(&info);
+}
+
+IMGUI_RUBY_EXPORT void imgui_ruby_wgpu_shutdown() {
+  ImGui_ImplWGPU_Shutdown();
+}
+
+IMGUI_RUBY_EXPORT void imgui_ruby_wgpu_new_frame() {
+  ImGui_ImplWGPU_NewFrame();
+}
+
+IMGUI_RUBY_EXPORT void imgui_ruby_wgpu_render_draw_data(
+    ImDrawData* draw_data,
+    void* render_pass_encoder) {
+  ImGui_ImplWGPU_RenderDrawData(
+      draw_data,
+      static_cast<WGPURenderPassEncoder>(render_pass_encoder));
+}
+
+IMGUI_RUBY_EXPORT bool imgui_ruby_wgpu_render_draw_data_to_view(
+    ImDrawData* draw_data,
+    void* command_encoder,
+    void* target_view) {
+  WGPURenderPassColorAttachment color_attachment = {};
+  color_attachment.view = static_cast<WGPUTextureView>(target_view);
+  color_attachment.depthSlice = WGPU_DEPTH_SLICE_UNDEFINED;
+  color_attachment.loadOp = WGPULoadOp_Load;
+  color_attachment.storeOp = WGPUStoreOp_Store;
+
+  WGPURenderPassDescriptor descriptor = {};
+  descriptor.colorAttachmentCount = 1;
+  descriptor.colorAttachments = &color_attachment;
+  WGPURenderPassEncoder pass = wgpuCommandEncoderBeginRenderPass(
+      static_cast<WGPUCommandEncoder>(command_encoder),
+      &descriptor);
+  if (!pass) {
+    return false;
+  }
+
+  ImGui_ImplWGPU_RenderDrawData(draw_data, pass);
+  wgpuRenderPassEncoderEnd(pass);
+  wgpuRenderPassEncoderRelease(pass);
+  return true;
+}
+
+}

data/ext/install_cimgui.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "rbconfig"
+
+source_dir, ruby_arch_dir = ARGV
+raise ArgumentError, "source and Ruby architecture directories are required" unless source_dir && ruby_arch_dir
+
+library = Dir.glob(File.join(source_dir, "*cimgui_ruby.{so,dylib,dll}")).first
+raise "built cimgui library was not found in #{source_dir}" unless library
+
+host_os = RbConfig::CONFIG.fetch("host_os")
+platform_os = if host_os.include?("darwin")
+                "darwin"
+              elsif host_os.match?(/mswin|mingw/)
+                "windows"
+              else
+                "linux"
+              end
+host_cpu = RbConfig::CONFIG.fetch("host_cpu")
+platform_cpu = host_cpu == "arm64" ? "aarch64" : host_cpu
+destination = File.join(ruby_arch_dir, "imgui", "vendor", "#{platform_cpu}-#{platform_os}")
+
+FileUtils.mkdir_p(destination)
+FileUtils.cp(library, destination)