ruby2d 0.9.3 → 0.11.0

data/ext/ruby2d/image.c

@@ -0,0 +1,58 @@
+// image.c
+
+#include "ruby2d.h"
+
+
+SDL_Surface *R2D_CreateImageSurface(const char *path) {
+  R2D_Init();
+
+  // Check if image file exists
+  if (!R2D_FileExists(path)) {
+    R2D_Error("R2D_CreateImageSurface", "Image file `%s` not found", path);
+    return NULL;
+  }
+
+  // Load image from file as SDL_Surface
+  SDL_Surface *surface = IMG_Load(path);
+
+  int bits_per_color = surface->format->Amask == 0 ?
+    surface->format->BitsPerPixel / 3 :
+    surface->format->BitsPerPixel / 4;
+
+  if (bits_per_color < 8) {
+    R2D_Log(R2D_WARN, "`%s` has less than 8 bits per color and will likely not render correctly", path, bits_per_color);
+  }
+
+  return surface;
+}
+
+void R2D_ImageConvertToRGB(SDL_Surface *surface) {
+  Uint32 r = surface->format->Rmask;
+  Uint32 g = surface->format->Gmask;
+  Uint32 a = surface->format->Amask;
+
+  if (r&0xFF000000 || r&0xFF0000) {
+    char *p = (char *)surface->pixels;
+    int bpp = surface->format->BytesPerPixel;
+    int w = surface->w;
+    int h = surface->h;
+    char tmp;
+    for (int i = 0; i < bpp * w * h; i += bpp) {
+      if (a&0xFF) {
+        tmp = p[i];
+        p[i] = p[i+3];
+        p[i+3] = tmp;
+      }
+      if (g&0xFF0000) {
+        tmp = p[i+1];
+        p[i+1] = p[i+2];
+        p[i+2] = tmp;
+      }
+      if (r&0xFF0000) {
+        tmp = p[i];
+        p[i] = p[i+2];
+        p[i+2] = tmp;
+      }
+    }
+  }
+}

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,27 +99,15 @@
   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
 #if MRUBY
