imgui-bindings 0.1.17-aarch64-linux → 1.0.1-aarch64-linux

data/lib/imgui_impl_raylib.rb

@@ -5,17 +5,40 @@ require_relative 'imgui'
 
 module ImGui
 
+  CAMERA_MOVE_SPEED = 5.4
+  CAMERA_ROTATION_SPEED = 0.03
+  CAMERA_PAN_SPEED = 2.0
+  CAMERA_MOUSE_MOVE_SENSITIVITY = 0.003
+  CAMERA_ORBITAL_SPEED = 0.5
+
   @@g_BackendPlatformName = FFI::MemoryPointer.from_string("imgui_impl_raylib")
+  @@g_BackendRendererName = FFI::MemoryPointer.from_string("imgui_impl_raylib")
 
   # ImGui::GetCurrentContext().address => ImGui_ImplRaylib_Data
   @@g_BackendData = Hash.new
 
   # [INTERNAL]
   class ImGui_ImplRaylib_Data
-    attr_accessor :time
+    attr_accessor :time, :textures, :warned_viewports_unsupported
 
     def initialize
       @time = 0.0
+      @textures = {}
+      @warned_viewports_unsupported = false
+    end
+  end
+
+  # [INTERNAL]
+  def self.ImplRaylib_DisableUnsupportedViewports(io = nil)
+    io = ImGuiIO.new(ImGui::GetIO()) if io == nil
+    return if (io[:ConfigFlags] & ImGuiConfigFlags_ViewportsEnable) == 0
+
+    io[:ConfigFlags] &= ~ImGuiConfigFlags_ViewportsEnable
+    bd = ImGui_ImplRaylib_GetBackendData()
+    if bd != nil && !bd.warned_viewports_unsupported
+      # raylib backend currently supports docking in a single OS window only.
+      $stderr.puts('[imgui_impl_raylib] ImGuiConfigFlags_ViewportsEnable is not supported and was disabled.')
+      bd.warned_viewports_unsupported = true
     end
   end
 
@@ -28,6 +51,89 @@ module ImGui
     end
   end
 
+  # [INTERNAL]
+  def self.ImplRaylib_UpdateTexture(tex_raw)
+    bd = ImGui_ImplRaylib_GetBackendData()
+    return if bd == nil
+
+    tex = tex_raw.kind_of?(ImTextureData) ? tex_raw : ImTextureData.new(tex_raw)
+
+    case tex[:Status]
+    when ImTextureStatus_WantCreate
+      return if tex[:Format] != ImTextureFormat_RGBA32
+
+      image = Raylib::Image.new
+      image[:data] = tex.GetPixels()
+      image[:width] = tex[:Width]
+      image[:height] = tex[:Height]
+      image[:mipmaps] = 1
+      image[:format] = Raylib::PIXELFORMAT_UNCOMPRESSED_R8G8B8A8
+
+      texture = Raylib.LoadTextureFromImage(image)
+      raise 'Backend failed to create Raylib texture!' if texture[:id] == 0
+
+      Raylib.SetTextureFilter(texture, Raylib::TEXTURE_FILTER_BILINEAR)
+      Raylib.SetTextureWrap(texture, Raylib::TEXTURE_WRAP_CLAMP)
+
+      bd.textures[texture[:id]] = texture
+
+      tex.SetTexID(texture[:id])
+      tex.SetStatus(ImTextureStatus_OK)
+
+    when ImTextureStatus_WantUpdates
+      tex_id = tex.GetTexID()
+      return if tex_id == 0
+
+      texture = bd.textures[tex_id]
+      if texture == nil
+        texture = Raylib::Texture.new
+        texture[:id] = tex_id
+        texture[:width] = tex[:Width]
+        texture[:height] = tex[:Height]
+        texture[:mipmaps] = 1
+        texture[:format] = Raylib::PIXELFORMAT_UNCOMPRESSED_R8G8B8A8
+      end
+
+      # Raylib.UpdateTextureRec has no row-pitch argument, so sub-rect updates
+      # sourced from a larger atlas can sample incorrect rows and corrupt glyphs.
+      # Uploading the full atlas keeps texture data consistent across backends.
+      Raylib.UpdateTexture(texture, tex.GetPixels())
+      tex.SetStatus(ImTextureStatus_OK)
+
+    when ImTextureStatus_WantDestroy
+      tex_id = tex.GetTexID()
+      if tex_id != 0 && tex[:UnusedFrames] > 0
+        texture = bd.textures.delete(tex_id)
+        if texture == nil
+          texture = Raylib::Texture.new
+          texture[:id] = tex_id
+          texture[:width] = tex[:Width]
+          texture[:height] = tex[:Height]
+          texture[:mipmaps] = 1
+          texture[:format] = Raylib::PIXELFORMAT_UNCOMPRESSED_R8G8B8A8
+        end
+
+        Raylib.UnloadTexture(texture)
+        tex.SetTexID(0)
+        tex.SetStatus(ImTextureStatus_Destroyed)
+      end
+    end
+  end
+
+  # [INTERNAL]
+  def self.ImplRaylib_ProcessTextureUpdates(draw_data)
+    return if draw_data[:Textures] == nil || draw_data[:Textures].address == 0
+
+    textures = ImVector_ImTextureDataPtr.new(draw_data[:Textures])
+    textures[:Size].times do |i|
+      tex_ptr = (textures[:Data] + FFI.type_size(:pointer) * i).read_pointer
+      next if tex_ptr == nil || tex_ptr.address == 0
+
+      tex = ImTextureData.new(tex_ptr)
+      ImplRaylib_UpdateTexture(tex) if tex[:Status] != ImTextureStatus_OK
+    end
+  end
+
   # [TODO] Support ClipboardText
   # g_ClipboardTextData
   # ImplRaylib_GetClipboardText
