ray 0.0.0.pre1 → 0.0.0.pre2

data/ext/extconf.rb

@@ -29,7 +29,7 @@ def have_framework(name)
     $LDFLAGS << " -F#{File.dirname(ret)}"
     $LDFLAGS << " -framework #{name}"
     $CFLAGS  << " -I#{File.join(ret, "Headers")}"
-    $CFLAGS  << " -DHAVE_FRAMEWORK_#{name.upcase}"
+    $CFLAGS  << " -DHAVE_#{name.upcase}"
   else
     puts "no"
   end
@@ -56,6 +56,10 @@ unless RUBY_PLATFORM =~ /darwin/
     exit 1
   end
 
+  if have_library("SDL_image")
+    have_header("SDL/SDL_image.h") or have_header("SDL_image.h")
+  end
+
   create_makefile("ray_ext")
 
   data = File.read("Makefile").gsub("SDLMain.o", "")
@@ -75,6 +79,8 @@ else
     exit 1
   end
 
+  have_framework("SDL_image")
+
   have_library("ruby", "ruby_init")
 
   create_makefile("ray_ext")

data/ext/image.c

@@ -18,24 +18,7 @@ SDL_Surface *ray_rb2surface(VALUE object) {
    return ray_rb2image(object)->surface;
 }
 