-  static void free_image(mrb_state *mrb, void *p_);
-  static const struct mrb_data_type image_data_type = {
-    "image", free_image
-  };
-  static void free_sprite(mrb_state *mrb, void *p_);
-  static const struct mrb_data_type sprite_data_type = {
-    "sprite", free_sprite
-  };
-  static void free_text(mrb_state *mrb, void *p_);
-  static const struct mrb_data_type text_data_type = {
-    "text", free_text
-  };
   static void free_sound(mrb_state *mrb, void *p_);
   static const struct mrb_data_type sound_data_type = {
     "sound", free_sound
@@ -130,19 +117,18 @@ 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_sound(R2D_Sound *snd);
+  static void free_music(R2D_Music *mus);
+  static void free_font(TTF_Font *font);
+  static void free_surface(SDL_Surface *font);
 #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 +153,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 +199,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 +238,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 +284,43 @@ 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;
@@ -323,295 +328,217 @@ static R_VAL ruby2d_circle_ext_render(R_VAL self) {
 
 
 /*
- * Ruby2D::Image#ext_init
- * Initialize image structure data
+ * Ruby2D::Circle#self.ext_draw
  */
 #if MRUBY
-static R_VAL ruby2d_image_ext_init(mrb_state* mrb, R_VAL self) {
-  mrb_value path;
-  mrb_get_args(mrb, "o", &path);
+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_image_ext_init(R_VAL self, R_VAL path) {
+static R_VAL ruby2d_circle_ext_draw(R_VAL self, R_VAL a) {
 #endif
-  S2D_Image *img = S2D_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));
+  // `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_TRUE;
+  return R_NIL;
 }
 
 
 /*
- * Ruby2D::Image#ext_render
+ * Ruby2D::Image#ext_load_image
+ * Create an SDL surface from an image path, return the surface, width, and height
  */
-#if MRUBY
-static R_VAL ruby2d_image_ext_render(mrb_state* mrb, R_VAL self) {
-#else
-static R_VAL ruby2d_image_ext_render(R_VAL self) {
-#endif
-  S2D_Image *img;
-  r_data_get_struct(self, "@data", &image_data_type, S2D_Image, img);
-
-  img->x = NUM2DBL(r_iv_get(self, "@x"));
-  img->y = NUM2DBL(r_iv_get(self, "@y"));
+static R_VAL ruby2d_image_ext_load_image(R_VAL self, R_VAL path) {
+  R2D_Init();
 
-  R_VAL w = r_iv_get(self, "@width");
-  R_VAL h = r_iv_get(self, "@height");
-  if (r_test(w)) img->width  = NUM2INT(w);
-  if (r_test(h)) img->height = NUM2INT(h);
+  VALUE result = rb_ary_new2(3);
 
-  S2D_RotateImage(img, NUM2DBL(r_iv_get(self, "@rotate")), S2D_CENTER);
+  SDL_Surface *surface = R2D_CreateImageSurface(RSTRING_PTR(path));
+  R2D_ImageConvertToRGB(surface);
 
-  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"));
+  rb_ary_push(result, r_data_wrap_struct(surface, surface));
+  rb_ary_push(result, INT2NUM(surface->w));
+  rb_ary_push(result, INT2NUM(surface->h));
 
-  S2D_DrawImage(img);
-
-  return R_NIL;
+  return result;
 }
 
 
 /*
- * Free image structure attached to Ruby 2D `Image` class
+ * Ruby2D::Text#ext_load_text
  */
-#if MRUBY
-static void free_image(mrb_state *mrb, void *p_) {
-  S2D_Image *img = (S2D_Image *)p_;
-#else
-static void free_image(S2D_Image *img) {
-#endif
-  S2D_FreeImage(img);
-}
+static R_VAL ruby2d_text_ext_load_text(R_VAL self, R_VAL font, R_VAL message) {
+  R2D_Init();
 
+  VALUE result = rb_ary_new2(3);
 
-/*
- * Ruby2D::Sprite#ext_init
- * Initialize sprite structure data
- */
-#if MRUBY
-static R_VAL ruby2d_sprite_ext_init(mrb_state* mrb, R_VAL self) {
-  mrb_value path;
-  mrb_get_args(mrb, "o", &path);
-#else
-static R_VAL ruby2d_sprite_ext_init(R_VAL self, R_VAL path) {
-#endif
-  S2D_Sprite *spr = S2D_CreateSprite(RSTRING_PTR(path));
-  if (!spr) return R_FALSE;
+  TTF_Font *ttf_font;
+  Data_Get_Struct(font, TTF_Font, ttf_font);
 
-  r_iv_set(self, "@img_width" , INT2NUM(spr->width));
-  r_iv_set(self, "@img_height", INT2NUM(spr->height));
-  r_iv_set(self, "@data", r_data_wrap_struct(sprite, spr));
+  SDL_Surface *surface = R2D_TextCreateSurface(ttf_font, RSTRING_PTR(message));
+  if (!surface) {
+    return result;
+  }
 
-  return R_TRUE;
-}
+  rb_ary_push(result, r_data_wrap_struct(surface, surface));
+  rb_ary_push(result, INT2NUM(surface->w));
+  rb_ary_push(result, INT2NUM(surface->h));
 
+  return result;
+}
 
 /*
- * Ruby2D::Sprite#ext_render
+ * Ruby2D::Texture#ext_create
  */
-#if MRUBY
-static R_VAL ruby2d_sprite_ext_render(mrb_state* mrb, R_VAL self) {
-#else
-static R_VAL ruby2d_sprite_ext_render(R_VAL self) {
-#endif
-  r_funcall(self, "update", 0);
-
-  S2D_Sprite *spr;
-  r_data_get_struct(self, "@data", &sprite_data_type, S2D_Sprite, spr);
-
-  spr->x = NUM2DBL(r_iv_get(self, "@flip_x"));
-  spr->y = NUM2DBL(r_iv_get(self, "@flip_y"));
-
-  R_VAL w = r_iv_get(self, "@flip_width");
-  if (r_test(w)) spr->width = NUM2DBL(w);
-
-  R_VAL h = r_iv_get(self, "@flip_height");
-  if (r_test(h)) spr->height = NUM2DBL(h);
+static R_VAL ruby2d_texture_ext_create(R_VAL self, R_VAL rubySurface, R_VAL width, R_VAL height) {
+  GLuint texture_id = 0;
+  SDL_Surface *surface;
+  Data_Get_Struct(rubySurface, SDL_Surface, surface);
+
+  // Detect image mode
+  GLint format = GL_RGB;
+  if (surface->format->BytesPerPixel == 4) {
+    format = GL_RGBA;
+  }
 
-  S2D_RotateSprite(spr, NUM2DBL(r_iv_get(self, "@rotate")), S2D_CENTER);
+  R2D_GL_CreateTexture(&texture_id, format,
+                       NUM2INT(width), NUM2INT(height),
+                       surface->pixels, GL_NEAREST);
 
-  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"));
+  return INT2NUM(texture_id);
+}
 
-  S2D_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"))
-  );
+/*
+ * Ruby2D::Texture#ext_delete
+ */
+static R_VAL ruby2d_texture_ext_delete(R_VAL self, R_VAL rubyTexture_id) {
+  GLuint texture_id = NUM2INT(rubyTexture_id);
 
-  S2D_DrawSprite(spr);
+  R2D_GL_FreeTexture(&texture_id);
 
   return R_NIL;
 }
 
 
 /*
- * Free sprite structure attached to Ruby 2D `Sprite` class
+ * Ruby2D::Sound#ext_init
+ * Initialize sound structure data
  */
 #if MRUBY
-static void free_sprite(mrb_state *mrb, void *p_) {
-  S2D_Sprite *spr = (S2D_Sprite *)p_;
+static R_VAL ruby2d_sound_ext_init(mrb_state* mrb, R_VAL self) {
+  mrb_value path;
+  mrb_get_args(mrb, "o", &path);
 #else
-static void free_sprite(S2D_Sprite *spr) {
+static R_VAL ruby2d_sound_ext_init(R_VAL self, R_VAL path) {
 #endif
-  S2D_FreeSprite(spr);
+  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;
 }
 
 
 /*
- * Ruby2D::Text#ext_init
- * Initialize text structure data
+ * Ruby2D::Sound#ext_play
  */
 #if MRUBY
-static R_VAL ruby2d_text_ext_init(mrb_state* mrb, R_VAL self) {
+static R_VAL ruby2d_sound_ext_play(mrb_state* mrb, R_VAL self) {
 #else
-static R_VAL ruby2d_text_ext_init(R_VAL self) {
+static R_VAL ruby2d_sound_ext_play(R_VAL self) {
 #endif
-  // Trim the font file string to its actual length on MRuby
-  #if MRUBY
-    mrb_value s = r_iv_get(self, "@font");
-    mrb_str_resize(mrb, s, RSTRING_LEN(s));
-  #endif
-
-  S2D_Text *txt = S2D_CreateText(
-    RSTRING_PTR(r_iv_get(self, "@font")),
-    RSTRING_PTR(r_iv_get(self, "@text")),
-    NUM2DBL(r_iv_get(self, "@size"))
-  );
-  if (!txt) return R_FALSE;
-
-  r_iv_set(self, "@width", INT2NUM(txt->width));
-  r_iv_set(self, "@height", INT2NUM(txt->height));
-  r_iv_set(self, "@data", r_data_wrap_struct(text, txt));
-
-  return R_TRUE;
+  R2D_Sound *snd;
+  r_data_get_struct(self, "@data", &sound_data_type, R2D_Sound, snd);
+  R2D_PlaySound(snd);
+  return R_NIL;
 }
 
 
 /*
- * Ruby2D::Text#ext_set
+ * Ruby2D::Sound#ext_length
  */
-#if MRUBY
-static R_VAL ruby2d_text_ext_set(mrb_state* mrb, R_VAL self) {
-  mrb_value text;
-  mrb_get_args(mrb, "o", &text);
-#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);
-
-  S2D_SetText(txt, RSTRING_PTR(text));
-
-  r_iv_set(self, "@width", INT2NUM(txt->width));
-  r_iv_set(self, "@height", INT2NUM(txt->height));
-
-  return R_NIL;
+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));
 }
 
 
 /*
- * Ruby2D::Text#ext_render
+ * Free sound structure attached to Ruby 2D `Sound` class
  */
 #if MRUBY
-static R_VAL ruby2d_text_ext_render(mrb_state* mrb, R_VAL self) {
+static void free_sound(mrb_state *mrb, void *p_) {
+  R2D_Sound *snd = (R2D_Sound *)p_;
 #else
-static R_VAL ruby2d_text_ext_render(R_VAL self) {
+static void free_sound(R2D_Sound *snd) {
 #endif
-  S2D_Text *txt;
-  r_data_get_struct(self, "@data", &text_data_type, S2D_Text, txt);
-
-  txt->x = NUM2DBL(r_iv_get(self, "@x"));
-  txt->y = NUM2DBL(r_iv_get(self, "@y"));
-
-  S2D_RotateText(txt, NUM2DBL(r_iv_get(self, "@rotate")), S2D_CENTER);
-
-  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"));
-
-  S2D_DrawText(txt);
-
-  return R_NIL;
+  R2D_FreeSound(snd);
 }
 
-
 /*
- * Free text structure attached to Ruby 2D `Text` class
+ * Ruby2D::Sound#ext_get_volume
  */
 #if MRUBY
-static void free_text(mrb_state *mrb, void *p_) {
-  S2D_Text *txt = (S2D_Text *)p_;
+static R_VAL ruby2d_sound_ext_get_volume(mrb_state* mrb, R_VAL self) {
 #else
-static void free_text(S2D_Text *txt) {
+static R_VAL ruby2d_sound_ext_get_volume(R_VAL self) {
 #endif
-  S2D_FreeText(txt);
+  R2D_Sound *snd;
+  r_data_get_struct(self, "@data", &sound_data_type, R2D_Sound, snd);
+  return INT2NUM(ceil(Mix_VolumeChunk(snd->data, -1) * (100.0 / MIX_MAX_VOLUME)));
 }
 
-
 /*
- * Ruby2D::Sound#ext_init
- * Initialize sound structure data
+ * Ruby2D::Music#ext_set_volume
  */
 #if MRUBY
-static R_VAL ruby2d_sound_ext_init(mrb_state* mrb, R_VAL self) {
-  mrb_value path;
-  mrb_get_args(mrb, "o", &path);
+static R_VAL ruby2d_sound_ext_set_volume(mrb_state* mrb, R_VAL self) {
+  mrb_value volume;
+  mrb_get_args(mrb, "o", &volume);
 #else
-static R_VAL ruby2d_sound_ext_init(R_VAL self, R_VAL path) {
+static R_VAL ruby2d_sound_ext_set_volume(R_VAL self, R_VAL volume) {
 #endif
-  S2D_Sound *snd = S2D_CreateSound(RSTRING_PTR(path));
-  if (!snd) return R_FALSE;
-  r_iv_set(self, "@data", r_data_wrap_struct(sound, snd));
-  return R_TRUE;
+  R2D_Sound *snd;
+  r_data_get_struct(self, "@data", &sound_data_type, R2D_Sound, snd);
+  Mix_VolumeChunk(snd->data, (NUM2INT(volume) / 100.0) * MIX_MAX_VOLUME);
+  return R_NIL;
 }
 
-
 /*
- * Ruby2D::Sound#ext_play
+ * Ruby2D::Sound#ext_get_mix_volume
  */
 #if MRUBY
-static R_VAL ruby2d_sound_ext_play(mrb_state* mrb, R_VAL self) {
+static R_VAL ruby2d_sound_ext_get_mix_volume(mrb_state* mrb, R_VAL self) {
 #else
-static R_VAL ruby2d_sound_ext_play(R_VAL self) {
+static R_VAL ruby2d_sound_ext_get_mix_volume(R_VAL self) {
 #endif
-  S2D_Sound *snd;
-  r_data_get_struct(self, "@data", &sound_data_type, S2D_Sound, snd);
-  S2D_PlaySound(snd);
-  return R_NIL;
+  return INT2NUM(ceil(Mix_Volume(-1, -1) * (100.0 / MIX_MAX_VOLUME)));
 }
 
-
 /*
- * Free sound structure attached to Ruby 2D `Sound` class
+ * Ruby2D::Music#ext_set_mix_volume
  */
 #if MRUBY
-static void free_sound(mrb_state *mrb, void *p_) {
-  S2D_Sound *snd = (S2D_Sound *)p_;
+static R_VAL ruby2d_sound_ext_set_mix_volume(mrb_state* mrb, R_VAL self) {
+  mrb_value volume;
+  mrb_get_args(mrb, "o", &volume);
 #else
-static void free_sound(S2D_Sound *snd) {
+static R_VAL ruby2d_sound_ext_set_mix_volume(R_VAL self, R_VAL volume) {
 #endif
-  S2D_FreeSound(snd);
+  Mix_Volume(-1, (NUM2INT(volume) / 100.0) * MIX_MAX_VOLUME);
+  return R_NIL;
 }
 
-
 /*
  * Ruby2D::Music#ext_init
  * Initialize music structure data
@@ -623,7 +550,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 +565,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 +580,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 +593,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 +606,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 +619,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 +633,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 +648,95 @@ 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));
+}
+
+/*
+ * Ruby2D::Font#ext_load
+ */
+static R_VAL ruby2d_font_ext_load(R_VAL self, R_VAL path, R_VAL size, R_VAL style) {
+  R2D_Init();
+
+  TTF_Font *font = R2D_FontCreateTTFFont(RSTRING_PTR(path), NUM2INT(size), RSTRING_PTR(style));
+  if (!font) {
+    return R_NIL;
+  }
+
+  return r_data_wrap_struct(font, font);
+}
+
+
+/*
+ * Ruby2D::Texture#ext_draw
+ */
+static R_VAL ruby2d_texture_ext_draw(R_VAL self, R_VAL ruby_coordinates, R_VAL ruby_texture_coordinates, R_VAL ruby_color, R_VAL texture_id) {
+  GLfloat coordinates[8];
+  GLfloat texture_coordinates[8];
+  GLfloat color[4];
+
+  for(int i = 0; i < 8; i++) { coordinates[i] = NUM2DBL(r_ary_entry(ruby_coordinates, i)); }
+  for(int i = 0; i < 8; i++) { texture_coordinates[i] = NUM2DBL(r_ary_entry(ruby_texture_coordinates, i)); }
+  for(int i = 0; i < 4; i++) { color[i] = NUM2DBL(r_ary_entry(ruby_color, i)); }
+  
+  R2D_GL_DrawTexture(coordinates, texture_coordinates, color, NUM2INT(texture_id));
+
   return R_NIL;
 }
 
+/*
+ * Free font structure stored in the Ruby 2D `Font` class
+ */
+static void free_font(TTF_Font *font) {
+  TTF_CloseFont(font);
+}
+
+/*
+ * Free surface structure used within the Ruby 2D `Texture` class
+ */
+static void free_surface(SDL_Surface *surface) {
+  SDL_FreeSurface(surface);
+}
+
 
 /*
  * 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 +746,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 +801,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 +897,7 @@ static void on_controller(S2D_Event e) {
 
 
 /*
- * Simple 2D `update` callback function
+ * Ruby 2D native `update` callback function
  */
 static void update() {
 
@@ -934,7 +917,7 @@ static void update() {
 
 
 /*
- * Simple 2D `render` callback function
+ * Ruby 2D native `render` callback function
  */
 static void render() {
 
@@ -952,8 +935,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 +953,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 +968,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 +985,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 +1018,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 +1040,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 +1052,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 +1070,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 +1082,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,59 +1112,47 @@ 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");
 
-  // 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::Sprite
-  R_CLASS ruby2d_sprite_class = r_define_class(ruby2d_module, "Sprite");
-
-  // 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::Image#ext_load_image
+  r_define_class_method(ruby2d_image_class, "ext_load_image", ruby2d_image_ext_load_image, r_args_req(1));
 
   // Ruby2D::Text
   R_CLASS ruby2d_text_class = r_define_class(ruby2d_module, "Text");
 
-  // Ruby2D::Text#ext_init
-  r_define_method(ruby2d_text_class, "ext_init", ruby2d_text_ext_init, r_args_none);
-
-  // 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#ext_load_text
+  r_define_class_method(ruby2d_text_class, "ext_load_text", ruby2d_text_ext_load_text, r_args_req(2));
 
   // Ruby2D::Sound
   R_CLASS ruby2d_sound_class = r_define_class(ruby2d_module, "Sound");
@@ -1188,6 +1162,21 @@ 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_get_volume
+  r_define_method(ruby2d_sound_class, "ext_get_volume", ruby2d_sound_ext_get_volume, r_args_none);
+  
+  // Ruby2D::Sound#ext_set_volume
+  r_define_method(ruby2d_sound_class, "ext_set_volume", ruby2d_sound_ext_set_volume, r_args_req(1));
+  
+  // Ruby2D::Sound#self.ext_get_mix_volume
+  r_define_class_method(ruby2d_sound_class, "ext_get_mix_volume", ruby2d_sound_ext_get_mix_volume, r_args_none);
+  
+  // Ruby2D::Sound#self.ext_set_mix_volume
+  r_define_class_method(ruby2d_sound_class, "ext_set_mix_volume", ruby2d_sound_ext_set_mix_volume, r_args_req(1));
+
+  // 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 +1205,27 @@ 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::Font
+  R_CLASS ruby2d_font_class = r_define_class(ruby2d_module, "Font");
+
+  // Ruby2D::Font#ext_load
+  r_define_class_method(ruby2d_font_class, "ext_load", ruby2d_font_ext_load, r_args_req(3));
+
+  // Ruby2D::Texture
+  R_CLASS ruby2d_texture_class = r_define_class(ruby2d_module, "Texture");
+
+  // Ruby2D::Texture#ext_draw
+  r_define_method(ruby2d_texture_class, "ext_draw", ruby2d_texture_ext_draw, r_args_req(4));
+
+  // Ruby2D::Texture#ext_create
+  r_define_method(ruby2d_texture_class, "ext_create", ruby2d_texture_ext_create, r_args_req(3));
+
+  // Ruby2D::Texture#ext_delete
+  r_define_method(ruby2d_texture_class, "ext_delete", ruby2d_texture_ext_delete, r_args_req(1));
+
   // Ruby2D::Window
   R_CLASS ruby2d_window_class = r_define_class(ruby2d_module, "Window");