imgui-bindings 0.0.1

data/lib/imgui_impl_glfw.rb

@@ -0,0 +1,240 @@
+require 'ffi'
+require 'opengl'
+require 'glfw'
+
+require_relative 'imgui'
+
+module ImGui
+
+  @@g_Window = nil # GLFWwindow*
+  @@g_Time = 0.0 # double
+  @@g_MouseWindow = nil # GLFWwindow*
+  @@g_MouseJustPressed = [false, false, false, false, false]
+  @@g_MouseCursors = Array.new(ImGuiMouseCursor_COUNT) { 0 }
+
+  @@g_BackendPlatformName = FFI::MemoryPointer.from_string("imgui_impl_glfw")
+
+  # Chain GLFW callbacks: our callbacks will call the user's previously installed callbacks, if any.
+  @@g_PrevUserCallbackCursorEnter = nil
+  @@g_PrevUserCallbackMousebutton = nil
+  @@g_PrevUserCallbackScroll = nil
+  @@g_PrevUserCallbackKey = nil
+  @@g_PrevUserCallbackChar = nil
+
+  @@ImplGlfw_MouseButtonCallback = GLFW::create_callback(:GLFWmousebuttonfun) do |window, button, action, mods|
+    unless @@g_PrevUserCallbackMousebutton.null?
+      userfunc = Fiddle::Function.new(@@g_PrevUserCallbackMousebutton, GLFWmousebuttonfun_cb_args, GLFWmousebuttonfun_cb_retval)
+      userfunc.call(window, button, action, mods)
+    end
+
+    if action == GLFW_PRESS && button >= 0 && button < @@g_MouseJustPressed.size
+      @@g_MouseJustPressed[button] = true
+    end
+  end
+
+  @@ImplGlfw_ScrollCallback = GLFW::create_callback(:GLFWscrollfun) do |window, xoffset, yoffset|
+    unless @@g_PrevUserCallbackScroll.null?
+      userfunc = Fiddle::Function.new(@@g_PrevUserCallbackScroll, GLFWscrollfun_cb_args, GLFWscrollfun_cb_retval)
+      userfunc.call(window, xoffset, yoffset)
+    end
+
+    io = ImGuiIO.new(ImGui::GetIO())
+    io[:MouseWheelH] += xoffset.to_f
+    io[:MouseWheel] += yoffset.to_f
+  end
+
+  @@ImplGlfw_KeyCallback = GLFW::create_callback(:GLFWkeyfun) do |window, key, scancode, action, mods|
+    unless @@g_PrevUserCallbackKey.null?
+      userfunc = Fiddle::Function.new(@@g_PrevUserCallbackKey, GLFWkeyfun_cb_args, GLFWkeyfun_cb_retval)
+      userfunc.call(window, key, scancode, action, mods)
+    end
+
+    io = ImGuiIO.new(ImGui::GetIO())
+    io[:KeysDown][key] = true if action == GLFW_PRESS
+    io[:KeysDown][key] = false if action == GLFW_RELEASE
+
+    # Modifiers are not reliable across systems
+    io[:KeyCtrl] = io[:KeysDown][GLFW_KEY_LEFT_CONTROL] || io[:KeysDown][GLFW_KEY_RIGHT_CONTROL]
+    io[:KeyShift] = io[:KeysDown][GLFW_KEY_LEFT_SHIFT] || io[:KeysDown][GLFW_KEY_RIGHT_SHIFT]
+    io[:KeyAlt] = io[:KeysDown][GLFW_KEY_LEFT_ALT] || io[:KeysDown][GLFW_KEY_RIGHT_ALT]
+    io[:KeySuper] = io[:KeysDown][GLFW_KEY_LEFT_SUPER] || io[:KeysDown][GLFW_KEY_RIGHT_SUPER]
+  end
+
+  @@ImGui_ImplGlfw_CursorEnterCallback = GLFW::create_callback(:GLFWcursorenterfun) do |window, entered|
+     unless @@g_PrevUserCallbackCursorEnter.null?
+       userfunc = Fiddle::Function.new(@@g_PrevUserCallbackCursorEnter, GLFWcursorenterfun_cb_args, GLFWcursorenterfun_cb_retval)
+       userfunc.call(window, entered)
+     end
+
+     @@g_MouseWindow = window if entered
+     @@g_MouseWindow = nil if (!entered && @@g_MouseWindow == window)
+  end
+
+  @@ImplGlfw_CharCallback = GLFW::create_callback(:GLFWcharfun) do |window, c|
+    unless @@g_PrevUserCallbackChar.null?
+      @@g_PrevUserCallbackChar.call(window, c)
+    end
+
+    io = ImGuiIO.new(ImGui::GetIO())
+    io.AddInputCharacter(c);
+  end
+
+  def self.ImplGlfw_UpdateMousePosAndButtons()
+    # Update buttons
+    io = ImGuiIO.new(ImGui::GetIO())
+    io[:MouseDown].size.times do |i|
+      # 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][i] = (@@g_MouseJustPressed[i] || glfwGetMouseButton(@@g_Window, i) != 0)
+      @@g_MouseJustPressed[i] = false
+    end
+
+    focused = glfwGetWindowAttrib(@@g_Window, GLFW_FOCUSED) != 0
+    mouse_window = (@@g_MouseWindow == @@g_Window || focused) ? @@g_Window : nil
+
+    # Update mouse position
+    mouse_pos_backup = io[:MousePos]
+    io[:MousePos][:x] = -Float::MAX
+    io[:MousePos][:y] = -Float::MAX
+    if io[:WantSetMousePos]
+      if focused
+        glfwSetCursorPos(@@g_Window, mouse_pos_backup[:x].to_f, mouse_pos_backup[:y].to_f)
+      end
+    elsif @@g_MouseWindow != nil
+      mouse_x = ' ' * 8
+      mouse_y = ' ' * 8
+      glfwGetCursorPos(@@g_Window, mouse_x, mouse_y)
+      io[:MousePos][:x] = mouse_x.unpack1('d')
+      io[:MousePos][:y] = mouse_y.unpack1('d')
+    end
+  end
+
+  def self.ImplGlfw_UpdateMouseCursor()
+    io = ImGuiIO.new(ImGui::GetIO())
+    return if ((io[:ConfigFlags] & ImGuiConfigFlags_NoMouseCursorChange) || glfwGetInputMode(@@g_Window, GLFW_CURSOR) == GLFW_CURSOR_DISABLED)
+
+    imgui_cursor = ImGui::GetMouseCursor()
+    if imgui_cursor == ImGuiMouseCursor_None || io[:MouseDrawCursor]
+        # Hide OS mouse cursor if imgui is drawing it or if it wants no cursor
+        glfwSetInputMode(@@g_Window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN)
+    else
+      # Show OS mouse cursor
+      # FIXME-PLATFORM: Unfocused windows seems to fail changing the mouse cursor with GLFW 3.2, but 3.3 works here.
+      glfwSetCursor(@@g_Window, @@g_MouseCursors[imgui_cursor] ? @@g_MouseCursors[imgui_cursor] : @@g_MouseCursors[ImGuiMouseCursor_Arrow])
+      glfwSetInputMode(@@g_Window, GLFW_CURSOR, GLFW_CURSOR_NORMAL)
+    end
+  end
+
+  def self.ImplGlfw_InitForOpenGL(window, install_callbacks)
+    return ImplGlfw_Init(window, install_callbacks, :GlfwClientApi_OpenGL)
+  end
+
+  def self.ImplGlfw_Shutdown()
+    ImGuiMouseCursor_COUNT.times do |cursor_n|
+      glfwDestroyCursor(@@g_MouseCursors[cursor_n])
+      @@g_MouseCursors[cursor_n] = nil
+    end
+  end
+
+  def self.ImplGlfw_NewFrame()
+    io = ImGuiIO.new(ImGui::GetIO())
+    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
+    glfwGetWindowSize(@@g_Window, w, h)
+    glfwGetFramebufferSize(@@g_Window, display_w, display_h)
+
+    w = w.unpack1('L')
+    h = h.unpack1('L')
+    io[:DisplaySize][:x] = w
+    io[:DisplaySize][:y] = h
+
+    if w > 0 && h > 0
+      io[:DisplayFramebufferScale][:x] = display_w.unpack1('L') / w
+      io[:DisplayFramebufferScale][:y] = display_h.unpack1('L') / h
+    end
+
+    #  Setup time step
+    current_time = glfwGetTime()
+    io[:DeltaTime] = @@g_Time > 0.0 ? (current_time - @@g_Time).to_f : (1.0/60.0)
+    @@g_Time = current_time
+
+    ImplGlfw_UpdateMousePosAndButtons()
+    ImplGlfw_UpdateMouseCursor()
+    # TODO update gamepads
+  end
+
+  # private
+
+  def self.ImplGlfw_Init(window, install_callbacks, client_api)
+    @@g_Window = window
+    @@g_Time = 0.0
+
+    io = ImGuiIO.new(ImGui::GetIO())
+    io[:BackendFlags] |= ImGuiBackendFlags_HasMouseCursors # We can honor GetMouseCursor() values (optional)
+    io[:BackendFlags] |= ImGuiBackendFlags_HasSetMousePos  # We can honor io.WantSetMousePos requests (optional, rarely used)
+    io[:BackendPlatformName] = @@g_BackendPlatformName
+
+    # Keyboard mapping. ImGui will use those indices to peek into the io.KeysDown[] array.
+    io[:KeyMap][ImGuiKey_Tab] = GLFW_KEY_TAB
+    io[:KeyMap][ImGuiKey_LeftArrow] = GLFW_KEY_LEFT
+    io[:KeyMap][ImGuiKey_RightArrow] = GLFW_KEY_RIGHT
+    io[:KeyMap][ImGuiKey_UpArrow] = GLFW_KEY_UP
+    io[:KeyMap][ImGuiKey_DownArrow] = GLFW_KEY_DOWN
+    io[:KeyMap][ImGuiKey_PageUp] = GLFW_KEY_PAGE_UP
+    io[:KeyMap][ImGuiKey_PageDown] = GLFW_KEY_PAGE_DOWN
+    io[:KeyMap][ImGuiKey_Home] = GLFW_KEY_HOME
+    io[:KeyMap][ImGuiKey_End] = GLFW_KEY_END
+    io[:KeyMap][ImGuiKey_Insert] = GLFW_KEY_INSERT
+    io[:KeyMap][ImGuiKey_Delete] = GLFW_KEY_DELETE
+    io[:KeyMap][ImGuiKey_Backspace] = GLFW_KEY_BACKSPACE
+    io[:KeyMap][ImGuiKey_Space] = GLFW_KEY_SPACE
+    io[:KeyMap][ImGuiKey_Enter] = GLFW_KEY_ENTER
+    io[:KeyMap][ImGuiKey_Escape] = GLFW_KEY_ESCAPE
+    io[:KeyMap][ImGuiKey_KeyPadEnter] = GLFW_KEY_KP_ENTER
+    io[:KeyMap][ImGuiKey_A] = GLFW_KEY_A
+    io[:KeyMap][ImGuiKey_C] = GLFW_KEY_C
+    io[:KeyMap][ImGuiKey_V] = GLFW_KEY_V
+    io[:KeyMap][ImGuiKey_X] = GLFW_KEY_X
+    io[:KeyMap][ImGuiKey_Y] = GLFW_KEY_Y
+    io[:KeyMap][ImGuiKey_Z] = GLFW_KEY_Z
+
+    # [TODO] Support ClipboardText & IME on Windows
+    # io.SetClipboardTextFn = ImGui_ImplGlfw_SetClipboardText;
+    # io.GetClipboardTextFn = ImGui_ImplGlfw_GetClipboardText;
+    # io.ClipboardUserData = g_Window;
+    # #if defined(_WIN32)
+    # io.ImeWindowHandle = (void*)glfwGetWin32Window(g_Window);
+    # #endif
+
+    @@g_MouseCursors[ImGuiMouseCursor_Arrow] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR)
+    @@g_MouseCursors[ImGuiMouseCursor_TextInput] = glfwCreateStandardCursor(GLFW_IBEAM_CURSOR)
+    @@g_MouseCursors[ImGuiMouseCursor_ResizeAll] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR)   # FIXME: GLFW doesn't have this.
+    @@g_MouseCursors[ImGuiMouseCursor_ResizeNS] = glfwCreateStandardCursor(GLFW_VRESIZE_CURSOR)
+    @@g_MouseCursors[ImGuiMouseCursor_ResizeEW] = glfwCreateStandardCursor(GLFW_HRESIZE_CURSOR)
+    @@g_MouseCursors[ImGuiMouseCursor_ResizeNESW] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR)  # FIXME: GLFW doesn't have this.
+    @@g_MouseCursors[ImGuiMouseCursor_ResizeNWSE] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR)  # FIXME: GLFW doesn't have this.
+    @@g_MouseCursors[ImGuiMouseCursor_Hand] = glfwCreateStandardCursor(GLFW_HAND_CURSOR)
+
+    # Chain GLFW callbacks: our callbacks will call the user's previously installed callbacks, if any.
+    @@g_PrevUserCallbackMousebutton = nil
+    @@g_PrevUserCallbackScroll = nil
+    @@g_PrevUserCallbackKey = nil
+    @@g_PrevUserCallbackChar = nil
+    if install_callbacks
+      @@g_PrevUserCallbackCursorEnter = glfwSetCursorEnterCallback(window, @@ImGui_ImplGlfw_CursorEnterCallback)
+      @@g_PrevUserCallbackMousebutton = glfwSetMouseButtonCallback(window, @@ImplGlfw_MouseButtonCallback)
+      @@g_PrevUserCallbackScroll = glfwSetScrollCallback(window, @@ImplGlfw_ScrollCallback)
+      @@g_PrevUserCallbackKey = glfwSetKeyCallback(window, @@ImplGlfw_KeyCallback)
+      @@g_PrevUserCallbackChar = glfwSetCharCallback(window, @@ImplGlfw_CharCallback)
+    end
+
+    return true
+  end
+
+end

