graphics 1.0.0b6 → 1.0.0

data/graphics_setup.sh

@@ -1,26 +1,56 @@
 #!/bin/sh
 set -e
+set -v
 
-for pkg in sdl sdl_image sdl_ttf sdl_mixer sdl_gfx smpeg freetype libogg libvorbis libsmpeg libpng libtiff; do
-    brew uninstall $pkg || true
-done
+# if [ $(id -u) != 0 ]; then
+#     echo "Please run this as root or with sudo"
+#     exit 1
+# fi
 
-for gem in graphics rubysdl rsdl; do
-    gem uninstall -ax $gem || true
+for gem in graphics rsdl; do
+  gem uninstall -ax $gem || true
 done
 
-# brew update
+case `uname` in
+    Darwin)
+	echo "I'm on OSX. Not using sudo"
+	SUDO=
+
+	brew unlink sdl
+	brew unlink sdl_mixer
+	brew unlink sdl_ttf
+	brew unlink sdl_image
+
+	brew install sdl2
+	brew install sdl2_mixer
+	brew install sdl2_ttf
+	brew install sdl2_image --without-webp
+        brew install sdl2_gfx
+	;;
+    Linux)
+	echo "I'm on linux, using sudo where needed"
+	SUDO=sudo
+
+	$SUDO apt-get install --no-install-recommends --no-install-suggests libsdl1.2-dev libsdl-image1.2-dev libsdl-mixer1.2-dev libsdl-ttf2.0-dev
+	$SUDO apt-get install --no-install-recommends --no-install-suggests gcc g++
+	;;
+    *)
+	echo "Unknown OS $OSTYPE, aborting"
+	exit 1
+	;;
+esac
+
+$SUDO gem update --system -N -V
 
-brew install sdl       --universal
-brew install sdl_mixer --universal --with-smpeg
-brew install sdl_ttf   --universal
-brew install sdl_image --universal --without-webp
+gem install hoe --conservative
+$SUDO rake newb
+rake test
 
 if [ -f $0 ]; then
     rake clean package
-    gem install pkg/graphics*.gem
+    $SUDO gem install pkg/graphics*.gem
 else
-    gem install graphics --pre
+    $SUDO gem install graphics --pre
 fi
 
-rsdl -rgraphics -e 'Class.new(Graphics::Simulation) { def draw n; clear :white; text "hit escape to quit", 100, 100, :black; end; }.new(500, 250, 0, "Working!").run'
+rsdl -Ilib -rgraphics -e 'Class.new(Graphics::Simulation) { def draw n; clear :white; text "hit escape to quit", 100, 100, :black; end; }.new(500, 250, 0, "Working!").run'

data/lib/graphics.rb

@@ -2,7 +2,7 @@
 # The top-level namespace.
 
 class Graphics
-  VERSION = "1.0.0b6" # :nodoc:
+  VERSION = "1.0.0" # :nodoc:
 end
 
 require "graphics/simulation"

data/lib/graphics/body.rb

@@ -70,6 +70,14 @@ class Graphics::Body
     self.m = 0.0
   end
 
+  ##
+  # Update the body. Does nothing by default. Override this method to
+  # add behavior to the body.
+
+  def update
+    # do nothing
+  end
+
   def inspect # :nodoc:
     "%s(%.2fx%.2f @ %.2f°x%.2f == %p @ %p)" %
       [self.class, x, y, a, m, position, velocity]

data/lib/graphics/decorators.rb

@@ -1,12 +1,20 @@
+##
+# Include this in your simulation to automatically include an FPS
+# meter.
+
 module ShowFPS
-  def draw n
+  def draw n # :nodoc:
     super
     fps n
   end
 end
 
+##
+# Include this in your simulation and define +GRID_WIDTH+ to draw a
+# grid in the window.
+
 module DrawGrid
-  def pre_draw n
+  def pre_draw n # :nodoc:
     super
 
     (0...w).step(self.class::GRID_WIDTH).each do |x|
@@ -16,6 +24,10 @@ module DrawGrid
   end
 end
 
+##
+# Include this in your simulation to make the background white.
+
 module WhiteBackground
