ruby2d 0.9.0 → 0.9.1

data/assets/linux/simple2d/src/gl2.c

@@ -0,0 +1,146 @@
+// OpenGL 2.1
+
+#include "../include/simple2d.h"
+
+#if !GLES
+
+
+/*
+ * Applies the projection matrix
+ */
+void S2D_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 S2D_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) {
+    S2D_GL_PrintError("OpenGL initialization failed");
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+
+/*
+ * Draw triangle
+ */
+void S2D_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 texture
+ */
+static void S2D_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 };
+
+  // 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);
+  }
+
+  glEnable(GL_TEXTURE_2D);
+
+  glBindTexture(GL_TEXTURE_2D, texture_id);
+
+  glBegin(GL_QUADS);
+    glColor4f(r, g, b, a);
+    glTexCoord2f(tx1, ty1); glVertex2f(v1.x, v1.y);
+    glTexCoord2f(tx2, ty2); glVertex2f(v2.x, v2.y);
+    glTexCoord2f(tx3, ty3); glVertex2f(v3.x, v3.y);
+    glTexCoord2f(tx4, ty4); glVertex2f(v4.x, v4.y);
+  glEnd();
+
+  glDisable(GL_TEXTURE_2D);
+}
+
+
+/*
+ * Draw image
+ */
+void S2D_GL2_DrawImage(S2D_Image *img) {
+  S2D_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,
+    0.f, 0.f, 1.f, 0.f, 1.f, 1.f, 0.f, 1.f,
+    img->texture_id
+  );
+}
+
+
+/*
+ * Draw sprite
+ */
+void S2D_GL2_DrawSprite(S2D_Sprite *spr) {
+  S2D_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,
+    spr->tx1, spr->ty1, spr->tx2, spr->ty2, spr->tx3, spr->ty3, spr->tx4, spr->ty4,
+    spr->img->texture_id
+  );
+}
+
+
+/*
+ * Draw text
+ */
+void S2D_GL2_DrawText(S2D_Text *txt) {
+  S2D_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,
+    0.f, 0.f, 1.f, 0.f, 1.f, 1.f, 0.f, 1.f,
+    txt->texture_id
+  );
+}
+
+#endif

data/assets/linux/simple2d/src/gl3.c

