ruby2d 0.10.0 → 0.11.2

data/ext/ruby2d/gles.c

@@ -1,24 +1,18 @@
-// OpenGL ES 2.0
+// OpenGL ES
 
 #include "ruby2d.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 };
+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 = 7500;  // number of objects the VBO can store
+static GLuint verticesTextureIds[7500]; // store the texture_id of each vertices
+static GLuint shaderProgram;  // triangle shader program
+static GLuint texShaderProgram;  // texture shader program
 
 
 /*
@@ -29,6 +23,7 @@ void R2D_GLES_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
@@ -37,6 +32,7 @@ void R2D_GLES_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
@@ -45,7 +41,7 @@ void R2D_GLES_ApplyProjection(GLfloat orthoMatrix[16]) {
 
 
 /*
- * Initalize OpenGL ES
+ * Initalize OpenGL
  */
 int R2D_GLES_Init() {
 
@@ -76,7 +72,9 @@ int R2D_GLES_Init() {
 
   // Fragment shader source string
   GLchar fragmentSource[] =
+    #ifdef __EMSCRIPTEN__
     "precision mediump float;"
+    #endif
     // input vertex color from vertex shader
     "varying vec4 v_color;"
 
@@ -87,7 +85,9 @@ int R2D_GLES_Init() {
 
   // Fragment shader source string for textures
   GLchar texFragmentSource[] =
+    #ifdef __EMSCRIPTEN__
     "precision mediump float;"
+    #endif
     // input vertex color from vertex shader
     "varying vec4 v_color;"
     "varying vec2 v_texcoord;"
@@ -98,6 +98,23 @@ int R2D_GLES_Init() {
     "  gl_FragColor = texture2D(s_texture, v_texcoord) * v_color;"
     "}";
 
+  // // Create a vertex array object
+  // GLuint vao;
+  // glGenVertexArrays(1, &vao);
+  // glBindVertexArray(vao);
+
+  // Create a vertex buffer object and allocate data
+  glGenBuffers(1, &vbo);
+  glBindBuffer(GL_ARRAY_BUFFER, vbo);
+  vboSize = vboObjCapacity * sizeof(GLfloat) * 8;
+  vboData = (GLfloat *) malloc(vboSize);
+  vboDataCurrent = vboData;
+
+  // Create an element buffer object
+  GLuint ebo;
+  glGenBuffers(1, &ebo);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
+
   // Load the vertex and fragment shaders
   GLuint vertexShader      = R2D_GL_LoadShader(  GL_VERTEX_SHADER,      vertexSource, "GLES Vertex");
   GLuint fragmentShader    = R2D_GL_LoadShader(GL_FRAGMENT_SHADER,    fragmentSource, "GLES Fragment");
@@ -124,9 +141,15 @@ int R2D_GLES_Init() {
   // Check if linked
   R2D_GL_CheckLinked(shaderProgram, "GLES shader");
 
-  // Get the attribute locations
-  positionLocation = glGetAttribLocation(shaderProgram, "a_position");
-  colorLocation    = glGetAttribLocation(shaderProgram, "a_color");
+  // Specify the layout of the position vertex data...
+  GLint posAttrib = glGetAttribLocation(shaderProgram, "a_position");
+  glEnableVertexAttribArray(posAttrib);
+  glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), 0);
+
+  // ...and the color vertex data
+  GLint colAttrib = glGetAttribLocation(shaderProgram, "a_color");
+  glEnableVertexAttribArray(colAttrib);
+  glVertexAttribPointer(colAttrib, 4, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (void*)(2 * sizeof(GLfloat)));
 
   // Texture Shader //
 
@@ -149,175 +172,131 @@ int R2D_GLES_Init() {
   // Check if linked
   R2D_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");
+  // Specify the layout of the position vertex data...
+  posAttrib = glGetAttribLocation(texShaderProgram, "a_position");
+  glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), 0);
+  glEnableVertexAttribArray(posAttrib);
 
-  // Get the sampler location
-  samplerLocation = glGetUniformLocation(texShaderProgram, "s_texture");
+  // ...and the color vertex data...
+  colAttrib = glGetAttribLocation(texShaderProgram, "a_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, "a_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);
 
+  // If successful, return true
   return GL_TRUE;
 }
 
 
 /*
- * Draw triangle
+ * Render the vertex buffer and reset it
  */
-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,
-                           GLfloat x3, GLfloat y3,
-                           GLfloat r3, GLfloat g3, GLfloat b3, GLfloat a3) {
+void R2D_GLES_FlushBuffers() {
 
-  GLfloat vertices[] =
-    { x1, y1, 0.f,
-      x2, y2, 0.f,
-      x3, y3, 0.f };
+  // Bind to the vertex buffer object and update its data
+  glBindBuffer(GL_ARRAY_BUFFER, vbo);
 
-  GLfloat colors[] =
-    { r1, g1, b1, a1,
-      r2, g2, b2, a2,
-      r3, g3, b3, a3 };
+  glBufferData(GL_ARRAY_BUFFER, vboSize, NULL, GL_DYNAMIC_DRAW);
+  glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(GLfloat) * vboDataIndex * 8, vboData);
 
-  glUseProgram(shaderProgram);
+  GLuint verticesOffset = 0;
+  GLuint lastTextureId = verticesTextureIds[0];
 
-  // Load the vertex position
-  glVertexAttribPointer(positionLocation, 3, GL_FLOAT, GL_FALSE, 0, vertices);
-  glEnableVertexAttribArray(positionLocation);
+  for (GLuint i = 0; i <= vboDataIndex; i++) {
+    if (lastTextureId != verticesTextureIds[i] || i == vboDataIndex) {
+      // A texture ID of 0 represents no texture (render a triangle)
+      if (lastTextureId == 0) {
 
-  // Load the colors
-  glVertexAttribPointer(colorLocation, 4, GL_FLOAT, GL_FALSE, 0, colors);
-  glEnableVertexAttribArray(colorLocation);
+        // Use the triangle shader program
+        glUseProgram(shaderProgram);
 
-  // draw
-  glDrawArrays(GL_TRIANGLES, 0, 3);
-}
+      // A number other than 0 represents a texture_id
+      } else {
 
+        // Use the texture shader program
+        glUseProgram(texShaderProgram);
 
-/*
- * Draw a texture
- */
-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) {
-
-  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 = 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[] =
-  //  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);
+        // Bind the texture using the provided ID
+        glBindTexture(GL_TEXTURE_2D, lastTextureId);
+      }
 
-  // Load the vertex position
-  glVertexAttribPointer(texPositionLocation, 3, GL_FLOAT, GL_FALSE,
-                        5 * sizeof(GLfloat), vertices);
-  glEnableVertexAttribArray(texPositionLocation);
+      glDrawArrays(GL_TRIANGLES, verticesOffset, i - verticesOffset);
 
-  // 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);
+      lastTextureId = verticesTextureIds[i];
+      verticesOffset = i;
+    }
+  }
 
