tung-tea 0.0.4

data/lib/tea/m_event_keyboard.rb

@@ -0,0 +1,299 @@
+# This file holds the key press and modifier events.
+
+require 'sdl'
+
+#
+module Tea
+
+  module Kbd
+    # Event generated when a key is pressed down.
+    #
+    # +key+::   Physical key that was pressed, as a symbol (see key reference).
+    # +mods+::  Hash of the active key modifiers.  Values are +true+ or
+    #           +false+, and the keys can be: +:L_SHIFT+, +:R_SHIFT+,
+    #           +:L_CTRL+, +:R_CTRL+, +:L_ALT+, +:R_ALT+, +:NUM_LOCK+,
+    #           +:CAPS_LOCK+, +:ALT_GR+.  Also, +:SHIFT+, +:CTRL+ and +:ALT+
+    #           are provided for convenience, and Tea key constants with the
+    #           same names can be used instead.
+    # +char+::  String character generated by that key and those modifiers.
+    #           With Ruby >= 1.9, the encoding of this character is UTF-8,
+    #           otherwise it varies with the running environment.
+    class Down
+      attr_reader :key, :mods, :char
+      def initialize(sdl_event)
+        @key = Kbd.instance_variable_get(:@sdl_key_table)[sdl_event.sym]
+        @mods = Kbd.send(:decode_modifiers, sdl_event.mod)
+
+        # Ruby 1.9 uses UTF-8 Unicode encoding.  Below this, who knows how
+        # Unicode code points are interpreted?
+        if sdl_event.unicode != 0
+          unicode_field = "%c"
+          ruby_minor = RUBY_VERSION.match(/\.(\d+)\./)
+          if ruby_minor && ruby_minor[1].to_i >= 9
+            unicode_field = unicode_field.encode('utf-8')
+          end
+          @char = unicode_field % sdl_event.unicode
+        else
+          @char = ''
+        end
+      end
+    end
+
+    # Event generated when a held-down key is released.  +key+ and +mods+ are
+    # the same as in KeyDown.
+    #
+    # +key+::   Physical key that was pressed, as a symbol (see key reference).
+    # +mods+::  Hash of the active key modifiers.  Values are +true+ or
+    #           +false+, and the keys can be: +:L_SHIFT+, +:R_SHIFT+,
+    #           +:L_CTRL+, +:R_CTRL+, +:L_ALT+, +:R_ALT+, +:NUM_LOCK+,
+    #           +:CAPS_LOCK+, +:ALT_GR+.  Also, +:SHIFT+, +:CTRL+ and +:ALT+
+    #           are provided for convenience, and Tea key constants with the
+    #           same names can be used instead.
+    class Up
+      attr_reader :key, :mods
+      def initialize(sdl_event)
+        @key = Kbd.instance_variable_get(:@sdl_key_table)[sdl_event.sym]
+        @mods = Kbd.send(:decode_modifiers, sdl_event.mod)
+      end
+    end
+
+    # Returns +true+ if +key+ is being pressed down.
+    def Kbd.key_down?(key)
+      if (down = @key_states[key]) == nil
+        raise Tea::Error, "Can't find key #{key} to check", caller
+      end
+      down
+    end
+
+    # Returns true if the modifier is 'active'.  For +:L_SHIFT+, +:R_SHIFT+,
+    # +:L_CTRL+, +:R_CTRL+, +:L_ALT+, and +:ALT_GR+ (and convenience modifier
+    # constants +:SHIFT+, +:CTRL+ and +:ALT+), this means they're being held
+    # down.  For +:NUM_LOCK+ and +:CAPS_LOCK+, this means their toggle is on.
+    def Kbd.mod_active?(mod)
+      if (active = @mod_states[mod]) == nil
+        raise Tea::Error, "Can't find modifier #{mod} to check", caller
+      end
+      active
+    end
+
+    # Returns true if the keyboard is focused in the screen window.
+    def Kbd.in_app?
+      @in_app = true if !instance_variable_defined?(:@in_app)
+      @in_app
+    end
+
+    # Update the keyboard state, so that Kbd.key_down? and Kbd.mod_active?
+    # provide fresh data.  Called automatically by Event.get.
+    def Kbd.update_state(tea_event)
+      case tea_event
+      when Down, Up
+        @key_states[tea_event.key] = (tea_event.class == Down)
+        @mod_states.merge! tea_event.mods
+      when Lost then   @in_app = false
+      when Gained then @in_app = true
+      end
+    end
+
+    # Decode the SDL key event mod into a hash of easily consulted key modifier
+    # symbols.  For internal use only.
+    def Kbd.decode_modifiers(sdl_key_event_mod)
+      mods = {}
+
+      mods[:L_SHIFT] = (sdl_key_event_mod & SDL::Key::MOD_LSHIFT) != 0
+      mods[:R_SHIFT] = (sdl_key_event_mod & SDL::Key::MOD_RSHIFT) != 0
+      mods[:SHIFT]   = mods[:L_SHIFT] || mods[:R_SHIFT]
+
+      mods[:L_CTRL] = (sdl_key_event_mod & SDL::Key::MOD_LCTRL) != 0
+      mods[:R_CTRL] = (sdl_key_event_mod & SDL::Key::MOD_RCTRL) != 0
+      mods[:CTRL]   = mods[:L_CTRL] || mods[:R_CTRL]
+
+      mods[:L_ALT] = (sdl_key_event_mod & SDL::Key::MOD_LALT) != 0
+      mods[:R_ALT] = (sdl_key_event_mod & SDL::Key::MOD_RALT) != 0
+      mods[:ALT]   = mods[:L_ALT] || mods[:R_ALT]
+
+      mods[:NUM_LOCK]  = (sdl_key_event_mod & SDL::Key::MOD_NUM) != 0
+      mods[:CAPS_LOCK] = (sdl_key_event_mod & SDL::Key::MOD_CAPS) != 0
+      mods[:ALT_GR]    = (sdl_key_event_mod & SDL::Key::MOD_MODE) != 0
+
+      mods
+    end
+    private_class_method :decode_modifiers
+
+    # Big fat table of SDL keys to Ruby strings.  For internal use only.
+    @sdl_key_table = { SDL::Key::BACKSPACE => :BACKSPACE,
+                       SDL::Key::TAB => :TAB,
+                       #SDL::Key::CLEAR => clear, # ???
+                       SDL::Key::RETURN => :ENTER,
+                       SDL::Key::PAUSE => :PAUSE,
+                       SDL::Key::ESCAPE => :ESCAPE,
+                       SDL::Key::SPACE => :SPACE,
+                       SDL::Key::EXCLAIM => :EXCLAMATION_MARK,
+                       SDL::Key::QUOTEDBL => :DOUBLE_QUOTE,
+                       SDL::Key::HASH => :HASH,
+                       SDL::Key::DOLLAR => :DOLLAR,
+                       SDL::Key::AMPERSAND => :AMPERSAND,
+                       SDL::Key::QUOTE => :QUOTE,
+                       SDL::Key::LEFTPAREN => :OPEN_PAREN,
+                       SDL::Key::RIGHTPAREN => :CLOSE_PAREN,
+                       SDL::Key::ASTERISK => :ASTERISK,
+                       SDL::Key::PLUS => :PLUS,
+                       SDL::Key::COMMA => :COMMA,
+                       SDL::Key::MINUS => :MINUS,
+                       SDL::Key::PERIOD => :PERIOD,
+                       SDL::Key::SLASH => :SLASH,
+                       SDL::Key::K0 => :K0,
+                       SDL::Key::K1 => :K1,
+                       SDL::Key::K2 => :K2,
+                       SDL::Key::K3 => :K3,
+                       SDL::Key::K4 => :K4,
+                       SDL::Key::K5 => :K5,
+                       SDL::Key::K6 => :K6,
+                       SDL::Key::K7 => :K7,
+                       SDL::Key::K8 => :K8,
+                       SDL::Key::K9 => :K9,
+                       SDL::Key::COLON => :COLON,
+                       SDL::Key::SEMICOLON => :SEMICOLON,
+                       SDL::Key::LESS => :LESS_THAN,
+                       SDL::Key::EQUALS => :EQUALS,
+                       SDL::Key::GREATER => :GREATER_THAN,
+                       SDL::Key::QUESTION => :QUESTION_MARK,
+                       SDL::Key::AT => :AT,
+                       SDL::Key::LEFTBRACKET => :OPEN_SQUARE_BRACKET,
+                       SDL::Key::BACKSLASH => :BACKSLASH,
+                       SDL::Key::RIGHTBRACKET => :CLOSE_SQUARE_BRACKET,
+                       SDL::Key::CARET => :CARET,
+                       SDL::Key::UNDERSCORE => :UNDERSCORE,
+                       SDL::Key::BACKQUOTE => :BACKTICK,
+                       SDL::Key::A => :A,
+                       SDL::Key::B => :B,
+                       SDL::Key::C => :C,
+                       SDL::Key::D => :D,
+                       SDL::Key::E => :E,
+                       SDL::Key::F => :F,
+                       SDL::Key::G => :G,
+                       SDL::Key::H => :H,
+                       SDL::Key::I => :I,
+                       SDL::Key::J => :J,
+                       SDL::Key::K => :K,
+                       SDL::Key::L => :L,
+                       SDL::Key::M => :M,
+                       SDL::Key::N => :N,
+                       SDL::Key::O => :O,
+                       SDL::Key::P => :P,
+                       SDL::Key::Q => :Q,
+                       SDL::Key::R => :R,
+                       SDL::Key::S => :S,
+                       SDL::Key::T => :T,
+                       SDL::Key::U => :U,
+                       SDL::Key::V => :V,
+                       SDL::Key::W => :W,
+                       SDL::Key::X => :X,
+                       SDL::Key::Y => :Y,
+                       SDL::Key::Z => :Z,
+                       SDL::Key::DELETE => :DELETE,
+                       SDL::Key::KP0 => :NP0,
+                       SDL::Key::KP1 => :NP1,
+                       SDL::Key::KP2 => :NP2,
+                       SDL::Key::KP3 => :NP3,
+                       SDL::Key::KP4 => :NP4,
+                       SDL::Key::KP5 => :NP5,
+                       SDL::Key::KP6 => :NP6,
+                       SDL::Key::KP7 => :NP7,
+                       SDL::Key::KP8 => :NP8,
+                       SDL::Key::KP9 => :NP9,
+                       SDL::Key::KP_PERIOD => :NP_PERIOD,
+                       SDL::Key::KP_DIVIDE => :NP_DIVIDE,
+                       SDL::Key::KP_MULTIPLY => :NP_MULTIPLY,
+                       SDL::Key::KP_MINUS => :NP_MINUS,
+                       SDL::Key::KP_PLUS => :NP_PLUS,
+                       SDL::Key::KP_ENTER => :NP_ENTER,
+                       SDL::Key::KP_EQUALS => :NP_EQUALS,
+                       SDL::Key::UP => :UP,
+                       SDL::Key::DOWN => :DOWN,
+                       SDL::Key::RIGHT => :RIGHT,
+                       SDL::Key::LEFT => :LEFT,
+                       SDL::Key::INSERT => :INSERT,
+                       SDL::Key::HOME => :HOME,
+                       SDL::Key::END => :END,
+                       SDL::Key::PAGEUP => :PAGE_UP,
+                       SDL::Key::PAGEDOWN => :PAGE_DOWN,
+                       SDL::Key::F1 => :F1,
+                       SDL::Key::F2 => :F2,
+                       SDL::Key::F3 => :F3,
+                       SDL::Key::F4 => :F4,
+                       SDL::Key::F5 => :F5,
+                       SDL::Key::F6 => :F6,
+                       SDL::Key::F7 => :F7,
+                       SDL::Key::F8 => :F8,
+                       SDL::Key::F9 => :F9,
+                       SDL::Key::F10 => :F10,
+                       SDL::Key::F11 => :F11,
+                       SDL::Key::F12 => :F12,
+                       #SDL::Key::F13 => F13, # Who
+                       #SDL::Key::F14 => F14, # has
+                       #SDL::Key::F15 => F15, # these?
+                       SDL::Key::NUMLOCK => :NUM_LOCK,
+                       SDL::Key::CAPSLOCK => :CAPS_LOCK,
+                       SDL::Key::SCROLLOCK => :SCROLL_LOCK,
+                       SDL::Key::RSHIFT => :R_SHIFT,
+                       SDL::Key::LSHIFT => :L_SHIFT,
+                       SDL::Key::RCTRL => :R_CTRL,
+                       SDL::Key::LCTRL => :L_CTRL,
+                       SDL::Key::RALT => :R_ALT,
+                       SDL::Key::LALT => :L_ALT,
+                       #SDL::Key::RMETA => right meta, # 'meta' should
+                       #SDL::Key::LMETA => left meta,  # be 'alt'?
+                       SDL::Key::LSUPER => :L_SUPER,
+                       SDL::Key::RSUPER => :R_SUPER,
+                       SDL::Key::MODE => :ALT_GR,
+                       #SDL::Key::HELP => help, # Rare enough to cause problems.
+                       SDL::Key::PRINT => :PRINT_SCREEN,
+                       SDL::Key::SYSREQ => :SYS_REQ,
+                       SDL::Key::BREAK => :BREAK,
+                       SDL::Key::MENU => :MENU,
+                       #SDL::Key::POWER => power, # "Power Macintosh" power key
+                       SDL::Key::EURO => :EURO, # Some European keyboards need this.
+                       }
+
+    # Define Tea key symbols as constants to avoid typo errors.
+    @sdl_key_table.each_value { |sym| const_set(sym, sym) }
+
+    # Extra modifier constants for making modifier detection more consistent.
+    SHIFT = :shift
+    CTRL = :ctrl
+    ALT = :alt
+
+    # Initialise key states to false, as opposed to nil.
+    @key_states = {}
+    @sdl_key_table.each_value { |sym| @key_states[sym] = false }
+
+    # Modifier states, same deal.
+    @mod_states = { :L_SHIFT => false, :R_SHIFT => false, :SHIFT => false,
+                    :L_CTRL  => false, :R_CTRL  => false, :CTRL  => false,
+                    :L_ALT   => false, :R_ALT   => false, :ALT   => false,
+                    :NUM_LOCK => false,
+                    :CAPS_LOCK => false,
+                    :ALT_GR => false }
+  end
+
+  module Event
+
+    # Convert a keyboard-related SDL::Event into a Tea event.  For internal use
+    # only.
+    def Event.translate_keyboard_event(sdl_event)
+      out_events = []
+
+      case sdl_event
+      when SDL::Event::KeyDown
+        out_events.push Kbd::Down.new(sdl_event)
+      when SDL::Event::KeyUp
+        out_events.push Kbd::Up.new(sdl_event)
+      end
+
+      out_events
+    end
+    private_class_method :translate_keyboard_event
+
+  end
+
+end

