ruby-sfml 3.0.0.0

data/lib/sfml/network/tcp_socket.rb

@@ -0,0 +1,74 @@
+module SFML
+  module Network
+    # A TCP client socket. Connect to a server, send/receive bytes,
+    # disconnect.
+    #
+    #   sock = SFML::Network::TcpSocket.new
+    #   case sock.connect(SFML::Network::IpAddress::LOCALHOST, port: 8080)
+    #   when :done then ...
+    #   end
+    #
+    #   sock.send("hello")
+    #   status, bytes = sock.receive(max: 1024)
+    #
+    # By default sockets are blocking; set `socket.blocking = false`
+    # for non-blocking polling, where send/receive may return :not_ready.
+    class TcpSocket
+      def initialize
+        ptr = C::Network.sfTcpSocket_create
+        raise Error, "sfTcpSocket_create returned NULL" if ptr.null?
+        @handle = FFI::AutoPointer.new(ptr, C::Network.method(:sfTcpSocket_destroy))
+      end
+
+      # Open a connection. Returns one of the SOCKET_STATUSES symbols
+      # (:done, :not_ready, :disconnected, :error). `timeout` is a
+      # SFML::Time; SFML::Time.zero (default) blocks forever.
+      def connect(address, port:, timeout: SFML::Time.zero)
+        addr = address.is_a?(IpAddress) ? address : IpAddress.from_string(address)
+        code = C::Network.sfTcpSocket_connect(@handle, addr.struct, Integer(port), timeout.to_native)
+        C::Network::STATUSES[code]
+      end
+
+      def disconnect
+        C::Network.sfTcpSocket_disconnect(@handle)
+        self
+      end
+
+      def send(data)
+        bytes = data.to_s
+        buf   = FFI::MemoryPointer.new(:uint8, bytes.bytesize)
+        buf.write_bytes(bytes)
+        code = C::Network.sfTcpSocket_send(@handle, buf, bytes.bytesize)
+        C::Network::STATUSES[code]
+      end
+
+      # Read up to `max` bytes. Returns [status, data] — `data` is a
+      # binary String when status is :done, nil otherwise.
+      def receive(max: 4096)
+        buf      = FFI::MemoryPointer.new(:uint8, Integer(max))
+        received = FFI::MemoryPointer.new(:size_t)
+        code = C::Network.sfTcpSocket_receive(@handle, buf, Integer(max), received)
+        status = C::Network::STATUSES[code]
+
+        return [status, nil] unless status == :done
+        n = received.read(:size_t)
+        [status, buf.read_bytes(n)]
+      end
+
+      def blocking? = C::Network.sfTcpSocket_isBlocking(@handle)
+
+      def blocking=(value)
+        C::Network.sfTcpSocket_setBlocking(@handle, value ? true : false)
+      end
+
+      def local_port  = C::Network.sfTcpSocket_getLocalPort(@handle)
+      def remote_port = C::Network.sfTcpSocket_getRemotePort(@handle)
+
+      def remote_address
+        IpAddress.wrap(C::Network.sfTcpSocket_getRemoteAddress(@handle))
+      end
+
+      attr_reader :handle # :nodoc:
+    end
+  end
+end

data/lib/sfml/network/udp_socket.rb

