ruby-sfml 3.0.0.0

data/lib/sfml/c/window.rb

@@ -0,0 +1,186 @@
+module SFML
+  module C
+    module Window
+      extend FFI::Library
+
+      ffi_lib LIB_CANDIDATES[:window]
+
+      class VideoMode < FFI::Struct
+        layout :size,           System::Vector2u,
+               :bits_per_pixel, :uint32
+      end
+
+      # sfStyle is a bitmask. sfWindowState is a plain enum.
+      module Style
+        NONE     = 0
+        TITLEBAR = 1 << 0
+        RESIZE   = 1 << 1
+        CLOSE    = 1 << 2
+        DEFAULT  = TITLEBAR | RESIZE | CLOSE
+      end
+
+      State = enum :window_state, [:windowed, :fullscreen]
+
+      # sfEventType — order MUST match CSFML/Window/Event.h. We expose this as
+      # an :int FFI type and translate to/from Ruby symbols in the high-level
+      # SFML::Event class. Order is load-bearing.
+      EVENT_TYPES = %i[
+        closed
+        resized
+        focus_lost
+        focus_gained
+        text_entered
+        key_pressed
+        key_released
+        mouse_wheel_scrolled
+        mouse_button_pressed
+        mouse_button_released
+        mouse_moved
+        mouse_moved_raw
+        mouse_entered
+        mouse_left
+        joystick_button_pressed
+        joystick_button_released
+        joystick_moved
+        joystick_connected
+        joystick_disconnected
+        touch_began
+        touch_moved
+        touch_ended
+        sensor_changed
+      ].freeze
+
+      # Per-variant structs of the sfEvent union.
+      class KeyEvent < FFI::Struct
+        layout :type,     :int,
+               :code,     :int32,
+               :scancode, :int32,
+               :alt,      :bool,
+               :control,  :bool,
+               :shift,    :bool,
+               :system,   :bool
+      end
+
+      class TextEvent < FFI::Struct
+        layout :type, :int, :unicode, :uint32
+      end
+
+      class SizeEvent < FFI::Struct
+        layout :type, :int, :size, System::Vector2u
+      end
+
+      class MouseMoveEvent < FFI::Struct
+        layout :type, :int, :position, System::Vector2i
+      end
+
+      class MouseButtonEvent < FFI::Struct
+        layout :type,     :int,
+               :button,   :int,
+               :position, System::Vector2i
+      end
+
+      class MouseWheelScrollEvent < FFI::Struct
+        layout :type,     :int,
+               :wheel,    :int,
+               :delta,    :float,
+               :position, System::Vector2i
+      end
+
+      class JoystickButtonEvent < FFI::Struct
+        layout :type,        :int,
+               :joystick_id, :uint32,
+               :button,      :uint32
+      end
+
+      class JoystickMoveEvent < FFI::Struct
+        layout :type,        :int,
+               :joystick_id, :uint32,
+               :axis,        :int,
+               :position,    :float
+      end
+
+      class JoystickConnectEvent < FFI::Struct
+        layout :type,        :int,
+               :joystick_id, :uint32
+      end
+
+      # sfEvent is a C union. The largest variant (KeyEvent on x86_64: 4+4+4+4
+      # = 20 bytes) defines the union size; we allocate a buffer that big and
+      # reinterpret per-type. We use a Struct (not Union) here because Ruby
+      # FFI handles variable-tag unions awkwardly — the tag is the first int32
+      # in every variant, so we read it directly.
+      class Event < FFI::Struct
+        layout :type, :int, :_pad, [:uint8, 28]
+
+        def event_type
+          EVENT_TYPES[self[:type]]
+        end
+      end
+
+      attach_function :sfVideoMode_getDesktopMode, [], VideoMode.by_value
+
+      attach_function :sfKeyboard_isKeyPressed, [:int], :bool
+
+      # Mouse: position queries here use a sfWindow*. Pass NULL to get
+      # desktop-relative coordinates. The render-window variants live in
+      # SFML::C::Graphics (different shared library).
+      attach_function :sfMouse_isButtonPressed, [:int], :bool
+      attach_function :sfMouse_getPosition,     [:pointer], System::Vector2i.by_value
+      attach_function :sfMouse_setPosition,     [System::Vector2i.by_value, :pointer], :void
+
+      # ---- Cursor ----
+      typedef :pointer, :cursor_t
+
+      attach_function :sfCursor_createFromPixels, [:pointer, System::Vector2u.by_value, System::Vector2u.by_value], :cursor_t
+      attach_function :sfCursor_createFromSystem, [:int], :cursor_t
+      attach_function :sfCursor_destroy,          [:cursor_t], :void
+
+      # ---- Clipboard ----
+      attach_function :sfClipboard_getString,        [], :string
+      attach_function :sfClipboard_setString,        [:string], :void
+      attach_function :sfClipboard_getUnicodeString, [], :pointer
+      attach_function :sfClipboard_setUnicodeString, [:pointer], :void
+
+      # ---- Joystick ----
+      class JoystickIdentification < FFI::Struct
+        layout :name,       :pointer,  # const char*
+               :vendor_id,  :uint32,
+               :product_id, :uint32
+      end
+
+      attach_function :sfJoystick_isConnected,     [:uint32], :bool
+      attach_function :sfJoystick_getButtonCount,  [:uint32], :uint32
+      attach_function :sfJoystick_hasAxis,         [:uint32, :int], :bool
+      attach_function :sfJoystick_isButtonPressed, [:uint32, :uint32], :bool
+      attach_function :sfJoystick_getAxisPosition, [:uint32, :int], :float
+      attach_function :sfJoystick_getIdentification, [:uint32], JoystickIdentification.by_value
+      attach_function :sfJoystick_update,          [], :void
+
+      # ---- Bare Window (no rendering) ----
+      # SFML 3 splits sf::Window (pure window + GL context) from
+      # sf::RenderWindow (window + 2D batcher). The bare variant is
+      # useful only when you're driving raw OpenGL yourself.
+      typedef :pointer, :raw_window_t
+
+      attach_function :sfWindow_create,        [VideoMode.by_value, :string, :uint32, :int, :pointer], :raw_window_t
+      attach_function :sfWindow_destroy,       [:raw_window_t], :void
+      attach_function :sfWindow_close,         [:raw_window_t], :void
+      attach_function :sfWindow_isOpen,        [:raw_window_t], :bool
+      attach_function :sfWindow_pollEvent,     [:raw_window_t, :pointer], :bool
+      attach_function :sfWindow_waitEvent,     [:raw_window_t, System::Time.by_value, :pointer], :bool
+      attach_function :sfWindow_display,       [:raw_window_t], :void
+      attach_function :sfWindow_setVisible,    [:raw_window_t, :bool], :void
+      attach_function :sfWindow_setTitle,      [:raw_window_t, :string], :void
+      attach_function :sfWindow_getSize,       [:raw_window_t], System::Vector2u.by_value
+      attach_function :sfWindow_setSize,       [:raw_window_t, System::Vector2u.by_value], :void
+      attach_function :sfWindow_getPosition,   [:raw_window_t], System::Vector2i.by_value
+      attach_function :sfWindow_setPosition,   [:raw_window_t, System::Vector2i.by_value], :void
+      attach_function :sfWindow_setFramerateLimit,      [:raw_window_t, :uint32], :void
+      attach_function :sfWindow_setVerticalSyncEnabled, [:raw_window_t, :bool], :void
+      attach_function :sfWindow_setKeyRepeatEnabled,    [:raw_window_t, :bool], :void
+      attach_function :sfWindow_requestFocus,  [:raw_window_t], :void
+      attach_function :sfWindow_hasFocus,      [:raw_window_t], :bool
+      attach_function :sfWindow_setActive,     [:raw_window_t, :bool], :bool
+    end
+  end
+end

