imgui 1.0.0

data/lib/imgui/dsl.rb

@@ -0,0 +1,311 @@
+# frozen_string_literal: true
+
+module ImGui
+  class << self
+    def window(title, open: nil, flags: 0, &block)
+      guard_context!
+      open_pointer = boolean_pointer(open)
+      run_scope(
+        :window,
+        :igEnd,
+        Native.igBegin(title.to_s, open_pointer, Integer(flags)),
+        always_close: true,
+        &block
+      )
+    end
+
+    def child(id, size: [0, 0], child_flags: 0, window_flags: 0, &block)
+      guard_context!
+      opened = Native.igBeginChild_Str(
+        id.to_s,
+        StructValue.vec2(size),
+        Integer(child_flags),
+        Integer(window_flags)
+      )
+      run_scope(:child, :igEndChild, opened, always_close: true, &block)
+    end
+
+    def child_id(id, size: [0, 0], child_flags: 0, window_flags: 0, &block)
+      guard_context!
+      opened = Native.igBeginChild_ID(
+        Integer(id),
+        StructValue.vec2(size),
+        Integer(child_flags),
+        Integer(window_flags)
+      )
+      run_scope(:child, :igEndChild, opened, always_close: true, &block)
+    end
+
+    def menu_bar(&block)
+      conditional_scope(:menu_bar, :igBeginMenuBar, :igEndMenuBar, &block)
+    end
+
+    def main_menu_bar(&block)
+      conditional_scope(:main_menu_bar, :igBeginMainMenuBar, :igEndMainMenuBar, &block)
+    end
+
+    def menu(label, enabled: true, &block)
+      conditional_scope(:menu, :igBeginMenu, :igEndMenu, label.to_s, !!enabled, &block)
+    end
+
+    def popup(id, flags: 0, &block)
+      conditional_scope(:popup, :igBeginPopup, :igEndPopup, id.to_s, Integer(flags), &block)
+    end
+
+    def popup_context_item(id = nil, flags: PopupFlags::MouseButtonRight, &block)
+      conditional_scope(
+        :popup,
+        :igBeginPopupContextItem,
+        :igEndPopup,
+        id&.to_s,
+        Integer(flags),
+        &block
+      )
+    end
+
+    def popup_context_window(id = nil, flags: PopupFlags::MouseButtonRight, &block)
+      conditional_scope(
+        :popup,
+        :igBeginPopupContextWindow,
+        :igEndPopup,
+        id&.to_s,
+        Integer(flags),
+        &block
+      )
+    end
+
+    def popup_context_void(id = nil, flags: PopupFlags::MouseButtonRight, &block)
+      conditional_scope(
+        :popup,
+        :igBeginPopupContextVoid,
+        :igEndPopup,
+        id&.to_s,
+        Integer(flags),
+        &block
+      )
+    end
+
+    def popup_modal(title, open: nil, flags: 0, &block)
+      conditional_scope(
+        :popup,
+        :igBeginPopupModal,
+        :igEndPopup,
+        title.to_s,
+        boolean_pointer(open),
+        Integer(flags),
+        &block
+      )
+    end
+
+    def combo(label, preview = nil, flags: 0, &block)
+      conditional_scope(:combo, :igBeginCombo, :igEndCombo, label.to_s, preview, Integer(flags), &block)
+    end
+
+    def combo_preview(&block)
+      conditional_scope(:combo_preview, :igBeginComboPreview, :igEndComboPreview, &block)
+    end
+
+    def list_box(label, size: [0, 0], &block)
+      conditional_scope(
+        :list_box,
+        :igBeginListBox,
+        :igEndListBox,
+        label.to_s,
+        StructValue.vec2(size),
+        &block
+      )
+    end
+
+    def table(id, columns, flags: 0, outer_size: [0, 0], inner_width: 0.0, &block)
+      conditional_scope(
+        :table,
+        :igBeginTable,
+        :igEndTable,
+        id.to_s,
+        Integer(columns),
+        Integer(flags),
+        StructValue.vec2(outer_size),
+        Float(inner_width),
+        &block
+      )
+    end
+
+    def tab_bar(id, flags: 0, &block)
+      conditional_scope(:tab_bar, :igBeginTabBar, :igEndTabBar, id.to_s, Integer(flags), &block)
+    end
+
+    def tab_item(label, open: nil, flags: 0, &block)
+      conditional_scope(
+        :tab_item,
+        :igBeginTabItem,
+        :igEndTabItem,
+        label.to_s,
+        boolean_pointer(open),
+        Integer(flags),
+        &block
+      )
+    end
+
+    def tooltip(&block)
+      conditional_scope(:tooltip, :igBeginTooltip, :igEndTooltip, &block)
+    end
+
+    def item_tooltip(&block)
+      conditional_scope(:tooltip, :igBeginItemTooltip, :igEndTooltip, &block)
+    end
+
+    def multi_select(flags: 0, selection_size: 0, items_count: -1, &block)
+      pointer_scope(
+        :multi_select,
+        :igBeginMultiSelect,
+        :igEndMultiSelect,
+        Integer(flags),
+        Integer(selection_size),
+        Integer(items_count),
+        &block
+      )
+    end
+
+    def tree_node(label, &block)
+      conditional_scope(:tree_node, :igTreeNode_Str, :igTreePop, label.to_s, &block)
+    end
+
+    def tree_node_ex(label, flags: 0, &block)
+      conditional_scope(:tree_node, :igTreeNodeEx_Str, :igTreePop, label.to_s, Integer(flags), &block)
+    end
+
+    def drag_drop_source(flags: 0, &block)
+      conditional_scope(
+        :drag_drop_source,
+        :igBeginDragDropSource,
+        :igEndDragDropSource,
+        Integer(flags),
+        &block
+      )
+    end
+
+    def drag_drop_target(&block)
+      conditional_scope(:drag_drop_target, :igBeginDragDropTarget, :igEndDragDropTarget, &block)
+    end
+
+    def group(&block)
+      void_scope(:group, :igBeginGroup, :igEndGroup, &block)
+    end
+
+    def disabled(disabled = true, &block)
+      void_scope(:disabled, :igBeginDisabled, :igEndDisabled, !!disabled, &block)
+    end
+
+    def font(font, &block)
+      push_scope(:font, :igPushFont, :igPopFont, Backends.pointer(font), &block)
+    end
+
+    def item_width(width, &block)
+      push_scope(:item_width, :igPushItemWidth, :igPopItemWidth, Float(width), &block)
+    end
+
+    def text_wrap_pos(position = 0.0, &block)
+      push_scope(:text_wrap_pos, :igPushTextWrapPos, :igPopTextWrapPos, Float(position), &block)
+    end
+
+    def item_flag(flag, enabled = true, &block)
+      push_scope(:item_flag, :igPushItemFlag, :igPopItemFlag, Integer(flag), !!enabled, &block)
+    end
+
+    def focus_scope(id, &block)
+      push_scope(:focus_scope, :igPushFocusScope, :igPopFocusScope, Integer(id), &block)
+    end
+
+    def clip_rect(minimum, maximum, intersect: false, &block)
+      push_scope(
+        :clip_rect,
+        :igPushClipRect,
+        :igPopClipRect,
+        StructValue.vec2(minimum),
+        StructValue.vec2(maximum),
+        !!intersect,
+        &block
+      )
+    end
+
+    def style_color(index, color)
+      arguments = [
+        :style_color,
+        :igPushStyleColor_Vec4,
+        :igPopStyleColor,
+        Integer(index),
+        StructValue.vec4(color)
+      ]
+      return push_scope(*arguments, pop_arguments: [1]) unless block_given?
+
+      push_scope(*arguments, pop_arguments: [1]) { yield }
+    end
+
+    def style_var(index, value)
+      function, native_value = if value.is_a?(Array)
+                                 [:igPushStyleVar_Vec2, StructValue.vec2(value)]
+                               else
+                                 [:igPushStyleVar_Float, Float(value)]
+                               end
+      arguments = [:style_var, function, :igPopStyleVar, Integer(index), native_value]
+      return push_scope(*arguments, pop_arguments: [1]) unless block_given?
+
+      push_scope(*arguments, pop_arguments: [1]) { yield }
+    end
+
+    def with_id(value)
+      guard_context!
+      push_id(value)
+      return run_pushed_scope(:id, :igPopID) unless block_given?
+
+      run_pushed_scope(:id, :igPopID) { yield }
+    end
+
+    def end_window
+      close_manual_scope(:window)
+    end
+
+    def end_child
+      close_manual_scope(:child)
+    end
+
+    {
+      end_menu_bar: :menu_bar,
+      end_main_menu_bar: :main_menu_bar,
+      end_menu: :menu,
+      end_popup: :popup,
+      end_combo: :combo,
+      end_combo_preview: :combo_preview,
+      end_list_box: :list_box,
+      end_table: :table,
+      end_tab_bar: :tab_bar,
+      end_tab_item: :tab_item,
+      end_tooltip: :tooltip,
+      end_multi_select: :multi_select,
+      tree_pop: :tree_node,
+      end_drag_drop_source: :drag_drop_source,
+      end_drag_drop_target: :drag_drop_target,
+      end_group: :group,
+      end_disabled: :disabled,
+      pop_font: :font,
+      pop_item_width: :item_width,
+      pop_text_wrap_pos: :text_wrap_pos,
+      pop_item_flag: :item_flag,
+      pop_focus_scope: :focus_scope,
+      pop_clip_rect: :clip_rect,
+      pop_style_color: :style_color,
+      pop_style_var: :style_var,
+      pop_id: :id
+    }.each do |method_name, kind|
+      define_method(method_name) { close_manual_scope(kind) }
+    end
+
+    def close_scope
+      scope = scope_stack.last
+      raise StackError, "there is no open manual scope" unless scope
+
+      close_manual_scope(scope.fetch(0))
+    end
+
+  end
+end

