rbgl 0.1.0 → 1.0.1

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    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, 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)
+          start
+
+          while @running && !backend.should_close?
+            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
+        end
+
+        def stop
+          @running = false
+        end
+
+        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
+      end
+    end
+  end
+end

data/lib/rbgl/gui/window.rb

@@ -1,87 +1,72 @@
 # frozen_string_literal: true
 
+require_relative "window/render_loop"
+require_relative "window/event_dispatcher"
+
 module RBGL
   module GUI
     class Window
       attr_reader :context, :backend, :width, :height
 
-      def initialize(width:, height:, title: "RBGL", backend: :auto, **options)
+      def initialize(width:, height:, title: "RBGL", backend: :auto, target_fps: 60, **options)
         @width = width
         @height = height
         @title = title
+        @render_loop = RenderLoop.new(target_fps: target_fps)
         @context = Engine::Context.new(width: width, height: height)
-
-        @backend = case backend
-                   when :auto, :native
-                     detect_backend(width, height, title)
-                   when :file
-                     FileBackend.new(width, height, title, **options)
-                   when :x11
-                     require_relative "x11/backend"
-                     X11::Backend.new(width, height, title)
-                   when :wayland
-                     require_relative "wayland/backend"
-                     Wayland::Backend.new(width, height, title)
-                   when :cocoa
-                     require_relative "cocoa/backend"
-                     Cocoa::Backend.new(width, height, title)
-                   when Backend
-                     backend
-                   else
-                     raise "Unknown backend: #{backend}"
-                   end
-
-        @running = false
-        @frame_callback = nil
-        @last_time = Time.now
-        @fps = 0
-        @frame_count = 0
+        @backend = build_backend(backend, width: width, height: height, title: title, **options)
         @event_handlers = Hash.new { |h, k| h[k] = [] }
+        @event_dispatcher = EventDispatcher.new(
+          backend: @backend,
+          event_handlers: @event_handlers,
+          on_resize: method(:apply_resize)
+        )
+        @closed = false
       end
 
       def on(event_type, &block)
+        validate_event_handler!(event_type, block)
         @event_handlers[event_type] << block
       end
 
-      def on_key(&block)
-        @backend.on_key(&block)
-      end
-
-      def on_mouse(&block)
-        @backend.on_mouse(&block)
-      end
-
       def run(&frame_callback)
-        @frame_callback = frame_callback
-        @running = true
-        @start_time = Time.now
-
-        while @running && !@backend.should_close?
-          current_time = Time.now
-          delta_time = current_time - @last_time
-          @last_time = current_time
-
-          process_events
-
-          @frame_callback&.call(@context, delta_time)
-
-          @backend.present(@context.framebuffer)
-
-          @frame_count += 1
-          elapsed = current_time - @start_time
-          @fps = @frame_count / elapsed if elapsed > 0
+        raise RuntimeError, "Window#run is one-shot and cannot be called after the window is closed" if @closed
+
+        @render_loop.run(
+          backend: @backend,
+          context: @context,
+          process_events: method(:process_events),
+          &frame_callback
+        )
+      ensure
+        original_error = $!
+        begin
+          close if @backend
+        rescue StandardError
+          raise unless original_error
         end
+      end
 
-        @backend.close
+      # Advances one frame. `now` is seconds on a monotonic timeline.
+      def step(now = nil, &frame_callback)
+        return false if @closed
+
+        !!@render_loop.step(
+          backend: @backend,
+          context: @context,
+          process_events: method(:process_events),
+          now:,
+          &frame_callback
+        )
       end
 
       def stop
-        @running = false
+        @render_loop.stop
       end
 
       def present_framebuffer(framebuffer = nil)
         fb = framebuffer || @context.framebuffer
-        @backend.present(fb)
+        @render_loop.record_present_result(@backend.present(fb))
       end
 
       def set_pixels(buffer)
@@ -89,11 +74,11 @@ module RBGL
       end
 
       def metal_available?
-        @backend.metal_available?
+        @backend.respond_to?(:metal_available?) && @backend.metal_available?
       end
 
       def native_handle
-        @backend.native_handle
+        @backend.native_handle if @backend.respond_to?(:native_handle)
       end
 
       def should_close?
@@ -101,47 +86,52 @@ module RBGL
       end
 
       def poll_events_raw
