ruby2d 0.9.2 → 0.10.0

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,21 +46,22 @@ void S2D_GL_PrintContextInfo(S2D_Window *window) {
 /*
  * Store info about the current OpenGL context
  */
-void S2D_GL_StoreContextInfo(S2D_Window *window) {
-  window->S2D_GL_VENDOR   = glGetString(GL_VENDOR);
-  window->S2D_GL_RENDERER = glGetString(GL_RENDERER);
-  window->S2D_GL_VERSION  = glGetString(GL_VERSION);
+void R2D_GL_StoreContextInfo(R2D_Window *window) {
+
+  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);
 };
 
 
@@ -68,16 +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 shader;
-  GLint compiled;
+GLuint R2D_GL_LoadShader(GLenum type, const GLchar *shaderSrc, char *shaderName) {
 
   // Create the shader object
-  shader = glCreateShader(type);
+  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;
   }
 
@@ -88,21 +86,17 @@ GLuint S2D_GL_LoadShader(GLenum type, const GLchar *shaderSrc, char *shaderName)
   glCompileShader(shader);
 
   // Check the compile status
+  GLint compiled;
   glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
 
   if (!compiled) {
-
     GLint infoLen = 0;
-
     glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
 
     if (infoLen > 1) {
-
       char *infoLog = malloc(sizeof(char) * infoLen);
-
       glGetShaderInfoLog(shader, infoLen, NULL, infoLog);
       printf("Error compiling shader \"%s\":\n%s\n", shaderName, infoLog);
-
       free(infoLog);
     }
 
@@ -117,23 +111,19 @@ 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);
 
   if (!linked) {
-
     GLint infoLen = 0;
     glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLen);
 
     if (infoLen > 1) {
-
       char *infoLog = malloc(sizeof(char) * infoLen);
-
       glGetProgramInfoLog(program, infoLen, NULL, infoLog);
       printf("Error linking program `%s`: %s\n", name, infoLog);
-
       free(infoLog);
     }
 
@@ -148,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,
@@ -165,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;
@@ -175,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;
   }
 
@@ -204,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
 }
@@ -218,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
@@ -231,6 +221,7 @@ int S2D_GL_Init(S2D_Window *window) {
     if (FORCE_GL2) {
       SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
       SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
+
     // Request an OpenGL 3.3 forward-compatible core profile
     } else {
       SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
@@ -253,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
@@ -284,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;
 }
@@ -308,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) {
 
@@ -333,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;
@@ -344,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,
@@ -352,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);
     }
@@ -372,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
 }
@@ -388,14 +379,31 @@ 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
+    R2D_GLES_DrawSprite(spr);
+  #else
+    if (R2D_GL2) {
+      R2D_GL2_DrawSprite(spr);
+    } else {
+      R2D_GL3_DrawSprite(spr);
+    }
+  #endif
+}
+
+
+/*
+ * Draw a tile
+ */
+void R2D_GL_DrawTile(R2D_Image *img, int x, int y, int tw, int th, GLfloat tx1, GLfloat ty1, GLfloat tx2,
+  GLfloat ty2, GLfloat tx3, GLfloat ty3, GLfloat tx4, GLfloat ty4) {
   #if GLES
-    S2D_GLES_DrawSprite(spr);
+    R2D_GLES_DrawTile(img, x, y, tw, th, tx1, ty1, tx2, ty2, tx3, ty3, tx4, ty4);
   #else
-    if (S2D_GL2) {
-      S2D_GL2_DrawSprite(spr);
+    if (R2D_GL2) {
+      R2D_GL2_DrawTile(img, x, y, tw, th, tx1, ty1, tx2, ty2, tx3, ty3, tx4, ty4);
     } else {
-      S2D_GL3_DrawSprite(spr);
+      R2D_GL3_DrawTile(img, x, y, tw, th, tx1, ty1, tx2, ty2, tx3, ty3, tx4, ty4);
     }
   #endif
 }
@@ -404,23 +412,36 @@ 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
 }
 
 
+/*
+ * Render and flush OpenGL buffers
+ */
+void R2D_GL_FlushBuffers() {
+  // Only implemented in our OpenGL 3.3+ and ES 2.0 renderers
+  #if GLES
+    // TODO: R2D_GLES_FlushBuffers();
+  #else
+    if (!R2D_GL2) R2D_GL3_FlushBuffers();
+  #endif
+}
+
+
 /*
  * 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);
 }

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

@@ -1,6 +1,6 @@
 // OpenGL 2.1
 
-#include "../include/simple2d.h"
+#include "ruby2d.h"
 
 #if !GLES
 
@@ -8,7 +8,7 @@
 /*
  * Applies the projection matrix
  */
