ruby2d 0.9.4 → 0.9.5

data/{assets/include/simple2d.h → ext/ruby2d/ruby2d.h}

@@ -1,4 +1,4 @@
-// simple2d.h
+// ruby2d.h
 
 #ifdef __cplusplus
 extern "C" {
@@ -101,93 +101,93 @@ extern "C" {
   #include <SDL2/SDL_ttf.h>
 #endif
 
-// Simple 2D Definitions ///////////////////////////////////////////////////////
+// Ruby 2D Definitions /////////////////////////////////////////////////////////
 
 // Messages
-#define S2D_INFO  1
-#define S2D_WARN  2
-#define S2D_ERROR 3
+#define R2D_INFO  1
+#define R2D_WARN  2
+#define R2D_ERROR 3
 
 // Window attributes
-#define S2D_RESIZABLE  SDL_WINDOW_RESIZABLE
-#define S2D_BORDERLESS SDL_WINDOW_BORDERLESS
-#define S2D_FULLSCREEN SDL_WINDOW_FULLSCREEN_DESKTOP
-#define S2D_HIGHDPI    SDL_WINDOW_ALLOW_HIGHDPI
-#define S2D_DISPLAY_WIDTH  0
-#define S2D_DISPLAY_HEIGHT 0
+#define R2D_RESIZABLE  SDL_WINDOW_RESIZABLE
+#define R2D_BORDERLESS SDL_WINDOW_BORDERLESS
+#define R2D_FULLSCREEN SDL_WINDOW_FULLSCREEN_DESKTOP
+#define R2D_HIGHDPI    SDL_WINDOW_ALLOW_HIGHDPI
+#define R2D_DISPLAY_WIDTH  0
+#define R2D_DISPLAY_HEIGHT 0
 
 // Viewport scaling modes
-#define S2D_FIXED   1
-#define S2D_EXPAND  2
-#define S2D_SCALE   3
-#define S2D_STRETCH 4
+#define R2D_FIXED   1
+#define R2D_EXPAND  2
+#define R2D_SCALE   3
+#define R2D_STRETCH 4
 
 // Positions
-#define S2D_CENTER       1
-#define S2D_TOP_LEFT     2
-#define S2D_TOP_RIGHT    3
-#define S2D_BOTTOM_LEFT  4
-#define S2D_BOTTOM_RIGHT 5
+#define R2D_CENTER       1
+#define R2D_TOP_LEFT     2
+#define R2D_TOP_RIGHT    3
+#define R2D_BOTTOM_LEFT  4
+#define R2D_BOTTOM_RIGHT 5
 
 // Keyboard events
-#define S2D_KEY_DOWN 1  // key is pressed
-#define S2D_KEY_HELD 2  // key is held down
-#define S2D_KEY_UP   3  // key is released
+#define R2D_KEY_DOWN 1  // key is pressed
+#define R2D_KEY_HELD 2  // key is held down
+#define R2D_KEY_UP   3  // key is released
 
 // Mouse events
-#define S2D_MOUSE_DOWN   1  // mouse button pressed
-#define S2D_MOUSE_UP     2  // mouse button released
-#define S2D_MOUSE_SCROLL 3  // mouse scrolling or wheel movement
-#define S2D_MOUSE_MOVE   4  // mouse movement
-#define S2D_MOUSE_LEFT   SDL_BUTTON_LEFT
-#define S2D_MOUSE_MIDDLE SDL_BUTTON_MIDDLE
-#define S2D_MOUSE_RIGHT  SDL_BUTTON_RIGHT
-#define S2D_MOUSE_X1     SDL_BUTTON_X1
-#define S2D_MOUSE_X2     SDL_BUTTON_X2
-#define S2D_MOUSE_SCROLL_NORMAL   SDL_MOUSEWHEEL_NORMAL
-#define S2D_MOUSE_SCROLL_INVERTED SDL_MOUSEWHEEL_FLIPPED
+#define R2D_MOUSE_DOWN   1  // mouse button pressed
+#define R2D_MOUSE_UP     2  // mouse button released
+#define R2D_MOUSE_SCROLL 3  // mouse scrolling or wheel movement
+#define R2D_MOUSE_MOVE   4  // mouse movement
+#define R2D_MOUSE_LEFT   SDL_BUTTON_LEFT
+#define R2D_MOUSE_MIDDLE SDL_BUTTON_MIDDLE
+#define R2D_MOUSE_RIGHT  SDL_BUTTON_RIGHT
+#define R2D_MOUSE_X1     SDL_BUTTON_X1
+#define R2D_MOUSE_X2     SDL_BUTTON_X2
+#define R2D_MOUSE_SCROLL_NORMAL   SDL_MOUSEWHEEL_NORMAL
+#define R2D_MOUSE_SCROLL_INVERTED SDL_MOUSEWHEEL_FLIPPED
 
 // Controller events
-#define S2D_AXIS        1
-#define S2D_BUTTON_DOWN 2
-#define S2D_BUTTON_UP   3
+#define R2D_AXIS        1
+#define R2D_BUTTON_DOWN 2
+#define R2D_BUTTON_UP   3
 
 // Controller axis labels
-#define S2D_AXIS_INVALID      SDL_CONTROLLER_AXIS_INVALID
-#define S2D_AXIS_LEFTX        SDL_CONTROLLER_AXIS_LEFTX
-#define S2D_AXIS_LEFTY        SDL_CONTROLLER_AXIS_LEFTY
-#define S2D_AXIS_RIGHTX       SDL_CONTROLLER_AXIS_RIGHTX
-#define S2D_AXIS_RIGHTY       SDL_CONTROLLER_AXIS_RIGHTY
-#define S2D_AXIS_TRIGGERLEFT  SDL_CONTROLLER_AXIS_TRIGGERLEFT
-#define S2D_AXIS_TRIGGERRIGHT SDL_CONTROLLER_AXIS_TRIGGERRIGHT
-#define S2D_AXIS_MAX          SDL_CONTROLLER_AXIS_MAX
+#define R2D_AXIS_INVALID      SDL_CONTROLLER_AXIS_INVALID
+#define R2D_AXIS_LEFTX        SDL_CONTROLLER_AXIS_LEFTX
+#define R2D_AXIS_LEFTY        SDL_CONTROLLER_AXIS_LEFTY
+#define R2D_AXIS_RIGHTX       SDL_CONTROLLER_AXIS_RIGHTX
+#define R2D_AXIS_RIGHTY       SDL_CONTROLLER_AXIS_RIGHTY
+#define R2D_AXIS_TRIGGERLEFT  SDL_CONTROLLER_AXIS_TRIGGERLEFT
+#define R2D_AXIS_TRIGGERRIGHT SDL_CONTROLLER_AXIS_TRIGGERRIGHT
+#define R2D_AXIS_MAX          SDL_CONTROLLER_AXIS_MAX
 
 // Controller button labels
-#define S2D_BUTTON_INVALID       SDL_CONTROLLER_BUTTON_INVALID
-#define S2D_BUTTON_A             SDL_CONTROLLER_BUTTON_A
-#define S2D_BUTTON_B             SDL_CONTROLLER_BUTTON_B
-#define S2D_BUTTON_X             SDL_CONTROLLER_BUTTON_X
-#define S2D_BUTTON_Y             SDL_CONTROLLER_BUTTON_Y
-#define S2D_BUTTON_BACK          SDL_CONTROLLER_BUTTON_BACK
-#define S2D_BUTTON_GUIDE         SDL_CONTROLLER_BUTTON_GUIDE
-#define S2D_BUTTON_START         SDL_CONTROLLER_BUTTON_START
-#define S2D_BUTTON_LEFTSTICK     SDL_CONTROLLER_BUTTON_LEFTSTICK
-#define S2D_BUTTON_RIGHTSTICK    SDL_CONTROLLER_BUTTON_RIGHTSTICK
-#define S2D_BUTTON_LEFTSHOULDER  SDL_CONTROLLER_BUTTON_LEFTSHOULDER
-#define S2D_BUTTON_RIGHTSHOULDER SDL_CONTROLLER_BUTTON_RIGHTSHOULDER
-#define S2D_BUTTON_DPAD_UP       SDL_CONTROLLER_BUTTON_DPAD_UP
-#define S2D_BUTTON_DPAD_DOWN     SDL_CONTROLLER_BUTTON_DPAD_DOWN
-#define S2D_BUTTON_DPAD_LEFT     SDL_CONTROLLER_BUTTON_DPAD_LEFT
-#define S2D_BUTTON_DPAD_RIGHT    SDL_CONTROLLER_BUTTON_DPAD_RIGHT
-#define S2D_BUTTON_MAX           SDL_CONTROLLER_BUTTON_MAX
+#define R2D_BUTTON_INVALID       SDL_CONTROLLER_BUTTON_INVALID
+#define R2D_BUTTON_A             SDL_CONTROLLER_BUTTON_A
+#define R2D_BUTTON_B             SDL_CONTROLLER_BUTTON_B
+#define R2D_BUTTON_X             SDL_CONTROLLER_BUTTON_X
+#define R2D_BUTTON_Y             SDL_CONTROLLER_BUTTON_Y
+#define R2D_BUTTON_BACK          SDL_CONTROLLER_BUTTON_BACK
+#define R2D_BUTTON_GUIDE         SDL_CONTROLLER_BUTTON_GUIDE
+#define R2D_BUTTON_START         SDL_CONTROLLER_BUTTON_START
+#define R2D_BUTTON_LEFTSTICK     SDL_CONTROLLER_BUTTON_LEFTSTICK
+#define R2D_BUTTON_RIGHTSTICK    SDL_CONTROLLER_BUTTON_RIGHTSTICK
+#define R2D_BUTTON_LEFTSHOULDER  SDL_CONTROLLER_BUTTON_LEFTSHOULDER
+#define R2D_BUTTON_RIGHTSHOULDER SDL_CONTROLLER_BUTTON_RIGHTSHOULDER
+#define R2D_BUTTON_DPAD_UP       SDL_CONTROLLER_BUTTON_DPAD_UP
+#define R2D_BUTTON_DPAD_DOWN     SDL_CONTROLLER_BUTTON_DPAD_DOWN
+#define R2D_BUTTON_DPAD_LEFT     SDL_CONTROLLER_BUTTON_DPAD_LEFT
+#define R2D_BUTTON_DPAD_RIGHT    SDL_CONTROLLER_BUTTON_DPAD_RIGHT
+#define R2D_BUTTON_MAX           SDL_CONTROLLER_BUTTON_MAX
 
 // Internal Shared Data ////////////////////////////////////////////////////////
 
-extern bool S2D_diagnostics;  // flag for whether to print diagnostics with S2D_Log
+extern bool R2D_diagnostics;  // flag for whether to print diagnostics with R2D_Log
 
 // Type Definitions ////////////////////////////////////////////////////////////
 
-// S2D_Event
+// R2D_Event
 typedef struct {
   int which;
   int type;
@@ -201,68 +201,68 @@ typedef struct {
   int direction;
   int axis;
   int value;
-} S2D_Event;
+} R2D_Event;
 
-typedef void (*S2D_Update)();
-typedef void (*S2D_Render)();
-typedef void (*S2D_On_Key)(S2D_Event e);
-typedef void (*S2D_On_Mouse)(S2D_Event e);
-typedef void (*S2D_On_Controller)(S2D_Event e);
+typedef void (*R2D_Update)();
+typedef void (*R2D_Render)();
+typedef void (*R2D_On_Key)(R2D_Event e);
+typedef void (*R2D_On_Mouse)(R2D_Event e);
+typedef void (*R2D_On_Controller)(R2D_Event e);
 
-// S2D_GL_Point, for graphics calculations
+// R2D_GL_Point, for graphics calculations
 typedef struct {
   GLfloat x;
   GLfloat y;
-} S2D_GL_Point;
+} R2D_GL_Point;
 
-// S2D_Color
+// R2D_Color
 typedef struct {
   GLfloat r;
   GLfloat g;
   GLfloat b;
   GLfloat a;
-} S2D_Color;
+} R2D_Color;
 
