rbgl 1.0.0 → 1.0.2

data/lib/rbgl/gui/wayland/event_dispatcher.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "input_mapper"
+
 module RBGL
   module GUI
     module Wayland
@@ -13,16 +15,24 @@ module RBGL
           object = @connection.object_for(object_id)
 
           case object
+          when Display
+            handle_display_event(opcode, payload)
           when Registry
             handle_registry_event(opcode, payload)
           when Callback
             object.handle_done if opcode == 0
           when WlBuffer
             object.handle_release if opcode == 0
+          when Seat
+            object.handle_capabilities(payload.unpack1("V")) if opcode == 0
+          when Keyboard
+            handle_keyboard_event(object, opcode, payload)
+          when Pointer
+            handle_pointer_event(object, opcode, payload)
           when XdgWmBase
             handle_xdg_wm_base_event(object, opcode, payload)
           when XdgSurface
-            handle_xdg_surface_event(object, opcode, payload)
+            object.handle_configure(payload.unpack1("V")) if opcode == 0
           when XdgToplevel
             handle_xdg_toplevel_event(object_id, opcode, payload)
           end
@@ -30,14 +40,29 @@ module RBGL
 
         private
 
-        def handle_registry_event(opcode, payload)
-          return unless opcode == 0
+        def handle_display_event(opcode, payload)
+          case opcode
+          when 0
+            failed_object, code, length = payload.byteslice(0, 12).unpack("VVV")
+            message = payload.byteslice(12, length - 1)
+            raise GUI::BackendUnavailable,
+                  "Wayland protocol error #{code} on object #{failed_object}: #{message}"
+          when 1
+            @connection.unregister_object(payload.unpack1("V"))
+          end
+        end
 
-          name = payload[0, 4].unpack1("V")
-          interface_length = payload[4, 4].unpack1("V")
-          interface = payload[8, interface_length - 1]
-          version = payload[8 + @codec.pad_length(interface_length), 4].unpack1("V")
-          @connection.store_global(interface, name: name, version: version)
+        def handle_registry_event(opcode, payload)
+          case opcode
+          when 0
+            name = payload[0, 4].unpack1("V")
+            interface_length = payload[4, 4].unpack1("V")
+            interface = payload[8, interface_length - 1]
+            version = payload[8 + @codec.pad_length(interface_length), 4].unpack1("V")
+            @connection.store_global(interface, name: name, version: version)
+          when 1
+            @connection.remove_global(payload.unpack1("V"))
+          end
         end
 
         def handle_xdg_wm_base_event(object, opcode, payload)
@@ -47,11 +72,77 @@ module RBGL
           @connection.flush
         end
 
-        def handle_xdg_surface_event(object, opcode, payload)
-          return unless opcode == 0
+        def handle_keyboard_event(keyboard, opcode, payload)
+          case opcode
+          when 0
+            format, size = payload.unpack("V2")
+            keyboard.handle_keymap(format, size, @connection.consume_received_fd)
+          when 1
+            keyboard.focus(payload.byteslice(4, 4).unpack1("V"))
+          when 2
+            keyboard.blur
+          when 3
+            _serial, _time, keycode, state = payload.unpack("V4")
+            event = {
+              type: state == 1 ? :key_press : :key_release,
+              surface_id: keyboard.focused_surface_id,
+              key: InputMapper.key(keycode),
+              keycode: keycode
+            }
+            event[:modifiers] = keyboard.modifiers.dup unless keyboard.modifiers.empty?
+            @connection.queue_event(event)
+          when 4
+            _serial, depressed, latched, locked, group = payload.unpack("V5")
+            keyboard.handle_modifiers(
+              depressed: depressed,
+              latched: latched,
+              locked: locked,
+              group: group
+            )
+          end
+        end
 
