rbgl 1.0.0 → 1.0.2

data/lib/rbgl/gui/window.rb

@@ -8,10 +8,11 @@ module RBGL
     class Window
       attr_reader :context, :backend, :width, :height
 
-      def initialize(width:, height:, title: "RBGL", backend: :auto, **options)
+      def initialize(width:, height:, title: "RBGL", backend: :auto, target_fps: 60, **options)
         @width = width
         @height = height
         @title = title
+        @render_loop = RenderLoop.new(target_fps: target_fps)
         @context = Engine::Context.new(width: width, height: height)
         @backend = build_backend(backend, width: width, height: height, title: title, **options)
         @event_handlers = Hash.new { |h, k| h[k] = [] }
@@ -20,7 +21,7 @@ module RBGL
           event_handlers: @event_handlers,
           on_resize: method(:apply_resize)
         )
-        @render_loop = RenderLoop.new
+        @closed = false
       end
 
       def on(event_type, &block)
@@ -29,6 +30,8 @@ module RBGL
       end
 
       def run(&frame_callback)
+        raise RuntimeError, "Window#run is one-shot and cannot be called after the window is closed" if @closed
+
         @render_loop.run(
           backend: @backend,
           context: @context,
@@ -36,7 +39,25 @@ module RBGL
           &frame_callback
         )
       ensure
-        @backend.close if @backend
+        original_error = $!
+        begin
+          close if @backend
+        rescue StandardError
+          raise unless original_error
+        end
+      end
+
+      # Advances one frame. `now` is seconds on a monotonic timeline.
+      def step(now = nil, &frame_callback)
+        return false if @closed
+
+        !!@render_loop.step(
+          backend: @backend,
+          context: @context,
+          process_events: method(:process_events),
+          now:,
+          &frame_callback
+        )
       end
 
       def stop
@@ -53,11 +74,11 @@ module RBGL
       end
 
       def metal_available?
-        @backend.metal_available?
+        @backend.respond_to?(:metal_available?) && @backend.metal_available?
       end
 
       def native_handle
-        @backend.native_handle
+        @backend.native_handle if @backend.respond_to?(:native_handle)
       end
 
       def should_close?
@@ -65,11 +86,21 @@ module RBGL
       end
 
       def poll_events_raw
-        @backend.poll_events_raw
+        events = @backend.poll_events_raw
+        Array(events).each do |event|
+          next unless event.respond_to?(:[]) && event[:type] == :resize
+
+          apply_resize(Event.new(:resize, width: event[:width], height: event[:height]))
+        end
+        events
       end
 
       def close
+        return if @closed
+
+        @render_loop.stop
         @backend.close
+        @closed = true
       end
 
       def fps
@@ -91,10 +122,10 @@ module RBGL
       end
 
       def apply_resize(event)
+        @backend.resize(event.width, event.height)
+        @context.resize(width: event.width, height: event.height)
         @width = event.width
         @height = event.height
-        @context.resize(width: event.width, height: event.height)
-        @backend.resize(event.width, event.height)
       end
 
       def validate_event_handler!(event_type, block)

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

@@ -17,8 +17,11 @@ module RBGL
 
         def fetch(name)
           return name if name.is_a?(Integer)
+          return @cache[name] if @cache.key?(name)
 
-          @cache[name] ||= @resolver.call(name)
+          resolved = @resolver.call(name)
+          @cache[name] = resolved
+          resolved
         end
       end
     end

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

@@ -1,16 +1,24 @@
 # frozen_string_literal: true
 
 require_relative "connection"
+require_relative "pixel_encoder"
 
 module RBGL
   module GUI
     module X11
       class Backend < GUI::Backend
-        def initialize(width, height, title = "RBGL", env: ENV)
+        def initialize(width, height, title = "RBGL", env: ENV, reply_timeout: Connection::DEFAULT_REPLY_TIMEOUT)
           super(width, height, title)
-          @display = Connection.new(env["DISPLAY"] || ":0")
-          @windows = {}
+          @display = Connection.new(env["DISPLAY"] || ":0", env: env, reply_timeout: reply_timeout)
+          @window = nil
           setup_window(width, height, title)