@@ -203,7 +309,7 @@ module ImGui
     when Raylib::KEY_RIGHT_SHIFT then ImGuiKey_RightShift
     when Raylib::KEY_RIGHT_ALT then ImGuiKey_RightAlt
     when Raylib::KEY_RIGHT_SUPER then ImGuiKey_RightSuper
-    when Raylib::KEY_MENU then ImGuiKey_Menu
+    when Raylib::KEY_KB_MENU then ImGuiKey_Menu
     when Raylib::KEY_ZERO then ImGuiKey_0
     when Raylib::KEY_ONE then ImGuiKey_1
     when Raylib::KEY_TWO then ImGuiKey_2
@@ -289,7 +395,6 @@ module ImGui
 
   # [INTERNAL]
   def self.ImplRaylib_UpdateMouseData()
-    bd = ImGui_ImplRaylib_GetBackendData()
     io = ImGuiIO.new(ImGui::GetIO())
 
     # Set OS mouse position if requested (rarely used, only when ImGuiConfigFlags_NavEnableSetMousePos is enabled by user)
@@ -335,17 +440,176 @@ module ImGui
   # [TODO] Support ImplRaylib_UpdateGamepads
   #
 
+  # [INTERNAL]
+  def self.ImplRaylib_CameraPointer(camera)
+    if camera.kind_of?(FFI::Pointer)
+      camera
+    elsif camera.respond_to?(:pointer)
+      camera.pointer
+    else
+      raise ArgumentError, 'camera must be Raylib::Camera (FFI::Struct) or FFI::Pointer'
+    end
+  end
+
+  # ImGui-aware UpdateCamera implementation in Ruby.
+  # Unlike Raylib.UpdateCamera(), this checks io[:WantCaptureMouse]/io[:WantCaptureKeyboard]
+  # and avoids camera control while ImGui is consuming corresponding inputs.
+  def self.ImplRaylib_UpdateCamera(camera, mode)
+    camera_ptr = ImplRaylib_CameraPointer(camera)
+    io = ImGuiIO.new(ImGui::GetIO())
+
+    mouse_position_delta = Raylib.GetMouseDelta()
+
+    move_in_world_plane = (mode == Raylib::CAMERA_FIRST_PERSON) || (mode == Raylib::CAMERA_THIRD_PERSON)
+    rotate_around_target = (mode == Raylib::CAMERA_THIRD_PERSON) || (mode == Raylib::CAMERA_ORBITAL)
+    lock_view = (mode == Raylib::CAMERA_FREE) || (mode == Raylib::CAMERA_FIRST_PERSON) || (mode == Raylib::CAMERA_THIRD_PERSON) || (mode == Raylib::CAMERA_ORBITAL)
+    rotate_up = false
+
+    frame_time = Raylib.GetFrameTime()
+    camera_move_speed = CAMERA_MOVE_SPEED * frame_time
+    camera_rotation_speed = CAMERA_ROTATION_SPEED * frame_time
+    camera_pan_speed = CAMERA_PAN_SPEED * frame_time
+    camera_orbital_speed = CAMERA_ORBITAL_SPEED * frame_time
+
+    wants_mouse = io[:WantCaptureMouse]
+    wants_keyboard = io[:WantCaptureKeyboard]
+    any_imgui_window_focused = false
+    begin
+      any_imgui_window_focused = ImGui.IsWindowFocused(ImGuiFocusedFlags_AnyWindow)
+    rescue StandardError
+      # Keep backward compatibility with older bindings.
+      any_imgui_window_focused = false
+    end
+    block_keyboard_controls = wants_keyboard || any_imgui_window_focused
+
+    if mode == Raylib::CAMERA_CUSTOM
+      # no-op
+    elsif mode == Raylib::CAMERA_ORBITAL
+      rotation = Raylib.MatrixRotate(Raylib.GetCameraUp(camera_ptr), camera_orbital_speed)
+      view = Raylib.Vector3Subtract(Raylib::Camera.new(camera_ptr)[:position], Raylib::Camera.new(camera_ptr)[:target])
+      view = Raylib.Vector3Transform(view, rotation)
+      camera_data = Raylib::Camera.new(camera_ptr)
+      camera_data[:position] = Raylib.Vector3Add(camera_data[:target], view)
+    else
+      if !block_keyboard_controls
+        if Raylib.IsKeyDown(Raylib::KEY_DOWN)
+          Raylib.CameraPitch(camera_ptr, -camera_rotation_speed, lock_view, rotate_around_target, rotate_up)
+        end
+        if Raylib.IsKeyDown(Raylib::KEY_UP)
+          Raylib.CameraPitch(camera_ptr, camera_rotation_speed, lock_view, rotate_around_target, rotate_up)
+        end
+        if Raylib.IsKeyDown(Raylib::KEY_RIGHT)
+          Raylib.CameraYaw(camera_ptr, -camera_rotation_speed, rotate_around_target)
+        end
+        if Raylib.IsKeyDown(Raylib::KEY_LEFT)
+          Raylib.CameraYaw(camera_ptr, camera_rotation_speed, rotate_around_target)
+        end
+        if Raylib.IsKeyDown(Raylib::KEY_Q)
+          Raylib.CameraRoll(camera_ptr, -camera_rotation_speed)
+        end
+        if Raylib.IsKeyDown(Raylib::KEY_E)
+          Raylib.CameraRoll(camera_ptr, camera_rotation_speed)
+        end
+      end
+
+      if !wants_mouse
+        if (mode == Raylib::CAMERA_FREE) && Raylib.IsMouseButtonDown(Raylib::MOUSE_BUTTON_MIDDLE)
+          mouse_delta = Raylib.GetMouseDelta()
+          if mouse_delta[:x] > 0.0
+            Raylib.CameraMoveRight(camera_ptr, camera_pan_speed, move_in_world_plane)
+          end
+          if mouse_delta[:x] < 0.0
+            Raylib.CameraMoveRight(camera_ptr, -camera_pan_speed, move_in_world_plane)
+          end
+          if mouse_delta[:y] > 0.0
+            Raylib.CameraMoveUp(camera_ptr, -camera_pan_speed)
+          end
+          if mouse_delta[:y] < 0.0
+            Raylib.CameraMoveUp(camera_ptr, camera_pan_speed)
+          end
+        else
+          Raylib.CameraYaw(camera_ptr, -mouse_position_delta[:x] * CAMERA_MOUSE_MOVE_SENSITIVITY, rotate_around_target)
+          Raylib.CameraPitch(camera_ptr, -mouse_position_delta[:y] * CAMERA_MOUSE_MOVE_SENSITIVITY, lock_view, rotate_around_target, rotate_up)
+        end
+      end
+
+      if !block_keyboard_controls
+        if Raylib.IsKeyDown(Raylib::KEY_W)
+          Raylib.CameraMoveForward(camera_ptr, camera_move_speed, move_in_world_plane)
+        end
+        if Raylib.IsKeyDown(Raylib::KEY_A)
+          Raylib.CameraMoveRight(camera_ptr, -camera_move_speed, move_in_world_plane)
+        end
+        if Raylib.IsKeyDown(Raylib::KEY_S)
+          Raylib.CameraMoveForward(camera_ptr, -camera_move_speed, move_in_world_plane)
+        end
+        if Raylib.IsKeyDown(Raylib::KEY_D)
+          Raylib.CameraMoveRight(camera_ptr, camera_move_speed, move_in_world_plane)
+        end
+      end
+
+      if Raylib.IsGamepadAvailable(0)
+        Raylib.CameraYaw(camera_ptr, -(Raylib.GetGamepadAxisMovement(0, Raylib::GAMEPAD_AXIS_RIGHT_X) * 2.0) * CAMERA_MOUSE_MOVE_SENSITIVITY, rotate_around_target)
+        Raylib.CameraPitch(camera_ptr, -(Raylib.GetGamepadAxisMovement(0, Raylib::GAMEPAD_AXIS_RIGHT_Y) * 2.0) * CAMERA_MOUSE_MOVE_SENSITIVITY, lock_view, rotate_around_target, rotate_up)
+
+        if Raylib.GetGamepadAxisMovement(0, Raylib::GAMEPAD_AXIS_LEFT_Y) <= -0.25
+          Raylib.CameraMoveForward(camera_ptr, camera_move_speed, move_in_world_plane)
+        end
+        if Raylib.GetGamepadAxisMovement(0, Raylib::GAMEPAD_AXIS_LEFT_X) <= -0.25
+          Raylib.CameraMoveRight(camera_ptr, -camera_move_speed, move_in_world_plane)
+        end
+        if Raylib.GetGamepadAxisMovement(0, Raylib::GAMEPAD_AXIS_LEFT_Y) >= 0.25
+          Raylib.CameraMoveForward(camera_ptr, -camera_move_speed, move_in_world_plane)
+        end
+        if Raylib.GetGamepadAxisMovement(0, Raylib::GAMEPAD_AXIS_LEFT_X) >= 0.25
+          Raylib.CameraMoveRight(camera_ptr, camera_move_speed, move_in_world_plane)
+        end
+      end
+
+      if mode == Raylib::CAMERA_FREE && !block_keyboard_controls
+        if Raylib.IsKeyDown(Raylib::KEY_SPACE)
+          Raylib.CameraMoveUp(camera_ptr, camera_move_speed)
+        end
+        if Raylib.IsKeyDown(Raylib::KEY_LEFT_CONTROL)
+          Raylib.CameraMoveUp(camera_ptr, -camera_move_speed)
+        end
+      end
+    end
+
+    if ((mode == Raylib::CAMERA_THIRD_PERSON) || (mode == Raylib::CAMERA_ORBITAL) || (mode == Raylib::CAMERA_FREE)) && !wants_mouse
+      Raylib.CameraMoveToTarget(camera_ptr, -Raylib.GetMouseWheelMove())
+      if Raylib.IsKeyPressed(Raylib::KEY_KP_SUBTRACT)
+        Raylib.CameraMoveToTarget(camera_ptr, 2.0)
+      end
+      if Raylib.IsKeyPressed(Raylib::KEY_KP_ADD)
+        Raylib.CameraMoveToTarget(camera_ptr, -2.0)
+      end
+    end
+  end
+
   def self.ImplRaylib_Init()
     # Setup backend capabilities flags
     bd = ImGui_ImplRaylib_Data.new
     @@g_BackendData[ImGui::GetCurrentContext().address] = bd
 
     io = ImGuiIO.new(ImGui::GetIO())
