ruby2d 0.9.3 → 0.11.0

data/ext/ruby2d/font.c

@@ -0,0 +1,35 @@
+// font.c
+
+#include "ruby2d.h"
+
+
+/*
+ * Create a TTF_Font object given a path to a font and a size
+ */
+TTF_Font *R2D_FontCreateTTFFont(const char *path, int size, const char *style) {
+
+ // Check if font file exists
+  if (!R2D_FileExists(path)) {
+    R2D_Error("R2D_FontCreateTTFFont", "Font file `%s` not found", path);
+    return NULL;
+  }
+
+  TTF_Font *font = TTF_OpenFont(path, size);
+
+  if (!font) {
+    R2D_Error("TTF_OpenFont", TTF_GetError());
+    return NULL;
+  }
+
+  if(strncmp(style, "bold", 4) == 0) {
+    TTF_SetFontStyle(font, TTF_STYLE_BOLD);
+  } else if(strncmp(style, "italic", 6) == 0) {
+    TTF_SetFontStyle(font, TTF_STYLE_ITALIC);
+  } else if(strncmp(style, "underline", 9) == 0) {
+    TTF_SetFontStyle(font, TTF_STYLE_UNDERLINE);
+  } else if(strncmp(style, "strikethrough", 13) == 0) {
+    TTF_SetFontStyle(font, TTF_STYLE_STRIKETHROUGH);
+  }
+
+  return font;
+}

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,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, const 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, const 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);
     }
@@ -370,49 +361,30 @@ 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);
+      R2D_GL3_DrawTexture(coordinates, texture_coordinates, color, texture_id);
     }
   #endif
 }
 
 
 /*
- * Draw sprite
+ * Render and flush OpenGL buffers
  */
-void S2D_GL_DrawSprite(S2D_Sprite *spr) {
+void R2D_GL_FlushBuffers() {
+  // Only implemented in our OpenGL 3.3+ and ES 2.0 renderers
   #if GLES
-    S2D_GLES_DrawSprite(spr);
+    // TODO: R2D_GLES_FlushBuffers();
   #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);
-    }
+    if (!R2D_GL2) R2D_GL3_FlushBuffers();
   #endif
 }
 
@@ -420,7 +392,7 @@ void S2D_GL_DrawText(S2D_Text *txt) {
 /*
  * 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