glfw-ruby 0.1.0

data/lib/glfw/api/types.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module GLFW
+  module API
+    extend FFI::Library
+
+    typedef :pointer, :GLFWwindow
+    typedef :pointer, :GLFWmonitor
+    typedef :pointer, :GLFWcursor
+    typedef :pointer, :GLFWglproc
+    typedef :pointer, :GLFWvkproc
+
+    callback :GLFWallocatefun, [:size_t, :pointer], :pointer
+    callback :GLFWreallocatefun, [:pointer, :size_t, :pointer], :pointer
+    callback :GLFWdeallocatefun, [:pointer, :pointer], :void
+
+    class GLFWvidmode < FFI::Struct
+      layout :width, :int,
+             :height, :int,
+             :redBits, :int,
+             :greenBits, :int,
+             :blueBits, :int,
+             :refreshRate, :int
+    end
+
+    class GLFWgammaramp < FFI::Struct
+      layout :red, :pointer,
+             :green, :pointer,
+             :blue, :pointer,
+             :size, :uint
+    end
+
+    class GLFWimage < FFI::Struct
+      layout :width, :int,
+             :height, :int,
+             :pixels, :pointer
+    end
+
+    class GLFWgamepadstate < FFI::Struct
+      layout :buttons, [:uchar, 15],
+             :axes, [:float, 6]
+    end
+
+    class GLFWallocator < FFI::Struct
+      layout :allocate, :GLFWallocatefun,
+             :reallocate, :GLFWreallocatefun,
+             :deallocate, :GLFWdeallocatefun,
+             :user, :pointer
+
+      def self.build(allocate:, reallocate:, deallocate:, user: nil)
+        allocator = new
+        allocator.allocate = allocate
+        allocator.reallocate = reallocate
+        allocator.deallocate = deallocate
+        allocator[:user] = user
+        allocator
+      end
+
+      def allocate=(callback)
+        @allocate_callback = callback
+        self[:allocate] = callback
+      end
+
+      def reallocate=(callback)
+        @reallocate_callback = callback
+        self[:reallocate] = callback
+      end
+
+      def deallocate=(callback)
+        @deallocate_callback = callback
+        self[:deallocate] = callback
+      end
+    end
+
+    callback :GLFWerrorfun, [:int, :string], :void
+    callback :GLFWwindowposfun, [:GLFWwindow, :int, :int], :void
+    callback :GLFWwindowsizefun, [:GLFWwindow, :int, :int], :void
+    callback :GLFWwindowclosefun, [:GLFWwindow], :void
+    callback :GLFWwindowrefreshfun, [:GLFWwindow], :void
+    callback :GLFWwindowfocusfun, [:GLFWwindow, :int], :void
+    callback :GLFWwindowiconifyfun, [:GLFWwindow, :int], :void
+    callback :GLFWwindowmaximizefun, [:GLFWwindow, :int], :void
+    callback :GLFWframebuffersizefun, [:GLFWwindow, :int, :int], :void
+    callback :GLFWwindowcontentscalefun, [:GLFWwindow, :float, :float], :void
+    callback :GLFWmousebuttonfun, [:GLFWwindow, :int, :int, :int], :void
+    callback :GLFWcursorposfun, [:GLFWwindow, :double, :double], :void
+    callback :GLFWcursorenterfun, [:GLFWwindow, :int], :void
+    callback :GLFWscrollfun, [:GLFWwindow, :double, :double], :void
+    callback :GLFWkeyfun, [:GLFWwindow, :int, :int, :int, :int], :void
+    callback :GLFWcharfun, [:GLFWwindow, :uint], :void
+    callback :GLFWcharmodsfun, [:GLFWwindow, :uint, :int], :void
+    callback :GLFWdropfun, [:GLFWwindow, :int, :pointer], :void
+    callback :GLFWmonitorfun, [:GLFWmonitor, :int], :void
+    callback :GLFWjoystickfun, [:int, :int], :void
+  end
+end

data/lib/glfw/api/v34.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module GLFW
+  module API
+    V34_FUNCTIONS = {
+      glfwGetPlatform: [[], :int],
+      glfwPlatformSupported: [[:int], :int],
+      glfwGetWindowTitle: [[:GLFWwindow], :string],
+      glfwInitAllocator: [[:pointer], :void],
+      glfwInitVulkanLoader: [[:GLFWvkproc], :void]
+    }.freeze
+
+    def self.bind_v34_functions!
+      V34_FUNCTIONS.each do |name, (args, ret)|
+        attach_function name, args, ret
+      rescue FFI::NotFoundError
+        define_singleton_method(name) { |*_| raise GLFW::NotSupportedError, "#{name} requires GLFW 3.4+" }
+      end
+    end
+  end
+end