data/lib/tea/m_event_mouse.rb

@@ -0,0 +1,190 @@
+# This file holds the mouse motion and button events.
+
+require 'sdl'
+
+# Hot-patch for Ruby/SDL for missing mouse wheel constants.
+module SDL
+  module Mouse
+    BUTTON_WHEELUP = 4
+    BUTTON_WHEELDOWN = 5
+  end
+end
+
+#
+module Tea
+
+  module Mouse
+
+    # Mouse button constants for mouse events.
+    LEFT = :LEFT
+    MIDDLE = :MIDDLE
+    RIGHT = :RIGHT
+
+    # Event generated when the mouse cursor is moved.
+    #
+    # +x+, +y+::    coordinates of the mouse cursor
+    # +buttons+::   an array that may contain +:left+, +:middle+ and +:right+
+    class Move
+      attr_reader :x, :y, :buttons
+      def initialize(sdl_event)
+        @x = sdl_event.x
+        @y = sdl_event.y
+        @buttons = {}
+        @buttons[Mouse::LEFT]   = (sdl_event.state & SDL::Mouse::BUTTON_LMASK) != 0
+        @buttons[Mouse::MIDDLE] = (sdl_event.state & SDL::Mouse::BUTTON_MMASK) != 0
+        @buttons[Mouse::RIGHT]  = (sdl_event.state & SDL::Mouse::BUTTON_RMASK) != 0
+      end
+    end
+
+    # Event generated when a mouse button is held down.
+    #
+    # +x+, +y+::    coordinates of the mouse cursor
+    # +button+::    the mouse button that is down: +:left+, +:middle+ or +:right+
+    class Down
+      attr_reader :x, :y, :button
+      def initialize(sdl_event)
+        @x = sdl_event.x
+        @y = sdl_event.y
+        case sdl_event.button
+        when SDL::Mouse::BUTTON_LEFT   then @button = Mouse::LEFT
+        when SDL::Mouse::BUTTON_MIDDLE then @button = Mouse::MIDDLE
+        when SDL::Mouse::BUTTON_RIGHT  then @button = Mouse::RIGHT
+        end
+      end
+    end
+
+    # Event generated when a mouse button that was held down is released.
+    #
+    # +x+, +y+::    coordinates of the mouse cursor
+    # +button+::    the mouse button that was released: +:left+, +:middle+ or
+    #               +:right+
+    class Up
+      attr_reader :x, :y, :button
+      def initialize(sdl_event)
+        @x = sdl_event.x
+        @y = sdl_event.y
+        case sdl_event.button
+        when SDL::Mouse::BUTTON_LEFT   then @button = Mouse::LEFT
+        when SDL::Mouse::BUTTON_MIDDLE then @button = Mouse::MIDDLE
+        when SDL::Mouse::BUTTON_RIGHT  then @button = Mouse::RIGHT
+        end
+      end
+    end
+
+    # Event generated when the mouse wheel is scrolled.
+    #
+    # +x+, +y+::    coordinates of the mouse cursor.
+    # +delta+::     1 when scrolling down, -1 when scrolling up.
+    class Scroll
+      attr_reader :x, :y, :delta
+      def initialize(sdl_event)
+        @x = sdl_event.x
+        @y = sdl_event.y
+        case sdl_event.button
+        when SDL::Mouse::BUTTON_WHEELDOWN then @delta = 1
+        when SDL::Mouse::BUTTON_WHEELUP   then @delta = -1
+        else
+          raise Tea::Error, "Tea::Mouse::Scroll given an unexpected event: #{sdl_event.inspect}", caller
+        end
+      end
+    end
+
+    # Report the x position of the mouse in the screen window.  Updated when
+    # Event.get is called.
+    def Mouse.x
+      @x = 0 if !instance_variable_defined?(:@x)
+      @x
+    end
+
+    # Report the y position of the mouse in the screen window.  Updated when
+    # Event.get is called.
+    def Mouse.y
+      @y = 0 if !instance_variable_defined?(:@y)
+      @y
+    end
+
+    # Returns true if the left mouse button is down.  Updated when Event.get is
+    # called.
+    def Mouse.left?
+      @left = false if !instance_variable_defined?(:@left)
+      @left
+    end
+
+    # Returns true if the middle mouse button is down.  Updated when Event.get
+    # is called.
+    def Mouse.middle?
+      @middle = false if !instance_variable_defined?(:@middle)
+      @middle
+    end
+
+    # Returns true if the right mouse button is down.  Updated when Event.get
+    # is called.
+    def Mouse.right?
+      @right = false if !instance_variable_defined?(:@right)
+      @right
+    end
+
+    # Returns true if the mouse is in the screen window
+    def Mouse.in_app?
+      @in_app = true if !instance_variable_defined?(:@in_app)
+      @in_app
+    end
+
+    # Update the mouse state, so that Mouse.x, Mouse.y, Mouse.left?,
+    # Mouse.middle? and Mouse.right? return recent data.
+    def Mouse.update_state(tea_event)
+      case tea_event
+      when Move
+        @x = tea_event.x
+        @y = tea_event.y
+      when Down
+        case tea_event.button
+        when LEFT   then @left = true
+        when MIDDLE then @middle = true
+        when RIGHT  then @right = true
+        end
+      when Up
+        case tea_event.button
+        when LEFT   then @left = false
+        when MIDDLE then @middle = false
+        when RIGHT  then @right = false
+        end
+      when Lost
+        @in_app = false
+      when Gained
+        @in_app = true
+      end
+    end
+  end
+
+  module Event
+
+    # Convert a mouse-related SDL::Event into a Tea event.  For internal use only.
+    def Event.translate_mouse_event(sdl_event)
+      out_events = []
+
+      case sdl_event
+      when SDL::Event::MouseMotion
+        out_events.push Mouse::Move.new(sdl_event)
+      when SDL::Event::MouseButtonDown
+        case sdl_event.button
+        when SDL::Mouse::BUTTON_LEFT, SDL::Mouse::BUTTON_MIDDLE, SDL::Mouse::BUTTON_RIGHT
+          out_events.push Mouse::Down.new(sdl_event)
+        when SDL::Mouse::BUTTON_WHEELDOWN, SDL::Mouse::BUTTON_WHEELUP
+          out_events.push Mouse::Scroll.new(sdl_event)
+        end
+      when SDL::Event::MouseButtonUp
+        # Ignore MouseButtonUp for the scroll wheel.
+        case sdl_event.button
+        when SDL::Mouse::BUTTON_LEFT, SDL::Mouse::BUTTON_MIDDLE, SDL::Mouse::BUTTON_RIGHT
+          out_events.push Mouse::Up.new(sdl_event)
+        end
+      end
+
+      out_events
+    end
+    private_class_method :translate_mouse_event
+
+  end
+
+end