-// S2D_Mouse
+// R2D_Mouse
 typedef struct {
   int visible;
   int x;
   int y;
-} S2D_Mouse;
+} R2D_Mouse;
 
-// S2D_Viewport
+// R2D_Viewport
 typedef struct {
   int width;
   int height;
   int mode;
-} S2D_Viewport;
+} R2D_Viewport;
 
-// S2D_Window
+// R2D_Window
 typedef struct {
   SDL_Window *sdl;
   SDL_GLContext glcontext;
-  const GLubyte *S2D_GL_VENDOR;
-  const GLubyte *S2D_GL_RENDERER;
-  const GLubyte *S2D_GL_VERSION;
-  GLint S2D_GL_MAJOR_VERSION;
-  GLint S2D_GL_MINOR_VERSION;
-  const GLubyte *S2D_GL_SHADING_LANGUAGE_VERSION;
+  const GLubyte *R2D_GL_VENDOR;
+  const GLubyte *R2D_GL_RENDERER;
+  const GLubyte *R2D_GL_VERSION;
+  GLint R2D_GL_MAJOR_VERSION;
+  GLint R2D_GL_MINOR_VERSION;
+  const GLubyte *R2D_GL_SHADING_LANGUAGE_VERSION;
   const char *title;
   int width;
   int height;
   int orig_width;
   int orig_height;
-  S2D_Viewport viewport;
-  S2D_Update update;
-  S2D_Render render;
+  R2D_Viewport viewport;
+  R2D_Update update;
+  R2D_Render render;
   int flags;
-  S2D_Mouse mouse;
-  S2D_On_Key on_key;
-  S2D_On_Mouse on_mouse;
-  S2D_On_Controller on_controller;
+  R2D_Mouse mouse;
+  R2D_On_Key on_key;
+  R2D_On_Mouse on_mouse;
+  R2D_On_Controller on_controller;
   bool vsync;
   int fps_cap;
-  S2D_Color background;
+  R2D_Color background;
   const char *icon;
   Uint32 frames;
   Uint32 elapsed_ms;
@@ -270,15 +270,15 @@ typedef struct {
   Uint32 delay_ms;
   double fps;
   bool close;
-} S2D_Window;
+} R2D_Window;
 