-  CLEAR_COLOR = :white
+  CLEAR_COLOR = :white # :nodoc:
+  DEBUG_COLOR = :black # :nodoc:
 end

data/lib/graphics/extensions.rb

@@ -25,7 +25,7 @@ class Numeric
   # Normalize a number to be within 0...360
 
   def degrees
-    (self < 0 ? self + 360 : self) % 360
+    self % 360
   end
 
   ##

data/lib/graphics/rainbows.rb

@@ -1,17 +1,20 @@
+##
+# Creates a range of colors all at once. See #initialize_rainbow.
+
 class Graphics::Rainbow
-  attr_reader :cache
+  attr_reader :cache # :nodoc:
 
-  def initialize
+  def initialize # :nodoc:
     @cache = self.cache_colors
   end
 
-  def clamp d, min, max
+  def clamp d, min, max # :nodoc:
     [[min, d].max, max].min
   end
 
   ##
-  # Takes a value and a range,
-  # and scales that range to 0-360
+  # Takes a value and a range, and scales that range to 0-360
+
   def scale d, min, max
     range = max - min
     if range != 0
@@ -22,7 +25,7 @@ class Graphics::Rainbow
     end
   end
 
-  def cache_colors
+  def cache_colors # :nodoc:
     # Saves all the colors to a hash
     cache = {}
     (0..360).each do |degree|
@@ -31,12 +34,12 @@ class Graphics::Rainbow
     cache
   end
 
-  def color d, min=0, max=360
+  def color d, min=0, max=360 # :nodoc:
     scaled = scale d, min, max
     @cache[scaled]
   end
 
-  def _color degree
+  def _color degree # :nodoc:
     raise "Subclass responsibility"
   end
   private :_color
@@ -46,11 +49,7 @@ end
 # Black to white gradient
 #
 class Graphics::Greyscale < Graphics::Rainbow
-  def initialize
-    super
-  end
-
-  def _color degree
+  def _color degree # :nodoc:
     brightness_unit = degree/360.0
     brightness = (brightness_unit*255.0).floor # Scale back to RGB
 
@@ -62,12 +61,7 @@ end
 # The full RGB spectrum
 #
 class Graphics::Hue < Graphics::Rainbow
-
-  def initialize
-    super
-  end
-
-  def _color degree
+  def _color degree # :nodoc:
     main_color = 1 * 255 # Let chroma (saturation * brightness) always == 1
     second_strongest_color = ((1 - (degree/60.0 % 2 - 1).abs) * 255).floor
 
@@ -93,12 +87,7 @@ end
 # Spectrum with linearly increasing brightness
 #
 class Graphics::Cubehelix < Graphics::Rainbow
-
-  def initialize
-    super
-  end
-
-  def _color degree
+  def _color degree # :nodoc:
     d = degree/360.0
     start = 0.5 # Starting position in color space - 0=blue, 1=red, 2=green
     rotations = -1.5 # How many rotations through the rainbow?
@@ -119,6 +108,9 @@ class Graphics::Cubehelix < Graphics::Rainbow
 end
 
 class Graphics::Simulation
+  ##
+  # Generate colors using a rainbow and a prefix name.
+
   def initialize_rainbow rainbow, name
     rainbow.cache.each do |degree, color|
       color_name = "#{name}_#{degree}".to_sym

data/lib/graphics/simulation.rb

@@ -2,16 +2,64 @@
 
 require "sdl/sdl"
 
-module SDL; end # :nodoc: -- stupid rdoc :(
+module SDL # :nodoc:
+  init INIT_EVERYTHING
+end
+
+module SDL
+  ##
+  # Renderer is the workhorse of the graphics gem. Everything
+  # graphical gets done through the renderer.
+
+  class Renderer
+    ##
+    # The PixelFormat for the current renderer.
+
+    attr_reader :format
+
+    ##
+    # The surface used by this renderer.
+
+    attr_reader :surface
+
+    ##
+    # The window for this renderer
+
+    attr_reader :window
+
+    ##
+    # The title of the window.
+
+    def title
+      @window.title
+    end
+
+    ##
+    # Sets the title of the window.
+
+    def title= s
+      @window.title = s
+    end
+  end
+end
 
 ##
 # An abstract simulation. See Graphics::Simulation and Graphics::Drawing.
 
 class Graphics::AbstractSimulation
 