data/lib/tea/m_primitive_drawing.rb

@@ -0,0 +1,79 @@
+# This file holds the classes and methods needed to draw primitives on Bitmaps.
+
+require 'sdl'
+
+#
+module Tea
+
+  private
+
+  # The PrimitiveDrawing mixin enables primitive shapes to be drawn to classes
+  # with an internal SDL::Surface.
+  #
+  # To use this mixin, include it and implement/alias a +primitive_buffer+
+  # method that gets the object's SDL::Surface.
+  #
+  #   include 'PrimitiveDrawing'
+  #   def primitive_buffer
+  #     @internal_sdl_buffer
+  #   end
+  module PrimitiveDrawing
+
+    # Clear the drawing buffer.  This is the same as drawing a completely black
+    # rectangle over the whole buffer.
+    def clear
+      primitive_buffer.fill_rect 0, 0, primitive_buffer.w, primitive_buffer.h,
+                                 primitive_color(0x000000ff)
+    end
+
+    # Plot a point at (x, y) with the given color (0xRRGGBBAA) on the Bitmap.
+    def point(x, y, color)
+      primitive_buffer[x, y] = primitive_color(color)
+    end
+
+    # Draw a rectangle of size w * h with the top-left corner at (x, y) with
+    # the given color (0xRRGGBBAA).
+    def rect(x, y, w, h, color)
+      primitive_buffer.fill_rect x, y, w, h, primitive_color(color)
+    end
+
+    # Draw a line from (x1, y1) to (x2, y2) with the given color (0xRRGGBBAA).
+    # Optional hash arguments:
+    #
+    # +:antialias+::    If true, smooth the line with antialiasing.
+    def line(x1, y1, x2, y2, color, options=nil)
+      primitive_buffer.draw_line x1, y1, x2, y2,
+                                 primitive_color(color),
+                                 (options[:antialias] if options)
+    end
+
+    # Draw a circle centred at (x, y) with the given radius and color.
+    # Optional hash arguments:
+    #
+    # +:outline+::    If true, do not fill the circle, just draw an outline.
+    # +:antialias+::  If true, smooth the edges of the circle with
+    #                 antialiasing.
+    def circle(x, y, radius, color, options=nil)
+      if options
+        primitive_buffer.draw_circle x, y, radius, primitive_color(color),
+                                     !options[:outline], options[:antialias]
+      else
+        primitive_buffer.draw_circle x, y, radius, primitive_color(color), true
+      end
+    end
+
+    private
+
+    # Convert hex_color of the form 0xRRGGBBAA to a color value the
+    # primitive_buffer understands.
+    def primitive_color(hex_color)
+      red   = (hex_color & 0xff000000) >> 24
+      green = (hex_color & 0x00ff0000) >> 16
+      blue  = (hex_color & 0x0000ff00) >>  8
+      alpha = (hex_color & 0x000000ff)
+      primitive_buffer.map_rgba(red, green, blue, alpha)
+    end
+
+  end
+
+end

