rbgl 1.0.0 → 1.0.1

data/lib/rbgl/engine/rasterizer.rb

@@ -76,31 +76,14 @@ module RBGL
               end
 
         Larb::Vec3.new(
-          (ndc.x + 1) * 0.5 * @viewport[:width] + @viewport[:x],
-          (1 - ndc.y) * 0.5 * @viewport[:height] + @viewport[:y],
+          ((ndc.x + 1) * 0.5 * @viewport[:width]) + @viewport[:x],
+          ((1 - ndc.y) * 0.5 * @viewport[:height]) + @viewport[:y],
           (ndc.z + 1) * 0.5
         )
       end
 
       def edge_function(a, b, c)
-        (c.x - a.x) * (b.y - a.y) - (c.y - a.y) * (b.x - a.x)
-      end
-
-      def interpolate_attributes(v0, v1, v2, w0, w1, w2)
-        @attribute_interpolator.interpolate([v0, v1, v2], [w0, w1, w2])
-      end
-
-      def interpolate_value(a, b, c, w0, w1, w2)
-        @attribute_interpolator.interpolate_values([a, b, c], [w0, w1, w2])
-      end
-
-      def interpolate_line_attributes(v0, v1, t)
-        corrected_weights = perspective_correct_weights([v0[:position], v1[:position]], [1.0 - t, t])
-        @attribute_interpolator.interpolate([v0, v1], corrected_weights)
-      end
-
-      def perspective_correct_weights(positions, weights)
-        @attribute_interpolator.perspective_correct_weights(positions, weights)
+        ((c.x - a.x) * (b.y - a.y)) - ((c.y - a.y) * (b.x - a.x))
       end
 
       def state(cull_mode:, depth_test:, depth_write:, blend_mode:)

data/lib/rbgl/engine/shader/base_shader.rb

@@ -9,18 +9,14 @@ module RBGL
         @process_block = block
       end
 
-      def process(input, uniforms)
-        output = ShaderIO.new
-        @input = input
-        @uniforms = uniforms
-        @output = output
+      def process(input, uniforms, output: nil)
+        output ||= ShaderIO.new
+        output.clear
 
         instance_exec(input, uniforms, output, &@process_block)
         finalize_output(output)
       end
 
-      attr_reader :input, :uniforms, :output
-
       def self.create(&block)
         new(&block)
       end

data/lib/rbgl/engine/shader/builtins.rb

@@ -53,25 +53,26 @@ module RBGL
 
       def refract(v, n, eta)
         cos_i = -dot(n, v)
-        sin_t2 = eta * eta * (1.0 - cos_i * cos_i)
-        return vec3(0) if sin_t2 > 1.0
+        sin_t2 = eta * eta * (1.0 - (cos_i * cos_i))
+        return v * 0 if sin_t2 > 1.0
 
         cos_t = Math.sqrt(1.0 - sin_t2)
-        v * eta + n * (eta * cos_i - cos_t)
+        (v * eta) + (n * ((eta * cos_i) - cos_t))
       end
 
       def mix(a, b, t)
         case a
-        when Numeric then a + (b - a) * t
-        when Larb::Vec2, Larb::Vec3, Larb::Vec4 then a.lerp(b, t)
-        when Larb::Color then a.lerp(b, t)
+        when Numeric then a + ((b - a) * t)
+        when Larb::Vec2, Larb::Vec3, Larb::Vec4, Larb::Color then a.lerp(b, t)
+        else
+          raise ArgumentError, "Unsupported mix operand: #{a.class}"
         end
       end
 
       def clamp(v, min_val, max_val)
         case v
         when Numeric then v.clamp(min_val, max_val)
-        when Larb::Color then v.clamp
+        when Larb::Color then Larb::Color.new(*v.to_a.map { |component| component.clamp(min_val, max_val) })
         else
           component_map(v) { |component| component.clamp(min_val, max_val) }
         end
@@ -83,8 +84,10 @@ module RBGL
 
       def smoothstep(edge0, edge1, x)
         component_ternary_map(edge0, edge1, x) do |e0, e1, value|
-          t = ((value - e0) / (e1 - e0)).clamp(0.0, 1.0)
-          t * t * (3.0 - 2.0 * t)
+          next value < e0 ? 0.0 : 1.0 if e0 == e1
+
+          t = (value - e0).fdiv(e1 - e0).clamp(0.0, 1.0)
+          t * t * (3.0 - (2.0 * t))
         end
       end
 
@@ -97,7 +100,7 @@ module RBGL
       end
 
       def mod(x, y)
-        component_binary_map(x, y) { |left, right| left - right * (left / right).floor }
+        component_binary_map(x, y) { |left, right| left - (right * (left / right).floor) }
       end
 
       def abs(x)

data/lib/rbgl/engine/shader/dynamic_data.rb