data/lib/sfml/c.rb

@@ -0,0 +1,72 @@
+require "ffi"
+
+module SFML
+  # Low-level FFI bindings to CSFML 3.x. One module per CSFML library.
+  #
+  # End users should not call into here directly. The high-level Ruby classes
+  # (SFML::Vector2, SFML::Clock, SFML::RenderWindow, ...) wrap these. This
+  # layer exists to be replaceable: when CSFML ships a new minor version, only
+  # the files under SFML::C should need to move.
+  module C
+    # Library name candidates per CSFML module. Each value is an Array passed
+    # as a single argument to ffi_lib — FFI then tries the names in order and
+    # uses the first one it can dlopen. (Splatting would tell FFI to load all
+    # of them at once, not as alternatives.)
+    #
+    # The bare name ("csfml-system") is what FFI auto-decorates per platform:
+    #   Linux   → libcsfml-system.so
+    #   macOS   → libcsfml-system.dylib
+    #   Windows → csfml-system.dll
+    # The remaining entries are explicit fallbacks for systems where the
+    # unversioned symlink is missing (e.g. runtime-only installs without -dev).
+    LIB_CANDIDATES = {
+      system:   ["csfml-system",   "libcsfml-system.so.3.0",   "libcsfml-system.3.0.0.dylib"],
+      window:   ["csfml-window",   "libcsfml-window.so.3.0",   "libcsfml-window.3.0.0.dylib"],
+      graphics: ["csfml-graphics", "libcsfml-graphics.so.3.0", "libcsfml-graphics.3.0.0.dylib"],
+      audio:    ["csfml-audio",    "libcsfml-audio.so.3.0",    "libcsfml-audio.3.0.0.dylib"],
+      network:  ["csfml-network",  "libcsfml-network.so.3.0",  "libcsfml-network.3.0.0.dylib"],
+    }.freeze
+  end
+end
+
+# Version probe — runs before any binding modules attach their full
+# function tables. We try to attach a single CSFML 3.0+ symbol; if it's
+# missing the linked libcsfml is older (e.g. Ubuntu 22.04 / 24.04 ship
+# CSFML 2.5 in their repos). Trip a clear SFML::LoadError now rather
+# than letting users hit a cryptic FFI::NotFoundError mid-attach when
+# they `require "sfml"` for the first time.
+begin
+  probe = Module.new
+  probe.extend FFI::Library
+  probe.ffi_lib SFML::C::LIB_CANDIDATES[:system]
+  # sfClock_isRunning is part of the SFML 3.0 sf::Clock rewrite — not
+  # present in any 2.x release. Cheap and dependency-free to probe.
+  probe.attach_function :sfClock_isRunning, [:pointer], :bool
+rescue FFI::NotFoundError
+  raise SFML::LoadError, <<~MSG.chomp
+
+    ============================================================================
+    ruby-sfml requires CSFML #{SFML::CSFML_VERSION} or compatible.
+
+    The libcsfml-system on your system is older than 3.0 — it's missing
+    'sfClock_isRunning', which was added in the SFML 3.0 / CSFML 3.0
+    release (March 2025).
+
+    Fix:
+      Ubuntu 25.04+ / Debian:  sudo apt install libcsfml-dev
+      Ubuntu 22.04 / 24.04:    repo is too old, build from source:
+                                 https://github.com/SFML/CSFML/releases/tag/3.0.0
+      macOS (brew):            brew upgrade csfml
+      Arch Linux:              sudo pacman -S csfml
+      Windows:                 https://www.sfml-dev.org/download/csfml/
+
+    See also: https://github.com/SFML/CSFML/releases for the latest 3.x.
+    ============================================================================
+  MSG
+end
+
+require "sfml/c/system"
+require "sfml/c/window"
+require "sfml/c/graphics"
+require "sfml/c/audio"
+require "sfml/c/network"

