rbgl 0.1.0 → 1.0.1

data/lib/rbgl/gui/file_backend.rb

@@ -1,35 +1,43 @@
 # frozen_string_literal: true
 
+require "fileutils"
+require_relative "file_backend/frame_writer"
+require_relative "file_backend/ppm_writer"
+require_relative "file_backend/bmp_writer"
+require_relative "file_backend/png_writer"
+
 module RBGL
   module GUI
     class FileBackend < Backend
-      def initialize(width, height, title = "RBGL", format: :ppm, output_dir: ".")
+      SUPPORTED_FORMATS = %i[ppm bmp png].freeze
+      PPM_MODES = %i[ascii binary].freeze
+
+      attr_reader :max_frames, :output_dir
+
+      def initialize(width, height, title = "RBGL", format: :ppm, ppm_mode: :ascii, output_dir: ".", max_frames: 1)
         super(width, height, title)
-        @format = format
-        @output_dir = output_dir
+        @format = normalize_format(format)
+        @ppm_mode = normalize_ppm_mode(ppm_mode, @format)
+        @writer = FrameWriter.build(@format, ppm_mode: @ppm_mode)
+        @output_dir = File.expand_path(output_dir)
+        FileUtils.mkdir_p(@output_dir)
         @frame_count = 0
         @should_close = false
-        @max_frames = nil
+        self.max_frames = max_frames
       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?
@@ -40,51 +48,38 @@ module RBGL
         @should_close = true
       end
 
-      def set_max_frames(count)
-        @max_frames = count
+      def max_frames=(count)
+        @max_frames = normalize_max_frames(count)
       end
 
+      alias set_max_frames max_frames=
+
       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
-
-        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")
-
-        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
-
-        header + dib + pixels
+      def normalize_format(format)
+        normalized = format.to_sym
+        return normalized if SUPPORTED_FORMATS.include?(normalized)
+
+        raise ArgumentError, "Unsupported file backend format: #{format}"
+      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
+
+        raise ArgumentError, "PPM mode is only supported with :ppm format"
+      end
+
+      def normalize_max_frames(count)
+        return nil if count.nil?
+
+        normalized = Integer(count)
+        return normalized if normalized.positive?
+
+        raise ArgumentError, "max_frames must be a positive integer or nil"
+      rescue TypeError
+        raise ArgumentError, "max_frames must be a positive integer or nil"
       end
     end
   end

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

@@ -1,16 +1,28 @@
 # frozen_string_literal: true
 
 require_relative "connection"
+require "tempfile"
 
 module RBGL
   module GUI
     module Wayland
       class Backend < GUI::Backend
-        def initialize(width, height, title = "RBGL")
-          super
-          @connection = Connection.new
-          @windows = {}
+        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)
+          @window = nil
+          @retired_buffers = []
+          @connection = Connection.new(env: env, roundtrip_timeout: roundtrip_timeout)
           setup_window(width, height, title)
+        rescue StandardError => error
+          begin
+            close
+          rescue StandardError
+            nil
+          end
+          raise error
         end
 
         private def setup_window(w, h, t)
@@ -19,72 +31,108 @@ module RBGL
           toplevel = xdg_surface.get_toplevel
           toplevel.set_title(t)
 
-          shm_buffer = create_shm_buffer(w, h)
-
-          surface.attach(shm_buffer, 0, 0)
-          surface.commit
-          @connection.flush
-
-          handle = surface.id
-          @windows[handle] = {
+          @window = {
             surface: surface,
             xdg_surface: xdg_surface,
             toplevel: toplevel,
-            shm_buffer: shm_buffer,
+            buffers: [],
+            shm_buffer: nil,
             width: w,
             height: h,
-            should_close: false,
-            pending_events: []
+            should_close: false
           }
 
-          @handle = handle
+          surface.commit
+          @connection.flush
+          wait_for_initial_configure(xdg_surface)
+
+          buffers = create_shm_buffers(w, h)
+          @window[:buffers] = buffers
+          @window[:shm_buffer] = buffers.first
         end
 
         def present(framebuffer)
-          return unless @handle
+          return false unless @window
+
+          present_bytes(convert_to_wayland_format(framebuffer), framebuffer.width, framebuffer.height)
+        end
+
+        def set_pixels(buffer, width, height)
+          return false unless @window
+
+          bytes = validate_rgba_buffer(buffer, width, height)
+          present_bytes(rgba_to_wayland_bytes(bytes), width, height)
+        end
 
-          window = @windows[@handle]
-          return unless window
+        private def present_bytes(buffer, width, height)
+          window = @window
+          return false unless window
+          unless width == window[:width] && height == window[:height]
+            raise ArgumentError, "Framebuffer dimensions must match the Wayland window"
+          end
+
+          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].damage(0, 0, width, height)
+          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)
+          window = @window
+          return super unless window
+          return super if window[:width] == width && window[:height] == height
 
-          events
+          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
+          super
+          (@retired_buffers ||= []).concat(old_buffers)
+          old_buffers.each(&:destroy)
+          @retired_buffers.reject! { |buffer| buffer.respond_to?(:destroyed?) && buffer.destroyed? }
         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 = @windows[@handle]
-          return unless window
+          window = @window
+          operations = []
+          if window
+            window[:should_close] = true
+            operations << -> { window[:toplevel].destroy }
+            operations << -> { window[:xdg_surface].destroy }
+            operations << -> { window[:surface].destroy }
+            buffers = window.fetch(:buffers, [window[:shm_buffer]].compact) + Array(@retired_buffers)
+            operations.concat(buffers.uniq.map { |buffer| -> { buffer.destroy(force: true) } })
+            operations << -> { @connection.flush }
+          end
+          operations << -> { @connection&.close }
 