-  glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
+  // Reset the buffer object index and data pointer
+  vboDataIndex = 0;
+  vboDataCurrent = vboData;
 }
 
 
 /*
- * Draw image
+ * Draw triangle
  */
-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,
-    0.f, 0.f, 1.f, 0.f, 1.f, 1.f, 0.f, 1.f,
-    img->texture_id
-  );
-}
+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,
+                           GLfloat x3, GLfloat y3,
+                           GLfloat r3, GLfloat g3, GLfloat b3, GLfloat a3) {
 
+  // If buffer is full, flush it
+  if (vboDataIndex + 3 >= vboObjCapacity) R2D_GLES_FlushBuffers();
 
-/*
- * Draw sprite
- */
-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,
-    spr->tx1, spr->ty1, spr->tx2, spr->ty2, spr->tx3, spr->ty3, spr->tx4, spr->ty4,
-    spr->img->texture_id
-  );
-}
+  // Set the triangle data into a formatted array
+  GLfloat vertices[24] =
+    { x1, y1, r1, g1, b1, a1, 0, 0,
+      x2, y2, r2, g2, b2, a2, 0, 0,
+      x3, y3, r3, g3, b3, a3, 0, 0 };
 
+  // Copy the vertex data into the current position of the buffer
+  memcpy(vboDataCurrent, vertices, sizeof(vertices));
 
