rbgl 0.1.0 → 1.0.0

data/lib/rbgl/gui/backend.rb

@@ -2,16 +2,19 @@
 
 module RBGL
   module GUI
+    class BackendUnavailable < StandardError
+    end
+
+    class BackendSelectionError < ArgumentError
+    end
+
     class Backend
       attr_reader :width, :height, :title
 
-      def initialize(width, height, title = "RBGL")
+      def initialize(width, height, title = "RBGL", **_options)
         @width = width
         @height = height
         @title = title
-        @key_callback = nil
-        @mouse_callback = nil
-        @resize_callback = nil
       end
 
       def present(_framebuffer)
@@ -26,6 +29,11 @@ module RBGL
         []
       end
 
+      def resize(width, height)
+        @width = width
+        @height = height
+      end
+
       def should_close?
         raise NotImplementedError
       end
@@ -45,32 +53,6 @@ module RBGL
       def native_handle
         nil
       end
-
-      def on_key(&block)
-        @key_callback = block
-      end
-
-      def on_mouse(&block)
-        @mouse_callback = block
-      end
-
-      def on_resize(&block)
-        @resize_callback = block
-      end
-
-      protected
-
-      def emit_key(key, action)
-        @key_callback&.call(key, action)
-      end
-
-      def emit_mouse(x, y, button, action)
-        @mouse_callback&.call(x, y, button, action)
-      end
-
-      def emit_resize(width, height)
-        @resize_callback&.call(width, height)
-      end
     end
   end
 end

data/lib/rbgl/gui/backend_factory.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    class BackendFactory
+      AUTO_BACKEND_ERRORS = [LoadError, SystemCallError, BackendUnavailable].freeze
+
+      class << self
+        def build(backend, width:, height:, title:, platform: RUBY_PLATFORM, env: ENV, **options)
+          case backend
+          when :auto
+            build_auto_backend(
+              width: width,
+              height: height,
+              title: title,
+              platform: platform,
+              env: env,
+              **options
+            )
+          else
+            build_specific_backend(backend, width: width, height: height, title: title, env: env, **options)
+          end
+        end
+
+        private
+
+        def build_auto_backend(width:, height:, title:, platform:, env:, builder: nil, **options)
+          builder ||= method(:build_specific_backend)
+          errors = []
+
+          native_backend_candidates(platform: platform, env: env).each do |candidate|
+            return builder.call(candidate, width: width, height: height, title: title, env: env, **options)
+          rescue *AUTO_BACKEND_ERRORS => error
+            errors << [candidate, error]
+          end
+
+          raise_auto_backend_error(errors)
+        end
+
+        def build_specific_backend(backend, width:, height:, title:, env: ENV, **options)
+          case backend
+          when :file
+            FileBackend.new(width, height, title, **options)
+          when :x11
+            require_relative "x11/backend"
+            X11::Backend.new(width, height, title, env: env)
+          when :wayland
+            require_relative "wayland/backend"
+            Wayland::Backend.new(width, height, title, env: env)
+          when :cocoa
+            require_relative "cocoa/backend"
+            Cocoa::Backend.new(width, height, title, env: env)
+          when Backend
+            backend
+          else
+            raise BackendSelectionError, "Unknown backend: #{backend}"
+          end
+        end
+
+        def raise_auto_backend_error(errors)
+          return if errors.empty?
+
+          details = errors.map { |backend, error| "#{backend}: #{error.class}: #{error.message}" }.join(", ")
+          raise BackendUnavailable, "Failed to initialize any native backend (#{details})"
+        end
+
+        def native_backend_candidates(platform:, env:)
+          case platform
+          when /darwin/
+            [:cocoa]
+          when /linux/
+            candidates = []
+            candidates << :wayland if env["WAYLAND_DISPLAY"]
+            candidates << :x11 if env["DISPLAY"]
+            return candidates unless candidates.empty?
+
+            raise BackendUnavailable, "No display server found (DISPLAY or WAYLAND_DISPLAY not set)"
+          else
+            raise BackendUnavailable, "Unsupported platform: #{platform}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,48 +1,40 @@
 # frozen_string_literal: true
 
-begin
-  require "metaco"
-  METACO_AVAILABLE = true
-rescue LoadError
-  METACO_AVAILABLE = false
-end
-
 module RBGL
   module GUI
     module Cocoa
+      METACO_AVAILABLE = begin
+        require "metaco"
+        true
+      rescue LoadError
+        false
+      end
+
       class Backend < GUI::Backend