-          window[:should_close] = true
-          window[:toplevel].destroy
-          window[:xdg_surface].destroy
-          window[:surface].destroy
-          window[:shm_buffer].destroy
-          @windows.delete(@handle)
+          error = nil
+          operations.each do |operation|
+            operation.call
+          rescue StandardError => cleanup_error
+            error ||= cleanup_error
+          end
+          @window = nil
+          @retired_buffers = []
+          raise error if error
         end
 
         private
@@ -93,33 +141,139 @@ module RBGL
           framebuffer.to_bgra_bytes
         end
 
+        def rgba_to_wayland_bytes(buffer)
+          output = String.new(capacity: buffer.bytesize, encoding: Encoding::BINARY)
+          byte_index = 0
+          while byte_index < buffer.bytesize
+            output << buffer.getbyte(byte_index + 2) << buffer.getbyte(byte_index + 1) <<
+                      buffer.getbyte(byte_index) << buffer.getbyte(byte_index + 3)
+            byte_index += 4
+          end
+          output
+        end
+
+        def convert_event(raw)
+          window = window_for_event(raw[:surface_id] || 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?
+
+            Event.new(:resize, width: width, height: height)
+          when :key_press, :key_release
+            Event.new(raw[:type], key: raw[:key], keycode: raw[:keycode], modifiers: raw[:modifiers])
+          when :pointer_motion
+            Event.new(:mouse_move, x: raw[:x], y: raw[:y])
+          when :pointer_button_press
+            Event.new(:mouse_press, button: raw[:button], x: raw[:x], y: raw[:y])
+          when :pointer_button_release
+            Event.new(:mouse_release, button: raw[:button], x: raw[:x], y: raw[:y])
+          when :pointer_axis
+            Event.new(:mouse_scroll, x: raw[:x], y: raw[:y], axis: raw[:axis], value: raw[:value])
+          end
+        end
+
+        def window_for_event(object_id)
+          return unless @window
+          return @window if @window[:toplevel].id == object_id || @window[:surface].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)
+          buffers = []
+          count.times { buffers << create_shm_buffer(width, height) }
+          buffers
+        rescue StandardError => error
+          buffers&.each do |buffer|
+            begin
+              buffer.destroy(force: true)
+            rescue StandardError
+              nil
+            end
+          end
+          raise error
+        end
+
         def create_shm_buffer(width, height)
           size = width * height * 4
 
-          fd = create_anonymous_file(size)
+          file = create_anonymous_file(size)
+          pool = @connection.shm.create_pool(file, size)
+          buffer = pool.create_buffer(0, width, height, width * 4, :xrgb8888)
 
-          pool = @connection.shm.create_pool(fd, size)
-          buffer = pool.create_buffer(0, width, height, width * 4, :argb8888)
-
-          ShmBuffer.new(fd, size, buffer)
+          ShmBuffer.new(file, pool, buffer)
+        rescue StandardError => error
+          begin
+            buffer&.destroy(force: true)
+          rescue StandardError
+            nil
+          end
+          begin
+            pool&.destroy
+          rescue StandardError
+            nil
+          end
+          file&.close unless file&.closed?
+          raise error
         end
 
         def create_anonymous_file(size)
-          name = "rbgl-#{Process.pid}-#{rand(10000)}"
-          path = "/dev/shm/#{name}"
-
-          file = File.open(path, File::RDWR | File::CREAT | File::EXCL, 0o600)
+          file = Tempfile.new("rbgl-wayland")
+          file.binmode
+          file.chmod(0o600)
           file.truncate(size)
-          fd = file.fileno
-          File.unlink(path)
+          file.unlink
+          file
+        end
+
+        def wait_for_initial_configure(xdg_surface)
+          configured = @connection.wait_until { xdg_surface.configured? }
+          return if configured
 
-          fd
-        rescue Errno::ENOENT
-          require "tempfile"
-          tmpfile = Tempfile.new("rbgl")
-          tmpfile.truncate(size)
-          tmpfile.fileno
+          raise GUI::BackendUnavailable, "Wayland compositor did not configure the surface"
         end
+
       end
     end
   end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    module Wayland
+      class Codec
+        def pack_args(args)
+          result = String.new
+
+          args.each do |arg|
+            unless arg.is_a?(TypedArgument)
+              raise ArgumentError, "Wayland requests require typed arguments"
+            end
+
+            result << pack_typed_argument(arg)
+          end
+
+          result
+        end
+
+        def pad_length(length)
+          ((length + 3) / 4) * 4
+        end
+
+        private
+
+        def pack_typed_argument(argument)
+          case argument.type
+          when :uint, :object, :new_id
+            [argument.value].pack("V")
+          when :int
+            [argument.value].pack("l<")
+          when :fixed
+            [(argument.value * 256).round].pack("l<")
+          when :string
+            pack_string(argument.value)
+          else
+            raise ArgumentError, "Unsupported Wayland argument type: #{argument.type}"
+          end
+        end
+
+        def pack_string(value)
+          bytes = value.to_s.encode(Encoding::UTF_8).b
+          length = bytes.bytesize + 1
+          [length].pack("V") + bytes + "\x00" + ("\x00" * ((4 - (length % 4)) % 4))
+        end
+      end
+    end
+  end
+end