@@ -0,0 +1,71 @@
+module SFML
+  module Network
+    # Connectionless UDP datagram socket. Bind a port to receive,
+    # send to (address, port). Stateless — every send/receive specifies
+    # the peer.
+    #
+    #   sock = SFML::Network::UdpSocket.new
+    #   sock.bind(port: 9999)
+    #   sock.send("hello", to: SFML::Network::IpAddress::LOCALHOST, port: 9000)
+    #   status, bytes, addr, port = sock.receive(max: 1024)
+    class UdpSocket
+      MAX_DATAGRAM_SIZE = C::Network.sfUdpSocket_maxDatagramSize
+
+      def initialize
+        ptr = C::Network.sfUdpSocket_create
+        raise Error, "sfUdpSocket_create returned NULL" if ptr.null?
+        @handle = FFI::AutoPointer.new(ptr, C::Network.method(:sfUdpSocket_destroy))
+      end
+
+      def bind(port:, address: IpAddress::ANY)
+        addr = address.is_a?(IpAddress) ? address : IpAddress.from_string(address)
+        code = C::Network.sfUdpSocket_bind(@handle, Integer(port), addr.struct)
+        C::Network::STATUSES[code]
+      end
+
+      def unbind
+        C::Network.sfUdpSocket_unbind(@handle)
+        self
+      end
+
+      def send(data, to:, port:)
+        bytes = data.to_s
+        addr  = to.is_a?(IpAddress) ? to : IpAddress.from_string(to)
+        buf   = FFI::MemoryPointer.new(:uint8, bytes.bytesize)
+        buf.write_bytes(bytes)
+        code = C::Network.sfUdpSocket_send(@handle, buf, bytes.bytesize, addr.struct, Integer(port))
+        C::Network::STATUSES[code]
+      end
+
+      # Returns [status, data, sender_ip, sender_port].
+      # `data` is a binary String when status is :done, otherwise nil.
+      def receive(max: 1024)
+        buf            = FFI::MemoryPointer.new(:uint8, Integer(max))
+        received_size  = FFI::MemoryPointer.new(:size_t)
+        sender_addr    = C::Network::IpAddress.new
+        sender_port    = FFI::MemoryPointer.new(:uint16)
+
+        code = C::Network.sfUdpSocket_receive(
+          @handle, buf, Integer(max), received_size, sender_addr.pointer, sender_port,
+        )
+        status = C::Network::STATUSES[code]
+
+        return [status, nil, nil, nil] unless status == :done
+        n     = received_size.read(:size_t)
+        sip   = IpAddress.wrap(sender_addr)
+        sport = sender_port.read(:uint16)
+        [status, buf.read_bytes(n), sip, sport]
+      end
+
+      def blocking? = C::Network.sfUdpSocket_isBlocking(@handle)
+
+      def blocking=(value)
+        C::Network.sfUdpSocket_setBlocking(@handle, value ? true : false)
+      end
+
+      def local_port = C::Network.sfUdpSocket_getLocalPort(@handle)
+
+      attr_reader :handle # :nodoc:
+    end
+  end
+end

data/lib/sfml/system/clock.rb

@@ -0,0 +1,44 @@
+module SFML
+  # Monotonic high-resolution timer. Wraps sfClock from CSFML.
+  #
+  #   clock = SFML::Clock.new
+  #   # ... do work ...
+  #   puts clock.elapsed_time.as_seconds
+  #   clock.restart  # returns the elapsed time and resets to zero
+  class Clock
+    def initialize
+      ptr = C::System.sfClock_create
+      raise Error, "sfClock_create returned NULL" if ptr.null?
+      @handle = FFI::AutoPointer.new(ptr, C::System.method(:sfClock_destroy))
+    end
+
+    def elapsed_time
+      Time.from_native(C::System.sfClock_getElapsedTime(@handle))
+    end
+    alias elapsed elapsed_time
+
+    def running?
+      C::System.sfClock_isRunning(@handle)
+    end
+
+    def start
+      C::System.sfClock_start(@handle)
+      self
+    end
+
+    def stop
+      C::System.sfClock_stop(@handle)
+      self
+    end
+
+    def restart
+      Time.from_native(C::System.sfClock_restart(@handle))
+    end
+
+    def reset
+      Time.from_native(C::System.sfClock_reset(@handle))
+    end
+
+    attr_reader :handle # :nodoc:
+  end
+end

data/lib/sfml/system/rect.rb

