glfw-ruby 0.1.0

data/lib/glfw/high_level/window.rb

@@ -0,0 +1,435 @@
+# frozen_string_literal: true
+
+module GLFW
+  class Window
+    HINT_MAP = {
+      resizable: GLFW_RESIZABLE,
+      visible: GLFW_VISIBLE,
+      decorated: GLFW_DECORATED,
+      focused: GLFW_FOCUSED,
+      auto_iconify: GLFW_AUTO_ICONIFY,
+      floating: GLFW_FLOATING,
+      maximized: GLFW_MAXIMIZED,
+      center_cursor: GLFW_CENTER_CURSOR,
+      transparent_framebuffer: GLFW_TRANSPARENT_FRAMEBUFFER,
+      focus_on_show: GLFW_FOCUS_ON_SHOW,
+      scale_to_monitor: GLFW_SCALE_TO_MONITOR,
+      mouse_passthrough: GLFW_MOUSE_PASSTHROUGH,
+      samples: GLFW_SAMPLES,
+      refresh_rate: GLFW_REFRESH_RATE,
+      stereo: GLFW_STEREO,
+      srgb_capable: GLFW_SRGB_CAPABLE,
+      doublebuffer: GLFW_DOUBLEBUFFER,
+      client_api: GLFW_CLIENT_API,
+      context_version_major: GLFW_CONTEXT_VERSION_MAJOR,
+      context_version_minor: GLFW_CONTEXT_VERSION_MINOR,
+      context_robustness: GLFW_CONTEXT_ROBUSTNESS,
+      opengl_forward_compat: GLFW_OPENGL_FORWARD_COMPAT,
+      opengl_debug_context: GLFW_OPENGL_DEBUG_CONTEXT,
+      context_release_behavior: GLFW_CONTEXT_RELEASE_BEHAVIOR,
+      context_no_error: GLFW_CONTEXT_NO_ERROR,
+      context_creation_api: GLFW_CONTEXT_CREATION_API,
+      red_bits: GLFW_RED_BITS,
+      green_bits: GLFW_GREEN_BITS,
+      blue_bits: GLFW_BLUE_BITS,
+      alpha_bits: GLFW_ALPHA_BITS,
+      depth_bits: GLFW_DEPTH_BITS,
+      stencil_bits: GLFW_STENCIL_BITS,
+      opengl_profile: GLFW_OPENGL_PROFILE
+    }.freeze
+
+    PROFILE_MAP = {
+      any: GLFW_OPENGL_ANY_PROFILE,
+      core: GLFW_OPENGL_CORE_PROFILE,
+      compat: GLFW_OPENGL_COMPAT_PROFILE
+    }.freeze
+
+    attr_reader :handle
+
+    def initialize(width, height, title, monitor: nil, share: nil, **hints)
+      API.glfwDefaultWindowHints
+
+      hints.each do |key, value|
+        hint_const = HINT_MAP[key]
+        raise ArgumentError, "Unknown hint: #{key}" unless hint_const
+
+        if key == :opengl_profile && value.is_a?(Symbol)
+          value = PROFILE_MAP[value] || raise(ArgumentError, "Unknown profile: #{value}")
+        elsif value == true
+          value = GLFW_TRUE
+        elsif value == false
+          value = GLFW_FALSE
+        end
+
+        API.glfwWindowHint(hint_const, value)
+      end
+
+      monitor_handle = monitor&.handle
+      share_handle = share&.handle
+
+      @handle = API.glfwCreateWindow(width, height, title, monitor_handle, share_handle)
+      raise GLFW::Error, "Failed to create GLFW window" if @handle.null?
+
+      @title = title
+      @callbacks = {}
+      GLFW.register_window(self)
+    end
+
+    def destroy
+      GLFW.unregister_callbacks(@handle)
+      GLFW.unregister_window(self)
+      API.glfwDestroyWindow(@handle)
+      @handle = nil
+    end
+
+    def title
+      if GLFW.version_at_least?(3, 4)
+        API.glfwGetWindowTitle(@handle)
+      else
+        @title
+      end
+    end
+
+    def title=(t)
+      @title = t
+      API.glfwSetWindowTitle(@handle, t)
+    end
+
+    def size
+      w = FFI::MemoryPointer.new(:int)
+      h = FFI::MemoryPointer.new(:int)
+      API.glfwGetWindowSize(@handle, w, h)
+      [w.read_int, h.read_int]
+    end
+
+    def size=(wh)
+      API.glfwSetWindowSize(@handle, wh[0], wh[1])
+    end
+
+    def position
+      x = FFI::MemoryPointer.new(:int)
+      y = FFI::MemoryPointer.new(:int)
+      API.glfwGetWindowPos(@handle, x, y)
+      [x.read_int, y.read_int]
+    end
+
+    def position=(xy)
+      API.glfwSetWindowPos(@handle, xy[0], xy[1])
+    end
+
+    def framebuffer_size
+      w = FFI::MemoryPointer.new(:int)
+      h = FFI::MemoryPointer.new(:int)
+      API.glfwGetFramebufferSize(@handle, w, h)
+      [w.read_int, h.read_int]
+    end
+
+    def content_scale
+      x = FFI::MemoryPointer.new(:float)
+      y = FFI::MemoryPointer.new(:float)
+      API.glfwGetWindowContentScale(@handle, x, y)
+      [x.read_float, y.read_float]
+    end
+
+    def frame_size
+      l = FFI::MemoryPointer.new(:int)
+      t = FFI::MemoryPointer.new(:int)
+      r = FFI::MemoryPointer.new(:int)
+      b = FFI::MemoryPointer.new(:int)
+      API.glfwGetWindowFrameSize(@handle, l, t, r, b)
+      { left: l.read_int, top: t.read_int, right: r.read_int, bottom: b.read_int }
+    end
+
+    def opacity
+      API.glfwGetWindowOpacity(@handle)
+    end
+
+    def opacity=(val)
+      API.glfwSetWindowOpacity(@handle, val.to_f)
+    end
+
+    def should_close?
+      API.glfwWindowShouldClose(@handle) == GLFW_TRUE
+    end
+
+    def should_close=(val)
+      API.glfwSetWindowShouldClose(@handle, val ? GLFW_TRUE : GLFW_FALSE)
+    end
+
+    def focused?
+      API.glfwGetWindowAttrib(@handle, GLFW_FOCUSED) == GLFW_TRUE
+    end
+
+    def iconified?
+      API.glfwGetWindowAttrib(@handle, GLFW_ICONIFIED) == GLFW_TRUE
+    end
+
+    def maximized?
+      API.glfwGetWindowAttrib(@handle, GLFW_MAXIMIZED) == GLFW_TRUE
+    end
+
+    def visible?
+      API.glfwGetWindowAttrib(@handle, GLFW_VISIBLE) == GLFW_TRUE
+    end
+
+    def hovered?
+      API.glfwGetWindowAttrib(@handle, GLFW_HOVERED) == GLFW_TRUE
+    end
+
+    def transparent_framebuffer?
+      API.glfwGetWindowAttrib(@handle, GLFW_TRANSPARENT_FRAMEBUFFER) == GLFW_TRUE
+    end
+
+    def iconify
+      API.glfwIconifyWindow(@handle)
+    end
+
+    def restore
+      API.glfwRestoreWindow(@handle)
+    end
+
+    def maximize
+      API.glfwMaximizeWindow(@handle)
+    end
+
+    def show
+      API.glfwShowWindow(@handle)
+    end
+
+    def hide
+      API.glfwHideWindow(@handle)
+    end
+
+    def focus
+      API.glfwFocusWindow(@handle)
+    end
+
+    def request_attention
+      API.glfwRequestWindowAttention(@handle)
+    end
+
+    def swap_buffers
+      API.glfwSwapBuffers(@handle)
+    end
+
+    def make_context_current
+      API.glfwMakeContextCurrent(@handle)
+    end
+
+    def set_size_limits(min_w, min_h, max_w, max_h)
+      API.glfwSetWindowSizeLimits(@handle, min_w, min_h, max_w, max_h)
+    end
+
+    def set_aspect_ratio(numer, denom)
+      API.glfwSetWindowAspectRatio(@handle, numer, denom)
+    end
+
+    def monitor
+      ptr = API.glfwGetWindowMonitor(@handle)
+      return nil if ptr.null?
+
+      Monitor.new(ptr)
+    end
+
+    def set_fullscreen(monitor, width, height, refresh_rate: GLFW_DONT_CARE)
+      API.glfwSetWindowMonitor(@handle, monitor.handle, 0, 0, width, height, refresh_rate)
+    end
+
+    def set_windowed(x, y, width, height)
+      API.glfwSetWindowMonitor(@handle, nil, x, y, width, height, GLFW_DONT_CARE)
+    end
+
+    def get_attrib(attrib)
+      API.glfwGetWindowAttrib(@handle, attrib)
+    end
+
+    def set_attrib(attrib, value)
+      API.glfwSetWindowAttrib(@handle, attrib, value)
+    end
+
+    def decorated?
+      get_attrib(GLFW_DECORATED) == GLFW_TRUE
+    end
+
+    def resizable?
+      get_attrib(GLFW_RESIZABLE) == GLFW_TRUE
+    end
+
+    def floating?
+      get_attrib(GLFW_FLOATING) == GLFW_TRUE
+    end
+
+    def auto_iconify?
+      get_attrib(GLFW_AUTO_ICONIFY) == GLFW_TRUE
+    end
+
+    def focus_on_show?
+      get_attrib(GLFW_FOCUS_ON_SHOW) == GLFW_TRUE
+    end
+
+    def mouse_passthrough?
+      get_attrib(GLFW_MOUSE_PASSTHROUGH) == GLFW_TRUE
+    end
+
+    def set_icon(images)
+      count = images.size
+      structs_ptr = FFI::MemoryPointer.new(API::GLFWimage, count)
+      images.each_with_index do |img, i|
+        s = img.to_struct
+        structs_ptr.put_bytes(i * API::GLFWimage.size, s.pointer.read_bytes(API::GLFWimage.size))
+      end
+      API.glfwSetWindowIcon(@handle, count, structs_ptr)
+    end
+
+    def clear_icon
+      API.glfwSetWindowIcon(@handle, 0, nil)
+    end
+
+    def cursor=(cursor)
+      API.glfwSetCursor(@handle, cursor&.handle)
+    end
+
+    def cursor_pos
+      x = FFI::MemoryPointer.new(:double)
+      y = FFI::MemoryPointer.new(:double)
+      API.glfwGetCursorPos(@handle, x, y)
+      [x.read_double, y.read_double]
+    end
+
+    def cursor_pos=(xy)
+      API.glfwSetCursorPos(@handle, xy[0].to_f, xy[1].to_f)
+    end
+
+    def key(key_code)
+      val = API.glfwGetKey(@handle, key_code)
+      ACTION_MAP[val] || val
+    end
+
+    def mouse_button(button)
+      val = API.glfwGetMouseButton(@handle, button)
+      ACTION_MAP[val] || val
+    end
+
+    def input_mode(mode)
+      API.glfwGetInputMode(@handle, mode)
+    end
+
+    def set_input_mode(mode, value)
+      API.glfwSetInputMode(@handle, mode, value)
+    end
+
+    # Callbacks
+    def on_key(&block)
+      cb = proc { |_win_ptr, key, scancode, action, mods|
+        block.call(self, key, scancode, ACTION_MAP[action] || action, mods)
+      }
+      register_and_set(:key, cb) { |c| API.glfwSetKeyCallback(@handle, c) }
+    end
+
+    def on_char(&block)
+      cb = proc { |_win_ptr, codepoint|
+        block.call(self, codepoint)
+      }
+      register_and_set(:char, cb) { |c| API.glfwSetCharCallback(@handle, c) }
+    end
+
+    def on_mouse_button(&block)
+      cb = proc { |_win_ptr, button, action, mods|
+        block.call(self, button, ACTION_MAP[action] || action, mods)
+      }
+      register_and_set(:mouse_button, cb) { |c| API.glfwSetMouseButtonCallback(@handle, c) }
+    end
+
+    def on_cursor_pos(&block)
+      cb = proc { |_win_ptr, x, y|
+        block.call(self, x, y)
+      }
+      register_and_set(:cursor_pos, cb) { |c| API.glfwSetCursorPosCallback(@handle, c) }
+    end
+
+    def on_cursor_enter(&block)
+      cb = proc { |_win_ptr, entered|
+        block.call(self, entered == GLFW_TRUE)
+      }
+      register_and_set(:cursor_enter, cb) { |c| API.glfwSetCursorEnterCallback(@handle, c) }
+    end
+
+    def on_scroll(&block)
+      cb = proc { |_win_ptr, xoffset, yoffset|
+        block.call(self, xoffset, yoffset)
+      }
+      register_and_set(:scroll, cb) { |c| API.glfwSetScrollCallback(@handle, c) }
+    end
+
+    def on_drop(&block)
+      cb = proc { |_win_ptr, count, paths_ptr|
+        paths = count.times.map { |i| paths_ptr.get_pointer(i * FFI::Pointer.size).read_string }
+        block.call(self, paths)
+      }
+      register_and_set(:drop, cb) { |c| API.glfwSetDropCallback(@handle, c) }
+    end
+
+    def on_resize(&block)
+      cb = proc { |_win_ptr, width, height|
+        block.call(self, width, height)
+      }
+      register_and_set(:resize, cb) { |c| API.glfwSetWindowSizeCallback(@handle, c) }
+    end
+
+    def on_close(&block)
+      cb = proc { |_win_ptr|
+        block.call(self)
+      }
+      register_and_set(:close, cb) { |c| API.glfwSetWindowCloseCallback(@handle, c) }
+    end
+
+    def on_refresh(&block)
+      cb = proc { |_win_ptr|
+        block.call(self)
+      }
+      register_and_set(:refresh, cb) { |c| API.glfwSetWindowRefreshCallback(@handle, c) }
+    end
+
+    def on_focus(&block)
+      cb = proc { |_win_ptr, focused|
+        block.call(self, focused == GLFW_TRUE)
+      }
+      register_and_set(:focus, cb) { |c| API.glfwSetWindowFocusCallback(@handle, c) }
+    end
+
+    def on_iconify(&block)
+      cb = proc { |_win_ptr, iconified|
+        block.call(self, iconified == GLFW_TRUE)
+      }
+      register_and_set(:iconify, cb) { |c| API.glfwSetWindowIconifyCallback(@handle, c) }
+    end
+
+    def on_maximize(&block)
+      cb = proc { |_win_ptr, maximized|
+        block.call(self, maximized == GLFW_TRUE)
+      }
+      register_and_set(:maximize, cb) { |c| API.glfwSetWindowMaximizeCallback(@handle, c) }
+    end
+
+    def on_framebuffer_resize(&block)
+      cb = proc { |_win_ptr, width, height|
+        block.call(self, width, height)
+      }
+      register_and_set(:framebuffer_resize, cb) { |c| API.glfwSetFramebufferSizeCallback(@handle, c) }
+    end
+
+    def on_content_scale(&block)
+      cb = proc { |_win_ptr, xscale, yscale|
+        block.call(self, xscale, yscale)
+      }
+      register_and_set(:content_scale, cb) { |c| API.glfwSetWindowContentScaleCallback(@handle, c) }
+    end
+
+    private
+
+    def register_and_set(type, cb)
+      GLFW.register_callback(type, @handle, cb)
+      yield cb
+    end
+  end
+end