data/lib/imgui/dsl_support.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module ImGui
+  class << self
+    private
+
+    def conditional_scope(kind, begin_function, end_function, *arguments, &block)
+      guard_context!
+      opened = Native.public_send(begin_function, *arguments)
+      run_scope(kind, end_function, opened, always_close: false, &block)
+    end
+
+    def void_scope(kind, begin_function, end_function, *arguments, &block)
+      guard_context!
+      Native.public_send(begin_function, *arguments)
+      run_scope(kind, end_function, true, always_close: true, &block)
+    end
+
+    def pointer_scope(kind, begin_function, end_function, *arguments, &block)
+      guard_context!
+      pointer = Native.public_send(begin_function, *arguments)
+      opened = !null_pointer?(pointer)
+      return run_scope(kind, end_function, pointer, always_close: false) unless block
+      return unless opened
+
+      begin
+        block.call(pointer)
+      ensure
+        Native.public_send(end_function)
+      end
+    end
+
+    def push_scope(kind, push_function, pop_function, *arguments, pop_arguments: [], &block)
+      guard_context!
+      Native.public_send(push_function, *arguments)
+      run_pushed_scope(kind, pop_function, *pop_arguments, &block)
+    end
+
+    def run_pushed_scope(kind, pop_function, *pop_arguments, &block)
+      unless block
+        scope_stack << [kind, pop_function, pop_arguments]
+        return true
+      end
+
+      block.call
+    ensure
+      Native.public_send(pop_function, *pop_arguments) if block
+    end
+
+    def run_scope(kind, end_function, opened, always_close:, &block)
+      should_close = always_close || opened
+      unless block
+        scope_stack << [kind, end_function] if should_close
+        return opened
+      end
+
+      return false unless should_close
+
+      begin
+        opened ? block.call : false
+      ensure
+        Native.public_send(end_function)
+      end
+    end
+
+    def close_manual_scope(expected_kind)
+      guard_context!
+      scope = scope_stack.pop
+      unless scope&.fetch(0) == expected_kind
+        scope_stack << scope if scope
+        actual = scope&.fetch(0) || "none"
+        raise StackError, "expected #{expected_kind} scope, found #{actual}"
+      end
+
+      Native.public_send(scope.fetch(1), *Array(scope[2]))
+    end
+
+    def scope_stack
+      Thread.current.thread_variable_get(:imgui_ruby_scope_stack) || begin
+        stack = []
+        Thread.current.thread_variable_set(:imgui_ruby_scope_stack, stack)
+        stack
+      end
+    end
+
+    def boolean_pointer(value)
+      return nil if value.nil?
+      if value.is_a?(Value)
+        require_value_type!(value, :bool)
+        return value.pointer
+      end
+
+      pointer = MemoryPool.pointer(:bool)
+      pointer.put(:bool, 0, !!value)
+      pointer
+    end
+
+    def push_id(value)
+      case value
+      when String then Native.igPushID_Str(value)
+      when Integer then Native.igPushID_Int(value)
+      when FFI::Pointer then Native.igPushID_Ptr(value)
+      else Native.igPushID_Ptr(FFI::Pointer.new(value.object_id))
+      end
+    end
+  end
+end