-        def initialize(width, height, title = "RBGL")
+        def initialize(width, height, title = "RBGL", env: ENV)
+          @env = env
           unless METACO_AVAILABLE
             raise LoadError, "metaco gem is required for Cocoa backend. Install it with: gem install metaco"
           end
 
-          super
+          super(width, height, title)
           Metaco.init
           @handle = Metaco.window_create(width, height, title)
         end
 
         def present(framebuffer)
-          return unless @handle
+          return false unless @handle
 
           Metaco.set_pixels(@handle, framebuffer.to_rgba_bytes, framebuffer.width, framebuffer.height)
           Metaco.present(@handle)
+          true
         end
 
         def poll_events
           return [] unless @handle
 
           raw_events = Metaco.poll_events(@handle)
-          events = []
-
-          raw_events.each do |e|
-            event = convert_event(e)
-            if event
-              events << event
-              emit_from_event(event)
-            end
-          end
-
-          events
+          raw_events.filter_map { |event| convert_event(event) }
         end
 
         def poll_events_raw
@@ -97,24 +89,12 @@ module RBGL
             Event.new(:mouse_release, x: raw[:x], y: raw[:y], button: raw[:button])
           when :mouse_move
             Event.new(:mouse_move, x: raw[:x], y: raw[:y])
+          when :resize
+            Event.new(:resize, width: raw[:width], height: raw[:height])
           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)
-          end
-        end
       end
     end
   end

data/lib/rbgl/gui/file_backend/bmp_writer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    class FileBackend < Backend
+      class BmpWriter < FrameWriter
+        def extension
+          "bmp"
+        end
+
+        def write(filename, framebuffer)
+          File.binwrite(filename, encode(framebuffer))
+        end
+
+        private
+
+        def encode(framebuffer)
+          width = framebuffer.width
+          height = framebuffer.height
+          row_size = ((24 * width + 31) / 32) * 4
+          pixel_data_size = row_size * height
+          file_size = 54 + pixel_data_size
+
+          header = [
+            0x42, 0x4D,
+            file_size,
+            0, 0,
+            54
+          ].pack("CCVvvV")
+
+          dib = [
+            40,
+            width, height,
+            1,
+            24,
+            0,
+            pixel_data_size,
+            2835, 2835,
+            0, 0
+          ].pack("VVVvvVVVVVV")
+
+          header + dib + pixel_rows(framebuffer, width, height, row_size)
+        end
+
+        def pixel_rows(framebuffer, width, height, row_size)
+          pixels = +""
+
+          (height - 1).downto(0) do |y|
+            row = +""
+            width.times do |x|
+              bytes = framebuffer.get_pixel(x, y).to_bytes
+              row << [bytes[2], bytes[1], bytes[0]].pack("CCC")
+            end
+            row << "\x00" * (row_size - width * 3)
+            pixels << row
+          end
+
+          pixels
+        end
+      end
+    end
+  end
+end

data/lib/rbgl/gui/file_backend/frame_writer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    class FileBackend < Backend
+      class FrameWriter
+        def self.build(format, ppm_mode: :ascii)
+          case format
+          when :ppm
+            PpmWriter.new(binary: ppm_mode == :binary)
+          when :bmp
+            BmpWriter.new
+          else
+            raise ArgumentError, "Unsupported file backend format: #{format}"
+          end
+        end
+
+        def extension
+          raise NotImplementedError
+        end
+
+        def write(_filename, _framebuffer)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/rbgl/gui/file_backend/ppm_writer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    class FileBackend < Backend
+      class PpmWriter < FrameWriter
+        def initialize(binary:)
+          @binary = binary
+        end
+
+        def extension
+          "ppm"
+        end
+
+        def write(filename, framebuffer)
+          if @binary
+            File.binwrite(filename, framebuffer.to_ppm_binary)
+          else
+            File.write(filename, framebuffer.to_ppm)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbgl/gui/file_backend.rb

@@ -1,11 +1,20 @@
 # frozen_string_literal: true
 
+require_relative "file_backend/frame_writer"
+require_relative "file_backend/ppm_writer"
+require_relative "file_backend/bmp_writer"
+
 module RBGL
   module GUI
     class FileBackend < Backend
-      def initialize(width, height, title = "RBGL", format: :ppm, output_dir: ".")
+      SUPPORTED_FORMATS = %i[ppm bmp].freeze
+      PPM_MODES = %i[ascii binary].freeze
+
+      def initialize(width, height, title = "RBGL", format: :ppm, ppm_mode: :ascii, output_dir: ".")
         super(width, height, title)
