rbgl 0.1.0 → 1.0.1

data/lib/rbgl/engine.rb

@@ -1,15 +1,18 @@
 # frozen_string_literal: true
 
+require_relative "version"
+require_relative "engine/immutable_color"
 require_relative "engine/framebuffer"
 require_relative "engine/buffer"
 require_relative "engine/shader"
 require_relative "engine/texture"
 require_relative "engine/rasterizer"
 require_relative "engine/pipeline"
+require_relative "engine/clip_space_clipper"
 require_relative "engine/context"
 
 module RBGL
   module Engine
-    VERSION = "0.1.0"
+    VERSION = RBGL::VERSION
   end
 end

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)
@@ -23,7 +26,12 @@ module RBGL
       end
 
       def poll_events_raw
-        []
+        poll_events.filter_map { |event| event.to_h if event.respond_to?(:to_h) }
+      end
+
+      def resize(width, height)
+        @width = width
+        @height = height
       end
 
       def should_close?
@@ -35,41 +43,20 @@ module RBGL
       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
+        bytes = validate_rgba_buffer(buffer, width, height)
+        present(Engine::Framebuffer.from_rgba_bytes(width, height, bytes))
       end
 
       protected
 
-      def emit_key(key, action)
-        @key_callback&.call(key, action)
-      end
+      def validate_rgba_buffer(buffer, width, height)
+        bytes = String.try_convert(buffer)
+        raise ArgumentError, "Pixel buffer must be a String" unless bytes
 
-      def emit_mouse(x, y, button, action)
-        @mouse_callback&.call(x, y, button, action)
-      end
+        expected_size = width * height * 4
+        return bytes if bytes.bytesize == expected_size
 
-      def emit_resize(width, height)
-        @resize_callback&.call(width, height)
+        raise ArgumentError, "Pixel buffer size mismatch: expected #{expected_size}, got #{bytes.bytesize}"
       end
     end
   end

data/lib/rbgl/gui/backend_factory.rb

@@ -0,0 +1,89 @@
+# 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, **options)
+          when :wayland
+            require_relative "wayland/backend"
+            Wayland::Backend.new(width, height, title, env: env, **options)
+          when :cocoa
+            require_relative "cocoa/backend"
+            Cocoa::Backend.new(width, height, title, env: env, **options)
+          when Backend
+            unless options.empty?
+              raise ArgumentError, "Backend instances do not accept construction options: #{options.keys.join(', ')}"
+            end
+
+            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,58 +1,51 @@
 # frozen_string_literal: true
 
-begin
-  require "metaco"
-  METACO_AVAILABLE = true
-rescue LoadError
-  METACO_AVAILABLE = false
-end
+require_relative "key_mapper"
 
 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, resizable: false, high_dpi: false, **_options)
+          @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)
+          @handle = Metaco.window_create(width, height, title, resizable: resizable, high_dpi: high_dpi)
+          @framebuffer_width, @framebuffer_height = Metaco.framebuffer_size(@handle)
         end
 
         def present(framebuffer)
-          return unless @handle
+          return false unless @handle
 
