ruby2d 0.9.4 → 0.9.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d097c7865d0f9920bccf154e7e7652bb4fac02767f0874b5adcf74b248ab5eb
-  data.tar.gz: fd6e9a7b221f850b9e6f71ba0d46a86e28f474d055d355a1c45f07078e2207de
+  metadata.gz: 694ff325167fe7d6ff8b61d8717fe4237d06da7d37c44d2df377c92651742537
+  data.tar.gz: 8985f19ff3d888286bbbb1dc6ec167c5b59f0eaa98ab2f628c3960c90ba978e0
 SHA512:
-  metadata.gz: 932f5623ab4abd18521f721b2921a9c7e64f81c446345949904613d7e059286ed85788e88b3c181c6e435a104692a7a093edb20cbc49847b925e16bf09d1a8cc
-  data.tar.gz: 3660bd43e97441b715513dd4236aaf36263d503f92af052fd961c1cb08e27d497a4598e9ca23b301c28a79ca0e8f8d1deed8107b98f54fb94d97255e036b02ef
+  metadata.gz: b3c772f6781eaf972ddf4213e9454c8333471a127b5787da0ffd8e7b1c04f62fc091eb10c0ad1c558786ff1842b2d3b1b3c7797de8c17dfc7e84b5ab4e12c371
+  data.tar.gz: 4b082fecf24c7a4e6269d41701f9ec13589fca93155487fd336ce8818f07eeeb251a3425f9ca9688d2be1a0fc9326280da1752750c2a198cddaec9be148df926

data/bin/ruby2d

@@ -115,6 +115,7 @@ when 'launch'
   else
     puts usage_launch
   end
+# TODO: Need add this functionality to the gem
 when 'simulator'
   case ARGV[1]
   when '--list'

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

@@ -1,11 +1,11 @@
-// Simple 2D Shared functions and data
+// Ruby 2D Shared functions and data
 
-#include "../include/simple2d.h"
+#include "ruby2d.h"
 
-// Initalize S2D shared data
-bool S2D_diagnostics = false;
+// Initalize shared data
+bool R2D_diagnostics = false;
 
-// S2D initialization status
+// Initialization status
 static bool initted = false;
 
 