data/lib/glfw/api/vulkan.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module GLFW
+  module API
+    attach_function :glfwVulkanSupported, [], :int
+    attach_function :glfwGetRequiredInstanceExtensions, [:pointer], :pointer
+    attach_function :glfwGetInstanceProcAddress, [:pointer, :string], :GLFWvkproc
+    attach_function :glfwGetPhysicalDevicePresentationSupport, [:pointer, :pointer, :uint32], :int
+    attach_function :glfwCreateWindowSurface, [:pointer, :GLFWwindow, :pointer, :pointer], :int
+  end
+end

data/lib/glfw/api/window.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module GLFW
+  module API
+    attach_function :glfwDefaultWindowHints, [], :void
+    attach_function :glfwWindowHint, [:int, :int], :void
+    attach_function :glfwWindowHintString, [:int, :string], :void
+    attach_function :glfwCreateWindow, [:int, :int, :string, :GLFWmonitor, :GLFWwindow], :GLFWwindow
+    attach_function :glfwDestroyWindow, [:GLFWwindow], :void
+    attach_function :glfwWindowShouldClose, [:GLFWwindow], :int
+    attach_function :glfwSetWindowShouldClose, [:GLFWwindow, :int], :void
+    attach_function :glfwSetWindowTitle, [:GLFWwindow, :string], :void
+    attach_function :glfwSetWindowIcon, [:GLFWwindow, :int, :pointer], :void
+    attach_function :glfwGetWindowPos, [:GLFWwindow, :pointer, :pointer], :void
+    attach_function :glfwSetWindowPos, [:GLFWwindow, :int, :int], :void
+    attach_function :glfwGetWindowSize, [:GLFWwindow, :pointer, :pointer], :void
+    attach_function :glfwSetWindowSize, [:GLFWwindow, :int, :int], :void
+    attach_function :glfwSetWindowSizeLimits, [:GLFWwindow, :int, :int, :int, :int], :void
+    attach_function :glfwSetWindowAspectRatio, [:GLFWwindow, :int, :int], :void
+    attach_function :glfwGetFramebufferSize, [:GLFWwindow, :pointer, :pointer], :void
+    attach_function :glfwGetWindowFrameSize, [:GLFWwindow, :pointer, :pointer, :pointer, :pointer], :void
+    attach_function :glfwGetWindowContentScale, [:GLFWwindow, :pointer, :pointer], :void
+    attach_function :glfwGetWindowOpacity, [:GLFWwindow], :float
+    attach_function :glfwSetWindowOpacity, [:GLFWwindow, :float], :void
+    attach_function :glfwIconifyWindow, [:GLFWwindow], :void
+    attach_function :glfwRestoreWindow, [:GLFWwindow], :void
+    attach_function :glfwMaximizeWindow, [:GLFWwindow], :void
+    attach_function :glfwShowWindow, [:GLFWwindow], :void
+    attach_function :glfwHideWindow, [:GLFWwindow], :void
+    attach_function :glfwFocusWindow, [:GLFWwindow], :void
+    attach_function :glfwRequestWindowAttention, [:GLFWwindow], :void
+    attach_function :glfwGetWindowMonitor, [:GLFWwindow], :GLFWmonitor
+    attach_function :glfwSetWindowMonitor, [:GLFWwindow, :GLFWmonitor, :int, :int, :int, :int, :int], :void
+    attach_function :glfwGetWindowAttrib, [:GLFWwindow, :int], :int
+    attach_function :glfwSetWindowAttrib, [:GLFWwindow, :int, :int], :void
+    attach_function :glfwSetWindowUserPointer, [:GLFWwindow, :pointer], :void
+    attach_function :glfwGetWindowUserPointer, [:GLFWwindow], :pointer
+    attach_function :glfwSetWindowPosCallback, [:GLFWwindow, :GLFWwindowposfun], :pointer
+    attach_function :glfwSetWindowSizeCallback, [:GLFWwindow, :GLFWwindowsizefun], :pointer
+    attach_function :glfwSetWindowCloseCallback, [:GLFWwindow, :GLFWwindowclosefun], :pointer
+    attach_function :glfwSetWindowRefreshCallback, [:GLFWwindow, :GLFWwindowrefreshfun], :pointer
+    attach_function :glfwSetWindowFocusCallback, [:GLFWwindow, :GLFWwindowfocusfun], :pointer
+    attach_function :glfwSetWindowIconifyCallback, [:GLFWwindow, :GLFWwindowiconifyfun], :pointer
+    attach_function :glfwSetWindowMaximizeCallback, [:GLFWwindow, :GLFWwindowmaximizefun], :pointer
+    attach_function :glfwSetFramebufferSizeCallback, [:GLFWwindow, :GLFWframebuffersizefun], :pointer
+    attach_function :glfwSetWindowContentScaleCallback, [:GLFWwindow, :GLFWwindowcontentscalefun], :pointer
+    attach_function :glfwPollEvents, [], :void
+    attach_function :glfwWaitEvents, [], :void
+    attach_function :glfwWaitEventsTimeout, [:double], :void
+    attach_function :glfwPostEmptyEvent, [], :void
+    attach_function :glfwSwapBuffers, [:GLFWwindow], :void
+  end
+end