@@ -0,0 +1,64 @@
+module SFML
+  # An axis-aligned rectangle. Mirrors sfFloatRect / sfIntRect — those structs
+  # are just (position: Vector2, size: Vector2). We deliberately keep one
+  # Ruby class for both the float and int variants since pattern-matching
+  # `case bounds in {position: {x:, y:}, size: {x: w, y: h}}` is what the
+  # users reach for either way.
+  #
+  #   r = SFML::Rect.new([10, 20], [100, 50])
+  #   r.contains?([50, 30])    #=> true
+  #   r.right                  #=> 110
+  #
+  # Used by Text#local_bounds, Text#global_bounds, Sprite#texture_rect, etc.
+  class Rect
+    attr_reader :position, :size
+
+    def initialize(position, size)
+      @position = position.is_a?(Vector2) ? position : Vector2.new(*position)
+      @size     = size.is_a?(Vector2) ? size : Vector2.new(*size)
+      freeze
+    end
+
+    def x      = @position.x
+    def y      = @position.y
+    def width  = @size.x
+    def height = @size.y
+    alias left x
+    alias top  y
+    def right  = @position.x + @size.x
+    def bottom = @position.y + @size.y
+
+    def contains?(point)
+      px, py = point.is_a?(Vector2) ? [point.x, point.y] : [point[0], point[1]]
+      px >= left && px < right && py >= top && py < bottom
+    end
+
+    def intersects?(other)
+      left   < other.right  &&
+        right  > other.left  &&
+        top    < other.bottom &&
+        bottom > other.top
+    end
+
+    def ==(other)
+      other.is_a?(Rect) && @position == other.position && @size == other.size
+    end
+    alias eql? ==
+    def hash = [@position, @size].hash
+
+    def to_a = [x, y, width, height]
+    def to_h = { position: @position, size: @size }
+    def deconstruct = [x, y, width, height]
+    def deconstruct_keys(_keys) = { position: @position, size: @size }
+
+    def to_s = "Rect(x=#{x}, y=#{y}, w=#{width}, h=#{height})"
+    alias inspect to_s
+
+    def self.from_native(struct) # :nodoc:
+      new(
+        Vector2.new(struct[:position][:x], struct[:position][:y]),
+        Vector2.new(struct[:size][:x], struct[:size][:y]),
+      )
+    end
+  end
+end

data/lib/sfml/system/time.rb

@@ -0,0 +1,48 @@
+module SFML
+  # Represents a time value. Stored internally as microseconds (int64), same
+  # as sfTime in CSFML. Immutable and comparable.
+  #
+  #   SFML::Time.seconds(1.5)        #=> 1_500_000 µs
+  #   SFML::Time.milliseconds(500)
+  #   SFML::Time.microseconds(42)
+  #   SFML::Time.zero
+  class Time
+    include Comparable
+
+    attr_reader :microseconds
+
+    def self.seconds(value)      = new((value * 1_000_000).to_i)
+    def self.milliseconds(value) = new(Integer(value) * 1_000)
+    def self.microseconds(value) = new(Integer(value))
+    def self.zero                = new(0)
+
+    def initialize(microseconds)
+      @microseconds = Integer(microseconds)
+      freeze
+    end
+
+    def as_seconds      = @microseconds / 1_000_000.0
+    def as_milliseconds = @microseconds / 1_000
+    def as_microseconds = @microseconds
+
+    def +(other) = Time.new(@microseconds + other.microseconds)
+    def -(other) = Time.new(@microseconds - other.microseconds)
+    def -@       = Time.new(-@microseconds)
+    def <=>(other) = @microseconds <=> other.microseconds
+
+    def hash = @microseconds.hash
+    def eql?(other) = other.is_a?(Time) && @microseconds == other.microseconds
+    alias == eql?
+
+    def to_s = "#<SFML::Time #{as_seconds}s>"
+    alias inspect to_s
+
+    def self.from_native(struct) # :nodoc:
+      new(struct[:microseconds])
+    end
+
+    def to_native # :nodoc:
+      C::System::Time.new.tap { |t| t[:microseconds] = @microseconds }
+    end
+  end
+end