-/*
- * 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
-  );
+  // Increment the buffer object index and the vertex data pointer for next use
+  verticesTextureIds[vboDataIndex] = verticesTextureIds[vboDataIndex + 1] = verticesTextureIds[vboDataIndex + 2] = 0;
+  vboDataIndex += 3;
+  vboDataCurrent = (GLfloat *)((char *)vboDataCurrent + (sizeof(GLfloat) * 24));
 }
 
 
 /*
- * Draw text
+ * Draw a texture (New method with vertices pre-calculated)
  */
-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,
-    0.f, 0.f, 1.f, 0.f, 1.f, 1.f, 0.f, 1.f,
-    txt->texture_id
-  );
+void R2D_GLES_DrawTexture(GLfloat coordinates[], GLfloat texture_coordinates[], GLfloat color[], int texture_id) {
+  // If buffer is full, flush it
+  if (vboDataIndex + 6 >= vboObjCapacity) R2D_GLES_FlushBuffers();
+
+  // There are 6 vertices for a square as we are rendering two Triangles to make up our square:
+  // Triangle one: Top left, Top right, Bottom right
+  // Triangle two: Bottom right, Bottom left, Top left
+  GLfloat vertices[48] = {
+    coordinates[0], coordinates[1], color[0], color[1], color[2], color[3], texture_coordinates[0], texture_coordinates[1],
+    coordinates[2], coordinates[3], color[0], color[1], color[2], color[3], texture_coordinates[2], texture_coordinates[3],
+    coordinates[4], coordinates[5], color[0], color[1], color[2], color[3], texture_coordinates[4], texture_coordinates[5],
+    coordinates[4], coordinates[5], color[0], color[1], color[2], color[3], texture_coordinates[4], texture_coordinates[5],
+    coordinates[6], coordinates[7], color[0], color[1], color[2], color[3], texture_coordinates[6], texture_coordinates[7],
+    coordinates[0], coordinates[1], color[0], color[1], color[2], color[3], texture_coordinates[0], texture_coordinates[1],
+  };
+
+  // Copy the vertex data into the current position of the buffer
+  memcpy(vboDataCurrent, vertices, sizeof(vertices));
+
+  verticesTextureIds[vboDataIndex] = verticesTextureIds[vboDataIndex + 1] = verticesTextureIds[vboDataIndex + 2] = verticesTextureIds[vboDataIndex + 3] = verticesTextureIds[vboDataIndex + 4] = verticesTextureIds[vboDataIndex + 5] = texture_id;
+  vboDataIndex += 6;
+  vboDataCurrent = (GLfloat *)((char *)vboDataCurrent + (sizeof(GLfloat) * 48));
 }
 
+
 #endif

data/ext/ruby2d/image.c

@@ -3,75 +3,39 @@
 #include "ruby2d.h"
 
 
