imgui 1.0.0

data/generator/overrides.yml

@@ -0,0 +1,11 @@
+---
+skip:
+  - igText
+  - igTextColored
+  - ImGuiFreeType_GetBuilderForFreeType
+  - ImGuiFreeType_SetAllocatorFunctions
+rename:
+  igGetIO_Nil: igGetIO
+varargs_via_preformat:
+  - igSetTooltip
+  - igLabelText

data/generator/type_mapper.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module ImGuiRuby
+  module Generator
+    class TypeMapper
+      PRIMITIVES = {
+        "void" => ":void",
+        "bool" => ":bool",
+        "char" => ":char",
+        "signed char" => ":char",
+        "unsigned char" => ":uchar",
+        "short" => ":short",
+        "unsigned short" => ":ushort",
+        "int" => ":int",
+        "unsigned int" => ":uint",
+        "long" => ":long",
+        "unsigned long" => ":ulong",
+        "long long" => ":long_long",
+        "unsigned long long" => ":ulong_long",
+        "float" => ":float",
+        "double" => ":double",
+        "size_t" => ":size_t",
+        "ptrdiff_t" => ":ptrdiff_t"
+      }.freeze
+
+      def initialize(typedefs:, structs:, enum_types:, struct_references: {})
+        @typedefs = typedefs
+        @structs = structs
+        @enum_types = enum_types
+        @struct_references = struct_references
+      end
+
+      def ffi_type(c_type, member: nil)
+        type = normalize(c_type)
+        array_size = member&.fetch("size", nil) || array_size_from(type)
+        return ":pointer" if member.nil? && array_size
+
+        type = type.sub(/\s*\[[^\]]+\]\z/, "") if array_size
+        mapped = map_scalar(type, struct_member: !member.nil?)
+        return mapped unless array_size
+
+        "[#{mapped}, #{array_size}]"
+      end
+
+      def typedef_type(c_type)
+        type = normalize(c_type)
+        return ":pointer" if pointer?(type) || callback?(type) || type.include?("<")
+        return PRIMITIVES.fetch(type) if PRIMITIVES.key?(type)
+        return ":int" if enum_type?(type)
+
+        resolved = @typedefs[type]
+        return typedef_type(resolved) if resolved && resolved != c_type
+
+        ":pointer"
+      end
+
+      private
+
+      def map_scalar(type, struct_member: false)
+        return ":pointer" if struct_member && pointer?(type)
+        return ":string" if type.match?(/\Aconst\s+char\s*\*\z/)
+        return ":pointer" if pointer?(type) || callback?(type)
+
+        bare = type.sub(/\Aconst\s+/, "").strip
+        return PRIMITIVES.fetch(bare) if PRIMITIVES.key?(bare)
+        return ":int" if enum_type?(bare)
+        return "#{struct_reference(bare)}.by_value" if @structs.key?(bare)
+
+        template_base = bare.split("_").first
+        return "#{struct_reference(template_base)}.by_value" if @structs.key?(template_base)
+
+        resolved = @typedefs[bare]
+        return ":#{bare}" if resolved && callback?(resolved)
+        return typedef_type(resolved) if resolved
+
+        ":pointer"
+      end
+
+      def normalize(c_type)
+        c_type.to_s
+          .gsub(/\bvolatile\b/, "")
+          .gsub(/\bstruct\s+/, "")
+          .gsub(/\s+/, " ")
+          .strip
+          .sub(/;\z/, "")
+      end
+
+      def pointer?(type)
+        type.include?("*") || type.end_with?("&")
+      end
+
+      def callback?(type)
+        type.include?("(*)") || type.include?("(*")
+      end
+
+      def enum_type?(type)
+        @enum_types.include?(type) ||
+          type.match?(/\AImGui_Impl\w+_(?:Gamepad)?Mode\z/) ||
+          @typedefs[type] == "int" && type.match?(/Flags|ImGuiCol\z|ImGuiKey\z/)
+      end
+
+      def array_size_from(type)
+        match = type.match(/\[([^\]]+)\]\z/)
+        match && match[1]
+      end
+
+      def struct_reference(name)
+        @struct_references.fetch(name, name)
+      end
+    end
+  end
+end

data/generator/update_vendor.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+require_relative "native_dependency_snapshot"
+
+options = { latest: false, verify: false, checkout: nil }
+OptionParser.new do |parser|
+  parser.banner = "Usage: ruby generator/update_vendor.rb [--latest | --verify | --checkout SOURCE:DIR]"
+  parser.on("--latest", "Refresh snapshots from configured upstream branches") { options[:latest] = true }
+  parser.on("--verify", "Verify cached snapshots without network access") { options[:verify] = true }
+  parser.on("--checkout SOURCE:DIR", "Checkout a complete pinned upstream source tree") do |value|
+    options[:checkout] = value.split(":", 2)
+  end
+end.parse!
+
+selected_modes = [options[:latest], options[:verify], options[:checkout]].count { |value| value }
+abort "--latest, --verify, and --checkout cannot be combined" if selected_modes > 1
+abort "--checkout requires SOURCE:DIR" if options[:checkout]&.length == 1
+
+snapshot = ImGuiRuby::NativeDependencySnapshot.new
+if options[:checkout]
+  snapshot.checkout_source!(*options[:checkout])
+elsif options[:verify]
+  snapshot.verify!
+elsif options[:latest]
+  snapshot.refresh!(latest: true)
+else
+  snapshot.fetch!
+end

data/lib/imgui/api.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module ImGui
+  class << self
+    def create_context(shared_font_atlas = nil)
+      context = Native.igCreateContext(shared_font_atlas)
+      raise Error, "cimgui returned a null context" if null_pointer?(context)
+
+      context_threads[context_key(context)] = Thread.current
+      context
+    end
+
+    def destroy_context(context = nil)
+      context ||= Native.igGetCurrentContext
+      return if null_pointer?(context)
+
+      check_context_thread!(context)
+      Native.igDestroyContext(context)
+      context_threads.delete(context_key(context))
+      clear_context_views(context)
+      nil
+    end
+
+    def current_context
+      context = Native.igGetCurrentContext
+      null_pointer?(context) ? nil : context
+    end
+
+    def current_context=(context)
+      check_context_thread!(context) unless null_pointer?(context)
+      Native.igSetCurrentContext(context)
+      context
+    end
+
+    def new_frame
+      guarded_native_call(:igNewFrame)
+    end
+
+    def end_frame
+      guarded_native_call(:igEndFrame)
+    end
+
+    def render
+      guarded_native_call(:igRender)
+    end
+
+    def draw_data
+      guard_context!
+      pointer = Native.igGetDrawData
+      return if null_pointer?(pointer)
+
+      DrawData.new(pointer)
+    end
+
+    def io
+      context = guard_context!
+      key = context_key(context)
+      io_views[key] ||= IO.new(Native.igGetIO)
+    end
+
+    def style
+      context = guard_context!
+      key = context_key(context)
+      style_views[key] ||= Style.new(Native.igGetStyle)
+    end
+
+    def ini_filename=(filename)
+      io.ini_filename = filename
+    end
+
+    def unsafe_allow_threads!
+      @thread_checks_enabled = false
+    end
+
+    def enforce_thread_safety!
+      @thread_checks_enabled = true
+    end
+
+    def thread_checks_enabled?
+      @thread_checks_enabled != false
+    end
+
+    def version_string
+      Native.igGetVersion
+    end
+
+  end
+end