rbgl 0.1.0

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

@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module RBGL
+  module GUI
+    module Wayland
+      class WaylandObject
+        attr_reader :id, :connection
+
+        def initialize(connection, id)
+          @connection = connection
+          @id = id
+        end
+
+        def send_request(opcode, *args)
+          @connection.send_request(@id, opcode, *args)
+        end
+      end
+
+      class Display < WaylandObject
+        def initialize(connection)
+          super(connection, 1)
+        end
+
+        def sync
+          callback_id = @connection.allocate_id
+          send_request(0, callback_id)
+          Callback.new(@connection, callback_id)
+        end
+
+        def get_registry
+          registry_id = @connection.allocate_id
+          send_request(1, registry_id)
+          Registry.new(@connection, registry_id)
+        end
+      end
+
+      class Registry < WaylandObject
+        def bind(name, interface, version)
+          new_id = @connection.allocate_id
+          send_request(0, name, interface, version, new_id)
+          new_id
+        end
+      end
+
+      class Callback < WaylandObject
+        def initialize(connection, id)
+          super
+          @done = false
+        end
+
+        def done?
+          @done
+        end
+
+        def handle_done
+          @done = true
+        end
+      end
+
+      class Compositor < WaylandObject
+        def create_surface
+          surface_id = @connection.allocate_id
+          send_request(0, surface_id)
+          Surface.new(@connection, surface_id)
+        end
+      end
+
+      class Surface < WaylandObject
+        def attach(buffer, x, y)
+          send_request(1, buffer.id, x, y)
+        end
+
+        def damage(x, y, width, height)
+          send_request(2, x, y, width, height)
+        end
+
+        def commit
+          send_request(6)
+        end
+
+        def destroy
+          send_request(0)
+        end
+      end
+
+      class Shm < WaylandObject
+        def create_pool(fd, size)
+          pool_id = @connection.allocate_id
+          @connection.send_request_with_fd(@id, 0, pool_id, size, fd)
+          ShmPool.new(@connection, pool_id)
+        end
+      end
+
+      class ShmPool < WaylandObject
+        def create_buffer(offset, width, height, stride, format)
+          buffer_id = @connection.allocate_id
+          format_val = case format
+                       when :argb8888 then 0
+                       when :xrgb8888 then 1
+                       else 0
+                       end
+          send_request(0, buffer_id, offset, width, height, stride, format_val)
+          WlBuffer.new(@connection, buffer_id)
+        end
+
+        def destroy
+          send_request(1)
+        end
+      end
+
+      class WlBuffer < WaylandObject
+        def destroy
+          send_request(0)
+        end
+      end
+
+      class XdgWmBase < WaylandObject
+        def get_xdg_surface(surface)
+          xdg_surface_id = @connection.allocate_id
+          send_request(2, xdg_surface_id, surface.id)
+          XdgSurface.new(@connection, xdg_surface_id)
+        end
+
+        def pong(serial)
+          send_request(3, serial)
+        end
+      end
+
+      class XdgSurface < WaylandObject
+        def get_toplevel
+          toplevel_id = @connection.allocate_id
+          send_request(1, toplevel_id)
+          XdgToplevel.new(@connection, toplevel_id)
+        end
+
+        def ack_configure(serial)
+          send_request(4, serial)
+        end
+
+        def destroy
+          send_request(0)
+        end
+      end
+
+      class XdgToplevel < WaylandObject
+        def set_title(title)
+          send_request(2, title)
+        end
+
+        def destroy
+          send_request(0)
+        end
+      end
+
+      class Connection
+        attr_reader :compositor, :shm, :xdg_wm_base
+
+        def initialize
+          socket_path = ENV["WAYLAND_DISPLAY"] || "wayland-0"
+          unless socket_path.start_with?("/")
+            runtime_dir = ENV["XDG_RUNTIME_DIR"] || "/run/user/#{Process.uid}"
+            socket_path = File.join(runtime_dir, socket_path)
+          end
+
+          @socket = UNIXSocket.new(socket_path)
+          @objects = {}
+          @next_id = 2
+          @globals = {}
+
+          @display = Display.new(self)
+          @objects[1] = @display
+
+          registry = @display.get_registry
+          @objects[registry.id] = registry
+          flush
+          roundtrip
+
+          bind_globals
+        end
+
+        def allocate_id
+          id = @next_id
+          @next_id += 1
+          id
+        end
+
+        def send_request(object_id, opcode, *args)
+          payload = pack_args(args)
+          header = [object_id, (payload.bytesize + 8) << 16 | opcode].pack("VV")
+          @socket.write(header + payload)
+        end
+
+        def send_request_with_fd(object_id, opcode, *args, fd)
+          payload = pack_args(args)
+          header = [object_id, (payload.bytesize + 8) << 16 | opcode].pack("VV")
+
+          @socket.sendmsg(header + payload, 0, nil, Socket::AncillaryData.unix_rights(fd))
+        end
+
+        def flush
+          @socket.flush
+        end
+
+        def dispatch_pending
+          while IO.select([@socket], nil, nil, 0)
+            header = @socket.read(8)
+            break unless header && header.bytesize == 8
+
+            object_id, size_and_opcode = header.unpack("VV")
+            size = size_and_opcode >> 16
+            opcode = size_and_opcode & 0xFFFF
+
+            payload = size > 8 ? @socket.read(size - 8) : ""
+            handle_event(object_id, opcode, payload)
+          end
+        end
+
+        def roundtrip
+          callback = @display.sync
+          @objects[callback.id] = callback
+          flush
+
+          until callback.done?
+            dispatch_pending
+            sleep 0.001
+          end
+        end
+
+        private
+
+        def handle_event(object_id, opcode, payload)
+          case object_id
+          when 2
+            if opcode == 0
+              name = payload[0, 4].unpack1("V")
+              interface_len = payload[4, 4].unpack1("V")
+              interface = payload[8, interface_len - 1]
+              version = payload[8 + pad_length(interface_len), 4].unpack1("V")
+              @globals[interface] = { name: name, version: version }
+            end
+          else
+            obj = @objects[object_id]
+            if obj.is_a?(Callback) && opcode == 0
+              obj.handle_done
+            end
+          end
+        end
+
+        def bind_globals
+          if @globals["wl_compositor"]
+            id = allocate_id
+            g = @globals["wl_compositor"]
+            @objects[2].bind(g[:name], "wl_compositor", [g[:version], 4].min)
+            @compositor = Compositor.new(self, id)
+            @objects[id] = @compositor
+          end
+
+          if @globals["wl_shm"]
+            id = allocate_id
+            g = @globals["wl_shm"]
+            @objects[2].bind(g[:name], "wl_shm", [g[:version], 1].min)
+            @shm = Shm.new(self, id)
+            @objects[id] = @shm
+          end
+
+          if @globals["xdg_wm_base"]
+            id = allocate_id
+            g = @globals["xdg_wm_base"]
+            @objects[2].bind(g[:name], "xdg_wm_base", [g[:version], 2].min)
+            @xdg_wm_base = XdgWmBase.new(self, id)
+            @objects[id] = @xdg_wm_base
+          end
+
+          flush
+          roundtrip
+        end
+
+        def pack_args(args)
+          result = String.new
+          args.each do |arg|
+            case arg
+            when Integer
+              result << [arg].pack("V")
+            when String
+              len = arg.bytesize + 1
+              result << [len].pack("V")
+              result << arg << "\x00"
+              result << "\x00" * ((4 - len % 4) % 4)
+            when Float
+              result << [(arg * 256).to_i].pack("V")
+            end
+          end
+          result
+        end
+
+        def pad_length(len)
+          ((len + 3) / 4) * 4
+        end
+      end
+
+      class ShmBuffer
+        attr_reader :wl_buffer
+
+        def initialize(fd, size, wl_buffer)
+          @fd = fd
+          @size = size
+          @wl_buffer = wl_buffer
+          @file = File.open("/proc/self/fd/#{fd}", "r+b")
+          @file.seek(0)
+        end
+
+        def write(data)
+          @file.seek(0)
+          @file.write(data)
+          @file.flush
+        end
+
+        def id
+          @wl_buffer.id
+        end
+
+        def destroy
+          @wl_buffer.destroy
+          @file.close
+        end
+      end
+    end
+  end
+end

