imgui-bindings 0.0.1

data/lib/imgui_impl_sdl2.rb

@@ -0,0 +1,296 @@
+require 'ffi'
+require 'sdl2'
+require_relative 'imgui'
+
+module ImGui
+
+  class ImGui_ImplSDL2_Data < FFI::Struct
+    layout(
+      :Window, :pointer,
+      :Time, :uint64,
+      :MousePressed, [:bool, 3],
+      :MouseCursors, [:pointer, ImGuiMouseCursor_COUNT],
+      :ClipboardTextData, :pointer,
+      :MouseCanUseGlobalState, :bool
+    )
+  end
+
+  def self.ImGui_ImplSDL2_GetBackendData()
+    io = ImGuiIO.new(ImGui::GetIO())
+    return ImGui_ImplSDL2_Data.new(io[:BackendPlatformUserData])
+  end
+
+  @@g_Window = nil # SDL_Window*
+  @@g_Time = 0.0 # UInt64
+  @@g_BackendPlatformName = FFI::MemoryPointer.from_string("imgui_impl_sdl")
+  @@g_BackendPlatformUserData = nil
+
+  # [TODO] Support ClipboardText
+  # g_ClipboardTextData
+  # ImplSDL2_GetClipboardText
+  # ImplSDL2_SetClipboardText
+
+  # [TODO] SDL_MOUSE
+  def self.get_sdl2_mousebit(x); return (1 << ((x)-1)); end
+
+  # [TODO] #define KMOD_CTRL, #define KMOD_SHIFT, #define KMOD_ALT and #define KMOD_GUI
+  KMOD_CTRL = SDL2::KMOD_LCTRL|SDL2::KMOD_RCTRL
+  KMOD_SHIFT = SDL2::KMOD_LSHIFT|SDL2::KMOD_RSHIFT
+  KMOD_ALT = SDL2::KMOD_LALT|SDL2::KMOD_RALT
+  KMOD_GUI = SDL2::KMOD_LGUI|SDL2::KMOD_RGUI
+
+  # [INTERNAL]
+  def self.ImplSDL2_UpdateMousePosAndButtons()
+    # Update buttons
+    io = ImGuiIO.new(ImGui::GetIO())
+    bd = ImGui_ImplSDL2_GetBackendData()
+    window = bd[:Window]
+
+    # Set OS mouse position if requested (rarely used, only when ImGuiConfigFlags_NavEnableSetMousePos is enabled by user)
+    if io[:WantSetMousePos]
+      SDL2::SDL_WarpMouseInWindow(window, io[:MousePos][:x].to_i, io[:MousePos][:y].to_i)
+    else
+      io[:MousePos][:x] = -Float::MAX
+      io[:MousePos][:y] = -Float::MAX
+    end
+
+    mx = FFI::MemoryPointer.new(:int)
+    my = FFI::MemoryPointer.new(:int)
+    mouse_buttons = SDL2::SDL_GetMouseState(mx, my)
+    io[:MouseDown][0] = bd[:MousePressed][0] || (mouse_buttons & get_sdl2_mousebit(SDL2::SDL_BUTTON_LEFT)) != 0  # If a mouse press event came, always pass it as "mouse held this frame", so we don't miss click-release events that are shorter than 1 frame.
+    io[:MouseDown][1] = bd[:MousePressed][1] || (mouse_buttons & get_sdl2_mousebit(SDL2::SDL_BUTTON_RIGHT)) != 0
+    io[:MouseDown][2] = bd[:MousePressed][2] || (mouse_buttons & get_sdl2_mousebit(SDL2::SDL_BUTTON_MIDDLE)) != 0
+    bd[:MousePressed][0] = bd[:MousePressed][1] = bd[:MousePressed][2] = false
+
+    focused_window = SDL2::SDL_GetKeyboardFocus()
+    hover_window = nil
+    mouse_window = nil
+    if defined?(SDL2::SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH)
+      hovered_window = SDL_GetMouseFocus() # This is better but is only reliably useful with SDL 2.0.5+ and SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH enabled.
+      mouse_window = (window == focused_window || window == hovered_window) ? window : nil
+    else
+      mouse_window = (window == focused_window) ? window : nil
+    end
+    if mouse_window != nil
+      if bd[:MouseCanUseGlobalState]
+        # SDL_GetMouseState() gives mouse position seemingly based on the last window entered/focused(?)
+        # The creation of a new windows at runtime and SDL_CaptureMouse both seems to severely mess up with that, so we retrieve that position globally.
+        # Won't use this workaround on SDL backends that have no global mouse position, like Wayland or RPI
+        wx = FFI::MemoryPointer.new(:int)
+        wy = FFI::MemoryPointer.new(:int)
+        SDL2::SDL_GetWindowPosition(focused_window, wx, wy)
+        SDL2::SDL_GetGlobalMouseState(mx, my)
+        io[:MousePos][:x] = mx.read(:int).to_f - wx.read(:int).to_f
+        io[:MousePos][:y] = my.read(:int).to_f - wy.read(:int).to_f
+      else
+        io[:MousePos][:x] = mx.read(:int).to_f
+        io[:MousePos][:y] = my.read(:int).to_f
+      end
+    end
+
+    # SDL_CaptureMouse() let the OS know e.g. that our imgui drag outside the SDL window boundaries shouldn't e.g. trigger the OS window resize cursor.
+    # The function is only supported from SDL 2.0.4 (released Jan 2016)
+    any_mouse_button_down = ImGui::IsAnyMouseDown()
+    SDL2::SDL_CaptureMouse(any_mouse_button_down ? SDL2::SDL_TRUE : SDL2::SDL_FALSE)
+
+    # [TODO]
+    #if SDL_HAS_CAPTURE_AND_GLOBAL_MOUSE && !defined(__EMSCRIPTEN__) && !defined(__ANDROID__) && !(defined(__APPLE__) && TARGET_OS_IOS)
+  end
+
+  def self.ImplSDL2_UpdateMouseCursor()
+    io = ImGuiIO.new(ImGui::GetIO())
+    return if (io[:ConfigFlags] & ImGuiConfigFlags_NoMouseCursorChange)
+    bd = ImGui_ImplSDL2_GetBackendData()
+
+    imgui_cursor = ImGui::GetMouseCursor()
+    if io[:MouseDrawCursor] || imgui_cursor == ImGuiMouseCursor_None
+      # Hide OS mouse cursor if imgui is drawing it or if it wants no cursor
+      SDL2::SDL_ShowCursor(SDL2::SDL_FALSE)
+    else
+      # Show OS mouse cursor
+      SDL2::SDL_SetCursor(bd[:MouseCursors][imgui_cursor] ? bd[:MouseCursors][imgui_cursor] : bd[:MouseCursors][ImGuiMouseCursor_Arrow])
+      SDL2::SDL_ShowCursor(SDL2::SDL_TRUE)
+    end
+  end
+
+  #
+  # [TODO] Support ImplSDL2_UpdateGamepads
+  #
+
+  def self.ImplSDL2_Shutdown()
+    io = ImGuiIO.new(ImGui::GetIO())
+    bd = ImGui_ImplSDL2_GetBackendData()
+
+    # [TODO] Destroy last known clipboard data
+
+    @@g_Window = nil
+    ImGuiMouseCursor_COUNT.times do |cursor_n|
+      SDL2::SDL_FreeCursor(bd[:MouseCursors][cursor_n])
+      bd[:MouseCursors][cursor_n] = nil
+    end
+    @@g_BackendPlatformUserData = nil
+  end
+
+  def self.ImplSDL2_NewFrame()
+    io = ImGuiIO.new(ImGui::GetIO())
+    bd = ImGui_ImplSDL2_GetBackendData()
+
+    unless io[:Fonts].IsBuilt()
+      puts "Font atlas not built! It is generally built by the renderer back-end. Missing call to renderer _NewFrame() function? e.g. ImGui_ImplOpenGL3_NewFrame()."
+    end
+
+    #  Setup display size (every frame to accommodate for window resizing)
+    w = ' ' * 4
+    h = ' ' * 4
+    display_w = ' ' * 4
+    display_h = ' ' * 4
+    SDL2::SDL_GetWindowSize(bd[:Window], w, h)
+    SDL2::SDL_GL_GetDrawableSize(bd[:Window], display_w, display_h)
+
+    w = w.unpack1('L')
+    h = h.unpack1('L')
+    display_size = ImVec2.new
+    display_size[:x] = w.to_f
+    display_size[:y] = h.to_f
+    io[:DisplaySize] = display_size
+
+    if w > 0 && h > 0
+      fb_scale = ImVec2.new
+      fb_scale[:x] = display_w.unpack1('L').to_f / w
+      fb_scale[:y] = display_h.unpack1('L').to_f / h
+      io[:DisplayFramebufferScale] = fb_scale
+    end
+
+    # Setup time step (we don't use SDL_GetTicks() because it is using millisecond resolution)
+    frequency = SDL2::SDL_GetPerformanceFrequency()
+    current_time = SDL2::SDL_GetPerformanceCounter()
+
+    io[:DeltaTime] = @@g_Time > 0 ? ((current_time - @@g_Time).to_f / frequency) : (1.0/60.0)
+    @@g_Time = current_time
+
+    ImplSDL2_UpdateMousePosAndButtons()
+    ImplSDL2_UpdateMouseCursor()
+
+    # [TODO] update gamepads
+  end
+
+  # 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.
+  # - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application.
+  # Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
+  # If you have multiple SDL events and some of them are not meant to be used by dear imgui, you may need to filter events based on their windowID field.
+  def self.ImplSDL2_ProcessEvent(event)
+    io = ImGuiIO.new(ImGui::GetIO())
+    bd = ImGui_ImplSDL2_GetBackendData()
+
+    case event[:type]
+
+    when SDL2::SDL_MOUSEWHEEL
+      io[:MouseWheelH] += 1 if (event[:wheel][:x] > 0)
+      io[:MouseWheelH] -= 1 if (event[:wheel][:x] < 0)
+      io[:MouseWheel] += 1  if (event[:wheel][:y] > 0)
+      io[:MouseWheel] -= 1  if (event[:wheel][:y] < 0)
+      return true
+
+    when SDL2::SDL_MOUSEBUTTONDOWN
+      bd[:MousePressed][0] = true if event[:button][:button] == SDL2::SDL_BUTTON_LEFT
+      bd[:MousePressed][1] = true if event[:button][:button] == SDL2::SDL_BUTTON_RIGHT
+      bd[:MousePressed][2] = true if event[:button][:button] == SDL2::SDL_BUTTON_MIDDLE
+      return true
+
+    when SDL2::SDL_TEXTINPUT
+      io.AddInputCharactersUTF8(event[:text][:text])
+      return true
+
+    when SDL2::SDL_KEYDOWN, SDL2::SDL_KEYUP
+      key = event[:key][:keysym][:scancode]
+      # IM_ASSERT(key >= 0 && key < IM_ARRAYSIZE(io.KeysDown))
+      io[:KeysDown][key] = (event[:type] == SDL2::SDL_KEYDOWN)
+      io[:KeyShift] = ((SDL2::SDL_GetModState() & KMOD_SHIFT) != 0)
+      io[:KeyCtrl] = ((SDL2::SDL_GetModState() & KMOD_CTRL) != 0)
+      io[:KeyAlt] = ((SDL2::SDL_GetModState() & KMOD_ALT) != 0)
+      io[:KeySuper] = ((SDL2::SDL_GetModState() & KMOD_GUI) != 0) # [TODO] io.KeySuper = false on _WIN32
+      return true
+    end
+
+    return false
+  end
+
+  def self.ImplSDL2_Init(window)
+
+    @@g_Window = window
+    @@g_Time = 0
+
+    @@g_BackendPlatformUserData = ImGui_ImplSDL2_Data.new
+    @@g_BackendPlatformUserData[:Window] = window
+
+    io = ImGuiIO.new(ImGui::GetIO())
+
+    io[:BackendPlatformUserData] = @@g_BackendPlatformUserData
+    io[:BackendPlatformName] = @@g_BackendPlatformName
+    io[:BackendFlags] |= ImGuiBackendFlags_HasMouseCursors # We can honor GetMouseCursor() values (optional)
+    io[:BackendFlags] |= ImGuiBackendFlags_HasSetMousePos  # We can honor io.WantSetMousePos requests (optional, rarely used)
+
+    # Keyboard mapping. ImGui will use those indices to peek into the io.KeysDown[] array.
+    io[:KeyMap][ImGuiKey_Tab] = SDL2::SDL_SCANCODE_TAB
+    io[:KeyMap][ImGuiKey_LeftArrow] = SDL2::SDL_SCANCODE_LEFT
+    io[:KeyMap][ImGuiKey_RightArrow] = SDL2::SDL_SCANCODE_RIGHT
+    io[:KeyMap][ImGuiKey_UpArrow] = SDL2::SDL_SCANCODE_UP
+    io[:KeyMap][ImGuiKey_DownArrow] = SDL2::SDL_SCANCODE_DOWN
+    io[:KeyMap][ImGuiKey_PageUp] = SDL2::SDL_SCANCODE_PAGEUP
+    io[:KeyMap][ImGuiKey_PageDown] = SDL2::SDL_SCANCODE_PAGEDOWN
+    io[:KeyMap][ImGuiKey_Home] = SDL2::SDL_SCANCODE_HOME
+    io[:KeyMap][ImGuiKey_End] = SDL2::SDL_SCANCODE_END
+    io[:KeyMap][ImGuiKey_Insert] = SDL2::SDL_SCANCODE_INSERT
+    io[:KeyMap][ImGuiKey_Delete] = SDL2::SDL_SCANCODE_DELETE
+    io[:KeyMap][ImGuiKey_Backspace] = SDL2::SDL_SCANCODE_BACKSPACE
+    io[:KeyMap][ImGuiKey_Space] = SDL2::SDL_SCANCODE_SPACE
+    io[:KeyMap][ImGuiKey_Enter] = SDL2::SDL_SCANCODE_RETURN
+    io[:KeyMap][ImGuiKey_Escape] = SDL2::SDL_SCANCODE_ESCAPE
+    io[:KeyMap][ImGuiKey_KeyPadEnter] = SDL2::SDL_SCANCODE_RETURN2
+    io[:KeyMap][ImGuiKey_A] = SDL2::SDL_SCANCODE_A
+    io[:KeyMap][ImGuiKey_C] = SDL2::SDL_SCANCODE_C
+    io[:KeyMap][ImGuiKey_V] = SDL2::SDL_SCANCODE_V
+    io[:KeyMap][ImGuiKey_X] = SDL2::SDL_SCANCODE_X
+    io[:KeyMap][ImGuiKey_Y] = SDL2::SDL_SCANCODE_Y
+    io[:KeyMap][ImGuiKey_Z] = SDL2::SDL_SCANCODE_Z
+
+    # [TODO] Support ClipboardText
+
+    bd = ImGui_ImplSDL2_GetBackendData()
+
+    bd[:MouseCursors][ImGuiMouseCursor_Arrow]      = SDL2::SDL_CreateSystemCursor(SDL2::SDL_SYSTEM_CURSOR_ARROW)
+    bd[:MouseCursors][ImGuiMouseCursor_TextInput]  = SDL2::SDL_CreateSystemCursor(SDL2::SDL_SYSTEM_CURSOR_IBEAM)
+    bd[:MouseCursors][ImGuiMouseCursor_ResizeAll]  = SDL2::SDL_CreateSystemCursor(SDL2::SDL_SYSTEM_CURSOR_SIZEALL)
+    bd[:MouseCursors][ImGuiMouseCursor_ResizeNS]   = SDL2::SDL_CreateSystemCursor(SDL2::SDL_SYSTEM_CURSOR_SIZENS)
+    bd[:MouseCursors][ImGuiMouseCursor_ResizeEW]   = SDL2::SDL_CreateSystemCursor(SDL2::SDL_SYSTEM_CURSOR_SIZEWE)
+    bd[:MouseCursors][ImGuiMouseCursor_ResizeNESW] = SDL2::SDL_CreateSystemCursor(SDL2::SDL_SYSTEM_CURSOR_SIZENESW)
+    bd[:MouseCursors][ImGuiMouseCursor_ResizeNWSE] = SDL2::SDL_CreateSystemCursor(SDL2::SDL_SYSTEM_CURSOR_SIZENWSE)
+    bd[:MouseCursors][ImGuiMouseCursor_Hand]       = SDL2::SDL_CreateSystemCursor(SDL2::SDL_SYSTEM_CURSOR_HAND)
+    bd[:MouseCursors][ImGuiMouseCursor_NotAllowed] = SDL2::SDL_CreateSystemCursor(SDL2::SDL_SYSTEM_CURSOR_NO)
+
+=begin
+#ifdef _WIN32
+    SDL_SysWMinfo info;
+    SDL_VERSION(&info.version);
+    if (SDL_GetWindowWMInfo(window, &info))
+        io.ImeWindowHandle = info.info.win.window;
+#else
+=end
+
+=begin
+    sdl_backend = SDL_GetCurrentVideoDriver().read_string
+    global_mouse_whitelist = [ "windows", "cocoa", "x11", "DIVE", "VMAN" ]
+    bd[:MouseCanUseGlobalState] = false
+    global_mouse_whitelist.each do |elem|
+      bd[:MouseCanUseGlobalState] = true if sdl_backend == elem
+    end
+=end
+    if defined?(SDL2::SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH)
+      SDL_SetHint(SDL2::SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH, "1")
+    end
+
+    return true
+  end
+
+end

