ruby2d 0.9.2 → 0.10.0

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

@@ -1,12 +1,19 @@
-// OpenGL 3.3
+// OpenGL 3.3+
 
-#include "../include/simple2d.h"
+#include "ruby2d.h"
 
+// Skip this file if OpenGL ES
 #if !GLES
 
-static GLuint shaderProgram;
-static GLuint texShaderProgram;
-static GLuint indices[] =
+static GLuint vbo;  // our primary vertex buffer object (VBO)
+static GLuint vboSize;  // size of the VBO in bytes
+static GLfloat *vboData;  // pointer to the VBO data
+static GLfloat *vboDataCurrent;  // pointer to the data for the current vertices
+static GLuint vboDataIndex = 0;  // index of the current object being rendered
+static GLuint vboObjCapacity = 2500;  // number of objects the VBO can store
+static GLuint shaderProgram;  // triangle shader program
+static GLuint texShaderProgram;  // texture shader program
+static GLuint indices[] =  // indices for rendering textured quads
   { 0, 1, 2,
     2, 3, 0 };
 
@@ -14,11 +21,12 @@ static GLuint indices[] =
 /*
  * Applies the projection matrix
  */
-void S2D_GL3_ApplyProjection(GLfloat orthoMatrix[16]) {
+void R2D_GL3_ApplyProjection(GLfloat orthoMatrix[16]) {
 
   // Use the program object
   glUseProgram(shaderProgram);
 
+  // Apply the projection matrix to the triangle shader
   glUniformMatrix4fv(
     glGetUniformLocation(shaderProgram, "u_mvpMatrix"),
     1, GL_FALSE, orthoMatrix
@@ -27,6 +35,7 @@ void S2D_GL3_ApplyProjection(GLfloat orthoMatrix[16]) {
   // Use the texture program object
   glUseProgram(texShaderProgram);
 
+  // Apply the projection matrix to the texture shader
   glUniformMatrix4fv(
     glGetUniformLocation(texShaderProgram, "u_mvpMatrix"),
     1, GL_FALSE, orthoMatrix
@@ -37,7 +46,7 @@ void S2D_GL3_ApplyProjection(GLfloat orthoMatrix[16]) {
 /*
  * Initalize OpenGL
  */
-int S2D_GL3_Init() {
+int R2D_GL3_Init() {
 
   // Enable transparency
   glEnable(GL_BLEND);
@@ -45,65 +54,80 @@ int S2D_GL3_Init() {
 
   // Vertex shader source string
   GLchar vertexSource[] =
-    "#version 150 core\n"
-    "uniform mat4 u_mvpMatrix;"
-    "in vec4 position;"
-    "in vec4 color;"
-    "in vec2 texcoord;"
-    "out vec4 Color;"
-    "out vec2 Texcoord;"
+    "#version 150 core\n"  // shader version
+
+    "uniform mat4 u_mvpMatrix;"  // projection matrix
+
+    // Input attributes to the vertex shader
+    "in vec4 position;"  // position value
+    "in vec4 color;"     // vertex color
+    "in vec2 texcoord;"  // texture coordinates
+
+    // Outputs to the fragment shader
+    "out vec4 Color;"     // vertex color
+    "out vec2 Texcoord;"  // texture coordinates
+
     "void main() {"
+    // Send the color and texture coordinates right through to the fragment shader
     "  Color = color;"
     "  Texcoord = texcoord;"
+    // Transform the vertex position using the projection matrix
     "  gl_Position = u_mvpMatrix * position;"
     "}";
 
   // Fragment shader source string
   GLchar fragmentSource[] =
-    "#version 150 core\n"
-    "in vec4 Color;"
-    "out vec4 outColor;"
+    "#version 150 core\n"  // shader version
+    "in vec4 Color;"       // input color from vertex shader
+    "out vec4 outColor;"   // output fragment color
+
     "void main() {"
-    "  outColor = Color;"
+    "  outColor = Color;"  // pass the color right through
     "}";
 
   // Fragment shader source string for textures
   GLchar texFragmentSource[] =
-    "#version 150 core\n"
-    "in vec4 Color;"
-    "in vec2 Texcoord;"
-    "out vec4 outColor;"
-    "uniform sampler2D tex;"
+    "#version 150 core\n"     // shader version
+    "in vec4 Color;"          // input color from vertex shader
+    "in vec2 Texcoord;"       // input texture coordinates
+    "out vec4 outColor;"      // output fragment color
+    "uniform sampler2D tex;"  // 2D texture unit
+
     "void main() {"
+    // Apply the texture unit, texture coordinates, and color
     "  outColor = texture(tex, Texcoord) * Color;"
     "}";
 
-  // Create Vertex Array Object
+  // Create a vertex array object
   GLuint vao;
   glGenVertexArrays(1, &vao);
   glBindVertexArray(vao);
 
-  // Create Vertex Buffer Object
-  GLuint vbo;
+  // Create a vertex buffer object and allocate data
   glGenBuffers(1, &vbo);
   glBindBuffer(GL_ARRAY_BUFFER, vbo);
+  vboSize = vboObjCapacity * sizeof(GLfloat) * 24;
+  vboData = (GLfloat *) malloc(vboSize);
+  vboDataCurrent = vboData;
 
-  // Create an element array
+  // Create an element buffer object
   GLuint ebo;
   glGenBuffers(1, &ebo);
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
 
   // Load the vertex and fragment shaders
-  GLuint vertexShader      = S2D_GL_LoadShader(  GL_VERTEX_SHADER,      vertexSource, "GL3 Vertex");
-  GLuint fragmentShader    = S2D_GL_LoadShader(GL_FRAGMENT_SHADER,    fragmentSource, "GL3 Fragment");
-  GLuint texFragmentShader = S2D_GL_LoadShader(GL_FRAGMENT_SHADER, texFragmentSource, "GL3 Texture Fragment");
+  GLuint vertexShader      = R2D_GL_LoadShader(  GL_VERTEX_SHADER,      vertexSource, "GL3 Vertex");
+  GLuint fragmentShader    = R2D_GL_LoadShader(GL_FRAGMENT_SHADER,    fragmentSource, "GL3 Fragment");
+  GLuint texFragmentShader = R2D_GL_LoadShader(GL_FRAGMENT_SHADER, texFragmentSource, "GL3 Texture Fragment");
+
+  // Triangle Shader //
 
   // Create the shader program object
   shaderProgram = glCreateProgram();
 
   // Check if program was created successfully
   if (shaderProgram == 0) {
-    S2D_GL_PrintError("Failed to create shader program");
+    R2D_GL_PrintError("Failed to create shader program");
     return GL_FALSE;
   }
 
@@ -111,52 +135,60 @@ int S2D_GL3_Init() {
   glAttachShader(shaderProgram, vertexShader);
   glAttachShader(shaderProgram, fragmentShader);
 
-  // Bind the varying out variables to the fragment shader color number
+  // Bind the output color variable to the fragment shader color number
   glBindFragDataLocation(shaderProgram, 0, "outColor");
 
   // Link the shader program
   glLinkProgram(shaderProgram);
 
   // Check if linked
-  S2D_GL_CheckLinked(shaderProgram, "GL3 shader");
+  R2D_GL_CheckLinked(shaderProgram, "GL3 shader");
 
-  // Specify the layout of the vertex data
+  // Specify the layout of the position vertex data...
   GLint posAttrib = glGetAttribLocation(shaderProgram, "position");
-  glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), 0);
   glEnableVertexAttribArray(posAttrib);
+  glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), 0);
 
+  // ...and the color vertex data
   GLint colAttrib = glGetAttribLocation(shaderProgram, "color");
-  glVertexAttribPointer(colAttrib, 4, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void*)(2 * sizeof(GLfloat)));
   glEnableVertexAttribArray(colAttrib);
+  glVertexAttribPointer(colAttrib, 4, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void*)(2 * sizeof(GLfloat)));
+
+  // Texture Shader //
 
   // Create the texture shader program object
   texShaderProgram = glCreateProgram();
 
   // Check if program was created successfully
   if (texShaderProgram == 0) {
-    S2D_GL_PrintError("Failed to create shader program");
+    R2D_GL_PrintError("Failed to create shader program");
     return GL_FALSE;
   }
 
+  // Attach the shader objects to the program object
   glAttachShader(texShaderProgram, vertexShader);
   glAttachShader(texShaderProgram, texFragmentShader);
 
+  // Bind the output color variable to the fragment shader color number
   glBindFragDataLocation(texShaderProgram, 0, "outColor");
 
+  // Link the shader program
   glLinkProgram(texShaderProgram);
 
   // Check if linked
-  S2D_GL_CheckLinked(texShaderProgram, "GL3 texture shader");
+  R2D_GL_CheckLinked(texShaderProgram, "GL3 texture shader");
 
-  // Specify the layout of the vertex data
+  // Specify the layout of the position vertex data...
   posAttrib = glGetAttribLocation(texShaderProgram, "position");
   glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), 0);
   glEnableVertexAttribArray(posAttrib);
 
+  // ...and the color vertex data...
   colAttrib = glGetAttribLocation(texShaderProgram, "color");
   glVertexAttribPointer(colAttrib, 4, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void*)(2 * sizeof(GLfloat)));
   glEnableVertexAttribArray(colAttrib);
 
+  // ...and the texture coordinates
   GLint texAttrib = glGetAttribLocation(texShaderProgram, "texcoord");
   glVertexAttribPointer(texAttrib, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void*)(6 * sizeof(GLfloat)));
   glEnableVertexAttribArray(texAttrib);