-/*
-  Creates a new image. You must call Ray.create_window before
-  this function.
-
-  @overload initialize(hash)
-    @option hash [Integer] :width Width of the surface
-    @option hash [Integer] :height Height of the surface
-    
-    @option hash [Integer] :w Alias for width
-    @option hash [Integer] :h Alias for height
-
-    @option hash [Integer] :bits_per_pixel See Ray.create_window
-    @option hash [Integer] :pp Alias for bits_per_pixel
-
-    @option hash [true, false] :hw_surface See Ray.create_window
-    @option hash [true, false] :sw_surface See Ray.create_window
- */
-VALUE ray_init_image(VALUE self, VALUE arg) {
+void ray_init_image_with_hash(VALUE self, VALUE arg) {
    VALUE width = rb_hash_aref(arg, RAY_SYM("width"));
    if (NIL_P(width)) width = rb_hash_aref(arg, RAY_SYM("w"));
 
@@ -63,7 +46,59 @@ VALUE ray_init_image(VALUE self, VALUE arg) {
       rb_raise(rb_eRuntimeError, "Could not create the image (%s)",
                SDL_GetError());
    }
+}
+
+void ray_init_image_with_filename(VALUE self, VALUE filename) {
+   char *c_filename = StringValuePtr(filename);
+   ray_image *image = ray_rb2image(self);
+
+#ifdef HAVE_SDL_IMAGE
+   image->surface = IMG_Load(c_filename);
+
+   if (!image->surface) {
+      rb_raise(rb_eRuntimeError, "Could not create the image (%s)",
+               IMG_GetError());
+   }
+#else
+   image->surface = SDL_LoadBMP(c_filename);
    
+   if (!image->surface) {
+      rb_raise(rb_eRuntimeError, "Could not create the image (%s)",
+               SDL_GetError());
+   }
+#endif
+}
+
+/*
+  Creates a new image.
+
+  @overload initialize(hash)
+    @option hash [Integer] :width Width of the surface
+    @option hash [Integer] :height Height of the surface
+    
+    @option hash [Integer] :w Alias for width
+    @option hash [Integer] :h Alias for height
+
+    @option hash [Integer] :bits_per_pixel See Ray.create_window
+    @option hash [Integer] :pp Alias for bits_per_pixel
+
+    @option hash [true, false] :hw_surface See Ray.create_window
+    @option hash [true, false] :sw_surface See Ray.create_window
+
+  @overload initialize(filename)
+    Loads the image from a file.
+    @param [String, #to_str] filename The name of the file to open 
+ */
+VALUE ray_init_image(VALUE self, VALUE arg) {
+   if (RAY_IS_A(arg, rb_cHash))
+      ray_init_image_with_hash(self, arg);
+   else if (rb_respond_to(arg, RAY_METH("to_str")))
+      ray_init_image_with_filename(self, rb_String(arg));
+   else {
+      rb_raise(rb_eTypeError, "Can't convert %s into Hash",
+               RAY_OBJ_CLASSNAME(arg));
+   }
+
    return Qnil;
 }
 
@@ -179,6 +214,40 @@ VALUE ray_image_blit(VALUE self, VALUE hash) {
    return surf;
 }
 
+/*
+  Sets the alpha transparency.
+  @param [Integer, 0..255] alpha the new transparency
+*/
+VALUE ray_image_set_alpha(VALUE self, VALUE alpha) {
+   SDL_SetAlpha(ray_rb2surface(self), SDL_SRCALPHA | SDL_RLEACCEL,
+                NUM2INT(alpha));
+   return alpha;
+}
+
+/*
+  Returns the flags of an image (an OR'd combination of the Ray::Image::FLAG_*
+  constants)
+*/
+VALUE ray_image_flags(VALUE self) {
+   uint32_t flags = ray_rb2surface(self)->flags;
+   return INT2NUM(flags);
+}
+
+/* @return [Integer] Width of the surface */
+VALUE ray_image_width(VALUE self) {
+   return INT2FIX(ray_rb2surface(self)->w);
+}
+
+/* @return [Integer] Height of the surface */
+VALUE ray_image_height(VALUE self) {
+   return INT2FIX(ray_rb2surface(self)->h);
+}
+
+/* @return [Integer] Bits per pixel */
+VALUE ray_image_bpp(VALUE self) {
+   return INT2FIX(ray_rb2surface(self)->format->BitsPerPixel);
+}
+
 void Init_ray_image() {
    ray_cImage = rb_define_class_under(ray_mRay, "Image", rb_cObject);
    
@@ -189,4 +258,27 @@ void Init_ray_image() {
    rb_define_method(ray_cImage, "flip", ray_image_flip, 0);
 
    rb_define_method(ray_cImage, "blit", ray_image_blit, 1);
+
+   rb_define_method(ray_cImage, "alpha=", ray_image_set_alpha, 1);
+
+   rb_define_method(ray_cImage, "flags", ray_image_flags, 0);
+
+   rb_define_method(ray_cImage, "width", ray_image_width, 0);
+   rb_define_method(ray_cImage, "height", ray_image_height, 0);
+   rb_define_method(ray_cImage, "bpp", ray_image_bpp, 0);
+
+   rb_define_const(ray_cImage, "FLAG_ANYFORMAT", INT2FIX(SDL_ANYFORMAT));
+   rb_define_const(ray_cImage, "FLAG_ASYNCBLIT", INT2FIX(SDL_ASYNCBLIT));
+   rb_define_const(ray_cImage, "FLAG_DOUBLEBUF", INT2FIX(SDL_DOUBLEBUF));
+   rb_define_const(ray_cImage, "FLAG_HWPALETTE", INT2FIX(SDL_HWPALETTE));
+   rb_define_const(ray_cImage, "FLAG_HWACCEL", INT2FIX(SDL_HWACCEL));
+   rb_define_const(ray_cImage, "FLAG_HWSURFACE", INT2FIX(SDL_HWSURFACE));
+   rb_define_const(ray_cImage, "FLAG_FULLSCREEN", INT2FIX(SDL_FULLSCREEN));
+   rb_define_const(ray_cImage, "FLAG_OPENGL", INT2FIX(SDL_OPENGL));
+   rb_define_const(ray_cImage, "FLAG_OPENGLBLIT", INT2FIX(SDL_OPENGLBLIT));
+   rb_define_const(ray_cImage, "FLAG_RESIZABLE", INT2FIX(SDL_RESIZABLE));
+   rb_define_const(ray_cImage, "FLAG_RLEACCEL", INT2FIX(SDL_RLEACCEL));
+   rb_define_const(ray_cImage, "FLAG_SRCALPHA", INT2FIX(SDL_SRCALPHA));
+   rb_define_const(ray_cImage, "FLAG_SRCCOLORKEY", INT2FIX(SDL_SRCCOLORKEY));
+   rb_define_const(ray_cImage, "FLAG_PREALLOC", INT2FIX(SDL_PREALLOC));
 }

data/ext/joystick.c

@@ -0,0 +1,145 @@
+#include "ray.h"
+
+VALUE ray_cJoystick = Qnil;
+
+SDL_Joystick *ray_rb2joystick(VALUE object) {
+   if (!RAY_IS_A(object, ray_cJoystick)) {
+      rb_raise(rb_eTypeError, "Can't convert %s into Ray::Joystick",
+               RAY_OBJ_CLASSNAME(object));
+   }
+
+   ray_joystick *joy = NULL;
+   Data_Get_Struct(object, ray_joystick, joy);
+
+   if (!joy->joystick)
+      rb_raise(rb_eRuntimeError, "Trying to get a joystick that is not opened.");
+
+   return joy->joystick;
+}
+
+void ray_free_joystick(ray_joystick *ptr) {
+   if (ptr->joystick) SDL_JoystickClose(ptr->joystick);
+   free(ptr);
+}
+
+VALUE ray_alloc_joystick(VALUE self) {
+   ray_joystick *ptr = malloc(sizeof(ray_joystick));
+   ptr->joystick = NULL;
+   
+   return Data_Wrap_Struct(self, NULL, ray_free_joystick, ptr);
+}
+
+/*
+  Creates a new joystick, and open it. You don't need to close it explictly,
+  although doing multiple call to 
+  @param [Integer] stick_id Identifier for this stick. Should be smaller
+                            than Ray::Joystick.count.
+*/
+VALUE ray_init_joystick(VALUE self, VALUE stick_id) {
+   rb_iv_set(self, "@id", stick_id);
+   rb_funcall2(self, RAY_METH("open"), 0, NULL);
+   return Qnil;
+}
+
+/* @return [Integer] the number of joysticks available */
+VALUE ray_joystick_count(VALUE self) {
+   return INT2FIX(SDL_NumJoysticks());
+}
+
+/*
+  @return [true, false] True if events coming from the joystick are handled.
+*/
+VALUE ray_joystick_handle_event(VALUE self) {
+   return SDL_JoystickEventState(SDL_QUERY) ? Qtrue : Qfalse; 
+}
+
+/*
+  Sets whether we should handle events coming from the joystick.
+ */
+VALUE ray_joystick_set_handle_event(VALUE self, VALUE val) {
+   SDL_JoystickEventState(RTEST(val) ? SDL_ENABLE : SDL_DISABLE);
+   return val;
+}
+
+/* Opens the joystick */
+VALUE ray_joystick_open(VALUE self) {
+   int id = NUM2INT(rb_iv_get(self, "@id"));
+   SDL_Joystick *ptr = SDL_JoystickOpen(id);
+
+   if (!ptr) {
+      rb_raise(rb_eArgError, "Failled to open joystick %d (%s)",
+               id, SDL_GetError());
+   }
+
+   ray_joystick *joy = NULL;
+   Data_Get_Struct(self, ray_joystick, joy);
+
+   joy->joystick = ptr;
+
+   return self;
+}
+
+/* Closes the joystick. Can be called even if closed? is true. */
+VALUE ray_joystick_close(VALUE self) {
+   if (ray_joystick_close(self) == Qtrue)
+      return Qnil;
+
+   SDL_JoystickClose(ray_rb2joystick(self));
+
+   ray_joystick *joy = NULL;
+   Data_Get_Struct(self, ray_joystick, joy);
+
+   joy->joystick = NULL;
+   
+   return Qnil;
+}
+
+/* @return [true, false] true if the joystick is closed */ 
+VALUE ray_joystick_closed(VALUE self) {
+   ray_joystick *joy = NULL;
+   Data_Get_Struct(self, ray_joystick, joy);
+   
+   return joy->joystick == NULL ? Qtrue : Qfalse;
+}
+
+/* @return [Integer] The number of buttons on this joystick */
+VALUE ray_joystick_button_count(VALUE self) {
+   return INT2FIX(SDL_JoystickNumButtons(ray_rb2joystick(self)));
+}
+
+/* @return [Integer] The number of axes on this joystick */
+VALUE ray_joystick_axe_count(VALUE self) {
+   return INT2FIX(SDL_JoystickNumAxes(ray_rb2joystick(self)));
+}
+
+/* @return [Integer] The number of trackballs on this joystick */
+VALUE ray_joystick_ball_count(VALUE self) {
+   return INT2FIX(SDL_JoystickNumBalls(ray_rb2joystick(self)));
+}
+
+/* @return [Integer] The number of hats on this joystick */
+VALUE ray_joystick_hat_count(VALUE self) {
+   return INT2FIX(SDL_JoystickNumHats(ray_rb2joystick(self)));
+}
+
+void Init_ray_joystick() {
+   ray_cJoystick = rb_define_class_under(ray_mRay, "Joystick", rb_cObject);
+   rb_define_alloc_func(ray_cJoystick, ray_alloc_joystick);
+   rb_define_method(ray_cJoystick, "initialize", ray_init_joystick, 1);
+
+   rb_define_module_function(ray_cJoystick, "count", ray_joystick_count, 0);
+
+   rb_define_module_function(ray_cJoystick, "handle_event=",
+                             ray_joystick_set_handle_event, 1);
+   rb_define_module_function(ray_cJoystick, "handle_event",
+                             ray_joystick_handle_event, 0);
+
+   rb_define_method(ray_cJoystick, "open", ray_joystick_open, 0);
+   rb_define_method(ray_cJoystick, "close", ray_joystick_close, 0);
+   rb_define_method(ray_cJoystick, "closed?", ray_joystick_closed, 0);
+   
+   rb_define_method(ray_cJoystick, "button_count", ray_joystick_button_count, 0);
+   rb_define_method(ray_cJoystick, "axe_count", ray_joystick_axe_count, 0);
+   rb_define_method(ray_cJoystick, "hat_count", ray_joystick_hat_count, 0);
+   rb_define_method(ray_cJoystick, "ball_count", ray_joystick_ball_count, 0);
+}

data/ext/ray.c

@@ -4,7 +4,7 @@ VALUE ray_mRay = Qnil;
 
 /* Inits ray */
 VALUE ray_init(VALUE self) {
-   SDL_Init(SDL_INIT_VIDEO);
+   SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK);
    return Qnil;
 }
 
@@ -14,6 +14,54 @@ VALUE ray_stop(VALUE self) {
    return Qnil;
 }
 
+ray_video_mode ray_parse_video_mode(VALUE hash) {
+   VALUE width  = rb_hash_aref(hash, RAY_SYM("width"));
+   VALUE height = rb_hash_aref(hash, RAY_SYM("height"));
+
+   if (NIL_P(width))  width  = rb_hash_aref(hash, RAY_SYM("w"));
+   if (NIL_P(height)) height = rb_hash_aref(hash, RAY_SYM("h"));
+
+   if (NIL_P(width) || NIL_P(height))
+      rb_raise(rb_eArgError, "Missing parameter: width or height");
+
+   VALUE bitsperpixel = rb_hash_aref(hash, RAY_SYM("bits_per_pixel"));
+   if (NIL_P(bitsperpixel)) bitsperpixel = rb_hash_aref(hash, RAY_SYM("bpp"));
+
+   if (NIL_P(bitsperpixel))
+      bitsperpixel = INT2FIX(32);
+
+   uint32_t flags = 0;
+   if (RTEST(rb_hash_aref(hash, RAY_SYM("sw_surface"))))
+      flags |= SDL_SWSURFACE;
+   else
+      flags |= SDL_HWSURFACE; /* even if hwsurface was false and not nil */
+
+   if (RTEST(rb_hash_aref(hash, RAY_SYM("async_blit"))))
+      flags |= SDL_ASYNCBLIT;
+
+   if (!(flags & SDL_SWSURFACE) &&
+       RTEST(rb_hash_aref(hash, RAY_SYM("double_buf")))) {
+      flags |= SDL_DOUBLEBUF;
+   }
+
+   if (RTEST(rb_hash_aref(hash, RAY_SYM("fullscreen"))))
+      flags |= SDL_FULLSCREEN;
+
+   if (RTEST(rb_hash_aref(hash, RAY_SYM("no_frame"))))
+      flags |= SDL_NOFRAME;
+
+   ray_video_mode mode = {
+      NUM2INT(width),
+      NUM2INT(height),
+
+      NUM2INT(bitsperpixel),
+
+      flags
+   };
+
+   return mode;
+}
+
 /*
   Creates a new window.
 
@@ -46,51 +94,114 @@ VALUE ray_stop(VALUE self) {
                                          possible.
  */
 VALUE ray_create_window(VALUE self, VALUE hash) {
-   VALUE width  = rb_hash_aref(hash, RAY_SYM("width"));
-   VALUE height = rb_hash_aref(hash, RAY_SYM("height"));
+   ray_video_mode mode = ray_parse_video_mode(hash);
+   SDL_Surface *screen = SDL_SetVideoMode(mode.width, mode.height,
+                                          mode.bpp, mode.flags);
+   
+   if (!screen) {
+      rb_raise(rb_eRuntimeError, "Could not create the window (%s)",
+               SDL_GetError());
+   }
 
-   if (NIL_P(width))  width  = rb_hash_aref(hash, RAY_SYM("h"));
-   if (NIL_P(height)) height = rb_hash_aref(hash, RAY_SYM("w"));
+   return ray_create_image(screen);
+}
 
-   if (NIL_P(width) || NIL_P(height))
-      rb_raise(rb_eArgError, "Missing parameter: width or height");
+/*
+  @return [true, false] True if the video mode described by hash
+                        can be used.
+*/
+VALUE ray_can_use_mode(VALUE self, VALUE hash) {
+   ray_video_mode mode = ray_parse_video_mode(hash);
+   
+   int res = SDL_VideoModeOK(mode.width, mode.height, mode.bpp, mode.flags);
+   return res ? Qtrue : Qfalse;
+}
 
-   VALUE bitsperpixel = rb_hash_aref(hash, RAY_SYM("bits_per_pixel"));
-   if (NIL_P(bitsperpixel)) bitsperpixel = rb_hash_aref(hash, RAY_SYM("bpp"));
+/*
+  Sets the window icon
+  @param [Ray::Image] icon The icon to display
+*/
+VALUE ray_set_icon(VALUE self, VALUE icon) {
+   SDL_WM_SetIcon(ray_rb2surface(icon), NULL);
+   return icon;
+}
 
-   if (NIL_P(bitsperpixel))
-      bitsperpixel = INT2FIX(32);
+/* @return [String, nil] The window title */
+VALUE ray_window_title(VALUE self) {
+   char *title = NULL;
+   SDL_WM_GetCaption(&title, NULL);
 
-   uint32_t flags = 0;
-   if (RTEST(rb_hash_aref(hash, RAY_SYM("sw_surface"))))
-      flags |= SDL_SWSURFACE;
-   else
-      flags |= SDL_HWSURFACE; /* even if hwsurface was false and not nil */
+   if (!title)
+      return Qnil;
+   return rb_str_new2(title);
+}
 
-   if (RTEST(rb_hash_aref(hash, RAY_SYM("async_blit"))))
-      flags |= SDL_ASYNCBLIT;
+/* Sets the window title */
+VALUE ray_set_window_title(VALUE self, VALUE title) {
+   char *icon = NULL;
 
-   if (!(flags & SDL_SWSURFACE) &&
-       RTEST(rb_hash_aref(hash, RAY_SYM("double_buf")))) {
-      flags |= SDL_DOUBLEBUF;
-   }
+   if (!NIL_P(title)) title = rb_String(title);
 
-   if (RTEST(rb_hash_aref(hash, RAY_SYM("fullscreen"))))
-      flags |= SDL_FULLSCREEN;
+   SDL_WM_GetCaption(NULL, &icon);
+   SDL_WM_SetCaption(NIL_P(title) ? NULL : StringValuePtr(title), icon);
 
-   if (RTEST(rb_hash_aref(hash, RAY_SYM("no_frame"))))
-      flags |= SDL_NOFRAME;
+   return title;
+}
 
-   SDL_Surface *screen = SDL_SetVideoMode(NUM2INT(width),
-                                          NUM2INT(height),
-                                          NUM2INT(bitsperpixel),
-                                          flags);
-   if (!screen) {
-      rb_raise(rb_eRuntimeError, "Could not create the window (%s)",
-               SDL_GetError());
-   }
+/* @return [String, nil] The window text icon */
+VALUE ray_text_icon(VALUE self) {
+   char *icon = NULL;
+   SDL_WM_GetCaption(NULL, &icon);
 
-   return ray_create_image(screen);
+   if (!icon)
+      return Qnil;
+   return rb_str_new2(icon);   
+}
+
+/* Sets the window title */
+VALUE ray_set_text_icon(VALUE self, VALUE icon) {
+   char *title;
+   
+   if (!NIL_P(icon)) icon = rb_String(icon);
+
+   SDL_WM_GetCaption(&title, NULL);
+   SDL_WM_SetCaption(title, NIL_P(icon) ? NULL : StringValuePtr(icon));
+
+   return icon;
+}
+
+/*
+  @return [true, false] True if the input is grabbed, which means the mouse
+                        is confined in the window, and keyboard input is sent
+                        directly to the window.
+*/
+VALUE ray_grab_input(VALUE self) {
+   SDL_GrabMode mode = SDL_WM_GrabInput(SDL_GRAB_QUERY);
+   return (mode == SDL_GRAB_ON) ? Qtrue : Qfalse;
+}
+
+/* Sets the grab input to true or false */
+VALUE ray_set_grab_input(VALUE self, VALUE grab) {
+   SDL_WM_GrabInput(RTEST(grab) ? SDL_GRAB_ON : SDL_GRAB_OFF);
+   return grab;
+}
+
+/* @return [Ray::Image, nil] The current screen, created by create_window */
+VALUE ray_screen(VALUE self) {
+   SDL_Surface *surf = SDL_GetVideoSurface();
+   
+   if (!surf)
+      return Qnil;
+   return ray_create_image(surf);
+}
+
+/* @return [true, false] true if Ray supports other image formats than BMP */
+VALUE ray_has_image_support(VALUE self) {
+#ifdef HAVE_SDL_IMAGE
+   return Qtrue;
+#else
+   return Qfalse;
+#endif
 }
 
 void Init_ray_ext() {
@@ -98,13 +209,38 @@ void Init_ray_ext() {
 
    rb_define_module_function(ray_mRay, "init", ray_init, 0);
    rb_define_module_function(ray_mRay, "stop", ray_stop, 0);
+
    rb_define_module_function(ray_mRay, "create_window", ray_create_window, 1);
+   rb_define_module_function(ray_mRay, "can_use_mode?", ray_can_use_mode, 1);
+   rb_define_module_function(ray_mRay, "screen", ray_screen, 0);
+   
+   rb_define_module_function(ray_mRay, "icon=", ray_set_icon, 1);
+   rb_define_module_function(ray_mRay, "window_title=", ray_set_window_title,
+                             1);
+   rb_define_module_function(ray_mRay, "text_icon=", ray_set_text_icon, 1);
+
+   rb_define_module_function(ray_mRay, "window_title", ray_window_title, 0);
+   rb_define_module_function(ray_mRay, "text_icon", ray_text_icon, 0);
+
+   rb_define_module_function(ray_mRay, "grab_input", ray_grab_input, 0);
+   rb_define_module_function(ray_mRay, "grab_input=", ray_set_grab_input, 1);
+
+   rb_define_module_function(ray_mRay, "has_image_support?",
+                             ray_has_image_support, 0);
 
    Init_ray_image();
    Init_ray_color();
    Init_ray_rect();
+   Init_ray_event();
+   Init_ray_joystick();
+
+#ifdef PSP
+   Init_ray_psp();
+#endif
 }
 
+#ifndef PSP
+
 int main(int argc, char *argv[]) {
 #if defined(HAVE_RUBY_RUN_NODE)
    ruby_init();
@@ -123,3 +259,120 @@ int main(int argc, char *argv[]) {
 
    return 0;
 }
+
+#endif
+
+#ifdef PSP
+
+PSP_MAIN_THREAD_ATTR(THREAD_ATTR_USER | THREAD_ATTR_VFPU);
+PSP_HEAP_SIZE_KB(-512);
+
+#include <unistd.h>
+
+#define RGB(r, g, b) ((r) | ((g)<<8) | ((b)<<16) | (0xff<<24))
+
+VALUE ray_safe_load(VALUE self) {
+   return rb_require("./script.rb");
+}
+
+int SDL_main(int argc, char *argv[]) {
+   ruby_init();
+
+   ruby_incpush("./ruby/1.8");
+   ruby_incpush("./ruby/site_ruby");
+   ruby_incpush("./ruby/site_ruby/1.8");
+
+   ruby_incpush("ms0:/ruby/1.8");
+   ruby_incpush("ms0:/ruby/site_ruby");
+   ruby_incpush("ms0:/ruby/site_ruby/1.8");
+
+   ruby_incpush(".");
+   
+   ruby_script("ray");
+
+   Init_ray_ext();
+
+   int error = 0;
+   VALUE res = rb_protect(ray_safe_load, 0, &error);
+
+   if (error != 0) {
+      pspDebugScreenInit();
+
+      pspDebugScreenSetBackColor(RGB(0, 0, 0));
+      pspDebugScreenEnableBackColor(1);
+
+      pspDebugScreenClear();
+      pspDebugScreenSetXY(0, 0);
+
+      pspDebugScreenSetTextColor(RGB(255, 0, 0));
+      pspDebugScreenPrintf("Ray - error manager\n\n\n");
+      pspDebugScreenSetTextColor(RGB(255, 255, 255));
+
+      pspDebugScreenPrintf("This is Ray's error manager.An exception ");
+      pspDebugScreenPrintf("has been thrown, and the script ");
+      pspDebugScreenPrintf("cannot be run. If you're the developper of");
+      pspDebugScreenPrintf(" this application,\ncheck yout script.");
+      pspDebugScreenPrintf(" If it seems fine to you, consider ");
+      pspDebugScreenPrintf("filling a bug report.\n");
+      pspDebugScreenPrintf("If you're not the developper, consider");
+      pspDebugScreenPrintf(" contacting him.\n\n\n");
+
+      pspDebugScreenSetTextColor(RGB(255, 0, 0));
+      pspDebugScreenPrintf("Errors informations :\n\n\n");
+      pspDebugScreenSetTextColor(RGB(255, 255, 255));
+
+      // Now, we get the error.
+      VALUE error = rb_gv_get("$!");
+
+      // And the information we want to have about it.
+      VALUE backtrace = rb_funcall(error, RAY_METH("backtrace"), 0);
+      VALUE type      = rb_funcall(error, RAY_METH("class"), 0);
+      VALUE msg       = rb_funcall(error, RAY_METH("message"), 0);
+
+      type = rb_funcall(type, RAY_METH("to_s"), 0);
+
+      VALUE first = rb_ary_entry(backtrace, 0);
+
+      FILE *log = fopen("ray-error.log", "w");
+      if (!log) {
+         sceKernelExitGame();
+         return 1;
+      }
+
+      pspDebugScreenPrintf("%s: %s: %s\n", StringValuePtr(first),
+                                           StringValuePtr(type),
+                                           StringValuePtr(msg));
+      fprintf(log, "%s: %s: %s\n", StringValuePtr(first), StringValuePtr(type),
+              StringValuePtr(msg));
+
+      int i = 1;
+      for (i = 1; i < RARRAY_LEN(backtrace); ++i) {
+         VALUE entry = rb_ary_entry(backtrace, i);
+         pspDebugScreenPrintf("%s\n", StringValuePtr(entry));
+         fprintf(log, "%s\n", StringValuePtr(entry));
+      }
+
+      fclose(log);
+
+      pspDebugScreenPrintf("\nThese informations can be found in ");
+      pspDebugScreenPrintf("ray-error.log\n\n");
+
+      pspDebugScreenPrintf("Press X to quit.");
+
+      SceCtrlData pad;
+
+      sceCtrlSetSamplingCycle(0);
+      sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
+      sceCtrlReadBufferPositive(&pad, 1);
+
+      while (!(pad.Buttons & PSP_CTRL_CROSS))
+         sceCtrlReadBufferPositive(&pad, 1);
+
+      sceKernelExitGame();
+      return 0;
+   }
+
+   return res;
+}
+
+#endif