imgui 1.0.0

data/lib/imgui/api_support.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module ImGui
+  class << self
+    private
+
+    def guarded_native_call(function, *arguments)
+      guard_context!
+      Native.public_send(function, *arguments)
+    end
+
+    def define_generated_method(ruby_name, native_name, argument_types, defaults)
+      singleton_class.define_method(ruby_name) do |*arguments, **keywords|
+        if arguments.length > argument_types.length
+          raise ArgumentError, "wrong number of arguments (given #{arguments.length}, expected #{argument_types.length})"
+        end
+
+        values = argument_types.each_with_index.map do |(name, c_type), index|
+          value = if index < arguments.length
+                    arguments[index]
+                  elsif keywords.key?(name.to_sym)
+                    keywords.delete(name.to_sym)
+                  elsif defaults.key?(name)
+                    defaults.fetch(name)
+                  else
+                    raise ArgumentError, "missing argument: #{name}"
+                  end
+          convert_generated_argument(c_type, value)
+        end
+        raise ArgumentError, "unknown keywords: #{keywords.keys.join(", ")}" unless keywords.empty?
+
+        guarded_native_call(native_name, *values)
+      end
+    end
+
+    def convert_generated_argument(c_type, value)
+      type = c_type.gsub(/\bconst\b/, "").strip
+      return StructValue.vec2(value) if type == "ImVec2"
+      return StructValue.vec4(value) if type == "ImVec4"
+      return !!value if type == "bool"
+      return Float(value) if %w[float double].include?(type)
+      return Integer(value) if type.match?(/\A(?:unsigned )?(?:char|short|int|long|long long)\z/)
+      return value&.to_s if type == "char*"
+
+      value
+    end
+
+    def guard_context!
+      context = Native.igGetCurrentContext
+      raise NoContextError, "create an ImGui context before calling this method" if null_pointer?(context)
+
+      key = context_key(context)
+      context_threads[key] ||= Thread.current
+      check_context_thread!(context)
+      context
+    end
+
+    def check_context_thread!(context)
+      return unless thread_checks_enabled?
+
+      owner = context_threads[context_key(context)]
+      return unless owner && owner != Thread.current
+
+      raise ThreadError, "ImGui context belongs to thread #{owner.object_id}, not #{Thread.current.object_id}"
+    end
+
+    def null_pointer?(pointer)
+      pointer.nil? || pointer == 0 || pointer.respond_to?(:null?) && pointer.null?
+    end
+
+    def context_key(context)
+      context.respond_to?(:address) ? context.address : context.object_id
+    end
+
+    def context_threads
+      @context_threads ||= {}
+    end
+
+    def io_views
+      @io_views ||= {}
+    end
+
+    def style_views
+      @style_views ||= {}
+    end
+
+    def clear_context_views(context)
+      key = context_key(context)
+      io_views.delete(key)
+      style_views.delete(key)
+    end
+
+    def edit_scalar(function, label, value, type:, arguments:)
+      guard_context!
+      if value.is_a?(Value)
+        require_value_type!(value, type)
+        return Native.public_send(function, label, value.pointer, *arguments)
+      end
+
+      pointer = MemoryPool.pointer(type)
+      pointer.put(type, 0, coerce_scalar(type, value))
+      changed = Native.public_send(function, label, pointer, *arguments)
+      [changed, pointer.get(type, 0)]
+    end
+
+    def edit_vector(function, label, value, count:, arguments:)
+      guard_context!
+      expected_type = "vec#{count}".to_sym
+      if value.is_a?(Value)
+        require_value_type!(value, expected_type)
+        return Native.public_send(function, label, value.pointer, *arguments)
+      end
+
+      values = Array(value)
+      raise ArgumentError, "expected #{count} values" unless values.length == count
+
+      pointer = MemoryPool.pointer(:float, count)
+      pointer.write_array_of_float(values.map { |item| Float(item) })
+      changed = Native.public_send(function, label, pointer, *arguments)
+      [changed, pointer.read_array_of_float(count)]
+    end
+
+    def vector_result(function, *arguments, count: 2)
+      guard_context!
+      pointer = MemoryPool.pointer(:float, count)
+      Native.public_send(function, pointer, *arguments)
+      pointer.read_array_of_float(count)
+    end
+
+    def require_value_type!(value, expected)
+      return if value.type == expected
+
+      raise TypeError, "expected ImGui::Value.#{expected}, got #{value.type}"
+    end
+
+    def coerce_scalar(type, value)
+      case type
+      when :bool then !!value
+      when :int then Integer(value)
+      else Float(value)
+      end
+    end
+  end
+end