+    platform_io = ImGuiPlatformIO.new(ImGui::GetPlatformIO())
 
     io[:BackendPlatformUserData] = nil
     io[:BackendPlatformName] = @@g_BackendPlatformName
+    io[:BackendRendererUserData] = nil
+    io[:BackendRendererName] = @@g_BackendRendererName
     io[:BackendFlags] |= ImGuiBackendFlags_HasMouseCursors # We can honor GetMouseCursor() values (optional)
     io[:BackendFlags] |= ImGuiBackendFlags_HasSetMousePos  # We can honor io.WantSetMousePos requests (optional, rarely used)
+    io[:BackendFlags] |= ImGuiBackendFlags_RendererHasVtxOffset
+    io[:BackendFlags] |= ImGuiBackendFlags_RendererHasTextures
+    io[:BackendFlags] &= ~(ImGuiBackendFlags_PlatformHasViewports | ImGuiBackendFlags_RendererHasViewports)
+
+    ImplRaylib_DisableUnsupportedViewports(io)
+
+    # Conservative limit suitable for most GL backends used by raylib.
+    platform_io[:Renderer_TextureMaxWidth] = 8192
+    platform_io[:Renderer_TextureMaxHeight] = 8192
 
     bd.time = 0.0
 
@@ -353,10 +617,32 @@ module ImGui
   end
 
   def self.ImplRaylib_Shutdown()