-// S2D_Image
+// R2D_Image
 typedef struct {
   const char *path;
   SDL_Surface *surface;
   int format;
   GLuint texture_id;
-  S2D_Color color;
+  R2D_Color color;
   int x;
   int y;
   int width;
@@ -288,13 +288,13 @@ typedef struct {
   GLfloat rotate;  // Rotation angle in degrees
   GLfloat rx;      // X coordinate to be rotated around
   GLfloat ry;      // Y coordinate to be rotated around
-} S2D_Image;
+} R2D_Image;
 
-// S2D_Sprite
+// R2D_Sprite
 typedef struct {
   const char *path;
-  S2D_Image *img;
-  S2D_Color color;
+  R2D_Image *img;
+  R2D_Color color;
   int x;
   int y;
   int width;
@@ -312,15 +312,15 @@ typedef struct {
   GLfloat ty3;
   GLfloat tx4;
   GLfloat ty4;
-} S2D_Sprite;
+} R2D_Sprite;
 
-// S2D_Text
+// R2D_Text
 typedef struct {
   const char *font;
   SDL_Surface *surface;
   GLuint texture_id;
   TTF_Font *font_data;
-  S2D_Color color;
+  R2D_Color color;
   char *msg;
   int x;
   int y;
@@ -329,61 +329,61 @@ typedef struct {
   GLfloat rotate;  // Rotation angle in degrees
   GLfloat rx;      // X coordinate to be rotated around
   GLfloat ry;      // Y coordinate to be rotated around
-} S2D_Text;
+} R2D_Text;
 