-          Metaco.set_pixels(@handle, framebuffer.to_rgba_bytes, framebuffer.width, framebuffer.height)
+          bytes = framebuffer.to_rgba_bytes
+          width = @framebuffer_width
+          height = @framebuffer_height
+          bytes = scale_pixels(bytes, framebuffer.width, framebuffer.height, width, height) if [width, height] != [framebuffer.width, framebuffer.height]
+          Metaco.set_pixels(@handle, bytes, width, 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
-        end
-
-        def poll_events_raw
-          return [] unless @handle
-
-          Metaco.poll_events(@handle)
+          raw_events.filter_map { |event| convert_event(event) }
         end
 
         def should_close?
-          return false unless @handle
+          return true unless @handle
 
           Metaco.should_close?(@handle)
         end
@@ -67,10 +60,17 @@ module RBGL
         def set_pixels(buffer, width, height)
           return unless @handle
 
-          Metaco.set_pixels(@handle, buffer, width, height)
+          bytes = validate_rgba_buffer(buffer, width, height)
+          bytes = scale_pixels(bytes, width, height, @framebuffer_width, @framebuffer_height) if [width, height] != [@framebuffer_width, @framebuffer_height]
+          Metaco.set_pixels(@handle, bytes, @framebuffer_width, @framebuffer_height)
           Metaco.present(@handle)
         end
 
+        def resize(width, height)
+          super
+          @framebuffer_width, @framebuffer_height = Metaco.framebuffer_size(@handle)
+        end
+
         def metal_available?
           return false unless @handle
 
@@ -88,32 +88,45 @@ module RBGL
 
           case type
           when :key_press
-            Event.new(:key_press, key: raw[:key], char: raw[:char])
+            Event.new(:key_press, key: normalize_key(raw[:key], raw[:char]), keycode: raw[:key], char: raw[:char], modifiers: raw[:modifiers] || [])
           when :key_release
-            Event.new(:key_release, key: raw[:key])
+            Event.new(:key_release, key: normalize_key(raw[:key]), keycode: raw[:key], modifiers: raw[:modifiers] || [])
           when :mouse_press
-            Event.new(:mouse_press, x: raw[:x], y: raw[:y], button: raw[:button])
+            Event.new(:mouse_press, x: raw[:x], y: mouse_y(raw[:y]), button: raw[:button], modifiers: raw[:modifiers] || [])
           when :mouse_release
-            Event.new(:mouse_release, x: raw[:x], y: raw[:y], button: raw[:button])
+            Event.new(:mouse_release, x: raw[:x], y: mouse_y(raw[:y]), button: raw[:button], modifiers: raw[:modifiers] || [])
           when :mouse_move
-            Event.new(:mouse_move, x: raw[:x], y: raw[:y])
+            Event.new(:mouse_move, x: raw[:x], y: mouse_y(raw[:y]), modifiers: raw[:modifiers] || [])
+          when :scroll
+            Event.new(:scroll, dx: raw[:dx], dy: raw[:dy], modifiers: raw[:modifiers] || [])
+          when :focus, :blur
+            Event.new(type)
+          when :resize
+            Event.new(:resize, width: raw[:width], height: raw[:height],
+                               framebuffer_width: raw[:framebuffer_width], framebuffer_height: raw[:framebuffer_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)
+        def normalize_key(key, char = nil)
+          KeyMapper.key(key, char)
+        end
+
+        def mouse_y(y)
+          @height ? @height - 1 - y : y
+        end
+
+        def scale_pixels(bytes, source_width, source_height, target_width, target_height)
+          scaled = String.new(capacity: target_width * target_height * 4, encoding: Encoding::BINARY)
+          target_height.times do |y|
+            source_y = y * source_height / target_height
+            target_width.times do |x|
+              source_x = x * source_width / target_width
+              scaled << bytes.byteslice(((source_y * source_width) + source_x) * 4, 4)
+            end
           end
+          scaled
         end
       end
     end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    module Cocoa
+      module KeyMapper
+        KEY_CODES = {
+          0 => :a, 1 => :s, 2 => :d, 3 => :f, 4 => :h, 5 => :g, 6 => :z, 7 => :x,
+          8 => :c, 9 => :v, 11 => :b, 12 => :q, 13 => :w, 14 => :e, 15 => :r,
+          16 => :y, 17 => :t, 18 => :one, 19 => :two, 20 => :three, 21 => :four,
+          22 => :six, 23 => :five, 24 => :equal, 25 => :nine, 26 => :seven,
+          27 => :minus, 28 => :eight, 29 => :zero, 30 => :right_bracket, 31 => :o,
+          32 => :u, 33 => :left_bracket, 34 => :i, 35 => :p, 36 => :enter, 37 => :l,
+          38 => :j, 39 => :quote, 40 => :k, 41 => :semicolon, 42 => :backslash,
+          43 => :comma, 44 => :slash, 45 => :n, 46 => :m, 47 => :period, 48 => :tab,
+          49 => :space, 50 => :grave, 51 => :backspace, 53 => :escape, 54 => :right_meta,
+          55 => :left_meta, 56 => :left_shift, 57 => :caps_lock, 58 => :left_alt,
+          59 => :left_control, 60 => :right_shift, 61 => :right_alt, 62 => :right_control,
+          63 => :function, 64 => :f17, 65 => :keypad_decimal, 67 => :keypad_multiply,
+          69 => :keypad_plus, 71 => :keypad_clear, 72 => :volume_up, 73 => :volume_down,
+          74 => :mute, 75 => :keypad_divide, 76 => :keypad_enter, 78 => :keypad_minus,
+          79 => :f18, 80 => :f19, 81 => :keypad_equal, 82 => :keypad_zero,
+          83 => :keypad_one, 84 => :keypad_two, 85 => :keypad_three, 86 => :keypad_four,
+          87 => :keypad_five, 88 => :keypad_six, 89 => :keypad_seven,
+          91 => :keypad_eight, 92 => :keypad_nine, 96 => :f5, 97 => :f6, 98 => :f7,
+          99 => :f3, 100 => :f8, 101 => :f9, 103 => :f11, 105 => :f13,
+          106 => :f16, 107 => :f14, 109 => :f10, 111 => :f12, 113 => :f15,
+          114 => :help, 115 => :home, 116 => :page_up, 117 => :delete,
+          118 => :f4, 119 => :end, 120 => :f2, 121 => :page_down, 122 => :f1,
+          123 => :left, 124 => :right, 125 => :down, 126 => :up
+        }.freeze
+
+        module_function
+
+        def key(code, char = nil)
+          return code if code.is_a?(Symbol)
+          return KEY_CODES.fetch(code, code) if code.is_a?(Integer)
+
+          text = char.to_s.empty? ? code.to_s : char.to_s
+          return :escape if text == "\e" || text.casecmp?("escape")
+          return text.downcase.to_sym if text.length == 1
+
+          code
+        end
+      end
+    end
+  end
+end

data/lib/rbgl/gui/event.rb

@@ -14,8 +14,10 @@ module RBGL
         @data[key]
       end
 
-      def method_missing(name, *args)
-        @data.key?(name) ? @data[name] : super
+      def method_missing(name, *args, &block)
+        return @data[name] if args.empty? && block.nil? && @data.key?(name)
+
+        super
       end
 
       def respond_to_missing?(name, include_private = false)

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,35 @@
+# 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
+          when :png
+            begin
+              require "tessel"
+            rescue LoadError
+              raise ArgumentError, "format: :png requires the tessel gem"
+            end
+            PngWriter.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/png_writer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    class FileBackend
+      class PngWriter < FrameWriter
+        def extension
+          "png"
+        end
+
+        def write(filename, framebuffer)
+          image = Tessel::Image.from_rgba(framebuffer.width, framebuffer.height, framebuffer.to_rgba_bytes)
+          image.write(filename)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    class FileBackend < Backend
+      class PpmWriter < FrameWriter
+        def initialize(binary:)
+          super()
+          @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