+    bd = ImGui_ImplRaylib_GetBackendData()
     io = ImGuiIO.new(ImGui::GetIO())
+    platform_io = ImGuiPlatformIO.new(ImGui::GetPlatformIO())
+
+    if bd != nil
+      bd.textures.each_value do |texture|
+        Raylib.UnloadTexture(texture) if texture != nil && texture[:id] != 0
+      end
+      bd.textures.clear
+    end
+
     io[:BackendPlatformName] = nil
     io[:BackendPlatformUserData] = nil
-    @@g_BackendData[ImGui::GetCurrentContext()] = nil
+    io[:BackendRendererName] = nil
+    io[:BackendRendererUserData] = nil
+    io[:BackendFlags] &= ~(ImGuiBackendFlags_HasMouseCursors | ImGuiBackendFlags_HasSetMousePos | ImGuiBackendFlags_RendererHasVtxOffset | ImGuiBackendFlags_RendererHasTextures | ImGuiBackendFlags_PlatformHasViewports | ImGuiBackendFlags_RendererHasViewports)
+
+    begin
+      platform_io.ClearRendererHandlers()
+    rescue StandardError
+      # Older generated bindings may not expose this helper.
+    end
+
+    if ImGui::GetCurrentContext() != nil
+      @@g_BackendData.delete(ImGui::GetCurrentContext().address)
+    end
   end
 
   def self.ImplRaylib_NewFrame()