data/lib/glfw/errors.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module GLFW
+  class Error < StandardError; end
+  class LibraryNotFoundError < Error; end
+  class InitError < Error; end
+  class NotSupportedError < Error; end
+
+  class APIError < Error
+    attr_reader :code
+
+    def initialize(code, message)
+      @code = code
+      super("[GLFW #{error_name(code)}] #{message}")
+    end
+
+    private
+
+    def error_name(code)
+      ERROR_CODE_NAMES[code] || "0x#{code.to_s(16).rjust(8, '0')}"
+    end
+  end
+
+  ERROR_CODE_NAMES = {
+    0x00010001 => "NOT_INITIALIZED",
+    0x00010002 => "NO_CURRENT_CONTEXT",
+    0x00010003 => "INVALID_ENUM",
+    0x00010004 => "INVALID_VALUE",
+    0x00010005 => "OUT_OF_MEMORY",
+    0x00010006 => "API_UNAVAILABLE",
+    0x00010007 => "VERSION_UNAVAILABLE",
+    0x00010008 => "PLATFORM_ERROR",
+    0x00010009 => "FORMAT_UNAVAILABLE",
+    0x0001000A => "NO_WINDOW_CONTEXT",
+    0x0001000B => "CURSOR_UNAVAILABLE",
+    0x0001000C => "FEATURE_UNAVAILABLE",
+    0x0001000D => "FEATURE_UNIMPLEMENTED",
+    0x0001000E => "PLATFORM_UNAVAILABLE"
+  }.freeze
+
+  class NotInitializedError < APIError; end
+  class NoCurrentContextError < APIError; end
+  class InvalidEnumError < APIError; end
+  class InvalidValueError < APIError; end
+  class OutOfMemoryError < APIError; end
+  class APIUnavailableError < APIError; end
+  class VersionUnavailableError < APIError; end
+  class PlatformError < APIError; end
+  class FormatUnavailableError < APIError; end
+  class NoWindowContextError < APIError; end
+  class CursorUnavailableError < APIError; end
+  class FeatureUnavailableError < APIError; end
+  class FeatureUnimplementedError < APIError; end
+  class PlatformUnavailableError < APIError; end
+
+  ERROR_CLASS_MAP = {
+    0x00010001 => NotInitializedError,
+    0x00010002 => NoCurrentContextError,
+    0x00010003 => InvalidEnumError,
+    0x00010004 => InvalidValueError,
+    0x00010005 => OutOfMemoryError,
+    0x00010006 => APIUnavailableError,
+    0x00010007 => VersionUnavailableError,
+    0x00010008 => PlatformError,
+    0x00010009 => FormatUnavailableError,
+    0x0001000A => NoWindowContextError,
+    0x0001000B => CursorUnavailableError,
+    0x0001000C => FeatureUnavailableError,
+    0x0001000D => FeatureUnimplementedError,
+    0x0001000E => PlatformUnavailableError
+  }.freeze
+end

data/lib/glfw/high_level/cursor.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module GLFW
+  class Cursor
+    attr_reader :handle
+
+    def initialize(handle)
+      @handle = handle
+    end
+
+    def self.create(image, xhot, yhot)
+      img_struct = image.to_struct
+      handle = API.glfwCreateCursor(img_struct, xhot, yhot)
+      raise GLFW::Error, "Failed to create cursor" if handle.null?
+
+      new(handle)
+    end
+
+    def self.standard(shape)
+      handle = API.glfwCreateStandardCursor(shape)
+      raise GLFW::Error, "Failed to create standard cursor" if handle.null?
+
+      new(handle)
+    end
+
+    def destroy
+      API.glfwDestroyCursor(@handle)
+      @handle = nil
+    end
+  end
+end