data/lib/sfml/system/vector2.rb

@@ -0,0 +1,66 @@
+module SFML
+  # 2D vector with float components. Operator-friendly and pattern-matchable.
+  #
+  #   v = SFML::Vector2[3, 4]
+  #   v.length          #=> 5.0
+  #   v + Vector2[1, 1] #=> Vector2(4, 5)
+  #   v * 2             #=> Vector2(6, 8)
+  #   x, y = v          # destructures via to_a
+  class Vector2
+    attr_reader :x, :y
+
+    def self.[](x, y) = new(x, y)
+    def self.zero     = new(0, 0)
+
+    def initialize(x = 0, y = 0)
+      @x = x
+      @y = y
+      freeze
+    end
+
+    def +(other) = Vector2.new(@x + other.x, @y + other.y)
+    def -(other) = Vector2.new(@x - other.x, @y - other.y)
+    def *(scalar) = Vector2.new(@x * scalar, @y * scalar)
+    def /(scalar) = Vector2.new(@x / scalar.to_f, @y / scalar.to_f)
+    def -@ = Vector2.new(-@x, -@y)
+
+    # Lets Ruby evaluate `2 * vec` as `vec * 2`. Without this, Numeric#*
+    # would raise TypeError because it doesn't know about Vector2.
+    def coerce(other)
+      raise TypeError, "Vector2 cannot coerce #{other.class}" unless other.is_a?(Numeric)
+      [self, other]
+    end
+
+    def ==(other) = other.is_a?(Vector2) && @x == other.x && @y == other.y
+    alias eql? ==
+    def hash = [@x, @y].hash
+
+    def length    = Math.sqrt(length_sq)
+    def length_sq = (@x * @x) + (@y * @y)
+
+    def normalize
+      len = length
+      return Vector2.zero if len.zero?
+      self / len
+    end
+
+    def dot(other)   = (@x * other.x) + (@y * other.y)
+    def cross(other) = (@x * other.y) - (@y * other.x)
+
+    def to_a = [@x, @y]
+    def to_h = { x: @x, y: @y }
+    def deconstruct = [@x, @y]
+    def deconstruct_keys(_keys) = { x: @x, y: @y }
+
+    def to_s = "Vector2(#{@x}, #{@y})"
+    alias inspect to_s
+
+    def self.from_native(struct) # :nodoc:
+      new(struct[:x], struct[:y])
+    end
+
+    def to_native_f # :nodoc:
+      C::System::Vector2f.new.tap { |v| v[:x] = @x; v[:y] = @y }
+    end
+  end
+end

data/lib/sfml/system/vector3.rb

@@ -0,0 +1,63 @@
+module SFML
+  # 3D vector with float components. Mirrors Vector2's surface.
+  class Vector3
+    attr_reader :x, :y, :z
+
+    def self.[](x, y, z) = new(x, y, z)
+    def self.zero        = new(0, 0, 0)
+
+    def initialize(x = 0, y = 0, z = 0)
+      @x = x
+      @y = y
+      @z = z
+      freeze
+    end
+
+    def +(other) = Vector3.new(@x + other.x, @y + other.y, @z + other.z)
+    def -(other) = Vector3.new(@x - other.x, @y - other.y, @z - other.z)
+    def *(scalar) = Vector3.new(@x * scalar, @y * scalar, @z * scalar)
+    def /(scalar) = Vector3.new(@x / scalar.to_f, @y / scalar.to_f, @z / scalar.to_f)
+    def -@ = Vector3.new(-@x, -@y, -@z)
+
+    def ==(other)
+      other.is_a?(Vector3) && @x == other.x && @y == other.y && @z == other.z
+    end
+    alias eql? ==
+    def hash = [@x, @y, @z].hash
+
+    def length    = Math.sqrt(length_sq)
+    def length_sq = (@x * @x) + (@y * @y) + (@z * @z)
+
+    def normalize
+      len = length
+      return Vector3.zero if len.zero?
+      self / len
+    end
+
+    def dot(other) = (@x * other.x) + (@y * other.y) + (@z * other.z)
+
+    def cross(other)
+      Vector3.new(
+        (@y * other.z) - (@z * other.y),
+        (@z * other.x) - (@x * other.z),
+        (@x * other.y) - (@y * other.x)
+      )
+    end
+
+    def to_a = [@x, @y, @z]
+    def to_h = { x: @x, y: @y, z: @z }
+    def deconstruct = [@x, @y, @z]
+    def deconstruct_keys(_keys) = { x: @x, y: @y, z: @z }
+
+    def to_s = "Vector3(#{@x}, #{@y}, #{@z})"
+    alias inspect to_s
+
+    def self.from_native(struct) # :nodoc:
+      new(struct[:x], struct[:y], struct[:z])
+    end
+
+    def to_native_f # :nodoc:
+      C::System::Vector3f.new.tap { |v| v[:x] = @x; v[:y] = @y; v[:z] = @z }
+    end
+  end
+end