-  # The default color to clear the screen.
+  ##
+  # Flags to be used when initializing a window. Defaults to 0. See
+  # SDL doco for more.
+
+  SCREEN_FLAGS = 0
+
+  # The default color to clear the window.
   CLEAR_COLOR = :black
 
+  # The default font color for `debug` calls.
+  DEBUG_COLOR = :white
+
   # degrees to radians
   D2R = Math::PI / 180.0
 
@@ -21,11 +69,19 @@ class Graphics::AbstractSimulation
   # Call +log+ every N ticks, if +log+ is defined.
   LOG_INTERVAL = 60
 
+  # The default font. Menlo on OS X, Deja Vu Sans Mono on linux.
+  DEFAULT_FONT = case RUBY_PLATFORM
+                 when /darwin/ then "Menlo"
+                 when /linux/  then "DejaVuSansMono"
+                 else
+                   raise "Unsupported platform #{RUBY_PLATFORM}. Please fix."
+                 end
+
   # Collection of collections of Bodies to auto-update and draw.
   attr_accessor :_bodies
 
-  # The window the simulation is drawing in.
-  attr_accessor :screen
+  # The renderer (software or hardware backed) the simulation is drawing in.
+  attr_accessor :renderer
 
   # The window width.
   attr_accessor :w
@@ -42,9 +98,6 @@ class Graphics::AbstractSimulation
   # A hash of color names to their values.
   attr_accessor :color
 
-  # A hash of color values to their rgb values. For text, apparently. *shrug*
-  attr_accessor :rgb
-
   # Number of update iterations per drawing tick.
   attr_accessor :iter_per_tick
 
@@ -64,22 +117,28 @@ class Graphics::AbstractSimulation
   #
   # This also names a bunch colors and hues for convenience.
 
-  def initialize w, h, bpp = 0, name = self.class.name, full = false
-    SDL.init SDL::INIT_VIDEO
+  def initialize w=nil, h=nil, name=self.class.name, full=false
+    w ||= SDL::Screen::W/2
+    h ||= SDL::Screen::H/2
+
+    # TODO: remove for 1.0.0 final
+    raise "Do NOT pass bpp to Simulation anymore" if !name || Integer === name
 
     full = full ? SDL::FULLSCREEN : 0
 
     self._bodies = []
 
-    self.font = find_font("Menlo", 32)
+    self.font = find_font(DEFAULT_FONT, 32)
 
-    SDL::WM.set_caption name, name
+    name ||= "Unknown"
+    name = name.gsub(/[A-Z]/, ' \0').strip
 
-    self.screen = SDL::Screen.open w, h, bpp, self.class::SCREEN_FLAGS|full
-    self.w, self.h = screen.w, screen.h
+    self.renderer = SDL::Screen.open w, h, 32, self.class::SCREEN_FLAGS|full
+    self.w, self.h = w, h
+
+    renderer.title = name
 
     self.color = {}
-    self.rgb   = Hash.new { |hash, k| hash[k] = screen.format.get_rgb(color[k]) }
     self.paused = false
 
     self.iter_per_tick = 1
@@ -89,6 +148,9 @@ class Graphics::AbstractSimulation
 
     initialize_keys
     initialize_colors
+
+    clear # so you start with the right color blank window on frame 0
+    renderer.present
   end
 
   ##
@@ -109,17 +171,17 @@ class Graphics::AbstractSimulation
     register_color :red,       255, 0,   0
     register_color :green,     0,   255, 0
     register_color :blue,      0,   0,   255
-    register_color :cyan,      0, 255, 255
-    register_color :magenta,   255, 0, 255
+    register_color :cyan,      0,   255, 255
+    register_color :magenta,   255, 0,   255
     register_color :yellow,    255, 255, 0
