ruby2d 0.9.2 → 0.10.0

data/{assets/linux/simple2d/src → ext/ruby2d}/image.c

@@ -1,31 +1,31 @@
 // image.c
 
-#include "../include/simple2d.h"
+#include "ruby2d.h"
 
 
 /*
  * Create an image, given a file path
  */
-S2D_Image *S2D_CreateImage(const char *path) {
-  S2D_Init();
+R2D_Image *R2D_CreateImage(const char *path) {
+  R2D_Init();
 
   // Check if image file exists
-  if (!S2D_FileExists(path)) {
-    S2D_Error("S2D_CreateImage", "Image file `%s` not found", path);
+  if (!R2D_FileExists(path)) {
+    R2D_Error("R2D_CreateImage", "Image file `%s` not found", path);
     return NULL;
   }
 
   // Allocate the image structure
-  S2D_Image *img = (S2D_Image *) malloc(sizeof(S2D_Image));
+  R2D_Image *img = (R2D_Image *) malloc(sizeof(R2D_Image));
   if (!img) {
-    S2D_Error("S2D_CreateImage", "Out of memory!");
+    R2D_Error("R2D_CreateImage", "Out of memory!");
     return NULL;
   }
 
   // Load image from file as SDL_Surface
   img->surface = IMG_Load(path);
   if (!img->surface) {
-    S2D_Error("IMG_Load", IMG_GetError());
+    R2D_Error("IMG_Load", IMG_GetError());
     free(img);
     return NULL;
   }
@@ -35,7 +35,7 @@ S2D_Image *S2D_CreateImage(const char *path) {
     img->surface->format->BitsPerPixel / 4;
 
   if (bits_per_color < 8) {
-    S2D_Log(S2D_WARN, "`%s` has less than 8 bits per color and will likely not render correctly", path, bits_per_color);
+    R2D_Log(R2D_WARN, "`%s` has less than 8 bits per color and will likely not render correctly", path, bits_per_color);
   }
 
   // Initialize values
@@ -99,9 +99,9 @@ S2D_Image *S2D_CreateImage(const char *path) {
 /*
  * Rotate an image
  */
-void S2D_RotateImage(S2D_Image *img, GLfloat angle, int position) {
+void R2D_RotateImage(R2D_Image *img, GLfloat angle, int position) {
 
-  S2D_GL_Point p = S2D_GetRectRotationPoint(
+  R2D_GL_Point p = R2D_GetRectRotationPoint(
     img->x, img->y, img->width, img->height, position
   );
 
@@ -114,25 +114,25 @@ void S2D_RotateImage(S2D_Image *img, GLfloat angle, int position) {
 /*
  * Draw an image
  */
-void S2D_DrawImage(S2D_Image *img) {
+void R2D_DrawImage(R2D_Image *img) {
   if (!img) return;
 
   if (img->texture_id == 0) {
-    S2D_GL_CreateTexture(&img->texture_id, img->format,
+    R2D_GL_CreateTexture(&img->texture_id, img->format,
                          img->orig_width, img->orig_height,
                          img->surface->pixels, GL_NEAREST);
     SDL_FreeSurface(img->surface);
   }
 
-  S2D_GL_DrawImage(img);
+  R2D_GL_DrawImage(img);
 }
 
 
 /*
  * Free an image
  */
-void S2D_FreeImage(S2D_Image *img) {
+void R2D_FreeImage(R2D_Image *img) {
   if (!img) return;
-  S2D_GL_FreeTexture(&img->texture_id);
+  R2D_GL_FreeTexture(&img->texture_id);
   free(img);
 }

data/{assets/linux/simple2d/src → ext/ruby2d}/input.c

@@ -1,30 +1,30 @@
 // input.c
 
-#include "../include/simple2d.h"
+#include "ruby2d.h"
 
 
 /*
  * Get the mouse coordinates relative to the viewport
  */
-void S2D_GetMouseOnViewport(S2D_Window *window, int wx, int wy, int *x, int *y) {
+void R2D_GetMouseOnViewport(R2D_Window *window, int wx, int wy, int *x, int *y) {
 
   double scale;  // viewport scale factor
   int w, h;      // width and height of scaled viewport
 
   switch (window->viewport.mode) {
 
-    case S2D_FIXED: case S2D_EXPAND:
+    case R2D_FIXED: case R2D_EXPAND:
       *x = wx / (window->orig_width  / (double)window->viewport.width);
       *y = wy / (window->orig_height / (double)window->viewport.height);
       break;
 
-    case S2D_SCALE:
-      S2D_GL_GetViewportScale(window, &w, &h, &scale);
+    case R2D_SCALE:
+      R2D_GL_GetViewportScale(window, &w, &h, &scale);
       *x = wx * 1 / scale - (window->width  - w) / (2.0 * scale);
       *y = wy * 1 / scale - (window->height - h) / (2.0 * scale);
       break;
 
-    case S2D_STRETCH:
+    case R2D_STRETCH:
       *x = wx * window->viewport.width  / (double)window->width;
       *y = wy * window->viewport.height / (double)window->height;
       break;
@@ -35,7 +35,7 @@ void S2D_GetMouseOnViewport(S2D_Window *window, int wx, int wy, int *x, int *y)
 /*
  * Show the cursor over the window
  */
-void S2D_ShowCursor() {
+void R2D_ShowCursor() {
   SDL_ShowCursor(SDL_ENABLE);
 }
 
@@ -43,6 +43,6 @@ void S2D_ShowCursor() {
 /*
  * Hide the cursor over the window
  */
-void S2D_HideCursor() {
+void R2D_HideCursor() {
   SDL_ShowCursor(SDL_DISABLE);
 }

data/{assets/linux/simple2d/src → ext/ruby2d}/music.c

@@ -1,31 +1,31 @@
 // music.c
 
-#include "../include/simple2d.h"
+#include "ruby2d.h"
 
 
 /*
  * Create the music
  */
-S2D_Music *S2D_CreateMusic(const char *path) {
-  S2D_Init();
+R2D_Music *R2D_CreateMusic(const char *path) {
+  R2D_Init();
 
   // Check if music file exists
-  if (!S2D_FileExists(path)) {
-    S2D_Error("S2D_CreateMusic", "Music file `%s` not found", path);
+  if (!R2D_FileExists(path)) {
+    R2D_Error("R2D_CreateMusic", "Music file `%s` not found", path);
     return NULL;
   }
 
   // Allocate the music structure
-  S2D_Music *mus = (S2D_Music *) malloc(sizeof(S2D_Music));
+  R2D_Music *mus = (R2D_Music *) malloc(sizeof(R2D_Music));
   if (!mus) {
-    S2D_Error("S2D_CreateMusic", "Out of memory!");
+    R2D_Error("R2D_CreateMusic", "Out of memory!");
     return NULL;
   }
 
   // Load the music data from file
   mus->data = Mix_LoadMUS(path);
   if (!mus->data) {
-    S2D_Error("Mix_LoadMUS", Mix_GetError());
+    R2D_Error("Mix_LoadMUS", Mix_GetError());
     free(mus);
     return NULL;
   }
@@ -33,6 +33,11 @@ S2D_Music *S2D_CreateMusic(const char *path) {
   // Initialize values
   mus->path = path;
 
+  // Calculate the length of music by creating a temporary R2D_Sound object
+  R2D_Sound *snd = R2D_CreateSound(path);
+  mus->length = R2D_GetSoundLength(snd);
+  R2D_FreeSound(snd);
+
   return mus;
 }
 
@@ -40,7 +45,7 @@ S2D_Music *S2D_CreateMusic(const char *path) {
 /*
  * Play the music
  */
-void S2D_PlayMusic(S2D_Music *mus, bool loop) {
+void R2D_PlayMusic(R2D_Music *mus, bool loop) {
   if (!mus) return;
 
   // If looping, set to -1 times; else 0
@@ -49,7 +54,7 @@ void S2D_PlayMusic(S2D_Music *mus, bool loop) {
   // times: 0 == once, -1 == forever
   if (Mix_PlayMusic(mus->data, times) == -1) {
     // No music for you
-    S2D_Error("S2D_PlayMusic", Mix_GetError());
+    R2D_Error("R2D_PlayMusic", Mix_GetError());
   }
 }
 
@@ -57,7 +62,7 @@ void S2D_PlayMusic(S2D_Music *mus, bool loop) {
 /*
  * Pause the playing music
  */
-void S2D_PauseMusic() {
+void R2D_PauseMusic() {
   Mix_PauseMusic();
 }
 
@@ -65,7 +70,7 @@ void S2D_PauseMusic() {
 /*
  * Resume the current music
  */
-void S2D_ResumeMusic() {
+void R2D_ResumeMusic() {
   Mix_ResumeMusic();
 }
 
@@ -73,7 +78,7 @@ void S2D_ResumeMusic() {
 /*
  * Stop the playing music; interrupts fader effects
  */
-void S2D_StopMusic() {
+void R2D_StopMusic() {
   Mix_HaltMusic();
 }
 
@@ -81,7 +86,7 @@ void S2D_StopMusic() {
 /*
  * Get the music volume
  */
-int S2D_GetMusicVolume() {
+int R2D_GetMusicVolume() {
   // Get music volume as percentage of maximum mix volume
   return ceil(Mix_VolumeMusic(-1) * (100.0 / MIX_MAX_VOLUME));
 }
@@ -90,7 +95,7 @@ int S2D_GetMusicVolume() {
 /*
  * Set the music volume a given percentage
  */
-void S2D_SetMusicVolume(int volume) {
+void R2D_SetMusicVolume(int volume) {
   // Set volume to be a percentage of the maximum mix volume
   Mix_VolumeMusic((volume / 100.0) * MIX_MAX_VOLUME);
 }
@@ -99,15 +104,23 @@ void S2D_SetMusicVolume(int volume) {
 /*
  * Fade out the playing music
  */
-void S2D_FadeOutMusic(int ms) {
+void R2D_FadeOutMusic(int ms) {
   Mix_FadeOutMusic(ms);
 }
 
 
+/*
+ * Get the length of the music in seconds
+ */
+int R2D_GetMusicLength(R2D_Music *mus) {
+  return mus->length;
+}
+
+
 /*
  * Free the music
  */
-void S2D_FreeMusic(S2D_Music *mus) {
+void R2D_FreeMusic(R2D_Music *mus) {
   if (!mus) return;
   Mix_FreeMusic(mus->data);
   free(mus);

data/ext/ruby2d/ruby2d.c

@@ -1,10 +1,9 @@
 // Native C extension for Ruby and MRuby
 
-// Simple 2D includes
+// Ruby 2D includes
 #if RUBY2D_IOS_TVOS
-  #include <Simple2D/simple2d.h>
 #else
-  #include <simple2d.h>
+  #include <ruby2d.h>
 #endif
 
 // Ruby includes
@@ -100,11 +99,11 @@
   static mrb_state *mrb;
 #endif
 
-// Ruby 2D window
+// Ruby 2D interpreter window
 static R_VAL ruby2d_window;
 
-// Simple 2D window
-static S2D_Window *window;
+// Ruby 2D native window
+static R2D_Window *window;
 
 
 // Method signatures and structures for Ruby 2D classes
@@ -130,19 +129,19 @@ static S2D_Window *window;
     "music", free_music
   };
 #else
-  static void free_image(S2D_Image *img);
-  static void free_sprite(S2D_Sprite *spr);
-  static void free_text(S2D_Text *txt);
-  static void free_sound(S2D_Sound *snd);
-  static void free_music(S2D_Music *mus);
+  static void free_image(R2D_Image *img);
+  static void free_sprite(R2D_Sprite *spr);
+  static void free_text(R2D_Text *txt);
+  static void free_sound(R2D_Sound *snd);
+  static void free_music(R2D_Music *mus);
 #endif
 
 
 /*
- * Function pointer to free the Simple 2D window
+ * Function pointer to free the Ruby 2D native window
  */
 static void free_window() {
-  S2D_FreeWindow(window);
+  R2D_FreeWindow(window);
 }
 
 
@@ -167,38 +166,45 @@ static R_VAL ruby2d_ext_base_path(R_VAL self) {
 
 
 /*
- * Ruby2D::Triangle#ext_render
+ * Ruby2D::Pixel#self.ext_draw
  */
 #if MRUBY
-static R_VAL ruby2d_triangle_ext_render(mrb_state* mrb, R_VAL self) {
+static R_VAL ruby2d_pixel_ext_draw(mrb_state* mrb, R_VAL self) {
+  mrb_value a;
+  mrb_get_args(mrb, "o", &a);
 #else
-static R_VAL ruby2d_triangle_ext_render(R_VAL self) {
+static R_VAL ruby2d_pixel_ext_draw(R_VAL self, R_VAL a) {
 #endif
-  R_VAL c1 = r_iv_get(self, "@c1");
-  R_VAL c2 = r_iv_get(self, "@c2");
-  R_VAL c3 = r_iv_get(self, "@c3");
-
-  S2D_DrawTriangle(
-    NUM2DBL(r_iv_get(self, "@x1")),
-    NUM2DBL(r_iv_get(self, "@y1")),
-    NUM2DBL(r_iv_get(c1, "@r")),
-    NUM2DBL(r_iv_get(c1, "@g")),
-    NUM2DBL(r_iv_get(c1, "@b")),
-    NUM2DBL(r_iv_get(c1, "@a")),
-
-    NUM2DBL(r_iv_get(self, "@x2")),
-    NUM2DBL(r_iv_get(self, "@y2")),
-    NUM2DBL(r_iv_get(c2, "@r")),
-    NUM2DBL(r_iv_get(c2, "@g")),
-    NUM2DBL(r_iv_get(c2, "@b")),
-    NUM2DBL(r_iv_get(c2, "@a")),
-
-    NUM2DBL(r_iv_get(self, "@x3")),
-    NUM2DBL(r_iv_get(self, "@y3")),
-    NUM2DBL(r_iv_get(c3, "@r")),
-    NUM2DBL(r_iv_get(c3, "@g")),
-    NUM2DBL(r_iv_get(c3, "@b")),
-    NUM2DBL(r_iv_get(c3, "@a"))
+  // `a` is the array representing the pixel
+
+  R2D_DrawQuad(
+    NUM2DBL(r_ary_entry(a,  0)),  // x1
+    NUM2DBL(r_ary_entry(a,  1)),  // y1
+    NUM2DBL(r_ary_entry(a,  8)),  // color
+    NUM2DBL(r_ary_entry(a,  9)),  // color
+    NUM2DBL(r_ary_entry(a, 10)),  // color
+    NUM2DBL(r_ary_entry(a, 11)),  // color
+
+    NUM2DBL(r_ary_entry(a,  2)),  // x2
+    NUM2DBL(r_ary_entry(a,  3)),  // y2
+    NUM2DBL(r_ary_entry(a,  8)),  // color
+    NUM2DBL(r_ary_entry(a,  9)),  // color
+    NUM2DBL(r_ary_entry(a, 10)),  // color
+    NUM2DBL(r_ary_entry(a, 11)),  // color
+
+    NUM2DBL(r_ary_entry(a,  4)),  // x3
+    NUM2DBL(r_ary_entry(a,  5)),  // y3
+    NUM2DBL(r_ary_entry(a,  8)),  // color
+    NUM2DBL(r_ary_entry(a,  9)),  // color
+    NUM2DBL(r_ary_entry(a, 10)),  // color
+    NUM2DBL(r_ary_entry(a, 11)),  // color
+
+    NUM2DBL(r_ary_entry(a,  6)),  // x4
+    NUM2DBL(r_ary_entry(a,  7)),  // y4
+    NUM2DBL(r_ary_entry(a,  8)),  // color
+    NUM2DBL(r_ary_entry(a,  9)),  // color
+    NUM2DBL(r_ary_entry(a, 10)),  // color
+    NUM2DBL(r_ary_entry(a, 11))   // color
   );
 
   return R_NIL;
@@ -206,46 +212,38 @@ static R_VAL ruby2d_triangle_ext_render(R_VAL self) {
 
 
 /*
- * Ruby2D::Quad#ext_render
+ * Ruby2D::Triangle#self.ext_draw
  */
 #if MRUBY
-static R_VAL ruby2d_quad_ext_render(mrb_state* mrb, R_VAL self) {
+static R_VAL ruby2d_triangle_ext_draw(mrb_state* mrb, R_VAL self) {
+  mrb_value a;
+  mrb_get_args(mrb, "o", &a);
 #else
-static R_VAL ruby2d_quad_ext_render(R_VAL self) {
+static R_VAL ruby2d_triangle_ext_draw(R_VAL self, R_VAL a) {
 #endif
-  R_VAL c1 = r_iv_get(self, "@c1");
-  R_VAL c2 = r_iv_get(self, "@c2");
-  R_VAL c3 = r_iv_get(self, "@c3");
-  R_VAL c4 = r_iv_get(self, "@c4");
-
-  S2D_DrawQuad(
-    NUM2DBL(r_iv_get(self, "@x1")),
-    NUM2DBL(r_iv_get(self, "@y1")),
-    NUM2DBL(r_iv_get(c1, "@r")),
-    NUM2DBL(r_iv_get(c1, "@g")),
-    NUM2DBL(r_iv_get(c1, "@b")),
-    NUM2DBL(r_iv_get(c1, "@a")),
-
-    NUM2DBL(r_iv_get(self, "@x2")),
-    NUM2DBL(r_iv_get(self, "@y2")),
-    NUM2DBL(r_iv_get(c2, "@r")),
-    NUM2DBL(r_iv_get(c2, "@g")),
-    NUM2DBL(r_iv_get(c2, "@b")),
-    NUM2DBL(r_iv_get(c2, "@a")),
-
-    NUM2DBL(r_iv_get(self, "@x3")),
-    NUM2DBL(r_iv_get(self, "@y3")),
-    NUM2DBL(r_iv_get(c3, "@r")),
-    NUM2DBL(r_iv_get(c3, "@g")),
-    NUM2DBL(r_iv_get(c3, "@b")),
-    NUM2DBL(r_iv_get(c3, "@a")),
-
-    NUM2DBL(r_iv_get(self, "@x4")),
-    NUM2DBL(r_iv_get(self, "@y4")),
-    NUM2DBL(r_iv_get(c4, "@r")),
-    NUM2DBL(r_iv_get(c4, "@g")),
-    NUM2DBL(r_iv_get(c4, "@b")),
-    NUM2DBL(r_iv_get(c4, "@a"))
+  // `a` is the array representing the triangle
+
+  R2D_DrawTriangle(
+    NUM2DBL(r_ary_entry(a,  0)),  // x1
+    NUM2DBL(r_ary_entry(a,  1)),  // y1
+    NUM2DBL(r_ary_entry(a,  2)),  // c1 red
+    NUM2DBL(r_ary_entry(a,  3)),  // c1 green
+    NUM2DBL(r_ary_entry(a,  4)),  // c1 blue
+    NUM2DBL(r_ary_entry(a,  5)),  // c1 alpha
+
+    NUM2DBL(r_ary_entry(a,  6)),  // x2
+    NUM2DBL(r_ary_entry(a,  7)),  // y2
+    NUM2DBL(r_ary_entry(a,  8)),  // c2 red
+    NUM2DBL(r_ary_entry(a,  9)),  // c2 green
+    NUM2DBL(r_ary_entry(a, 10)),  // c2 blue
+    NUM2DBL(r_ary_entry(a, 11)),  // c2 alpha
+
+    NUM2DBL(r_ary_entry(a, 12)),  // x3
+    NUM2DBL(r_ary_entry(a, 13)),  // y3
+    NUM2DBL(r_ary_entry(a, 14)),  // c3 red
+    NUM2DBL(r_ary_entry(a, 15)),  // c3 green
+    NUM2DBL(r_ary_entry(a, 16)),  // c3 blue
+    NUM2DBL(r_ary_entry(a, 17))  // c3 alpha
   );
 
   return R_NIL;
@@ -253,44 +251,45 @@ static R_VAL ruby2d_quad_ext_render(R_VAL self) {
 
 
 /*
- * Ruby2D::Line#ext_render
+ * Ruby2D::Quad#self.ext_draw
  */
 #if MRUBY
-static R_VAL ruby2d_line_ext_render(mrb_state* mrb, R_VAL self) {
+static R_VAL ruby2d_quad_ext_draw(mrb_state* mrb, R_VAL self) {
+  mrb_value a;
+  mrb_get_args(mrb, "o", &a);
 #else
-static R_VAL ruby2d_line_ext_render(R_VAL self) {
+static R_VAL ruby2d_quad_ext_draw(R_VAL self, R_VAL a) {
 #endif
-  R_VAL c1 = r_iv_get(self, "@c1");
-  R_VAL c2 = r_iv_get(self, "@c2");
-  R_VAL c3 = r_iv_get(self, "@c3");
-  R_VAL c4 = r_iv_get(self, "@c4");
-
-  S2D_DrawLine(
-    NUM2DBL(r_iv_get(self, "@x1")),
-    NUM2DBL(r_iv_get(self, "@y1")),
-    NUM2DBL(r_iv_get(self, "@x2")),
-    NUM2DBL(r_iv_get(self, "@y2")),
-    NUM2DBL(r_iv_get(self, "@width")),
-
-    NUM2DBL(r_iv_get(c1, "@r")),
-    NUM2DBL(r_iv_get(c1, "@g")),
-    NUM2DBL(r_iv_get(c1, "@b")),
-    NUM2DBL(r_iv_get(c1, "@a")),
-
-    NUM2DBL(r_iv_get(c2, "@r")),
-    NUM2DBL(r_iv_get(c2, "@g")),
-    NUM2DBL(r_iv_get(c2, "@b")),
-    NUM2DBL(r_iv_get(c2, "@a")),
-
-    NUM2DBL(r_iv_get(c3, "@r")),
-    NUM2DBL(r_iv_get(c3, "@g")),
-    NUM2DBL(r_iv_get(c3, "@b")),
-    NUM2DBL(r_iv_get(c3, "@a")),
-
-    NUM2DBL(r_iv_get(c4, "@r")),
-    NUM2DBL(r_iv_get(c4, "@g")),
-    NUM2DBL(r_iv_get(c4, "@b")),
-    NUM2DBL(r_iv_get(c4, "@a"))
+  // `a` is the array representing the quad
+
+  R2D_DrawQuad(
+    NUM2DBL(r_ary_entry(a,  0)),  // x1
+    NUM2DBL(r_ary_entry(a,  1)),  // y1
+    NUM2DBL(r_ary_entry(a,  2)),  // c1 red
+    NUM2DBL(r_ary_entry(a,  3)),  // c1 green
+    NUM2DBL(r_ary_entry(a,  4)),  // c1 blue
+    NUM2DBL(r_ary_entry(a,  5)),  // c1 alpha
+
+    NUM2DBL(r_ary_entry(a,  6)),  // x2
+    NUM2DBL(r_ary_entry(a,  7)),  // y2
+    NUM2DBL(r_ary_entry(a,  8)),  // c2 red
+    NUM2DBL(r_ary_entry(a,  9)),  // c2 green
+    NUM2DBL(r_ary_entry(a, 10)),  // c2 blue
+    NUM2DBL(r_ary_entry(a, 11)),  // c2 alpha
+
+    NUM2DBL(r_ary_entry(a, 12)),  // x3
+    NUM2DBL(r_ary_entry(a, 13)),  // y3
+    NUM2DBL(r_ary_entry(a, 14)),  // c3 red
+    NUM2DBL(r_ary_entry(a, 15)),  // c3 green
+    NUM2DBL(r_ary_entry(a, 16)),  // c3 blue
+    NUM2DBL(r_ary_entry(a, 17)),  // c3 alpha
+
+    NUM2DBL(r_ary_entry(a, 18)),  // x4
+    NUM2DBL(r_ary_entry(a, 19)),  // y4
+    NUM2DBL(r_ary_entry(a, 20)),  // c4 red
+    NUM2DBL(r_ary_entry(a, 21)),  // c4 green
+    NUM2DBL(r_ary_entry(a, 22)),  // c4 blue
+    NUM2DBL(r_ary_entry(a, 23))   // c4 alpha
   );
 
   return R_NIL;
@@ -298,24 +297,70 @@ static R_VAL ruby2d_line_ext_render(R_VAL self) {
 
 
 /*
- * Ruby2D::Circle#ext_render
+ * Ruby2D::Line#self.ext_draw
  */
 #if MRUBY
-static R_VAL ruby2d_circle_ext_render(mrb_state* mrb, R_VAL self) {
+static R_VAL ruby2d_line_ext_draw(mrb_state* mrb, R_VAL self) {
+  mrb_value a;
+  mrb_get_args(mrb, "o", &a);
 #else
-static R_VAL ruby2d_circle_ext_render(R_VAL self) {
+static R_VAL ruby2d_line_ext_draw(R_VAL self, R_VAL a) {
 #endif
-  R_VAL c = r_iv_get(self, "@color");
-
-  S2D_DrawCircle(
-    NUM2DBL(r_iv_get(self, "@x")),
-    NUM2DBL(r_iv_get(self, "@y")),
-    NUM2DBL(r_iv_get(self, "@radius")),
-    NUM2DBL(r_iv_get(self, "@sectors")),
-    NUM2DBL(r_iv_get(c, "@r")),
-    NUM2DBL(r_iv_get(c, "@g")),
-    NUM2DBL(r_iv_get(c, "@b")),
-    NUM2DBL(r_iv_get(c, "@a"))
+  // `a` is the array representing the line
+
+  R2D_DrawLine(
+    NUM2DBL(r_ary_entry(a,  0)),  // x1
+    NUM2DBL(r_ary_entry(a,  1)),  // y1
+    NUM2DBL(r_ary_entry(a,  2)),  // x2
+    NUM2DBL(r_ary_entry(a,  3)),  // y2
+    NUM2DBL(r_ary_entry(a,  4)),  // width
+
+    NUM2DBL(r_ary_entry(a,  5)),  // c1 red
+    NUM2DBL(r_ary_entry(a,  6)),  // c1 green
+    NUM2DBL(r_ary_entry(a,  7)),  // c1 blue
+    NUM2DBL(r_ary_entry(a,  8)),  // c1 alpha
+
+    NUM2DBL(r_ary_entry(a,  9)),  // c2 red
+    NUM2DBL(r_ary_entry(a, 10)),  // c2 green
+    NUM2DBL(r_ary_entry(a, 11)),  // c2 blue
+    NUM2DBL(r_ary_entry(a, 12)),  // c2 alpha
+
+    NUM2DBL(r_ary_entry(a, 13)),  // c3 red
+    NUM2DBL(r_ary_entry(a, 14)),  // c3 green
+    NUM2DBL(r_ary_entry(a, 15)),  // c3 blue
+    NUM2DBL(r_ary_entry(a, 16)),  // c3 alpha
+
+    NUM2DBL(r_ary_entry(a, 17)),  // c4 red
+    NUM2DBL(r_ary_entry(a, 18)),  // c4 green
+    NUM2DBL(r_ary_entry(a, 19)),  // c4 blue
+    NUM2DBL(r_ary_entry(a, 20))   // c4 alpha
+  );
+
+  return R_NIL;
+}
+
+
+/*
+ * Ruby2D::Circle#self.ext_draw
+ */
+#if MRUBY
+static R_VAL ruby2d_circle_ext_draw(mrb_state* mrb, R_VAL self) {
+  mrb_value a;
+  mrb_get_args(mrb, "o", &a);
+#else
+static R_VAL ruby2d_circle_ext_draw(R_VAL self, R_VAL a) {
+#endif
+  // `a` is the array representing the circle
+
+  R2D_DrawCircle(
+    NUM2DBL(r_ary_entry(a, 0)),  // x
+    NUM2DBL(r_ary_entry(a, 1)),  // y
+    NUM2DBL(r_ary_entry(a, 2)),  // radius
+    NUM2DBL(r_ary_entry(a, 3)),  // sectors
+    NUM2DBL(r_ary_entry(a, 4)),  // red
+    NUM2DBL(r_ary_entry(a, 5)),  // green
+    NUM2DBL(r_ary_entry(a, 6)),  // blue
+    NUM2DBL(r_ary_entry(a, 7))   // alpha
   );
 
   return R_NIL;
@@ -333,7 +378,7 @@ static R_VAL ruby2d_image_ext_init(mrb_state* mrb, R_VAL self) {
 #else
 static R_VAL ruby2d_image_ext_init(R_VAL self, R_VAL path) {
 #endif
-  S2D_Image *img = S2D_CreateImage(RSTRING_PTR(path));
+  R2D_Image *img = R2D_CreateImage(RSTRING_PTR(path));
   if (!img) return R_FALSE;
 
   // Get width and height from Ruby class. If set, use it, else choose the
@@ -349,34 +394,36 @@ static R_VAL ruby2d_image_ext_init(R_VAL self, R_VAL path) {
 
 
 /*
- * Ruby2D::Image#ext_render
+ * Ruby2D::Image#self.ext_draw
  */
 #if MRUBY
-static R_VAL ruby2d_image_ext_render(mrb_state* mrb, R_VAL self) {
+static R_VAL ruby2d_image_ext_draw(mrb_state* mrb, R_VAL self) {
+  mrb_value a;
+  mrb_get_args(mrb, "o", &a);
 #else
-static R_VAL ruby2d_image_ext_render(R_VAL self) {
+static R_VAL ruby2d_image_ext_draw(R_VAL self, R_VAL a) {
 #endif
-  S2D_Image *img;
-  r_data_get_struct(self, "@data", &image_data_type, S2D_Image, img);
+  // `a` is the array representing the image
 
-  img->x = NUM2DBL(r_iv_get(self, "@x"));
-  img->y = NUM2DBL(r_iv_get(self, "@y"));
+  R2D_Image *img;
+  r_data_get_struct(r_ary_entry(a, 0), "@data", &image_data_type, R2D_Image, img);
 
-  R_VAL w = r_iv_get(self, "@width");
-  R_VAL h = r_iv_get(self, "@height");
+  img->x = NUM2DBL(r_ary_entry(a, 1));
+  img->y = NUM2DBL(r_ary_entry(a, 2));
+
+  R_VAL w = r_ary_entry(a, 3);
+  R_VAL h = r_ary_entry(a, 4);
   if (r_test(w)) img->width  = NUM2INT(w);
   if (r_test(h)) img->height = NUM2INT(h);
 
-  S2D_RotateImage(img, NUM2DBL(r_iv_get(self, "@rotate")), S2D_CENTER);
+  R2D_RotateImage(img, NUM2DBL(r_ary_entry(a, 5)), R2D_CENTER);
 
-  R_VAL c = r_iv_get(self, "@color");
-  img->color.r = NUM2DBL(r_iv_get(c, "@r"));
-  img->color.g = NUM2DBL(r_iv_get(c, "@g"));
-  img->color.b = NUM2DBL(r_iv_get(c, "@b"));
-  img->color.a = NUM2DBL(r_iv_get(c, "@a"));
-
-  S2D_DrawImage(img);
+  img->color.r = NUM2DBL(r_ary_entry(a, 6));
+  img->color.g = NUM2DBL(r_ary_entry(a, 7));
+  img->color.b = NUM2DBL(r_ary_entry(a, 8));
+  img->color.a = NUM2DBL(r_ary_entry(a, 9));
 
+  R2D_DrawImage(img);
   return R_NIL;
 }
 
@@ -386,11 +433,11 @@ static R_VAL ruby2d_image_ext_render(R_VAL self) {
  */
 #if MRUBY
 static void free_image(mrb_state *mrb, void *p_) {
-  S2D_Image *img = (S2D_Image *)p_;
+  R2D_Image *img = (R2D_Image *)p_;
 #else
-static void free_image(S2D_Image *img) {
+static void free_image(R2D_Image *img) {
 #endif
-  S2D_FreeImage(img);
+  R2D_FreeImage(img);
 }
 
 
@@ -405,7 +452,7 @@ static R_VAL ruby2d_sprite_ext_init(mrb_state* mrb, R_VAL self) {
 #else
 static R_VAL ruby2d_sprite_ext_init(R_VAL self, R_VAL path) {
 #endif
-  S2D_Sprite *spr = S2D_CreateSprite(RSTRING_PTR(path));
+  R2D_Sprite *spr = R2D_CreateSprite(RSTRING_PTR(path));
   if (!spr) return R_FALSE;
 
   r_iv_set(self, "@img_width" , INT2NUM(spr->width));
@@ -417,45 +464,45 @@ static R_VAL ruby2d_sprite_ext_init(R_VAL self, R_VAL path) {
 
 
 /*
- * Ruby2D::Sprite#ext_render
+ * Ruby2D::Sprite#ext_draw
  */
 #if MRUBY
-static R_VAL ruby2d_sprite_ext_render(mrb_state* mrb, R_VAL self) {
+static R_VAL ruby2d_sprite_ext_draw(mrb_state* mrb, R_VAL self) {
+  mrb_value a;
+  mrb_get_args(mrb, "o", &a);
 #else
-static R_VAL ruby2d_sprite_ext_render(R_VAL self) {
+static R_VAL ruby2d_sprite_ext_draw(R_VAL self, R_VAL a) {
 #endif
-  r_funcall(self, "update", 0);
+  // `a` is the array representing the sprite
 
-  S2D_Sprite *spr;
-  r_data_get_struct(self, "@data", &sprite_data_type, S2D_Sprite, spr);
+  R2D_Sprite *spr;
+  r_data_get_struct(r_ary_entry(a, 0), "@data", &sprite_data_type, R2D_Sprite, spr);
 
-  spr->x = NUM2DBL(r_iv_get(self, "@flip_x"));
-  spr->y = NUM2DBL(r_iv_get(self, "@flip_y"));
+  spr->x = NUM2DBL(r_ary_entry(a, 1));
+  spr->y = NUM2DBL(r_ary_entry(a, 2));
 
-  R_VAL w = r_iv_get(self, "@flip_width");
+  R_VAL w = r_ary_entry(a, 3);
   if (r_test(w)) spr->width = NUM2DBL(w);
 
-  R_VAL h = r_iv_get(self, "@flip_height");
+  R_VAL h = r_ary_entry(a, 4);
   if (r_test(h)) spr->height = NUM2DBL(h);
 
-  S2D_RotateSprite(spr, NUM2DBL(r_iv_get(self, "@rotate")), S2D_CENTER);
-
-  R_VAL c = r_iv_get(self, "@color");
-  spr->color.r = NUM2DBL(r_iv_get(c, "@r"));
-  spr->color.g = NUM2DBL(r_iv_get(c, "@g"));
-  spr->color.b = NUM2DBL(r_iv_get(c, "@b"));
-  spr->color.a = NUM2DBL(r_iv_get(c, "@a"));
+  R2D_RotateSprite(spr, NUM2DBL(r_ary_entry(a, 5)), R2D_CENTER);
 
-  S2D_ClipSprite(
+  R2D_ClipSprite(
     spr,
-    NUM2INT(r_iv_get(self, "@clip_x")),
-    NUM2INT(r_iv_get(self, "@clip_y")),
-    NUM2INT(r_iv_get(self, "@clip_width")),
-    NUM2INT(r_iv_get(self, "@clip_height"))
+    NUM2INT(r_ary_entry(a, 6)),
+    NUM2INT(r_ary_entry(a, 7)),
+    NUM2INT(r_ary_entry(a, 8)),
+    NUM2INT(r_ary_entry(a, 9))
   );
 
-  S2D_DrawSprite(spr);
+  spr->color.r = NUM2DBL(r_ary_entry(a, 10));
+  spr->color.g = NUM2DBL(r_ary_entry(a, 11));
+  spr->color.b = NUM2DBL(r_ary_entry(a, 12));
+  spr->color.a = NUM2DBL(r_ary_entry(a, 13));
 
+  R2D_DrawSprite(spr);
   return R_NIL;
 }
 
@@ -465,11 +512,55 @@ static R_VAL ruby2d_sprite_ext_render(R_VAL self) {
  */
 #if MRUBY
 static void free_sprite(mrb_state *mrb, void *p_) {
-  S2D_Sprite *spr = (S2D_Sprite *)p_;
+  R2D_Sprite *spr = (R2D_Sprite *)p_;
 #else
-static void free_sprite(S2D_Sprite *spr) {
+static void free_sprite(R2D_Sprite *spr) {
 #endif
-  S2D_FreeSprite(spr);
+  R2D_FreeSprite(spr);
+}
+
+
+/*
+ * Ruby2D::Tileset#ext_init
+ * Initialize tileset data
+ */
+static R_VAL ruby2d_tileset_ext_init(R_VAL self, R_VAL path) {
+  R2D_Image *img = R2D_CreateImage(RSTRING_PTR(path));
+  if (!img) return R_FALSE;
+
+  // Get width and height from Ruby class. If set, use it, else choose the
+  // native dimensions of the image.
+  R_VAL w = r_iv_get(self, "@width");
+  R_VAL h = r_iv_get(self, "@height");
+  r_iv_set(self, "@width" , r_test(w) ? w : INT2NUM(img->width));
+  r_iv_set(self, "@height", r_test(h) ? h : INT2NUM(img->height));
+  r_iv_set(self, "@data", r_data_wrap_struct(image, img));
+
+  return R_TRUE;
+}
+
+
+/*
+ * Ruby2D::Tileset#ext_draw
+ * Draws a single tile, will be called once per individual tile to draw
+ */
+static R_VAL ruby2d_tileset_ext_draw(R_VAL self, R_VAL a) {
+  // `a` is the array representing the tileset
+
+  R2D_Image *img;
+  r_data_get_struct(r_ary_entry(a, 0), "@data", &image_data_type, R2D_Image, img);
+
+  int tw = NUM2INT(r_ary_entry(a, 1));
+  int th = NUM2INT(r_ary_entry(a, 2));
+  int padding = NUM2INT(r_ary_entry(a, 3));
+  int spacing = NUM2INT(r_ary_entry(a, 4));
+  int tx = NUM2INT(r_ary_entry(a, 5));
+  int ty = NUM2INT(r_ary_entry(a, 6));
+  int x = NUM2INT(r_ary_entry(a, 7));
+  int y = NUM2INT(r_ary_entry(a, 8));
+
+  R2D_DrawTile(img, tw, th, padding, spacing, tx, ty, x, y);
+  return R_NIL;
 }
 
 
@@ -488,7 +579,7 @@ static R_VAL ruby2d_text_ext_init(R_VAL self) {
     mrb_str_resize(mrb, s, RSTRING_LEN(s));
   #endif
 
-  S2D_Text *txt = S2D_CreateText(
+  R2D_Text *txt = R2D_CreateText(
     RSTRING_PTR(r_iv_get(self, "@font")),
     RSTRING_PTR(r_iv_get(self, "@text")),
     NUM2DBL(r_iv_get(self, "@size"))
@@ -513,10 +604,10 @@ static R_VAL ruby2d_text_ext_set(mrb_state* mrb, R_VAL self) {
 #else
 static R_VAL ruby2d_text_ext_set(R_VAL self, R_VAL text) {
 #endif
-  S2D_Text *txt;
-  r_data_get_struct(self, "@data", &text_data_type, S2D_Text, txt);
+  R2D_Text *txt;
+  r_data_get_struct(self, "@data", &text_data_type, R2D_Text, txt);
 
-  S2D_SetText(txt, RSTRING_PTR(text));
+  R2D_SetText(txt, RSTRING_PTR(text));
 
   r_iv_set(self, "@width", INT2NUM(txt->width));
   r_iv_set(self, "@height", INT2NUM(txt->height));
@@ -526,29 +617,31 @@ static R_VAL ruby2d_text_ext_set(R_VAL self, R_VAL text) {
 
 
 /*
- * Ruby2D::Text#ext_render
+ * Ruby2D::Text#self.ext_draw
  */
 #if MRUBY
-static R_VAL ruby2d_text_ext_render(mrb_state* mrb, R_VAL self) {
+static R_VAL ruby2d_text_ext_draw(mrb_state* mrb, R_VAL self) {
+  mrb_value a;
+  mrb_get_args(mrb, "o", &a);
 #else
-static R_VAL ruby2d_text_ext_render(R_VAL self) {
+static R_VAL ruby2d_text_ext_draw(R_VAL self, R_VAL a) {
 #endif
-  S2D_Text *txt;
-  r_data_get_struct(self, "@data", &text_data_type, S2D_Text, txt);
+  // `a` is the array representing the text
 
-  txt->x = NUM2DBL(r_iv_get(self, "@x"));
-  txt->y = NUM2DBL(r_iv_get(self, "@y"));
+  R2D_Text *txt;
+  r_data_get_struct(r_ary_entry(a, 0), "@data", &text_data_type, R2D_Text, txt);
 
-  S2D_RotateText(txt, NUM2DBL(r_iv_get(self, "@rotate")), S2D_CENTER);
+  txt->x = NUM2DBL(r_ary_entry(a, 1));
+  txt->y = NUM2DBL(r_ary_entry(a, 2));
 
-  R_VAL c = r_iv_get(self, "@color");
-  txt->color.r = NUM2DBL(r_iv_get(c, "@r"));
-  txt->color.g = NUM2DBL(r_iv_get(c, "@g"));
-  txt->color.b = NUM2DBL(r_iv_get(c, "@b"));
-  txt->color.a = NUM2DBL(r_iv_get(c, "@a"));
+  R2D_RotateText(txt, NUM2DBL(r_ary_entry(a, 3)), R2D_CENTER);
 
-  S2D_DrawText(txt);
+  txt->color.r = NUM2DBL(r_ary_entry(a, 4));
+  txt->color.g = NUM2DBL(r_ary_entry(a, 5));
+  txt->color.b = NUM2DBL(r_ary_entry(a, 6));
+  txt->color.a = NUM2DBL(r_ary_entry(a, 7));
 
+  R2D_DrawText(txt);
   return R_NIL;
 }
 
@@ -558,11 +651,11 @@ static R_VAL ruby2d_text_ext_render(R_VAL self) {
  */
 #if MRUBY
 static void free_text(mrb_state *mrb, void *p_) {
-  S2D_Text *txt = (S2D_Text *)p_;
+  R2D_Text *txt = (R2D_Text *)p_;
 #else
-static void free_text(S2D_Text *txt) {
+static void free_text(R2D_Text *txt) {
 #endif
-  S2D_FreeText(txt);
+  R2D_FreeText(txt);
 }
 
 
@@ -577,7 +670,7 @@ static R_VAL ruby2d_sound_ext_init(mrb_state* mrb, R_VAL self) {
 #else
 static R_VAL ruby2d_sound_ext_init(R_VAL self, R_VAL path) {
 #endif
-  S2D_Sound *snd = S2D_CreateSound(RSTRING_PTR(path));
+  R2D_Sound *snd = R2D_CreateSound(RSTRING_PTR(path));
   if (!snd) return R_FALSE;
   r_iv_set(self, "@data", r_data_wrap_struct(sound, snd));
   return R_TRUE;
@@ -592,23 +685,33 @@ static R_VAL ruby2d_sound_ext_play(mrb_state* mrb, R_VAL self) {
 #else
 static R_VAL ruby2d_sound_ext_play(R_VAL self) {
 #endif
-  S2D_Sound *snd;
-  r_data_get_struct(self, "@data", &sound_data_type, S2D_Sound, snd);
-  S2D_PlaySound(snd);
+  R2D_Sound *snd;
+  r_data_get_struct(self, "@data", &sound_data_type, R2D_Sound, snd);
+  R2D_PlaySound(snd);
   return R_NIL;
 }
 
 
+/*
+ * Ruby2D::Sound#ext_length
+ */
+static R_VAL ruby2d_sound_ext_length(R_VAL self) {
+  R2D_Sound *snd;
+  r_data_get_struct(self, "@data", &sound_data_type, R2D_Sound, snd);
+  return INT2NUM(R2D_GetSoundLength(snd));
+}
+
+
 /*
  * Free sound structure attached to Ruby 2D `Sound` class
  */
 #if MRUBY
 static void free_sound(mrb_state *mrb, void *p_) {
-  S2D_Sound *snd = (S2D_Sound *)p_;
+  R2D_Sound *snd = (R2D_Sound *)p_;
 #else
-static void free_sound(S2D_Sound *snd) {
+static void free_sound(R2D_Sound *snd) {
 #endif
-  S2D_FreeSound(snd);
+  R2D_FreeSound(snd);
 }
 
 
@@ -623,7 +726,7 @@ static R_VAL ruby2d_music_ext_init(mrb_state* mrb, R_VAL self) {
 #else
 static R_VAL ruby2d_music_ext_init(R_VAL self, R_VAL path) {
 #endif
-  S2D_Music *mus = S2D_CreateMusic(RSTRING_PTR(path));
+  R2D_Music *mus = R2D_CreateMusic(RSTRING_PTR(path));
   if (!mus) return R_FALSE;
   r_iv_set(self, "@data", r_data_wrap_struct(music, mus));
   return R_TRUE;
@@ -638,9 +741,9 @@ static R_VAL ruby2d_music_ext_play(mrb_state* mrb, R_VAL self) {
 #else
 static R_VAL ruby2d_music_ext_play(R_VAL self) {
 #endif
-  S2D_Music *mus;
-  r_data_get_struct(self, "@data", &music_data_type, S2D_Music, mus);
-  S2D_PlayMusic(mus, r_test(r_iv_get(self, "@loop")));
+  R2D_Music *mus;
+  r_data_get_struct(self, "@data", &music_data_type, R2D_Music, mus);
+  R2D_PlayMusic(mus, r_test(r_iv_get(self, "@loop")));
   return R_NIL;
 }
 
@@ -653,7 +756,7 @@ static R_VAL ruby2d_music_ext_pause(mrb_state* mrb, R_VAL self) {
 #else
 static R_VAL ruby2d_music_ext_pause(R_VAL self) {
 #endif
-  S2D_PauseMusic();
+  R2D_PauseMusic();
   return R_NIL;
 }
 
@@ -666,7 +769,7 @@ static R_VAL ruby2d_music_ext_resume(mrb_state* mrb, R_VAL self) {
 #else
 static R_VAL ruby2d_music_ext_resume(R_VAL self) {
 #endif
-  S2D_ResumeMusic();
+  R2D_ResumeMusic();
   return R_NIL;
 }
 
@@ -679,7 +782,7 @@ static R_VAL ruby2d_music_ext_stop(mrb_state* mrb, R_VAL self) {
 #else
 static R_VAL ruby2d_music_ext_stop(R_VAL self) {
 #endif
-  S2D_StopMusic();
+  R2D_StopMusic();
   return R_NIL;
 }
 
@@ -692,7 +795,7 @@ static R_VAL ruby2d_music_ext_get_volume(mrb_state* mrb, R_VAL self) {
 #else
 static R_VAL ruby2d_music_ext_get_volume(R_VAL self) {
 #endif
-  return INT2NUM(S2D_GetMusicVolume());
+  return INT2NUM(R2D_GetMusicVolume());
 }
 
 
@@ -706,7 +809,7 @@ static R_VAL ruby2d_music_ext_set_volume(mrb_state* mrb, R_VAL self) {
 #else
 static R_VAL ruby2d_music_ext_set_volume(R_VAL self, R_VAL volume) {
 #endif
-  S2D_SetMusicVolume(NUM2INT(volume));
+  R2D_SetMusicVolume(NUM2INT(volume));
   return R_NIL;
 }
 
@@ -721,39 +824,49 @@ static R_VAL ruby2d_music_ext_fadeout(mrb_state* mrb, R_VAL self) {
 #else
 static R_VAL ruby2d_music_ext_fadeout(R_VAL self, R_VAL ms) {
 #endif
-  S2D_FadeOutMusic(NUM2INT(ms));
+  R2D_FadeOutMusic(NUM2INT(ms));
   return R_NIL;
 }
 
 
+/*
+ * Ruby2D::Music#ext_length
+ */
+static R_VAL ruby2d_music_ext_length(R_VAL self) {
+  R2D_Music *ms;
+  r_data_get_struct(self, "@data", &music_data_type, R2D_Music, ms);
+  return INT2NUM(R2D_GetMusicLength(ms));
+}
+
+
 /*
  * Free music structure attached to Ruby 2D `Music` class
  */
 #if MRUBY
 static void free_music(mrb_state *mrb, void *p_) {
-  S2D_Music *mus = (S2D_Music *)p_;
+  R2D_Music *mus = (R2D_Music *)p_;
 #else
-static void free_music(S2D_Music *mus) {
+static void free_music(R2D_Music *mus) {
 #endif
-  S2D_FreeMusic(mus);
+  R2D_FreeMusic(mus);
 }
 
 
 /*
- * Simple 2D `on_key` input callback function
+ * Ruby 2D native `on_key` input callback function
  */
-static void on_key(S2D_Event e) {
+static void on_key(R2D_Event e) {
 
   R_VAL type;
 
   switch (e.type) {
-    case S2D_KEY_DOWN:
+    case R2D_KEY_DOWN:
       type = r_char_to_sym("down");
       break;
-    case S2D_KEY_HELD:
+    case R2D_KEY_HELD:
       type = r_char_to_sym("held");
       break;
-    case S2D_KEY_UP:
+    case R2D_KEY_UP:
       type = r_char_to_sym("up");
       break;
   }
@@ -763,48 +876,48 @@ static void on_key(S2D_Event e) {
 
 
 /*
- * Simple 2D `on_mouse` input callback function
+ * Ruby 2D native `on_mouse` input callback function
  */
-void on_mouse(S2D_Event e) {
+void on_mouse(R2D_Event e) {
 
   R_VAL type = R_NIL; R_VAL button = R_NIL; R_VAL direction = R_NIL;
 
   switch (e.type) {
-    case S2D_MOUSE_DOWN:
+    case R2D_MOUSE_DOWN:
       // type, button, x, y
       type = r_char_to_sym("down");
       break;
-    case S2D_MOUSE_UP:
+    case R2D_MOUSE_UP:
       // type, button, x, y
       type = r_char_to_sym("up");
       break;
-    case S2D_MOUSE_SCROLL:
+    case R2D_MOUSE_SCROLL:
       // type, direction, delta_x, delta_y
       type = r_char_to_sym("scroll");
-      direction = e.direction == S2D_MOUSE_SCROLL_NORMAL ?
+      direction = e.direction == R2D_MOUSE_SCROLL_NORMAL ?
         r_char_to_sym("normal") : r_char_to_sym("inverted");
       break;
-    case S2D_MOUSE_MOVE:
+    case R2D_MOUSE_MOVE:
       // type, x, y, delta_x, delta_y
       type = r_char_to_sym("move");
       break;
   }
 
-  if (e.type == S2D_MOUSE_DOWN || e.type == S2D_MOUSE_UP) {
+  if (e.type == R2D_MOUSE_DOWN || e.type == R2D_MOUSE_UP) {
     switch (e.button) {
-      case S2D_MOUSE_LEFT:
+      case R2D_MOUSE_LEFT:
         button = r_char_to_sym("left");
         break;
-      case S2D_MOUSE_MIDDLE:
+      case R2D_MOUSE_MIDDLE:
         button = r_char_to_sym("middle");
         break;
-      case S2D_MOUSE_RIGHT:
+      case R2D_MOUSE_RIGHT:
         button = r_char_to_sym("right");
         break;
-      case S2D_MOUSE_X1:
+      case R2D_MOUSE_X1:
         button = r_char_to_sym("x1");
         break;
-      case S2D_MOUSE_X2:
+      case R2D_MOUSE_X2:
         button = r_char_to_sym("x2");
         break;
     }
@@ -818,88 +931,88 @@ void on_mouse(S2D_Event e) {
 
 
 /*
- * Simple 2D `on_controller` input callback function
+ * Ruby 2D native `on_controller` input callback function
  */
-static void on_controller(S2D_Event e) {
+static void on_controller(R2D_Event e) {
 
   R_VAL type = R_NIL; R_VAL axis = R_NIL; R_VAL button = R_NIL;
 
   switch (e.type) {
-    case S2D_AXIS:
+    case R2D_AXIS:
       type = r_char_to_sym("axis");
       switch (e.axis) {
-        case S2D_AXIS_LEFTX:
+        case R2D_AXIS_LEFTX:
           axis = r_char_to_sym("left_x");
           break;
-        case S2D_AXIS_LEFTY:
+        case R2D_AXIS_LEFTY:
           axis = r_char_to_sym("left_y");
           break;
-        case S2D_AXIS_RIGHTX:
+        case R2D_AXIS_RIGHTX:
           axis = r_char_to_sym("right_x");
           break;
-        case S2D_AXIS_RIGHTY:
+        case R2D_AXIS_RIGHTY:
           axis = r_char_to_sym("right_y");
           break;
-        case S2D_AXIS_TRIGGERLEFT:
+        case R2D_AXIS_TRIGGERLEFT:
           axis = r_char_to_sym("trigger_left");
           break;
-        case S2D_AXIS_TRIGGERRIGHT:
+        case R2D_AXIS_TRIGGERRIGHT:
           axis = r_char_to_sym("trigger_right");
           break;
-        case S2D_AXIS_INVALID:
+        case R2D_AXIS_INVALID:
           axis = r_char_to_sym("invalid");
           break;
       }
       break;
-    case S2D_BUTTON_DOWN: case S2D_BUTTON_UP:
-      type = e.type == S2D_BUTTON_DOWN ? r_char_to_sym("button_down") : r_char_to_sym("button_up");
+    case R2D_BUTTON_DOWN: case R2D_BUTTON_UP:
+      type = e.type == R2D_BUTTON_DOWN ? r_char_to_sym("button_down") : r_char_to_sym("button_up");
       switch (e.button) {
-        case S2D_BUTTON_A:
+        case R2D_BUTTON_A:
           button = r_char_to_sym("a");
           break;
-        case S2D_BUTTON_B:
+        case R2D_BUTTON_B:
           button = r_char_to_sym("b");
           break;
-        case S2D_BUTTON_X:
+        case R2D_BUTTON_X:
           button = r_char_to_sym("x");
           break;
-        case S2D_BUTTON_Y:
+        case R2D_BUTTON_Y:
           button = r_char_to_sym("y");
           break;
-        case S2D_BUTTON_BACK:
+        case R2D_BUTTON_BACK:
           button = r_char_to_sym("back");
           break;
-        case S2D_BUTTON_GUIDE:
+        case R2D_BUTTON_GUIDE:
           button = r_char_to_sym("guide");
           break;
-        case S2D_BUTTON_START:
+        case R2D_BUTTON_START:
           button = r_char_to_sym("start");
           break;
-        case S2D_BUTTON_LEFTSTICK:
+        case R2D_BUTTON_LEFTSTICK:
           button = r_char_to_sym("left_stick");
           break;
-        case S2D_BUTTON_RIGHTSTICK:
+        case R2D_BUTTON_RIGHTSTICK:
           button = r_char_to_sym("right_stick");
           break;
-        case S2D_BUTTON_LEFTSHOULDER:
+        case R2D_BUTTON_LEFTSHOULDER:
           button = r_char_to_sym("left_shoulder");
           break;
-        case S2D_BUTTON_RIGHTSHOULDER:
+        case R2D_BUTTON_RIGHTSHOULDER:
           button = r_char_to_sym("right_shoulder");
           break;
-        case S2D_BUTTON_DPAD_UP:
+        case R2D_BUTTON_DPAD_UP:
           button = r_char_to_sym("up");
           break;
-        case S2D_BUTTON_DPAD_DOWN:
+        case R2D_BUTTON_DPAD_DOWN:
           button = r_char_to_sym("down");
           break;
-        case S2D_BUTTON_DPAD_LEFT:
+        case R2D_BUTTON_DPAD_LEFT:
           button = r_char_to_sym("left");
           break;
-        case S2D_BUTTON_DPAD_RIGHT:
+        case R2D_BUTTON_DPAD_RIGHT:
           button = r_char_to_sym("right");
           break;
-        case S2D_BUTTON_INVALID:
+        case R2D_BUTTON_INVALID:
           button = r_char_to_sym("invalid");
           break;
       }
@@ -914,7 +1027,7 @@ static void on_controller(S2D_Event e) {
 
 
 /*
- * Simple 2D `update` callback function
+ * Ruby 2D native `update` callback function
  */
 static void update() {
 
@@ -934,7 +1047,7 @@ static void update() {
 
 
 /*
- * Simple 2D `render` callback function
+ * Ruby 2D native `render` callback function
  */
 static void render() {
 
@@ -952,8 +1065,11 @@ static void render() {
   // Switch on each object type
   for (int i = 0; i < num_objects; ++i) {
     R_VAL el = r_ary_entry(objects, i);
-    r_funcall(el, "ext_render", 0);
+    r_funcall(el, "render", 0);  // call the object's `render` function
   }
+
+  // Call render proc, `window.render`
+  r_funcall(ruby2d_window, "render_callback", 0);
 }
 
 
@@ -967,8 +1083,8 @@ static R_VAL ruby2d_ext_diagnostics(mrb_state* mrb, R_VAL self) {
 #else
 static R_VAL ruby2d_ext_diagnostics(R_VAL self, R_VAL enable) {
 #endif
-  // Set Simple 2D diagnostics
-  S2D_Diagnostics(r_test(enable));
+  // Set Ruby 2D native diagnostics
+  R2D_Diagnostics(r_test(enable));
   return R_TRUE;
 }
 
@@ -982,7 +1098,7 @@ static R_VAL ruby2d_window_ext_get_display_dimensions(mrb_state* mrb, R_VAL self
 static R_VAL ruby2d_window_ext_get_display_dimensions(R_VAL self) {
 #endif
   int w; int h;
-  S2D_GetDisplayDimensions(&w, &h);
+  R2D_GetDisplayDimensions(&w, &h);
   r_iv_set(self, "@display_width" , INT2NUM(w));
   r_iv_set(self, "@display_height", INT2NUM(h));
   return R_NIL;
@@ -999,8 +1115,8 @@ static R_VAL ruby2d_window_ext_add_controller_mappings(mrb_state* mrb, R_VAL sel
 #else
 static R_VAL ruby2d_window_ext_add_controller_mappings(R_VAL self, R_VAL path) {
 #endif
-  S2D_Log(S2D_INFO, "Adding controller mappings from `%s`", RSTRING_PTR(path));
-  S2D_AddControllerMappingsFromFile(RSTRING_PTR(path));
+  R2D_Log(R2D_INFO, "Adding controller mappings from `%s`", RSTRING_PTR(path));
+  R2D_AddControllerMappingsFromFile(RSTRING_PTR(path));
   return R_NIL;
 }
 
@@ -1032,16 +1148,16 @@ static R_VAL ruby2d_window_ext_show(R_VAL self) {
   // Get window flags
   int flags = 0;
   if (r_test(r_iv_get(self, "@resizable"))) {
-    flags = flags | S2D_RESIZABLE;
+    flags = flags | R2D_RESIZABLE;
   }
   if (r_test(r_iv_get(self, "@borderless"))) {
-    flags = flags | S2D_BORDERLESS;
+    flags = flags | R2D_BORDERLESS;
   }
   if (r_test(r_iv_get(self, "@fullscreen"))) {
-    flags = flags | S2D_FULLSCREEN;
+    flags = flags | R2D_FULLSCREEN;
   }
   if (r_test(r_iv_get(self, "@highdpi"))) {
-    flags = flags | S2D_HIGHDPI;
+    flags = flags | R2D_HIGHDPI;
   }
 
   // Check viewport size and set
@@ -1054,7 +1170,7 @@ static R_VAL ruby2d_window_ext_show(R_VAL self) {
 
   // Create and show window
 
-  window = S2D_CreateWindow(
+  window = R2D_CreateWindow(
     title, width, height, update, render, flags
   );
 
@@ -1066,7 +1182,7 @@ static R_VAL ruby2d_window_ext_show(R_VAL self) {
   window->on_mouse        = on_mouse;
   window->on_controller   = on_controller;
 
-  S2D_Show(window);
+  R2D_Show(window);
 
   atexit(free_window);
   return R_NIL;
@@ -1084,7 +1200,7 @@ static R_VAL ruby2d_ext_screenshot(mrb_state* mrb, R_VAL self) {
 static R_VAL ruby2d_ext_screenshot(R_VAL self, R_VAL path) {
 #endif
   if (window) {
-    S2D_Screenshot(window, RSTRING_PTR(path));
+    R2D_Screenshot(window, RSTRING_PTR(path));
     return path;
   } else {
     return R_FALSE;
@@ -1096,7 +1212,7 @@ static R_VAL ruby2d_ext_screenshot(R_VAL self, R_VAL path) {
  * Ruby2D::Window#ext_close
  */
 static R_VAL ruby2d_window_ext_close() {
-  S2D_Close(window);
+  R2D_Close(window);
   return R_NIL;
 }
 
@@ -1126,29 +1242,35 @@ void Init_ruby2d() {
   // Ruby2D#self.ext_base_path
   r_define_class_method(ruby2d_module, "ext_base_path", ruby2d_ext_base_path, r_args_none);
 
+  // Ruby2D::Pixel
+  R_CLASS ruby2d_pixel_class = r_define_class(ruby2d_module, "Pixel");
+
+  // Ruby2D::Pixel#self.ext_draw
+  r_define_class_method(ruby2d_pixel_class, "ext_draw", ruby2d_pixel_ext_draw, r_args_req(1));
+
   // Ruby2D::Triangle
   R_CLASS ruby2d_triangle_class = r_define_class(ruby2d_module, "Triangle");
 
-  // Ruby2D::Triangle#ext_render
-  r_define_method(ruby2d_triangle_class, "ext_render", ruby2d_triangle_ext_render, r_args_none);
+  // Ruby2D::Triangle#self.ext_draw
+  r_define_class_method(ruby2d_triangle_class, "ext_draw", ruby2d_triangle_ext_draw, r_args_req(1));
 
   // Ruby2D::Quad
   R_CLASS ruby2d_quad_class = r_define_class(ruby2d_module, "Quad");
 
-  // Ruby2D::Quad#ext_render
-  r_define_method(ruby2d_quad_class, "ext_render", ruby2d_quad_ext_render, r_args_none);
+  // Ruby2D::Quad#self.ext_draw
+  r_define_class_method(ruby2d_quad_class, "ext_draw", ruby2d_quad_ext_draw, r_args_req(1));
 
   // Ruby2D::Line
   R_CLASS ruby2d_line_class = r_define_class(ruby2d_module, "Line");
 
-  // Ruby2D::Line#ext_render
-  r_define_method(ruby2d_line_class, "ext_render", ruby2d_line_ext_render, r_args_none);
+  // Ruby2D::Line#self.ext_draw
+  r_define_class_method(ruby2d_line_class, "ext_draw", ruby2d_line_ext_draw, r_args_req(1));
 
   // Ruby2D::Circle
   R_CLASS ruby2d_circle_class = r_define_class(ruby2d_module, "Circle");
 
-  // Ruby2D::Circle#ext_render
-  r_define_method(ruby2d_circle_class, "ext_render", ruby2d_circle_ext_render, r_args_none);
+  // Ruby2D::Circle#self.ext_draw
+  r_define_class_method(ruby2d_circle_class, "ext_draw", ruby2d_circle_ext_draw, r_args_req(1));
 
   // Ruby2D::Image
   R_CLASS ruby2d_image_class = r_define_class(ruby2d_module, "Image");
@@ -1156,8 +1278,8 @@ void Init_ruby2d() {
   // Ruby2D::Image#ext_init
   r_define_method(ruby2d_image_class, "ext_init", ruby2d_image_ext_init, r_args_req(1));
 
-  // Ruby2D::Image#ext_render
-  r_define_method(ruby2d_image_class, "ext_render", ruby2d_image_ext_render, r_args_none);
+  // Ruby2D::Image#self.ext_draw
+  r_define_class_method(ruby2d_image_class, "ext_draw", ruby2d_image_ext_draw, r_args_req(1));
 
   // Ruby2D::Sprite
   R_CLASS ruby2d_sprite_class = r_define_class(ruby2d_module, "Sprite");
@@ -1165,8 +1287,17 @@ void Init_ruby2d() {
   // Ruby2D::Sprite#ext_init
   r_define_method(ruby2d_sprite_class, "ext_init", ruby2d_sprite_ext_init, r_args_req(1));
 
-  // Ruby2D::Sprite#ext_render
-  r_define_method(ruby2d_sprite_class, "ext_render", ruby2d_sprite_ext_render, r_args_none);
+  // Ruby2D::Sprite#self.ext_draw
+  r_define_class_method(ruby2d_sprite_class, "ext_draw", ruby2d_sprite_ext_draw, r_args_req(1));
+
+  // Ruby2D::Tileset
+  R_CLASS ruby2d_tileset_class = r_define_class(ruby2d_module, "Tileset");
+
+  // Ruby2D::Tileset#ext_init
+  r_define_method(ruby2d_tileset_class, "ext_init", ruby2d_tileset_ext_init, r_args_req(1));
+
+  // Ruby2D::Tileset#self.ext_draw
+  r_define_class_method(ruby2d_tileset_class, "ext_draw", ruby2d_tileset_ext_draw, r_args_req(1));
 
   // Ruby2D::Text
   R_CLASS ruby2d_text_class = r_define_class(ruby2d_module, "Text");
@@ -1177,8 +1308,8 @@ void Init_ruby2d() {
   // Ruby2D::Text#ext_set
   r_define_method(ruby2d_text_class, "ext_set", ruby2d_text_ext_set, r_args_req(1));
 
-  // Ruby2D::Text#ext_render
-  r_define_method(ruby2d_text_class, "ext_render", ruby2d_text_ext_render, r_args_none);
+  // Ruby2D::Text#self.ext_draw
+  r_define_class_method(ruby2d_text_class, "ext_draw", ruby2d_text_ext_draw, r_args_req(1));
 
   // Ruby2D::Sound
   R_CLASS ruby2d_sound_class = r_define_class(ruby2d_module, "Sound");
@@ -1189,6 +1320,9 @@ void Init_ruby2d() {
   // Ruby2D::Sound#ext_play
   r_define_method(ruby2d_sound_class, "ext_play", ruby2d_sound_ext_play, r_args_none);
 
+  // Ruby2D::Sound#ext_length
+  r_define_method(ruby2d_sound_class, "ext_length", ruby2d_sound_ext_length, r_args_none);
+
   // Ruby2D::Music
   R_CLASS ruby2d_music_class = r_define_class(ruby2d_module, "Music");
 
@@ -1216,6 +1350,9 @@ void Init_ruby2d() {
   // Ruby2D::Music#ext_fadeout
   r_define_method(ruby2d_music_class, "ext_fadeout", ruby2d_music_ext_fadeout, r_args_req(1));
 
+  // Ruby2D::Music#ext_length
+  r_define_method(ruby2d_music_class, "ext_length", ruby2d_music_ext_length, r_args_none);
+
   // Ruby2D::Window
   R_CLASS ruby2d_window_class = r_define_class(ruby2d_module, "Window");