data/lib/imgui_impl_sdlrenderer.rb

@@ -0,0 +1,201 @@
+require 'ffi'
+require 'sdl2'
+require_relative 'imgui'
+
+module ImGui
+
+  class ImGui_ImplSDLRenderer_Data < FFI::Struct
+    layout(
+      :SDLRenderer, :pointer,
+      :FontTexture, :pointer
+    )
+  end
+
+  def self.ImGui_ImplSDLRenderer_GetBackendData()
+    if ImGui::GetCurrentContext() != nil
+      io = ImGuiIO.new(ImGui::GetIO())
+      instance = ImGui_ImplSDLRenderer_Data.new(io[:BackendRendererUserData])
+      return instance
+    else
+      return nil
+    end
+  end
+
+  @@g_BackendRendererName = FFI::MemoryPointer.from_string("imgui_impl_sdlrenderer")
+  @@g_BackendRendererUserData = nil
+
+  def self.ImplSDLRenderer_Init(renderer)
+    io = ImGuiIO.new(ImGui::GetIO())
+
+    # Setup backend capabilities flags
+
+    io[:BackendRendererName] = @@g_BackendRendererName
+
+    @@g_BackendRendererUserData = ImGui_ImplSDLRenderer_Data.new
+    @@g_BackendRendererUserData[:SDLRenderer] = renderer
+    @@g_BackendRendererUserData[:FontTexture] = nil
+    io[:BackendRendererUserData] = @@g_BackendRendererUserData
+
+    io[:BackendFlags] |= ImGuiBackendFlags_RendererHasVtxOffset # We can honor the ImDrawCmd::VtxOffset field, allowing for large meshes.
+
+    return true
+  end
+
+  def self.ImplSDLRenderer_Shutdown()
+    ImplSDLRenderer_DestroyDeviceObjects()
+    io = ImGuiIO.new(ImGui::GetIO())
+    io[:BackendRendererName] = nil
+    io[:BackendRendererUserData] = nil
+    @@g_BackendRendererUserData = nil
+  end
+
+  # [Internal]
+  def self.ImplSDLRenderer_SetupRenderState()
+    bd = ImGui_ImplSDLRenderer_GetBackendData()
+
+    # Clear out any viewports and cliprect set by the user
+    # FIXME: Technically speaking there are lots of other things we could backup/setup/restore during our render process.
+    SDL_RenderSetViewport(bd[:SDLRenderer], nil)
+    SDL_RenderSetClipRect(bd[:SDLRenderer], nil)
+  end
+
+  def self.ImplSDLRenderer_NewFrame()
+    io = ImGuiIO.new(ImGui::GetIO())
+    bd = ImGui_ImplSDLRenderer_GetBackendData()
+    ImGui::ImplSDLRenderer_CreateDeviceObjects() if bd[:FontTexture] == nil
+  end
+
+  def self.ImplSDLRenderer_RenderDrawData(draw_data_raw)
+    draw_data = ImDrawData.new(draw_data_raw)
+    bd = ImGui_ImplSDLRenderer_GetBackendData()
+
+    # If there's a scale factor set by the user, use that instead
+    # If the user has specified a scale factor to SDL_Renderer already via SDL_RenderSetScale(), SDL will scale whatever we pass
+    # to SDL_RenderGeometryRaw() by that scale factor. In that case we don't want to be also scaling it ourselves here.
+    rsx = FFI::MemoryPointer.new :float
+    rsy = FFI::MemoryPointer.new :float
+    SDL_RenderGetScale(bd[:SDLRenderer], rsx, rsy)
+    render_scale = ImVec2.create(0, 0)
+    render_scale[:x] = (rsx.read_float() == 1.0) ? draw_data[:FramebufferScale][:x] : 1.0
+    render_scale[:y] = (rsy.read_float() == 1.0) ? draw_data[:FramebufferScale][:y] : 1.0
+
+    # Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates)
+    fb_width = (draw_data[:DisplaySize][:x] * render_scale[:x]).to_i
+    fb_height = (draw_data[:DisplaySize][:y] * render_scale[:y]).to_i
+    return if fb_width == 0 || fb_height == 0
+
+    # Backup SDL_Renderer state that will be modified to restore it afterwards
+    oldViewport = SDL_Rect.new
+    oldClipEnabled = FFI::MemoryPointer.new :bool
+    oldClipRect = SDL_Rect.new
+
+    oldClipEnabled = (SDL_RenderIsClipEnabled(bd[:SDLRenderer]) == SDL_TRUE)
+    SDL_RenderGetViewport(bd[:SDLRenderer], oldViewport)
+    SDL_RenderGetClipRect(bd[:SDLRenderer], oldClipRect)
+
+    # Will project scissor/clipping rectangles into framebuffer space
+    clip_off = draw_data[:DisplayPos] # (0,0) unless using multi-viewports
+    clip_scale = render_scale
+
+    # Render command lists
+    ImplSDLRenderer_SetupRenderState()
+    draw_data[:CmdListsCount].times do |n|
+      cmd_list = ImDrawList.new((draw_data[:CmdLists].pointer + FFI.type_size(:pointer) * n).read_pointer)
+      vtx_buffer = cmd_list[:VtxBuffer][:Data] # const ImDrawVert*
+      idx_buffer = cmd_list[:IdxBuffer][:Data] # const ImDrawIdx*
+
+      cmd_list[:CmdBuffer][:Size].times do |cmd_i|
+        pcmd = ImDrawCmd.new(cmd_list[:CmdBuffer][:Data] + ImDrawCmd.size * cmd_i) # const ImDrawCmd*
+        if pcmd[:UserCallback] != nil
+          # [TODO] Handle user callback (Ref.: https://github.com/ffi/ffi/wiki/Callbacks )
+
+          #  User callback, registered via ImDrawList::AddCallback()
+          #  (ImDrawCallback_ResetRenderState is a special callback value used by the user to request the renderer to reset render state.)
+          # if pcmd[:UserCallback] == :ImDrawCallback_ResetRenderState
+            ImGui_ImplSDLRenderer_SetupRenderState()
+          # else
+          #   pcmd[:UserCallback](cmd_list, pcmd)
+          # end
+        else
+          clip_min = ImVec2.create((pcmd[:ClipRect][:x] - clip_off[:x]) * clip_scale[:x], (pcmd[:ClipRect][:y] - clip_off[:y]) * clip_scale[:y])
+          clip_max = ImVec2.create((pcmd[:ClipRect][:z] - clip_off[:x]) * clip_scale[:x], (pcmd[:ClipRect][:w] - clip_off[:y]) * clip_scale[:y])
+
+          clip_min[:x] = 0.0 if clip_min[:x] < 0.0
+          clip_min[:y] = 0.0 if clip_min[:y] < 0.0
+          clip_max[:x] = fb_width.to_f if clip_max[:x] > fb_width
+          clip_max[:y] = fb_height.to_f if clip_max[:y] > fb_height
+          next if (clip_max[:x] <= clip_min[:x] || clip_max[:y] <= clip_min[:y])
+
+          r = SDL_Rect.new
+          r[:x] = clip_min[:x].to_i
+          r[:y] = clip_min[:y].to_i
+          r[:w] = (clip_max[:x] - clip_min[:x]).to_i
+          r[:h] = (clip_max[:y] - clip_min[:y]).to_i
+
+          SDL_RenderSetClipRect(bd[:SDLRenderer], r.to_ptr)
+
+          xy = vtx_buffer + (pcmd[:VtxOffset] + ImDrawVert.offset_of(:pos))
+          uv = vtx_buffer + (pcmd[:VtxOffset] + ImDrawVert.offset_of(:uv))
+          color = vtx_buffer + (pcmd[:VtxOffset] + ImDrawVert.offset_of(:col))
+
+          SDL_RenderGeometryRaw(bd[:SDLRenderer], pcmd[:TextureId],
+                                xy, ImDrawVert.size,
+                                color, ImDrawVert.size,
+                                uv, ImDrawVert.size,
+                                cmd_list[:VtxBuffer][:Size] - pcmd[:VtxOffset],
+                                idx_buffer + FFI.type_size(:ImDrawIdx) * pcmd[:IdxOffset], pcmd[:ElemCount], FFI.type_size(:ImDrawIdx)) # FFI.type_size(:ImDrawIdx) == FFI::Type::UINT16.size
+
+          # Restore modified SDL_Renderer state
+          SDL_RenderSetViewport(bd[:SDLRenderer], oldViewport)
+          SDL_RenderSetClipRect(bd[:SDLRenderer], oldClipEnabled ? oldClipRect : nil)
+        end
+      end
+    end
+  end
+
+  # Called by Init/NewFrame/Shutdown
+  def self.ImplSDLRenderer_CreateFontsTexture()
+    io = ImGuiIO.new(ImGui::GetIO())
+    bd = ImGui_ImplSDLRenderer_GetBackendData()
+
+    # Build texture atlas
+    pixels = FFI::MemoryPointer.new :pointer
+    width = FFI::MemoryPointer.new :int
+    height = FFI::MemoryPointer.new :int
+    io[:Fonts].GetTexDataAsRGBA32(pixels, width, height, nil)   #  Load as RGBA 32-bits (75% of the memory is wasted, but default font is so small) because it is more likely to be compatible with user's existing shaders. If your ImTextureId represent a higher-level concept than just a GL texture id, consider calling GetTexDataAsAlpha8() instead to save on GPU memory.
+
+    # Upload texture to graphics system
+    bd[:FontTexture] = SDL_CreateTexture(bd[:SDLRenderer], SDL_PIXELFORMAT_RGBA32, SDL_TEXTUREACCESS_STATIC, width.read_int, height.read_int)
+    if bd[:FontTexture] == nil
+      SDL_Log("error creating texture")
+      return false
+    end
+
+    SDL_UpdateTexture(bd[:FontTexture], nil, pixels.read_pointer, 4 * width.read_int)
+    SDL_SetTextureBlendMode(bd[:FontTexture], SDL_BLENDMODE_BLEND)
+
+    # Store our identifier
+    io[:Fonts].SetTexID(bd[:FontTexture])
+
+    return true
+  end
+
+  def self.ImplSDLRenderer_DestroyFontsTexture()
+    io = ImGuiIO.new(ImGui::GetIO())
+    bd = ImGui_ImplSDLRenderer_GetBackendData()
+    if bd[:FontTexture] != nil
+      io[:Fonts].SetTexID(nil)
+      SDL_DestroyTexture(bd[:FontTexture])
+      bd[:FontTexture] = nil
+    end
+  end
+
+  def self.ImplSDLRenderer_CreateDeviceObjects()
+    return ImGui::ImplSDLRenderer_CreateFontsTexture()
+  end
+
+  def self.ImplSDLRenderer_DestroyDeviceObjects()
+    ImGui::ImplSDLRenderer_DestroyFontsTexture()
+  end
+
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: imgui-bindings
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- vaiorabbit
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-12-31 00:00:00.000000000 Z
+dependencies: []
+description: 'Ruby bindings for Dear ImGui.
+
+  '
+email:
+- vaiorabbit@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ChangeLog
+- LICENSE.txt
+- README.md
+- lib/imgui.dll
+- lib/imgui.dylib
+- lib/imgui.rb
+- lib/imgui_debug.dll
+- lib/imgui_debug.dylib
+- lib/imgui_impl_glfw.rb
+- lib/imgui_impl_opengl2.rb
+- lib/imgui_impl_opengl3.rb
+- lib/imgui_impl_sdl2.rb
+- lib/imgui_impl_sdlrenderer.rb
+homepage: https://github.com/vaiorabbit/ruby-imgui
+licenses:
+- Zlib
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: Bindings for Dear ImGui
+test_files: []