data/lib/sfml/game.rb

@@ -0,0 +1,101 @@
+module SFML
+  # Subclass-friendly main loop. Removes the boilerplate of window creation,
+  # event pumping, clock management, and clear/display so a small game fits
+  # in a few methods.
+  #
+  #   class MyGame < SFML::Game
+  #     def setup
+  #       @ball = SFML::CircleShape.new(radius: 30, position: [200, 200],
+  #                                     fill_color: SFML::Color.white)
+  #     end
+  #
+  #     def update(dt)
+  #       @ball.move([60 * dt.as_seconds, 30 * dt.as_seconds])
+  #     end
+  #
+  #     def draw
+  #       window.draw(@ball)
+  #     end
+  #   end
+  #
+  #   MyGame.new(title: "Hello").run
+  #
+  # The loop auto-handles :closed and :key_pressed/:escape by calling #quit;
+  # everything else is forwarded to #on_event. Override that to handle keys,
+  # mouse, etc.
+  class Game
+    attr_reader   :window
+    attr_accessor :background_color
+
+    def initialize(
+      width: 800, height: 600, title: nil,
+      framerate: 60, vsync: nil,
+      background: Color::BLACK,
+      style: nil, fullscreen: false
+    )
+      window_opts = { framerate: framerate, fullscreen: fullscreen }
+      window_opts[:vsync] = vsync   unless vsync.nil?
+      window_opts[:style] = style   unless style.nil?
+
+      @window           = RenderWindow.new(width, height, title || self.class.name, **window_opts)
+      @background_color = background
+    end
+
+    # Width and height shortcuts that always reflect the current window size,
+    # which matters once the user is allowed to resize.
+    def width  = @window.size.x
+    def height = @window.size.y
+
+    # Close the window. The main loop exits at the start of the next frame.
+    def quit
+      @window.close
+      self
+    end
+
+    # The main entry point. Calls #setup once, then runs the per-frame loop
+    # until the window closes.
+    def run
+      setup
+      clock = Clock.new
+      while @window.open?
+        dt = clock.restart
+        @window.each_event { |event| _dispatch(event) }
+        update(dt)
+        @window.clear(@background_color)
+        draw
+        @window.display
+      end
+      teardown
+      self
+    end
+
+    # ---- Override these in subclasses --------------------------------------
+
+    # Called once, just before the first frame. Build initial state here.
+    def setup; end
+
+    # Called every frame. `dt` is a SFML::Time covering the previous frame.
+    def update(dt); end
+
+    # Called every frame after #update. Use window.draw(...) for any drawables.
+    def draw; end
+
+    # Called for events the framework didn't auto-handle (everything except
+    # :closed and the Esc key). Call #quit from here to exit on a custom key.
+    def on_event(event); end
+
+    # Called once after the window closes. Useful for saving state. Default
+    # is a no-op.
+    def teardown; end
+
+    private
+
+    def _dispatch(event)
+      case event
+      in {type: :closed}                     then quit
+      in {type: :key_pressed, code: :escape} then quit
+      else                                        on_event(event)
+      end
+    end
+  end
+end