-// S2D_Sound
+// R2D_Sound
 typedef struct {
   const char *path;
   Mix_Chunk *data;
-} S2D_Sound;
+} R2D_Sound;
 
-// S2D_Music
+// R2D_Music
 typedef struct {
   const char *path;
   Mix_Music *data;
-} S2D_Music;
+} R2D_Music;
 
-// Simple 2D Functions /////////////////////////////////////////////////////////
+// Ruby 2D Functions ///////////////////////////////////////////////////////////
 
 /*
  * Checks if a file exists and can be accessed
  */
-bool S2D_FileExists(const char *path);
+bool R2D_FileExists(const char *path);
 
 /*
  * Logs standard messages to the console
  */
-void S2D_Log(int type, const char *msg, ...);
+void R2D_Log(int type, const char *msg, ...);
 
 /*
- * Logs Simple 2D errors to the console, with caller and message body
+ * Logs Ruby 2D errors to the console, with caller and message body
  */
-void S2D_Error(const char *caller, const char *msg, ...);
+void R2D_Error(const char *caller, const char *msg, ...);
 
 /*
  * Enable/disable logging of diagnostics
  */
-void S2D_Diagnostics(bool status);
+void R2D_Diagnostics(bool status);
 
 /*
  * Enable terminal colors in Windows
  */