data/lib/rbgl/gui/window.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    class Window
+      attr_reader :context, :backend, :width, :height
+
+      def initialize(width:, height:, title: "RBGL", backend: :auto, **options)
+        @width = width
+        @height = height
+        @title = title
+        @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
+        @event_handlers = Hash.new { |h, k| h[k] = [] }
+      end
+
+      def on(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
+        end
+
+        @backend.close
+      end
+
+      def stop
+        @running = false
+      end
+
+      def present_framebuffer(framebuffer = nil)
+        fb = framebuffer || @context.framebuffer
+        @backend.present(fb)
+      end
+
+      def set_pixels(buffer)
+        @backend.set_pixels(buffer, @width, @height)
+      end
+
+      def metal_available?
+        @backend.metal_available?
+      end
+
+      def native_handle
+        @backend.native_handle
+      end
+
+      def should_close?
+        @backend.should_close?
+      end
+
+      def poll_events_raw
+        @backend.poll_events_raw
+      end
+
+      def close
+        @backend.close
+      end
+
+      attr_reader :fps
+
+      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
+      end
+
+      def process_events
+        events = @backend.poll_events
+
+        return unless events.is_a?(Array)
+
+        events.each do |event|
+          next unless event.is_a?(Event)
+
+          @event_handlers[event.type].each { |handler| handler.call(event) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require_relative "connection"
+
+module RBGL
+  module GUI
+    module X11
+      class Backend < GUI::Backend
+        def initialize(width, height, title = "RBGL")
+          super
+          @display = Connection.new(ENV["DISPLAY"] || ":0")
+          @windows = {}
+          setup_window(width, height, title)
+        end
+
+        private def setup_window(w, h, t)
+          wid = @display.generate_id
+
+          @display.create_window(
+            depth: @display.root_depth,
+            wid: wid,
+            parent: @display.root,
+            x: 0, y: 0,
+            width: w, height: h,
+            border_width: 0,
+            window_class: :input_output,
+            visual: @display.root_visual,
+            value_mask: [:back_pixel, :event_mask],
+            values: {
+              back_pixel: @display.black_pixel,
+              event_mask: [:exposure, :key_press, :key_release,
+                           :button_press, :button_release, :pointer_motion,
+                           :structure_notify]
+            }
+          )
+
+          @display.change_property(wid, :wm_name, :string, t)
+          @display.map_window(wid)
+          @display.flush
+
+          gc_id = @display.generate_id
+          @display.create_gc(gc_id, wid)
+
+          @windows[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
+
+          buffer = convert_to_x11_format(framebuffer)
+
+          @display.put_image(
+            format: :z_pixmap,
+            drawable: @handle,
+            gc: window[:gc],
+            width: framebuffer.width,
+            height: framebuffer.height,
+            dst_x: 0, dst_y: 0,
+            depth: @display.root_depth,
+            data: buffer
+          )
+
+          @display.flush
+        end
+
+        def poll_events
+          events = []
+
+          while @display.pending > 0
+            raw_event = @display.next_event
+            next unless raw_event
+
+            event = convert_event(raw_event)
+            if event
+              events << event
+              emit_from_event(event)
+            end
+          end
+
+          events
+        end
+
+        def should_close?
+          return false unless @handle
+
+          @windows[@handle]&.[](:should_close) || false
+        end
+
+        def close
+          return unless @handle
+
+          @windows[@handle][:should_close] = true
+          @display.destroy_window(@handle)
+          @windows.delete(@handle)
+        end
+
+        private
+
+        def convert_to_x11_format(framebuffer)
+          # X11 uses BGRX format (blue, green, red, padding)
+          framebuffer.to_bgra_bytes
+        end
+
+        def convert_event(raw)
+          case raw[:type]
+          when :key_press
+            Event.new(:key_press, key: raw[:keycode])
+          when :key_release
+            Event.new(:key_release, key: raw[:keycode])
+          when :button_press
+            Event.new(:mouse_press, x: raw[:x], y: raw[:y], button: raw[:button])
+          when :button_release
+            Event.new(:mouse_release, x: raw[:x], y: raw[:y], button: raw[:button])
+          when :motion_notify
+            Event.new(:mouse_move, x: raw[:x], y: raw[:y])
+          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
+            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
+end