@@ -373,6 +659,8 @@ module ImGui
     io[:DeltaTime] = bd.time > 0 ? (current_time - bd.time).to_f : 1.0 / 60.0
     bd.time = current_time
 
+    ImplRaylib_DisableUnsupportedViewports(io)
+
     ImplRaylib_ProcessKeyboard()
     ImplRaylib_UpdateMouseData()
     ImplRaylib_UpdateMouseCursor()
@@ -389,9 +677,17 @@ module ImGui
 
   def self.ImplRaylib_RenderDrawData(draw_data_raw)
     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
+
+    ImplRaylib_ProcessTextureUpdates(draw_data)
+
     Raylib.rlDisableBackfaceCulling()
 
     clip_offset = draw_data[:DisplayPos]
+    clip_scale = draw_data[:FramebufferScale]
     draw_data[:CmdListsCount].times do |n|
       cmd_list = ImDrawList.new((draw_data[:CmdLists][:Data] + FFI.type_size(:pointer) * n).read_pointer)
       vtx_buffer = cmd_list[:VtxBuffer][:Data] # const ImDrawVert*
@@ -402,15 +698,21 @@ module ImGui
         if pcmd[:UserCallback] != nil
           # [TODO] Handle user callback (Ref.: https://github.com/ffi/ffi/wiki/Callbacks )
         else
