ruby2d 0.2.1 → 0.3.0

data/ext/ruby2d/ruby2d.c

@@ -1,104 +1,465 @@
-#include <ruby.h>
+// ruby2d.c – Native C extension for Ruby and MRuby
+
+// Simple 2D includes
 #include <simple2d.h>
 
+// Ruby includes
+#if MRUBY
+  #include <mruby.h>
+  #include <mruby/array.h>
+  #include <mruby/string.h>
+  #include <mruby/variable.h>
+  #include <mruby/numeric.h>
+  #include <mruby/data.h>
+  #include <mruby/irep.h>
+#else
+  #include <ruby.h>
+#endif
+
+// Define Ruby type conversions in MRuby
+#if MRUBY
+  // C to MRuby types
+  #define INT2FIX(val)   (mrb_fixnum_value(val))
+  #define INT2NUM(val)   (mrb_fixnum_value((mrb_int)(val)))
+  #define UINT2NUM(val)  (INT2NUM((unsigned mrb_int)(val)))
+  #define LL2NUM(val)    (INT2NUM(val))
+  #define ULL2NUM(val)   (INT2NUM((unsigned __int64)(val)))
+  #define DBL2NUM(val)   (mrb_float_value(mrb, (mrb_float)(val)))
+  // MRuby to C types
+  #define TO_PDT(val)    ((mrb_type(val) == MRB_TT_FLOAT) ? mrb_float(val) : mrb_int(mrb, (val)))
+  #define FIX2INT(val)   (mrb_fixnum(val))
+  #define NUM2INT(val)   ((mrb_int)TO_PDT(val))
+  #define NUM2UINT(val)  ((unsigned mrb_int)TO_PDT(val))
+  #define NUM2LONG(val)  (mrb_int(mrb, (val)))
+  #define NUM2LL(val)    ((__int64)(TO_PDT(val)))
+  #define NUM2ULL(val)   ((unsigned __int64)(TO_PDT(val)))
+  #define NUM2DBL(val)   (mrb_to_flo(mrb, (val)))
+  #define NUM2CHR(val)   ((mrb_string_p(val) && (RSTRING_LEN(val)>=1)) ? RSTRING_PTR(val)[0] : (char)(NUM2INT(val) & 0xff))
+  // Memory management
+  #define ALLOC(type)        ((type *)mrb_malloc(mrb, sizeof(type)))
+  #define ALLOC_N(type, n)   ((type *)mrb_malloc(mrb, sizeof(type) * (n)))
+  #define ALLOCA_N(type, n)  ((type *)alloca(sizeof(type) * (n)))
+  #define MEMCMP(p1, p2, type, n)  (memcmp((p1), (p2), sizeof(type)*(n)))
+#endif
+
+// Define common types and API calls, mapping to both Ruby and MRuby APIs
+#if MRUBY
+  // MRuby
+  #define R_VAL  mrb_value
+  #define R_NIL  (mrb_nil_value())
+  #define R_TRUE  (mrb_true_value())
+  #define R_FALSE  (mrb_false_value())
+  #define R_CLASS  struct RClass *
+  #define r_iv_get(self, var)  mrb_iv_get(mrb, self, mrb_intern_lit(mrb, var))
+  #define r_iv_set(self, var, val)  mrb_iv_set(mrb, self, mrb_intern_lit(mrb, var), val)
+  #define r_funcall(self, method, num_args, ...)  mrb_funcall(mrb, self, method, num_args, ##__VA_ARGS__)
+  #define r_str_new(str)  mrb_str_new(mrb, str, strlen(str))
+  #define r_test(val)  (mrb_test(val) == true)
+  #define r_ary_entry(ary, pos)  mrb_ary_entry(ary, pos)
+  #define r_data_wrap_struct(name, data)  mrb_obj_value(Data_Wrap_Struct(mrb, mrb->object_class, &name##_data_type, data))
+  #define r_data_get_struct(self, var, mrb_type, rb_type, data)  Data_Get_Struct(mrb, r_iv_get(self, var), mrb_type, data)
+  #define r_define_module(name)  mrb_module_get(mrb, name)
+  #define r_define_class(module, name)  mrb_class_get_under(mrb, module, name);
+  #define r_define_method(class, name, function, args)  mrb_define_method(mrb, class, name, function, args)
+  #define r_args_none  (MRB_ARGS_NONE())
+  #define r_args_req(n)  MRB_ARGS_REQ(n)
+#else
+  // Ruby
+  #define R_VAL  VALUE
+  #define R_NIL  Qnil
+  #define R_TRUE  Qtrue
+  #define R_FALSE  Qfalse
+  #define R_CLASS  R_VAL
+  #define r_iv_get(self, var)  rb_iv_get(self, var)
+  #define r_iv_set(self, var, val)  rb_iv_set(self, var, val)
+  #define r_funcall(self, method, num_args, ...)  rb_funcall(self, rb_intern(method), num_args, ##__VA_ARGS__)
+  #define r_str_new(str)  rb_str_new2(str)
+  #define r_test(val)  (val != Qfalse && val != Qnil)
+  #define r_ary_entry(ary, pos)  rb_ary_entry(ary, pos)
+  #define r_data_wrap_struct(name, data)  Data_Wrap_Struct(rb_cObject, NULL, (free_##name), data)
+  #define r_data_get_struct(self, var, mrb_type, rb_type, data)  Data_Get_Struct(r_iv_get(self, var), rb_type, data)
+  #define r_define_module(name)  rb_define_module(name)
+  #define r_define_class(module, name)  rb_define_class_under(module, name, rb_cObject);
+  #define r_define_method(class, name, function, args)  rb_define_method(class, name, function, args)
+  #define r_args_none  0
+  #define r_args_req(n)  n
+#endif
+
 // @type_id values for rendering