-    register_color :alpha,     0, 0, 0, 0
+    register_color :alpha,     0,   0,   0,   0
 
     (0..99).each do |n|
       m = (255 * (n / 100.0)).to_i
-      register_color(("gray%02d"  % n).to_sym, m, m, m)
-      register_color(("red%02d"   % n).to_sym, m, 0, 0)
-      register_color(("green%02d" % n).to_sym, 0, m, 0)
-      register_color(("blue%02d"  % n).to_sym, 0, 0, m)
+      register_color(("gray%02d"    % n).to_sym, m, m, m)
+      register_color(("red%02d"     % n).to_sym, m, 0, 0)
+      register_color(("green%02d"   % n).to_sym, 0, m, 0)
+      register_color(("blue%02d"    % n).to_sym, 0, 0, m)
       register_color(("cyan%02d"    % n).to_sym, 0, m, m)
       register_color(("magenta%02d" % n).to_sym, m, 0, m)
       register_color(("yellow%02d"  % n).to_sym, m, m, 0)
@@ -137,10 +199,16 @@ class Graphics::AbstractSimulation
     end
   end
 
-  sys_font  = "/System/Library/Fonts"
-  lib_font  = "/Library/Fonts"
-  user_font = File.expand_path "~/Library/Fonts/"
-  FONT_GLOB = "{#{sys_font},#{lib_font},#{user_font}}" # :nodoc:
+  font_dirs = [
+    # OS X
+    "/System/Library/Fonts",
+    "/Library/Fonts",
+    File.expand_path("~/Library/Fonts/"),
+
+    # Ubuntu
+    "/usr/share/fonts/truetype/**/",
+  ]
+  FONT_GLOB = "{#{font_dirs.join(",")}}" # :nodoc:
 
   ##
   # Find and open a (TTF) font. Should be as system agnostic as possible.
@@ -165,7 +233,7 @@ class Graphics::AbstractSimulation
   # Register a single Body to be auto-updated and drawn.
 
   def register_body obj
-    _bodies << [obj]
+    register_bodies Array(obj)
     obj
   end
 
@@ -173,7 +241,77 @@ class Graphics::AbstractSimulation
   # Name a color w/ rgba values.
 
   def register_color name, r, g, b, a = 255
-    color[name] = screen.format.map_rgba r, g, b, a
+    color[name] = renderer.format.map_rgba r, g, b, a
+  end
+
+  ##
+  # Name a color w/ HSL values.
+
+  def register_hsla n, h, s, l, a = 1.0
+    register_color n, *from_hsl(h, s, l), (a*255).round
+  end
+
+  ##
+  # Name a color w/ HSV values.
+
+  def register_hsva n, h, s, v, a = 1.0
+    register_color n, *from_hsv(h, s, v), (a*255).round
+  end
+
+  ##
+  # Convert HSL to RGB.
+  #
+  # https://en.wikipedia.org/wiki/HSL_and_HSV#From_HSV
+
+  def from_hsl h, s, l # 0..360, 0..1, 0..1
+    raise ArgumentError, "%f, %f, %f out of range" % [h, s, v] unless
+      h.between?(0, 360) && s.between?(0, 1) && l.between?(0, 1)
+
+    c  = (1 - (2*l - 1).abs) * s
+    h2 = h / 60.0
+    x  = c * (1 - (h2 % 2 - 1).abs)
+    m  = l - c/2
+
+    r, g, b = case
+              when 0 <= h2 && h2 < 1 then [c+m, x+m, 0+m]
+              when 1 <= h2 && h2 < 2 then [x+m, c+m, 0+m]
+              when 2 <= h2 && h2 < 3 then [0+m, c+m, x+m]
+              when 3 <= h2 && h2 < 4 then [0+m, x+m, c+m]
+              when 4 <= h2 && h2 < 5 then [x+m, 0+m, c+m]
+              when 5 <= h2 && h2 < 6 then [c+m, 0+m, x+m]
+              else
+                raise [h, s, v, h2, x, m].inspect
+              end
+
+    [(r*255).round, (g*255).round, (b*255).round]
+  end
+
+  ##
+  # Convert HSV to RGB.
+  #
+  # https://en.wikipedia.org/wiki/HSL_and_HSV#From_HSV
+
+  def from_hsv h, s, v # 0..360, 0..1, 0..1
+    raise ArgumentError, "%f, %f, %f out of range" % [h, s, v] unless
+      h.between?(0, 360) && s.between?(0, 1) && v.between?(0, 1)
+
+    c  = v * s
+    h2 = h / 60.0
+    x  = c * (1 - (h2 % 2 - 1).abs)
+    m  = v - c
+
+    r, g, b = case
+              when 0 <= h2 && h2 < 1 then [c+m, x+m, 0+m]
+              when 1 <= h2 && h2 < 2 then [x+m, c+m, 0+m]
+              when 2 <= h2 && h2 < 3 then [0+m, c+m, x+m]
+              when 3 <= h2 && h2 < 4 then [0+m, x+m, c+m]
+              when 4 <= h2 && h2 < 5 then [x+m, 0+m, c+m]
+              when 5 <= h2 && h2 < 6 then [c+m, 0+m, x+m]
+              else
+                raise [h, s, v, h2, x, m].inspect
+              end
+
+    [(r*255).round, (g*255).round, (b*255).round]
   end
 
   ##