@@ -30,7 +30,7 @@ int vasprintf(char **strp, const char *fmt, va_list ap) {
 /*
  * Checks if a file exists and can be accessed
  */
-bool S2D_FileExists(const char *path) {
+bool R2D_FileExists(const char *path) {
   if (!path) return false;
 
   if (access(path, F_OK) != -1) {
@@ -44,22 +44,22 @@ bool S2D_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, ...) {
 
   // Always log if diagnostics set, or if a warning or error message
-  if (S2D_diagnostics || type != S2D_INFO) {
+  if (R2D_diagnostics || type != R2D_INFO) {
 
     va_list args;
     va_start(args, msg);
 
     switch (type) {
-      case S2D_INFO:
+      case R2D_INFO:
         printf("\033[1;36mInfo:\033[0m ");
         break;
-      case S2D_WARN:
+      case R2D_WARN:
         printf("\033[1;33mWarning:\033[0m ");
         break;
-      case S2D_ERROR:
+      case R2D_ERROR:
         printf("\033[1;31mError:\033[0m ");
         break;
     }
@@ -72,14 +72,14 @@ void S2D_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, ...) {
   va_list args;
   va_start(args, msg);
   char *fmsg;
   vasprintf(&fmsg, msg, args);
-  S2D_Log(S2D_ERROR, "(%s) %s", caller, fmsg);
+  R2D_Log(R2D_ERROR, "(%s) %s", caller, fmsg);
   free(fmsg);
   va_end(args);
 }
@@ -88,15 +88,15 @@ void S2D_Error(const char *caller, const char *msg, ...) {
 /*
  * Enable/disable logging of diagnostics
  */
-void S2D_Diagnostics(bool status) {
-  S2D_diagnostics = status;
+void R2D_Diagnostics(bool status) {
+  R2D_diagnostics = status;
 }
 
 
 /*
  * Enable terminal colors in Windows
  */
-void S2D_Windows_EnableTerminalColors() {
+void R2D_Windows_EnableTerminalColors() {
   #if WINDOWS
     HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
     DWORD dwMode = 0;
@@ -108,25 +108,25 @@ void S2D_Windows_EnableTerminalColors() {
 
 
 /*
- * Initialize Simple 2D subsystems
+ * Initialize Ruby 2D subsystems
  */
-bool S2D_Init() {
+bool R2D_Init() {
   if (initted) return true;
 
   // Enable terminal colors in Windows
-  S2D_Windows_EnableTerminalColors();
+  R2D_Windows_EnableTerminalColors();
 
-  S2D_Log(S2D_INFO, "Initializing Simple 2D");
+  R2D_Log(R2D_INFO, "Initializing Ruby 2D");
 
   // Initialize SDL
   if (SDL_Init(SDL_INIT_EVERYTHING) != 0) {
-    S2D_Error("SDL_Init", SDL_GetError());
+    R2D_Error("SDL_Init", SDL_GetError());
     return false;
   }
 
   // Initialize SDL_ttf
   if (TTF_Init() != 0) {
-    S2D_Error("TTF_Init", TTF_GetError());
+    R2D_Error("TTF_Init", TTF_GetError());
     return false;
   }
 
@@ -142,17 +142,17 @@ bool S2D_Init() {
     // It's version 2.0.2, don't check for Mix_Init errors
   } else {
     if ((mix_initted&mix_flags) != mix_flags) {
-      S2D_Error("Mix_Init", Mix_GetError());
+      R2D_Error("Mix_Init", Mix_GetError());
     }
   }
 
   if (Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 4096) != 0) {
-    S2D_Error("Mix_OpenAudio", Mix_GetError());
+    R2D_Error("Mix_OpenAudio", Mix_GetError());
     return false;
   }
 
-  // Call `S2D_Quit` at program exit
-  atexit(S2D_Quit);
+  // Call `R2D_Quit` at program exit
+  atexit(R2D_Quit);
 
   // All subsystems initted
   initted = true;
@@ -161,10 +161,10 @@ bool S2D_Init() {
 
 
 /*
- * Gets the primary display's dimentions
+ * Gets the primary display's dimensions
  */
-void S2D_GetDisplayDimensions(int *w, int *h) {
-  S2D_Init();
+void R2D_GetDisplayDimensions(int *w, int *h) {
+  R2D_Init();
   SDL_DisplayMode dm;
   SDL_GetCurrentDisplayMode(0, &dm);
   *w = dm.w;
@@ -173,9 +173,9 @@ void S2D_GetDisplayDimensions(int *w, int *h) {
 
 
 /*
- * Quits Simple 2D subsystems
+ * Quits Ruby 2D subsystems
  */
-void S2D_Quit() {
+void R2D_Quit() {
   IMG_Quit();
   Mix_CloseAudio();
   Mix_Quit();

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

@@ -1,6 +1,6 @@
 // controllers.c
 
-#include "../include/simple2d.h"
+#include "ruby2d.h"
 
 // Stores the last joystick instance ID seen by the system. These instance IDs
 // are unique and increment with each new joystick connected.
@@ -10,7 +10,7 @@ static int last_intance_id = -1;
 /*
  * Add controller mapping from string
  */
-void S2D_AddControllerMapping(const char *map) {
+void R2D_AddControllerMapping(const char *map) {
   int result = SDL_GameControllerAddMapping(map);
 
   char guid[33];
@@ -18,13 +18,13 @@ void S2D_AddControllerMapping(const char *map) {
 
   switch (result) {
     case 1:
-      S2D_Log(S2D_INFO, "Mapping added for GUID: %s", guid);
+      R2D_Log(R2D_INFO, "Mapping added for GUID: %s", guid);
       break;
     case 0:
-      S2D_Log(S2D_INFO, "Mapping updated for GUID: %s", guid);
+      R2D_Log(R2D_INFO, "Mapping updated for GUID: %s", guid);
       break;
     case -1:
-      S2D_Error("SDL_GameControllerAddMapping", SDL_GetError());
+      R2D_Error("SDL_GameControllerAddMapping", SDL_GetError());
       break;
   }
 }
@@ -33,17 +33,17 @@ void S2D_AddControllerMapping(const char *map) {
 /*
  * Add controller mappings from the specified file
  */
-void S2D_AddControllerMappingsFromFile(const char *path) {
-  if (!S2D_FileExists(path)) {
-    S2D_Log(S2D_WARN, "Controller mappings file not found: %s", path);
+void R2D_AddControllerMappingsFromFile(const char *path) {
+  if (!R2D_FileExists(path)) {
+    R2D_Log(R2D_WARN, "Controller mappings file not found: %s", path);
     return;
   }
 
   int mappings_added = SDL_GameControllerAddMappingsFromFile(path);
   if (mappings_added == -1) {
-    S2D_Error("SDL_GameControllerAddMappingsFromFile", SDL_GetError());
+    R2D_Error("SDL_GameControllerAddMappingsFromFile", SDL_GetError());
   } else {
-    S2D_Log(S2D_INFO, "Added %i controller mapping(s)", mappings_added);
+    R2D_Log(R2D_INFO, "Added %i controller mapping(s)", mappings_added);
   }
 }
 
@@ -51,7 +51,7 @@ void S2D_AddControllerMappingsFromFile(const char *path) {
 /*
  * Check if joystick is a controller
  */
-bool S2D_IsController(SDL_JoystickID id) {
+bool R2D_IsController(SDL_JoystickID id) {
   return SDL_GameControllerFromInstanceID(id) == NULL ? false : true;
 }
 
@@ -59,7 +59,7 @@ bool S2D_IsController(SDL_JoystickID id) {
 /*
  * Open controllers and joysticks
  */
-void S2D_OpenControllers() {
+void R2D_OpenControllers() {
 
   char guid_str[33];
 
@@ -78,9 +78,9 @@ void S2D_OpenControllers() {
 
       if (intance_id > last_intance_id) {
         if (controller) {
-          S2D_Log(S2D_INFO, "Controller #%i: %s\n      GUID: %s", intance_id, SDL_GameControllerName(controller), guid_str);
+          R2D_Log(R2D_INFO, "Controller #%i: %s\n      GUID: %s", intance_id, SDL_GameControllerName(controller), guid_str);
         } else {
-          S2D_Log(S2D_ERROR, "Could not open controller #%i: %s", intance_id, SDL_GetError());
+          R2D_Log(R2D_ERROR, "Could not open controller #%i: %s", intance_id, SDL_GetError());
         }
         last_intance_id = intance_id;
       }
@@ -91,18 +91,18 @@ void S2D_OpenControllers() {
       SDL_JoystickID intance_id = SDL_JoystickInstanceID(joy);
 
       if (!joy) {
-        S2D_Log(S2D_ERROR, "Could not open controller");
+        R2D_Log(R2D_ERROR, "Could not open controller");
       } else if(intance_id > last_intance_id) {
         SDL_JoystickGetGUIDString(
           SDL_JoystickGetGUID(joy),
           guid_str, 33
         );
-        S2D_Log(S2D_INFO,
+        R2D_Log(R2D_INFO,
           "Controller #%i: %s\n      GUID: %s\n      Axes: %d\n      Buttons: %d\n      Balls: %d",
           intance_id, SDL_JoystickName(joy), guid_str, SDL_JoystickNumAxes(joy),
           SDL_JoystickNumButtons(joy), SDL_JoystickNumBalls(joy)
         );
-        S2D_Log(S2D_WARN, "Controller #%i does not have a mapping available", intance_id);
+        R2D_Log(R2D_WARN, "Controller #%i does not have a mapping available", intance_id);
         last_intance_id = intance_id;
       }
     }

data/ext/ruby2d/extconf.rb

@@ -1,7 +1,6 @@
 require 'mkmf'
 require_relative '../../lib/ruby2d/cli/colorize'
 
-S2D_VERSION = '1.2.0'  # Simple 2D minimum version required
 $errors = []  # Holds errors
 
 # Set the OS platform
@@ -31,27 +30,6 @@ def print_errors
 end
 
 
-# Check that Simple 2D is installed and meets minimum version requirements
-def check_s2d
-
-  # Simple 2D not installed
-  if `which simple2d`.empty?
-    $errors << "Ruby 2D uses a native library called Simple 2D, which was not found." <<
-               "To install, follow the instructions at #{"ruby2d.com".bold}"
-    print_errors; exit
-
-  # Simple 2D installed, checking version
-  else
-    unless Gem::Version.new(`bash simple2d --version`) >= Gem::Version.new(S2D_VERSION)
-      $errors << "Simple 2D needs to be updated for this version of Ruby 2D." <<
-                 "Run the following, then try reinstalling this gem:\n" <<
-                 "  simple2d update".bold
-      print_errors; exit
-    end
-  end
-end
-
-
 # Add compiler and linker flags
 def add_flags(type, flags)
   case type
@@ -106,14 +84,11 @@ def set_rpi_flags
 end
 
 
-# Use the Simple 2D, SDL, and other libraries installed by the user (not those bundled with the gem)
+# Use SDL and other libraries installed by the user (not those bundled with the gem)
 def use_usr_libs
-  check_s2d
-
   # Add flags
   set_rpi_flags
   add_flags(:c, '-I/usr/local/include')
-  add_flags(:ld, `bash simple2d --libs`)
 end
 
 
@@ -134,7 +109,6 @@ else
     add_flags(:c, '-I../../assets/include')
     ldir = "#{Dir.pwd}/../../assets/macos/lib"
 
-    add_flags(:ld, "#{ldir}/libsimple2d.a")
     add_flags(:ld, "#{ldir}/libSDL2.a #{ldir}/libSDL2_image.a #{ldir}/libSDL2_mixer.a #{ldir}/libSDL2_ttf.a")
     add_flags(:ld, "#{ldir}/libjpeg.a #{ldir}/libpng16.a #{ldir}/libtiff.a #{ldir}/libwebp.a")
     add_flags(:ld, "#{ldir}/libmpg123.a #{ldir}/libogg.a #{ldir}/libFLAC.a #{ldir}/libvorbis.a #{ldir}/libvorbisfile.a")
@@ -143,18 +117,14 @@ else
 
   when :linux, :linux_rpi
     check_sdl_linux
-    simple2d_dir = "#{Dir.pwd}/../../assets/linux/simple2d"
-
-    `(cd #{simple2d_dir} && make)`
 
     set_rpi_flags
-    add_flags(:c, "-I#{simple2d_dir}/include")
-    add_flags(:ld, "#{simple2d_dir}/build/libsimple2d.a -lSDL2 -lSDL2_image -lSDL2_mixer -lSDL2_ttf -lm")
+    add_flags(:ld, "-lSDL2 -lSDL2_image -lSDL2_mixer -lSDL2_ttf -lm")
     if $platform == :linux then add_flags(:ld, '-lGL') end
 
   when :windows
     add_flags(:c, '-I../../assets/include')
-    add_flags(:ld, '-L../../assets/mingw/lib -lsimple2d -lSDL2 -lSDL2_image -lSDL2_mixer -lSDL2_ttf')
+    add_flags(:ld, '-L../../assets/mingw/lib -lSDL2 -lSDL2_image -lSDL2_mixer -lSDL2_ttf')
     add_flags(:ld, '-lmingw32 -lopengl32 -lglew32')
 
   # If can't detect the platform, use libraries installed by the user
@@ -165,5 +135,5 @@ end
 
 $LDFLAGS.gsub!(/\n/, ' ')  # remove newlines in flags, they can cause problems
 
-# Create the Makefile
+# Create Makefile
 create_makefile('ruby2d/ruby2d')

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

@@ -1,15 +1,15 @@
-// Simple 2D OpenGL Functions
+// Ruby 2D OpenGL Functions
 
-#include "../include/simple2d.h"
+#include "ruby2d.h"
 
 // Set to `true` to force OpenGL 2.1 (for testing)
 static bool FORCE_GL2 = false;
 
 // Flag set if using OpenGL 2.1
-static bool S2D_GL2 = false;
+static bool R2D_GL2 = false;
 
 // The orthographic projection matrix for 2D rendering.
-// Elements 0 and 5 are set in S2D_GL_SetViewport.
+// Elements 0 and 5 are set in R2D_GL_SetViewport.
 static GLfloat orthoMatrix[16] =
   {    0,    0,     0,    0,
        0,    0,     0,    0,
@@ -20,25 +20,25 @@ static GLfloat orthoMatrix[16] =
 /*
  * Prints current GL error
  */
-void S2D_GL_PrintError(char *error) {
-  S2D_Log(S2D_ERROR, "%s (%d)", error, glGetError());
+void R2D_GL_PrintError(char *error) {
+  R2D_Log(R2D_ERROR, "%s (%d)", error, glGetError());
 }
 
 
 /*
  * Print info about the current OpenGL context
  */
-void S2D_GL_PrintContextInfo(S2D_Window *window) {
-  S2D_Log(S2D_INFO,
+void R2D_GL_PrintContextInfo(R2D_Window *window) {
+  R2D_Log(R2D_INFO,
     "OpenGL Context\n"
     "      GL_VENDOR: %s\n"
     "      GL_RENDERER: %s\n"
     "      GL_VERSION: %s\n"
     "      GL_SHADING_LANGUAGE_VERSION: %s",
-    window->S2D_GL_VENDOR,
-    window->S2D_GL_RENDERER,
-    window->S2D_GL_VERSION,
-    window->S2D_GL_SHADING_LANGUAGE_VERSION
+    window->R2D_GL_VENDOR,
+    window->R2D_GL_RENDERER,
+    window->R2D_GL_VERSION,
+    window->R2D_GL_SHADING_LANGUAGE_VERSION
   );
 }
 
@@ -46,22 +46,22 @@ void S2D_GL_PrintContextInfo(S2D_Window *window) {
 /*
  * Store info about the current OpenGL context
  */
-void S2D_GL_StoreContextInfo(S2D_Window *window) {
+void R2D_GL_StoreContextInfo(R2D_Window *window) {
 
-  window->S2D_GL_VENDOR   = glGetString(GL_VENDOR);
-  window->S2D_GL_RENDERER = glGetString(GL_RENDERER);
-  window->S2D_GL_VERSION  = glGetString(GL_VERSION);
+  window->R2D_GL_VENDOR   = glGetString(GL_VENDOR);
+  window->R2D_GL_RENDERER = glGetString(GL_RENDERER);
+  window->R2D_GL_VERSION  = glGetString(GL_VERSION);
 
   // These are not defined in GLES
   #if GLES
-    window->S2D_GL_MAJOR_VERSION = 0;
-    window->S2D_GL_MINOR_VERSION = 0;
+    window->R2D_GL_MAJOR_VERSION = 0;
+    window->R2D_GL_MINOR_VERSION = 0;
   #else
-    glGetIntegerv(GL_MAJOR_VERSION, &window->S2D_GL_MAJOR_VERSION);
-    glGetIntegerv(GL_MINOR_VERSION, &window->S2D_GL_MINOR_VERSION);
+    glGetIntegerv(GL_MAJOR_VERSION, &window->R2D_GL_MAJOR_VERSION);
+    glGetIntegerv(GL_MINOR_VERSION, &window->R2D_GL_MINOR_VERSION);
   #endif
 
-  window->S2D_GL_SHADING_LANGUAGE_VERSION = glGetString(GL_SHADING_LANGUAGE_VERSION);
+  window->R2D_GL_SHADING_LANGUAGE_VERSION = glGetString(GL_SHADING_LANGUAGE_VERSION);
 };
 
 
@@ -69,13 +69,13 @@ void S2D_GL_StoreContextInfo(S2D_Window *window) {
  * Creates a shader object, loads shader string, and compiles.
  * Returns 0 if shader could not be compiled.
  */
-GLuint S2D_GL_LoadShader(GLenum type, const GLchar *shaderSrc, char *shaderName) {
+GLuint R2D_GL_LoadShader(GLenum type, const GLchar *shaderSrc, char *shaderName) {
 
   // Create the shader object
   GLuint shader = glCreateShader(type);
 
   if (shader == 0) {
-    S2D_GL_PrintError("Failed to create shader program");
+    R2D_GL_PrintError("Failed to create shader program");
     return 0;
   }
 
@@ -111,7 +111,7 @@ GLuint S2D_GL_LoadShader(GLenum type, const GLchar *shaderSrc, char *shaderName)
 /*
  * Check if shader program was linked
  */
-int S2D_GL_CheckLinked(GLuint program, char *name) {
+int R2D_GL_CheckLinked(GLuint program, char *name) {
 
   GLint linked;
   glGetProgramiv(program, GL_LINK_STATUS, &linked);
@@ -138,7 +138,7 @@ int S2D_GL_CheckLinked(GLuint program, char *name) {
 /*
  * Calculate the viewport's scaled width and height
  */
-void S2D_GL_GetViewportScale(S2D_Window *window, int *w, int *h, double *scale) {
+void R2D_GL_GetViewportScale(R2D_Window *window, int *w, int *h, double *scale) {
 
   double s = fmin(
     window->width  / (double)window->viewport.width,
@@ -155,7 +155,7 @@ void S2D_GL_GetViewportScale(S2D_Window *window, int *w, int *h, double *scale)
 /*
  * Sets the viewport and matrix projection
  */
-void S2D_GL_SetViewport(S2D_Window *window) {
+void R2D_GL_SetViewport(R2D_Window *window) {
 
   int ortho_w = window->viewport.width;
   int ortho_h = window->viewport.height;
@@ -165,25 +165,25 @@ void S2D_GL_SetViewport(S2D_Window *window) {
 
   switch (window->viewport.mode) {
 
-    case S2D_FIXED:
+    case R2D_FIXED:
       w = window->orig_width;
       h = window->orig_height;
       y = window->height - h;
       break;
 
-    case S2D_EXPAND:
+    case R2D_EXPAND:
       ortho_w = w;
       ortho_h = h;
       break;
 
-    case S2D_SCALE:
-      S2D_GL_GetViewportScale(window, &w, &h, NULL);
+    case R2D_SCALE:
+      R2D_GL_GetViewportScale(window, &w, &h, NULL);
       // Center the viewport
       x = window->width  / 2.0 - w/2.0;
       y = window->height / 2.0 - h/2.0;
       break;
 
-    case S2D_STRETCH:
+    case R2D_STRETCH:
       break;
   }
 
@@ -194,12 +194,12 @@ void S2D_GL_SetViewport(S2D_Window *window) {
   orthoMatrix[5] = -2.0f / (GLfloat)ortho_h;
 
   #if GLES
-    S2D_GLES_ApplyProjection(orthoMatrix);
+    R2D_GLES_ApplyProjection(orthoMatrix);
   #else
-    if (S2D_GL2) {
-      S2D_GL2_ApplyProjection(ortho_w, ortho_h);
+    if (R2D_GL2) {
+      R2D_GL2_ApplyProjection(ortho_w, ortho_h);
     } else {
-      S2D_GL3_ApplyProjection(orthoMatrix);
+      R2D_GL3_ApplyProjection(orthoMatrix);
     }
   #endif
 }
@@ -208,7 +208,7 @@ void S2D_GL_SetViewport(S2D_Window *window) {
 /*
  * Initialize OpenGL
  */
-int S2D_GL_Init(S2D_Window *window) {
+int R2D_GL_Init(R2D_Window *window) {
 
   // Specify OpenGL contexts and set attributes
   #if GLES
@@ -244,25 +244,25 @@ int S2D_GL_Init(S2D_Window *window) {
 
     // Initialize OpenGL ES 2.0
     #if GLES
-      S2D_GLES_Init();
-      S2D_GL_SetViewport(window);
+      R2D_GLES_Init();
+      R2D_GL_SetViewport(window);
 
     // Initialize OpenGL 3.3+
     #else
       // Initialize GLEW on Windows
       #if WINDOWS
         GLenum err = glewInit();
-        if (GLEW_OK != err) S2D_Error("GLEW", glewGetErrorString(err));
+        if (GLEW_OK != err) R2D_Error("GLEW", glewGetErrorString(err));
       #endif
-      S2D_GL3_Init();
-      S2D_GL_SetViewport(window);
+      R2D_GL3_Init();
+      R2D_GL_SetViewport(window);
     #endif
 
   // Context could not be created
   } else {
 
     #if GLES
-      S2D_Error("GLES / SDL_GL_CreateContext", SDL_GetError());
+      R2D_Error("GLES / SDL_GL_CreateContext", SDL_GetError());
 
     #else
       // Try to fallback using an OpenGL 2.1 context
@@ -275,22 +275,22 @@ int S2D_GL_Init(S2D_Window *window) {
       // Check if this context was created
       if (window->glcontext) {
         // Valid context found
-        S2D_GL2 = true;
-        S2D_GL2_Init();
-        S2D_GL_SetViewport(window);
+        R2D_GL2 = true;
+        R2D_GL2_Init();
+        R2D_GL_SetViewport(window);
 
       // Could not create any OpenGL contexts, hard failure
       } else {
-        S2D_Error("GL2 / SDL_GL_CreateContext", SDL_GetError());
-        S2D_Log(S2D_ERROR, "An OpenGL context could not be created");
+        R2D_Error("GL2 / SDL_GL_CreateContext", SDL_GetError());
+        R2D_Log(R2D_ERROR, "An OpenGL context could not be created");
         return -1;
       }
     #endif
   }
 
   // Store the context and print it if diagnostics is enabled
-  S2D_GL_StoreContextInfo(window);
-  if (S2D_diagnostics) S2D_GL_PrintContextInfo(window);
+  R2D_GL_StoreContextInfo(window);
+  if (R2D_diagnostics) R2D_GL_PrintContextInfo(window);
 
   return 0;
 }
@@ -299,7 +299,7 @@ int S2D_GL_Init(S2D_Window *window) {
 /*
  * Creates a texture for rendering
  */
-void S2D_GL_CreateTexture(GLuint *id, GLint format,
+void R2D_GL_CreateTexture(GLuint *id, GLint format,
                           int w, int h,
                           const GLvoid *data, GLint filter) {
 
@@ -324,7 +324,7 @@ void S2D_GL_CreateTexture(GLuint *id, GLint format,
 /*
  * Free a texture
  */
-void S2D_GL_FreeTexture(GLuint *id) {
+void R2D_GL_FreeTexture(GLuint *id) {
   if (*id != 0) {
     glDeleteTextures(1, id);
     *id = 0;
@@ -335,7 +335,7 @@ void S2D_GL_FreeTexture(GLuint *id) {
 /*
  * Draw a triangle
  */
-void S2D_GL_DrawTriangle(GLfloat x1, GLfloat y1,
+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,
@@ -343,16 +343,16 @@ void S2D_GL_DrawTriangle(GLfloat x1, GLfloat y1,
                          GLfloat r3, GLfloat g3, GLfloat b3, GLfloat a3) {
 
   #if GLES
-    S2D_GLES_DrawTriangle(x1, y1, r1, g1, b1, a1,
+    R2D_GLES_DrawTriangle(x1, y1, r1, g1, b1, a1,
                           x2, y2, r2, g2, b2, a2,
                           x3, y3, r3, g3, b3, a3);
   #else
-    if (S2D_GL2) {
-      S2D_GL2_DrawTriangle(x1, y1, r1, g1, b1, a1,
+    if (R2D_GL2) {
+      R2D_GL2_DrawTriangle(x1, y1, r1, g1, b1, a1,
                            x2, y2, r2, g2, b2, a2,
                            x3, y3, r3, g3, b3, a3);
     } else {
-      S2D_GL3_DrawTriangle(x1, y1, r1, g1, b1, a1,
+      R2D_GL3_DrawTriangle(x1, y1, r1, g1, b1, a1,
                            x2, y2, r2, g2, b2, a2,
                            x3, y3, r3, g3, b3, a3);
     }
@@ -363,14 +363,14 @@ void S2D_GL_DrawTriangle(GLfloat x1, GLfloat y1,
 /*
  * Draw an image
  */
-void S2D_GL_DrawImage(S2D_Image *img) {
+void R2D_GL_DrawImage(R2D_Image *img) {
   #if GLES
-    S2D_GLES_DrawImage(img);
+    R2D_GLES_DrawImage(img);
   #else
-    if (S2D_GL2) {
-      S2D_GL2_DrawImage(img);
+    if (R2D_GL2) {
+      R2D_GL2_DrawImage(img);
     } else {
-      S2D_GL3_DrawImage(img);
+      R2D_GL3_DrawImage(img);
     }
   #endif
 }
@@ -379,14 +379,14 @@ void S2D_GL_DrawImage(S2D_Image *img) {
 /*
  * Draw sprite
  */
-void S2D_GL_DrawSprite(S2D_Sprite *spr) {
+void R2D_GL_DrawSprite(R2D_Sprite *spr) {
   #if GLES
-    S2D_GLES_DrawSprite(spr);
+    R2D_GLES_DrawSprite(spr);
   #else
-    if (S2D_GL2) {
-      S2D_GL2_DrawSprite(spr);
+    if (R2D_GL2) {
+      R2D_GL2_DrawSprite(spr);
     } else {
-      S2D_GL3_DrawSprite(spr);
+      R2D_GL3_DrawSprite(spr);
     }
   #endif
 }
@@ -395,14 +395,14 @@ void S2D_GL_DrawSprite(S2D_Sprite *spr) {
 /*
  * Draw text
  */
-void S2D_GL_DrawText(S2D_Text *txt) {
+void R2D_GL_DrawText(R2D_Text *txt) {
   #if GLES
-    S2D_GLES_DrawText(txt);
+    R2D_GLES_DrawText(txt);
   #else
-    if (S2D_GL2) {
-      S2D_GL2_DrawText(txt);
+    if (R2D_GL2) {
+      R2D_GL2_DrawText(txt);
     } else {
-      S2D_GL3_DrawText(txt);
+      R2D_GL3_DrawText(txt);
     }
   #endif
 }
@@ -411,12 +411,12 @@ void S2D_GL_DrawText(S2D_Text *txt) {
 /*
  * Render and flush OpenGL buffers
  */
-void S2D_GL_FlushBuffers() {
+void R2D_GL_FlushBuffers() {
   // Only implemented in our OpenGL 3.3+ and ES 2.0 renderers
   #if GLES
-    // TODO: S2D_GLES_FlushBuffers();
+    // TODO: R2D_GLES_FlushBuffers();
   #else
-    if (!S2D_GL2) S2D_GL3_FlushBuffers();
+    if (!R2D_GL2) R2D_GL3_FlushBuffers();
   #endif
 }
 
@@ -424,7 +424,7 @@ void S2D_GL_FlushBuffers() {
 /*
  * Clear buffers to given color values
  */
-void S2D_GL_Clear(S2D_Color clr) {
+void R2D_GL_Clear(R2D_Color clr) {
   glClearColor(clr.r, clr.g, clr.b, clr.a);
   glClear(GL_COLOR_BUFFER_BIT);
 }