-void S2D_GL2_ApplyProjection(int w, int h) {
+void R2D_GL2_ApplyProjection(int w, int h) {
 
   // Initialize the projection matrix
   glMatrixMode(GL_PROJECTION);
@@ -26,7 +26,7 @@ void S2D_GL2_ApplyProjection(int w, int h) {
 /*
  * Initalize OpenGL
  */
-int S2D_GL2_Init() {
+int R2D_GL2_Init() {
 
   GLenum error = GL_NO_ERROR;
 
@@ -37,7 +37,7 @@ int S2D_GL2_Init() {
   // Check for errors
   error = glGetError();
   if (error != GL_NO_ERROR) {
-    S2D_GL_PrintError("OpenGL initialization failed");
+    R2D_GL_PrintError("OpenGL initialization failed");
     return 1;
   } else {
     return 0;
@@ -48,7 +48,7 @@ int S2D_GL2_Init() {
 /*
  * Draw triangle
  */
-void S2D_GL2_DrawTriangle(GLfloat x1, GLfloat y1,
+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,
@@ -66,24 +66,24 @@ void S2D_GL2_DrawTriangle(GLfloat x1, GLfloat y1,
 /*
  * Draw texture
  */
-static void S2D_GL2_DrawTexture(int x, int y, int w, int h,
+static void R2D_GL2_DrawTexture(int x, int y, int w, int h,
                                 GLfloat angle, GLfloat rx, GLfloat ry,
                                 GLfloat r, GLfloat g, GLfloat b, GLfloat a,
                                 GLfloat tx1, GLfloat ty1, GLfloat tx2, GLfloat ty2,
                                 GLfloat tx3, GLfloat ty3, GLfloat tx4, GLfloat ty4,
                                 GLuint texture_id) {
 
-  S2D_GL_Point v1 = { .x = x,     .y = y     };
-  S2D_GL_Point v2 = { .x = x + w, .y = y     };
-  S2D_GL_Point v3 = { .x = x + w, .y = y + h };
-  S2D_GL_Point v4 = { .x = x,     .y = y + h };
+  R2D_GL_Point v1 = { .x = x,     .y = y     };
+  R2D_GL_Point v2 = { .x = x + w, .y = y     };
+  R2D_GL_Point v3 = { .x = x + w, .y = y + h };
+  R2D_GL_Point v4 = { .x = x,     .y = y + h };
 
   // Rotate vertices
   if (angle != 0) {
-    v1 = S2D_RotatePoint(v1, angle, rx, ry);
-    v2 = S2D_RotatePoint(v2, angle, rx, ry);
-    v3 = S2D_RotatePoint(v3, angle, rx, ry);
-    v4 = S2D_RotatePoint(v4, angle, rx, ry);
+    v1 = R2D_RotatePoint(v1, angle, rx, ry);
+    v2 = R2D_RotatePoint(v2, angle, rx, ry);
+    v3 = R2D_RotatePoint(v3, angle, rx, ry);
+    v4 = R2D_RotatePoint(v4, angle, rx, ry);
   }
 
   glEnable(GL_TEXTURE_2D);
@@ -105,8 +105,8 @@ static void S2D_GL2_DrawTexture(int x, int y, int w, int h,
 /*
  * Draw image
  */
-void S2D_GL2_DrawImage(S2D_Image *img) {
-  S2D_GL2_DrawTexture(
+void R2D_GL2_DrawImage(R2D_Image *img) {
+  R2D_GL2_DrawTexture(
     img->x, img->y, img->width, img->height,
     img->rotate, img->rx, img->ry,
     img->color.r, img->color.g, img->color.b, img->color.a,
@@ -119,8 +119,8 @@ void S2D_GL2_DrawImage(S2D_Image *img) {
 /*
  * Draw sprite
  */
-void S2D_GL2_DrawSprite(S2D_Sprite *spr) {
-  S2D_GL2_DrawTexture(
+void R2D_GL2_DrawSprite(R2D_Sprite *spr) {
+  R2D_GL2_DrawTexture(
     spr->x, spr->y, spr->width, spr->height,
     spr->rotate, spr->rx, spr->ry,
     spr->color.r, spr->color.g, spr->color.b, spr->color.a,
@@ -130,11 +130,26 @@ void S2D_GL2_DrawSprite(S2D_Sprite *spr) {
 }
 
 
+/*
+ * Draw a tile
+ */
+void R2D_GL2_DrawTile(R2D_Image *img, int x, int y, int tw, int th, GLfloat tx1, GLfloat ty1, GLfloat tx2,
+GLfloat ty2, GLfloat tx3, GLfloat ty3, GLfloat tx4, GLfloat ty4) {
+  R2D_GL2_DrawTexture(
+    x, y, tw, th,
+    img->rotate, img->rx, img->ry,
+    img->color.r, img->color.g, img->color.b, img->color.a,
+    tx1, ty1, tx2, ty2, tx3, ty3, tx4, ty4,
+    img->texture_id
+  );
+}
+
+
 /*
  * Draw text
  */
-void S2D_GL2_DrawText(S2D_Text *txt) {
-  S2D_GL2_DrawTexture(
+void R2D_GL2_DrawText(R2D_Text *txt) {
+  R2D_GL2_DrawTexture(
     txt->x, txt->y, txt->width, txt->height,
     txt->rotate, txt->rx, txt->ry,
     txt->color.r, txt->color.g, txt->color.b, txt->color.a,