data/lib/glfw/high_level/gamepad.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module GLFW
+  class GamepadState
+    attr_reader :buttons, :axes
+
+    def initialize(buttons, axes)
+      @buttons = buttons
+      @axes = axes
+    end
+
+    def button_pressed?(button)
+      @buttons[button] == GLFW_PRESS
+    end
+
+    def axis_value(axis)
+      @axes[axis]
+    end
+  end
+
+  class Gamepad
+    def initialize(jid)
+      @jid = jid
+    end
+
+    def name
+      API.glfwGetGamepadName(@jid)
+    end
+
+    def state
+      gs = API::GLFWgamepadstate.new
+      return nil unless API.glfwGetGamepadState(@jid, gs) == GLFW_TRUE
+
+      buttons = gs[:buttons].to_a
+      axes = gs[:axes].to_a
+      GamepadState.new(buttons, axes)
+    end
+
+    def self.update_mappings(string)
+      API.glfwUpdateGamepadMappings(string) == GLFW_TRUE
+    end
+  end
+end

data/lib/glfw/high_level/gamma_ramp.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module GLFW
+  class GammaRamp
+    attr_reader :red, :green, :blue, :size
+
+    def initialize(red, green, blue, size)
+      @red = red
+      @green = green
+      @blue = blue
+      @size = size
+    end
+
+    def self.from_struct(ptr)
+      struct = API::GLFWgammaramp.new(ptr)
+      size = struct[:size]
+      red = struct[:red].read_array_of_uint16(size)
+      green = struct[:green].read_array_of_uint16(size)
+      blue = struct[:blue].read_array_of_uint16(size)
+      new(red, green, blue, size)
+    end
+
+    def to_struct
+      ramp = API::GLFWgammaramp.new
+      ramp[:size] = @size
+      ramp[:red] = FFI::MemoryPointer.new(:uint16, @size).tap { |p| p.write_array_of_uint16(@red) }
+      ramp[:green] = FFI::MemoryPointer.new(:uint16, @size).tap { |p| p.write_array_of_uint16(@green) }
+      ramp[:blue] = FFI::MemoryPointer.new(:uint16, @size).tap { |p| p.write_array_of_uint16(@blue) }
+      ramp
+    end
+  end
+end

data/lib/glfw/high_level/image.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module GLFW
+  class Image
+    attr_reader :width, :height, :pixels
+
+    def initialize(width, height, pixels)
+      @width = width
+      @height = height
+      @pixels = pixels
+    end
+
+    def self.from_rgba(width, height, data)
+      pixels = FFI::MemoryPointer.new(:uchar, data.bytesize)
+      pixels.put_bytes(0, data)
+      new(width, height, pixels)
+    end
+
+    def to_struct
+      img = API::GLFWimage.new
+      img[:width] = @width
+      img[:height] = @height
+      img[:pixels] = @pixels
+      img
+    end
+  end
+end

data/lib/glfw/high_level/joystick.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module GLFW
+  class Joystick
+    attr_reader :jid
+
+    def initialize(jid)
+      @jid = jid
+    end
+
+    def self.[](jid)
+      new(jid)
+    end
+
+    def present?
+      API.glfwJoystickPresent(@jid) == GLFW_TRUE
+    end
+
+    def name
+      API.glfwGetJoystickName(@jid)
+    end
+
+    def guid
+      API.glfwGetJoystickGUID(@jid)
+    end
+
+    def axes
+      count = FFI::MemoryPointer.new(:int)
+      ptr = API.glfwGetJoystickAxes(@jid, count)
+      return [] if ptr.null?
+
+      ptr.read_array_of_float(count.read_int)
+    end
+
+    def buttons
+      count = FFI::MemoryPointer.new(:int)
+      ptr = API.glfwGetJoystickButtons(@jid, count)
+      return [] if ptr.null?
+
+      ptr.read_array_of_uchar(count.read_int).map { |b| ACTION_MAP[b] || b }
+    end
+
+    def hats
+      count = FFI::MemoryPointer.new(:int)
+      ptr = API.glfwGetJoystickHats(@jid, count)
+      return [] if ptr.null?
+
+      ptr.read_array_of_uchar(count.read_int)
+    end
+
+    def gamepad?
+      API.glfwJoystickIsGamepad(@jid) == GLFW_TRUE
+    end
+
+    def gamepad
+      return nil unless gamepad?
+
+      Gamepad.new(@jid)
+    end
+
+    def self.on_connect(&block)
+      cb = proc { |jid, event|
+        block.call(new(jid), event == GLFW_CONNECTED ? :connected : :disconnected)
+      }
+      GLFW.register_callback(:joystick, nil, cb)
+      API.glfwSetJoystickCallback(cb)
+    end
+  end
+end