-/*
- * Create an image, given a file path
- */
-R2D_Image *R2D_CreateImage(const char *path) {
+SDL_Surface *R2D_CreateImageSurface(const char *path) {
   R2D_Init();
 
   // Check if image file exists
   if (!R2D_FileExists(path)) {
-    R2D_Error("R2D_CreateImage", "Image file `%s` not found", path);
-    return NULL;
-  }
-
-  // Allocate the image structure
-  R2D_Image *img = (R2D_Image *) malloc(sizeof(R2D_Image));
-  if (!img) {
-    R2D_Error("R2D_CreateImage", "Out of memory!");
+    R2D_Error("R2D_CreateImageSurface", "Image file `%s` not found", path);
     return NULL;
   }
 
   // Load image from file as SDL_Surface
-  img->surface = IMG_Load(path);
-  if (!img->surface) {
-    R2D_Error("IMG_Load", IMG_GetError());
-    free(img);
-    return NULL;
-  }
+  SDL_Surface *surface = IMG_Load(path);
 
-  int bits_per_color = img->surface->format->Amask == 0 ?
-    img->surface->format->BitsPerPixel / 3 :
-    img->surface->format->BitsPerPixel / 4;
+  int bits_per_color = surface->format->Amask == 0 ?
+    surface->format->BitsPerPixel / 3 :
+    surface->format->BitsPerPixel / 4;
 
   if (bits_per_color < 8) {
     R2D_Log(R2D_WARN, "`%s` has less than 8 bits per color and will likely not render correctly", path, bits_per_color);
   }
 
-  // Initialize values
-  img->path = path;
-  img->x = 0;
-  img->y = 0;
-  img->color.r = 1.f;
-  img->color.g = 1.f;
-  img->color.b = 1.f;
-  img->color.a = 1.f;
-  img->orig_width  = img->surface->w;
-  img->orig_height = img->surface->h;
-  img->width  = img->orig_width;
-  img->height = img->orig_height;
-  img->rotate = 0;
-  img->rx = 0;
-  img->ry = 0;
-  img->texture_id = 0;
-
-  // Detect image mode
-  img->format = GL_RGB;
-  if (img->surface->format->BytesPerPixel == 4) {
-    img->format = GL_RGBA;
-  }
-
-  // Flip image bits if BGA
+  return surface;
+}
 
-  Uint32 r = img->surface->format->Rmask;
-  Uint32 g = img->surface->format->Gmask;
-  Uint32 a = img->surface->format->Amask;
+void R2D_ImageConvertToRGB(SDL_Surface *surface) {
+  Uint32 r = surface->format->Rmask;
+  Uint32 g = surface->format->Gmask;
+  Uint32 a = surface->format->Amask;
 
   if (r&0xFF000000 || r&0xFF0000) {
-    char *p = (char *)img->surface->pixels;
-    int bpp = img->surface->format->BytesPerPixel;
-    int w = img->surface->w;
-    int h = img->surface->h;
+    char *p = (char *)surface->pixels;
+    int bpp = surface->format->BytesPerPixel;
+    int w = surface->w;
+    int h = surface->h;
     char tmp;
     for (int i = 0; i < bpp * w * h; i += bpp) {
       if (a&0xFF) {
@@ -91,48 +55,4 @@ R2D_Image *R2D_CreateImage(const char *path) {
       }
     }
   }
-
-  return img;
-}
-
-
-/*
- * Rotate an image
- */
-void R2D_RotateImage(R2D_Image *img, GLfloat angle, int position) {
-
-  R2D_GL_Point p = R2D_GetRectRotationPoint(
-    img->x, img->y, img->width, img->height, position
-  );
-
-  img->rotate = angle;
-  img->rx = p.x;
-  img->ry = p.y;
-}
-
-
-/*
- * Draw an image
- */
-void R2D_DrawImage(R2D_Image *img) {
-  if (!img) return;
-
-  if (img->texture_id == 0) {
-    R2D_GL_CreateTexture(&img->texture_id, img->format,
-                         img->orig_width, img->orig_height,
-                         img->surface->pixels, GL_NEAREST);
-    SDL_FreeSurface(img->surface);
-  }
-
-  R2D_GL_DrawImage(img);
-}
-
-
-/*
- * Free an image
- */
-void R2D_FreeImage(R2D_Image *img) {
-  if (!img) return;
-  R2D_GL_FreeTexture(&img->texture_id);
-  free(img);
 }