data/lib/sfml/graphics/blend_mode.rb

@@ -0,0 +1,108 @@
+module SFML
+  # How source pixels combine with destination pixels when drawing.
+  # Use the named constants for the common cases:
+  #
+  #   window.draw(sprite, blend_mode: SFML::BlendMode::ADD)
+  #
+  # ADD       — bright shapes accumulate (great for glow / lighting)
+  # MULTIPLY  — darken (shadows, screen-style overlays)
+  # MIN / MAX — pick the darker / brighter pixel
+  # NONE      — overwrite, ignoring the destination
+  # ALPHA     — the default; src*α blended onto dst
+  #
+  # Build a custom mode with kwargs:
+  #
+  #   SFML::BlendMode.new(
+  #     color_src: :src_alpha, color_dst: :one, color_eq: :add,
+  #     alpha_src: :one,       alpha_dst: :one, alpha_eq: :add,
+  #   )
+  class BlendMode
+    # Order matches sfBlendFactor in CSFML 3.
+    FACTORS = %i[
+      zero one src_color one_minus_src_color dst_color one_minus_dst_color
+      src_alpha one_minus_src_alpha dst_alpha one_minus_dst_alpha
+    ].freeze
+    FACTOR_INDEX = FACTORS.each_with_index.to_h.freeze
+
+    EQUATIONS = %i[add subtract reverse_subtract min max].freeze
+    EQUATION_INDEX = EQUATIONS.each_with_index.to_h.freeze
+
+    attr_reader :color_src, :color_dst, :color_eq,
+                :alpha_src, :alpha_dst, :alpha_eq
+
+    def initialize(color_src:, color_dst:, color_eq:,
+                   alpha_src:, alpha_dst:, alpha_eq:)
+      @color_src = _check_factor(color_src)
+      @color_dst = _check_factor(color_dst)
+      @color_eq  = _check_equation(color_eq)
+      @alpha_src = _check_factor(alpha_src)
+      @alpha_dst = _check_factor(alpha_dst)
+      @alpha_eq  = _check_equation(alpha_eq)
+      freeze
+    end
+
+    def ==(other)
+      other.is_a?(BlendMode) &&
+        color_src == other.color_src && color_dst == other.color_dst && color_eq == other.color_eq &&
+        alpha_src == other.alpha_src && alpha_dst == other.alpha_dst && alpha_eq == other.alpha_eq
+    end
+    alias eql? ==
+    def hash = [color_src, color_dst, color_eq, alpha_src, alpha_dst, alpha_eq].hash
+
+    def to_s
+      "BlendMode(color: #{color_src}/#{color_dst}/#{color_eq}, alpha: #{alpha_src}/#{alpha_dst}/#{alpha_eq})"
+    end
+    alias inspect to_s
+
+    # @!visibility private
+    # Write our six fields into a CSFML BlendMode struct (or a sub-struct
+    # of an existing RenderStates buffer).
+    def populate(struct)
+      struct[:color_src_factor] = FACTOR_INDEX[@color_src]
+      struct[:color_dst_factor] = FACTOR_INDEX[@color_dst]
+      struct[:color_equation]   = EQUATION_INDEX[@color_eq]
+      struct[:alpha_src_factor] = FACTOR_INDEX[@alpha_src]
+      struct[:alpha_dst_factor] = FACTOR_INDEX[@alpha_dst]
+      struct[:alpha_equation]   = EQUATION_INDEX[@alpha_eq]
+      struct
+    end
+
+    # @!visibility private
+    def self.from_native(struct)
+      new(
+        color_src: FACTORS[struct[:color_src_factor]],
+        color_dst: FACTORS[struct[:color_dst_factor]],
+        color_eq:  EQUATIONS[struct[:color_equation]],
+        alpha_src: FACTORS[struct[:alpha_src_factor]],
+        alpha_dst: FACTORS[struct[:alpha_dst_factor]],
+        alpha_eq:  EQUATIONS[struct[:alpha_equation]],
+      )
+    end
+
+    # Defined as private at the bottom of the file would arrive too late
+    # — the constants below call .new through .from_native, which goes
+    # through #initialize, which uses these checks.
+    private
+
+    def _check_factor(name)
+      raise ArgumentError, "Unknown blend factor: #{name.inspect}" unless FACTOR_INDEX.key?(name)
+      name
+    end
+
+    def _check_equation(name)
+      raise ArgumentError, "Unknown blend equation: #{name.inspect}" unless EQUATION_INDEX.key?(name)
+      name
+    end
+
+    public
+
+    # Built-in modes — read straight out of CSFML's global constants so
+    # we never have to hand-maintain the canonical factor lists.
+    ALPHA    = from_native(C::Graphics.sfBlendAlpha)
+    ADD      = from_native(C::Graphics.sfBlendAdd)
+    MULTIPLY = from_native(C::Graphics.sfBlendMultiply)
+    MIN      = from_native(C::Graphics.sfBlendMin)
+    MAX      = from_native(C::Graphics.sfBlendMax)
+    NONE     = from_native(C::Graphics.sfBlendNone)
+  end
+end