data/lib/glfw/loader.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module GLFW
+  module Loader
+    SEARCH_PATHS = {
+      linux: %w[libglfw.so.3 libglfw.so],
+      darwin: %w[libglfw.3.dylib libglfw.dylib /opt/homebrew/lib/libglfw.3.dylib
+                 /usr/local/lib/libglfw.3.dylib],
+      windows: %w[glfw3.dll glfw3_64.dll]
+    }.freeze
+
+    def self.load!
+      platform = detect_platform
+      paths = SEARCH_PATHS[platform].dup
+
+      if ENV["GLFW_LIB_PATH"]
+        paths.unshift(ENV["GLFW_LIB_PATH"])
+      end
+
+      lib_path = paths.find { |p| loadable?(p) }
+      raise GLFW::LibraryNotFoundError, <<~MSG unless lib_path
+        GLFW shared library not found.
+        Searched: #{paths.join(", ")}
+        Set GLFW_LIB_PATH environment variable to specify the library location.
+      MSG
+
+      lib_path
+    end
+
+    def self.detect_platform
+      case RbConfig::CONFIG["host_os"]
+      when /linux/i then :linux
+      when /darwin/i then :darwin
+      when /mswin|mingw|cygwin/i then :windows
+      else raise GLFW::Error, "Unsupported platform: #{RbConfig::CONFIG["host_os"]}"
+      end
+    end
+
+    def self.loadable?(path)
+      FFI::DynamicLibrary.open(path, FFI::DynamicLibrary::RTLD_LAZY)
+      true
+    rescue LoadError
+      false
+    end
+  end
+end