-        @backend.poll_events_raw
+        events = @backend.poll_events_raw
+        Array(events).each do |event|
+          next unless event.respond_to?(:[]) && event[:type] == :resize
+
+          apply_resize(Event.new(:resize, width: event[:width], height: event[:height]))
+        end
+        events
       end
 
       def close
+        return if @closed
+
+        @render_loop.stop
         @backend.close
+        @closed = true
       end
 
-      attr_reader :fps
+      def fps
+        @render_loop.fps
+      end
+
+      def dropped_frames
+        @render_loop.dropped_frames
+      end
 
       private
 
-      def detect_backend(width, height, title)
-        case RUBY_PLATFORM
-        when /darwin/
-          require_relative "cocoa/backend"
-          Cocoa::Backend.new(width, height, title)
-        when /linux/
-          if ENV["WAYLAND_DISPLAY"]
-            require_relative "wayland/backend"
-            Wayland::Backend.new(width, height, title)
-          elsif ENV["DISPLAY"]
-            require_relative "x11/backend"
-            X11::Backend.new(width, height, title)
-          else
-            raise "No display server found (DISPLAY or WAYLAND_DISPLAY not set)"
-          end
-        else
-          raise "Unsupported platform: #{RUBY_PLATFORM}"
-        end
+      def build_backend(backend, width:, height:, title:, **options)
+        BackendFactory.build(backend, width: width, height: height, title: title, **options)
       end
 
       def process_events
-        events = @backend.poll_events
+        @event_dispatcher.process
+      end
 
-        return unless events.is_a?(Array)
+      def apply_resize(event)
+        @backend.resize(event.width, event.height)
+        @context.resize(width: event.width, height: event.height)
+        @width = event.width
+        @height = event.height
+      end
 
-        events.each do |event|
-          next unless event.is_a?(Event)
+      def validate_event_handler!(event_type, block)
+        return if block
 
-          @event_handlers[event.type].each { |handler| handler.call(event) }
-        end
+        raise ArgumentError, "A block is required for #{event_type} handlers"
       end
     end
   end

data/lib/rbgl/gui/x11/atom_cache.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    module X11
+      class AtomCache
+        BUILTIN_ATOMS = {
+          wm_name: 39,
+          string: 31,
+          atom: 4
+        }.freeze
+
+        def initialize(&resolver)
+          @resolver = resolver
+          @cache = BUILTIN_ATOMS.dup
+        end
+
+        def fetch(name)
+          return name if name.is_a?(Integer)
+          return @cache[name] if @cache.key?(name)
+
+          resolved = @resolver.call(name)
+          @cache[name] = resolved
+          resolved
+        end
+      end
+    end
+  end
+end

data/lib/rbgl/gui/x11/backend.rb

@@ -1,16 +1,24 @@
 # frozen_string_literal: true
 
 require_relative "connection"
+require_relative "pixel_encoder"
 
 module RBGL
   module GUI
     module X11
       class Backend < GUI::Backend
-        def initialize(width, height, title = "RBGL")
-          super
-          @display = Connection.new(ENV["DISPLAY"] || ":0")
-          @windows = {}
+        def initialize(width, height, title = "RBGL", env: ENV, reply_timeout: Connection::DEFAULT_REPLY_TIMEOUT)
+          super(width, height, title)
+          @display = Connection.new(env["DISPLAY"] || ":0", env: env, reply_timeout: reply_timeout)
+          @window = nil
           setup_window(width, height, title)
+        rescue StandardError => error
+          begin
+            close
+          rescue StandardError
+            nil
+          end
+          raise error
         end
 
         private def setup_window(w, h, t)
@@ -35,42 +43,54 @@ module RBGL
           )
 
           @display.change_property(wid, :wm_name, :string, t)
+          @display.enable_wm_delete_window(wid)
           @display.map_window(wid)
           @display.flush
 
           gc_id = @display.generate_id
           @display.create_gc(gc_id, wid)
 