data/lib/imgui/easy_loop.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ImGui
+  class << self
+    def frame(platform: Backends::Glfw, renderer: Backends::OpenGL3)
+      renderer.new_frame
+      platform.new_frame
+      new_frame
+      result = yield
+      render
+      renderer.render_draw_data(draw_data)
+      result
+    end
+
+    def easy_loop(window, platform: Backends::Glfw, renderer: Backends::OpenGL3)
+      raise ArgumentError, "a UI block is required" unless block_given?
+
+      until window.should_close?
+        ::GLFW.poll_events if defined?(::GLFW) && ::GLFW.respond_to?(:poll_events)
+        frame(platform: platform, renderer: renderer) { yield }
+        window.swap_buffers if window.respond_to?(:swap_buffers)
+      end
+    end
+  end
+end

data/lib/imgui/errors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ImGui
+  class Error < StandardError; end
+  class LibraryLoadError < Error; end
+  class MissingSymbolError < Error; end
+  class BackendUnavailableError < Error; end
+  class NoContextError < Error; end
+  class ThreadError < Error; end
+  class StackError < Error; end
+end

data/lib/imgui/fonts.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ImGui
+  class Fonts
+    attr_reader :pointer
+
+    def initialize(pointer)
+      @pointer = pointer
+    end
+
+    def add_font_default
+      ImGui.__send__(:guard_context!)
+      Native.ImFontAtlas_AddFontDefault(pointer, nil)
+    end
+
+    def add_font(path, size:, glyph_ranges: nil, merge: false)
+      ImGui.__send__(:guard_context!)
+      config = merge ? Native.ImFontConfig_ImFontConfig : nil
+      Native::ImFontConfig.new(config)[:MergeMode] = true if config
+      Native.ImFontAtlas_AddFontFromFileTTF(
+        pointer,
+        File.expand_path(path),
+        Float(size),
+        config,
+        glyph_ranges
+      )
+    ensure
+      Native.ImFontConfig_destroy(config) if config
+    end
+
+    def add_font_jp(path, size:, merge: false)
+      ranges = Native.ImFontAtlas_GetGlyphRangesJapanese(pointer)
+      add_font(path, size: size, glyph_ranges: ranges, merge: merge)
+    end
+
+    def build
+      ImGui.__send__(:guard_context!)
+      Native.ImFontAtlas_Build(pointer)
+    end
+
+    def clear
+      ImGui.__send__(:guard_context!)
+      Native.ImFontAtlas_Clear(pointer)
+    end
+  end
+end