-          object.ack_configure(payload.unpack1("V"))
-          @connection.flush
+        def handle_pointer_event(pointer, opcode, payload)
+          case opcode
+          when 0
+            _serial, surface_id, x, y = payload.unpack("VVl<l<")
+            pointer.focus(surface_id)
+            queue_pointer_motion(pointer, x, y)
+          when 1
+            pointer.blur
+          when 2
+            _time, x, y = payload.unpack("Vl<l<")
+            queue_pointer_motion(pointer, x, y)
+          when 3
+            _serial, _time, button, state = payload.unpack("V4")
+            @connection.queue_event(
+              type: state == 1 ? :pointer_button_press : :pointer_button_release,
+              surface_id: pointer.focused_surface_id,
+              button: InputMapper.button(button),
+              x: pointer.x,
+              y: pointer.y
+            )
+          when 4
+            _time, axis, value = payload.unpack("VVl<")
+            @connection.queue_event(
+              type: :pointer_axis,
+              surface_id: pointer.focused_surface_id,
+              axis: { 0 => :vertical, 1 => :horizontal }.fetch(axis, axis),
+              value: value / 256.0,
+              x: pointer.x,
+              y: pointer.y
+            )
+          end
+        end
+
+        def queue_pointer_motion(pointer, fixed_x, fixed_y)
+          pointer.move(fixed_x / 256.0, fixed_y / 256.0)
+          @connection.queue_event(
+            type: :pointer_motion,
+            surface_id: pointer.focused_surface_id,
+            x: pointer.x,
+            y: pointer.y
+          )
         end
 
         def handle_xdg_toplevel_event(object_id, opcode, payload)

data/lib/rbgl/gui/wayland/global_binder.rb

@@ -9,9 +9,10 @@ module RBGL
         BINDINGS = {
           "wl_compositor" => [:compositor, Compositor, 4],
           "wl_shm" => [:shm, Shm, 1],
-          "xdg_wm_base" => [:xdg_wm_base, XdgWmBase, 2]
+          "xdg_wm_base" => [:xdg_wm_base, XdgWmBase, 2],
+          "wl_seat" => [:seat, Seat, 5]
         }.freeze
-        REQUIRED_INTERFACES = BINDINGS.keys.freeze
+        REQUIRED_INTERFACES = %w[wl_compositor wl_shm xdg_wm_base].freeze
 
         def initialize(connection)
           @connection = connection
@@ -25,8 +26,9 @@ module RBGL
             global = globals[interface]
             next unless global
 
-            object_id = registry.bind(global[:name], interface, [global[:version], max_version].min)
-            bound[slot] = @connection.register_object(klass.new(@connection, object_id))
+            version = [global[:version], max_version].min
+            object_id = registry.bind(global[:name], interface, version)
+            bound[slot] = @connection.register_object(klass.new(@connection, object_id, version: version))
           end
         end
 

data/lib/rbgl/gui/wayland/input_mapper.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    module Wayland
+      module InputMapper
+        KEY_NAMES = {
+          1 => :escape,
+          14 => :backspace,
+          15 => :tab,
+          28 => :enter,
+          29 => :left_control,
+          42 => :left_shift,
+          54 => :right_shift,
+          56 => :left_alt,
+          57 => :space,
+          58 => :caps_lock,
+          87 => :f11,
+          88 => :f12,
+          97 => :right_control,
+          100 => :right_alt,
+          102 => :home,
+          103 => :up,
+          104 => :page_up,
+          105 => :left,
+          106 => :right,
+          107 => :end,
+          108 => :down,
+          109 => :page_down,
+          110 => :insert,
+          111 => :delete,
+          125 => :left_meta,
+          126 => :right_meta
+        }.merge(
+          (2..10).zip(%i[one two three four five six seven eight nine]).to_h,
+          { 11 => :zero },
+          (16..25).zip(%i[q w e r t y u i o p]).to_h,
+          (30..38).zip(%i[a s d f g h j k l]).to_h,
+          (44..50).zip(%i[z x c v b n m]).to_h,
+          (59..68).zip(%i[f1 f2 f3 f4 f5 f6 f7 f8 f9 f10]).to_h
+        ).freeze
+
+        POINTER_BUTTONS = {
+          0x110 => 1,
+          0x111 => 3,
+          0x112 => 2
+        }.freeze
+
+        module_function
+
+        def key(code)
+          KEY_NAMES.fetch(code, code)
+        end
+
+        def button(code)
+          POINTER_BUTTONS.fetch(code, code)
+        end
+      end
+    end
+  end
+end

