ruby2d 0.9.2 → 0.10.0

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

@@ -1,6 +1,6 @@
 // shapes.c
 
-#include "../include/simple2d.h"
+#include "ruby2d.h"
 
 
 /*
@@ -11,7 +11,7 @@
  *   rx     The x coordinate to rotate around
  *   ry     The y coordinate to rotate around
  */
-S2D_GL_Point S2D_RotatePoint(S2D_GL_Point p, GLfloat angle, GLfloat rx, GLfloat ry) {
+R2D_GL_Point R2D_RotatePoint(R2D_GL_Point p, GLfloat angle, GLfloat rx, GLfloat ry) {
 
   // Convert from degrees to radians
   angle = angle * M_PI / 180.0;
@@ -39,28 +39,28 @@ S2D_GL_Point S2D_RotatePoint(S2D_GL_Point p, GLfloat angle, GLfloat rx, GLfloat
 /*
  * Get the point to be rotated around given a position in a rectangle
  */
-S2D_GL_Point S2D_GetRectRotationPoint(int x, int y, int w, int h, int position) {
+R2D_GL_Point R2D_GetRectRotationPoint(int x, int y, int w, int h, int position) {
 
-  S2D_GL_Point p;
+  R2D_GL_Point p;
 
   switch (position) {
-    case S2D_CENTER:
+    case R2D_CENTER:
       p.x = x + (w / 2.0);
       p.y = y + (h / 2.0);
       break;
-    case S2D_TOP_LEFT:
+    case R2D_TOP_LEFT:
       p.x = x;
       p.y = y;
       break;
-    case S2D_TOP_RIGHT:
+    case R2D_TOP_RIGHT:
       p.x = x + w;
       p.y = y;
       break;
-    case S2D_BOTTOM_LEFT:
+    case R2D_BOTTOM_LEFT:
       p.x = x;
       p.y = y + h;
       break;
-    case S2D_BOTTOM_RIGHT:
+    case R2D_BOTTOM_RIGHT:
       p.x = x + w;
       p.y = y + h;
       break;
@@ -73,14 +73,14 @@ S2D_GL_Point S2D_GetRectRotationPoint(int x, int y, int w, int h, int position)
 /*
  * Draw a triangle
  */
-void S2D_DrawTriangle(GLfloat x1, GLfloat y1,
+void R2D_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) {
 
-  S2D_GL_DrawTriangle(x1, y1, r1, g1, b1, a1,
+  R2D_GL_DrawTriangle(x1, y1, r1, g1, b1, a1,
                       x2, y2, r2, g2, b2, a2,
                       x3, y3, r3, g3, b3, a3);
 }
@@ -89,7 +89,7 @@ void S2D_DrawTriangle(GLfloat x1, GLfloat y1,
 /*
  * Draw a quad, using two triangles
  */
-void S2D_DrawQuad(GLfloat x1, GLfloat y1,
+void R2D_DrawQuad(GLfloat x1, GLfloat y1,
                   GLfloat r1, GLfloat g1, GLfloat b1, GLfloat a1,
                   GLfloat x2, GLfloat y2,
                   GLfloat r2, GLfloat g2, GLfloat b2, GLfloat a2,
@@ -98,11 +98,11 @@ void S2D_DrawQuad(GLfloat x1, GLfloat y1,
                   GLfloat x4, GLfloat y4,
                   GLfloat r4, GLfloat g4, GLfloat b4, GLfloat a4) {
 
-  S2D_GL_DrawTriangle(x1, y1, r1, g1, b1, a1,
+  R2D_GL_DrawTriangle(x1, y1, r1, g1, b1, a1,
                       x2, y2, r2, g2, b2, a2,
                       x3, y3, r3, g3, b3, a3);
 
-  S2D_GL_DrawTriangle(x3, y3, r3, g3, b3, a3,
+  R2D_GL_DrawTriangle(x3, y3, r3, g3, b3, a3,
                       x4, y4, r4, g4, b4, a4,
                       x1, y1, r1, g1, b1, a1);
 };
@@ -111,7 +111,7 @@ void S2D_DrawQuad(GLfloat x1, GLfloat y1,
 /*
  * Draw a line from a quad
  */
-void S2D_DrawLine(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2,
+void R2D_DrawLine(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2,
                   GLfloat width,
                   GLfloat r1, GLfloat g1, GLfloat b1, GLfloat a1,
                   GLfloat r2, GLfloat g2, GLfloat b2, GLfloat a2,
@@ -122,7 +122,7 @@ void S2D_DrawLine(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2,
   double x = ((x2 - x1) / length) * width / 2;
   double y = ((y2 - y1) / length) * width / 2;
 
-  S2D_DrawQuad(
+  R2D_DrawQuad(
     x1 - y, y1 + x, r1, g1, b1, a1,
     x1 + y, y1 - x, r2, g2, b2, a2,
     x2 + y, y2 - x, r3, g3, b3, a3,
@@ -134,7 +134,7 @@ void S2D_DrawLine(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2,
 /*
  * Draw a circle from triangles
  */
-void S2D_DrawCircle(GLfloat x, GLfloat y, GLfloat radius, int sectors,
+void R2D_DrawCircle(GLfloat x, GLfloat y, GLfloat radius, int sectors,
                     GLfloat r, GLfloat g, GLfloat b, GLfloat a) {
 
   double angle = 2 * M_PI / sectors;
@@ -147,7 +147,7 @@ void S2D_DrawCircle(GLfloat x, GLfloat y, GLfloat radius, int sectors,
     GLfloat x2 = x + radius * cos((i - 1) * angle);
     GLfloat y2 = y + radius * sin((i - 1) * angle);
 
-    S2D_GL_DrawTriangle( x,  y, r, g, b, a,
+    R2D_GL_DrawTriangle( x,  y, r, g, b, a,
                         x1, y1, r, g, b, a,
                         x2, y2, r, g, b, a);
   }

data/ext/ruby2d/sound.c

@@ -0,0 +1,118 @@
+// sound.c
+
+#include "ruby2d.h"
+
+
+/*
+ * Create a sound, given an audio file path
+ */
+R2D_Sound *R2D_CreateSound(const char *path) {
+  R2D_Init();
+
+  // Check if sound file exists
+  if (!R2D_FileExists(path)) {
+    R2D_Error("R2D_CreateSound", "Sound file `%s` not found", path);
+    return NULL;
+  }
+
+  // Allocate the sound structure
+  R2D_Sound *snd = (R2D_Sound *) malloc(sizeof(R2D_Sound));
+  if (!snd) {
+    R2D_Error("R2D_CreateSound", "Out of memory!");
+    return NULL;
+  }
+
+  // Load the sound data from file
+  snd->data = Mix_LoadWAV(path);
+  if (!snd->data) {
+    R2D_Error("Mix_LoadWAV", Mix_GetError());
+    free(snd);
+    return NULL;
+  }
+
+  // Initialize values
+  snd->path = path;
+
+  return snd;
+}
+
+
+/*
+ * Play the sound
+ */
+void R2D_PlaySound(R2D_Sound *snd) {
+  if (!snd) return;
+  Mix_PlayChannel(-1, snd->data, 0);
+}
+
+
+/*
+ * Get the sound's length in seconds
+ */
+int R2D_GetSoundLength(R2D_Sound *snd) {
+  float points = 0;
+  float frames = 0;
+  int frequency = 0;
+  Uint16 format = 0;
+  int channels = 0;
+
+  // Populate the frequency, format and channel variables
+  if (!Mix_QuerySpec(&frequency, &format, &channels)) return -1; // Querying audio deails failed
+  if (!snd) return -1;
+
+  // points = bytes / samplesize
+  points = (snd->data->alen / ((format & 0xFF) / 8));
+
+  // frames = sample points / channels
+  frames = (points / channels);
+
+  // frames / frequency is seconds of audio
+  return ceil(frames / frequency);
+}
+
+
+/*
+ * Get the sound's volume
+ */
+int R2D_GetSoundVolume(R2D_Sound *snd) {
+  if (!snd) return -1;
+  return ceil(Mix_VolumeChunk(snd->data, -1) * (100.0 / MIX_MAX_VOLUME));
+}
+
+
+/*
+ * Set the sound's volume a given percentage
+ */
+void R2D_SetSoundVolume(R2D_Sound *snd, int volume) {
+  if (!snd) return;
+  // Set volume to be a percentage of the maximum mix volume
+  Mix_VolumeChunk(snd->data, (volume / 100.0) * MIX_MAX_VOLUME);
+}
+
+
+/*
+ * Get the sound mixer volume
+ */
+int R2D_GetSoundMixVolume() {
+  return ceil(Mix_Volume(-1, -1) * (100.0 / MIX_MAX_VOLUME));
+}
+
+
+/*
+ * Set the sound mixer volume a given percentage
+ */
+void R2D_SetSoundMixVolume(int volume) {
+  // This sets the volume value across all channels
+  // Set volume to be a percentage of the maximum mix volume
+  Mix_Volume(-1, (volume / 100.0) * MIX_MAX_VOLUME);
+}
+
+
+/*
+ * Free the sound
+ */
+void R2D_FreeSound(R2D_Sound *snd) {
+  if (!snd) return;
+  Mix_FreeChunk(snd->data);
+  free(snd);
+}

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

@@ -1,30 +1,30 @@
 // sprite.c
 
-#include "../include/simple2d.h"
+#include "ruby2d.h"
 
 
 /*
  * Create a sprite, given an image file path
  */
-S2D_Sprite *S2D_CreateSprite(const char *path) {
+R2D_Sprite *R2D_CreateSprite(const char *path) {
 
   // Check if image file exists
-  if (!S2D_FileExists(path)) {
-    S2D_Error("S2D_CreateSprite", "Sprite image file `%s` not found", path);
+  if (!R2D_FileExists(path)) {
+    R2D_Error("R2D_CreateSprite", "Sprite image file `%s` not found", path);
     return NULL;
   }
 
   // Allocate the sprite structure
-  S2D_Sprite *spr = (S2D_Sprite *) malloc(sizeof(S2D_Sprite));
+  R2D_Sprite *spr = (R2D_Sprite *) malloc(sizeof(R2D_Sprite));
   if (!spr) {
-    S2D_Error("S2D_CreateSprite", "Out of memory!");
+    R2D_Error("R2D_CreateSprite", "Out of memory!");
     return NULL;
   }
 
   // Load the sprite image file
-  spr->img = S2D_CreateImage(path);
+  spr->img = R2D_CreateImage(path);
   if (!spr->img) {
-    S2D_Error("S2D_CreateSprite", "Cannot create sprite image `%s`", path);
+    R2D_Error("R2D_CreateSprite", "Cannot create sprite image `%s`", path);
     free(spr);
     return NULL;
   }
@@ -60,7 +60,7 @@ S2D_Sprite *S2D_CreateSprite(const char *path) {
 /*
  * Clip a sprite
  */
-void S2D_ClipSprite(S2D_Sprite *spr, int x, int y, int w, int h) {
+void R2D_ClipSprite(R2D_Sprite *spr, int x, int y, int w, int h) {
   if (!spr) return;
 
   // Calculate ratios
@@ -108,9 +108,9 @@ void S2D_ClipSprite(S2D_Sprite *spr, int x, int y, int w, int h) {
 /*
  * Rotate a sprite
  */
-void S2D_RotateSprite(S2D_Sprite *spr, GLfloat angle, int position) {
+void R2D_RotateSprite(R2D_Sprite *spr, GLfloat angle, int position) {
 
-  S2D_GL_Point p = S2D_GetRectRotationPoint(
+  R2D_GL_Point p = R2D_GetRectRotationPoint(
     spr->x, spr->y, spr->width, spr->height, position
   );
 
@@ -123,25 +123,25 @@ void S2D_RotateSprite(S2D_Sprite *spr, GLfloat angle, int position) {
 /*
  * Draw a sprite
  */
-void S2D_DrawSprite(S2D_Sprite *spr) {
+void R2D_DrawSprite(R2D_Sprite *spr) {
   if (!spr) return;
 
   if (spr->img->texture_id == 0) {
-    S2D_GL_CreateTexture(&spr->img->texture_id, spr->img->format,
+    R2D_GL_CreateTexture(&spr->img->texture_id, spr->img->format,
                          spr->img->width, spr->img->height,
                          spr->img->surface->pixels, GL_NEAREST);
     SDL_FreeSurface(spr->img->surface);
   }
 
-  S2D_GL_DrawSprite(spr);
+  R2D_GL_DrawSprite(spr);
 }
 
 
 /*
  * Free a sprite
  */
-void S2D_FreeSprite(S2D_Sprite *spr) {
+void R2D_FreeSprite(R2D_Sprite *spr) {
   if (!spr) return;
-  S2D_FreeImage(spr->img);
+  R2D_FreeImage(spr->img);
   free(spr);
 }

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

@@ -1,17 +1,17 @@
 // text.c
 
-#include "../include/simple2d.h"
+#include "ruby2d.h"
 
 
 /*
  * Create text, given a font file path, the message, and size
  */
-S2D_Text *S2D_CreateText(const char *font, const char *msg, int size) {
-  S2D_Init();
+R2D_Text *R2D_CreateText(const char *font, const char *msg, int size) {
+  R2D_Init();
 
   // Check if font file exists
-  if (!S2D_FileExists(font)) {
-    S2D_Error("S2D_CreateText", "Font file `%s` not found", font);
+  if (!R2D_FileExists(font)) {
+    R2D_Error("R2D_CreateText", "Font file `%s` not found", font);
     return NULL;
   }
 
@@ -19,16 +19,16 @@ S2D_Text *S2D_CreateText(const char *font, const char *msg, int size) {
   if (msg == NULL || strlen(msg) == 0) msg = " ";
 
   // Allocate the text structure
-  S2D_Text *txt = (S2D_Text *) malloc(sizeof(S2D_Text));
+  R2D_Text *txt = (R2D_Text *) malloc(sizeof(R2D_Text));
   if (!txt) {
-    S2D_Error("S2D_CreateText", "Out of memory!");
+    R2D_Error("R2D_CreateText", "Out of memory!");
     return NULL;
   }
 
   // Open the font
   txt->font_data = TTF_OpenFont(font, size);
   if (!txt->font_data) {
-    S2D_Error("TTF_OpenFont", TTF_GetError());
+    R2D_Error("TTF_OpenFont", TTF_GetError());
     free(txt);
     return NULL;
   }
@@ -49,7 +49,7 @@ S2D_Text *S2D_CreateText(const char *font, const char *msg, int size) {
   txt->texture_id = 0;
 
   // Save the width and height of the text
-  TTF_SizeText(txt->font_data, txt->msg, &txt->width, &txt->height);
+  TTF_SizeUTF8(txt->font_data, txt->msg, &txt->width, &txt->height);
 
   return txt;
 }
@@ -58,10 +58,10 @@ S2D_Text *S2D_CreateText(const char *font, const char *msg, int size) {
 /*
  * Set the text message
  */
-void S2D_SetText(S2D_Text *txt, const char *msg, ...) {
+void R2D_SetText(R2D_Text *txt, const char *msg, ...) {
   if (!txt) return;
 
-  // `msg` cannot be an empty string or NULL for TTF_SizeText
+  // `msg` cannot be an empty string or NULL for TTF_SizeUTF8
   if (msg == NULL || strlen(msg) == 0) msg = " ";
 
   // Format and store new text string
@@ -72,19 +72,19 @@ void S2D_SetText(S2D_Text *txt, const char *msg, ...) {
   va_end(args);
 
   // Save the width and height of the text
-  TTF_SizeText(txt->font_data, txt->msg, &txt->width, &txt->height);
+  TTF_SizeUTF8(txt->font_data, txt->msg, &txt->width, &txt->height);
 
   // Delete the current texture so a new one can be generated
-  S2D_GL_FreeTexture(&txt->texture_id);
+  R2D_GL_FreeTexture(&txt->texture_id);
 }
 
 
 /*
  * Rotate text
  */
-void S2D_RotateText(S2D_Text *txt, GLfloat angle, int position) {
+void R2D_RotateText(R2D_Text *txt, GLfloat angle, int position) {
 
-  S2D_GL_Point p = S2D_GetRectRotationPoint(
+  R2D_GL_Point p = R2D_GetRectRotationPoint(
     txt->x, txt->y, txt->width, txt->height, position
   );
 
@@ -97,33 +97,33 @@ void S2D_RotateText(S2D_Text *txt, GLfloat angle, int position) {
 /*
  * Draw text
  */
-void S2D_DrawText(S2D_Text *txt) {
+void R2D_DrawText(R2D_Text *txt) {
   if (!txt) return;
 
   if (txt->texture_id == 0) {
     SDL_Color color = { 255, 255, 255 };
-    txt->surface = TTF_RenderText_Blended(txt->font_data, txt->msg, color);
+    txt->surface = TTF_RenderUTF8_Blended(txt->font_data, txt->msg, color);
     if (!txt->surface) {
-      S2D_Error("TTF_RenderText_Blended", TTF_GetError());
+      R2D_Error("TTF_RenderUTF8_Blended", TTF_GetError());
       return;
     }
-    S2D_GL_CreateTexture(&txt->texture_id, GL_RGBA,
+    R2D_GL_CreateTexture(&txt->texture_id, GL_RGBA,
                          txt->width, txt->height,
                          txt->surface->pixels, GL_NEAREST);
     SDL_FreeSurface(txt->surface);
   }
 
-  S2D_GL_DrawText(txt);
+  R2D_GL_DrawText(txt);
 }
 
 
 /*
  * Free the text
  */
-void S2D_FreeText(S2D_Text *txt) {
+void R2D_FreeText(R2D_Text *txt) {
   if (!txt) return;
   free(txt->msg);
-  S2D_GL_FreeTexture(&txt->texture_id);
+  R2D_GL_FreeTexture(&txt->texture_id);
   TTF_CloseFont(txt->font_data);
   free(txt);
 }