ruby2d 0.9.4 → 0.9.5

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

@@ -1,6 +1,6 @@
 // shapes.c
 
-#include "../include/simple2d.h"
+#include "ruby2d.h"
 
 
 /*
@@ -11,7 +11,7 @@
  *   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) {
 
   // Convert from degrees to radians
   angle = angle * M_PI / 180.0;
@@ -39,28 +39,28 @@ S2D_GL_Point S2D_RotatePoint(S2D_GL_Point p, GLfloat angle, GLfloat rx, GLfloat
 /*
  * 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) {
 
-  S2D_GL_Point p;
+  R2D_GL_Point p;
 
   switch (position) {
-    case S2D_CENTER:
+    case R2D_CENTER:
       p.x = x + (w / 2.0);
       p.y = y + (h / 2.0);
       break;
-    case S2D_TOP_LEFT:
+    case R2D_TOP_LEFT:
       p.x = x;
       p.y = y;
       break;
-    case S2D_TOP_RIGHT:
+    case R2D_TOP_RIGHT:
       p.x = x + w;
       p.y = y;
       break;
-    case S2D_BOTTOM_LEFT:
+    case R2D_BOTTOM_LEFT:
       p.x = x;
       p.y = y + h;
       break;
-    case S2D_BOTTOM_RIGHT:
+    case R2D_BOTTOM_RIGHT:
       p.x = x + w;
       p.y = y + h;
       break;
@@ -73,14 +73,14 @@ S2D_GL_Point S2D_GetRectRotationPoint(int x, int y, int w, int h, int position)
 /*
  * Draw a triangle
  */