data/lib/sfml/version.rb

@@ -0,0 +1,19 @@
+module SFML
+  # The SFML/CSFML release this gem is built against. End users can
+  # check this at runtime to assert binding compatibility.
+  CSFML_VERSION = "3.0.0"
+
+  # Gem version. The first three segments mirror CSFML_VERSION exactly;
+  # the trailing fourth segment is our own patch number for fixes /
+  # additions made on top of the same upstream CSFML release.
+  #
+  # Examples on a hypothetical timeline:
+  #
+  #   "3.0.0.0"  — first cut against CSFML 3.0.0
+  #   "3.0.0.1"  — our bug fix, still on CSFML 3.0.0
+  #   "3.0.0.2"  — another patch
+  #   "3.0.1.0"  — CSFML 3.0.1 ships, we re-cut from upstream
+  #   "3.0.1.1"  — our patch on top of CSFML 3.0.1
+  #   "3.1.0.0"  — CSFML 3.1.0 ships, we add new bindings
+  VERSION = "3.0.0.0"
+end

data/lib/sfml/window/clipboard.rb

@@ -0,0 +1,38 @@
+module SFML
+  # The system clipboard. UTF-8 in, UTF-8 out — even when the OS stores
+  # it as wide chars, we go through CSFML's `*UnicodeString` variants
+  # and convert in Ruby so non-ASCII text round-trips losslessly.
+  #
+  #   SFML::Clipboard.text             #=> "whatever was last copied"
+  #   SFML::Clipboard.text = "пример"
+  #
+  # Useful inside text-input UIs (Ctrl+C / Ctrl+V handlers) and for
+  # quick "copy that error message" buttons in tools.
+  module Clipboard
+    module_function
+
+    def text
+      ptr = C::Window.sfClipboard_getUnicodeString
+      return "" if ptr.null?
+
+      codepoints = []
+      offset = 0
+      loop do
+        cp = ptr.get_uint32(offset)
+        break if cp.zero?
+        codepoints << cp
+        offset += 4
+      end
+      codepoints.pack("U*")
+    end
+
+    def text=(value)
+      str = value.to_s.encode("UTF-8")
+      cps = str.unpack("U*")
+      buf = FFI::MemoryPointer.new(:uint32, cps.length + 1)
+      buf.write_array_of_uint32(cps + [0])
+      C::Window.sfClipboard_setUnicodeString(buf)
+      str
+    end
+  end
+end

data/lib/sfml/window/cursor.rb