-void S2D_Windows_EnableTerminalColors();
+void R2D_Windows_EnableTerminalColors();
 
 /*
-* Initialize Simple 2D subsystems
+* Initialize Ruby 2D subsystems
 */
-bool S2D_Init();
+bool R2D_Init();
 
 /*
- * Gets the primary display's dimentions
+ * Gets the primary display's dimensions
  */
-void S2D_GetDisplayDimensions(int *w, int *h);
+void R2D_GetDisplayDimensions(int *w, int *h);
 
 /*
- * Quits Simple 2D subsystems
+ * Quits Ruby 2D subsystems
  */
-void S2D_Quit(void);
+void R2D_Quit(void);
 
 // Shapes //////////////////////////////////////////////////////////////////////
 
@@ -395,17 +395,17 @@ void S2D_Quit(void);
  *   rx     The x coordinate to rotate around
  *   ry     The y coordinate to rotate around
  */
-S2D_GL_Point S2D_RotatePoint(S2D_GL_Point p, GLfloat angle, GLfloat rx, GLfloat ry);
+R2D_GL_Point R2D_RotatePoint(R2D_GL_Point p, GLfloat angle, GLfloat rx, GLfloat ry);
 
 /*
  * Get the point to be rotated around given a position in a rectangle
  */
-S2D_GL_Point S2D_GetRectRotationPoint(int x, int y, int w, int h, int position);
+R2D_GL_Point R2D_GetRectRotationPoint(int x, int y, int w, int h, int position);
 
 /*
  * Draw a triangle
  */
