ruby2d 0.9.0 → 0.9.5

data/ext/ruby2d/shapes.c

@@ -0,0 +1,154 @@
+// shapes.c
+
+#include "ruby2d.h"
+
+
+/*
+ * Rotate a point around a given point
+ * Params:
+ *   p      The point to rotate
+ *   angle  The angle in degrees
+ *   rx     The x coordinate to rotate around
+ *   ry     The y coordinate to rotate around
+ */
+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;
+
+  // Get the sine and cosine of the angle
+  GLfloat sa = sin(angle);
+  GLfloat ca = cos(angle);
+
+  // Translate point to origin
+  p.x -= rx;
+  p.y -= ry;
+
+  // Rotate point
+  GLfloat xnew = p.x * ca - p.y * sa;
+  GLfloat ynew = p.x * sa + p.y * ca;
+
+  // Translate point back
+  p.x = xnew + rx;
+  p.y = ynew + ry;
+
+  return p;
+}
+
+
+/*
+ * Get the point to be rotated around given a position in a rectangle
+ */
+R2D_GL_Point R2D_GetRectRotationPoint(int x, int y, int w, int h, int position) {
+
+  R2D_GL_Point p;
+
+  switch (position) {
+    case R2D_CENTER:
+      p.x = x + (w / 2.0);
+      p.y = y + (h / 2.0);
+      break;
+    case R2D_TOP_LEFT:
+      p.x = x;
+      p.y = y;
+      break;
+    case R2D_TOP_RIGHT:
+      p.x = x + w;
+      p.y = y;
+      break;
+    case R2D_BOTTOM_LEFT:
+      p.x = x;
+      p.y = y + h;
+      break;
+    case R2D_BOTTOM_RIGHT:
+      p.x = x + w;
+      p.y = y + h;
+      break;
+  }
+
+  return p;
+}
+
+
+/*
+ * Draw a triangle
+ */
+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) {
+
+  R2D_GL_DrawTriangle(x1, y1, r1, g1, b1, a1,
+                      x2, y2, r2, g2, b2, a2,
+                      x3, y3, r3, g3, b3, a3);
+}
+
+
+/*
+ * Draw a quad, using two triangles
+ */
+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,
+                  GLfloat x3, GLfloat y3,
+                  GLfloat r3, GLfloat g3, GLfloat b3, GLfloat a3,
+                  GLfloat x4, GLfloat y4,
+                  GLfloat r4, GLfloat g4, GLfloat b4, GLfloat a4) {
+
+  R2D_GL_DrawTriangle(x1, y1, r1, g1, b1, a1,
+                      x2, y2, r2, g2, b2, a2,
+                      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);
+};
+
+
+/*
+ * Draw a line from a quad
+ */
+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,
+                  GLfloat r3, GLfloat g3, GLfloat b3, GLfloat a3,
+                  GLfloat r4, GLfloat g4, GLfloat b4, GLfloat a4) {
+
+  double length = sqrt(powf(x1 - x2, 2) + powf(y1 - y2, 2));
+  double x = ((x2 - x1) / length) * width / 2;
+  double y = ((y2 - y1) / length) * width / 2;
+
+  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,
+    x2 - y, y2 + x, r4, g4, b4, a4
+  );
+};
+
+
+/*
+ * Draw a circle from triangles
+ */
+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;
+
+  for (int i = 0; i < sectors; i++) {
+
+    GLfloat x1 = x + radius * cos(i * angle);
+    GLfloat y1 = y + radius * sin(i * angle);
+
+    GLfloat x2 = x + radius * cos((i - 1) * angle);
+    GLfloat y2 = y + radius * sin((i - 1) * angle);
+
+    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,93 @@
+// 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 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/ext/ruby2d/sprite.c

@@ -0,0 +1,147 @@
+// sprite.c
+
+#include "ruby2d.h"
+
+
+/*
+ * Create a sprite, given an image file path
+ */
+R2D_Sprite *R2D_CreateSprite(const char *path) {
+
+  // Check if image file exists
+  if (!R2D_FileExists(path)) {
+    R2D_Error("R2D_CreateSprite", "Sprite image file `%s` not found", path);
+    return NULL;
+  }
+
+  // Allocate the sprite structure
+  R2D_Sprite *spr = (R2D_Sprite *) malloc(sizeof(R2D_Sprite));
+  if (!spr) {
+    R2D_Error("R2D_CreateSprite", "Out of memory!");
+    return NULL;
+  }
+
+  // Load the sprite image file
+  spr->img = R2D_CreateImage(path);
+  if (!spr->img) {
+    R2D_Error("R2D_CreateSprite", "Cannot create sprite image `%s`", path);
+    free(spr);
+    return NULL;
+  }
+
+  // Initialize values
+  spr->path = path;
+  spr->x = 0;
+  spr->y = 0;
+  spr->color.r = 1.f;
+  spr->color.g = 1.f;
+  spr->color.b = 1.f;
+  spr->color.a = 1.f;
+  spr->width  = spr->img->width;
+  spr->height = spr->img->height;
+  spr->clip_width  = spr->img->width;
+  spr->clip_height = spr->img->height;
+  spr->rotate = 0;
+  spr->rx = 0;
+  spr->ry = 0;
+  spr->tx1 = 0.f;
+  spr->ty1 = 0.f;
+  spr->tx2 = 1.f;
+  spr->ty2 = 0.f;
+  spr->tx3 = 1.f;
+  spr->ty3 = 1.f;
+  spr->tx4 = 0.f;
+  spr->ty4 = 1.f;
+
+  return spr;
+}
+
+
+/*
+ * Clip a sprite
+ */
+void R2D_ClipSprite(R2D_Sprite *spr, int x, int y, int w, int h) {
+  if (!spr) return;
+
+  // Calculate ratios
+  // rw = ratio width; rh = ratio height
+  double rw = w / (double)spr->img->width;
+  double rh = h / (double)spr->img->height;
+
+  // Apply ratios to x, y coordinates
+  // cx = crop x coord; cy = crop y coord
+  double cx = x * rw;
+  double cy = y * rh;
+
+  // Convert given width, height to doubles
+  // cw = crop width; ch = crop height
+  double cw = (double)w;
+  double ch = (double)h;
+
+  // Apply ratio to texture width and height
+  // tw = texture width; th = texture height
+  double tw = rw * w;
+  double th = rh * h;
+
+  // Calculate and store sprite texture values
+
+  spr->tx1 =  cx       / cw;
+  spr->ty1 =  cy       / ch;
+
+  spr->tx2 = (cx + tw) / cw;
+  spr->ty2 =  cy       / ch;
+
+  spr->tx3 = (cx + tw) / cw;
+  spr->ty3 = (cy + th) / ch;
+
+  spr->tx4 =  cx       / cw;
+  spr->ty4 = (cy + th) / ch;
+
+  // Store the sprite dimensions
+  spr->width  = (spr->width  / (double)spr->clip_width ) * w;
+  spr->height = (spr->height / (double)spr->clip_height) * h;
+  spr->clip_width  = w;
+  spr->clip_height = h;
+}
+
+
+/*
+ * Rotate a sprite
+ */
+void R2D_RotateSprite(R2D_Sprite *spr, GLfloat angle, int position) {
+
+  R2D_GL_Point p = R2D_GetRectRotationPoint(
+    spr->x, spr->y, spr->width, spr->height, position
+  );
+
+  spr->rotate = angle;
+  spr->rx = p.x;
+  spr->ry = p.y;
+}
+
+
+/*
+ * Draw a sprite
+ */
+void R2D_DrawSprite(R2D_Sprite *spr) {
+  if (!spr) return;
+
+  if (spr->img->texture_id == 0) {
+    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);
+  }
+
+  R2D_GL_DrawSprite(spr);
+}
+
+
+/*
+ * Free a sprite
+ */
+void R2D_FreeSprite(R2D_Sprite *spr) {
+  if (!spr) return;
+  R2D_FreeImage(spr->img);
+  free(spr);
+}