@@ -0,0 +1,275 @@
+// OpenGL 3.3
+
+#include "../include/simple2d.h"
+
+#if !GLES
+
+static GLuint shaderProgram;
+static GLuint texShaderProgram;
+static GLuint indices[] =
+  { 0, 1, 2,
+    2, 3, 0 };
+
+
+/*
+ * Applies the projection matrix
+ */
+void S2D_GL3_ApplyProjection(GLfloat orthoMatrix[16]) {
+
+  // Use the program object
+  glUseProgram(shaderProgram);
+
+  glUniformMatrix4fv(
+    glGetUniformLocation(shaderProgram, "u_mvpMatrix"),
+    1, GL_FALSE, orthoMatrix
+  );
+
+  // Use the texture program object
+  glUseProgram(texShaderProgram);
+
+  glUniformMatrix4fv(
+    glGetUniformLocation(texShaderProgram, "u_mvpMatrix"),
+    1, GL_FALSE, orthoMatrix
+  );
+}
+
+
+/*
+ * Initalize OpenGL
+ */
+int S2D_GL3_Init() {
+
+  // Enable transparency
+  glEnable(GL_BLEND);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+  // 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;"
+    "void main() {"
+    "  Color = color;"
+    "  Texcoord = texcoord;"
+    "  gl_Position = u_mvpMatrix * position;"
+    "}";
+
+  // Fragment shader source string
+  GLchar fragmentSource[] =
+    "#version 150 core\n"
+    "in vec4 Color;"
+    "out vec4 outColor;"
+    "void main() {"
+    "  outColor = Color;"
+    "}";
+
+  // Fragment shader source string for textures
+  GLchar texFragmentSource[] =
+    "#version 150 core\n"
+    "in vec4 Color;"
+    "in vec2 Texcoord;"
+    "out vec4 outColor;"
+    "uniform sampler2D tex;"
+    "void main() {"
+    "  outColor = texture(tex, Texcoord) * Color;"
+    "}";
+
+  // Create Vertex Array Object
+  GLuint vao;
+  glGenVertexArrays(1, &vao);
+  glBindVertexArray(vao);
+
+  // Create Vertex Buffer Object
+  GLuint vbo;
+  glGenBuffers(1, &vbo);
+  glBindBuffer(GL_ARRAY_BUFFER, vbo);
+
+  // Create an element array
+  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");
+
+  // Create the shader program object
+  shaderProgram = glCreateProgram();
+
+  // Check if program was created successfully
+  if (shaderProgram == 0) {
+    S2D_GL_PrintError("Failed to create shader program");
+    return GL_FALSE;
+  }
+
+  // Attach the shader objects to the program object
+  glAttachShader(shaderProgram, vertexShader);
+  glAttachShader(shaderProgram, fragmentShader);
+
+  // Bind the varying out variables 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");
+
+  // Specify the layout of the vertex data
+  GLint posAttrib = glGetAttribLocation(shaderProgram, "position");
+  glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), 0);
+  glEnableVertexAttribArray(posAttrib);
+
+  GLint colAttrib = glGetAttribLocation(shaderProgram, "color");
+  glVertexAttribPointer(colAttrib, 4, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void*)(2 * sizeof(GLfloat)));
+  glEnableVertexAttribArray(colAttrib);
+
+  // 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");
+    return GL_FALSE;
+  }
+
+  glAttachShader(texShaderProgram, vertexShader);
+  glAttachShader(texShaderProgram, texFragmentShader);
+
+  glBindFragDataLocation(texShaderProgram, 0, "outColor");
+
+  glLinkProgram(texShaderProgram);
+
+  // Check if linked
+  S2D_GL_CheckLinked(texShaderProgram, "GL3 texture shader");
+
+  // Specify the layout of the vertex data
+  posAttrib = glGetAttribLocation(texShaderProgram, "position");
+  glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), 0);
+  glEnableVertexAttribArray(posAttrib);
+
+  colAttrib = glGetAttribLocation(texShaderProgram, "color");
+  glVertexAttribPointer(colAttrib, 4, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void*)(2 * sizeof(GLfloat)));
+  glEnableVertexAttribArray(colAttrib);
+
+  GLint texAttrib = glGetAttribLocation(texShaderProgram, "texcoord");
+  glVertexAttribPointer(texAttrib, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void*)(6 * sizeof(GLfloat)));
+  glEnableVertexAttribArray(texAttrib);
+
+  // Clean up
+  glDeleteShader(vertexShader);
+  glDeleteShader(fragmentShader);
+  glDeleteShader(texFragmentShader);
+
+  return GL_TRUE;
+}
+
+
+/*
+ * Draw triangle
+ */
+void S2D_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) {
+
+  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);
+}
+
+
+/*
+ * Draw a texture
+ */
+static void S2D_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 };
+
+  // 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);
+  }
+
+  GLfloat vertices[] =
+  //  vertex coords | colors      | x, y texture coords
+    { v1.x, v1.y,     r, g, b, a,   tx1, ty1,    // Top-left
+      v2.x, v2.y,     r, g, b, a,   tx2, ty2,    // Top-right
+      v3.x, v3.y,     r, g, b, a,   tx3, ty3,    // Bottom-right
+      v4.x, v4.y,     r, g, b, a,   tx4, ty4 };  // Bottom-left
+
+  glUseProgram(texShaderProgram);
+  glBindTexture(GL_TEXTURE_2D, texture_id);
+
+  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
+
+  glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
+}
+
+
+/*
+ * Draw image
+ */
+void S2D_GL3_DrawImage(S2D_Image *img) {
+  S2D_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,
+    0.f, 0.f, 1.f, 0.f, 1.f, 1.f, 0.f, 1.f,
+    img->texture_id
+  );
+}
+
+
+/*
+ * Draw sprite
+ */
+void S2D_GL3_DrawSprite(S2D_Sprite *spr) {
+  S2D_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,
+    spr->tx1, spr->ty1, spr->tx2, spr->ty2, spr->tx3, spr->ty3, spr->tx4, spr->ty4,
+    spr->img->texture_id
+  );
+}
+
+
+/*
+ * Draw text
+ */
+void S2D_GL3_DrawText(S2D_Text *txt) {
+  S2D_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,
+    0.f, 0.f, 1.f, 0.f, 1.f, 1.f, 0.f, 1.f,
+    txt->texture_id
+  );
+}
+
+#endif