data/lib/imgui/backends/glfw.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module ImGui
+  module Backends
+    module Glfw
+      module_function
+
+      def init_for_opengl(window, install_callbacks: true)
+        prepare_runtime!
+        Backends.invoke(
+          "GLFW",
+          :ImGui_ImplGlfw_InitForOpenGL,
+          Backends.pointer(window),
+          !!install_callbacks
+        )
+      end
+
+      def init_for_vulkan(window, install_callbacks: true)
+        prepare_runtime!
+        Backends.invoke(
+          "GLFW",
+          :ImGui_ImplGlfw_InitForVulkan,
+          Backends.pointer(window),
+          !!install_callbacks
+        )
+      end
+
+      def init_for_other(window, install_callbacks: true)
+        prepare_runtime!
+        Backends.invoke(
+          "GLFW",
+          :ImGui_ImplGlfw_InitForOther,
+          Backends.pointer(window),
+          !!install_callbacks
+        )
+      end
+
+      def install_callbacks(window)
+        Backends.invoke("GLFW", :ImGui_ImplGlfw_InstallCallbacks, Backends.pointer(window))
+      end
+
+      def restore_callbacks(window)
+        Backends.invoke("GLFW", :ImGui_ImplGlfw_RestoreCallbacks, Backends.pointer(window))
+      end
+
+      def chain_callbacks_for_all_windows=(enabled)
+        Backends.invoke("GLFW", :ImGui_ImplGlfw_SetCallbacksChainForAllWindows, !!enabled)
+      end
+
+      def prepare_runtime!
+        candidates = [ENV["IMGUI_RUBY_GLFW_LIB"]]
+        candidates.concat(::GLFW::API.ffi_libraries.map(&:name)) if defined?(::GLFW::API)
+        candidates.concat(
+          if FFI::Platform.windows?
+            %w[glfw3.dll glfw3_64.dll]
+          elsif FFI::Platform.mac?
+            %w[libglfw.3.dylib libglfw.dylib /opt/homebrew/lib/libglfw.3.dylib /usr/local/lib/libglfw.3.dylib]
+          else
+            %w[libglfw.so.3 libglfw.so]
+          end
+        )
+        Backends.load_runtime_library("GLFW", candidates)
+      end
+      private_class_method :prepare_runtime!
+
+      def new_frame
+        Backends.invoke("GLFW", :ImGui_ImplGlfw_NewFrame)
+      end
+
+      def shutdown
+        Backends.invoke("GLFW", :ImGui_ImplGlfw_Shutdown)
+      end
+    end
+  end
+end

