graphics 1.0.0b6 → 1.0.0

data/examples/walker.rb

@@ -74,7 +74,7 @@ class WalkerSimulation < Graphics::Simulation
   attr_accessor :ps, :body_img, :cmap
 
   def initialize
-    super 850, 850, 16, "Walker"
+    super 850, 850
 
     self.ps = populate Person
     register_bodies ps

data/examples/walker2.rb

@@ -141,7 +141,7 @@ class WalkerSimulation < Graphics::Simulation
   attr_accessor :ps, :body_img, :cmap
 
   def initialize
-    super 850, 850, 16, "Walker"
+    super 850, 850
 
     self.ps = populate Person, 2
     register_bodies ps

data/examples/zombies.rb

@@ -74,7 +74,7 @@ class Person < Entity
 
   INFECT_STEPS = 50.0 # must be a float
 
-  NORMAL_COLOR = :blue
+  NORMAL_COLOR = :black
   FREAKD_COLOR = :yellow
 
   attr_accessor :state, :infect, :speed
@@ -171,7 +171,7 @@ end
 
 class Hunter < Person
   COUNT = 6
-  COLOR = :white
+  COLOR = :red
 
   def color
     if @infect then
@@ -187,7 +187,7 @@ class Hunter < Person
     limit_bounds
 
     baddies = sim.zombie + sim.person.select(&:infect)
-    nearest = baddies.sort_by { |z| self.distance_from_squared z }.first
+    nearest = baddies.min_by { |z| self.distance_from_squared z }
 
     return unless nearest
 
@@ -195,10 +195,10 @@ class Hunter < Person
       if Person === nearest then
         nearest.kill
       else
-        if rand(10) != 0 then
+        if 9 =~ 10 then # Hunter has a 1 in 10 chance of dying
           nearest.kill
         else
-          self.state = INFECT
+          self.state  = INFECT
           self.infect = INFECT_STEPS.to_i
         end
       end
@@ -217,7 +217,7 @@ end
 
 class Zombie < Entity
   COUNT = 5
-  ZOMBIE_COLOR = :red
+  ZOMBIE_COLOR = :green50
 
   def self.from_person p, sim
     z = new sim
@@ -261,13 +261,15 @@ class Zombie < Entity
 end
 
 class ZombieGame < Graphics::Simulation
+  include WhiteBackground
+
   attr_accessor :person, :zombie
   attr_accessor :part_p, :part_z
   attr_accessor :scale, :partitions
   attr_accessor :start
 
   def initialize
-    super 512, 512, 16, "Zombie Epidemic Simulator"
+    super 512, 512, "Zombie Epidemic Simulator"
     self.scale = 2
     self.partitions = 64
 
@@ -374,6 +376,10 @@ class ZombieGame < Graphics::Simulation
   def max
     @max ||= w / scale
   end
+
+  def inspect
+    "ZombieGame"
+  end
 end
 
 ZombieGame.new.run

data/ext/sdl/extconf.rb

@@ -5,27 +5,19 @@ $INCFLAGS << " -I$(srcdir)/sge"
 
 $srcs = Dir.glob("#{$srcdir}/{,sge/}*.c{,pp}")
 
-sdl_config = with_config "sdl-config", "sdl-config"
-$CPPFLAGS   += " " + `#{sdl_config} --cflags`.chomp
+sdl_config = with_config "sdl2-config", "sdl2-config"
+$CPPFLAGS   += `#{sdl_config} --cflags`.chomp
+if ENV["STRICT"] then # this isn't right because it is at Makefile creation time
+  $CPPFLAGS += " "
+  $CPPFLAGS += %w[-Werror -Wall
+                  -Wimplicit-function-declaration
+                  -Wundefined-internal].join(" ")
+end
 $LOCAL_LIBS += " " + `#{sdl_config} --libs`.chomp
 
-have_library("SDL_mixer", "Mix_OpenAudio") or abort "Need sdl_mixer"
-have_library("SDL_image", "IMG_Load") or abort "Need sdl_image"
-have_library("SDL_ttf", "TTF_Init") or abort "Need sdl_ttf"
-# have_library("SDL_gfx", "fuck") or abort "Need sdl_gfx"
-
-# have_func "TTF_OpenFontIndex"
-# have_func "TTF_FontFaces"
-# have_func "TTF_FontFaceIsFixedWidth"
-# have_func "TTF_FontFaceFamilyName"
-# have_func "TTF_FontFaceStyleName"
-# have_func "Mix_LoadMUS_RW"
-# have_func "rb_thread_blocking_region"
-# have_func "rb_thread_call_without_gvl" if have_header "ruby/thread.h"
-
-# if have_func("rb_enc_str_new") && have_func("rb_str_export_to_enc")
-#   $CPPFLAGS += " -D ENABLE_M17N"
-#   $CPPFLAGS += " -D ENABLE_M17N_FILESYSTEM" if enable_config "m17n-filesystem", false
-# end
+have_library("SDL2_mixer", "Mix_OpenAudio") or abort "Need sdl2_mixer"
+have_library("SDL2_image", "IMG_Load")      or abort "Need sdl2_image"
+have_library("SDL2_ttf", "TTF_Init")        or abort "Need sdl2_ttf"
+have_library("SDL2_gfx", "hlineColor")      or abort "Need sdl2_gfx"
 
 create_makefile "sdl/sdl"

data/ext/sdl/sdl.c

@@ -3,7 +3,9 @@
 #include <ruby/intern.h>
 #include <SDL_ttf.h>
 #include <SDL_image.h>
-#include <sge.h>
+#include <SDL2_gfxPrimitives.h>
+#include <SDL2_rotozoom.h>
+#include <sge/sge_collision.h>
 #include <SDL_mixer.h>
 
 // https://github.com/google/protobuf/blob/master/ruby/ext/google/protobuf_c/defs.c
@@ -33,6 +35,12 @@
 #define DEFINE_SELF(type, var, rb_var)                           \
   SDL_##type* var = ruby_to_##type(rb_var)
 
+#define DEFINE_SELF0(type, var, rb_var)                           \
+  SDL_##type* var = RTEST(rb_var) ? ruby_to_##type(rb_var) : NULL;
+
+#define SET_SELF(type, var, rb_var)                           \
+  var = ruby_to_##type(rb_var)
+
 #define NUM2SINT32(n) (Sint32)NUM2INT(n)
 #define NUM2SINT16(n) (Sint16)NUM2INT(n)
 #define NUM2UINT32(n) (Uint32)NUM2UINT(n)
@@ -45,31 +53,15 @@
 
 #define UNUSED(x) (void)(x)
 
-#define ZERO_RECT(r) r.x == 0 && r.y == 0 && r.w == 0 && r.h == 0
+#define FAILURE(s)       rb_raise(eSDLError, "%s failed: %s", (s), SDL_GetError())
+#define AUDIO_FAILURE(s) rb_raise(eSDLError, "%s failed: %s", (s), Mix_GetError())
+#define TTF_FAILURE(s)   rb_raise(eSDLError, "%s failed: %s", (s), TTF_GetError())
 
-#define FAILURE(s) rb_raise(eSDLError, "%s failed: %s", (s), SDL_GetError());
-#define AUDIO_FAILURE(s) rb_raise(eSDLError, "%s failed: %s", (s), Mix_GetError());
-
-#ifdef rb_intern
-#undef rb_intern // HACK -- clang warns about recursive macros
-#endif
+#define SHOULD_BLEND(a) (a) != 0xff
 
 #define DEFINE_ID(name) static ID id_iv_##name
 #define INIT_ID(name) id_iv_##name = rb_intern("@"#name)
 
-#define DEFINE_DRAW6(type, name, func) \
-  static VALUE Surface_##name(VALUE s, VALUE x, VALUE y, VALUE w, VALUE h, VALUE c) { \
-    return _draw_func_##type(&func, s, x, y, w, h, c); \
-  }
-
-#define DEFINE_SXYRC(name, func) \
-  static VALUE Surface_##name(VALUE s, VALUE x, VALUE y, VALUE r, VALUE c) { \
-    return _draw_func_sxyrc(&func, s, x, y, r, c); \
-  }
-
-#define DEFINE_SXYXYC(name, func) DEFINE_DRAW6(sxyxyc, name, func)
-#define DEFINE_SXYWHC(name, func) DEFINE_DRAW6(sxywhc, name, func)
-
 static VALUE cEvent;
 static VALUE cEventKeydown;
 static VALUE cEventKeyup;
@@ -79,22 +71,27 @@ static VALUE cEventMouseup;
 static VALUE cEventQuit;
 static VALUE cScreen;
 static VALUE eSDLError;
-static VALUE eSDLMem;
 static VALUE mKey;
 static VALUE mSDL;
-static VALUE mWM;
 static VALUE mMouse;
 
 typedef TTF_Font SDL_TTFFont;
 typedef Mix_Chunk SDL_Audio;
 typedef sge_cdata SDL_CollisionMap;
 
