ruby2d 0.9.4 → 0.11.1

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(const 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, const 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, const 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);
     }
@@ -361,48 +361,16 @@ void S2D_GL_DrawTriangle(GLfloat x1, GLfloat y1,
 
 
 /*
- * Draw an image
+ * Draw a texture
  */
-void S2D_GL_DrawImage(S2D_Image *img) {
+void R2D_GL_DrawTexture(GLfloat coordinates[], GLfloat texture_coordinates[], GLfloat color[], int texture_id) {
   #if GLES
-    S2D_GLES_DrawImage(img);
+    R2D_GLES_DrawTexture(coordinates, texture_coordinates, color, texture_id);
   #else
-    if (S2D_GL2) {
-      S2D_GL2_DrawImage(img);
+    if (R2D_GL2) {
+      R2D_GL2_DrawTexture(coordinates, texture_coordinates, color, texture_id);
     } else {
-      S2D_GL3_DrawImage(img);
-    }
-  #endif
-}
-
-
-/*
- * Draw sprite
- */
-void S2D_GL_DrawSprite(S2D_Sprite *spr) {
-  #if GLES
-    S2D_GLES_DrawSprite(spr);
-  #else
-    if (S2D_GL2) {
-      S2D_GL2_DrawSprite(spr);
-    } else {
-      S2D_GL3_DrawSprite(spr);
-    }
-  #endif
-}
-
-
-/*
- * Draw text
- */
-void S2D_GL_DrawText(S2D_Text *txt) {
-  #if GLES
-    S2D_GLES_DrawText(txt);
-  #else
-    if (S2D_GL2) {
-      S2D_GL2_DrawText(txt);
-    } else {
-      S2D_GL3_DrawText(txt);
+      R2D_GL3_DrawTexture(coordinates, texture_coordinates, color, texture_id);
     }
   #endif
 }
@@ -411,12 +379,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 +392,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);
 }

data/ext/ruby2d/gl2.c

@@ -0,0 +1,86 @@
+// OpenGL 2.1
+
+#include "ruby2d.h"
+
+#if !GLES
+
+
+/*
+ * Applies the projection matrix
+ */
+void R2D_GL2_ApplyProjection(int w, int h) {
+
+  // Initialize the projection matrix
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+
+  // Multiply the current matrix with the orthographic matrix
+  glOrtho(0.f, w, h, 0.f, -1.f, 1.f);
+
+  // Initialize the model-view matrix
+  glMatrixMode(GL_MODELVIEW);
+  glLoadIdentity();
+}
+
+
+/*
+ * Initalize OpenGL
+ */
+int R2D_GL2_Init() {
+
+  GLenum error = GL_NO_ERROR;
+
+  // Enable transparency
+  glEnable(GL_BLEND);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+  // Check for errors
+  error = glGetError();
+  if (error != GL_NO_ERROR) {
+    R2D_GL_PrintError("OpenGL initialization failed");
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+
+/*
+ * Draw triangle
+ */
+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) {
+
+  glBegin(GL_TRIANGLES);
+    glColor4f(r1, g1, b1, a1); glVertex2f(x1, y1);
+    glColor4f(r2, g2, b2, a2); glVertex2f(x2, y2);
+    glColor4f(r3, g3, b3, a3); glVertex2f(x3, y3);
+  glEnd();
+}
+
+
+/*
+ * Draw a texture (New method with vertices pre-calculated)
+ */
+void R2D_GL2_DrawTexture(GLfloat coordinates[], GLfloat texture_coordinates[], GLfloat color[], int texture_id) {
+  glEnable(GL_TEXTURE_2D);
+
+  glBindTexture(GL_TEXTURE_2D, texture_id);
+
+  glBegin(GL_QUADS);
+    glColor4f(color[0], color[1], color[2], color[3]);
+    glTexCoord2f(texture_coordinates[0], texture_coordinates[1]); glVertex2f(coordinates[0], coordinates[1]);
+    glTexCoord2f(texture_coordinates[2], texture_coordinates[3]); glVertex2f(coordinates[2], coordinates[3]);
+    glTexCoord2f(texture_coordinates[4], texture_coordinates[5]); glVertex2f(coordinates[4], coordinates[5]);
+    glTexCoord2f(texture_coordinates[6], texture_coordinates[7]); glVertex2f(coordinates[6], coordinates[7]);
+  glEnd();
+
+  glDisable(GL_TEXTURE_2D);
+};
+
+
+#endif