data/lib/imgui/backends/opengl3.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ImGui
+  module Backends
+    module OpenGL3
+      module_function
+
+      def init(glsl_version = nil)
+        Backends.invoke("OpenGL3", :ImGui_ImplOpenGL3_Init, glsl_version)
+      end
+
+      def new_frame
+        Backends.invoke("OpenGL3", :ImGui_ImplOpenGL3_NewFrame)
+      end
+
+      def render_draw_data(draw_data = ImGui.draw_data)
+        return if draw_data.nil?
+
+        pointer = draw_data.respond_to?(:pointer) ? draw_data.pointer : Backends.pointer(draw_data)
+        Backends.invoke("OpenGL3", :ImGui_ImplOpenGL3_RenderDrawData, pointer)
+      end
+
+      def create_device_objects
+        Backends.invoke("OpenGL3", :ImGui_ImplOpenGL3_CreateDeviceObjects)
+      end
+
+      def destroy_device_objects
+        Backends.invoke("OpenGL3", :ImGui_ImplOpenGL3_DestroyDeviceObjects)
+      end
+
+      def create_fonts_texture
+        Backends.invoke("OpenGL3", :ImGui_ImplOpenGL3_CreateFontsTexture)
+      end
+
+      def destroy_fonts_texture
+        Backends.invoke("OpenGL3", :ImGui_ImplOpenGL3_DestroyFontsTexture)
+      end
+
+      def shutdown
+        Backends.invoke("OpenGL3", :ImGui_ImplOpenGL3_Shutdown)
+      end
+    end
+  end
+end

data/lib/imgui/backends/sdl3.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module ImGui
+  module Backends
+    module SDL3
+      module GamepadMode
+        AutoFirst = 0
+        AutoAll = 1
+        Manual = 2
+      end
+
+      module_function
+
+      def init_for_opengl(window, context)
+        prepare_runtime!
+        Backends.invoke(
+          "SDL3",
+          :ImGui_ImplSDL3_InitForOpenGL,
+          Backends.pointer(window),
+          Backends.pointer(context)
+        )
+      end
+
+      def init_for_other(window)
+        prepare_runtime!
+        Backends.invoke("SDL3", :ImGui_ImplSDL3_InitForOther, Backends.pointer(window))
+      end
+
+      def init_for_vulkan(window)
+        prepare_runtime!
+        Backends.invoke("SDL3", :ImGui_ImplSDL3_InitForVulkan, Backends.pointer(window))
+      end
+
+      def init_for_d3d(window)
+        prepare_runtime!
+        Backends.invoke("SDL3", :ImGui_ImplSDL3_InitForD3D, Backends.pointer(window))
+      end
+
+      def init_for_metal(window)
+        prepare_runtime!
+        Backends.invoke("SDL3", :ImGui_ImplSDL3_InitForMetal, Backends.pointer(window))
+      end
+
+      def init_for_sdl_renderer(window, renderer)
+        prepare_runtime!
+        Backends.invoke(
+          "SDL3",
+          :ImGui_ImplSDL3_InitForSDLRenderer,
+          Backends.pointer(window),
+          Backends.pointer(renderer)
+        )
+      end
+
+      def init_for_sdl_gpu(window)
+        prepare_runtime!
+        Backends.invoke("SDL3", :ImGui_ImplSDL3_InitForSDLGPU, Backends.pointer(window))
+      end
+
+      def process_event(event)
+        Backends.invoke("SDL3", :ImGui_ImplSDL3_ProcessEvent, Backends.pointer(event))
+      end
+
+      def new_frame
+        Backends.invoke("SDL3", :ImGui_ImplSDL3_NewFrame)
+      end
+
+      def gamepad_mode=(mode)
+        set_gamepad_mode(mode)
+      end
+
+      def set_gamepad_mode(mode, gamepads: nil)
+        native_mode = normalize_gamepad_mode(mode)
+        pointers = Array(gamepads).map { |gamepad| Backends.pointer(gamepad) }
+        if native_mode == GamepadMode::Manual
+          @manual_gamepads = if pointers.empty?
+                               FFI::Pointer::NULL
+                             else
+                               FFI::MemoryPointer.new(:pointer, pointers.length).tap do |memory|
+                                 memory.write_array_of_pointer(pointers)
+                               end
+                             end
+          count = pointers.length
+        else
+          @manual_gamepads = nil
+          count = -1
+        end
+
+        Backends.invoke(
+          "SDL3",
+          :ImGui_ImplSDL3_SetGamepadMode,
+          native_mode,
+          @manual_gamepads || FFI::Pointer::NULL,
+          count
+        )
+      end
+
+      def shutdown
+        Backends.invoke("SDL3", :ImGui_ImplSDL3_Shutdown)
+      ensure
+        @manual_gamepads = nil
+      end
+
+      def normalize_gamepad_mode(mode)
+        return Integer(mode) unless mode.is_a?(Symbol) || mode.is_a?(String)
+
+        {
+          auto_first: GamepadMode::AutoFirst,
+          auto_all: GamepadMode::AutoAll,
+          manual: GamepadMode::Manual
+        }.fetch(mode.to_sym) do
+          raise ArgumentError, "unknown SDL3 gamepad mode: #{mode.inspect}"
+        end
+      end
+      private_class_method :normalize_gamepad_mode
+
+      def prepare_runtime!
+        candidates = [ENV["IMGUI_RUBY_SDL3_LIB"]]
+        candidates.concat(::SDL3::Raw.ffi_libraries.map(&:name)) if defined?(::SDL3::Raw)
+        candidates.concat(
+          if FFI::Platform.windows?
+            %w[SDL3.dll]
+          elsif FFI::Platform.mac?
+            %w[libSDL3.dylib SDL3.framework/SDL3 /opt/homebrew/lib/libSDL3.dylib /usr/local/lib/libSDL3.dylib]
+          else
+            %w[libSDL3.so.0 libSDL3.so]
+          end
+        )
+        Backends.load_runtime_library("SDL3", candidates)
+      end
+      private_class_method :prepare_runtime!
+    end
+  end
+end