@@ -254,20 +392,19 @@ class Graphics::AbstractSimulation
       handle_event event, n while event = SDL::Event.poll
       handle_keys
 
-      next if paused
+      break if done
+      next  if paused
 
       iter_per_tick.times { update n; n += 1 }
       draw_and_flip n
 
       log if logger and n % log_interval == 0
-
-      break if done
     end
   end
 
   def draw_and_flip n # :nodoc:
     self.draw n
-    screen.flip
+    renderer.present
   end
 
   ##
@@ -280,10 +417,17 @@ class Graphics::AbstractSimulation
     post_draw n
   end
 
+  ##
+  # The pre-draw phase. Defaults to clearing.
+
   def pre_draw n
     clear
   end
 
+  ##
+  # The post-draw phase. Defaults to having all bodies draw
+  # themselves.
+
   def post_draw n
     _bodies.each do |ary|
       draw_collection ary
@@ -316,31 +460,36 @@ class Graphics::AbstractSimulation
   end
 
   ##
-  # Clear the whole screen. Defaults to CLEAR_COLOR.
+  # Clear the whole window. Defaults to CLEAR_COLOR.
 
   def clear c = self.class::CLEAR_COLOR
-    fast_rect 0, 0, w, h, c
+    cc = color[c]
+    if cc then
+      renderer.clear cc
+    else
+      warn "Color #{c} doesn't appear to be registered. Skipping clear."
+    end
   end
 
   ##
   # Draw an antialiased line from x1/y1 to x2/y2 in color c.
 
-  def line x1, y1, x2, y2, c
+  def line x1, y1, x2, y2, c, aa = true
     h = self.h
-    screen.draw_line x1, h-y1-1, x2, h-y2-1, color[c]
+    renderer.draw_line x1, h-y1-1, x2, h-y2-1, color[c], aa
   end
 
   ##
   # Draw a horizontal line from x1 to x2 at y in color c.
 
-  def hline y, c, x1 = 0, x2 = h
+  def hline y, c, x1 = 0, x2 = w
     line x1, y, x2, y, c
   end
 
   ##
   # Draw a vertical line from y1 to y2 at y in color c.
 
-  def vline x, c, y1 = 0, y2 = w
+  def vline x, c, y1 = h-1, y2 = 0
     line x, y1, x, y2, c
   end
 
@@ -367,14 +516,21 @@ class Graphics::AbstractSimulation
   # Draw a rect at x/y with w by h dimensions in color c. Ignores blending.
 
   def fast_rect x, y, w, h, c
-    screen.fast_rect x, self.h-y-h, w, h, color[c]
+    y = self.h-y-h # TODO: -1???
+    renderer.fast_rect x, y, w, h, color[c]
   end
 
   ##
-  # Draw a point at x/y w/ color c.
+  # Read or write a color to x/y. If c is given, write, otherwise read.
+  #
+  # Reading is pretty slow. Try to avoid.
 