-          rect_min_x = (pcmd[:ClipRect][:x] - clip_offset[:x])
-          rect_min_y = (pcmd[:ClipRect][:y] - clip_offset[:y])
-          rect_max_x = (pcmd[:ClipRect][:z] - clip_offset[:x])
-          rect_max_y = (pcmd[:ClipRect][:w] - clip_offset[:y])
+          rect_min_x = (pcmd[:ClipRect][:x] - clip_offset[:x]) * clip_scale[:x]
+          rect_min_y = (pcmd[:ClipRect][:y] - clip_offset[:y]) * clip_scale[:y]
+          rect_max_x = (pcmd[:ClipRect][:z] - clip_offset[:x]) * clip_scale[:x]
+          rect_max_y = (pcmd[:ClipRect][:w] - clip_offset[:y]) * clip_scale[:y]
+
+          rect_min_x = 0.0 if rect_min_x < 0.0
+          rect_min_y = 0.0 if rect_min_y < 0.0
+          rect_max_x = fb_width.to_f if rect_max_x > fb_width
+          rect_max_y = fb_height.to_f if rect_max_y > fb_height
+          next if rect_max_x <= rect_min_x || rect_max_y <= rect_min_y
 
           rect_w = rect_max_x - rect_min_x
           rect_h = rect_max_y - rect_min_y
 
-          Raylib.BeginScissorMode(rect_min_x, rect_min_y, rect_w, rect_h)
+          Raylib.BeginScissorMode(rect_min_x.to_i, rect_min_y.to_i, rect_w.to_i, rect_h.to_i)
 
           # Render triangles
           indices = idx_buffer + FFI.type_size(:ImDrawIdx) * pcmd[:IdxOffset]
@@ -418,8 +720,7 @@ module ImGui
           0.step(pcmd[:ElemCount] - 3, 3) do |i|
             Raylib.rlPushMatrix()
               Raylib.rlBegin(Raylib::RL_TRIANGLES)
-              # Raylib.rlSetTexture(pcmd[:TextureId].read_uint32)
-              Raylib.rlSetTexture(pcmd[:TextureId])
+              Raylib.rlSetTexture(pcmd.GetTexID())
 
                 index = indices.get_array_of_uint16(i * FFI::type_size(:ImDrawIdx), 3)
 
@@ -452,4 +753,29 @@ module ImGui
     Raylib.rlEnableBackfaceCulling()
   end
 
+  # Docking-compatible wrapper API (single viewport only)
+  def self.ImplDockingRaylib_Init()
+    ImplRaylib_Init()
+  end
+
+  # Docking-compatible wrapper API (single viewport only)
+  def self.ImplDockingRaylib_Shutdown()
+    ImplRaylib_Shutdown()
+  end
+
+  # Docking-compatible wrapper API (single viewport only)
+  def self.ImplDockingRaylib_NewFrame()
+    ImplRaylib_NewFrame()
+  end
+
+  # Docking-compatible wrapper API (single viewport only)
+  def self.ImplDockingRaylib_RenderDrawData(draw_data_raw)
+    ImplRaylib_RenderDrawData(draw_data_raw)
+  end
+
+  # Docking-compatible wrapper API (single viewport only)
+  def self.ImplDockingRaylib_UpdateCamera(camera, mode)
+    ImplRaylib_UpdateCamera(camera, mode)
+  end
+
 end