data/lib/imgui/backends/wgpu.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module ImGui
+  module Native
+    attach_function :imgui_ruby_wgpu_required_function_count, [], :size_t
+    attach_function :imgui_ruby_wgpu_required_function_name, [:size_t], :string
+    attach_function :imgui_ruby_wgpu_set_function, [:string, :pointer], :bool
+    attach_function :imgui_ruby_wgpu_bridge_ready, [], :bool
+    attach_function :imgui_ruby_wgpu_bridge_error, [], :string
+    attach_function :imgui_ruby_wgpu_init, [:pointer, :int, :int, :int, :uint, :uint, :bool], :bool
+    attach_function :imgui_ruby_wgpu_shutdown, [], :void
+    attach_function :imgui_ruby_wgpu_new_frame, [], :void
+    attach_function :imgui_ruby_wgpu_render_draw_data, [:pointer, :pointer], :void
+    attach_function :imgui_ruby_wgpu_render_draw_data_to_view, [:pointer, :pointer, :pointer], :bool
+  end
+
+  module Backends
+    module WGPU
+      UNDEFINED_TEXTURE_FORMAT = 0
+      DEFAULT_SAMPLE_MASK = 0xffff_ffff
+
+      module_function
+
+      def init(
+        device:,
+        queue: nil,
+        render_target_format:,
+        depth_format: nil,
+        frames_in_flight: 3,
+        sample_count: 1,
+        sample_mask: DEFAULT_SAMPLE_MASK,
+        alpha_to_coverage: false,
+        function_table: nil,
+        library_path: nil
+      )
+        validate_init_options!(frames_in_flight, sample_count)
+        source = resolve_function_source(device, function_table, library_path)
+        configure_function_table!(source)
+
+        # The official backend obtains the default queue from the device. Accepting
+        # queue keeps the stagecraft integration signature stable and validates it
+        # when supplied, without retaining an unnecessary second queue reference.
+        Backends.pointer(queue) if queue
+        Backends.invoke(
+          "WGPU",
+          :imgui_ruby_wgpu_init,
+          Backends.pointer(device),
+          Integer(frames_in_flight),
+          Integer(render_target_format),
+          depth_format.nil? ? UNDEFINED_TEXTURE_FORMAT : Integer(depth_format),
+          Integer(sample_count),
+          Integer(sample_mask),
+          !!alpha_to_coverage
+        )
+      end
+
+      def new_frame
+        Backends.invoke("WGPU", :imgui_ruby_wgpu_new_frame)
+      end
+
+      def render_draw_data(draw_data, encoder, target_view = nil)
+        return if draw_data.nil?
+
+        data_pointer = draw_data.respond_to?(:pointer) ? draw_data.pointer : Backends.pointer(draw_data)
+        encoder_pointer = Backends.pointer(encoder)
+        return Backends.invoke(
+          "WGPU",
+          :imgui_ruby_wgpu_render_draw_data,
+          data_pointer,
+          encoder_pointer
+        ) unless target_view
+
+        Backends.invoke(
+          "WGPU",
+          :imgui_ruby_wgpu_render_draw_data_to_view,
+          data_pointer,
+          encoder_pointer,
+          Backends.pointer(target_view)
+        )
+      end
+
+      def shutdown
+        Backends.invoke("WGPU", :imgui_ruby_wgpu_shutdown)
+      end
+
+      def available?
+        Native.load!
+        Native.imgui_ruby_wgpu_bridge_error
+        true
+      rescue LibraryLoadError, MissingSymbolError
+        false
+      end
+
+      def resolve_function_source(device, explicit, library_path)
+        return explicit if explicit
+
+        return device.function_table if device.respond_to?(:function_table)
+        return device.native_library if device.respond_to?(:native_library)
+
+        if library_path
+          library = FFI::DynamicLibrary.open(
+            File.expand_path(library_path),
+            FFI::DynamicLibrary::RTLD_LAZY | FFI::DynamicLibrary::RTLD_LOCAL
+          )
+          retained_libraries << library
+          return library
+        end
+
+        if defined?(::WGPU::Native) && ::WGPU::Native.respond_to?(:ffi_libraries)
+          library = ::WGPU::Native.ffi_libraries.find { |candidate| function_pointer(candidate, "wgpuDeviceCreateBuffer") }
+          return library if library
+        end
+
+        raise BackendUnavailableError, <<~MESSAGE.strip
+          WGPU needs a native function table. Load the wgpu/stagecraft runtime
+          first, pass function_table:, or pass library_path: to its native library.
+        MESSAGE
+      end
+      private_class_method :resolve_function_source
+
+      def configure_function_table!(source)
+        required_function_names.each do |name|
+          pointer = function_pointer(source, name)
+          raise BackendUnavailableError, "WebGPU function is unavailable: #{name}" unless pointer
+
+          configured = Backends.invoke("WGPU", :imgui_ruby_wgpu_set_function, name, pointer)
+          next if configured
+
+          raise BackendUnavailableError, "WGPU function-table bridge rejected #{name}"
+        end
+        return true if Backends.invoke("WGPU", :imgui_ruby_wgpu_bridge_ready)
+
+        raise BackendUnavailableError, "WGPU function-table bridge failed: #{Native.imgui_ruby_wgpu_bridge_error}"
+      end
+      private_class_method :configure_function_table!
+
+      def required_function_names
+        count = Backends.invoke("WGPU", :imgui_ruby_wgpu_required_function_count)
+        Array.new(count) do |index|
+          Backends.invoke("WGPU", :imgui_ruby_wgpu_required_function_name, index)
+        end
+      end
+      private_class_method :required_function_names
+
+      def function_pointer(source, name)
+        value = if source.respond_to?(:fetch)
+                  source.fetch(name) { source.fetch(name.to_sym, nil) }
+                elsif source.respond_to?(:find_function)
+                  source.find_function(name)
+                elsif source.respond_to?(:function_address)
+                  source.function_address(name)
+                elsif source.respond_to?(name)
+                  source.method(name)
+                end
+        return if value.nil?
+        return FFI::Pointer.new(value.address) if value.respond_to?(:address)
+
+        Backends.pointer(value)
+      rescue FFI::NotFoundError
+        nil
+      end
+      private_class_method :function_pointer
+
+      def retained_libraries
+        @retained_libraries ||= []
+      end
+      private_class_method :retained_libraries
+
+      def validate_init_options!(frames_in_flight, sample_count)
+        raise ArgumentError, "frames_in_flight must be positive" unless Integer(frames_in_flight).positive?
+        raise ArgumentError, "sample_count must be positive" unless Integer(sample_count).positive?
+      end
+      private_class_method :validate_init_options!
+    end
+  end
+end

