rbgl 0.1.0

data/lib/rbgl/gui/backend.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    class Backend
+      attr_reader :width, :height, :title
+
+      def initialize(width, height, title = "RBGL")
+        @width = width
+        @height = height
+        @title = title
+        @key_callback = nil
+        @mouse_callback = nil
+        @resize_callback = nil
+      end
+
+      def present(_framebuffer)
+        raise NotImplementedError
+      end
+
+      def poll_events
+        raise NotImplementedError
+      end
+
+      def poll_events_raw
+        []
+      end
+
+      def should_close?
+        raise NotImplementedError
+      end
+
+      def close
+        raise NotImplementedError
+      end
+
+      def set_pixels(buffer, width, height)
+        raise NotImplementedError
+      end
+
+      def metal_available?
+        false
+      end
+
+      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/cocoa/backend.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+begin
+  require "metaco"
+  METACO_AVAILABLE = true
+rescue LoadError
+  METACO_AVAILABLE = false
+end
+
+module RBGL
+  module GUI
+    module Cocoa
+      class Backend < GUI::Backend
+        def initialize(width, height, title = "RBGL")
+          unless METACO_AVAILABLE
+            raise LoadError, "metaco gem is required for Cocoa backend. Install it with: gem install metaco"
+          end
+
+          super
+          Metaco.init
+          @handle = Metaco.window_create(width, height, title)
+        end
+
+        def present(framebuffer)
+          return unless @handle
+
+          Metaco.set_pixels(@handle, framebuffer.to_rgba_bytes, framebuffer.width, framebuffer.height)
+          Metaco.present(@handle)
+        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
+        end
+
+        def poll_events_raw
+          return [] unless @handle
+
+          Metaco.poll_events(@handle)
+        end
+
+        def should_close?
+          return false unless @handle
+
+          Metaco.should_close?(@handle)
+        end
+
+        def close
+          return unless @handle
+
+          Metaco.window_destroy(@handle)
+          @handle = nil
+        end
+
+        def set_pixels(buffer, width, height)
+          return unless @handle
+
+          Metaco.set_pixels(@handle, buffer, width, height)
+          Metaco.present(@handle)
+        end
+
+        def metal_available?
+          return false unless @handle
+
+          Metaco.metal_compute_available?(@handle)
+        end
+
+        def native_handle
+          @handle
+        end
+
+        private
+
+        def convert_event(raw)
+          type = raw[:type]
+
+          case type
+          when :key_press
+            Event.new(:key_press, key: raw[:key], char: raw[:char])
+          when :key_release
+            Event.new(:key_release, key: raw[:key])
+          when :mouse_press
+            Event.new(:mouse_press, x: raw[:x], y: raw[:y], button: raw[:button])
+          when :mouse_release
+            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])
+          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
+end

data/lib/rbgl/gui/event.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    class Event
+      attr_reader :type, :data
+
+      def initialize(type, **data)
+        @type = type
+        @data = data
+      end
+
+      def [](key)
+        @data[key]
+      end
+
+      def method_missing(name, *args)
+        @data.key?(name) ? @data[name] : super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @data.key?(name) || super
+      end
+
+      def to_h
+        { type: @type }.merge(@data)
+      end
+
+      def inspect
+        "Event[#{@type}, #{@data.map { |k, v| "#{k}: #{v}" }.join(', ')}]"
+      end
+    end
+  end
+end

data/lib/rbgl/gui/file_backend.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    class FileBackend < Backend
+      def initialize(width, height, title = "RBGL", format: :ppm, output_dir: ".")
+        super(width, height, title)
+        @format = format
+        @output_dir = output_dir
+        @frame_count = 0
+        @should_close = false
+        @max_frames = nil
+      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
+
+        @frame_count += 1
+
+        @should_close = true if @max_frames && @frame_count >= @max_frames
+      end
+
+      def poll_events
+      end
+
+      def should_close?
+        @should_close
+      end
+
+      def close
+        @should_close = true
+      end
+
+      def set_max_frames(count)
+        @max_frames = count
+      end
+
+      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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative "connection"
+
+module RBGL
+  module GUI
+    module Wayland
+      class Backend < GUI::Backend
+        def initialize(width, height, title = "RBGL")
+          super
+          @connection = Connection.new
+          @windows = {}
+          setup_window(width, height, title)
+        end
+
+        private def setup_window(w, h, t)
+          surface = @connection.compositor.create_surface
+          xdg_surface = @connection.xdg_wm_base.get_xdg_surface(surface)
+          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] = {
+            surface: surface,
+            xdg_surface: xdg_surface,
+            toplevel: toplevel,
+            shm_buffer: shm_buffer,
+            width: w,
+            height: h,
+            should_close: false,
+            pending_events: []
+          }
+
+          @handle = handle
+        end
+
+        def present(framebuffer)
+          return unless @handle
+
+          window = @windows[@handle]
+          return unless window
+
+          buffer = convert_to_wayland_format(framebuffer)
+          window[:shm_buffer].write(buffer)
+
+          window[:surface].damage(0, 0, framebuffer.width, framebuffer.height)
+          window[:surface].attach(window[:shm_buffer], 0, 0)
+          window[:surface].commit
+          @connection.flush
+        end
+
+        def poll_events
+          events = []
+          @connection.dispatch_pending
+
+          if @handle && @windows[@handle]
+            events.concat(@windows[@handle][:pending_events])
+            @windows[@handle][:pending_events] = []
+          end
+
+          events
+        end
+
+        def should_close?
+          return false unless @handle
+
+          @windows[@handle]&.[](:should_close) || false
+        end
+
+        def close
+          return unless @handle
+
+          window = @windows[@handle]
+          return unless window
+
+          window[:should_close] = true
+          window[:toplevel].destroy
+          window[:xdg_surface].destroy
+          window[:surface].destroy
+          window[:shm_buffer].destroy
+          @windows.delete(@handle)
+        end
+
+        private
+
+        def convert_to_wayland_format(framebuffer)
+          framebuffer.to_bgra_bytes
+        end
+
+        def create_shm_buffer(width, height)
+          size = width * height * 4
+
+          fd = create_anonymous_file(size)
+
+          pool = @connection.shm.create_pool(fd, size)
+          buffer = pool.create_buffer(0, width, height, width * 4, :argb8888)
+
+          ShmBuffer.new(fd, size, buffer)
+        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.truncate(size)
+          fd = file.fileno
+          File.unlink(path)
+
+          fd
+        rescue Errno::ENOENT
+          require "tempfile"
+          tmpfile = Tempfile.new("rbgl")
+          tmpfile.truncate(size)
+          tmpfile.fileno
+        end
+      end
+    end
+  end
+end