-  def point x, y, c
-    screen[x, h-y-1] = color[c]
+  def point x, y, c = nil
+    if c then
+      renderer[x, h-y-1] = color[c]
+    else
+      renderer[x, h-y-1]
+    end
   end
 
   ##
@@ -390,45 +546,38 @@ class Graphics::AbstractSimulation
   # Draw a rect at x/y with w by h dimensions in color c.
 
   def rect x, y, w, h, c, fill = false
-    y = self.h-y-h-1
-    if fill then
-      screen.fill_rect x, y, w, h, color[c]
-    else
-      screen.draw_rect x, y, w, h, color[c]
-    end
+    y = self.h-y-h # TODO: -1???
+    renderer.draw_rect x, y, w, h, color[c], fill
   end
 
   ##
   # Draw a circle at x/y with radius r in color c.
 
-  def circle x, y, r, c, fill = false
+  def circle x, y, r, c, fill = false, aa = true
     y = h-y-1
-    if fill then
-      screen.fill_circle x, y, r, color[c]
-    else
-      screen.draw_circle x, y, r, color[c]
-    end
+    renderer.draw_circle x, y, r, color[c], aa, fill
   end
 
   ##
   # Draw a circle at x/y with radiuses w/h in color c.
 
-  def ellipse x, y, w, h, c, fill = false
+  def ellipse x, y, w, h, c, fill = false, aa = true
     y = self.h-y-1
-    if fill then
-      screen.fill_ellipse x, y, w, h, color[c]
-    else
-      screen.draw_ellipse x, y, w, h, color[c]
-    end
+    renderer.draw_ellipse x, y, w, h, color[c], aa, fill
   end
 
   ##
   # Draw an antialiased curve from x1/y1 to x2/y2 via control points
   # cx1/cy1 & cx2/cy2 in color c.
 
-  def bezier x1, y1, cx1, cy1, cx2, cy2, x2, y2, c, l = 7
-    h = self.h
-    screen.draw_bezier x1, h-y1-1, cx1, h-cy1, cx2, h-cy2, x2, h-y2-1, l, color[c]
+  def bezier *points, c
+    h = self.h-1
+
+    # TODO: there is probably a cleaner way... or move entirely into C
+    xs, ys = points.each_slice(2).to_a.transpose
+    ys.map! { |y| h-y }
+
+    renderer.draw_bezier xs, ys, 5, color[c]
   end
 
   ## Text
@@ -437,14 +586,14 @@ class Graphics::AbstractSimulation
   # Return the w/h of the text s in font f.
 
   def text_size s, f = font
-    f.text_size s
+    f.text_size s.to_s
   end
 
   ##
   # Return the rendered text s in color c in font f.
 
   def render_text s, c, f = font
-    f.render screen, s, color[c]
+    f.render renderer, s, color[c]
   end
 
   ##
@@ -452,7 +601,7 @@ class Graphics::AbstractSimulation
 
   def text s, x, y, c, f = font
     y = self.h-y-f.height-1
-    f.draw screen, s, x, y, color[c]
+    f.draw renderer, s, x, y, color[c]
   end
 
   ##
@@ -461,24 +610,22 @@ class Graphics::AbstractSimulation
 
   def debug fmt, *args
     s = fmt % args
-    text s, 10, h-40-font.height, :white
+    text s, 10, h-40-font.height, self.class::DEBUG_COLOR
   end
 
   attr_accessor :start_time # :nodoc:
 
   ##
-  # Draw the current frames-per-second in the top left corner in green.
+  # Draw the current frames-per-second in the top left corner. Defaults to green.
 
-  def fps n
+  def fps n, color = :green
     secs = Time.now - start_time
     fps = "%5.1f fps" % [n / secs]
-    text fps, 10, h-font.height, :green
+    text fps, 10, h-font.height, color
   end
 
   ### Blitting Methods:
 
-  # TODO: copy_rect(x,y,w,h)
-
   ##
   # Load an image at path into a new surface.
 