@@ -166,54 +198,90 @@ int S2D_GL3_Init() {
   glDeleteShader(fragmentShader);
   glDeleteShader(texFragmentShader);
 
+  // If successful, return true
   return GL_TRUE;
 }
 
 
+/*
+ * Render the vertex buffer and reset it
+ */
+void R2D_GL3_FlushBuffers() {
+
+  // Use the triangle shader program
+  glUseProgram(shaderProgram);
+
+  // Bind to the vertex buffer object and update its data
+  glBindBuffer(GL_ARRAY_BUFFER, vbo);
+  glBufferData(GL_ARRAY_BUFFER, vboSize, NULL, GL_DYNAMIC_DRAW);
+  glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(GLfloat) * vboDataIndex * 24, vboData);
+
+  // Render all the triangles in the buffer
+  glDrawArrays(GL_TRIANGLES, 0, (GLsizei)(vboDataIndex * 3));
+
+  // Reset the buffer object index and data pointer
+  vboDataIndex = 0;
+  vboDataCurrent = vboData;
+}
+
+
 /*
  * Draw triangle
  */
-void S2D_GL3_DrawTriangle(GLfloat x1, GLfloat y1,
+void R2D_GL3_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) {
 
+  // If buffer is full, flush it
+  if (vboDataIndex >= vboObjCapacity) R2D_GL3_FlushBuffers();
+
+  // Set the triangle data into a formatted array
   GLfloat vertices[] =
     { x1, y1, r1, g1, b1, a1, 0, 0,
       x2, y2, r2, g2, b2, a2, 0, 0,
       x3, y3, r3, g3, b3, a3, 0, 0 };
 
-  glUseProgram(shaderProgram);
-  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
-  glDrawArrays(GL_TRIANGLES, 0, 3);
+  // Copy the vertex data into the current position of the buffer
+  memcpy(vboDataCurrent, vertices, sizeof(vertices));
+
+  // Increment the buffer object index and the vertex data pointer for next use
+  vboDataIndex++;
+  vboDataCurrent = (GLfloat *)((char *)vboDataCurrent + (sizeof(GLfloat) * 24));
 }
 
 
 /*
  * Draw a texture
  */