data/lib/rbgl/gui/wayland/protocol_objects/arguments.rb

@@ -35,16 +35,28 @@ module RBGL
       end
 
       class WaylandObject
-        attr_reader :id, :connection
+        attr_reader :id, :connection, :version
 
-        def initialize(connection, id)
+        def initialize(connection, id, version: 1)
           @connection = connection
           @id = id
+          @version = version
+          @destroyed = false
         end
 
         def send_request(opcode, *args)
           @connection.send_request(@id, opcode, *args)
         end
+
+        private
+
+        def release(opcode, since: 1)
+          return if @destroyed
+
+          send_request(opcode) if @version >= since
+          @connection.unregister_object(@id) if @connection.respond_to?(:unregister_object)
+          @destroyed = true
+        end
       end
     end
   end

data/lib/rbgl/gui/wayland/protocol_objects/seat.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    module Wayland
+      class Seat < WaylandObject
+        POINTER_CAPABILITY = 1
+        KEYBOARD_CAPABILITY = 2
+
+        attr_reader :keyboard, :pointer
+
+        def handle_capabilities(capabilities)
+          update_pointer(capabilities & POINTER_CAPABILITY != 0)
+          update_keyboard(capabilities & KEYBOARD_CAPABILITY != 0)
+        end
+
+        def destroy
+          @pointer&.destroy
+          @keyboard&.destroy
+          release(3, since: 5)
+        end
+
+        private
+
+        def update_pointer(available)
+          @pointer ||= create_pointer if available
+          return if available || !@pointer
+
+          @pointer.destroy
+          @pointer = nil
+        end
+
+        def update_keyboard(available)
+          @keyboard ||= create_keyboard if available
+          return if available || !@keyboard
+
+          @keyboard.destroy
+          @keyboard = nil
+        end
+
+        def create_pointer
+          object_id = @connection.allocate_id
+          send_request(0, Arguments.new_id(object_id))
+          @connection.register_object(Pointer.new(@connection, object_id, version: @version))
+        end
+
+        def create_keyboard
+          object_id = @connection.allocate_id
+          send_request(1, Arguments.new_id(object_id))
+          @connection.register_object(Keyboard.new(@connection, object_id, version: @version))
+        end
+      end
+
+      class Keyboard < WaylandObject
+        attr_reader :focused_surface_id, :keymap, :keymap_format, :modifiers
+
+        def initialize(...)
+          super
+          @modifiers = {}
+        end
+
+        def focus(surface_id)
+          @focused_surface_id = surface_id
+        end
+
+        def blur
+          @focused_surface_id = nil
+        end
+
+        def handle_keymap(format, size, io)
+          raise GUI::BackendUnavailable, "Wayland keymap event did not include a file descriptor" unless io
+
+          @keymap_format = { 0 => :none, 1 => :xkb_v1 }.fetch(format, format)
+          @keymap = io.read(size)&.delete_suffix("\x00")
+        ensure
+          io&.close
+        end
+
+        def handle_modifiers(depressed:, latched:, locked:, group:)
+          @modifiers = {
+            depressed: depressed,
+            latched: latched,
+            locked: locked,
+            group: group
+          }
+        end
+
+        def destroy
+          release(0, since: 3)
+        end
+      end
+
+      class Pointer < WaylandObject
+        attr_reader :focused_surface_id, :x, :y
+
+        def focus(surface_id)
+          @focused_surface_id = surface_id
+        end
+
+        def blur
+          @focused_surface_id = nil
+        end
+
+        def move(x, y)
+          @x = x
+          @y = y
+        end
+
+        def destroy
+          release(1, since: 3)
+        end
+      end
+    end
+  end
+end