-void S2D_DrawTriangle(
+void R2D_DrawTriangle(
   GLfloat x1, GLfloat y1,
   GLfloat r1, GLfloat g1, GLfloat b1, GLfloat a1,
   GLfloat x2, GLfloat y2,
@@ -417,7 +417,7 @@ void S2D_DrawTriangle(
 /*
  * Draw a quad, using two triangles
  */
-void S2D_DrawQuad(
+void R2D_DrawQuad(
   GLfloat x1, GLfloat y1,
   GLfloat r1, GLfloat g1, GLfloat b1, GLfloat a1,
   GLfloat x2, GLfloat y2,
@@ -431,7 +431,7 @@ void S2D_DrawQuad(
 /*
  * Draw a line from a quad
  */
-void S2D_DrawLine(
+void R2D_DrawLine(
   GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2,
   GLfloat width,
   GLfloat r1, GLfloat g1, GLfloat b1, GLfloat a1,
@@ -443,7 +443,7 @@ void S2D_DrawLine(
 /*
  * Draw a circle from triangles
  */
-void S2D_DrawCircle(
+void R2D_DrawCircle(
   GLfloat x, GLfloat y, GLfloat radius, int sectors,
   GLfloat r, GLfloat g, GLfloat b, GLfloat a
 );
@@ -453,303 +453,303 @@ void S2D_DrawCircle(
 /*
  * Create an image, given a file path
  */
-S2D_Image *S2D_CreateImage(const char *path);
+R2D_Image *R2D_CreateImage(const char *path);
 
 /*
  * Rotate an image
  */
-void S2D_RotateImage(S2D_Image *img, GLfloat angle, int position);
+void R2D_RotateImage(R2D_Image *img, GLfloat angle, int position);
 
 /*
  * Draw an image
  */
-void S2D_DrawImage(S2D_Image *img);
+void R2D_DrawImage(R2D_Image *img);
 
 /*
  * Free an image
  */
-void S2D_FreeImage(S2D_Image *img);
+void R2D_FreeImage(R2D_Image *img);
 
 // Sprite //////////////////////////////////////////////////////////////////////
 
 /*
  * Create a sprite, given an image file path
  */
-S2D_Sprite *S2D_CreateSprite(const char *path);
+R2D_Sprite *R2D_CreateSprite(const char *path);
 
 /*
  * Clip a sprite
  */
-void S2D_ClipSprite(S2D_Sprite *spr, int x, int y, int w, int h);
+void R2D_ClipSprite(R2D_Sprite *spr, int x, int y, int w, int h);
 
 /*
  * Rotate a sprite
  */
-void S2D_RotateSprite(S2D_Sprite *spr, GLfloat angle, int position);
+void R2D_RotateSprite(R2D_Sprite *spr, GLfloat angle, int position);
 
 /*
  * Draw a sprite
  */
-void S2D_DrawSprite(S2D_Sprite *spr);
+void R2D_DrawSprite(R2D_Sprite *spr);
 
 /*
  * Free a sprite
  */
-void S2D_FreeSprite(S2D_Sprite *spr);
+void R2D_FreeSprite(R2D_Sprite *spr);
 
 // Text ////////////////////////////////////////////////////////////////////////
 
 /*
  * Create text, given a font file path, the message, and size
  */
-S2D_Text *S2D_CreateText(const char *font, const char *msg, int size);
+R2D_Text *R2D_CreateText(const char *font, const char *msg, int size);
 
 /*
 * Set the text message
 */
-void S2D_SetText(S2D_Text *txt, const char *msg, ...);
+void R2D_SetText(R2D_Text *txt, const char *msg, ...);
 
 /*
  * Rotate text
  */
-void S2D_RotateText(S2D_Text *txt, GLfloat angle, int position);
+void R2D_RotateText(R2D_Text *txt, GLfloat angle, int position);
 
 /*
  * Draw text
  */
-void S2D_DrawText(S2D_Text *txt);
+void R2D_DrawText(R2D_Text *txt);
 
 /*
  * Free the text
  */
-void S2D_FreeText(S2D_Text *txt);
+void R2D_FreeText(R2D_Text *txt);
 
 // Sound ///////////////////////////////////////////////////////////////////////
 
 /*
  * Create a sound, given an audio file path
  */
-S2D_Sound *S2D_CreateSound(const char *path);
+R2D_Sound *R2D_CreateSound(const char *path);
 
 /*
  * Play the sound
  */
-void S2D_PlaySound(S2D_Sound *snd);
+void R2D_PlaySound(R2D_Sound *snd);
 
 /*
  * Get the sound's volume
  */
-int S2D_GetSoundVolume(S2D_Sound *snd);
+int R2D_GetSoundVolume(R2D_Sound *snd);
 
 /*
  * Set the sound's volume a given percentage
  */
-void S2D_SetSoundVolume(S2D_Sound *snd, int volume);
+void R2D_SetSoundVolume(R2D_Sound *snd, int volume);
 
 /*
  * Get the sound mixer volume
  */
-int S2D_GetSoundMixVolume();
+int R2D_GetSoundMixVolume();
 
 /*
  * Set the sound mixer volume a given percentage
  */
-void S2D_SetSoundMixVolume(int volume);
+void R2D_SetSoundMixVolume(int volume);
 
 /*
  * Free the sound
  */
-void S2D_FreeSound(S2D_Sound *snd);
+void R2D_FreeSound(R2D_Sound *snd);
 
 // Music ///////////////////////////////////////////////////////////////////////
 
 /*
  * Create the music, given an audio file path
  */
-S2D_Music *S2D_CreateMusic(const char *path);
+R2D_Music *R2D_CreateMusic(const char *path);
 
 /*
  * Play the music
  */
-void S2D_PlayMusic(S2D_Music *mus, bool loop);
+void R2D_PlayMusic(R2D_Music *mus, bool loop);
 
 /*
  * Pause the playing music
  */
-void S2D_PauseMusic();
+void R2D_PauseMusic();
 
 /*
  * Resume the current music
  */
-void S2D_ResumeMusic();
+void R2D_ResumeMusic();
 
 /*
  * Stop the playing music; interrupts fader effects
  */
-void S2D_StopMusic();
+void R2D_StopMusic();
 
 /*
  * Get the music volume
  */
-int S2D_GetMusicVolume();
+int R2D_GetMusicVolume();
 
 /*
  * Set the music volume a given percentage
  */
-void S2D_SetMusicVolume(int volume);
+void R2D_SetMusicVolume(int volume);
 
 /*
  * Fade out the playing music
  */
-void S2D_FadeOutMusic(int ms);
+void R2D_FadeOutMusic(int ms);
 
 /*
  * Free the music
  */
-void S2D_FreeMusic(S2D_Music *mus);
+void R2D_FreeMusic(R2D_Music *mus);
 
 // Input ///////////////////////////////////////////////////////////////////////
 
 /*
  * 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);
 
 /*
  * Show the cursor over the window
  */
-void S2D_ShowCursor();
+void R2D_ShowCursor();
 
 /*
  * Hide the cursor over the window
  */
-void S2D_HideCursor();
+void R2D_HideCursor();
 
 // Controllers /////////////////////////////////////////////////////////////////
 
 /*
  * Add controller mapping from string
  */
-void S2D_AddControllerMapping(const char *map);
+void R2D_AddControllerMapping(const char *map);
 
 /*
  * Load controller mappings from the specified file
  */
-void S2D_AddControllerMappingsFromFile(const char *path);
+void R2D_AddControllerMappingsFromFile(const char *path);
 
 /*
  * Check if joystick is a controller
  */
-bool S2D_IsController(SDL_JoystickID id);
+bool R2D_IsController(SDL_JoystickID id);
 
 /*
  * Open controllers and joysticks
  */
-void S2D_OpenControllers();
+void R2D_OpenControllers();
 
 // Window //////////////////////////////////////////////////////////////////////
 
 /*
  * Create a window
  */
-S2D_Window *S2D_CreateWindow(
-  const char *title, int width, int height, S2D_Update, S2D_Render, int flags
+R2D_Window *R2D_CreateWindow(
+  const char *title, int width, int height, R2D_Update, R2D_Render, int flags
 );
 
 /*
  * Show the window
  */
-int S2D_Show(S2D_Window *window);
+int R2D_Show(R2D_Window *window);
 
 /*
  * Set the icon for the window
  */
-void S2D_SetIcon(S2D_Window *window, const char *icon);
+void R2D_SetIcon(R2D_Window *window, const char *icon);
 
 /*
  * Take a screenshot of the window
  */
-void S2D_Screenshot(S2D_Window *window, const char *path);
+void R2D_Screenshot(R2D_Window *window, const char *path);
 
 /*
  * Close the window
  */
-int S2D_Close(S2D_Window *window);
+int R2D_Close(R2D_Window *window);
 
 /*
  * Free all resources
  */
-int S2D_FreeWindow(S2D_Window *window);
+int R2D_FreeWindow(R2D_Window *window);
 
-// Simple 2D OpenGL Functions //////////////////////////////////////////////////
+// Ruby 2D OpenGL Functions ////////////////////////////////////////////////////
 
-int S2D_GL_Init(S2D_Window *window);
-void S2D_GL_PrintError(char *error);
-void S2D_GL_PrintContextInfo(S2D_Window *window);
-void S2D_GL_StoreContextInfo(S2D_Window *window);
-GLuint S2D_GL_LoadShader(GLenum type, const GLchar *shaderSrc, char *shaderName);
-int S2D_GL_CheckLinked(GLuint program, char *name);
-void S2D_GL_GetViewportScale(S2D_Window *window, int *w, int *h, double *scale);
-void S2D_GL_SetViewport(S2D_Window *window);
-void S2D_GL_CreateTexture(
+int R2D_GL_Init(R2D_Window *window);
+void R2D_GL_PrintError(char *error);
+void R2D_GL_PrintContextInfo(R2D_Window *window);
+void R2D_GL_StoreContextInfo(R2D_Window *window);
+GLuint R2D_GL_LoadShader(GLenum type, const GLchar *shaderSrc, char *shaderName);
+int R2D_GL_CheckLinked(GLuint program, char *name);
+void R2D_GL_GetViewportScale(R2D_Window *window, int *w, int *h, double *scale);
+void R2D_GL_SetViewport(R2D_Window *window);
+void R2D_GL_CreateTexture(
   GLuint *id, GLint format,
   int w, int h,
   const GLvoid *data, GLint filter);
-void S2D_GL_DrawTriangle(
+void R2D_GL_DrawTriangle(
   GLfloat x1, GLfloat y1,
   GLfloat r1, GLfloat g1, GLfloat b1, GLfloat a1,
   GLfloat x2, GLfloat y2,
   GLfloat r2, GLfloat g2, GLfloat b2, GLfloat a2,
   GLfloat x3, GLfloat y3,
   GLfloat r3, GLfloat g3, GLfloat b3, GLfloat a3);
-void S2D_GL_DrawImage(S2D_Image *img);
-void S2D_GL_DrawSprite(S2D_Sprite *spr);
-void S2D_GL_DrawText(S2D_Text *txt);
-void S2D_GL_FreeTexture(GLuint *id);
-void S2D_GL_Clear(S2D_Color clr);
-void S2D_GL_FlushBuffers();
+void R2D_GL_DrawImage(R2D_Image *img);
+void R2D_GL_DrawSprite(R2D_Sprite *spr);
+void R2D_GL_DrawText(R2D_Text *txt);
+void R2D_GL_FreeTexture(GLuint *id);
+void R2D_GL_Clear(R2D_Color clr);
+void R2D_GL_FlushBuffers();
 
 // OpenGL & GLES Internal Functions ////////////////////////////////////////////
 
 #if GLES
-  int S2D_GLES_Init();
-  void S2D_GLES_ApplyProjection(GLfloat orthoMatrix[16]);
-  void S2D_GLES_DrawTriangle(
+  int R2D_GLES_Init();
+  void R2D_GLES_ApplyProjection(GLfloat orthoMatrix[16]);
+  void R2D_GLES_DrawTriangle(
     GLfloat x1, GLfloat y1,
     GLfloat r1, GLfloat g1, GLfloat b1, GLfloat a1,
     GLfloat x2, GLfloat y2,
     GLfloat r2, GLfloat g2, GLfloat b2, GLfloat a2,
     GLfloat x3, GLfloat y3,
     GLfloat r3, GLfloat g3, GLfloat b3, GLfloat a3);
-  void S2D_GLES_DrawImage(S2D_Image *img);
-  void S2D_GLES_DrawSprite(S2D_Sprite *spr);
-  void S2D_GLES_DrawText(S2D_Text *txt);
+  void R2D_GLES_DrawImage(R2D_Image *img);
+  void R2D_GLES_DrawSprite(R2D_Sprite *spr);
+  void R2D_GLES_DrawText(R2D_Text *txt);
 #else
-  int S2D_GL2_Init();
-  int S2D_GL3_Init();
-  void S2D_GL2_ApplyProjection(int w, int h);
-  void S2D_GL3_ApplyProjection(GLfloat orthoMatrix[16]);
-  void S2D_GL2_DrawTriangle(
+  int R2D_GL2_Init();
+  int R2D_GL3_Init();
+  void R2D_GL2_ApplyProjection(int w, int h);
+  void R2D_GL3_ApplyProjection(GLfloat orthoMatrix[16]);
+  void R2D_GL2_DrawTriangle(
     GLfloat x1, GLfloat y1,
     GLfloat r1, GLfloat g1, GLfloat b1, GLfloat a1,
     GLfloat x2, GLfloat y2,
     GLfloat r2, GLfloat g2, GLfloat b2, GLfloat a2,
     GLfloat x3, GLfloat y3,
     GLfloat r3, GLfloat g3, GLfloat b3, GLfloat a3);
-  void S2D_GL3_DrawTriangle(
+  void R2D_GL3_DrawTriangle(
     GLfloat x1, GLfloat y1,
     GLfloat r1, GLfloat g1, GLfloat b1, GLfloat a1,
     GLfloat x2, GLfloat y2,
     GLfloat r2, GLfloat g2, GLfloat b2, GLfloat a2,
     GLfloat x3, GLfloat y3,
     GLfloat r3, GLfloat g3, GLfloat b3, GLfloat a3);
-  void S2D_GL2_DrawImage(S2D_Image *img);
-  void S2D_GL3_DrawImage(S2D_Image *img);
-  void S2D_GL2_DrawSprite(S2D_Sprite *spr);
-  void S2D_GL3_DrawSprite(S2D_Sprite *spr);
-  void S2D_GL2_DrawText(S2D_Text *txt);
-  void S2D_GL3_DrawText(S2D_Text *txt);
-  void S2D_GL3_FlushBuffers();
+  void R2D_GL2_DrawImage(R2D_Image *img);
+  void R2D_GL3_DrawImage(R2D_Image *img);
+  void R2D_GL2_DrawSprite(R2D_Sprite *spr);
+  void R2D_GL3_DrawSprite(R2D_Sprite *spr);
+  void R2D_GL2_DrawText(R2D_Text *txt);
+  void R2D_GL3_DrawText(R2D_Text *txt);
+  void R2D_GL3_FlushBuffers();
 #endif
 
 #ifdef __cplusplus