@@ -0,0 +1,68 @@
+module SFML
+  # A mouse cursor — either a built-in system shape, or a custom bitmap.
+  # Apply it with `window.cursor = cursor`.
+  #
+  #   window.cursor = SFML::Cursor.system(:hand)
+  #   window.cursor = SFML::Cursor.system(:not_allowed)
+  #
+  #   pixels = "..." # 32×32 RGBA bytes
+  #   window.cursor = SFML::Cursor.from_pixels(32, 32, pixels, hotspot: [16, 16])
+  #
+  # See SFML::Cursor::TYPES for the full list of system shapes.
+  class Cursor
+    # Order matches sfCursorType in CSFML/Window/Cursor.h.
+    TYPES = %i[
+      arrow arrow_wait wait text hand
+      size_horizontal size_vertical
+      size_top_left_bottom_right size_bottom_left_top_right
+      size_left size_right size_top size_bottom
+      size_top_left size_bottom_right size_bottom_left size_top_right
+      size_all cross help not_allowed
+    ].freeze
+    TYPE_INDEX = TYPES.each_with_index.to_h.freeze
+
+    # Build a cursor matching one of the OS-supplied shapes. Some types
+    # (the directional `size_*` family beyond Horizontal/Vertical) only
+    # render distinct shapes on Linux — on macOS / Windows they fall
+    # back to the closest equivalent.
+    def self.system(type)
+      code = TYPE_INDEX.fetch(type) do
+        raise ArgumentError, "Unknown cursor type: #{type.inspect}. " \
+                             "Expected one of: #{TYPES.inspect}"
+      end
+      ptr = C::Window.sfCursor_createFromSystem(code)
+      raise Error, "sfCursor_createFromSystem returned NULL for #{type.inspect}" if ptr.null?
+      _wrap(ptr)
+    end
+
+    # Build a cursor from raw RGBA pixels. `pixels` must be exactly
+    # width*height*4 bytes. `hotspot:` is the [x, y] within the cursor
+    # image that maps to the actual click point (e.g. tip of an arrow).
+    def self.from_pixels(width, height, pixels, hotspot: [0, 0])
+      expected = Integer(width) * Integer(height) * 4
+      raise ArgumentError, "pixels must be #{expected} bytes, got #{pixels.bytesize}" if pixels.bytesize != expected
+
+      buf = FFI::MemoryPointer.new(:uint8, expected)
+      buf.write_bytes(pixels)
+
+      size = C::System::Vector2u.new
+      size[:x] = Integer(width); size[:y] = Integer(height)
+
+      hot = C::System::Vector2u.new
+      hot[:x] = Integer(hotspot[0]); hot[:y] = Integer(hotspot[1])
+
+      ptr = C::Window.sfCursor_createFromPixels(buf, size, hot)
+      raise Error, "sfCursor_createFromPixels returned NULL" if ptr.null?
+      _wrap(ptr)
+    end
+
+    attr_reader :handle # :nodoc:
+
+    # @!visibility private
+    def self._wrap(ptr)
+      cursor = allocate
+      cursor.instance_variable_set(:@handle, FFI::AutoPointer.new(ptr, C::Window.method(:sfCursor_destroy)))
+      cursor
+    end
+  end
+end

data/lib/sfml/window/event.rb