data/lib/imgui_impl_opengl2.rb

@@ -0,0 +1,213 @@
+require 'ffi'
+require 'opengl'
+include OpenGL
+
+require_relative 'imgui'
+
+module ImGui
+
+  @@g_FontTexture = nil
+  @@g_BackendRendererName = FFI::MemoryPointer.from_string("imgui_impl_opengl2")
+
+  def self.ImplOpenGL2_Init()
+    io = ImGuiIO.new(ImGui::GetIO())
+    io[:BackendRendererName] = @@g_BackendRendererName
+
+    return true
+  end
+
+  def self.ImplOpenGL2_Shutdown()
+    ImplOpenGL2_DestroyDeviceObjects()
+  end
+
+  def self.ImplOpenGL2_NewFrame()
+    ImplOpenGL2_CreateDeviceObjects() if @@g_FontTexture == nil
+  end
+
+  def self.ImplOpenGL2_RenderDrawData(draw_data_raw)
+    #  Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates)
+    draw_data = ImDrawData.new(draw_data_raw)
+    fb_width = (draw_data[:DisplaySize][:x] * draw_data[:FramebufferScale][:x]).to_i
+    fb_height = (draw_data[:DisplaySize][:y] * draw_data[:FramebufferScale][:y]).to_i
+
+    return if fb_width == 0 || fb_height == 0
+
+    #  Backup GL state
+    last_texture = ' ' * 4
+    glGetIntegerv(GL_TEXTURE_BINDING_2D, last_texture)
+    last_polygon_mode = ' ' * 8
+    glGetIntegerv(GL_POLYGON_MODE, last_polygon_mode)
+    last_viewport = ' ' * 16
+    glGetIntegerv(GL_VIEWPORT, last_viewport)
+    last_scissor_box = ' ' * 16
+    glGetIntegerv(GL_SCISSOR_BOX, last_scissor_box)
+    glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_TRANSFORM_BIT)
+    last_shade_model = ' ' * 4
+    glGetIntegerv(GL_SHADE_MODEL, last_shade_model)
+    last_tex_env_mode = ' ' * 4
+    glGetTexEnviv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, last_tex_env_mode)
+
+    #  Setup desired GL state
+    ImplOpenGL2_SetupRenderState(draw_data, fb_width, fb_height)
+
+    #  Will project scissor/clipping rectangles into framebuffer space
+    clip_off = draw_data[:DisplayPos]         #  (0,0) unless using multi-viewports
+    clip_scale = draw_data[:FramebufferScale] #  (1,1) unless using retina display which are often (2,2)
+
+    #  Render command lists
+    draw_data[:CmdListsCount].times do |n|
+      cmd_list = ImDrawList.new((draw_data[:CmdLists].pointer + 8 * n).read_pointer) # 8 == const ImDrawList*
+      vtx_buffer = ImDrawVert.new(cmd_list[:VtxBuffer][:Data]) # const ImDrawVert*
+      idx_buffer = cmd_list[:IdxBuffer][:Data] # const ImDrawIdx*
+      glVertexPointer(2, GL_FLOAT, ImDrawVert.size,  Fiddle::Pointer.new((cmd_list[:VtxBuffer][:Data] + vtx_buffer.offset_of(:pos))) )
+      glTexCoordPointer(2, GL_FLOAT, ImDrawVert.size,  Fiddle::Pointer.new((cmd_list[:VtxBuffer][:Data] + vtx_buffer.offset_of(:uv))) )
+      glColorPointer(4, GL_UNSIGNED_BYTE, ImDrawVert.size,  Fiddle::Pointer.new((cmd_list[:VtxBuffer][:Data] + vtx_buffer.offset_of(:col))) )
+
+      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_ImplOpenGL2_SetupRenderState(draw_data, fb_width, fb_height)
+          # else
+          #   pcmd[:UserCallback](cmd_list, pcmd)
+          # end
+        else
+          #  Project scissor/clipping rectangles into framebuffer space
+          clip_rect = ImVec4.new
+          clip_rect[:x] = (pcmd[:ClipRect][:x] - clip_off[:x]) * clip_scale[:x]
+          clip_rect[:y] = (pcmd[:ClipRect][:y] - clip_off[:y]) * clip_scale[:y]
+          clip_rect[:z] = (pcmd[:ClipRect][:z] - clip_off[:x]) * clip_scale[:x]
+          clip_rect[:w] = (pcmd[:ClipRect][:w] - clip_off[:y]) * clip_scale[:y]
+
+          if (clip_rect[:x] < fb_width && clip_rect[:y] < fb_height && clip_rect[:z] >= 0.0 && clip_rect[:w] >= 0.0)
+            #  Apply scissor/clipping rectangle
+            glScissor(clip_rect[:x].to_i, (fb_height - clip_rect[:w]).to_i, (clip_rect[:z] - clip_rect[:x]).to_i, (clip_rect[:w] - clip_rect[:y]).to_i)
+
+            #  Bind texture, Draw
+            glBindTexture(GL_TEXTURE_2D, pcmd[:TextureId].address)
+            glDrawElements(GL_TRIANGLES, pcmd[:ElemCount], GL_UNSIGNED_SHORT, Fiddle::Pointer.new(idx_buffer.address))
+          end
+
+        end
+        idx_buffer += pcmd[:ElemCount] * 2 # 2 == ImDrawIdx(:ushort).size
+      end
+    end
+
+    #  Restore modified GL state
+    glDisableClientState(GL_COLOR_ARRAY)
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY)
+    glDisableClientState(GL_VERTEX_ARRAY)
+    glBindTexture(GL_TEXTURE_2D, last_texture.unpack1('L'))
+    glMatrixMode(GL_MODELVIEW)
+    glPopMatrix()
+    glMatrixMode(GL_PROJECTION)
+    glPopMatrix()
+    glPopAttrib()
+    last_polygon_mode = last_polygon_mode.unpack('L2')
+    glPolygonMode(GL_FRONT, last_polygon_mode[0])
+    glPolygonMode(GL_BACK, last_polygon_mode[1])
+    last_viewport = last_viewport.unpack('L4')
+    glViewport(last_viewport[0], last_viewport[1], last_viewport[2], last_viewport[3])
+    last_scissor_box = last_scissor_box.unpack('L4')
+    glScissor(last_scissor_box[0], last_scissor_box[1], last_scissor_box[2], last_scissor_box[3])
+    glShadeModel(last_shade_model.unpack1('L'))
+    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, last_tex_env_mode.unpack1('L'))
+  end
+
+  # private
+
+  def self.ImplOpenGL2_SetupRenderState(draw_data, fb_width, fb_height)
+    # Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, vertex/texcoord/color pointers, polygon fill.
+    glEnable(GL_BLEND)
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
+    # glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA) # In order to composite our output buffer we need to preserve alpha
+    glDisable(GL_CULL_FACE)
+    glDisable(GL_STENCIL_TEST)
+    glDisable(GL_DEPTH_TEST)
+    glDisable(GL_LIGHTING)
+    glDisable(GL_COLOR_MATERIAL)
+    glEnable(GL_SCISSOR_TEST)
+    glEnableClientState(GL_VERTEX_ARRAY)
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY)
+    glEnableClientState(GL_COLOR_ARRAY)
+    glDisableClientState(GL_NORMAL_ARRAY)
+    glEnable(GL_TEXTURE_2D)
+    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
+    glShadeModel(GL_SMOOTH)
+    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE)
+
+    #  If you are using this code with non-legacy OpenGL header/contexts (which you should not, prefer using imgui_impl_opengl3.cpp!!),
+    #  you may need to backup/reset/restore other state, e.g. for current shader using the commented lines below.
+    #  (DO NOT MODIFY THIS FILE! Add the code in your calling function)
+    #    GLint last_program;
+    #    glGetIntegerv(GL_CURRENT_PROGRAM, &last_program);
+    #    glUseProgram(0);
+    #    ImGui_ImplOpenGL2_RenderDrawData(...);
+    #    glUseProgram(last_program)
+    #  There are potentially many more states you could need to clear/setup that we can't access from default headers.
+    #  e.g. glBindBuffer(GL_ARRAY_BUFFER, 0), glDisable(GL_TEXTURE_CUBE_MAP).
+
+    #  Setup viewport, orthographic projection matrix
+    #  Our visible imgui space lies from draw_data->DisplayPos (top left) to draw_data->DisplayPos+data_data->DisplaySize (bottom right). DisplayPos is (0,0) for single viewport apps.
+    glViewport(0, 0, fb_width, fb_height)
+    glMatrixMode(GL_PROJECTION)
+    glPushMatrix()
+    glLoadIdentity()
+    glOrtho(draw_data[:DisplayPos][:x], draw_data[:DisplayPos][:x] + draw_data[:DisplaySize][:x], draw_data[:DisplayPos][:y] + draw_data[:DisplaySize][:y], draw_data[:DisplayPos][:y], -1.0, +1.0)
+    glMatrixMode(GL_MODELVIEW)
+    glPushMatrix()
+    glLoadIdentity()
+  end
+
+  def self.ImplOpenGL2_CreateFontsTexture()
+    #  Build texture atlas
+    io = ImGuiIO.new(ImGui::GetIO())
+    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
+    last_texture = ' ' * 4
+    @@g_FontTexture = ' ' * 4
+    glGetIntegerv(GL_TEXTURE_BINDING_2D, last_texture)
+    glGenTextures(1, @@g_FontTexture)
+    glBindTexture(GL_TEXTURE_2D, @@g_FontTexture.unpack1('L'))
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0)
+    # Ruby/FFI <-> Fiddle pointer exchange
+    pixels_ptr = Fiddle::Pointer.new(pixels.read_pointer.address)
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width.read_uint, height.read_uint, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels_ptr)
+
+    #  Store our identifier
+    io[:Fonts][:TexID] = @@g_FontTexture.unpack1('L')
+
+    #  Restore state
+    glBindTexture(GL_TEXTURE_2D, last_texture.unpack1('L'))
+
+    return true
+  end
+
+  def self.ImplOpenGL2_DestroyFontsTexture()
+    if @@g_FontTexture != 0
+      glDeleteTextures(1, @@g_FontTexture)
+      io = ImGuiIO.new(ImGui::GetIO())
+      io[:Fonts][:TexID] = 0
+      @@g_FontTexture = 0
+    end
+  end
+
+  def self.ImplOpenGL2_CreateDeviceObjects()
+    return ImplOpenGL2_CreateFontsTexture()
+  end
+
+  def self.ImplOpenGL2_DestroyDeviceObjects()
+    ImplOpenGL2_DestroyFontsTexture()
+  end
+
+end