-        @format = format
+        @format = normalize_format(format)
+        @ppm_mode = normalize_ppm_mode(ppm_mode, @format)
+        @writer = FrameWriter.build(@format, ppm_mode: @ppm_mode)
         @output_dir = output_dir
         @frame_count = 0
         @should_close = false
@@ -13,23 +22,17 @@ module RBGL
       end
 
       def present(framebuffer)
-        filename = File.join(@output_dir, format("frame_%05d.#{@format}", @frame_count))
-
-        case @format
-        when :ppm
-          File.write(filename, framebuffer.to_ppm)
-        when :ppm_binary
-          File.binwrite(filename, framebuffer.to_ppm_binary)
-        when :bmp
-          File.binwrite(filename, to_bmp(framebuffer))
-        end
+        filename = File.join(@output_dir, format("frame_%05d.#{@writer.extension}", @frame_count))
+        @writer.write(filename, framebuffer)
 
         @frame_count += 1
 
         @should_close = true if @max_frames && @frame_count >= @max_frames
+        true
       end
 
       def poll_events
+        []
       end
 
       def should_close?
@@ -46,45 +49,19 @@ module RBGL
 
       private
 
-      def to_bmp(framebuffer)
-        w = framebuffer.width
-        h = framebuffer.height
-        row_size = ((24 * w + 31) / 32) * 4
-        pixel_data_size = row_size * h
-        file_size = 54 + pixel_data_size
+      def normalize_format(format)
+        normalized = format.to_sym
+        return normalized if SUPPORTED_FORMATS.include?(normalized)
 
-        header = [
-          0x42, 0x4D,
-          file_size,
-          0, 0,
-          54
-        ].pack("CCVvvV")
-
-        dib = [
-          40,
-          w, h,
-          1,
-          24,
-          0,
-          pixel_data_size,
-          2835, 2835,
-          0, 0
-        ].pack("VVVvvVVVVVV")
+        raise ArgumentError, "Unsupported file backend format: #{format}"
+      end
 
-        pixels = +""
-        (h - 1).downto(0) do |y|
-          row = +""
-          w.times do |x|
-            color = framebuffer.get_pixel(x, y)
-            bytes = color.to_bytes
-            row << [bytes[2], bytes[1], bytes[0]].pack("CCC")
-          end
-          padding = row_size - w * 3
-          row << "\x00" * padding
-          pixels << row
-        end
+      def normalize_ppm_mode(ppm_mode, format)
+        normalized = ppm_mode.to_sym
+        raise ArgumentError, "Unsupported PPM mode: #{ppm_mode}" unless PPM_MODES.include?(normalized)
+        return normalized if format == :ppm || normalized == :ascii
 
-        header + dib + pixels
+        raise ArgumentError, "PPM mode is only supported with :ppm format"
       end
     end
   end

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

@@ -6,9 +6,12 @@ module RBGL
   module GUI
     module Wayland
       class Backend < GUI::Backend
-        def initialize(width, height, title = "RBGL")
-          super
-          @connection = Connection.new
+        BUFFER_WAIT_TIMEOUT = 0.25
+        BUFFER_POLL_INTERVAL = 0.016
+
+        def initialize(width, height, title = "RBGL", env: ENV, roundtrip_timeout: Connection::DEFAULT_ROUNDTRIP_TIMEOUT)
+          super(width, height, title)
+          @connection = Connection.new(env: env, roundtrip_timeout: roundtrip_timeout)
           @windows = {}
           setup_window(width, height, title)
         end
@@ -19,9 +22,11 @@ module RBGL
           toplevel = xdg_surface.get_toplevel
           toplevel.set_title(t)
 
-          shm_buffer = create_shm_buffer(w, h)
+          buffers = create_shm_buffers(w, h)
+          shm_buffer = buffers.first
 
           surface.attach(shm_buffer, 0, 0)
+          shm_buffer.mark_in_use
           surface.commit
           @connection.flush
 
@@ -30,41 +35,56 @@ module RBGL
             surface: surface,
             xdg_surface: xdg_surface,
             toplevel: toplevel,
+            buffers: buffers,
             shm_buffer: shm_buffer,
             width: w,
             height: h,
-            should_close: false,
-            pending_events: []
+            should_close: false
           }
 
           @handle = handle
         end
 
         def present(framebuffer)
-          return unless @handle
+          return false unless @handle
 
           window = @windows[@handle]
-          return unless window
+          return false unless window
+
+          buffer_object = wait_for_available_buffer(window)
+          return false unless buffer_object
 
           buffer = convert_to_wayland_format(framebuffer)