data/lib/glfw/high_level/monitor.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module GLFW
+  class Monitor
+    attr_reader :handle
+
+    def initialize(handle)
+      @handle = handle
+    end
+
+    def self.all
+      count = FFI::MemoryPointer.new(:int)
+      ptr = API.glfwGetMonitors(count)
+      return [] if ptr.null?
+
+      n = count.read_int
+      ptr.read_array_of_pointer(n).map { |p| new(p) }
+    end
+
+    def self.primary
+      handle = API.glfwGetPrimaryMonitor
+      return nil if handle.null?
+
+      new(handle)
+    end
+
+    def name
+      API.glfwGetMonitorName(@handle)
+    end
+
+    def position
+      x = FFI::MemoryPointer.new(:int)
+      y = FFI::MemoryPointer.new(:int)
+      API.glfwGetMonitorPos(@handle, x, y)
+      [x.read_int, y.read_int]
+    end
+
+    def workarea
+      x = FFI::MemoryPointer.new(:int)
+      y = FFI::MemoryPointer.new(:int)
+      w = FFI::MemoryPointer.new(:int)
+      h = FFI::MemoryPointer.new(:int)
+      API.glfwGetMonitorWorkarea(@handle, x, y, w, h)
+      { x: x.read_int, y: y.read_int, width: w.read_int, height: h.read_int }
+    end
+
+    def physical_size
+      w = FFI::MemoryPointer.new(:int)
+      h = FFI::MemoryPointer.new(:int)
+      API.glfwGetMonitorPhysicalSize(@handle, w, h)
+      [w.read_int, h.read_int]
+    end
+
+    def content_scale
+      x = FFI::MemoryPointer.new(:float)
+      y = FFI::MemoryPointer.new(:float)
+      API.glfwGetMonitorContentScale(@handle, x, y)
+      [x.read_float, y.read_float]
+    end
+
+    def video_modes
+      count = FFI::MemoryPointer.new(:int)
+      ptr = API.glfwGetVideoModes(@handle, count)
+      return [] if ptr.null?
+
+      n = count.read_int
+      n.times.map do |i|
+        struct = API::GLFWvidmode.new(ptr + i * API::GLFWvidmode.size)
+        VideoMode.from_struct(struct)
+      end
+    end
+
+    def current_video_mode
+      ptr = API.glfwGetVideoMode(@handle)
+      return nil if ptr.null?
+
+      VideoMode.from_struct(API::GLFWvidmode.new(ptr))
+    end
+
+    def gamma=(val)
+      API.glfwSetGamma(@handle, val.to_f)
+    end
+
+    def gamma_ramp
+      ptr = API.glfwGetGammaRamp(@handle)
+      return nil if ptr.null?
+
+      GammaRamp.from_struct(ptr)
+    end
+
+    def gamma_ramp=(ramp)
+      struct = ramp.to_struct
+      API.glfwSetGammaRamp(@handle, struct)
+    end
+
+    def self.on_connect(&block)
+      cb = proc { |monitor_ptr, event|
+        block.call(new(monitor_ptr), event == GLFW_CONNECTED ? :connected : :disconnected)
+      }
+      GLFW.register_callback(:monitor, nil, cb)
+      API.glfwSetMonitorCallback(cb)
+    end
+  end
+end

data/lib/glfw/high_level/video_mode.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module GLFW
+  class VideoMode
+    attr_reader :width, :height, :red_bits, :green_bits, :blue_bits, :refresh_rate
+
+    def initialize(width, height, red_bits, green_bits, blue_bits, refresh_rate)
+      @width = width
+      @height = height
+      @red_bits = red_bits
+      @green_bits = green_bits
+      @blue_bits = blue_bits
+      @refresh_rate = refresh_rate
+    end
+
+    def self.from_struct(struct)
+      new(struct[:width], struct[:height], struct[:redBits],
+          struct[:greenBits], struct[:blueBits], struct[:refreshRate])
+    end
+
+    def ==(other)
+      other.is_a?(VideoMode) &&
+        width == other.width && height == other.height &&
+        red_bits == other.red_bits && green_bits == other.green_bits &&
+        blue_bits == other.blue_bits && refresh_rate == other.refresh_rate
+    end
+
+    def to_s
+      "#{width}x#{height}@#{refresh_rate}Hz (#{red_bits}/#{green_bits}/#{blue_bits})"
+    end
+  end
+end