-#define TRIANGLE 1
-#define QUAD     2
-#define IMAGE    3
-#define TEXT     4
+#define R2D_TRIANGLE 1
+#define R2D_QUAD     2
+#define R2D_IMAGE    3
+#define R2D_SPRITE   4
+#define R2D_TEXT     5
+
+// Create the MRuby context
+#if MRUBY
+  static mrb_state *mrb;
+#endif
 
 // Ruby 2D window
-VALUE self;
+static R_VAL ruby2d_window;
 
 // Simple 2D window
-S2D_Window *window;
-
-// Ruby data types
-static VALUE ruby2d_module;
-static VALUE ruby2d_window_klass;
-static VALUE c_data_klass;
-
-// Structures for Ruby 2D classes
-struct image_data {
-  S2D_Image *img;
-};
-struct text_data {
-  S2D_Text *txt;
-};
-struct sound_data {
-  S2D_Sound *snd;
-};
+static S2D_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
+  };
+  static void free_music(mrb_state *mrb, void *p_);
+  static const struct mrb_data_type music_data_type = {
+    "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);
+#endif
 
 
 /*
- * Function pointer to close the Simple 2D window
+ * Function pointer to free the Simple 2D window
  */
-static void close_window() {
-  S2D_Close(window);
+static void free_window() {
+  S2D_FreeWindow(window);
+}
+
+
+/*
+ * Ruby2D::Image#init
+ * Initialize image structure data
+ */
+#if MRUBY
+static R_VAL ruby2d_image_init(mrb_state* mrb, R_VAL self) {
+  mrb_value path;
+  mrb_get_args(mrb, "o", &path);
+#else
+static R_VAL ruby2d_image_init(R_VAL self, R_VAL path) {
+#endif
+  sprintf(S2D_msg, "Init image: %s", RSTRING_PTR(path));
+  S2D_Log(S2D_msg, S2D_INFO);
+  S2D_Image *img = S2D_CreateImage(RSTRING_PTR(path));
+  r_iv_set(self, "@data", r_data_wrap_struct(image, img));
+  return R_NIL;
 }
 
 
 /*
  * Free image structure attached to Ruby 2D `Image` class
  */
-static void free_image(struct image_data *data) {
-  S2D_FreeImage(data->img);
-  xfree(data);
+#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
+  sprintf(S2D_msg, "Free image: %i, %i", img->x, img->y);
+  S2D_Log(S2D_msg, S2D_INFO);
+  S2D_FreeImage(img);
 }
 
 
 /*
- * Initialize image structure data
+ * Ruby2D::Sprite#init
+ * Initialize sprite structure data
  */
-static VALUE init_image(char *path) {
-  struct image_data *data = ALLOC(struct image_data);
-  data->img = S2D_CreateImage(path);
-  return Data_Wrap_Struct(c_data_klass, NULL, free_image, data);
+#if MRUBY
+static R_VAL ruby2d_sprite_init(mrb_state* mrb, R_VAL self) {
+  mrb_value path;
+  mrb_get_args(mrb, "o", &path);
+#else
+static R_VAL ruby2d_sprite_init(R_VAL self, R_VAL path) {
+#endif
+  sprintf(S2D_msg, "Init sprite: %s", RSTRING_PTR(path));
+  S2D_Log(S2D_msg, S2D_INFO);
+  S2D_Sprite *spr = S2D_CreateSprite(RSTRING_PTR(path));
+  r_iv_set(self, "@data", r_data_wrap_struct(sprite, spr));
+  return R_NIL;
 }
 
 
 /*
- * Free text structure attached to Ruby 2D `Text` class
+ * Free sprite structure attached to Ruby 2D `Sprite` class
  */
-static void free_text(struct text_data *data) {
-  S2D_FreeText(data->txt);
-  xfree(data);
+#if MRUBY
+static void free_sprite(mrb_state *mrb, void *p_) {
+  S2D_Sprite *spr = (S2D_Sprite *)p_;
+#else
+static void free_sprite(S2D_Sprite *spr) {
+#endif
+  sprintf(S2D_msg, "Free sprite: %i, %i", spr->x, spr->y);
+  S2D_Log(S2D_msg, S2D_INFO);
+  S2D_FreeSprite(spr);
 }
 
 
 /*
+ * Ruby2D::Text#init
  * Initialize text structure data
  */
-static VALUE init_text(char *font, char *msg, int size) {
-  struct text_data *data = ALLOC(struct text_data);
-  data->txt = S2D_CreateText(font, msg, size);
-  return Data_Wrap_Struct(c_data_klass, NULL, free_text, data);
+#if MRUBY
+static R_VAL ruby2d_text_init(mrb_state* mrb, R_VAL self) {
+#else
+static R_VAL ruby2d_text_init(R_VAL self) {
+#endif
+  sprintf(S2D_msg, "Init text: %s", RSTRING_PTR(r_iv_get(self, "@text")));
+  S2D_Log(S2D_msg, S2D_INFO);
+  
+  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"))
+  );
+  
+  r_iv_set(self, "@data", r_data_wrap_struct(text, txt));
+  return R_NIL;
+}
+
+
+/*
+ * Ruby2D::Text#text=
+ */
+#if MRUBY
+static R_VAL ruby2d_text_equals(mrb_state* mrb, R_VAL self) {
+  mrb_value text;
+  mrb_get_args(mrb, "o", &text);
+#else
+static R_VAL ruby2d_text_equals(R_VAL self, R_VAL text) {
+  r_iv_set(self, "@text", text);
+#endif
+  
+  // If called before window is shown, return
+  if (!r_test(ruby2d_window)) return R_NIL;
+  
+  S2D_Text *txt;
+  r_data_get_struct(self, "@data", &text_data_type, S2D_Text, txt);
+  
+  S2D_SetText(txt, RSTRING_PTR(text));
+  return R_NIL;
+}
+
+
+/*
+ * Free text structure attached to Ruby 2D `Text` class
+ */
+#if MRUBY
+static void free_text(mrb_state *mrb, void *p_) {
+  S2D_Text *txt = (S2D_Text *)p_;
+#else
+static void free_text(S2D_Text *txt) {
+#endif
+  sprintf(S2D_msg, "Free text: %s", txt->msg);
+  S2D_Log(S2D_msg, S2D_INFO);
+  S2D_FreeText(txt);
+}
+
+
+/*
+ * Ruby2D::Sound#init
+ * Initialize sound structure data
+ */
+#if MRUBY
+static R_VAL ruby2d_sound_init(mrb_state* mrb, R_VAL self) {
+  mrb_value path;
+  mrb_get_args(mrb, "o", &path);
+#else
+static R_VAL ruby2d_sound_init(R_VAL self, R_VAL path) {
+#endif
+  sprintf(S2D_msg, "Init sound: %s", RSTRING_PTR(path));
+  S2D_Log(S2D_msg, S2D_INFO);
+  S2D_Sound *snd = S2D_CreateSound(RSTRING_PTR(path));
+  r_iv_set(self, "@data", r_data_wrap_struct(sound, snd));
+  return R_NIL;
+}
+
+
+/*
+ * Ruby2D::Sound#play
+ */
+#if MRUBY
+static R_VAL ruby2d_sound_play(mrb_state* mrb, R_VAL self) {
+#else
+static R_VAL ruby2d_sound_play(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;
+}
+
+
+/*
+ * 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_;
+#else
+static void free_sound(S2D_Sound *snd) {
+#endif
+  sprintf(S2D_msg, "Free sound");
+  S2D_Log(S2D_msg, S2D_INFO);
+  S2D_FreeSound(snd);
+}
+
+
+/*
+ * Ruby2D::Music#init
+ * Initialize music structure data
+ */
+#if MRUBY
+static R_VAL ruby2d_music_init(mrb_state* mrb, R_VAL self) {
+  mrb_value path;
+  mrb_get_args(mrb, "o", &path);
+#else
+static R_VAL ruby2d_music_init(R_VAL self, R_VAL path) {
+#endif
+  sprintf(S2D_msg, "Init music: %s", RSTRING_PTR(path));
+  S2D_Log(S2D_msg, S2D_INFO);
+  S2D_Music *mus = S2D_CreateMusic(RSTRING_PTR(path));
+  r_iv_set(self, "@data", r_data_wrap_struct(music, mus));
+  return R_NIL;
+}
+
+
+/*
+ * Ruby2D::Music#play
+ */
+#if MRUBY
+static R_VAL ruby2d_music_play(mrb_state* mrb, R_VAL self) {
+#else
+static R_VAL ruby2d_music_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")));
+  return R_NIL;
+}
+
+
+/*
+ * Ruby2D::Music#pause
+ */
+#if MRUBY
+static R_VAL ruby2d_music_pause(mrb_state* mrb, R_VAL self) {
+#else
+static R_VAL ruby2d_music_pause(R_VAL self) {
+#endif
+  S2D_PauseMusic();
+  return R_NIL;
+}
+
+
+/*
+ * Ruby2D::Music#resume
+ */
+#if MRUBY
+static R_VAL ruby2d_music_resume(mrb_state* mrb, R_VAL self) {
+#else
+static R_VAL ruby2d_music_resume(R_VAL self) {
+#endif
+  S2D_ResumeMusic();
+  return R_NIL;
+}
+
+
+/*
+ * Ruby2D::Music#stop
+ */
+#if MRUBY
+static R_VAL ruby2d_music_stop(mrb_state* mrb, R_VAL self) {
+#else
+static R_VAL ruby2d_music_stop(R_VAL self) {
+#endif
+  S2D_StopMusic();
+  return R_NIL;
+}
+
+
+/*
+ * Ruby2D::Music#fadeout
+ */
+#if MRUBY
+static R_VAL ruby2d_music_fadeout(mrb_state* mrb, R_VAL self) {
+  mrb_value ms;
+  mrb_get_args(mrb, "o", &ms);
+#else
+static R_VAL ruby2d_music_fadeout(R_VAL self, R_VAL ms) {
+#endif
+  S2D_FadeOutMusic(NUM2INT(ms));
+  return R_NIL;
+}
+
+
+/*
+ * Free sound structure attached to Ruby 2D `Sound` class
+ */
+#if MRUBY
+static void free_music(mrb_state *mrb, void *p_) {
+  S2D_Music *mus = (S2D_Music *)p_;
+#else
+static void free_music(S2D_Music *mus) {
+#endif
+  sprintf(S2D_msg, "Free music");
+  S2D_Log(S2D_msg, S2D_INFO);
+  S2D_FreeMusic(mus);
 }
 
 
 /*
  * Simple 2D `on_key` input callback function
  */
-void on_key(const char *key) {
-  rb_funcall(self, rb_intern("key_callback"), 1, rb_str_new2(key));
+static void on_key(S2D_Event e, const char *key) {
+  switch (e) {
+    case S2D_KEYDOWN:
+      r_funcall(ruby2d_window, "key_down_callback", 1, r_str_new(key));
+      break;
+    
+    case S2D_KEY:
+      r_funcall(ruby2d_window, "key_callback", 1, r_str_new(key));
+      break;
+    
+    case S2D_KEYUP:
+      r_funcall(ruby2d_window, "key_up_callback", 1, r_str_new(key));
+      break;
+  }
 }
 
 
 /*
- * Simple 2D `on_key_down` input callback function
+ * Simple 2D `on_mouse` input callback function
  */
-void on_key_down(const char *key) {
-  rb_funcall(self, rb_intern("key_down_callback"), 1, rb_str_new2(key));
+void on_mouse(int x, int y) {
+  r_funcall(ruby2d_window, "mouse_callback", 3, r_str_new("any"), INT2NUM(x), INT2NUM(y));
 }
 
 
 /*
  * Simple 2D `on_controller` input callback function
  */
-void on_controller(bool is_axis, int axis, int val, bool is_btn, int btn) {
-  rb_funcall(self, rb_intern("controller_callback"), 5,
-    is_axis ? Qtrue : Qfalse, INT2NUM(axis), INT2NUM(val),
-    is_btn  ? Qtrue : Qfalse, INT2NUM(btn)
+static void on_controller(int which, bool is_axis, int axis, int val, bool is_btn, int btn, bool pressed) {
+  r_funcall(ruby2d_window, "controller_callback", 7,
+    INT2NUM(which),
+    is_axis ? R_TRUE : R_FALSE, INT2NUM(axis), INT2NUM(val),
+    is_btn  ? R_TRUE : R_FALSE, INT2NUM(btn), pressed ? R_TRUE : R_FALSE
   );
 }
 
@@ -106,137 +467,171 @@ void on_controller(bool is_axis, int axis, int val, bool is_btn, int btn) {
 /*
  * Simple 2D `update` callback function
  */
-void update() {
+static void update() {
   
   // Set the cursor
-  rb_iv_set(self, "@mouse_x", INT2NUM(window->mouse.x));
-  rb_iv_set(self, "@mouse_y", INT2NUM(window->mouse.y));
+  r_iv_set(ruby2d_window, "@mouse_x", INT2NUM(window->mouse.x));
+  r_iv_set(ruby2d_window, "@mouse_y", INT2NUM(window->mouse.y));
+  
+  // Store frames
+  r_iv_set(ruby2d_window, "@frames", DBL2NUM(window->frames));
   
   // Store frame rate
-  rb_iv_set(self, "@fps", INT2NUM(window->fps));
+  r_iv_set(ruby2d_window, "@fps", DBL2NUM(window->fps));
   
   // Call update proc, `window.update`
-  rb_funcall(self, rb_intern("update_callback"), 0);
+  r_funcall(ruby2d_window, "update_callback", 0);
 }
 
 
 /*
  * Simple 2D `render` callback function
  */
-void render() {
+static void render() {
+  
+  // Set background color
+  R_VAL bc = r_iv_get(ruby2d_window, "@background");
+  window->background.r = NUM2DBL(r_iv_get(bc, "@r"));
+  window->background.g = NUM2DBL(r_iv_get(bc, "@g"));
+  window->background.b = NUM2DBL(r_iv_get(bc, "@b"));
+  window->background.a = NUM2DBL(r_iv_get(bc, "@a"));
   
   // Read window objects
-  VALUE objects = rb_iv_get(self, "@objects");
-  int num_objects = NUM2INT(rb_funcall(objects, rb_intern("count"), 0));
+  R_VAL objects = r_iv_get(ruby2d_window, "@objects");
+  int num_objects = NUM2INT(r_funcall(objects, "length", 0));
   
   // Switch on each object type
   for (int i = 0; i < num_objects; ++i) {
     
-    VALUE el = rb_ary_entry(objects, i);
-    int type_id = NUM2INT(rb_iv_get(el, "@type_id"));
+    R_VAL el = r_ary_entry(objects, i);
+    int type_id = NUM2INT(r_iv_get(el, "@type_id"));
     
     // Switch on the object's type_id
     switch(type_id) {
       
-      case TRIANGLE: {
-        VALUE c1 = rb_iv_get(el, "@c1");
-        VALUE c2 = rb_iv_get(el, "@c2");
-        VALUE c3 = rb_iv_get(el, "@c3");
+      case R2D_TRIANGLE: {
+        R_VAL c1 = r_iv_get(el, "@c1");
+        R_VAL c2 = r_iv_get(el, "@c2");
+        R_VAL c3 = r_iv_get(el, "@c3");
         
         S2D_DrawTriangle(
-          NUM2DBL(rb_iv_get(el, "@x1")),
-          NUM2DBL(rb_iv_get(el, "@y1")),
-          NUM2DBL(rb_iv_get(c1, "@r")),
-          NUM2DBL(rb_iv_get(c1, "@g")),
-          NUM2DBL(rb_iv_get(c1, "@b")),
-          NUM2DBL(rb_iv_get(c1, "@a")),
+          NUM2DBL(r_iv_get(el, "@x1")),
+          NUM2DBL(r_iv_get(el, "@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(rb_iv_get(el, "@x2")),
-          NUM2DBL(rb_iv_get(el, "@y2")),
-          NUM2DBL(rb_iv_get(c2, "@r")),
-          NUM2DBL(rb_iv_get(c2, "@g")),
-          NUM2DBL(rb_iv_get(c2, "@b")),
-          NUM2DBL(rb_iv_get(c2, "@a")),
+          NUM2DBL(r_iv_get(el, "@x2")),
+          NUM2DBL(r_iv_get(el, "@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(rb_iv_get(el, "@x3")),
-          NUM2DBL(rb_iv_get(el, "@y3")),
-          NUM2DBL(rb_iv_get(c3, "@r")),
-          NUM2DBL(rb_iv_get(c3, "@g")),
-          NUM2DBL(rb_iv_get(c3, "@b")),
-          NUM2DBL(rb_iv_get(c3, "@a"))
+          NUM2DBL(r_iv_get(el, "@x3")),
+          NUM2DBL(r_iv_get(el, "@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"))
         );
       }
       break;
       
-      case QUAD: {
-        VALUE c1 = rb_iv_get(el, "@c1");
-        VALUE c2 = rb_iv_get(el, "@c2");
-        VALUE c3 = rb_iv_get(el, "@c3");
-        VALUE c4 = rb_iv_get(el, "@c4");
+      case R2D_QUAD: {
+        R_VAL c1 = r_iv_get(el, "@c1");
+        R_VAL c2 = r_iv_get(el, "@c2");
+        R_VAL c3 = r_iv_get(el, "@c3");
+        R_VAL c4 = r_iv_get(el, "@c4");
         
         S2D_DrawQuad(
-          NUM2DBL(rb_iv_get(el, "@x1")),
-          NUM2DBL(rb_iv_get(el, "@y1")),
-          NUM2DBL(rb_iv_get(c1, "@r")),
-          NUM2DBL(rb_iv_get(c1, "@g")),
-          NUM2DBL(rb_iv_get(c1, "@b")),
-          NUM2DBL(rb_iv_get(c1, "@a")),
-
-          NUM2DBL(rb_iv_get(el, "@x2")),
-          NUM2DBL(rb_iv_get(el, "@y2")),
-          NUM2DBL(rb_iv_get(c2, "@r")),
-          NUM2DBL(rb_iv_get(c2, "@g")),
-          NUM2DBL(rb_iv_get(c2, "@b")),
-          NUM2DBL(rb_iv_get(c2, "@a")),
-
-          NUM2DBL(rb_iv_get(el, "@x3")),
-          NUM2DBL(rb_iv_get(el, "@y3")),
-          NUM2DBL(rb_iv_get(c3, "@r")),
-          NUM2DBL(rb_iv_get(c3, "@g")),
-          NUM2DBL(rb_iv_get(c3, "@b")),
-          NUM2DBL(rb_iv_get(c3, "@a")),
-
-          NUM2DBL(rb_iv_get(el, "@x4")),
-          NUM2DBL(rb_iv_get(el, "@y4")),
-          NUM2DBL(rb_iv_get(c4, "@r")),
-          NUM2DBL(rb_iv_get(c4, "@g")),
-          NUM2DBL(rb_iv_get(c4, "@b")),
-          NUM2DBL(rb_iv_get(c4, "@a"))
+          NUM2DBL(r_iv_get(el, "@x1")),
+          NUM2DBL(r_iv_get(el, "@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(el, "@x2")),
+          NUM2DBL(r_iv_get(el, "@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(el, "@x3")),
+          NUM2DBL(r_iv_get(el, "@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(el, "@x4")),
+          NUM2DBL(r_iv_get(el, "@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"))
         );
       }
       break;
       
-      case IMAGE: {
-        if (rb_iv_get(el, "@data") == Qnil) {
-          VALUE data = init_image(RSTRING_PTR(rb_iv_get(el, "@path")));
-          rb_iv_set(el, "@data", data);
-        }
+      case R2D_IMAGE: {
+        S2D_Image *img;
+        r_data_get_struct(el, "@data", &image_data_type, S2D_Image, img);
+        
+        img->x = NUM2DBL(r_iv_get(el, "@x"));
+        img->y = NUM2DBL(r_iv_get(el, "@y"));
+        
+        R_VAL w = r_iv_get(el, "@width");
+        R_VAL h = r_iv_get(el, "@height");
+        if (r_test(w)) img->width  = NUM2INT(w);
+        if (r_test(h)) img->height = NUM2INT(h);
+        
+        R_VAL c = r_iv_get(el, "@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);
+      }
+      break;
+      
+      case R2D_SPRITE: {
+        S2D_Sprite *spr;
+        r_data_get_struct(el, "@data", &sprite_data_type, S2D_Sprite, spr);
         
-        struct image_data *data;
-        Data_Get_Struct(rb_iv_get(el, "@data"), struct image_data, data);
+        spr->x = NUM2DBL(r_iv_get(el, "@x"));
+        spr->y = NUM2DBL(r_iv_get(el, "@y"));
         
-        data->img->x = NUM2DBL(rb_iv_get(el, "@x"));
-        data->img->y = NUM2DBL(rb_iv_get(el, "@y"));
-        S2D_DrawImage(data->img);
+        S2D_ClipSprite(
+          spr,
+          NUM2INT(r_iv_get(el, "@clip_x")),
+          NUM2INT(r_iv_get(el, "@clip_y")),
+          NUM2INT(r_iv_get(el, "@clip_w")),
+          NUM2INT(r_iv_get(el, "@clip_h"))
+        );
+        
+        S2D_DrawSprite(spr);
       }
       break;
       
-      case TEXT: {
-        if (rb_iv_get(el, "@data") == Qnil) {
-          VALUE data = init_text(
-            RSTRING_PTR(rb_iv_get(el, "@font")),
-            RSTRING_PTR(rb_iv_get(el, "@text")),
-            NUM2DBL(rb_iv_get(el, "@size"))
-          );
-          rb_iv_set(el, "@data", data);
-        }
+      case R2D_TEXT: {
+        S2D_Text *txt;
+        r_data_get_struct(el, "@data", &text_data_type, S2D_Text, txt);
+        
+        txt->x = NUM2DBL(r_iv_get(el, "@x"));
+        txt->y = NUM2DBL(r_iv_get(el, "@y"));
         
-        struct text_data *data;
-        Data_Get_Struct(rb_iv_get(el, "@data"), struct text_data, data);
+        R_VAL c = r_iv_get(el, "@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"));
         
-        data->txt->x = NUM2DBL(rb_iv_get(el, "@x"));
-        data->txt->y = NUM2DBL(rb_iv_get(el, "@y"));
-        S2D_DrawText(data->txt);
+        S2D_DrawText(txt);
       }
       break;
     }
@@ -247,43 +642,159 @@ void render() {
 /*
  * Ruby2D::Window#show
  */
-static VALUE ruby2d_show(VALUE s) {
-  self = s;
+#if MRUBY
+static R_VAL ruby2d_show(mrb_state* mrb, R_VAL self) {
+#else
+static R_VAL ruby2d_show(R_VAL self) {
+#endif
+  ruby2d_window = self;
   
-  char *title = RSTRING_PTR(rb_iv_get(self, "@title"));
-  int width   = NUM2INT(rb_iv_get(self, "@width"));
-  int height  = NUM2INT(rb_iv_get(self, "@height"));
+  if (r_test(r_iv_get(self, "@diagnostics"))) {
+    S2D_Diagnostics(true);
+  }
+  
+  // Get window attributes
+  char *title = RSTRING_PTR(r_iv_get(self, "@title"));
+  int width   = NUM2INT(r_iv_get(self, "@width"));
+  int height  = NUM2INT(r_iv_get(self, "@height"));
   int flags   = 0;
   
+  // Get window flags
+  if (r_test(r_iv_get(self, "@resizable"))) {
+    flags = flags | S2D_RESIZABLE;
+  }
+  if (r_test(r_iv_get(self, "@borderless"))) {
+    flags = flags | S2D_BORDERLESS;
+  }
+  if (r_test(r_iv_get(self, "@fullscreen"))) {
+    flags = flags | S2D_FULLSCREEN;
+  }
+  if (r_test(r_iv_get(self, "@highdpi"))) {
+    flags = flags | S2D_HIGHDPI;
+  }
+  
+  // Check viewport size and set
+  
+  R_VAL vp_w = r_iv_get(self, "@viewport_width");
+  int viewport_width = r_test(vp_w) ? NUM2INT(vp_w) : width;
+  
+  R_VAL vp_h = r_iv_get(self, "@viewport_height");
+  int viewport_height = r_test(vp_h) ? NUM2INT(vp_h) : height;
+  
+  // Create and show window
+  
   window = S2D_CreateWindow(
     title, width, height, update, render, flags
   );
   
-  window->on_key = on_key;
-  window->on_key_down = on_key_down;
-  window->on_controller = on_controller;
+  window->viewport.width  = viewport_width;
+  window->viewport.height = viewport_height;
+  window->on_key          = on_key;
+  window->on_mouse        = on_mouse;
+  window->on_controller   = on_controller;
   
   S2D_Show(window);
   
-  atexit(close_window);
-  return Qnil;
+  atexit(free_window);
+  return R_NIL;
+}
+
+
+/*
+ * Ruby2D::Window#close
+ */
+static R_VAL ruby2d_close() {
+  S2D_Close(window);
+  return R_NIL;
 }
 
 
+#if MRUBY
+/*
+ * MRuby entry point
+ */
+int main(void) {
+  // Open the MRuby environment
+  mrb = mrb_open();
+  if (!mrb) { /* handle error */ }
+  
+  // Load the Ruby 2D library
+  mrb_load_irep(mrb, ruby2d_lib);
+#else
 /*
  * Ruby C extension init
  */
 void Init_ruby2d() {
+#endif
   
   // Ruby2D
-  ruby2d_module = rb_define_module("Ruby2D");
+  R_CLASS ruby2d_module = r_define_module("Ruby2D");
+  
+  // Ruby2D::Image
+  R_CLASS ruby2d_image_class = r_define_class(ruby2d_module, "Image");
+  
+  // Ruby2D::Image#init
+  r_define_method(ruby2d_image_class, "init", ruby2d_image_init, r_args_req(1));
+  
+  // Ruby2D::Sprite
+  R_CLASS ruby2d_sprite_class = r_define_class(ruby2d_module, "Sprite");
+  
+  // Ruby2D::Sprite#init
+  r_define_method(ruby2d_sprite_class, "init", ruby2d_sprite_init, r_args_req(1));
+  
+  // Ruby2D::Text
+  R_CLASS ruby2d_text_class = r_define_class(ruby2d_module, "Text");
+  
+  // Ruby2D::Text#init
+  r_define_method(ruby2d_text_class, "init", ruby2d_text_init, r_args_none);
+  
+  // Ruby2D::Text#text=
+  r_define_method(ruby2d_text_class, "text=", ruby2d_text_equals, r_args_req(1));
+  
+  // Ruby2D::Sound
+  R_CLASS ruby2d_sound_class = r_define_class(ruby2d_module, "Sound");
+  
+  // Ruby2D::Sound#init
+  r_define_method(ruby2d_sound_class, "init", ruby2d_sound_init, r_args_req(1));
+  
+  // Ruby2D::Sound#play
+  r_define_method(ruby2d_sound_class, "play", ruby2d_sound_play, r_args_none);
+  
+  // Ruby2D::Music
+  R_CLASS ruby2d_music_class = r_define_class(ruby2d_module, "Music");
+  
+  // Ruby2D::Music#init
+  r_define_method(ruby2d_music_class, "init", ruby2d_music_init, r_args_req(1));
+  
+  // Ruby2D::Music#play
+  r_define_method(ruby2d_music_class, "play", ruby2d_music_play, r_args_none);
+  
+  // Ruby2D::Music#pause
+  r_define_method(ruby2d_music_class, "pause", ruby2d_music_pause, r_args_none);
+  
+  // Ruby2D::Music#resume
+  r_define_method(ruby2d_music_class, "resume", ruby2d_music_resume, r_args_none);
+  
+  // Ruby2D::Music#stop
+  r_define_method(ruby2d_music_class, "stop", ruby2d_music_stop, r_args_none);
+  
+  // Ruby2D::Music#fadeout
+  r_define_method(ruby2d_music_class, "fadeout", ruby2d_music_fadeout, r_args_req(1));
   
   // Ruby2D::Window
-  ruby2d_window_klass = rb_define_class_under(ruby2d_module, "Window", rb_cObject);
+  R_CLASS ruby2d_window_class = r_define_class(ruby2d_module, "Window");
   
   // Ruby2D::Window#show
-  rb_define_method(ruby2d_window_klass, "show", ruby2d_show, 0);
+  r_define_method(ruby2d_window_class, "show", ruby2d_show, r_args_none);
+  
+  // Ruby2D::Window#close
+  r_define_method(ruby2d_window_class, "close", ruby2d_close, r_args_none);
+  
+#if MRUBY
+  // Load the Ruby 2D app
+  mrb_load_irep(mrb, ruby2d_app);
   
-  // Ruby2D::CData
-  c_data_klass = rb_define_class_under(ruby2d_module, "CData", rb_cObject);
+  // Close the MRuby environment
+  mrb_close(mrb);
+#endif
 }