-          window[:shm_buffer].write(buffer)
+          buffer_object.write(buffer)
 
           window[:surface].damage(0, 0, framebuffer.width, framebuffer.height)
-          window[:surface].attach(window[:shm_buffer], 0, 0)
+          window[:surface].attach(buffer_object, 0, 0)
+          buffer_object.mark_in_use
+          window[:shm_buffer] = buffer_object
           window[:surface].commit
           @connection.flush
+          true
         end
 
         def poll_events
-          events = []
-          @connection.dispatch_pending
+          @connection.dispatch_pending.filter_map { |event| convert_event(event) }
+        end
 
-          if @handle && @windows[@handle]
-            events.concat(@windows[@handle][:pending_events])
-            @windows[@handle][:pending_events] = []
-          end
+        def resize(width, height)
+          super
+          return unless @handle
 
-          events
+          window = @windows[@handle]
+          return unless window
+          return if window[:width] == width && window[:height] == height
+
+          old_buffers = window.fetch(:buffers, [window[:shm_buffer]].compact)
+          new_buffers = create_shm_buffers(width, height)
+          window[:buffers] = new_buffers
+          window[:shm_buffer] = new_buffers.first
+          window[:width] = width
+          window[:height] = height
+          old_buffers.each(&:destroy)
         end
 
         def should_close?
@@ -83,8 +103,9 @@ module RBGL
           window[:toplevel].destroy
           window[:xdg_surface].destroy
           window[:surface].destroy
-          window[:shm_buffer].destroy
+          window.fetch(:buffers, [window[:shm_buffer]].compact).each(&:destroy)
           @windows.delete(@handle)
+          @handle = nil
         end
 
         private
@@ -93,15 +114,77 @@ module RBGL
           framebuffer.to_bgra_bytes
         end
 
+        def convert_event(raw)
+          window = window_for_event(raw[:object_id])
+          return nil unless window
+
+          case raw[:type]
+          when :xdg_toplevel_close
+            window[:should_close] = true
+            Event.new(:close)
+          when :xdg_toplevel_configure
+            width = raw[:width]
+            height = raw[:height]
+            return nil unless width.positive? && height.positive?
+
+            window[:width] = width
+            window[:height] = height
+            Event.new(:resize, width: width, height: height)
+          end
+        end
+
+        def window_for_event(object_id)
+          @windows.values.find { |window| window[:toplevel].id == object_id }
+        end
+
+        def next_available_buffer(window)
+          window.fetch(:buffers, [window[:shm_buffer]].compact).find(&:available?)
+        end
+
+        def wait_for_available_buffer(window)
+          deadline = monotonic_time + BUFFER_WAIT_TIMEOUT
+
+          loop do
+            buffer = next_available_buffer(window)
+            return buffer if buffer
+            return nil if abort_buffer_wait?(window, deadline)
+
+            pump_connection(timeout: remaining_buffer_wait(deadline))
+          end
+        end
+
+        def pump_connection(timeout:)
+          if @connection.respond_to?(:pump_events)
+            @connection.pump_events(timeout: timeout)
+          else
+            sleep(timeout)
+          end
+        end
+
+        def abort_buffer_wait?(window, deadline)
+          window[:should_close] || monotonic_time >= deadline
+        end
+
+        def remaining_buffer_wait(deadline)
+          [deadline - monotonic_time, BUFFER_POLL_INTERVAL].min.clamp(0.0, BUFFER_POLL_INTERVAL)
+        end
+
+        def monotonic_time
+          Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
+
+        def create_shm_buffers(width, height, count = 2)
+          Array.new(count) { create_shm_buffer(width, height) }
+        end
+
         def create_shm_buffer(width, height)
           size = width * height * 4
 
-          fd = create_anonymous_file(size)
-
-          pool = @connection.shm.create_pool(fd, size)
+          file = create_anonymous_file(size)
+          pool = @connection.shm.create_pool(file.fileno, size)
           buffer = pool.create_buffer(0, width, height, width * 4, :argb8888)
 
-          ShmBuffer.new(fd, size, buffer)
+          ShmBuffer.new(file, pool, buffer)
         end
 
         def create_anonymous_file(size)
@@ -110,16 +193,15 @@ module RBGL
 
           file = File.open(path, File::RDWR | File::CREAT | File::EXCL, 0o600)
           file.truncate(size)
-          fd = file.fileno
           File.unlink(path)
-
-          fd
+          file
         rescue Errno::ENOENT
           require "tempfile"
           tmpfile = Tempfile.new("rbgl")
           tmpfile.truncate(size)
-          tmpfile.fileno
+          tmpfile
         end
+
       end
     end
   end