data/lib/sfml/graphics/circle_shape.rb

@@ -0,0 +1,67 @@
+module SFML
+  # A filled circle (or regular polygon if you set point_count). Cheapest
+  # drawable that requires no asset file — perfect for placeholders.
+  #
+  #   ball = SFML::CircleShape.new(
+  #     radius: 20,
+  #     position: [400, 300],
+  #     fill_color: SFML::Color.red,
+  #   )
+  #   window.draw(ball)
+  class CircleShape
+    include Graphics::Transformable
+    CSFML_PREFIX = :sfCircleShape
+
+    def initialize(radius: 10.0, **opts)
+      ptr = C::Graphics.sfCircleShape_create
+      raise Error, "sfCircleShape_create returned NULL" if ptr.null?
+      @handle = FFI::AutoPointer.new(ptr, C::Graphics.method(:sfCircleShape_destroy))
+
+      self.radius = radius
+      self.point_count        = opts[:point_count]        if opts[:point_count]
+      self.fill_color         = opts[:fill_color]         if opts.key?(:fill_color)
+      self.outline_color      = opts[:outline_color]      if opts.key?(:outline_color)
+      self.outline_thickness  = opts[:outline_thickness]  if opts.key?(:outline_thickness)
+      self.position           = opts[:position]           if opts.key?(:position)
+      self.origin             = opts[:origin]             if opts.key?(:origin)
+      self.rotation           = opts[:rotation]           if opts.key?(:rotation)
+      self.scale              = opts[:scale]              if opts.key?(:scale)
+    end
+
+    def radius = C::Graphics.sfCircleShape_getRadius(@handle)
+
+    def radius=(value)
+      C::Graphics.sfCircleShape_setRadius(@handle, value.to_f)
+    end
+
+    def point_count = C::Graphics.sfCircleShape_getPointCount(@handle)
+
+    def point_count=(n)
+      C::Graphics.sfCircleShape_setPointCount(@handle, Integer(n))
+    end
+
+    def fill_color = Color.from_native(C::Graphics.sfCircleShape_getFillColor(@handle))
+
+    def fill_color=(c)
+      C::Graphics.sfCircleShape_setFillColor(@handle, c.to_native)
+    end
+
+    def outline_color = Color.from_native(C::Graphics.sfCircleShape_getOutlineColor(@handle))
+
+    def outline_color=(c)
+      C::Graphics.sfCircleShape_setOutlineColor(@handle, c.to_native)
+    end
+
+    def outline_thickness = C::Graphics.sfCircleShape_getOutlineThickness(@handle)
+
+    def outline_thickness=(t)
+      C::Graphics.sfCircleShape_setOutlineThickness(@handle, t.to_f)
+    end
+
+    def draw_on(target, states_ptr = nil) # :nodoc:
+      target._draw_native(:CircleShape, @handle, states_ptr)
+    end
+
+    attr_reader :handle # :nodoc:
+  end
+end