+static ID id_H;
+static ID id_W;
+
+DEFINE_ID(surface);
+DEFINE_ID(format);
+DEFINE_ID(renderer);
+DEFINE_ID(window);
+DEFINE_ID(texture);
 DEFINE_ID(button);
 DEFINE_ID(mod);
 DEFINE_ID(press);
 DEFINE_ID(state);
 DEFINE_ID(sym);
-DEFINE_ID(unicode);
 DEFINE_ID(x);
 DEFINE_ID(xrel);
 DEFINE_ID(y);
@@ -105,42 +102,30 @@ DEFINE_CLASS(Surface,      "SDL::Surface")
 DEFINE_CLASS(CollisionMap, "SDL::CollisionMap")
 DEFINE_CLASS(PixelFormat,  "SDL::PixelFormat")
 DEFINE_CLASS_0(TTFFont,    "SDL::TTFFont")
+DEFINE_CLASS_0(Renderer,   "SDL::Renderer") // TODO: I kinda want these hidden
+DEFINE_CLASS_0(Window,     "SDL::Window")   // TODO: I kinda want these hidden
+DEFINE_CLASS_0(Texture,    "SDL::Texture")  // TODO: I kinda want these hidden
 
+#define SDL_NUMEVENTS 0xFFFF // HACK
 typedef VALUE (*event_creator)(SDL_Event *);
 static event_creator event_creators[SDL_NUMEVENTS];
 
 static int is_quit = 0;
+static int key_state_len = 0;
 static Uint8* key_state = NULL;
-static SDLMod mod_state;
+static SDL_Keymod mod_state;
 
 void Init_sdl(void);
 
 //// Misc / Utility functions:
 