data/lib/imgui/io.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module ImGui
+  class IO
+    BOOLEAN_FIELDS = %i[
+      want_capture_mouse want_capture_keyboard want_text_input want_set_mouse_pos
+      want_save_ini_settings nav_active nav_visible mouse_draw_cursor
+    ].freeze
+    INTEGER_FIELDS = %i[config_flags backend_flags metrics_render_vertices metrics_render_indices].freeze
+    FLOAT_FIELDS = %i[delta_time framerate font_global_scale].freeze
+
+    attr_reader :pointer
+
+    def initialize(pointer)
+      @pointer = pointer
+      @native = Native::ImGuiIO.new(pointer)
+      @retained_strings = {}
+    end
+
+    INTEGER_FIELDS.each do |field|
+      native_field = field.to_s.split("_").map(&:capitalize).join.to_sym
+      define_method(field) { @native[native_field] }
+      define_method("#{field}=") { |value| @native[native_field] = Integer(value) }
+    end
+
+    FLOAT_FIELDS.each do |field|
+      native_field = field.to_s.split("_").map(&:capitalize).join.to_sym
+      define_method(field) { @native[native_field] }
+      define_method("#{field}=") { |value| @native[native_field] = Float(value) }
+    end
+
+    BOOLEAN_FIELDS.each do |field|
+      native_field = field.to_s.split("_").map(&:capitalize).join.to_sym
+      define_method(field) { @native[native_field] }
+      define_method("#{field}=") { |value| @native[native_field] = !!value }
+    end
+
+    def display_size
+      StructValue.to_a(@native[:DisplaySize], 2)
+    end
+
+    def display_size=(value)
+      @native[:DisplaySize] = StructValue.vec2(value)
+    end
+
+    def display_framebuffer_scale
+      StructValue.to_a(@native[:DisplayFramebufferScale], 2)
+    end
+
+    def display_framebuffer_scale=(value)
+      @native[:DisplayFramebufferScale] = StructValue.vec2(value)
+    end
+
+    def fonts
+      @fonts ||= Fonts.new(@native[:Fonts])
+    end
+
+    def ini_filename
+      pointer = @native[:IniFilename]
+      pointer.null? ? nil : pointer.read_string
+    end
+
+    def ini_filename=(filename)
+      set_retained_string(:IniFilename, filename)
+    end
+
+    def log_filename
+      pointer = @native[:LogFilename]
+      pointer.null? ? nil : pointer.read_string
+    end
+
+    def log_filename=(filename)
+      set_retained_string(:LogFilename, filename)
+    end
+
+    private
+
+    def set_retained_string(field, value)
+      if value.nil?
+        @retained_strings.delete(field)
+        @native[field] = nil
+        return nil
+      end
+
+      memory = FFI::MemoryPointer.from_string(String(value).encode(Encoding::UTF_8))
+      @retained_strings[field] = memory
+      @native[field] = memory
+      value
+    end
+  end
+end