@@ -5,21 +5,23 @@ module RBGL
     class DynamicData
       def initialize(data = {})
         @data = {}
+        @writer_keys = {}
         data.to_h.each { |key, value| self[key] = value }
       end
 
       def method_missing(name, *args)
-        if writer_method?(name)
-          self[writer_key(name)] = args.first
-        elsif args.empty? && @data.key?(normalize_key(name))
-          self[name]
+        key = normalize_key(name)
+        if args.empty? && @data.key?(key)
+          @data[key]
+        elsif (writer = writer_key(name))
+          self[writer] = args.first
         else
           super
         end
       end
 
       def respond_to_missing?(name, include_private = false)
-        writer_method?(name) || @data.key?(normalize_key(name)) || super
+        @data.key?(normalize_key(name)) || !writer_key(name).nil? || super
       end
 
       def [](key)
@@ -38,18 +40,24 @@ module RBGL
         @data.keys
       end
 
+      def clear
+        @data.clear
+        self
+      end
+
       private
 
       def normalize_key(key)
-        key.to_s.chomp("=").to_sym
-      end
+        return key if key.is_a?(Symbol)
 
-      def writer_method?(name)
-        name.to_s.end_with?("=")
+        key.to_s.chomp("=").to_sym
       end
 
       def writer_key(name)
-        name.to_s.chomp("=").to_sym
+        return @writer_keys[name] if @writer_keys.key?(name)
+
+        text = name.to_s
+        @writer_keys[name] = text.end_with?("=") ? text.chomp("=").to_sym : nil
       end
     end
 

data/lib/rbgl/engine/texture.rb

@@ -7,7 +7,7 @@ module RBGL
       WRAP_MODES = %i[repeat clamp mirror].freeze
       FILTER_MODES = %i[nearest linear].freeze
 
-      attr_reader :width, :height, :data, :wrap_s, :wrap_t, :filter_min, :filter_mag
+      attr_reader :width, :height, :wrap_s, :wrap_t, :filter_min, :filter_mag
 
       WRAP_REPEAT = :repeat
       WRAP_CLAMP = :clamp
@@ -19,7 +19,7 @@ module RBGL
       def initialize(width, height, data = nil)
         @width = width
         @height = height
-        @data = data ? normalize_data!(data) : Array.new(width * height) { Larb::Color.black }
+        @data = data ? normalize_data!(data) : Array.new(width * height, immutable_color(Larb::Color.black))
         @levels = [@data]
         @mipmaps_dirty = true
         @wrap_s = WRAP_REPEAT
@@ -29,16 +29,20 @@ module RBGL
       end
 
       def sample(u, v, lod: 0)
-        u = wrap_coord(u, @wrap_s)
-        v = wrap_coord(v, @wrap_t)
         level = mip_level_for(lod)
         level_width = width_for_level(level)
         level_height = height_for_level(level)
+        filter = filter_for_lod(lod)
+        texel_offset = filter == FILTER_LINEAR ? -0.5 : 0.0
 
-        x = u * (level_width - 1)
-        y = v * (level_height - 1)
+        x = (u.to_f * level_width) + texel_offset
+        y = (v.to_f * level_height) + texel_offset
 
-        sample_with_filter(level, x, y, filter_for_lod(lod))
+        sample_with_filter(level, x, y, filter)
+      end
+
+      def data
+        @data.dup.freeze
       end
 
       def get_pixel(x, y)
@@ -48,7 +52,7 @@ module RBGL
       def set_pixel(x, y, color)
         return if x < 0 || x >= @width || y < 0 || y >= @height
 
-        @data[y.to_i * @width + x.to_i] = validate_color!(color)
+        @data[(y.to_i * @width) + x.to_i] = immutable_color(color)
         @mipmaps_dirty = true
       end
 
@@ -86,14 +90,15 @@ module RBGL
         height.times do |y|
           width.times do |x|
             checker = ((x / size) + (y / size)) % 2
-            data[y * width + x] = checker == 0 ? color1 : color2
+            data[(y * width) + x] = checker == 0 ? color1 : color2
           end
         end
         new(width, height, data)
       end
 
       def self.solid(width, height, color)
-        new(width, height, Array.new(width * height) { color })
+        immutable = ImmutableColor.from(color)
+        new(width, height, Array.new(width * height, immutable))
       end
 
       def self.parse_ppm_header(content)
@@ -112,7 +117,7 @@ module RBGL
       def self.parse_ppm_samples(content, format, pixel_count, max_val, body_offset)
         case format
         when "P3"
-          parse_p3_samples(content.byteslice(body_offset..), pixel_count)
+          parse_p3_samples(content.byteslice(body_offset..), pixel_count, max_val)
         when "P6"
           parse_p6_samples(content, body_offset, pixel_count, max_val)
         else