@@ -512,48 +659,40 @@ class Graphics::AbstractSimulation
   ##
   # Draw a bitmap centered at x/y with optional angle, x/y scale, and flags.
 
-  def blit src, x, y, a° = 0, xscale = 1, yscale = 1, flags = 0
-    img = src.transform src.format.colorkey, -a°, xscale, yscale, flags
-
-    SDL::Surface.blit img, 0, 0, 0, 0, screen, x-img.w/2, h-y-img.h/2
+  def blit src, x, y, a° = nil, xscale = nil, yscale = nil, flags = nil
+    renderer.blit src, x-src.w/2, h-y-src.h/2, a°, xscale, yscale, :center
   end
 
   ##
   # Draw a bitmap at x/y with optional angle, x/y scale, and flags.
 
-  def put src, x, y, a° = 0, xscale = 1, yscale = 1, flags = 0
-    img = src.transform src.format.colorkey, -a°, xscale, yscale, flags
-
-    # why x-1? because transform adds a pixel to all sides even if a°==0
-    SDL::Surface.blit img, 0, 0, 0, 0, screen, x-1, h-y-img.h
+  def put src, x, y, a° = nil, xscale = nil, yscale = nil, flags = nil
+    renderer.blit src, x, h-y-src.h, a°, xscale, yscale, false
   end
 
   ##
-  # Save the current screen to a bmp
+  # Save the current window to a png.
 
   def save path
-    screen.save path
+    renderer.save path
   end
 
   ##
-  # Create a new sprite with a given width and height and yield to a
-  # block with the new sprite as the current screen. All drawing
-  # primitives will work and the resulting surface is returned.
+  # Create a new renderer with a given width and height and yield to a
+  # block for drawing. The resulting surface is returned.
 
   def sprite w, h
-    new_screen = SDL::Surface.new w, h, screen.format
-    old_screen = screen
-    old_w, old_h = self.w, self.h
+    old_renderer   = renderer
+    new_renderer   = renderer.sprite w, h
+    old_w, old_h   = renderer.w, renderer.h
     self.w, self.h = w, h
+    self.renderer  = new_renderer
 
-    self.screen = new_screen
     yield if block_given?
 
-    new_screen.set_color_key SDL::SRCCOLORKEY, 0
-
-    new_screen
+    new_renderer.surface
   ensure
-    self.screen = old_screen
+    self.renderer  = old_renderer
     self.w, self.h = old_w, old_h
   end
 end
@@ -577,7 +716,7 @@ end
 # + Ball::View.draw takes a window and a ball and draws it.
 
 class Graphics::Simulation < Graphics::AbstractSimulation
-  SCREEN_FLAGS = SDL::HWSURFACE|SDL::DOUBLEBUF
+
 end
 
 ##
@@ -587,23 +726,43 @@ end
 # See AbstractSimulation for most methods.
 
 class Graphics::Drawing < Graphics::AbstractSimulation
-  SCREEN_FLAGS = SDL::HWSURFACE
+  ##
+  # The canvas used for all drawing.
+
+  attr_accessor :texture
 
-  def initialize(*a)
+  def initialize(*a) # :nodoc:
     super
 
-    clear
+    self.texture = renderer.new_texture
+
+    draw_on texture do
+      clear
+      yield if block_given?
+    end
   end
 
-  def draw_and_flip n
-    screen.update 0, 0, 0, 0
-    # no flip
+  ##
+  # Temporarily render to a texture instead of the renderer's window,
+  # then copy that texture to the renderer and present it.
+
+  def draw_on texture
+    renderer.target = texture
+
+    yield if block_given?
+  ensure
+    renderer.target = nil
+    renderer.copy_texture texture
+    renderer.present
   end
-end
 
-if $0 == __FILE__ then
-  SDL.init SDL::INIT_EVERYTHING
-  SDL.set_video_mode(640, 480, 16, SDL::SWSURFACE)
-  sleep 1
-  puts "if you saw a window, it was working"
+  def pre_draw n # :nodoc:
+    # no clear
+  end
+
+  def draw_and_flip n # :nodoc:
+    draw_on texture do
+      self.draw n
+    end
+  end
 end