data/lib/tea/screen.rb

@@ -0,0 +1,59 @@
+# This file contains the Screen class.
+
+require 'sdl'
+
+require 'tea/m_blitting'
+require 'tea/m_primitive_drawing'
+
+#
+module Tea
+
+  # A Bitmap-like object that displays its contents on the screen when drawn to
+  # and updated.
+  class Screen
+
+    # Video buffer depth.
+    BITS_PER_PIXEL = 32
+
+    # Set or change the screen video mode, giving a width * height screen buffer.
+    def Screen.set_mode(width, height)
+      begin
+        @screen = SDL::Screen.open(width, height, BITS_PER_PIXEL, SDL::SWSURFACE)
+        @set_mode_callbacks.each { |c| c.call }
+      rescue SDL::Error => e
+        raise Tea::Error, e.message, e.backtrace
+      end
+    end
+
+    # Check if Screen.set_mode has been called yet.
+    def Screen.mode_set?
+      @screen ? true : false
+    end
+
+    # Set a proc to be called when Screen.set_mode is called.  The proc will be
+    # called after the new screen mode is set.  The callback ordering is not
+    # defined, so don't make callbacks that depend on other callbacks being
+    # called first.
+    def Screen.on_set_mode(callback)
+      @set_mode_callbacks << callback
+    end
+    @set_mode_callbacks = []
+
+    # Get the screen width in pixels.
+    def Screen.w; @screen.w; end
+
+    # Get the screen height in pixels.
+    def Screen.h; @screen.h; end
+
+    # Update the screen so that things drawn on it are displayed.
+    def Screen.update; @screen.flip; end
+
+    extend Blitting
+    def Screen.blittable_buffer; @screen; end
+
+    extend PrimitiveDrawing
+    def Screen.primitive_buffer; @screen; end
+
+  end
+
+end

data/lib/tea.rb

@@ -0,0 +1,29 @@
+# Tea is a simple 2D game development library for Ruby.
+
+require 'sdl'
+
+require 'tea/c_bitmap'
+require 'tea/c_error'
+require 'tea/m_event'
+require 'tea/screen'
+
+# The Tea module acts as a namespace for all Tea-related objects and
+# methods.
+module Tea
+
+  # Initialise Tea.  This needs to be called before using any of Tea's
+  # objects or methods.
+  #
+  # May throw Tea::Error if initialisation fails.
+  def Tea.init
+    begin
+      SDL.init(SDL::INIT_VIDEO)
+
+      # Get typed characters from keys when pressed.
+      SDL::Event.enable_unicode
+    rescue SDL::Error => e
+      raise Tea::Error, e.message, e.backtrace
+    end
+  end
+
+end