-          @windows[wid] = {
+          @window = {
+            id: wid,
             width: w,
             height: h,
             gc: gc_id,
             should_close: false
           }
-
-          @handle = wid
         end
 
         def present(framebuffer)
-          return unless @handle
-
-          window = @windows[@handle]
-          return unless window
+          return false unless @window
 
           buffer = convert_to_x11_format(framebuffer)
+          present_bytes(buffer, framebuffer.width, framebuffer.height)
+        end
+
+        def set_pixels(buffer, width, height)
+          return false unless @window
+
+          bytes = validate_rgba_buffer(buffer, width, height)
+          present_bytes(pixel_encoder.encode_rgba(bytes, width, height), width, height)
+        end
+
+        private def present_bytes(buffer, width, height)
+          window = @window
+          return false unless window
 
           @display.put_image(
             format: :z_pixmap,
-            drawable: @handle,
+            drawable: window[:id],
             gc: window[:gc],
-            width: framebuffer.width,
-            height: framebuffer.height,
+            width: width,
+            height: height,
             dst_x: 0, dst_y: 0,
             depth: @display.root_depth,
-            data: buffer
+            data: buffer,
+            bytes_per_line: pixel_encoder.bytes_per_line(width)
           )
 
           @display.flush
+          true
         end
 
         def poll_events
@@ -81,42 +101,60 @@ module RBGL
             next unless raw_event
 
             event = convert_event(raw_event)
-            if event
-              events << event
-              emit_from_event(event)
-            end
+            events << event if event
           end
 
           events
         end
 
         def should_close?
-          return false unless @handle
-
-          @windows[@handle]&.[](:should_close) || false
+          @window.nil? || @window[:should_close]
         end
 
         def close
-          return unless @handle
+          window = @window
+          operations = []
+          if window
+            window[:should_close] = true
+            operations << -> { @display.destroy_window(window[:id]) }
+            operations << -> { @display.flush }
+          end
+          operations << -> { @display&.close }
 
-          @windows[@handle][:should_close] = true
-          @display.destroy_window(@handle)
-          @windows.delete(@handle)
+          error = nil
+          operations.each do |operation|
+            operation.call
+          rescue StandardError => cleanup_error
+            error ||= cleanup_error
+          end
+          @window = nil
+          raise error if error
         end
 
         private
 
         def convert_to_x11_format(framebuffer)
-          # X11 uses BGRX format (blue, green, red, padding)
-          framebuffer.to_bgra_bytes
+          pixel_encoder.encode(framebuffer)
+        end
+
+        def pixel_encoder
+          @pixel_encoder ||= PixelEncoder.new(
+            bits_per_pixel: @display.bits_per_pixel,
+            scanline_pad: @display.scanline_pad,
+            visual_class: @display.visual_class,
+            red_mask: @display.red_mask,
+            green_mask: @display.green_mask,
+            blue_mask: @display.blue_mask,
+            image_byte_order: @display.image_byte_order
+          )
         end
 
         def convert_event(raw)
           case raw[:type]
           when :key_press
-            Event.new(:key_press, key: raw[:keycode])
+            Event.new(:key_press, key: @display.key_for_keycode(raw[:keycode]), keycode: raw[:keycode])
           when :key_release
-            Event.new(:key_release, key: raw[:keycode])
+            Event.new(:key_release, key: @display.key_for_keycode(raw[:keycode]), keycode: raw[:keycode])
           when :button_press
             Event.new(:mouse_press, x: raw[:x], y: raw[:y], button: raw[:button])
           when :button_release
@@ -126,30 +164,16 @@ module RBGL
           when :configure_notify
             Event.new(:resize, width: raw[:width], height: raw[:height])
           when :client_message
-            if @handle && @windows[@handle]
-              @windows[@handle][:should_close] = true
-            end
+            return nil unless @window && raw[:window] == @window[:id]
+            return nil unless raw[:message_type] == @display.wm_protocols_atom
+            return nil unless raw[:data32]&.first == @display.wm_delete_window_atom
+
+            @window[:should_close] = true
             Event.new(:close)
           else
             nil
           end
         end
-
-        def emit_from_event(event)
-          case event.type
-          when :key_press, :key_release
-            emit_key(event.key, event.type == :key_press ? :press : :release)
-          when :mouse_press, :mouse_release, :mouse_move
-            action = case event.type
-                     when :mouse_press then :press
-                     when :mouse_release then :release
-                     else :move
-                     end
-            emit_mouse(event.x, event.y, event[:button], action)
-          when :resize
-            emit_resize(event.width, event.height)
-          end
-        end
       end
     end
   end