data/lib/imgui/backends.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ImGui
+  module Native
+    attach_function :imgui_ruby_backend_load_library, %i[string string], :bool
+    attach_function :imgui_ruby_backend_library_ready, [:string], :bool
+    attach_function :imgui_ruby_backend_has_function, %i[string string], :bool
+    attach_function :imgui_ruby_backend_required_function_count, [:string], :size_t
+    attach_function :imgui_ruby_backend_required_function_name, %i[string size_t], :string
+    attach_function :imgui_ruby_backend_library_error, [], :string
+  end
+
+  module Backends
+    module_function
+
+    def pointer(value)
+      candidate = value.respond_to?(:handle) ? value.handle : value
+      candidate = candidate.to_ptr if candidate.respond_to?(:to_ptr)
+      return candidate if candidate.is_a?(FFI::Pointer)
+      return FFI::Pointer.new(candidate) if candidate.is_a?(Integer)
+
+      raise TypeError, "expected a native pointer or an object exposing #handle/#to_ptr"
+    end
+
+    def invoke(backend, function, *arguments)
+      ImGui.__send__(:guard_context!)
+      Native.public_send(function, *arguments)
+    rescue MissingSymbolError => error
+      raise BackendUnavailableError, "#{backend} backend is not included in the loaded native library: #{error.message}"
+    end
+
+    def load_runtime_library(backend, candidates)
+      ImGui.__send__(:guard_context!)
+      unless Native.imgui_ruby_backend_library_ready(backend)
+        Array(candidates).compact.uniq.each do |path|
+          break if Native.imgui_ruby_backend_load_library(backend, path.to_s)
+        end
+      end
+
+      unless Native.imgui_ruby_backend_library_ready(backend)
+        detail = Native.imgui_ruby_backend_library_error
+        raise BackendUnavailableError,
+              "unable to load the #{backend} runtime library#{detail.to_s.empty? ? "" : ": #{detail}"}"
+      end
+
+      count = Native.imgui_ruby_backend_required_function_count(backend)
+      missing = count.times.filter_map do |index|
+        name = Native.imgui_ruby_backend_required_function_name(backend, index)
+        name unless Native.imgui_ruby_backend_has_function(backend, name)
+      end
+      return true if missing.empty?
+
+      raise BackendUnavailableError,
+            "#{backend} runtime library is incompatible; missing: #{missing.join(", ")}"
+    rescue MissingSymbolError => error
+      raise BackendUnavailableError,
+            "#{backend} runtime loading is not included in the loaded native library: #{error.message}"
+    end
+  end
+end

data/lib/imgui/draw_data.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ImGui
+  class DrawData
+    attr_reader :pointer
+
+    def initialize(pointer)
+      @pointer = pointer
+      @native = Native::ImDrawData.new(pointer)
+    end
+
+    def valid?
+      @native[:Valid]
+    end
+
+    def command_lists_count
+      @native[:CmdListsCount]
+    end
+
+    def total_index_count
+      @native[:TotalIdxCount]
+    end
+
+    def total_vertex_count
+      @native[:TotalVtxCount]
+    end
+
+    alias total_idx_count total_index_count
+    alias total_vtx_count total_vertex_count
+
+    def display_pos
+      StructValue.to_a(@native[:DisplayPos], 2)
+    end
+
+    def display_size
+      StructValue.to_a(@native[:DisplaySize], 2)
+    end
+
+    def framebuffer_scale
+      StructValue.to_a(@native[:FramebufferScale], 2)
+    end
+  end
+end