@@ -120,12 +125,19 @@ module RBGL
         end
       end
 
-      def self.parse_p3_samples(body, pixel_count)
-        samples = body.to_s.gsub(/#[^\n]*/, " ").scan(/\d+/).map(&:to_i)
+      def self.parse_p3_samples(body, pixel_count, max_val)
+        tokens = body.to_s.gsub(/#[^\n]*/, " ").split
         expected_count = pixel_count * 3
-        raise ArgumentError, "PPM pixel data is truncated" if samples.length < expected_count
+        raise ArgumentError, "PPM pixel data is truncated" if tokens.length < expected_count
+
+        tokens.first(expected_count).map do |token|
+          raise ArgumentError, "Invalid PPM sample: #{token}" unless /\A\d+\z/.match?(token)
 
-        samples.first(expected_count)
+          value = token.to_i
+          raise ArgumentError, "PPM sample exceeds max value: #{value}" if value > max_val
+
+          value
+        end
       end
 
       def self.parse_p6_samples(content, body_offset, pixel_count, max_val)
@@ -162,7 +174,7 @@ module RBGL
           raise ArgumentError, "Texture data size mismatch: expected #{expected_size}, got #{normalized.size}"
         end
 
-        normalized.map { |pixel| validate_color!(pixel) }
+        normalized.map { |pixel| immutable_color(pixel) }
       end
 
       def validate_color!(color)
@@ -171,16 +183,8 @@ module RBGL
         raise ArgumentError, "Texture data must contain only Larb::Color values"
       end
 
-      def wrap_coord(coord, mode)
-        case mode
-        when WRAP_REPEAT
-          coord - coord.floor
-        when WRAP_CLAMP
-          coord.clamp(0.0, 1.0)
-        when WRAP_MIRROR
-          t = coord - coord.floor
-          coord.floor.to_i.even? ? t : 1.0 - t
-        end
+      def immutable_color(color)
+        ImmutableColor.from(validate_color!(color))
       end
 
       def validate_wrap_mode!(mode)
@@ -198,7 +202,7 @@ module RBGL
       end
 
       def sample_nearest(level, x, y)
-        pixel_for_level(level, x.round, y.round)
+        pixel_for_level(level, x.floor, y.floor, wrap_s: @wrap_s, wrap_t: @wrap_t)
       end
 
       def filter_for_lod(lod)
@@ -224,10 +228,10 @@ module RBGL
         fx = x - x0
         fy = y - y0
 
-        c00 = pixel_for_level(level, x0, y0)
-        c10 = pixel_for_level(level, x1, y0)
-        c01 = pixel_for_level(level, x0, y1)
-        c11 = pixel_for_level(level, x1, y1)
+        c00 = pixel_for_level(level, x0, y0, wrap_s: @wrap_s, wrap_t: @wrap_t)
+        c10 = pixel_for_level(level, x1, y0, wrap_s: @wrap_s, wrap_t: @wrap_t)
+        c01 = pixel_for_level(level, x0, y1, wrap_s: @wrap_s, wrap_t: @wrap_t)
+        c11 = pixel_for_level(level, x1, y1, wrap_s: @wrap_s, wrap_t: @wrap_t)
 
         c0 = c00.lerp(c10, fx)
         c1 = c01.lerp(c11, fx)
@@ -241,13 +245,25 @@ module RBGL
         [lod.floor, @levels.size - 1].min
       end
 
-      def pixel_for_level(level, x, y)
+      def pixel_for_level(level, x, y, wrap_s: WRAP_CLAMP, wrap_t: WRAP_CLAMP)
         level_width = width_for_level(level)
         level_height = height_for_level(level)
         level_data = level.zero? ? @data : level_data(level)
-        clamped_x = x.clamp(0, level_width - 1).to_i
-        clamped_y = y.clamp(0, level_height - 1).to_i
-        level_data[clamped_y * level_width + clamped_x]
+        sample_x = wrap_index(x.to_i, level_width, wrap_s)
+        sample_y = wrap_index(y.to_i, level_height, wrap_t)
+        level_data[(sample_y * level_width) + sample_x]
+      end
+
+      def wrap_index(index, size, mode)
+        case mode
+        when WRAP_REPEAT
+          index % size
+        when WRAP_CLAMP
+          index.clamp(0, size - 1)
+        when WRAP_MIRROR
+          mirrored = index % (size * 2)
+          mirrored < size ? mirrored : ((size * 2) - mirrored - 1)
+        end
       end
 
       def level_data(level)
@@ -286,28 +302,36 @@ module RBGL
         Array.new(target_width * target_height) do |index|
           x = index % target_width
           y = index / target_width
-          average_texel_block(source_data, source_width, source_height, x * 2, y * 2)
+          start_x = x * source_width.fdiv(target_width)
+          end_x = x == target_width - 1 ? source_width.to_f : (x + 1) * source_width.fdiv(target_width)
+          start_y = y * source_height.fdiv(target_height)
+          end_y = y == target_height - 1 ? source_height.to_f : (y + 1) * source_height.fdiv(target_height)
+          average_texel_area(source_data, source_width, start_x, end_x, start_y, end_y)
         end
       end
 
-      def average_texel_block(source_data, source_width, source_height, start_x, start_y)
-        samples = []
+      def average_texel_area(source_data, source_width, start_x, end_x, start_y, end_y)
+        red = green = blue = alpha = total_weight = 0.0
 
-        2.times do |dy|
-          2.times do |dx|
-            x = [start_x + dx, source_width - 1].min
-            y = [start_y + dy, source_height - 1].min
-            samples << source_data[y * source_width + x]
+        (start_y.floor...end_y.ceil).each do |y|
+          y_weight = [end_y, y + 1].min - [start_y, y].max
+          (start_x.floor...end_x.ceil).each do |x|
+            weight = ([end_x, x + 1].min - [start_x, x].max) * y_weight
+            color = source_data[(y * source_width) + x]
+            red += color.r * weight
+            green += color.g * weight
+            blue += color.b * weight
+            alpha += color.a * weight
+            total_weight += weight
           end
         end
 
-        sample_count = samples.length.to_f
-        Larb::Color.new(
-          samples.sum(&:r) / sample_count,
-          samples.sum(&:g) / sample_count,
-          samples.sum(&:b) / sample_count,
-          samples.sum(&:a) / sample_count
-        )
+        immutable_color(Larb::Color.new(
+          red / total_weight,
+          green / total_weight,
+          blue / total_weight,
+          alpha / total_weight
+        ))
       end
     end
   end

data/lib/rbgl/engine.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "version"
+require_relative "engine/immutable_color"
 require_relative "engine/framebuffer"
 require_relative "engine/buffer"
 require_relative "engine/shader"
@@ -11,6 +13,6 @@ require_relative "engine/context"
 
 module RBGL
   module Engine
-    VERSION = "0.1.0"
+    VERSION = RBGL::VERSION
   end
 end

data/lib/rbgl/gui/backend.rb

@@ -26,7 +26,7 @@ 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)
@@ -43,15 +43,20 @@ module RBGL
       end
 
       def set_pixels(buffer, width, height)
-        raise NotImplementedError
+        bytes = validate_rgba_buffer(buffer, width, height)
+        present(Engine::Framebuffer.from_rgba_bytes(width, height, bytes))
       end
 
-      def metal_available?
-        false
-      end
+      protected
+
+      def validate_rgba_buffer(buffer, width, height)
+        bytes = String.try_convert(buffer)
+        raise ArgumentError, "Pixel buffer must be a String" unless bytes
+
+        expected_size = width * height * 4
+        return bytes if bytes.bytesize == expected_size
 
-      def native_handle
-        nil
+        raise ArgumentError, "Pixel buffer size mismatch: expected #{expected_size}, got #{bytes.bytesize}"
       end
     end
   end

data/lib/rbgl/gui/backend_factory.rb

@@ -43,14 +43,18 @@ module RBGL
             FileBackend.new(width, height, title, **options)
           when :x11
             require_relative "x11/backend"
-            X11::Backend.new(width, height, title, env: env)
+            X11::Backend.new(width, height, title, env: env, **options)
           when :wayland
             require_relative "wayland/backend"
-            Wayland::Backend.new(width, height, title, env: env)
+            Wayland::Backend.new(width, height, title, env: env, **options)
           when :cocoa
             require_relative "cocoa/backend"
-            Cocoa::Backend.new(width, height, title, env: env)
+            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}"

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "key_mapper"
+
 module RBGL
   module GUI
     module Cocoa
@@ -11,7 +13,7 @@ module RBGL
       end
 
       class Backend < GUI::Backend
-        def initialize(width, height, title = "RBGL", env: ENV)
+        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"
@@ -19,13 +21,18 @@ module RBGL
 
           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 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
@@ -37,14 +44,8 @@ module RBGL
           raw_events.filter_map { |event| convert_event(event) }
         end
 
-        def poll_events_raw
-          return [] unless @handle
-
-          Metaco.poll_events(@handle)
-        end
-
         def should_close?
-          return false unless @handle
+          return true unless @handle
 
           Metaco.should_close?(@handle)
         end
@@ -59,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
 
@@ -80,21 +88,46 @@ 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])
+            Event.new(:resize, width: raw[:width], height: raw[:height],
+                               framebuffer_width: raw[:framebuffer_width], framebuffer_height: raw[:framebuffer_height])
           else
             nil
           end
         end
+
+        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
   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)