data/lib/glfw/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module GLFW
+  VERSION = "0.1.0"
+end

data/lib/glfw.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+require_relative "glfw/version"
+require_relative "glfw/errors"
+require_relative "glfw/api/constants"
+require_relative "glfw/loader"
+require_relative "glfw/api/types"
+
+module GLFW
+  module API
+    ffi_lib Loader.load!
+  end
+end
+
+require_relative "glfw/api/init"
+require_relative "glfw/api/window"
+require_relative "glfw/api/monitor"
+require_relative "glfw/api/input"
+require_relative "glfw/api/context"
+require_relative "glfw/api/vulkan"
+require_relative "glfw/api/v34"
+
+GLFW::API.bind_v34_functions!
+
+require_relative "glfw/high_level/video_mode"
+require_relative "glfw/high_level/gamma_ramp"
+require_relative "glfw/high_level/image"
+require_relative "glfw/high_level/gamepad"
+require_relative "glfw/high_level/cursor"
+require_relative "glfw/high_level/joystick"
+require_relative "glfw/high_level/monitor"
+require_relative "glfw/high_level/window"
+
+module GLFW
+  @callback_registry = {}
+  @window_map = {}
+  @user_error_callback = nil
+  @error_callback = nil
+
+  def self.init
+    result = API.glfwInit
+    raise InitError, "Failed to initialize GLFW" if result == GLFW_FALSE
+
+    @error_callback = proc { |code, desc|
+      if @user_error_callback
+        @user_error_callback.call(code, desc)
+      else
+        warn "[GLFW Error 0x#{code.to_s(16)}]: #{desc}"
+      end
+    }
+    API.glfwSetErrorCallback(@error_callback)
+    true
+  end
+
+  def self.terminate
+    @window_map.values.each do |win|
+      warn "[GLFW] Window '#{win.title}' was not destroyed before terminate"
+    end
+    @window_map.clear
+    @callback_registry.clear
+    API.glfwTerminate
+  end
+
+  def self.version
+    major = FFI::MemoryPointer.new(:int)
+    minor = FFI::MemoryPointer.new(:int)
+    rev = FFI::MemoryPointer.new(:int)
+    API.glfwGetVersion(major, minor, rev)
+    [major.read_int, minor.read_int, rev.read_int]
+  end
+
+  def self.version_at_least?(maj, min)
+    v = version
+    v[0] > maj || (v[0] == maj && v[1] >= min)
+  end
+
+  def self.poll_events
+    API.glfwPollEvents
+  end
+
+  def self.wait_events(timeout: nil)
+    if timeout
+      API.glfwWaitEventsTimeout(timeout.to_f)
+    else
+      API.glfwWaitEvents
+    end
+  end
+
+  def self.post_empty_event
+    API.glfwPostEmptyEvent
+  end
+
+  def self.time
+    API.glfwGetTime
+  end
+
+  def self.time=(t)
+    API.glfwSetTime(t.to_f)
+  end
+
+  def self.clipboard
+    API.glfwGetClipboardString(nil)
+  end
+
+  def self.clipboard=(text)
+    API.glfwSetClipboardString(nil, text)
+  end
+
+  def self.on_error(&block)
+    @user_error_callback = block
+  end
+
+  def self.platform
+    PLATFORM_MAP[API.glfwGetPlatform]
+  end
+
+  def self.platform_supported?(platform_id)
+    API.glfwPlatformSupported(platform_id) == GLFW_TRUE
+  end
+
+  def self.register_callback(type, handle, proc_obj)
+    key = handle ? [type, handle.address] : [type, nil]
+    @callback_registry[key] = proc_obj
+  end
+
+  def self.unregister_callbacks(handle)
+    @callback_registry.delete_if { |k, _| k[1] == handle.address }
+  end
+
+  def self.register_window(window)
+    @window_map[window.handle.address] = window
+  end
+
+  def self.unregister_window(window)
+    @window_map.delete(window.handle.address)
+  end
+
+  def self.window_for(handle)
+    @window_map[handle.address]
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: glfw-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+description: Pure Ruby FFI bindings for the GLFW library, providing both low-level
+  C API access and high-level Ruby OOP interface for OpenGL/Vulkan window, context,
+  and input management.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/01_minimal_window.rb
+- examples/02_input_callbacks.rb
+- examples/03_window_attributes.rb
+- examples/04_monitor_info.rb
+- examples/05_custom_cursor_and_icon.rb
+- examples/06_gamepad_inspector.rb
+- examples/07_glfw_34_features.rb
+- examples/example_runtime.rb
+- lib/glfw.rb
+- lib/glfw/api/constants.rb
+- lib/glfw/api/context.rb
+- lib/glfw/api/init.rb
+- lib/glfw/api/input.rb
+- lib/glfw/api/monitor.rb
+- lib/glfw/api/types.rb
+- lib/glfw/api/v34.rb
+- lib/glfw/api/vulkan.rb
+- lib/glfw/api/window.rb
+- lib/glfw/errors.rb
+- lib/glfw/high_level/cursor.rb
+- lib/glfw/high_level/gamepad.rb
+- lib/glfw/high_level/gamma_ramp.rb
+- lib/glfw/high_level/image.rb
+- lib/glfw/high_level/joystick.rb
+- lib/glfw/high_level/monitor.rb
+- lib/glfw/high_level/video_mode.rb
+- lib/glfw/high_level/window.rb
+- lib/glfw/loader.rb
+- lib/glfw/version.rb
+homepage: https://github.com/ydah/glfw-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ydah/glfw-ruby
+  source_code_uri: https://github.com/ydah/glfw-ruby
+  changelog_uri: https://github.com/ydah/glfw-ruby/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Complete Ruby FFI bindings for GLFW 3.3/3.4
+test_files: []