-// TODO: collapse to one format
-static Uint32 VALUE2COLOR(VALUE color, SDL_PixelFormat *format) {
-  // TODO: reverse and use FIXNUM_P ?
-  if (rb_obj_is_kind_of(color, rb_cArray)) {
-    switch (RARRAY_LEN(color)) {
-    case 3:
-      return SDL_MapRGB(format,
-                        (Uint8)FIX2UINT(rb_ary_entry(color, 0)),
-                        (Uint8)FIX2UINT(rb_ary_entry(color, 1)),
-                        (Uint8)FIX2UINT(rb_ary_entry(color, 2)));
-    case 4:
-      return SDL_MapRGBA(format,
-                         (Uint8)FIX2UINT(rb_ary_entry(color, 0)),
-                         (Uint8)FIX2UINT(rb_ary_entry(color, 1)),
-                         (Uint8)FIX2UINT(rb_ary_entry(color, 2)),
-                         (Uint8)FIX2UINT(rb_ary_entry(color, 3)));
-    default:
-      rb_raise(rb_eArgError, "type mismatch:color array needs 3 or 4 elements");
-    }
-  } else {
-    return NUM2UINT(color);
-  }
+static void rb_const_reset(VALUE mod, ID id, VALUE val) { // avoids warnings
+  rb_const_remove(mod, id);
+  rb_const_set(mod, id, val);
 }
 
+#define VALUE2COLOR(c) NUM2UINT(c)
+
 //// SDL methods:
 
 static VALUE sdl_s_init(VALUE mod, VALUE flags) {
@@ -151,6 +136,15 @@ static VALUE sdl_s_init(VALUE mod, VALUE flags) {
   if (TTF_Init())
     rb_raise(eSDLError, "TTF_Init error: %s", TTF_GetError());
 
+  SDL_Rect r;
+  if (SDL_GetDisplayBounds(0, &r) != 0) {
+    rb_raise(eSDLError, "Failure calling SDL_GetDisplayBounds()");
+    return 1;
+  }
+
+  rb_const_reset(cScreen, id_W, UINT2NUM(r.w));
+  rb_const_reset(cScreen, id_H, UINT2NUM(r.h));
+
   return Qnil;
 }
 
@@ -205,7 +199,7 @@ static VALUE Audio_s_load(VALUE self, VALUE path) {
   Mix_Chunk *chunk = Mix_LoadWAV(RSTRING_PTR(path));
 
   if (!chunk)
-    FAILURE("Audio.load");
+    AUDIO_FAILURE("Audio.load");
 
   return TypedData_Wrap_Struct(cAudio, &_Audio_type, chunk);
 }
@@ -225,14 +219,7 @@ static void _CollisionMap_free(void* p) {
   if (is_quit) return;
   if (!p) return;
 
-  SDL_PixelFormat *format = p;
-
-  if (format->palette) {
-    free(format->palette->colors);
-    free(format->palette);
-  }
-
-  free(format);
+  sge_destroy_cmap(p);
 }
 
 static void _CollisionMap_mark(void* p) {
@@ -279,7 +266,6 @@ static VALUE __new_key_event(VALUE klass, SDL_Event *event) {
   rb_ivar_set(obj, id_iv_press,   INT2BOOL(event->key.state == SDL_PRESSED)); // TODO: nuke?
   rb_ivar_set(obj, id_iv_sym,     INT2FIX(event->key.keysym.sym));
   rb_ivar_set(obj, id_iv_mod,     UINT2NUM(event->key.keysym.mod));
-  rb_ivar_set(obj, id_iv_unicode, UINT2NUM(event->key.keysym.unicode));
   return obj;
 }
 
@@ -325,24 +311,27 @@ static VALUE Event__mouseup(SDL_Event *event) {
 
 //// SDL::Key methods:
 
-static VALUE Key_s_press_p(VALUE mod, VALUE keysym) {
+static VALUE Key_s_press_p(VALUE mod, VALUE keycode_) {
   UNUSED(mod);
-  int sym = NUM2INT(keysym);
-
-  if (SDLK_FIRST >= sym || sym >= SDLK_LAST)
-    rb_raise(eSDLError, "%d is out of key", sym);
 
   if (!key_state)
     rb_raise(eSDLError,
              "You should call SDL::Key#scan before calling SDL::Key#press?");
 
-  return INT2BOOL(key_state[sym]);
+  SDL_Keycode keycode   = NUM2INT(keycode_);
+  SDL_Scancode scancode = SDL_GetScancodeFromKey(keycode);
+
+  if (0 >= scancode || scancode >= key_state_len)
+    rb_raise(eSDLError, "%d (%d) is out of bounds: %d",
+             keycode, scancode, key_state_len);
+
+  return INT2BOOL(key_state[scancode]);
 }
 
 static VALUE Key_s_scan(VALUE mod) {
   UNUSED(mod);
 
-  key_state = SDL_GetKeyState(NULL);
+  key_state = (Uint8 *) SDL_GetKeyboardState(&key_state_len);
   mod_state = SDL_GetModState();
 
   return Qnil;
@@ -371,14 +360,7 @@ static void _PixelFormat_free(void* p) {
   if (is_quit) return;
   if (!p) return;
 
-  SDL_PixelFormat *format = p;
-
-  if (format->palette) {
-    free(format->palette->colors);
-    free(format->palette);
-  }
-
-  free(format);
+  SDL_FreeFormat(p);
 }
 
 static void _PixelFormat_mark(void* p) {
@@ -397,57 +379,75 @@ static VALUE PixelFormat_map_rgba(VALUE self, VALUE r, VALUE g, VALUE b, VALUE a
                               NUM2UINT8(b), NUM2UINT8(a)));
 }
 
-static VALUE PixelFormat_get_rgb(VALUE self, VALUE pixel) {
+static VALUE PixelFormat_get_rgba(VALUE self, VALUE pixel) {
   DEFINE_SELF(PixelFormat, format, self);
-  Uint8 r, g, b;
+  Uint8 r, g, b, a;
 
-  SDL_GetRGB(NUM2UINT(pixel), format, &r, &g, &b);
+  SDL_GetRGBA(NUM2UINT(pixel), format, &r, &g, &b, &a);
 
-  return rb_ary_new3(3, UINT2NUM(r), UINT2NUM(g), UINT2NUM(b));
+  return rb_ary_new3(4, UINT2NUM(r), UINT2NUM(g), UINT2NUM(b), UINT2NUM(a));
 }
 
-static VALUE PixelFormat_colorkey(VALUE self) {
-  DEFINE_SELF(PixelFormat, format, self);
+//// SDL::Screen methods:
 
-  return UINT2NUM(format->colorkey);
-}
+static VALUE Screen_s_open(VALUE klass, VALUE w_, VALUE h_, VALUE bpp_, VALUE flags_) {
+  UNUSED(klass);
 
-static VALUE PixelFormat_alpha(VALUE self) {
-  DEFINE_SELF(PixelFormat, format, self);
+  int w        = NUM2INT(w_);
+  int h        = NUM2INT(h_);
+  int bpp      = NUM2INT(bpp_);
+  Uint32 flags = NUM2UINT32(flags_);
 
-  return UINT2NUM(format->alpha);
-}
+  if (!bpp) bpp = 32; // TODO: remove bpp option and always be 32?
 
-//// SDL::Screen methods:
+  SDL_Window *window =
+    SDL_CreateWindow("", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
+                     w, h,
+                     flags);
+  if (!window) FAILURE("Screen.open(CreateWindow)");
 
-static VALUE Screen_s_open(VALUE klass, VALUE w, VALUE h, VALUE bpp, VALUE flags) {
-  UNUSED(klass);
-  SDL_Surface *screen;
+  SDL_Renderer *renderer =
+    SDL_CreateRenderer(window, -1,
+                       SDL_RENDERER_PRESENTVSYNC|SDL_RENDERER_ACCELERATED);
+  if (!renderer) FAILURE("Screen.open(CreateRenderer)");
+
+  // bumps the refcount and returns the same thing
+  SDL_PixelFormat *format = SDL_AllocFormat(SDL_PIXELFORMAT_RGBA32);
+  if (!format)
+    rb_raise(eSDLError, "SDL_AllocFormat freaked out.");
 
-  screen = SDL_SetVideoMode(NUM2INT(w), NUM2INT(h), NUM2INT(bpp), NUM2UINT(flags));
+  VALUE vrenderer = TypedData_Wrap_Struct(cRenderer, &_Renderer_type, renderer);
+  VALUE vwindow   = TypedData_Wrap_Struct(cWindow,   &_Window_type,   window);
+  VALUE vformat   = TypedData_Wrap_Struct(cPixelFormat, &_PixelFormat_type, format);
 
-  if (!screen)
-    rb_raise(eSDLError, "Couldn't set %dx%d %d bpp video mode: %s",
-             NUM2INT(w), NUM2INT(h), NUM2INT(bpp), SDL_GetError());
+  rb_ivar_set(vrenderer, id_iv_window,  vwindow);
+  rb_ivar_set(vrenderer, id_iv_format,  vformat);
 
-  return TypedData_Wrap_Struct(cScreen, &_Surface_type, screen);
+  return vrenderer;
 }
 
-static VALUE Screen_flip(VALUE self) {
-  DEFINE_SELF(Surface, surface, self);
+static VALUE Renderer_new_texture(VALUE self) {
+  DEFINE_SELF(Renderer, renderer, self);
 
-  if (SDL_Flip(surface) < 0)
-    FAILURE("Screen#flip");
+  int w, h;
+  if (SDL_GetRendererOutputSize(renderer, &w, &h))
+    FAILURE("Renderer#new_texture(GetRendererOutputSize");
 
-  return Qnil;
+  SDL_Texture *texture = SDL_CreateTexture(renderer,
+                                           SDL_PIXELFORMAT_RGBA32,
+                                           SDL_TEXTUREACCESS_TARGET,
+                                           w, h);
+  if (!texture)
+    FAILURE("Renderer#new_texture(CreateTexture)");
+
+  return TypedData_Wrap_Struct(cTexture, &_Texture_type, texture);
 }
 
-static VALUE Screen_update(VALUE self, VALUE x, VALUE y, VALUE w, VALUE h) {
-  DEFINE_SELF(Surface, surface, self);
 
-  SDL_UpdateRect(surface,
-                 NUM2SINT32(x), NUM2SINT32(y),
-                 NUM2UINT32(w), NUM2UINT32(h));
+static VALUE Renderer_present(VALUE self) {
+  DEFINE_SELF(Renderer, renderer, self);
+
+  SDL_RenderPresent(renderer);
 
   return Qnil;
 }
@@ -467,45 +467,6 @@ static size_t _Surface_memsize(const void *p) {
   return p ? sizeof(struct SDL_Surface) : 0;
 }
 
-static VALUE Surface_s_blit(VALUE self,
-                            VALUE src, VALUE srcX, VALUE srcY, VALUE srcW, VALUE srcH,
-                            VALUE dst, VALUE dstX, VALUE dstY) {
-  UNUSED(self);
-  DEFINE_SELF(Surface, src_surface, src);
-  DEFINE_SELF(Surface, dst_surface, dst);
-
-  SDL_Rect src_rect = NewRect(srcX, srcY, srcW, srcH);
-  SDL_Rect dst_rect = NewRect(dstX, dstY, srcW, srcH);
-  SDL_Rect *sr      = ZERO_RECT(src_rect) ? NULL : &src_rect;
-  SDL_Rect *dr      = ZERO_RECT(dst_rect) ? NULL : &dst_rect;
-  int result        = SDL_BlitSurface(src_surface, sr, dst_surface, dr);
-
-  switch (result) {
-  case -1:
-    FAILURE("SDL::Surface.blit");
-  case -2:
-    rb_raise(eSDLMem, "SDL::Surface lost video memory");
-  }
-
-  return INT2NUM(result);
-}
-
-static VALUE Surface_s_new(VALUE self, VALUE w, VALUE h, VALUE pf) {
-  UNUSED(self);
-  SDL_Surface* surface;
-
-  DEFINE_SELF(PixelFormat, format, pf);
-
-  surface = SDL_CreateRGBSurface(SDL_SWSURFACE, NUM2INT(w), NUM2INT(h),
-                                 format->BitsPerPixel,
-                                 format->Rmask, format->Gmask,
-                                 format->Bmask, format->Amask);
-  if (!surface)
-    FAILURE("Surface.new");
-
-  return TypedData_Wrap_Struct(cSurface, &_Surface_type, surface);
-}
-
 static VALUE Surface_s_load(VALUE klass, VALUE path) {
   UNUSED(klass);
   SDL_Surface *surface;
@@ -522,129 +483,232 @@ static VALUE Surface_s_load(VALUE klass, VALUE path) {
   return TypedData_Wrap_Struct(cSurface, &_Surface_type, surface);
 }
 
-static VALUE Surface_set_color_key(VALUE self, VALUE flag, VALUE key) {
-  DEFINE_SELF(Surface, surface, self);
+#define DEFINE_WRAP12(name)                                \
+  void wrap_##name(SDL_Surface* a,                         \
+                   Sint16 b, Sint16 c, Sint16 d, Sint16 e, \
+                   Sint16 f, Sint16 g, Sint16 h, Sint16 i, \
+                   int j,                                  \
+                   Uint32 k, Uint8 l) { name(a, b, c, d, e, f, g, h, i, j, k); }
+#define DEFINE_WRAP7(name)                                 \
+  void wrap_##name(SDL_Surface* a,                         \
+                   Sint16 b, Sint16 c, Sint16 d, Sint16 e, \
+                   Uint32 f, Uint8 g) { name(a, b, c, d, e, f); }
+#define DEFINE_WRAP6(name)                                 \
+  void wrap_##name(SDL_Surface* a,                         \
+                   Sint16 b, Sint16 c, Sint16 d,           \
+                   Uint32 e, Uint8 f) { name(a, b, c, d, e); }
+
+#define IDX1(a)                                 !!(a)
+#define IDX2(a, b)                 (!!(a))<<1 | !!(b)
+#define IDX3(a, b, c) (!!(a))<<2 | (!!(b))<<1 | !!(c)
+
+typedef int (*f_rxyxyc)(SDL_Renderer*,
+                        Sint16, Sint16, Sint16, Sint16,
+                        Uint32);
+typedef int (*f_rxyrc)(SDL_Renderer*,
+                        Sint16, Sint16, Sint16,
+                        Uint32);
+
+// TODO: ? maybe ?
+// int  hlineColor                  (SDL_Renderer *renderer, Sint16 x1, Sint16 x2, Sint16 y, Uint32 color)
+// int  vlineColor                  (SDL_Renderer *renderer, Sint16 x, Sint16 y1, Sint16 y2, Uint32 color)
+// int  roundedRectangleColor       (SDL_Renderer *renderer, Sint16 x1, Sint16 y1, Sint16 x2, Sint16 y2, Sint16 rad, Uint32 color)
+// int  roundedBoxColor             (SDL_Renderer *renderer, Sint16 x1, Sint16 y1, Sint16 x2, Sint16 y2, Sint16 rad, Uint32 color)
+// int  thickLineColor              (SDL_Renderer *renderer, Sint16 x1, Sint16 y1, Sint16 x2, Sint16 y2, Uint8 width, Uint32 color)
+// int  arcColor                    (SDL_Renderer *renderer, Sint16 x, Sint16 y, Sint16 rad, Sint16 start, Sint16 end, Uint32 color)
+// int  pieColor                    (SDL_Renderer *renderer, Sint16 x, Sint16 y, Sint16 rad, Sint16 start, Sint16 end, Uint32 color)
+// int  filledPieColor              (SDL_Renderer *renderer, Sint16 x, Sint16 y, Sint16 rad, Sint16 start, Sint16 end, Uint32 color)
+// int  trigonColor                 (SDL_Renderer *renderer, Sint16 x1, Sint16 y1, Sint16 x2, Sint16 y2, Sint16 x3, Sint16 y3, Uint32 color)
+// int  aatrigonColor               (SDL_Renderer *renderer, Sint16 x1, Sint16 y1, Sint16 x2, Sint16 y2, Sint16 x3, Sint16 y3, Uint32 color)
+// int  filledTrigonColor           (SDL_Renderer *renderer, Sint16 x1, Sint16 y1, Sint16 x2, Sint16 y2, Sint16 x3, Sint16 y3, Uint32 color)
+// int  polygonColor                (SDL_Renderer *renderer, const Sint16 *vx, const Sint16 *vy, int n, Uint32 color)
+// int  aapolygonColor              (SDL_Renderer *renderer, const Sint16 *vx, const Sint16 *vy, int n, Uint32 color)
+// int  filledPolygonColor          (SDL_Renderer *renderer, const Sint16 *vx, const Sint16 *vy, int n, Uint32 color)
+// int  texturedPolygon             (SDL_Renderer *renderer, const Sint16 *vx, const Sint16 *vy, int n, SDL_Surface *texture, int texture_dx, int texture_dy)
+// void gfxPrimitivesSetFont        (const void *fontdata, Uint32 cw, Uint32 ch)
+// void gfxPrimitivesSetFontRotation(Uint32 rotation)
+// int  characterColor              (SDL_Renderer *renderer, Sint16 x, Sint16 y, char c, Uint32 color)
+// int  stringColor                 (SDL_Renderer *renderer, Sint16 x, Sint16 y, const char *s, Uint32 color)
+
+static VALUE Renderer_draw_bezier(VALUE self,
+                                  VALUE xs_,
+                                  VALUE ys_,
+                                  VALUE steps_,
+                                  VALUE color_) {
+  DEFINE_SELF(Renderer, renderer, self);
+
+  int xlen = RARRAY_LENINT(xs_);
+  int ylen = RARRAY_LENINT(ys_);
+
+  if (xlen != ylen)
+    rb_raise(rb_eArgError, "xs & ys are different length");
+
+  Sint16 *xs = malloc(xlen*sizeof(Sint16));
+
+  for (int i = 0; i < xlen; i++) {
+    xs[i] = NUM2SINT16(RARRAY_AREF(xs_, i));
+  }
+
+  Sint16 *ys = malloc(ylen*sizeof(Sint16));
+  for (int i = 0; i < ylen; i++) {
+    ys[i] = NUM2SINT16(RARRAY_AREF(ys_, i));
+  }
+
+  int steps = NUM2INT(steps_);
+  Uint32 color = VALUE2COLOR(color_);
 
-  if (SDL_SetColorKey(surface,
-                      NUM2UINT(flag),
-                      VALUE2COLOR(key, surface->format)) < 0)
-    FAILURE("Surface#set_color_key");
+  if (bezierColor(renderer, xs, ys, xlen, steps, color))
+    FAILURE("draw_bezier");
+
+  free(xs);
+  free(ys);
 
   return Qnil;
 }
 
-typedef void (*sxyxyc_func)(SDL_Surface *, Sint16, Sint16, Sint16, Sint16, Uint32);
-typedef void (*sxyrc_func)(SDL_Surface *, Sint16, Sint16, Sint16, Uint32);
+int aafilledCircleColor(SDL_Renderer * renderer, Sint16 x, Sint16 y, Sint16 rad, Uint32 color) {
+  int result = 0;
+  result |= filledCircleColor(renderer, x, y, rad, color);
+  result |= aacircleColor(renderer, x, y, rad, color);
+  return result;
+}
 
-static VALUE _draw_func_sxyrc(sxyrc_func f, VALUE self, VALUE x, VALUE y, VALUE r, VALUE c) {
-  DEFINE_SELF(Surface, surface, self);
+static f_rxyrc f_circle[] = { &circleColor,
+                              &filledCircleColor,
+                              &aacircleColor,
+                              &aafilledCircleColor };
 
-  Sint16 x1, y1, r_;
-  Uint32 color;
+static VALUE Renderer_draw_circle(VALUE self,
+                                  VALUE x,  VALUE y,
+                                  VALUE r,
+                                  VALUE c,
+                                  VALUE aa, VALUE f) {
+  DEFINE_SELF(Renderer, renderer, self);
 
-  x1 = NUM2SINT16(x);
-  y1 = NUM2SINT16(y);
-  r_ = NUM2SINT16(r);
-  color = VALUE2COLOR(c, surface->format);
+  Uint8 idx = IDX2(RTEST(aa), RTEST(f));
 
-  f(surface, x1, y1, r_, color);
+  f_circle[idx](renderer,
+                NUM2SINT16(x), NUM2SINT16(y),
+                NUM2SINT16(r),
+                NUM2UINT(c));
 
   return Qnil;
 }
 
-static VALUE _draw_func_sxywhc(sxyxyc_func f, VALUE self, VALUE x, VALUE y, VALUE w, VALUE h, VALUE c) {
-  DEFINE_SELF(Surface, surface, self);
+int aafilledEllipseColor(SDL_Renderer * renderer, Sint16 x, Sint16 y, Sint16 rx, Sint16 ry, Uint32 color) {
+  int result = 0;
+  result |= filledEllipseColor(renderer, x, y, rx, ry, color);
+  result |= aaellipseColor(renderer, x, y, rx, ry, color);
+  return result;
+}
+
+static f_rxyxyc f_ellipse[] = { &ellipseColor,
+                                &filledEllipseColor,
+                                &aaellipseColor,
+                                &aafilledEllipseColor };
 
-  Sint16 x1, y1, x2, y2;
-  Uint32 color;
+static VALUE Renderer_draw_ellipse(VALUE self,
+                                   VALUE x,  VALUE y,
+                                   VALUE rx, VALUE ry,
+                                   VALUE c,
+                                   VALUE aa, VALUE f) {
+  DEFINE_SELF(Renderer, renderer, self);
 
-  x1 = NUM2SINT16(x);
-  y1 = NUM2SINT16(y);
-  x2 = x1 + NUM2SINT16(w);
-  y2 = y1 + NUM2SINT16(h);
-  color = VALUE2COLOR(c, surface->format);
+  Uint8 idx = IDX2(RTEST(aa), RTEST(f));
 
-  f(surface, x1, y1, x2, y2, color);
+  f_ellipse[idx](renderer,
+                 NUM2SINT16(x),
+                 NUM2SINT16(y),
+                 NUM2SINT16(rx),
+                 NUM2SINT16(ry),
+                 NUM2UINT(c));
 
   return Qnil;
 }
 
-static VALUE _draw_func_sxyxyc(sxyxyc_func f, VALUE self, VALUE x, VALUE y, VALUE w, VALUE h, VALUE c) {
-  DEFINE_SELF(Surface, surface, self);
+static f_rxyxyc f_line[] = { &lineColor,
+                             &aalineColor };
 
-  Sint16 x1, y1, r1, r2;
-  Uint32 color;
+static VALUE Renderer_draw_line(VALUE self,
+                                VALUE x1, VALUE y1,
+                                VALUE x2, VALUE y2,
+                                VALUE c,
+                                VALUE aa) {
+  DEFINE_SELF(Renderer, renderer, self);
 
-  x1 = NUM2SINT16(x);
-  y1 = NUM2SINT16(y);
-  r1 = NUM2SINT16(w);
-  r2 = NUM2SINT16(h);
-  color = VALUE2COLOR(c, surface->format);
+  Uint8 idx = IDX1(RTEST(aa));
 
-  f(surface, x1, y1, r1, r2, color);
+  f_line[idx](renderer,
+              NUM2SINT16(x1),
+              NUM2SINT16(y1),
+              NUM2SINT16(x2),
+              NUM2SINT16(y2),
+              VALUE2COLOR(c));
 
   return Qnil;
 }
 
-static VALUE Surface_draw_bezier(VALUE self,
-                                 VALUE x1,  VALUE y1,
-                                 VALUE cx1, VALUE cy1,
-                                 VALUE cx2, VALUE cy2,
-                                 VALUE x2,  VALUE y2,
-                                 VALUE l,   VALUE c) {
-  DEFINE_SELF(Surface, surface, self);
+static f_rxyxyc f_rect[] = { &rectangleColor,
+                             &boxColor };
+
+static VALUE Renderer_draw_rect(VALUE self,
+                                VALUE x_, VALUE y_,
+                                VALUE w_, VALUE h_,
+                                VALUE c,
+                                VALUE f) {
+  DEFINE_SELF(Renderer, renderer, self);
 
-  sge_AABezier(surface,
-               NUM2SINT16(x1), NUM2SINT16(y1),
-               NUM2SINT16(cx1), NUM2SINT16(cy1),
-               NUM2SINT16(cx2), NUM2SINT16(cy2),
-               NUM2SINT16(x2), NUM2SINT16(y2),
-               NUM2INT(l),
-               VALUE2COLOR(c, surface->format));
+  Sint16 x1 = NUM2SINT16(x_);
+  Sint16 y1 = NUM2SINT16(y_);
+  Sint16 x2 = NUM2SINT16(w_) + x1;
+  Sint16 y2 = NUM2SINT16(h_) + y1;
+  Uint8 idx = IDX1(RTEST(f));
+
+  f_rect[idx](renderer, x1, y1, x2, y2, NUM2UINT(c));
 
   return Qnil;
 }
 
-DEFINE_SXYRC(draw_circle,   sge_AACircle)
-DEFINE_SXYRC(fill_circle,   sge_AAFilledCircle)
-DEFINE_SXYXYC(draw_line,    sge_AALine)
-DEFINE_SXYXYC(fill_ellipse, sge_FilledEllipse)
-DEFINE_SXYXYC(draw_ellipse, sge_Ellipse)
-DEFINE_SXYWHC(draw_rect,    sge_Rect)
-DEFINE_SXYWHC(fill_rect,    sge_FilledRect)
+static VALUE Renderer_clear(VALUE self, VALUE color) {
+  DEFINE_SELF(Renderer, renderer, self);
+  DEFINE_SELF(PixelFormat, format, rb_ivar_get(self, id_iv_format));
 
-static VALUE Surface_fast_rect(VALUE self, VALUE x, VALUE y, VALUE w, VALUE h, VALUE color) {
-  DEFINE_SELF(Surface, surface, self);
+  Uint8 r, g, b, a;
+  SDL_GetRGBA(NUM2UINT(color), format, &r, &g, &b, &a);
 
-  SDL_Rect rect = NewRect(x, y, w, h);
+  SDL_SetRenderDrawColor(renderer, r, g, b, a);
 
-  if (SDL_FillRect(surface, &rect, VALUE2COLOR(color, surface->format)) < 0)
-    FAILURE("Surface#fast_rect");
+  if (SDL_RenderClear(renderer))
+    FAILURE("Renderer#clear");
 
   return Qnil;
 }
 
-static VALUE Surface_flags(VALUE self) {
-  DEFINE_SELF(Surface, surface, self);
-
-  return UINT2NUM(surface->flags);
-}
-
-static VALUE Surface_set_alpha(VALUE self, VALUE flag, VALUE alpha) {
-  DEFINE_SELF(Surface, surface, self);
+static VALUE Renderer_copy_texture(VALUE self, VALUE texture_) {
+  DEFINE_SELF(Renderer, renderer, self);
+  DEFINE_SELF(Texture,  texture,  texture_);
 
-  if (SDL_SetAlpha(surface, NUM2UINT(flag), NUM2UINT8(alpha)))
-    FAILURE("Surface#set_alpha");
+  if (SDL_RenderCopy(renderer, texture, NULL, NULL))
+    FAILURE("Renderer#copy_texture");
 
   return Qnil;
 }
 
+static VALUE Renderer_fast_rect(VALUE self,
+                               VALUE x, VALUE y,
+                               VALUE w, VALUE h,
+                               VALUE color) {
+  return Renderer_draw_rect(self, x, y, w, h, color, Qtrue);
+}
+
 static VALUE Surface_format(VALUE self) {
   DEFINE_SELF(Surface, surface, self);
   SDL_PixelFormat* format;
   SDL_Palette* palette;
   SDL_Palette* src = surface->format->palette;
 
+  // TODO: remove this or drop down to SDL_AllocFormat only
+
   if (src) {
     palette = ALLOC(SDL_Palette);
     palette->ncolors = src->ncolors;
@@ -662,6 +726,26 @@ static VALUE Surface_format(VALUE self) {
   return ret;
 }
 
+static VALUE Renderer_h(VALUE self) {
+  DEFINE_SELF(Renderer, renderer, self);
+
+  int w, h;
+
+  SDL_GetRendererOutputSize(renderer, &w, &h);
+
+  return INT2NUM(h);
+}
+
+static VALUE Renderer_w(VALUE self) {
+  DEFINE_SELF(Renderer, renderer, self);
+
+  int w, h;
+
+  SDL_GetRendererOutputSize(renderer, &w, &h);
+
+  return INT2NUM(w);
+}
+
 static VALUE Surface_h(VALUE self) {
   DEFINE_SELF(Surface, surface, self);
 
@@ -669,27 +753,41 @@ static VALUE Surface_h(VALUE self) {
 }
 
 static VALUE Surface_index(VALUE self, VALUE x, VALUE y) {
-  DEFINE_SELF(Surface, surface, self);
-
-  return UINT2NUM(sge_GetPixel(surface,
-                               NUM2SINT16(x), NUM2SINT16(y)));
+  rb_raise(eSDLError, "Reading the canvas isn't currently supported");
+  return Qnil;
 }
 
-static VALUE Surface_index_equals(VALUE self, VALUE x, VALUE y, VALUE color) {
-  DEFINE_SELF(Surface, surface, self);
+static VALUE Renderer_index_eq(VALUE self, VALUE x, VALUE y, VALUE color) {
+  DEFINE_SELF(Renderer, renderer, self);
 
-  sge_PutPixel(surface,
-               NUM2SINT16(x), NUM2SINT16(y),
-               VALUE2COLOR(color, surface->format));
+  pixelColor(renderer, NUM2SINT16(x), NUM2SINT16(y), VALUE2COLOR(color));
 
   return Qnil;
 }
 
+static SDL_Surface *pixel = NULL;
+
+static VALUE Renderer_index(VALUE self, VALUE x, VALUE y) {
+  DEFINE_SELF(Renderer, renderer, self);
+
+  SDL_Rect pixel_rect = { NUM2SINT16(x), NUM2SINT16(y), 1, 1 };
+
+  if (!pixel)
+    pixel = SDL_CreateRGBSurfaceWithFormat(0, 1, 1, 32,
+                                           SDL_PIXELFORMAT_RGBA32);
+
+  if (SDL_RenderReadPixels(renderer, &pixel_rect, SDL_PIXELFORMAT_RGBA32,
+                           pixel->pixels,
+                           pixel->pitch))
+    FAILURE("Renderer#[]");
+
+  return UINT2NUM(((Uint32*)pixel->pixels)[0]);
+}
+
 static VALUE Surface_make_collision_map(VALUE self) {
   DEFINE_SELF(Surface, surface, self);
 
   sge_cdata * cdata = sge_make_cmap(surface);
-
   if (!cdata)
     FAILURE("Surface#make_collision_map");
 
@@ -702,35 +800,205 @@ static VALUE Surface_w(VALUE self) {
   return INT2NUM(surface->w);
 }
 
-static VALUE Surface_transform(VALUE self, VALUE bgcolor, VALUE angle,
-                               VALUE xscale, VALUE yscale, VALUE flags) {
+// TODO: maybe remove? I dunno... could be nice for pre-rendering?
+static VALUE Surface_transform(VALUE self, VALUE angle,
+                               VALUE xscale, VALUE yscale,
+                               VALUE flags) {
   DEFINE_SELF(Surface, surface, self);
 
-  SDL_Surface *result = sge_transform_surface(surface,
-                                              VALUE2COLOR(bgcolor, surface->format),
-                                              NUM2FLT(angle),
-                                              NUM2FLT(xscale),
-                                              NUM2FLT(yscale),
-                                              NUM2UINT8(flags));
+  SDL_Surface *result = rotozoomSurfaceXY(surface,
+                                          NUM2FLT(angle),
+                                          NUM2FLT(xscale),
+                                          NUM2FLT(yscale),
+                                          SMOOTHING_ON);
+
   if (!result)
     FAILURE("Surface#transform");
 
-  if (SDL_SetColorKey(result,
-                      SDL_SRCCOLORKEY|SDL_RLEACCEL,
-                      surface->format->colorkey) < 0)
-    FAILURE("Surface#transform(set_color_key)");
+  return TypedData_Wrap_Struct(cSurface, &_Surface_type, result);
+}
 
+static VALUE Renderer_blit(VALUE self, VALUE src_,
+                           VALUE x_, VALUE y_,
+                           VALUE a_,
+                           VALUE ws_, VALUE hs_,
+                           VALUE center_) {
+  DEFINE_SELF(Renderer, renderer, self);
+  DEFINE_SELF(Surface, src, src_);
 
-  if (SDL_SetAlpha(result, SDL_SRCALPHA|SDL_RLEACCEL, surface->format->alpha))
-    FAILURE("Surface#transform(set_alpha)");
+  int x    = NUM2SINT16(x_);
+  int y    = NUM2SINT16(y_);
+  double a = RTEST(a_)  ? -NUM2DBL(a_) : 0.0;
+  float ws = RTEST(ws_) ? NUM2FLT(ws_) : 1.0;
+  float hs = RTEST(hs_) ? NUM2FLT(hs_) : 1.0;
 
-  return TypedData_Wrap_Struct(cSurface, &_Surface_type, result);
+  SDL_Texture* texture;
+  VALUE vtexture = rb_attr_get(src_, id_iv_texture);
+
+  if (RTEST(vtexture)) {
+    SET_SELF(Texture, texture, vtexture);
+  } else {
+    texture = SDL_CreateTextureFromSurface(renderer, src);
+    if (!texture)
+      FAILURE("_blit(SDL_CreateTextureFromSurface)");
+
+    VALUE vtexture = TypedData_Wrap_Struct(cTexture, &_Texture_type, texture);
+
+    rb_ivar_set(src_, id_iv_texture,  vtexture);
+  }
+
+  int w, h;
+  if (SDL_QueryTexture(texture, NULL, NULL, &w, &h))
+    FAILURE("_blit(SDL_QueryTexture)");
+
+  SDL_Rect dst_rect = { x, y, w*ws, h*hs };
+
+  if (SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND))
+    FAILURE("Renderer#blit(SetTextureBlendMode)");
+
+  if (RTEST(a_) || RTEST(ws_) || RTEST(hs_)) {
+    SDL_Point bottom_left  = { 0, h-1 };
+    SDL_Point *point = (RTEST(center_) ? NULL : &bottom_left);
+
+    if (SDL_RenderCopyEx(renderer, texture, NULL, &dst_rect,
+                         a, point, SDL_FLIP_NONE))
+      FAILURE("_blit(SDL_RenderCopyEx)");
+  } else {
+    if (SDL_RenderCopy(renderer, texture, NULL, &dst_rect))
+      FAILURE("_blit(SDL_RenderCopyEx)");
+  }
+
+  return Qnil;
 }
 
-static VALUE Surface_save(VALUE self, VALUE path) {
-  DEFINE_SELF(Surface, surface, self);
+static VALUE Renderer_sprite(VALUE self, VALUE w_, VALUE h_) {
+  UNUSED(self);
+
+  int w   = NUM2INT(w_);
+  int h   = NUM2INT(h_);
+  int bpp = 32;
+
+  SDL_Surface *surface =
+    SDL_CreateRGBSurfaceWithFormat(0, w, h, bpp, SDL_PIXELFORMAT_RGBA32);
+  if (!surface) FAILURE("Surface#sprite(CreateRGBSurfaceWithFormat)");
+
+  SDL_Renderer *renderer = SDL_CreateSoftwareRenderer(surface);
+  if (!renderer) FAILURE("Surface#sprite(CreateSoftwareRenderer)");
+
+  // bumps the refcount and returns the same thing
+  SDL_PixelFormat *format = SDL_AllocFormat(surface->format->format);
+  if (format != surface->format)
+    rb_raise(eSDLError, "SDL_AllocFormat freaked out. %p vs %p",
+             format,
+             surface->format);
+
+  VALUE vrenderer = TypedData_Wrap_Struct(cRenderer,    &_Renderer_type,    renderer);
+  VALUE vsurface  = TypedData_Wrap_Struct(cSurface,     &_Surface_type,     surface);
+  VALUE vformat   = TypedData_Wrap_Struct(cPixelFormat, &_PixelFormat_type, format);
+
+  rb_ivar_set(vrenderer, id_iv_surface, vsurface);
+  rb_ivar_set(vrenderer, id_iv_format,  vformat);
+
+  return vrenderer;
+}
+
+static VALUE Renderer_save(VALUE self, VALUE path) {
+  DEFINE_SELF(Renderer, renderer, self);
+
+  int w, h;
+  SDL_GetRendererOutputSize(renderer, &w, &h);
+
+  SDL_Surface *sshot = SDL_CreateRGBSurfaceWithFormat(0, w, h, 32,
+                                                      SDL_PIXELFORMAT_RGBA32);
+  if (SDL_RenderReadPixels(renderer, NULL, SDL_PIXELFORMAT_RGBA32,
+                           sshot->pixels,
+                           sshot->pitch))
+    FAILURE("Renderer#save");
+  int ret = IMG_SavePNG(sshot, RSTRING_PTR(path));
+  SDL_FreeSurface(sshot);
+
+  return INT2NUM(ret);
+}
+
+//// SDL::Renderer methods:
+
+static void _Renderer_free(void* renderer) {
+  if (is_quit) return;
+  if (renderer) SDL_DestroyRenderer(renderer);
+}
+
+static void _Renderer_mark(void* renderer) {
+  UNUSED(renderer);
+}
+
+static VALUE Renderer_target(VALUE self) {
+  DEFINE_SELF(Renderer, renderer, self);
+
+  SDL_Texture* texture = SDL_GetRenderTarget(renderer);
+
+  if (!texture)
+    FAILURE("Renderer#target");
+
+  return TypedData_Wrap_Struct(cTexture, &_Texture_type, texture);
+}
+
+static VALUE Renderer_target_eq(VALUE self, VALUE texture_) {
+  DEFINE_SELF(Renderer, renderer, self);
+  DEFINE_SELF0(Texture, texture, texture_);
+
+  if (SDL_SetRenderTarget(renderer, texture))
+    FAILURE("Renderer#target=");
+
+  return texture_;
+}
+
+//// SDL::Texture methods:
+
+static void _Texture_free(void* texture) {
+  if (is_quit) return;
+  if (texture) SDL_DestroyTexture(texture);
+}
 
-  return INT2NUM(SDL_SaveBMP(surface, RSTRING_PTR(path)));
+static void _Texture_mark(void* texture) {
+  UNUSED(texture);
+}
+
+//// SDL::Window methods:
+
+static void _Window_free(void* Window) {
+  if (is_quit) return;
+  if (Window) SDL_DestroyWindow(Window);
+}
+
+static void _Window_mark(void* Window) {
+  UNUSED(Window);
+}
+
+static VALUE Window_title_eq(VALUE self, VALUE title) {
+  DEFINE_SELF(Window, window, self);
+
+  ExportStringValue(title);
+
+  SDL_SetWindowTitle(window, StringValueCStr(title));
+
+  return Qnil;
+}
+
+static VALUE Window_title(VALUE self) {
+  DEFINE_SELF(Window, window, self);
+
+  const char* title = SDL_GetWindowTitle(window);
+
+  return rb_str_new_cstr(title);
+}
+
+static VALUE Window_update(VALUE self) {
+  DEFINE_SELF(Window, window, self);
+
+  if (SDL_UpdateWindowSurface(window))
+    FAILURE("Window#update");
+
+  return Qnil;
 }
 
 //// SDL::TTFFont methods:
@@ -765,47 +1033,47 @@ static VALUE Font_height(VALUE self) {
 
 static VALUE Font_render(VALUE self, VALUE dst, VALUE text, VALUE c) {
   DEFINE_SELF(TTFFont, font, self);
-  DEFINE_SELF(Surface, surface, dst);
+  DEFINE_SELF(PixelFormat, format, rb_ivar_get(dst, id_iv_format));
 
   SDL_Surface *result;
+  SDL_Color fg;
 
-  SDL_Color fg = sge_GetRGB(surface, VALUE2COLOR(c, surface->format));
+  SDL_GetRGBA(VALUE2COLOR(c), format,
+              &(fg.r), &(fg.g), &(fg.b), &(fg.a));
 
   ExportStringValue(text);
   result = TTF_RenderUTF8_Blended(font, StringValueCStr(text), fg);
 
-  if (result) return TypedData_Wrap_Struct(cSurface, &_Surface_type, result);
-  return Qnil;
+  if (!result)
+    TTF_FAILURE("Font.render");
+
+  return TypedData_Wrap_Struct(cSurface, &_Surface_type, result);
 }
 
 static VALUE Font_draw(VALUE self, VALUE dst, VALUE text, VALUE x, VALUE y, VALUE c) {
   VALUE img = Font_render(self, dst, text, c);
-  VALUE zero = INT2FIX(0);
-
-  Surface_s_blit(cSurface, img, zero, zero, zero, zero, dst, x, y);
-
-  return Qnil;
+  return Renderer_blit(dst, img, x, y, Qnil, Qnil, Qnil, Qnil);
 }
 
-//// SDL::WM methods:
-
-static VALUE WM_s_set_caption(VALUE mod, VALUE title, VALUE icon) {
-  UNUSED(mod);
-  ExportStringValue(title);
-  ExportStringValue(icon);
+static VALUE Font_text_size(VALUE self, VALUE text) {
+  DEFINE_SELF(TTFFont, font, self);
+  int w = 1, h = 2, result;
 
-  SDL_WM_SetCaption(StringValueCStr(title), StringValueCStr(icon));
+  ExportStringValue(text);
+  result = TTF_SizeText(font, StringValueCStr(text), &w, &h);
 
-  return Qnil;
+  if (!result) {
+    return rb_ary_new_from_args(2, INT2FIX(w), INT2FIX(h));
+  } else {
+    FAILURE("SDL::TTF#text_size");
+  }
 }
 
 // The Rest...
 
 void Init_sdl() {
-
   mSDL         = rb_define_module("SDL");
   mKey         = rb_define_module_under(mSDL, "Key");
-  mWM          = rb_define_module_under(mSDL, "WM");
   mMouse       = rb_define_module_under(mSDL, "Mouse");
 
   cAudio        = rb_define_class_under(mSDL, "Audio",        rb_cData);
@@ -816,17 +1084,19 @@ void Init_sdl() {
   cTTFFont      = rb_define_class_under(mSDL, "TTF",          rb_cData); // TODO: Font
 
   cScreen       = rb_define_class_under(mSDL, "Screen",       cSurface);
+  cRenderer     = rb_define_class_under(mSDL, "Renderer",     rb_cData);
+  cWindow       = rb_define_class_under(mSDL, "Window",       rb_cData);
+  cTexture      = rb_define_class_under(mSDL, "Texture",      rb_cData);
 
-  cEventQuit   = rb_define_class_under(cEvent, "Quit", cEvent);
+  cEventQuit    = rb_define_class_under(cEvent, "Quit",    cEvent);
   cEventKeydown = rb_define_class_under(cEvent, "Keydown", cEvent);
-  cEventKeyup   = rb_define_class_under(cEvent, "Keyup", cEvent);
+  cEventKeyup   = rb_define_class_under(cEvent, "Keyup",   cEvent);
 
   cEventMousemove = rb_define_class_under(cEvent, "Mousemove", cEvent);
   cEventMousedown = rb_define_class_under(cEvent, "Mousedown", cEvent);
   cEventMouseup   = rb_define_class_under(cEvent, "Mouseup",   cEvent);
 
   eSDLError    = rb_define_class_under(mSDL,     "Error",           rb_eStandardError);
-  eSDLMem      = rb_define_class_under(cSurface, "VideoMemoryLost", rb_eStandardError);
 
   //// SDL methods:
 
@@ -849,7 +1119,6 @@ void Init_sdl() {
   rb_define_attr(cEventKeydown, "press",   1, 1);
   rb_define_attr(cEventKeydown, "sym",     1, 1);
   rb_define_attr(cEventKeydown, "mod",     1, 1);
-  rb_define_attr(cEventKeydown, "unicode", 1, 1);
 
   rb_define_attr(cEventKeyup, "press",   1, 1); // TODO: refactor, possibly subclass
   rb_define_attr(cEventKeyup, "sym",     1, 1);
@@ -882,62 +1151,74 @@ void Init_sdl() {
   rb_define_module_function(mMouse, "state", Mouse_s_state, 0);
 
   //// SDL::PixelFormat methods:
+  //// TODO: phase these out... move to renderer or top of SDL
 
-  rb_define_method(cPixelFormat, "get_rgb",  PixelFormat_get_rgb, 1);
+  rb_define_method(cPixelFormat, "get_rgba", PixelFormat_get_rgba, 1);
   rb_define_method(cPixelFormat, "map_rgba", PixelFormat_map_rgba, 4);
-  rb_define_method(cPixelFormat, "colorkey", PixelFormat_colorkey, 0);
-  rb_define_method(cPixelFormat, "alpha", PixelFormat_alpha, 0);
 
   //// SDL::Screen methods:
+  //// TODO: phase these out entirely?
 
   rb_define_singleton_method(cScreen, "open", Screen_s_open, 4);
-  rb_define_method(cScreen, "flip", Screen_flip, 0);
-  rb_define_method(cScreen, "update", Screen_update, 4);
+
+  id_W = rb_intern("W");
+  id_H = rb_intern("H");
+  rb_const_set(cScreen, id_W, Qnil);
+  rb_const_set(cScreen, id_H, Qnil);
+
+  //// SDL::Window methods:
+
+  // TODO: move to top renderer?
+  rb_define_method(cWindow, "title",  Window_title, 0);
+  rb_define_method(cWindow, "title=", Window_title_eq, 1);
+  rb_define_method(cWindow, "update", Window_update, 0);
+
+  //// SDL::Renderer methods:
+
+  rb_define_method(cRenderer, "[]",            Renderer_index,        2);
+  rb_define_method(cRenderer, "[]=",           Renderer_index_eq,     3);
+  rb_define_method(cRenderer, "blit",          Renderer_blit,         7);
+  rb_define_method(cRenderer, "clear",         Renderer_clear,        1);
+  rb_define_method(cRenderer, "copy_texture",  Renderer_copy_texture, 1);
+  rb_define_method(cRenderer, "draw_bezier",   Renderer_draw_bezier,  4);
+  rb_define_method(cRenderer, "draw_circle",   Renderer_draw_circle,  6);
+  rb_define_method(cRenderer, "draw_ellipse",  Renderer_draw_ellipse, 7);
+  rb_define_method(cRenderer, "draw_line",     Renderer_draw_line,    6);
+  rb_define_method(cRenderer, "draw_rect",     Renderer_draw_rect,    6);
+  rb_define_method(cRenderer, "fast_rect",     Renderer_fast_rect,    5);
+  rb_define_method(cRenderer, "h",             Renderer_h,            0);
+  rb_define_method(cRenderer, "new_texture",   Renderer_new_texture,  0);
+  rb_define_method(cRenderer, "present",       Renderer_present,      0);
+  rb_define_method(cRenderer, "save",          Renderer_save,         1);
+  rb_define_method(cRenderer, "sprite",        Renderer_sprite,       2);
+  rb_define_method(cRenderer, "target",        Renderer_target,       0);
+  rb_define_method(cRenderer, "target=",       Renderer_target_eq,    1);
+  rb_define_method(cRenderer, "w",             Renderer_w,            0);
 
   //// SDL::Surface methods:
 
-  rb_define_singleton_method(cSurface, "blit", Surface_s_blit, 8);
-  rb_define_singleton_method(cSurface, "new", Surface_s_new, 3);
   rb_define_singleton_method(cSurface, "load", Surface_s_load, 1);
-  rb_define_method(cSurface, "set_color_key",  Surface_set_color_key, 2);
-  rb_define_method(cSurface, "draw_bezier",  Surface_draw_bezier,  10);
-  rb_define_method(cSurface, "draw_circle",  Surface_draw_circle,  4);
-  rb_define_method(cSurface, "fill_circle",  Surface_fill_circle,  4);
-  rb_define_method(cSurface, "draw_ellipse", Surface_draw_ellipse, 5);
-  rb_define_method(cSurface, "fill_ellipse", Surface_fill_ellipse, 5);
-  rb_define_method(cSurface, "draw_line",    Surface_draw_line,    5);
-  rb_define_method(cSurface, "draw_rect",    Surface_draw_rect,    5);
-  rb_define_method(cSurface, "fill_rect",    Surface_fill_rect,    5);
-  rb_define_method(cSurface, "fast_rect",    Surface_fast_rect,    5);
-  rb_define_method(cSurface, "format",       Surface_format,       0);
-  rb_define_method(cSurface, "h",            Surface_h,            0);
+
+  rb_define_method(cSurface, "h",             Surface_h,             0);
+  rb_define_method(cSurface, "[]",            Surface_index,         2);
+  rb_define_method(cSurface, "format",        Surface_format,        0);
+  rb_define_method(cSurface, "transform",     Surface_transform,     4);
+  rb_define_method(cSurface, "w",             Surface_w,             0);
+
+  // TODO: reimplement and jettison SGE
   rb_define_method(cSurface, "make_collision_map", Surface_make_collision_map, 0);
-  rb_define_method(cSurface, "w",            Surface_w,            0);
-  rb_define_method(cSurface, "[]",           Surface_index,        2);
-  rb_define_method(cSurface, "[]=",          Surface_index_equals, 3);
-  rb_define_method(cSurface, "transform",    Surface_transform,    5);
-  rb_define_method(cSurface, "save",         Surface_save,         1);
-  rb_define_method(cSurface, "flags",        Surface_flags,        0);
-  rb_define_method(cSurface, "set_alpha",    Surface_set_alpha,    2);
 
   //// SDL::TTFFont methods:
 
   rb_define_singleton_method(cTTFFont, "open", Font_s_open, 2);
 
-  rb_define_method(cTTFFont, "height", Font_height, 0);
-  rb_define_method(cTTFFont, "render", Font_render, 3);
-  rb_define_method(cTTFFont, "draw",   Font_draw, 5);
-
-  //// SDL::WM methods:
-
-  rb_define_module_function(mWM, "set_caption", WM_s_set_caption, 2);
+  rb_define_method(cTTFFont, "height",    Font_height,    0);
+  rb_define_method(cTTFFont, "render",    Font_render,    3);
+  rb_define_method(cTTFFont, "draw",      Font_draw,      5);
+  rb_define_method(cTTFFont, "text_size", Font_text_size, 1);
 
   //// Other Init Actions:
 
-  sge_Lock_ON();
-  sge_Update_OFF();
-  SDL_EnableUNICODE(1);
-
   for (int i=0; i < SDL_NUMEVENTS; ++i)
     event_creators[i] = Event__null;
 
@@ -951,42 +1232,49 @@ void Init_sdl() {
   // event_creators[SDL_SYSWMEVENT]      = Event__syswm;
   // event_creators[SDL_VIDEORESIZE]     = Event__videoresize;
 
+  // TODO: maybe pause/unpause automatically instead of chewing CPU?
+  // SDL_APP_DIDENTERBACKGROUND
+  // SDL_APP_DIDENTERFOREGROUND
+
   rb_set_end_proc(sdl__quit, 0);
 
   //// Simple Mapped Constants:
 
+  INIT_ID(surface);
+  INIT_ID(format);
+  INIT_ID(renderer);
+  INIT_ID(window);
+  INIT_ID(texture);
   INIT_ID(button);
   INIT_ID(mod);
   INIT_ID(press);
   INIT_ID(state);
   INIT_ID(sym);
-  INIT_ID(unicode);
   INIT_ID(x);
   INIT_ID(xrel);
   INIT_ID(y);
   INIT_ID(yrel);
 
   #define DC(n) rb_define_const(mSDL, #n, UINT2NUM(SDL_##n))
-  DC(DOUBLEBUF);
-  DC(HWSURFACE);
   DC(INIT_EVERYTHING);
-  DC(INIT_VIDEO);
-  DC(RLEACCEL);
-  DC(SRCALPHA);
-  DC(SRCCOLORKEY);
-  DC(SWSURFACE);
-
-  // DC("ANYFORMAT");
-  // DC("ASYNCBLIT");
-  // DC("FULLSCREEN");
-  // DC("HWACCEL");
-  // DC("HWPALETTE");
-  // DC("NOFRAME");
-  // DC("OPENGL");
-  // DC("OPENGLBLIT");
-  // DC("PREALLOC");
-  // DC("RESIZABLE");
-  // DC("RLEACCELOK");
+  DC(INIT_VIDEO); // TODO: phase out? it's in the tests...
+  DC(TRUE);
+
+  #define DW(n) rb_define_const(mSDL, #n, UINT2NUM(SDL_WINDOW_##n))
+  DW(FULLSCREEN);
+  DW(OPENGL);
+  DW(SHOWN);
+  DW(HIDDEN);
+  DW(BORDERLESS);
+  DW(RESIZABLE);
+  DW(MINIMIZED);
+  DW(MAXIMIZED);
+  DW(INPUT_GRABBED);
+  DW(INPUT_FOCUS);
+  DW(MOUSE_FOCUS);
+  DW(FULLSCREEN_DESKTOP);
+  DW(FOREIGN);
+  DW(ALLOW_HIGHDPI);
 
   //// Keyboard Constants
 
@@ -995,9 +1283,8 @@ void Init_sdl() {
   #define DK(n)      _KEY(#n,      SDLK_##n)
   #define DKP(n)     _KEY("K"#n,   SDLK_##n)
   #define DM(n)      _KEY("MOD_"#n, KMOD_##n)
-  #define DR(n)      _KEY("DEFAULT_REPEAT_"#n, SDL_DEFAULT_REPEAT_##n)
 
-  DK(UNKNOWN);   DK(FIRST);      DK(BACKSPACE); DK(TAB);       DK(CLEAR);
+  DK(UNKNOWN);                   DK(BACKSPACE); DK(TAB);       DK(CLEAR);
   DK(RETURN);    DK(PAUSE);      DK(ESCAPE);    DK(SPACE);     DK(EXCLAIM);
   DK(QUOTEDBL);  DK(HASH);       DK(DOLLAR);    DK(AMPERSAND); DK(QUOTE);
   DK(LEFTPAREN); DK(RIGHTPAREN); DK(ASTERISK);  DK(PLUS);      DK(COMMA);
@@ -1017,31 +1304,9 @@ void Init_sdl() {
   KEY("U", u); KEY("V", v); KEY("W", w); KEY("X", x); KEY("Y", y);
   KEY("Z", z);
 
-  // International keyboard syms
-  DK(WORLD_0);  DK(WORLD_1);  DK(WORLD_2);  DK(WORLD_3);  DK(WORLD_4);
-  DK(WORLD_5);  DK(WORLD_6);  DK(WORLD_7);  DK(WORLD_8);  DK(WORLD_9);
-  DK(WORLD_10); DK(WORLD_11); DK(WORLD_12); DK(WORLD_13); DK(WORLD_14);
-  DK(WORLD_15); DK(WORLD_16); DK(WORLD_17); DK(WORLD_18); DK(WORLD_19);
-  DK(WORLD_20); DK(WORLD_21); DK(WORLD_22); DK(WORLD_23); DK(WORLD_24);
-  DK(WORLD_25); DK(WORLD_26); DK(WORLD_27); DK(WORLD_28); DK(WORLD_29);
-  DK(WORLD_30); DK(WORLD_31); DK(WORLD_32); DK(WORLD_33); DK(WORLD_34);
-  DK(WORLD_35); DK(WORLD_36); DK(WORLD_37); DK(WORLD_38); DK(WORLD_39);
-  DK(WORLD_40); DK(WORLD_41); DK(WORLD_42); DK(WORLD_43); DK(WORLD_44);
-  DK(WORLD_45); DK(WORLD_46); DK(WORLD_47); DK(WORLD_48); DK(WORLD_49);
-  DK(WORLD_50); DK(WORLD_51); DK(WORLD_52); DK(WORLD_53); DK(WORLD_54);
-  DK(WORLD_55); DK(WORLD_56); DK(WORLD_57); DK(WORLD_58); DK(WORLD_59);
-  DK(WORLD_60); DK(WORLD_61); DK(WORLD_62); DK(WORLD_63); DK(WORLD_64);
-  DK(WORLD_65); DK(WORLD_66); DK(WORLD_67); DK(WORLD_68); DK(WORLD_69);
-  DK(WORLD_70); DK(WORLD_71); DK(WORLD_72); DK(WORLD_73); DK(WORLD_74);
-  DK(WORLD_75); DK(WORLD_76); DK(WORLD_77); DK(WORLD_78); DK(WORLD_79);
-  DK(WORLD_80); DK(WORLD_81); DK(WORLD_82); DK(WORLD_83); DK(WORLD_84);
-  DK(WORLD_85); DK(WORLD_86); DK(WORLD_87); DK(WORLD_88); DK(WORLD_89);
-  DK(WORLD_90); DK(WORLD_91); DK(WORLD_92); DK(WORLD_93); DK(WORLD_94);
-  DK(WORLD_95);
-
   // Numeric keypad
-  DK(KP0); DK(KP1); DK(KP2); DK(KP3); DK(KP4);
-  DK(KP5); DK(KP6); DK(KP7); DK(KP8); DK(KP9);
+  DK(KP_0); DK(KP_1); DK(KP_2); DK(KP_3); DK(KP_4);
+  DK(KP_5); DK(KP_6); DK(KP_7); DK(KP_8); DK(KP_9);
 
   DK(KP_PERIOD); DK(KP_DIVIDE); DK(KP_MULTIPLY); DK(KP_MINUS);
   DK(KP_PLUS);   DK(KP_ENTER);  DK(KP_EQUALS);
@@ -1055,20 +1320,14 @@ void Init_sdl() {
   DK(F10); DK(F11); DK(F12); DK(F13); DK(F14); DK(F15);
 
   // Key state modifier keys
-  DK(NUMLOCK); DK(CAPSLOCK); DK(SCROLLOCK); DK(RSHIFT); DK(LSHIFT); DK(RCTRL);
-  DK(LCTRL); DK(RALT); DK(LALT); DK(RMETA); DK(LMETA); DK(LSUPER); DK(RSUPER);
-  DK(MODE);
+  DK(CAPSLOCK); DK(SCROLLLOCK); DK(RSHIFT); DK(LSHIFT); DK(RCTRL);
+  DK(LCTRL); DK(RALT); DK(LALT); DK(RGUI); DK(LGUI); DK(MODE);
 
   // Miscellaneous function keys
-  DK(HELP); DK(PRINT); DK(SYSREQ); DK(BREAK);
-  DK(MENU); DK(POWER); DK(EURO); DK(LAST);
+  DK(HELP); DK(SYSREQ); DK(MENU); DK(POWER);
 
   // key mods
   DM(NONE);  DM(LSHIFT); DM(RSHIFT); DM(LCTRL); DM(RCTRL); DM(LALT);     DM(RALT);
-  DM(LMETA); DM(RMETA);  DM(NUM);    DM(CAPS);  DM(MODE);  DM(RESERVED); DM(CTRL);
-  DM(SHIFT); DM(ALT);    DM(META);
-
-  // key repeat constants
-  DR(DELAY);
-  DR(INTERVAL);
+  DM(LGUI);  DM(RGUI);   DM(NUM);    DM(CAPS);  DM(MODE);  DM(RESERVED); DM(CTRL);
+  DM(SHIFT); DM(ALT);    DM(GUI);
 }