data/lib/rbgl/gui/wayland/protocol_objects/shm.rb

@@ -4,9 +4,9 @@ module RBGL
   module GUI
     module Wayland
       class Shm < WaylandObject
-        def create_pool(fd, size)
+        def create_pool(file, size)
           pool_id = @connection.allocate_id
-          @connection.send_request_with_fd(@id, 0, Arguments.new_id(pool_id), Arguments.int(size), fd)
+          @connection.send_request_with_fd(@id, 0, Arguments.new_id(pool_id), Arguments.int(size), file)
           @connection.register_object(ShmPool.new(@connection, pool_id))
         end
       end
@@ -17,7 +17,8 @@ module RBGL
           format_val = case format
                        when :argb8888 then 0
                        when :xrgb8888 then 1
-                       else 0
+                       else
+                         raise ArgumentError, "Unsupported Wayland SHM format: #{format}"
                        end
           send_request(
             0,
@@ -67,10 +68,10 @@ module RBGL
           finalize_destroy if @destroy_requested
         end
 
-        def destroy
-          return if @destroyed || @destroy_requested
+        def destroy(force: false)
+          return if @destroyed || (@destroy_requested && !force)
 
-          if @busy
+          if @busy && !force
             @destroy_requested = true
           else
             finalize_destroy
@@ -119,12 +120,19 @@ module RBGL
           @wl_buffer.id
         end
 
-        def destroy
+        def destroy(force: false)
           return if @destroyed
 
           @destroy_requested = true
-          @wl_buffer.destroy
-          finalize_destroy unless @wl_buffer.busy?
+          begin
+            force ? @wl_buffer.destroy(force: true) : @wl_buffer.destroy
+          ensure
+            finalize_destroy if force || !@wl_buffer.busy?
+          end
+        end
+
+        def destroyed?
+          @destroyed
         end
 
         private
@@ -136,9 +144,12 @@ module RBGL
         def finalize_destroy
           return if @destroyed
 
-          @pool.destroy
-          @file.close unless @file.closed?
-          @destroyed = true
+          begin
+            @pool.destroy
+          ensure
+            @file.close unless @file.closed?
+            @destroyed = true
+          end
         end
       end
     end

data/lib/rbgl/gui/wayland/protocol_objects/xdg_shell.rb

@@ -16,6 +16,15 @@ module RBGL
       end
 
       class XdgSurface < WaylandObject
+        def initialize(connection, id)
+          super
+          @configured = false
+        end
+
+        def configured?
+          @configured
+        end
+
         def get_toplevel
           toplevel_id = @connection.allocate_id
           send_request(1, Arguments.new_id(toplevel_id))
@@ -26,6 +35,12 @@ module RBGL
           send_request(4, Arguments.uint(serial))
         end
 
+        def handle_configure(serial)
+          ack_configure(serial)
+          @connection.flush
+          @configured = true
+        end
+
         def destroy
           send_request(0)
         end

data/lib/rbgl/gui/wayland/protocol_objects.rb

@@ -4,4 +4,5 @@ require_relative "protocol_objects/arguments"
 require_relative "protocol_objects/display"
 require_relative "protocol_objects/surface"
 require_relative "protocol_objects/shm"
+require_relative "protocol_objects/seat"
 require_relative "protocol_objects/xdg_shell"

data/lib/rbgl/gui/window/render_loop.rb

@@ -5,39 +5,60 @@ module RBGL
     class Window
       class RenderLoop
         DEFAULT_TIME_SOURCE = -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
+        DEFAULT_SLEEPER = ->(duration) { sleep(duration) }
+        FPS_WINDOW_SECONDS = 1.0
 
         attr_reader :fps, :dropped_frames
 
-        def initialize(time_source: DEFAULT_TIME_SOURCE)
+        def initialize(time_source: DEFAULT_TIME_SOURCE, sleeper: DEFAULT_SLEEPER, target_fps: 60)
           @time_source = time_source
+          @sleeper = sleeper
+          @frame_interval = target_fps && (1.0 / validate_target_fps(target_fps))
           @fps = 0
           @dropped_frames = 0
           @running = false
+          @frame_times = []
         end
 
         def run(backend:, context:, process_events:, &frame_callback)
-          @running = true
-          start_time = @time_source.call
-          last_time = start_time
-          frame_count = 0
+          start
 
           while @running && !backend.should_close?
-            current_time = @time_source.call
-            delta_time = current_time - last_time
-            last_time = current_time
-
-            process_events.call
-            break if stop_requested?(backend)
-            frame_callback&.call(context, delta_time)
-            break if stop_requested?(backend)
-            record_present_result(backend.present(context.framebuffer))
-
-            frame_count += 1
-            elapsed = current_time - start_time
-            @fps = frame_count / elapsed if elapsed.positive?
+            frame_finished_at = step(backend:, context:, process_events:, &frame_callback)
+            break unless frame_finished_at
+
+            throttle(@next_frame_deadline, frame_finished_at)
+            @next_frame_deadline = advance_deadline(@next_frame_deadline, frame_finished_at)
           end
         end
 
+        def start(now: nil)
+          @running = true
+          @last_time = now.nil? ? @time_source.call : Float(now)
+          @next_frame_deadline = @frame_interval && (@last_time + @frame_interval)
+          @frame_times.clear
+        end
+
+        def step(backend:, context:, process_events:, now: nil, &frame_callback)
+          start(now:) if @last_time.nil?
+          return false unless @running
+          return false if backend.should_close?
+
+          frame_started_at = now.nil? ? @time_source.call : Float(now)
+          delta_time = frame_started_at - @last_time
+          @last_time = frame_started_at
+
+          process_events.call
+          return false if stop_requested?(backend)
+          frame_callback&.call(context, delta_time)
+          return false if stop_requested?(backend)
+
+          record_present_result(backend.present(context.framebuffer))
+          @last_frame_finished_at = now.nil? ? @time_source.call : frame_started_at
+          record_frame(@last_frame_finished_at)
+          @last_frame_finished_at
+        end
+
         def record_present_result(result)
           @dropped_frames += 1 if result == false
           result
@@ -49,6 +70,38 @@ module RBGL
 
         private
 
+        def record_frame(timestamp)
+          @frame_times << timestamp
+          cutoff = timestamp - FPS_WINDOW_SECONDS
+          @frame_times.shift while @frame_times.length > 2 && @frame_times.first < cutoff
+          return @fps = 0 if @frame_times.length < 2
+
+          elapsed = @frame_times.last - @frame_times.first
+          @fps = elapsed.positive? ? (@frame_times.length - 1) / elapsed : 0
+        end
+
+        def throttle(deadline, frame_finished_at)
+          return unless deadline
+
+          remaining = deadline - frame_finished_at
+          @sleeper.call(remaining) if remaining.positive?
+        end
+
+        def advance_deadline(deadline, frame_finished_at)
+          return unless deadline
+
+          [deadline, frame_finished_at].max + @frame_interval
+        end
+
+        def validate_target_fps(target_fps)
+          fps = Float(target_fps)
+          return fps if fps.positive?
+
+          raise ArgumentError, "target_fps must be positive or nil"
+        rescue ArgumentError, TypeError
+          raise ArgumentError, "target_fps must be positive or nil"
+        end
+
         def stop_requested?(backend)
           !@running || backend.should_close?
         end