@@ -0,0 +1,133 @@
+module SFML
+  # A window event. Holds a type symbol and a Hash of type-specific data.
+  # Pattern-match it directly; that's the intended interface:
+  #
+  #   case event
+  #   in {type: :closed}                              then ...
+  #   in {type: :key_pressed, code: :escape}          then ...
+  #   in {type: :resized, size:}                      then ...
+  #   in {type: :mouse_moved, position: {x:, y:}}     then ...
+  #   in {type: :mouse_wheel_scrolled, delta:}        then ...
+  #   end
+  #
+  # Type-specific fields are also reachable as plain methods (`event.code`,
+  # `event.position`) for the cases when pattern matching is overkill.
+  class Event
+    # Order matches sfMouseButton in CSFML 3: left, right, middle,
+    # extra1, extra2. (CSFML 2 called the last two x_button1/x_button2,
+    # but SFML 3 dropped the X-button terminology.)
+    MOUSE_BUTTONS = %i[left right middle extra1 extra2].freeze
+    MOUSE_WHEELS  = %i[vertical horizontal].freeze
+
+    attr_reader :type, :data
+
+    def initialize(type, data = {})
+      @type = type
+      @data = data.freeze
+      freeze
+    end
+
+    def [](key)        = @data[key]
+    def fetch(*args, &) = @data.fetch(*args, &)
+
+    def deconstruct_keys(_keys)
+      { type: @type, **@data }
+    end
+
+    def respond_to_missing?(name, _private = false)
+      @data.key?(name) || super
+    end
+
+    def method_missing(name, *args)
+      return @data[name] if args.empty? && @data.key?(name)
+      super
+    end
+
+    def to_s = "#<SFML::Event #{@type} #{@data.inspect}>"
+    alias inspect to_s
+
+    # Reads the sfEvent union buffer, decodes the discriminator, and reads
+    # the type-specific variant. CSFML lays each variant out with the
+    # sfEventType as the first field, so we can re-interpret the same memory
+    # as the right struct.
+    def self.from_native(buffer)
+      type_index = buffer[:type]
+      type_sym   = C::Window::EVENT_TYPES[type_index] || :unknown
+
+      data = decode(type_sym, buffer.to_ptr)
+      new(type_sym, data)
+    end
+
+    def self.decode(type_sym, ptr)
+      case type_sym
+      when :closed, :focus_lost, :focus_gained,
+           :mouse_entered, :mouse_left
+        EMPTY
+
+      when :resized
+        s = C::Window::SizeEvent.new(ptr)
+        { size: Vector2.new(s[:size][:x], s[:size][:y]) }
+
+      when :key_pressed, :key_released
+        k = C::Window::KeyEvent.new(ptr)
+        {
+          code:    Keyboard.code_to_symbol(k[:code]),
+          alt:     k[:alt],
+          control: k[:control],
+          shift:   k[:shift],
+          system:  k[:system],
+        }
+
+      when :text_entered
+        t = C::Window::TextEvent.new(ptr)
+        { unicode: t[:unicode], char: [t[:unicode]].pack("U*") }
+
+      when :mouse_moved
+        m = C::Window::MouseMoveEvent.new(ptr)
+        { position: Vector2.new(m[:position][:x], m[:position][:y]) }
+
+      when :mouse_moved_raw
+        m = C::Window::MouseMoveEvent.new(ptr)
+        # Raw event re-uses the same struct shape but the field is a delta.
+        { delta: Vector2.new(m[:position][:x], m[:position][:y]) }
+
+      when :mouse_button_pressed, :mouse_button_released
+        b = C::Window::MouseButtonEvent.new(ptr)
+        {
+          button:   MOUSE_BUTTONS[b[:button]] || :unknown,
+          position: Vector2.new(b[:position][:x], b[:position][:y]),
+        }
+
+      when :mouse_wheel_scrolled
+        w = C::Window::MouseWheelScrollEvent.new(ptr)
+        {
+          wheel:    MOUSE_WHEELS[w[:wheel]] || :unknown,
+          delta:    w[:delta],
+          position: Vector2.new(w[:position][:x], w[:position][:y]),
+        }
+
+      when :joystick_button_pressed, :joystick_button_released
+        b = C::Window::JoystickButtonEvent.new(ptr)
+        { joystick_id: b[:joystick_id], button: b[:button] }
+
+      when :joystick_moved
+        m = C::Window::JoystickMoveEvent.new(ptr)
+        {
+          joystick_id: m[:joystick_id],
+          axis:        Joystick::AXES[m[:axis]] || :unknown,
+          position:    m[:position],
+        }
+
+      when :joystick_connected, :joystick_disconnected
+        c = C::Window::JoystickConnectEvent.new(ptr)
+        { joystick_id: c[:joystick_id] }
+
+      else
+        EMPTY
+      end
+    end
+
+    EMPTY = {}.freeze
+    private_constant :EMPTY
+  end
+end