-static void S2D_GL3_DrawTexture(int x, int y, int w, int h,
+static void R2D_GL3_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 };
+  // Currently, textures are not buffered, so we have to flush all buffers so
+  // textures get rendered in the correct Z order
+  R2D_GL3_FlushBuffers();
+
+  // Set up the vertex points
+  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);
   }
 
+  // Set the textured quad data into a formatted array
   GLfloat vertices[] =
   //  vertex coords | colors      | x, y texture coords
     { v1.x, v1.y,     r, g, b, a,   tx1, ty1,    // Top-left
@@ -221,12 +289,17 @@ static void S2D_GL3_DrawTexture(int x, int y, int w, int h,
       v3.x, v3.y,     r, g, b, a,   tx3, ty3,    // Bottom-right
       v4.x, v4.y,     r, g, b, a,   tx4, ty4 };  // Bottom-left
 
+  // Use the texture shader program
   glUseProgram(texShaderProgram);
+
+  // Bind the texture using the provided ID
   glBindTexture(GL_TEXTURE_2D, texture_id);
 
+  // Create and Initialize the vertex data and array indices
   glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
   glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
 
+  // Render the textured quad
   glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
 }
 
@@ -234,8 +307,8 @@ static void S2D_GL3_DrawTexture(int x, int y, int w, int h,
 /*
  * Draw image
  */
-void S2D_GL3_DrawImage(S2D_Image *img) {
-  S2D_GL3_DrawTexture(
+void R2D_GL3_DrawImage(R2D_Image *img) {
+  R2D_GL3_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,
@@ -248,8 +321,8 @@ void S2D_GL3_DrawImage(S2D_Image *img) {
 /*
  * Draw sprite
  */
-void S2D_GL3_DrawSprite(S2D_Sprite *spr) {
-  S2D_GL3_DrawTexture(
+void R2D_GL3_DrawSprite(R2D_Sprite *spr) {
+  R2D_GL3_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,
@@ -259,11 +332,26 @@ void S2D_GL3_DrawSprite(S2D_Sprite *spr) {
 }
 
 
+/*
+ * Draw a tile
+ */
+void R2D_GL3_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_GL3_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_GL3_DrawText(S2D_Text *txt) {
-  S2D_GL3_DrawTexture(
+void R2D_GL3_DrawText(R2D_Text *txt) {
+  R2D_GL3_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,

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

@@ -1,6 +1,6 @@
 // OpenGL ES 2.0
 
-#include "../include/simple2d.h"
+#include "ruby2d.h"
 
 #if GLES
 
@@ -24,7 +24,7 @@ static GLushort indices[] =
 /*
  * Applies the projection matrix
  */
-void S2D_GLES_ApplyProjection(GLfloat orthoMatrix[16]) {
+void R2D_GLES_ApplyProjection(GLfloat orthoMatrix[16]) {
 
   // Use the program object
   glUseProgram(shaderProgram);
@@ -47,7 +47,7 @@ void S2D_GLES_ApplyProjection(GLfloat orthoMatrix[16]) {
 /*
  * Initalize OpenGL ES
  */
-int S2D_GLES_Init() {
+int R2D_GLES_Init() {
 
   // Enable transparency
   glEnable(GL_BLEND);
@@ -99,9 +99,9 @@ int S2D_GLES_Init() {
     "}";
 
   // Load the vertex and fragment shaders
-  GLuint vertexShader      = S2D_GL_LoadShader(  GL_VERTEX_SHADER,      vertexSource, "GLES Vertex");
-  GLuint fragmentShader    = S2D_GL_LoadShader(GL_FRAGMENT_SHADER,    fragmentSource, "GLES Fragment");
-  GLuint texFragmentShader = S2D_GL_LoadShader(GL_FRAGMENT_SHADER, texFragmentSource, "GLES Texture Fragment");
+  GLuint vertexShader      = R2D_GL_LoadShader(  GL_VERTEX_SHADER,      vertexSource, "GLES Vertex");
+  GLuint fragmentShader    = R2D_GL_LoadShader(GL_FRAGMENT_SHADER,    fragmentSource, "GLES Fragment");
+  GLuint texFragmentShader = R2D_GL_LoadShader(GL_FRAGMENT_SHADER, texFragmentSource, "GLES Texture Fragment");
 
   // Triangle Shader //
 
@@ -110,7 +110,7 @@ int S2D_GLES_Init() {
 
   // Check if program was created successfully
   if (shaderProgram == 0) {
-    S2D_GL_PrintError("Failed to create shader program");
+    R2D_GL_PrintError("Failed to create shader program");
     return GL_FALSE;
   }
 
@@ -122,7 +122,7 @@ int S2D_GLES_Init() {
   glLinkProgram(shaderProgram);
 
   // Check if linked
-  S2D_GL_CheckLinked(shaderProgram, "GLES shader");
+  R2D_GL_CheckLinked(shaderProgram, "GLES shader");
 
   // Get the attribute locations
   positionLocation = glGetAttribLocation(shaderProgram, "a_position");
@@ -135,7 +135,7 @@ int S2D_GLES_Init() {
 
   // Check if program was created successfully
   if (texShaderProgram == 0) {
-    S2D_GL_PrintError("Failed to create shader program");
+    R2D_GL_PrintError("Failed to create shader program");
     return GL_FALSE;
   }
 
@@ -147,7 +147,7 @@ int S2D_GLES_Init() {
   glLinkProgram(texShaderProgram);
 
   // Check if linked
-  S2D_GL_CheckLinked(texShaderProgram, "GLES texture shader");
+  R2D_GL_CheckLinked(texShaderProgram, "GLES texture shader");
 
   // Get the attribute locations
   texPositionLocation = glGetAttribLocation(texShaderProgram, "a_position");
@@ -169,7 +169,7 @@ int S2D_GLES_Init() {
 /*
  * Draw triangle
  */
-void S2D_GLES_DrawTriangle(GLfloat x1, GLfloat y1,
+void R2D_GLES_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,
@@ -204,24 +204,24 @@ void S2D_GLES_DrawTriangle(GLfloat x1, GLfloat y1,
 /*
  * Draw a texture
  */
-static void S2D_GLES_DrawTexture(int x, int y, int w, int h,
+static void R2D_GLES_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);
   }
 
   GLfloat vertices[] =
@@ -267,8 +267,8 @@ static void S2D_GLES_DrawTexture(int x, int y, int w, int h,
 /*
  * Draw image
  */
-void S2D_GLES_DrawImage(S2D_Image *img) {
-  S2D_GLES_DrawTexture(
+void R2D_GLES_DrawImage(R2D_Image *img) {
+  R2D_GLES_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,
@@ -281,8 +281,8 @@ void S2D_GLES_DrawImage(S2D_Image *img) {
 /*
  * Draw sprite
  */
-void S2D_GLES_DrawSprite(S2D_Sprite *spr) {
-  S2D_GLES_DrawTexture(
+void R2D_GLES_DrawSprite(R2D_Sprite *spr) {
+  R2D_GLES_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,
@@ -292,11 +292,26 @@ void S2D_GLES_DrawSprite(S2D_Sprite *spr) {
 }
 
 
+/*
+ * Draw a tile
+ */
+void R2D_GLES_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_GLES_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_GLES_DrawText(S2D_Text *txt) {
-  S2D_GLES_DrawTexture(
+void R2D_GLES_DrawText(R2D_Text *txt) {
+  R2D_GLES_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,