data/lib/sfml/graphics/color.rb

@@ -0,0 +1,89 @@
+module SFML
+  # 32-bit RGBA color, immutable.
+  #
+  #   SFML::Color.new(255, 100, 50)        # opaque
+  #   SFML::Color.new(255, 100, 50, 128)   # half-transparent
+  #   SFML::Color.rgb(255, 100, 50)        # alias
+  #   SFML::Color.rgba(255, 100, 50, 128)
+  #   SFML::Color["#ff6432"]               # hex (RGB or RRGGBB or RRGGBBAA)
+  #   SFML::Color.cornflower_blue          # named
+  class Color
+    attr_reader :r, :g, :b, :a
+
+    def initialize(r, g, b, a = 255)
+      @r = Integer(r)
+      @g = Integer(g)
+      @b = Integer(b)
+      @a = Integer(a)
+      freeze
+    end
+
+    def self.rgb(r, g, b)        = new(r, g, b, 255)
+    def self.rgba(r, g, b, a)    = new(r, g, b, a)
+
+    def self.[](hex)
+      str = hex.to_s.delete_prefix("#")
+      case str.length
+      when 3
+        new(str[0].hex * 17, str[1].hex * 17, str[2].hex * 17, 255)
+      when 6
+        new(str[0..1].to_i(16), str[2..3].to_i(16), str[4..5].to_i(16), 255)
+      when 8
+        new(str[0..1].to_i(16), str[2..3].to_i(16), str[4..5].to_i(16), str[6..7].to_i(16))
+      else
+        raise ArgumentError, "Color hex must be #RGB, #RRGGBB, or #RRGGBBAA, got #{hex.inspect}"
+      end
+    end
+
+    def ==(other)
+      other.is_a?(Color) && @r == other.r && @g == other.g && @b == other.b && @a == other.a
+    end
+    alias eql? ==
+    def hash = [@r, @g, @b, @a].hash
+
+    def to_a = [@r, @g, @b, @a]
+    def to_h = { r: @r, g: @g, b: @b, a: @a }
+    def deconstruct = to_a
+    def deconstruct_keys(_keys) = to_h
+
+    def to_s = "Color(#{@r}, #{@g}, #{@b}, #{@a})"
+    alias inspect to_s
+
+    def to_native # :nodoc:
+      C::Graphics::Color.new.tap do |c|
+        c[:r] = @r; c[:g] = @g; c[:b] = @b; c[:a] = @a
+      end
+    end
+
+    def self.from_native(struct) # :nodoc:
+      new(struct[:r], struct[:g], struct[:b], struct[:a])
+    end
+
+    # Standard SFML colors.
+    BLACK       = new(0,   0,   0)
+    WHITE       = new(255, 255, 255)
+    RED         = new(255, 0,   0)
+    GREEN       = new(0,   255, 0)
+    BLUE        = new(0,   0,   255)
+    YELLOW      = new(255, 255, 0)
+    MAGENTA     = new(255, 0,   255)
+    CYAN        = new(0,   255, 255)
+    TRANSPARENT = new(0,   0,   0,   0)
+
+    # A nicer default than pure black for empty windows.
+    CORNFLOWER_BLUE = new(100, 149, 237)
+
+    class << self
+      def black           = BLACK
+      def white           = WHITE
+      def red             = RED
+      def green           = GREEN
+      def blue            = BLUE
+      def yellow          = YELLOW
+      def magenta         = MAGENTA
+      def cyan            = CYAN
+      def transparent     = TRANSPARENT
+      def cornflower_blue = CORNFLOWER_BLUE
+    end
+  end
+end