data/ext/ruby2d/text.c

@@ -0,0 +1,129 @@
+// text.c
+
+#include "ruby2d.h"
+
+
+/*
+ * Create text, given a font file path, the message, and size
+ */
+R2D_Text *R2D_CreateText(const char *font, const char *msg, int size) {
+  R2D_Init();
+
+  // Check if font file exists
+  if (!R2D_FileExists(font)) {
+    R2D_Error("R2D_CreateText", "Font file `%s` not found", font);
+    return NULL;
+  }
+
+  // `msg` cannot be an empty string or NULL for TTF_SizeText
+  if (msg == NULL || strlen(msg) == 0) msg = " ";
+
+  // Allocate the text structure
+  R2D_Text *txt = (R2D_Text *) malloc(sizeof(R2D_Text));
+  if (!txt) {
+    R2D_Error("R2D_CreateText", "Out of memory!");
+    return NULL;
+  }
+
+  // Open the font
+  txt->font_data = TTF_OpenFont(font, size);
+  if (!txt->font_data) {
+    R2D_Error("TTF_OpenFont", TTF_GetError());
+    free(txt);
+    return NULL;
+  }
+
+  // Initialize values
+  txt->font = font;
+  txt->msg = (char *) malloc(strlen(msg) + 1 * sizeof(char));
+  strcpy(txt->msg, msg);
+  txt->x = 0;
+  txt->y = 0;
+  txt->color.r = 1.f;
+  txt->color.g = 1.f;
+  txt->color.b = 1.f;
+  txt->color.a = 1.f;
+  txt->rotate = 0;
+  txt->rx = 0;
+  txt->ry = 0;
+  txt->texture_id = 0;
+
+  // Save the width and height of the text
+  TTF_SizeUTF8(txt->font_data, txt->msg, &txt->width, &txt->height);
+
+  return txt;
+}
+
+
+/*
+ * Set the text message
+ */
+void R2D_SetText(R2D_Text *txt, const char *msg, ...) {
+  if (!txt) return;
+
+  // `msg` cannot be an empty string or NULL for TTF_SizeUTF8
+  if (msg == NULL || strlen(msg) == 0) msg = " ";
+
+  // Format and store new text string
+  va_list args;
+  va_start(args, msg);
+  free(txt->msg);
+  vasprintf(&txt->msg, msg, args);
+  va_end(args);
+
+  // Save the width and height of the text
+  TTF_SizeUTF8(txt->font_data, txt->msg, &txt->width, &txt->height);
+
+  // Delete the current texture so a new one can be generated
+  R2D_GL_FreeTexture(&txt->texture_id);
+}
+
+
+/*
+ * Rotate text
+ */
+void R2D_RotateText(R2D_Text *txt, GLfloat angle, int position) {
+
+  R2D_GL_Point p = R2D_GetRectRotationPoint(
+    txt->x, txt->y, txt->width, txt->height, position
+  );
+
+  txt->rotate = angle;
+  txt->rx = p.x;
+  txt->ry = p.y;
+}
+
+
+/*
+ * Draw text
+ */
+void R2D_DrawText(R2D_Text *txt) {
+  if (!txt) return;
+
+  if (txt->texture_id == 0) {
+    SDL_Color color = { 255, 255, 255 };
+    txt->surface = TTF_RenderUTF8_Blended(txt->font_data, txt->msg, color);
+    if (!txt->surface) {
+      R2D_Error("TTF_RenderUTF8_Blended", TTF_GetError());
+      return;
+    }
+    R2D_GL_CreateTexture(&txt->texture_id, GL_RGBA,
+                         txt->width, txt->height,
+                         txt->surface->pixels, GL_NEAREST);
+    SDL_FreeSurface(txt->surface);
+  }
+
+  R2D_GL_DrawText(txt);
+}
+
+
+/*
+ * Free the text
+ */
+void R2D_FreeText(R2D_Text *txt) {
+  if (!txt) return;
+  free(txt->msg);
+  R2D_GL_FreeTexture(&txt->texture_id);
+  TTF_CloseFont(txt->font_data);
+  free(txt);
+}