-void S2D_DrawTriangle(GLfloat x1, GLfloat y1,
+void R2D_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) {
 
-  S2D_GL_DrawTriangle(x1, y1, r1, g1, b1, a1,
+  R2D_GL_DrawTriangle(x1, y1, r1, g1, b1, a1,
                       x2, y2, r2, g2, b2, a2,
                       x3, y3, r3, g3, b3, a3);
 }
@@ -89,7 +89,7 @@ void S2D_DrawTriangle(GLfloat x1, GLfloat y1,
 /*
  * Draw a quad, using two triangles
  */
-void S2D_DrawQuad(GLfloat x1, GLfloat y1,
+void R2D_DrawQuad(GLfloat x1, GLfloat y1,
                   GLfloat r1, GLfloat g1, GLfloat b1, GLfloat a1,
                   GLfloat x2, GLfloat y2,
                   GLfloat r2, GLfloat g2, GLfloat b2, GLfloat a2,
@@ -98,11 +98,11 @@ void S2D_DrawQuad(GLfloat x1, GLfloat y1,
                   GLfloat x4, GLfloat y4,
                   GLfloat r4, GLfloat g4, GLfloat b4, GLfloat a4) {
 
-  S2D_GL_DrawTriangle(x1, y1, r1, g1, b1, a1,
+  R2D_GL_DrawTriangle(x1, y1, r1, g1, b1, a1,
                       x2, y2, r2, g2, b2, a2,
                       x3, y3, r3, g3, b3, a3);
 
-  S2D_GL_DrawTriangle(x3, y3, r3, g3, b3, a3,
+  R2D_GL_DrawTriangle(x3, y3, r3, g3, b3, a3,
                       x4, y4, r4, g4, b4, a4,
                       x1, y1, r1, g1, b1, a1);
 };
@@ -111,7 +111,7 @@ void S2D_DrawQuad(GLfloat x1, GLfloat y1,
 /*
  * Draw a line from a quad
  */
-void S2D_DrawLine(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2,
+void R2D_DrawLine(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2,
                   GLfloat width,
                   GLfloat r1, GLfloat g1, GLfloat b1, GLfloat a1,
                   GLfloat r2, GLfloat g2, GLfloat b2, GLfloat a2,
@@ -122,7 +122,7 @@ void S2D_DrawLine(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2,
   double x = ((x2 - x1) / length) * width / 2;
   double y = ((y2 - y1) / length) * width / 2;
 
-  S2D_DrawQuad(
+  R2D_DrawQuad(
     x1 - y, y1 + x, r1, g1, b1, a1,
     x1 + y, y1 - x, r2, g2, b2, a2,
     x2 + y, y2 - x, r3, g3, b3, a3,
@@ -134,7 +134,7 @@ void S2D_DrawLine(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2,
 /*
  * Draw a circle from triangles
  */
-void S2D_DrawCircle(GLfloat x, GLfloat y, GLfloat radius, int sectors,
+void R2D_DrawCircle(GLfloat x, GLfloat y, GLfloat radius, int sectors,
                     GLfloat r, GLfloat g, GLfloat b, GLfloat a) {
 
   double angle = 2 * M_PI / sectors;
@@ -147,7 +147,7 @@ void S2D_DrawCircle(GLfloat x, GLfloat y, GLfloat radius, int sectors,
     GLfloat x2 = x + radius * cos((i - 1) * angle);
     GLfloat y2 = y + radius * sin((i - 1) * angle);
 
-    S2D_GL_DrawTriangle( x,  y, r, g, b, a,
+    R2D_GL_DrawTriangle( x,  y, r, g, b, a,
                         x1, y1, r, g, b, a,
                         x2, y2, r, g, b, a);
   }

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

@@ -1,31 +1,31 @@
 // sound.c
 
-#include "../include/simple2d.h"
+#include "ruby2d.h"
 
 
 /*
  * Create a sound, given an audio file path
  */
-S2D_Sound *S2D_CreateSound(const char *path) {
-  S2D_Init();
+R2D_Sound *R2D_CreateSound(const char *path) {
+  R2D_Init();
 
   // Check if sound file exists
-  if (!S2D_FileExists(path)) {
-    S2D_Error("S2D_CreateSound", "Sound file `%s` not found", path);
+  if (!R2D_FileExists(path)) {
+    R2D_Error("R2D_CreateSound", "Sound file `%s` not found", path);
     return NULL;
   }
 
   // Allocate the sound structure
-  S2D_Sound *snd = (S2D_Sound *) malloc(sizeof(S2D_Sound));
+  R2D_Sound *snd = (R2D_Sound *) malloc(sizeof(R2D_Sound));
   if (!snd) {
-    S2D_Error("S2D_CreateSound", "Out of memory!");
+    R2D_Error("R2D_CreateSound", "Out of memory!");
     return NULL;
   }
 
   // Load the sound data from file
   snd->data = Mix_LoadWAV(path);
   if (!snd->data) {
-    S2D_Error("Mix_LoadWAV", Mix_GetError());
+    R2D_Error("Mix_LoadWAV", Mix_GetError());
     free(snd);
     return NULL;
   }
@@ -40,7 +40,7 @@ S2D_Sound *S2D_CreateSound(const char *path) {
 /*
  * Play the sound
  */
-void S2D_PlaySound(S2D_Sound *snd) {
+void R2D_PlaySound(R2D_Sound *snd) {
   if (!snd) return;
   Mix_PlayChannel(-1, snd->data, 0);
 }
@@ -49,7 +49,7 @@ void S2D_PlaySound(S2D_Sound *snd) {
 /*
  * Get the sound's volume
  */
-int S2D_GetSoundVolume(S2D_Sound *snd) {
+int R2D_GetSoundVolume(R2D_Sound *snd) {
   if (!snd) return -1;
   return ceil(Mix_VolumeChunk(snd->data, -1) * (100.0 / MIX_MAX_VOLUME));
 }
@@ -58,7 +58,7 @@ int S2D_GetSoundVolume(S2D_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) {
   if (!snd) return;
   // Set volume to be a percentage of the maximum mix volume
   Mix_VolumeChunk(snd->data, (volume / 100.0) * MIX_MAX_VOLUME);
@@ -68,7 +68,7 @@ void S2D_SetSoundVolume(S2D_Sound *snd, int volume) {
 /*
  * Get the sound mixer volume
  */
-int S2D_GetSoundMixVolume() {
+int R2D_GetSoundMixVolume() {
   return ceil(Mix_Volume(-1, -1) * (100.0 / MIX_MAX_VOLUME));
 }
 
@@ -76,7 +76,7 @@ int S2D_GetSoundMixVolume() {
 /*
  * Set the sound mixer volume a given percentage
  */
-void S2D_SetSoundMixVolume(int volume) {
+void R2D_SetSoundMixVolume(int volume) {
   // This sets the volume value across all channels
   // Set volume to be a percentage of the maximum mix volume
   Mix_Volume(-1, (volume / 100.0) * MIX_MAX_VOLUME);
@@ -86,7 +86,7 @@ void S2D_SetSoundMixVolume(int volume) {
 /*
  * Free the sound
  */
-void S2D_FreeSound(S2D_Sound *snd) {
+void R2D_FreeSound(R2D_Sound *snd) {
   if (!snd) return;
   Mix_FreeChunk(snd->data);
   free(snd);

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

@@ -1,30 +1,30 @@
 // sprite.c
 
-#include "../include/simple2d.h"
+#include "ruby2d.h"
 
 
 /*
  * Create a sprite, given an image file path
  */
-S2D_Sprite *S2D_CreateSprite(const char *path) {
+R2D_Sprite *R2D_CreateSprite(const char *path) {
 
   // Check if image file exists
-  if (!S2D_FileExists(path)) {
-    S2D_Error("S2D_CreateSprite", "Sprite image file `%s` not found", path);
+  if (!R2D_FileExists(path)) {
+    R2D_Error("R2D_CreateSprite", "Sprite image file `%s` not found", path);
     return NULL;
   }
 
   // Allocate the sprite structure
-  S2D_Sprite *spr = (S2D_Sprite *) malloc(sizeof(S2D_Sprite));
+  R2D_Sprite *spr = (R2D_Sprite *) malloc(sizeof(R2D_Sprite));
   if (!spr) {
-    S2D_Error("S2D_CreateSprite", "Out of memory!");
+    R2D_Error("R2D_CreateSprite", "Out of memory!");
     return NULL;
   }
 
   // Load the sprite image file
-  spr->img = S2D_CreateImage(path);
+  spr->img = R2D_CreateImage(path);
   if (!spr->img) {
-    S2D_Error("S2D_CreateSprite", "Cannot create sprite image `%s`", path);
+    R2D_Error("R2D_CreateSprite", "Cannot create sprite image `%s`", path);
     free(spr);
     return NULL;
   }
@@ -60,7 +60,7 @@ S2D_Sprite *S2D_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) {
   if (!spr) return;
 
   // Calculate ratios
@@ -108,9 +108,9 @@ void S2D_ClipSprite(S2D_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) {
 
-  S2D_GL_Point p = S2D_GetRectRotationPoint(
+  R2D_GL_Point p = R2D_GetRectRotationPoint(
     spr->x, spr->y, spr->width, spr->height, position
   );
 
@@ -123,25 +123,25 @@ void S2D_RotateSprite(S2D_Sprite *spr, GLfloat angle, int position) {
 /*
  * Draw a sprite
  */
-void S2D_DrawSprite(S2D_Sprite *spr) {
+void R2D_DrawSprite(R2D_Sprite *spr) {
   if (!spr) return;
 
   if (spr->img->texture_id == 0) {
-    S2D_GL_CreateTexture(&spr->img->texture_id, spr->img->format,
+    R2D_GL_CreateTexture(&spr->img->texture_id, spr->img->format,
                          spr->img->width, spr->img->height,
                          spr->img->surface->pixels, GL_NEAREST);
     SDL_FreeSurface(spr->img->surface);
   }
 
-  S2D_GL_DrawSprite(spr);
+  R2D_GL_DrawSprite(spr);
 }
 
 
 /*
  * Free a sprite
  */
-void S2D_FreeSprite(S2D_Sprite *spr) {
+void R2D_FreeSprite(R2D_Sprite *spr) {
   if (!spr) return;
-  S2D_FreeImage(spr->img);
+  R2D_FreeImage(spr->img);
   free(spr);
 }

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

@@ -1,17 +1,17 @@
 // text.c
 
-#include "../include/simple2d.h"
+#include "ruby2d.h"
 
 
 /*
  * Create text, given a font file path, the message, and size
  */
-S2D_Text *S2D_CreateText(const char *font, const char *msg, int size) {
-  S2D_Init();
+R2D_Text *R2D_CreateText(const char *font, const char *msg, int size) {
+  R2D_Init();
 
   // Check if font file exists
-  if (!S2D_FileExists(font)) {
-    S2D_Error("S2D_CreateText", "Font file `%s` not found", font);
+  if (!R2D_FileExists(font)) {
+    R2D_Error("R2D_CreateText", "Font file `%s` not found", font);
     return NULL;
   }
 
@@ -19,16 +19,16 @@ S2D_Text *S2D_CreateText(const char *font, const char *msg, int size) {
   if (msg == NULL || strlen(msg) == 0) msg = " ";
 
   // Allocate the text structure
-  S2D_Text *txt = (S2D_Text *) malloc(sizeof(S2D_Text));
+  R2D_Text *txt = (R2D_Text *) malloc(sizeof(R2D_Text));
   if (!txt) {
-    S2D_Error("S2D_CreateText", "Out of memory!");
+    R2D_Error("R2D_CreateText", "Out of memory!");
     return NULL;
   }
 
   // Open the font
   txt->font_data = TTF_OpenFont(font, size);
   if (!txt->font_data) {
-    S2D_Error("TTF_OpenFont", TTF_GetError());
+    R2D_Error("TTF_OpenFont", TTF_GetError());
     free(txt);
     return NULL;
   }
@@ -49,7 +49,7 @@ S2D_Text *S2D_CreateText(const char *font, const char *msg, int size) {
   txt->texture_id = 0;
 
   // Save the width and height of the text
-  TTF_SizeText(txt->font_data, txt->msg, &txt->width, &txt->height);
+  TTF_SizeUTF8(txt->font_data, txt->msg, &txt->width, &txt->height);
 
   return txt;
 }
@@ -58,10 +58,10 @@ S2D_Text *S2D_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, ...) {
   if (!txt) return;
 
-  // `msg` cannot be an empty string or NULL for TTF_SizeText
+  // `msg` cannot be an empty string or NULL for TTF_SizeUTF8
   if (msg == NULL || strlen(msg) == 0) msg = " ";
 
   // Format and store new text string
@@ -72,19 +72,19 @@ void S2D_SetText(S2D_Text *txt, const char *msg, ...) {
   va_end(args);
 
   // Save the width and height of the text
-  TTF_SizeText(txt->font_data, txt->msg, &txt->width, &txt->height);
+  TTF_SizeUTF8(txt->font_data, txt->msg, &txt->width, &txt->height);
 
   // Delete the current texture so a new one can be generated
-  S2D_GL_FreeTexture(&txt->texture_id);
+  R2D_GL_FreeTexture(&txt->texture_id);
 }
 
 
 /*
  * Rotate text
  */
-void S2D_RotateText(S2D_Text *txt, GLfloat angle, int position) {
+void R2D_RotateText(R2D_Text *txt, GLfloat angle, int position) {
 
-  S2D_GL_Point p = S2D_GetRectRotationPoint(
+  R2D_GL_Point p = R2D_GetRectRotationPoint(
     txt->x, txt->y, txt->width, txt->height, position
   );
 
@@ -97,33 +97,33 @@ void S2D_RotateText(S2D_Text *txt, GLfloat angle, int position) {
 /*
  * Draw text
  */
-void S2D_DrawText(S2D_Text *txt) {
+void R2D_DrawText(R2D_Text *txt) {
   if (!txt) return;
 
   if (txt->texture_id == 0) {
     SDL_Color color = { 255, 255, 255 };
-    txt->surface = TTF_RenderText_Blended(txt->font_data, txt->msg, color);
+    txt->surface = TTF_RenderUTF8_Blended(txt->font_data, txt->msg, color);
     if (!txt->surface) {
-      S2D_Error("TTF_RenderText_Blended", TTF_GetError());
+      R2D_Error("TTF_RenderUTF8_Blended", TTF_GetError());
       return;
     }
-    S2D_GL_CreateTexture(&txt->texture_id, GL_RGBA,
+    R2D_GL_CreateTexture(&txt->texture_id, GL_RGBA,
                          txt->width, txt->height,
                          txt->surface->pixels, GL_NEAREST);
     SDL_FreeSurface(txt->surface);
   }
 
-  S2D_GL_DrawText(txt);
+  R2D_GL_DrawText(txt);
 }
 
 
 /*
  * Free the text
  */
-void S2D_FreeText(S2D_Text *txt) {
+void R2D_FreeText(R2D_Text *txt) {
   if (!txt) return;
   free(txt->msg);
-  S2D_GL_FreeTexture(&txt->texture_id);
+  R2D_GL_FreeTexture(&txt->texture_id);
   TTF_CloseFont(txt->font_data);
   free(txt);
 }

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

@@ -1,25 +1,25 @@
 // window.c
 
-#include "../include/simple2d.h"
+#include "ruby2d.h"
 
 
 /*
  * Create a window
  */
-S2D_Window *S2D_CreateWindow(const char *title, int width, int height,
-                             S2D_Update update, S2D_Render render, int flags) {
+R2D_Window *R2D_CreateWindow(const char *title, int width, int height,
+                             R2D_Update update, R2D_Render render, int flags) {
 
-  S2D_Init();
+  R2D_Init();
 
   SDL_DisplayMode dm;
   SDL_GetCurrentDisplayMode(0, &dm);
-  S2D_Log(S2D_INFO, "Current display mode is %dx%dpx @ %dhz", dm.w, dm.h, dm.refresh_rate);
+  R2D_Log(R2D_INFO, "Current display mode is %dx%dpx @ %dhz", dm.w, dm.h, dm.refresh_rate);
 
-  width  = width  == S2D_DISPLAY_WIDTH  ? dm.w : width;
-  height = height == S2D_DISPLAY_HEIGHT ? dm.h : height;
+  width  = width  == R2D_DISPLAY_WIDTH  ? dm.w : width;
+  height = height == R2D_DISPLAY_HEIGHT ? dm.h : height;
 
   // Allocate window and set default values
-  S2D_Window *window      = (S2D_Window *) malloc(sizeof(S2D_Window));
+  R2D_Window *window      = (R2D_Window *) malloc(sizeof(R2D_Window));
   window->sdl             = NULL;
   window->glcontext       = NULL;
   window->title           = title;
@@ -29,7 +29,7 @@ S2D_Window *S2D_CreateWindow(const char *title, int width, int height,
   window->orig_height     = height;
   window->viewport.width  = width;
   window->viewport.height = height;
-  window->viewport.mode   = S2D_SCALE;
+  window->viewport.mode   = R2D_SCALE;
   window->update          = update;
   window->render          = render;
   window->flags           = flags;
@@ -53,10 +53,10 @@ S2D_Window *S2D_CreateWindow(const char *title, int width, int height,
 /*
  * Show the window
  */
-int S2D_Show(S2D_Window *window) {
+int R2D_Show(R2D_Window *window) {
 
   if (!window) {
-    S2D_Error("S2D_Show", "Window cannot be shown (because it's NULL)");
+    R2D_Error("R2D_Show", "Window cannot be shown (because it's NULL)");
     return 1;
   }
 
@@ -68,8 +68,8 @@ int S2D_Show(S2D_Window *window) {
     SDL_WINDOW_OPENGL | window->flags                // flags
   );
 
-  if (!window->sdl) S2D_Error("SDL_CreateWindow", SDL_GetError());
-  if (window->icon) S2D_SetIcon(window, window->icon);
+  if (!window->sdl) R2D_Error("SDL_CreateWindow", SDL_GetError());
+  if (window->icon) R2D_SetIcon(window, window->icon);
 
   // The window created by SDL might not actually be the requested size.
   // If it's not the same, retrieve and store the actual window size.
@@ -77,7 +77,7 @@ int S2D_Show(S2D_Window *window) {
   SDL_GetWindowSize(window->sdl, &actual_width, &actual_height);
 
   if ((window->width != actual_width) || (window->height != actual_height)) {
-    S2D_Log(S2D_INFO,
+    R2D_Log(R2D_INFO,
       "Scaling window to %ix%i (requested size was %ix%i)",
       actual_width, actual_height, window->width, window->height
     );
@@ -89,7 +89,7 @@ int S2D_Show(S2D_Window *window) {
 
   // Set Up OpenGL /////////////////////////////////////////////////////////////
 
-  S2D_GL_Init(window);
+  R2D_GL_Init(window);
 
   // SDL 2.0.10 and macOS 10.15 fix ////////////////////////////////////////////
 
@@ -116,7 +116,7 @@ int S2D_Show(S2D_Window *window) {
   // Enable VSync
   if (window->vsync) {
     if (!SDL_SetHint(SDL_HINT_RENDER_VSYNC, "1")) {
-      S2D_Log(S2D_WARN, "VSync cannot be enabled");
+      R2D_Log(R2D_WARN, "VSync cannot be enabled");
     }
   }
 
@@ -128,7 +128,7 @@ int S2D_Show(S2D_Window *window) {
 
     // Clear Frame /////////////////////////////////////////////////////////////
 
-    S2D_GL_Clear(window->background);
+    R2D_GL_Clear(window->background);
 
     // Set FPS /////////////////////////////////////////////////////////////////
 
@@ -164,8 +164,8 @@ int S2D_Show(S2D_Window *window) {
 
         case SDL_KEYDOWN:
           if (window->on_key && e.key.repeat == 0) {
-            S2D_Event event = {
-              .type = S2D_KEY_DOWN, .key = SDL_GetScancodeName(e.key.keysym.scancode)
+            R2D_Event event = {
+              .type = R2D_KEY_DOWN, .key = SDL_GetScancodeName(e.key.keysym.scancode)
             };
             window->on_key(event);
           }
@@ -173,8 +173,8 @@ int S2D_Show(S2D_Window *window) {
 
         case SDL_KEYUP:
           if (window->on_key) {
-            S2D_Event event = {
-              .type = S2D_KEY_UP, .key = SDL_GetScancodeName(e.key.keysym.scancode)
+            R2D_Event event = {
+              .type = R2D_KEY_UP, .key = SDL_GetScancodeName(e.key.keysym.scancode)
             };
             window->on_key(event);
           }
@@ -182,11 +182,11 @@ int S2D_Show(S2D_Window *window) {
 
         case SDL_MOUSEBUTTONDOWN: case SDL_MOUSEBUTTONUP:
           if (window->on_mouse) {
-            S2D_GetMouseOnViewport(window, e.button.x, e.button.y, &mx, &my);
-            S2D_Event event = {
+            R2D_GetMouseOnViewport(window, e.button.x, e.button.y, &mx, &my);
+            R2D_Event event = {
               .button = e.button.button, .x = mx, .y = my
             };
-            event.type = e.type == SDL_MOUSEBUTTONDOWN ? S2D_MOUSE_DOWN : S2D_MOUSE_UP;
+            event.type = e.type == SDL_MOUSEBUTTONDOWN ? R2D_MOUSE_DOWN : R2D_MOUSE_UP;
             event.dblclick = e.button.clicks == 2 ? true : false;
             window->on_mouse(event);
           }
@@ -194,8 +194,8 @@ int S2D_Show(S2D_Window *window) {
 
         case SDL_MOUSEWHEEL:
           if (window->on_mouse) {
-            S2D_Event event = {
-              .type = S2D_MOUSE_SCROLL, .direction = e.wheel.direction,
+            R2D_Event event = {
+              .type = R2D_MOUSE_SCROLL, .direction = e.wheel.direction,
               .delta_x = e.wheel.x, .delta_y = -e.wheel.y
             };
             window->on_mouse(event);
@@ -204,9 +204,9 @@ int S2D_Show(S2D_Window *window) {
 
         case SDL_MOUSEMOTION:
           if (window->on_mouse) {
-            S2D_GetMouseOnViewport(window, e.motion.x, e.motion.y, &mx, &my);
-            S2D_Event event = {
-              .type = S2D_MOUSE_MOVE,
+            R2D_GetMouseOnViewport(window, e.motion.x, e.motion.y, &mx, &my);
+            R2D_Event event = {
+              .type = R2D_MOUSE_MOVE,
               .x = mx, .y = my, .delta_x = e.motion.xrel, .delta_y = e.motion.yrel
             };
             window->on_mouse(event);
@@ -215,8 +215,8 @@ int S2D_Show(S2D_Window *window) {
 
         case SDL_CONTROLLERAXISMOTION:
           if (window->on_controller) {
-            S2D_Event event = {
-              .which = e.caxis.which, .type = S2D_AXIS,
+            R2D_Event event = {
+              .which = e.caxis.which, .type = R2D_AXIS,
               .axis = e.caxis.axis, .value = e.caxis.value
             };
             window->on_controller(event);
@@ -224,9 +224,9 @@ int S2D_Show(S2D_Window *window) {
           break;
 
         case SDL_JOYAXISMOTION:
-          if (window->on_controller && !S2D_IsController(e.jbutton.which)) {
-            S2D_Event event = {
-              .which = e.jaxis.which, .type = S2D_AXIS,
+          if (window->on_controller && !R2D_IsController(e.jbutton.which)) {
+            R2D_Event event = {
+              .which = e.jaxis.which, .type = R2D_AXIS,
               .axis = e.jaxis.axis, .value = e.jaxis.value
             };
             window->on_controller(event);
@@ -235,35 +235,35 @@ int S2D_Show(S2D_Window *window) {
 
         case SDL_CONTROLLERBUTTONDOWN: case SDL_CONTROLLERBUTTONUP:
           if (window->on_controller) {
-            S2D_Event event = {
+            R2D_Event event = {
               .which = e.cbutton.which, .button = e.cbutton.button
             };
-            event.type = e.type == SDL_CONTROLLERBUTTONDOWN ? S2D_BUTTON_DOWN : S2D_BUTTON_UP;
+            event.type = e.type == SDL_CONTROLLERBUTTONDOWN ? R2D_BUTTON_DOWN : R2D_BUTTON_UP;
             window->on_controller(event);
           }
           break;
 
         case SDL_JOYBUTTONDOWN: case SDL_JOYBUTTONUP:
-          if (window->on_controller && !S2D_IsController(e.jbutton.which)) {
-            S2D_Event event = {
+          if (window->on_controller && !R2D_IsController(e.jbutton.which)) {
+            R2D_Event event = {
               .which = e.jbutton.which, .button = e.jbutton.button
             };
-            event.type = e.type == SDL_JOYBUTTONDOWN ? S2D_BUTTON_DOWN : S2D_BUTTON_UP;
+            event.type = e.type == SDL_JOYBUTTONDOWN ? R2D_BUTTON_DOWN : R2D_BUTTON_UP;
             window->on_controller(event);
           }
           break;
 
         case SDL_JOYDEVICEADDED:
-          S2D_Log(S2D_INFO, "Controller connected (%i total)", SDL_NumJoysticks());
-          S2D_OpenControllers();
+          R2D_Log(R2D_INFO, "Controller connected (%i total)", SDL_NumJoysticks());
+          R2D_OpenControllers();
           break;
 
         case SDL_JOYDEVICEREMOVED:
-          if (S2D_IsController(e.jdevice.which)) {
-            S2D_Log(S2D_INFO, "Controller #%i: %s removed (%i remaining)", e.jdevice.which, SDL_GameControllerName(SDL_GameControllerFromInstanceID(e.jdevice.which)), SDL_NumJoysticks());
+          if (R2D_IsController(e.jdevice.which)) {
+            R2D_Log(R2D_INFO, "Controller #%i: %s removed (%i remaining)", e.jdevice.which, SDL_GameControllerName(SDL_GameControllerFromInstanceID(e.jdevice.which)), SDL_NumJoysticks());
             SDL_GameControllerClose(SDL_GameControllerFromInstanceID(e.jdevice.which));
           } else {
-            S2D_Log(S2D_INFO, "Controller #%i: %s removed (%i remaining)", e.jdevice.which, SDL_JoystickName(SDL_JoystickFromInstanceID(e.jdevice.which)), SDL_NumJoysticks());
+            R2D_Log(R2D_INFO, "Controller #%i: %s removed (%i remaining)", e.jdevice.which, SDL_JoystickName(SDL_JoystickFromInstanceID(e.jdevice.which)), SDL_NumJoysticks());
             SDL_JoystickClose(SDL_JoystickFromInstanceID(e.jdevice.which));
           }
           break;
@@ -274,13 +274,13 @@ int S2D_Show(S2D_Window *window) {
               // Store new window size, set viewport
               window->width  = e.window.data1;
               window->height = e.window.data2;
-              S2D_GL_SetViewport(window);
+              R2D_GL_SetViewport(window);
               break;
           }
           break;
 
         case SDL_QUIT:
-          S2D_Close(window);
+          R2D_Close(window);
           break;
       }
     }
@@ -292,8 +292,8 @@ int S2D_Show(S2D_Window *window) {
     for (int i = 0; i < num_keys; i++) {
       if (window->on_key) {
         if (key_state[i] == 1) {
-          S2D_Event event = {
-            .type = S2D_KEY_HELD, .key = SDL_GetScancodeName(i)
+          R2D_Event event = {
+            .type = R2D_KEY_HELD, .key = SDL_GetScancodeName(i)
           };
           window->on_key(event);
         }
@@ -303,7 +303,7 @@ int S2D_Show(S2D_Window *window) {
     // Get and store mouse position relative to the viewport
     int wx, wy;  // mouse x, y coordinates relative to the window
     SDL_GetMouseState(&wx, &wy);
-    S2D_GetMouseOnViewport(window, wx, wy, &window->mouse.x, &window->mouse.y);
+    R2D_GetMouseOnViewport(window, wx, wy, &window->mouse.x, &window->mouse.y);
 
     // Update Window State /////////////////////////////////////////////////////
 
@@ -321,7 +321,7 @@ int S2D_Show(S2D_Window *window) {
     // Draw Frame //////////////////////////////////////////////////////////////
 
     // Render and flush all OpenGL buffers
-    S2D_GL_FlushBuffers();
+    R2D_GL_FlushBuffers();
 
     // Swap buffers to display drawn contents in the window
     SDL_GL_SwapWindow(window->sdl);
@@ -334,14 +334,14 @@ int S2D_Show(S2D_Window *window) {
 /*
  * Set the icon for the window
  */
-void S2D_SetIcon(S2D_Window *window, const char *icon) {
-  S2D_Image *img = S2D_CreateImage(icon);
+void R2D_SetIcon(R2D_Window *window, const char *icon) {
+  R2D_Image *img = R2D_CreateImage(icon);
   if (img) {
     window->icon = icon;
     SDL_SetWindowIcon(window->sdl, img->surface);
-    S2D_FreeImage(img);
+    R2D_FreeImage(img);
   } else {
-    S2D_Log(S2D_WARN, "Could not set window icon");
+    R2D_Log(R2D_WARN, "Could not set window icon");
   }
 }
 
@@ -349,10 +349,10 @@ void S2D_SetIcon(S2D_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) {
 
   #if GLES
-    S2D_Error("S2D_Screenshot", "Not supported in OpenGL ES");
+    R2D_Error("R2D_Screenshot", "Not supported in OpenGL ES");
   #else
     // Create a surface the size of the window
     SDL_Surface *surface = SDL_CreateRGBSurface(
@@ -368,7 +368,7 @@ void S2D_Screenshot(S2D_Window *window, const char *path) {
 
     void *temp_row = (void *)malloc(surface->pitch);
     if (!temp_row) {
-      S2D_Error("S2D_Screenshot", "Out of memory!");
+      R2D_Error("R2D_Screenshot", "Out of memory!");
       SDL_FreeSurface(surface);
       return;
     }
@@ -393,9 +393,9 @@ void S2D_Screenshot(S2D_Window *window, const char *path) {
 /*
  * Close the window
  */
-int S2D_Close(S2D_Window *window) {
+int R2D_Close(R2D_Window *window) {
   if (!window->close) {
-    S2D_Log(S2D_INFO, "Closing window");
+    R2D_Log(R2D_INFO, "Closing window");
     window->close = true;
   }
   return 0;
@@ -405,8 +405,8 @@ int S2D_Close(S2D_Window *window) {
 /*
  * Free all resources
  */
-int S2D_FreeWindow(S2D_Window *window) {
-  S2D_Close(window);
+int R2D_FreeWindow(R2D_Window *window) {
+  R2D_Close(window);
   SDL_GL_DeleteContext(window->glcontext);
   SDL_DestroyWindow(window->sdl);
   free(window);