data/assets/linux/simple2d/src/gles.c

@@ -0,0 +1,308 @@
+// OpenGL ES 2.0
+
+#include "../include/simple2d.h"
+
+#if GLES
+
+// Triangle shader
+static GLuint shaderProgram;
+static GLuint positionLocation;
+static GLuint colorLocation;
+
+// Texture shader
+static GLuint texShaderProgram;
+static GLuint texPositionLocation;
+static GLuint texColorLocation;
+static GLuint texCoordLocation;
+static GLuint samplerLocation;
+
+static GLushort indices[] =
+  { 0, 1, 2,
+    2, 3, 0 };
+
+
+/*
+ * Applies the projection matrix
+ */
+void S2D_GLES_ApplyProjection(GLfloat orthoMatrix[16]) {
+
+  // Use the program object
+  glUseProgram(shaderProgram);
+
+  glUniformMatrix4fv(
+    glGetUniformLocation(shaderProgram, "u_mvpMatrix"),
+    1, GL_FALSE, orthoMatrix
+  );
+
+  // Use the texture program object
+  glUseProgram(texShaderProgram);
+
+  glUniformMatrix4fv(
+    glGetUniformLocation(texShaderProgram, "u_mvpMatrix"),
+    1, GL_FALSE, orthoMatrix
+  );
+}
+
+
+/*
+ * Initalize OpenGL ES
+ */
+int S2D_GLES_Init() {
+
+  // Enable transparency
+  glEnable(GL_BLEND);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+  // Vertex shader source string
+  GLchar vertexSource[] =
+    // uniforms used by the vertex shader
+    "uniform mat4 u_mvpMatrix;"   // projection matrix
+
+    // attributes input to the vertex shader
+    "attribute vec4 a_position;"  // position value
+    "attribute vec4 a_color;"     // input vertex color
+    "attribute vec2 a_texcoord;"  // input texture
+
+    // varying variables, input to the fragment shader
+    "varying vec4 v_color;"       // output vertex color
+    "varying vec2 v_texcoord;"    // output texture
+
+    "void main()"
+    "{"
+    "  v_color = a_color;"
+    "  v_texcoord = a_texcoord;"
+    "  gl_Position = u_mvpMatrix * a_position;"
+    "}";
+
+  // Fragment shader source string
+  GLchar fragmentSource[] =
+    "precision mediump float;"
+    // input vertex color from vertex shader
+    "varying vec4 v_color;"
+
+    "void main()"
+    "{"
+    "  gl_FragColor = v_color;"
+    "}";
+
+  // Fragment shader source string for textures
+  GLchar texFragmentSource[] =
+    "precision mediump float;"
+    // input vertex color from vertex shader
+    "varying vec4 v_color;"
+    "varying vec2 v_texcoord;"
+    "uniform sampler2D s_texture;"
+
+    "void main()"
+    "{"
+    "  gl_FragColor = texture2D(s_texture, v_texcoord) * v_color;"
+    "}";
+
+  // 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");
+
+  // 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");
+    return GL_FALSE;
+  }
+
+  // Attach the shader objects to the program object
+  glAttachShader(shaderProgram, vertexShader);
+  glAttachShader(shaderProgram, fragmentShader);
+
+  // Link the shader program
+  glLinkProgram(shaderProgram);
+
+  // Check if linked
+  S2D_GL_CheckLinked(shaderProgram, "GLES shader");
+
+  // Get the attribute locations
+  positionLocation = glGetAttribLocation(shaderProgram, "a_position");
+  colorLocation    = glGetAttribLocation(shaderProgram, "a_color");
+
+  // 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");
+    return GL_FALSE;
+  }
+
+  // Attach the shader objects to the program object
+  glAttachShader(texShaderProgram, vertexShader);
+  glAttachShader(texShaderProgram, texFragmentShader);
+
+  // Link the shader program
+  glLinkProgram(texShaderProgram);
+
+  // Check if linked
+  S2D_GL_CheckLinked(texShaderProgram, "GLES texture shader");
+
+  // Get the attribute locations
+  texPositionLocation = glGetAttribLocation(texShaderProgram, "a_position");
+  texColorLocation    = glGetAttribLocation(texShaderProgram, "a_color");
+  texCoordLocation    = glGetAttribLocation(texShaderProgram, "a_texcoord");
+
+  // Get the sampler location
+  samplerLocation = glGetUniformLocation(texShaderProgram, "s_texture");
+
+  // Clean up
+  glDeleteShader(vertexShader);
+  glDeleteShader(fragmentShader);
+  glDeleteShader(texFragmentShader);
+
+  return GL_TRUE;
+}
+
+
+/*
+ * Draw triangle
+ */
+void S2D_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,
+                           GLfloat x3, GLfloat y3,
+                           GLfloat r3, GLfloat g3, GLfloat b3, GLfloat a3) {
+
+  GLfloat vertices[] =
+    { x1, y1, 0.f,
+      x2, y2, 0.f,
+      x3, y3, 0.f };
+
+  GLfloat colors[] =
+    { r1, g1, b1, a1,
+      r2, g2, b2, a2,
+      r3, g3, b3, a3 };
+
+  glUseProgram(shaderProgram);
+
+  // Load the vertex position
+  glVertexAttribPointer(positionLocation, 3, GL_FLOAT, GL_FALSE, 0, vertices);
+  glEnableVertexAttribArray(positionLocation);
+
+  // Load the colors
+  glVertexAttribPointer(colorLocation, 4, GL_FLOAT, GL_FALSE, 0, colors);
+  glEnableVertexAttribArray(colorLocation);
+
+  // draw
+  glDrawArrays(GL_TRIANGLES, 0, 3);
+}
+
+
+/*
+ * Draw a texture
+ */
+static void S2D_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 };
+
+  // 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);
+  }
+
+  GLfloat vertices[] =
+  //  x, y coords | x, y texture coords
+    { v1.x, v1.y,   0.f, tx1, ty1,
+      v2.x, v2.y,   0.f, tx2, ty2,
+      v3.x, v3.y,   0.f, tx3, ty3,
+      v4.x, v4.y,   0.f, tx4, ty4 };
+
+  GLfloat colors[] =
+    { r, g, b, a,
+      r, g, b, a,
+      r, g, b, a,
+      r, g, b, a };
+
+  glUseProgram(texShaderProgram);
+
+  // Load the vertex position
+  glVertexAttribPointer(texPositionLocation, 3, GL_FLOAT, GL_FALSE,
+                        5 * sizeof(GLfloat), vertices);
+  glEnableVertexAttribArray(texPositionLocation);
+
+  // Load the colors
+  glVertexAttribPointer(texColorLocation, 4, GL_FLOAT, GL_FALSE, 0, colors);
+  glEnableVertexAttribArray(texColorLocation);
+
+  // Load the texture coordinate
+  glVertexAttribPointer(texCoordLocation, 2, GL_FLOAT, GL_FALSE,
+                        5 * sizeof(GLfloat), &vertices[3]);
+  glEnableVertexAttribArray(texCoordLocation);
+
+  // Bind the texture
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, texture_id);
+
+  // Set the sampler texture unit to 0
+  glUniform1i(samplerLocation, 0);
+
+  glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
+}
+
+
+/*
+ * Draw image
+ */
+void S2D_GLES_DrawImage(S2D_Image *img) {
+  S2D_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,
+    0.f, 0.f, 1.f, 0.f, 1.f, 1.f, 0.f, 1.f,
+    img->texture_id
+  );
+}
+
+
+/*
+ * Draw sprite
+ */
+void S2D_GLES_DrawSprite(S2D_Sprite *spr) {
+  S2D_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,
+    spr->tx1, spr->ty1, spr->tx2, spr->ty2, spr->tx3, spr->ty3, spr->tx4, spr->ty4,
+    spr->img->texture_id
+  );
+}
+
+
+/*
+ * Draw text
+ */
+void S2D_GLES_DrawText(S2D_Text *txt) {
+  S2D_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,
+    0.f, 0.f, 1.f, 0.f, 1.f, 1.f, 0.f, 1.f,
+    txt->texture_id
+  );
+}
+
+#endif