+        rescue StandardError => error
+          begin
+            close
+          rescue StandardError
+            nil
+          end
+          raise error
         end
 
         private def setup_window(w, h, t)
@@ -42,33 +50,43 @@ module RBGL
           gc_id = @display.generate_id
           @display.create_gc(gc_id, wid)
 
-          @windows[wid] = {
+          @window = {
+            id: wid,
             width: w,
             height: h,
             gc: gc_id,
             should_close: false
           }
-
-          @handle = wid
         end
 
         def present(framebuffer)
-          return false unless @handle
-
-          window = @windows[@handle]
-          return false unless window
+          return false unless @window
 
           buffer = convert_to_x11_format(framebuffer)
+          present_bytes(buffer, framebuffer.width, framebuffer.height)
+        end
+
+        def set_pixels(buffer, width, height)
+          return false unless @window
+
+          bytes = validate_rgba_buffer(buffer, width, height)
+          present_bytes(pixel_encoder.encode_rgba(bytes, width, height), width, height)
+        end
+
+        private def present_bytes(buffer, width, height)
+          window = @window
+          return false unless window
 
           @display.put_image(
             format: :z_pixmap,
-            drawable: @handle,
+            drawable: window[:id],
             gc: window[:gc],
-            width: framebuffer.width,
-            height: framebuffer.height,
+            width: width,
+            height: height,
             dst_x: 0, dst_y: 0,
             depth: @display.root_depth,
-            data: buffer
+            data: buffer,
+            bytes_per_line: pixel_encoder.bytes_per_line(width)
           )
 
           @display.flush
@@ -90,33 +108,53 @@ module RBGL
         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 = @window
+          operations = []
+          if window
+            window[:should_close] = true
+            operations << -> { @display.destroy_window(window[:id]) }
+            operations << -> { @display.flush }
+          end
+          operations << -> { @display&.close }
 
-          @windows[@handle][:should_close] = true
-          @display.destroy_window(@handle)
-          @windows.delete(@handle)
-          @handle = nil
+          error = nil
+          operations.each do |operation|
+            operation.call
+          rescue StandardError => cleanup_error
+            error ||= cleanup_error
+          end
+          @window = nil
+          raise error if error
         end
 
         private
 
         def convert_to_x11_format(framebuffer)
-          # X11 uses BGRX format (blue, green, red, padding)
-          framebuffer.to_bgra_bytes
+          pixel_encoder.encode(framebuffer)
+        end
+
+        def pixel_encoder
+          @pixel_encoder ||= PixelEncoder.new(
+            bits_per_pixel: @display.bits_per_pixel,
+            scanline_pad: @display.scanline_pad,
+            visual_class: @display.visual_class,
+            red_mask: @display.red_mask,
+            green_mask: @display.green_mask,
+            blue_mask: @display.blue_mask,
+            image_byte_order: @display.image_byte_order
+          )
         end
 
         def convert_event(raw)
           case raw[:type]
           when :key_press
-            Event.new(:key_press, key: raw[:keycode])
+            Event.new(:key_press, key: @display.key_for_keycode(raw[:keycode]), keycode: raw[:keycode])
           when :key_release
-            Event.new(:key_release, key: raw[:keycode])
+            Event.new(:key_release, key: @display.key_for_keycode(raw[:keycode]), keycode: raw[:keycode])
           when :button_press
             Event.new(:mouse_press, x: raw[:x], y: raw[:y], button: raw[:button])
           when :button_release
@@ -126,11 +164,11 @@ module RBGL
           when :configure_notify
             Event.new(:resize, width: raw[:width], height: raw[:height])
           when :client_message
-            return nil unless raw[:window] == @handle
+            return nil unless @window && raw[:window] == @window[:id]
             return nil unless raw[:message_type] == @display.wm_protocols_atom
             return nil unless raw[:data32]&.first == @display.wm_delete_window_atom
 
-            @windows[@handle][:should_close] = true if @handle && @windows[@handle]
+            @window[:should_close] = true
             Event.new(:close)
           else
             nil