ruby2d 0.9.0 → 0.9.1

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

@@ -0,0 +1,138 @@
+// image.c
+
+#include "../include/simple2d.h"
+
+
+/*
+ * Create an image, given a file path
+ */
+S2D_Image *S2D_CreateImage(const char *path) {
+  S2D_Init();
+
+  // Check if image file exists
+  if (!S2D_FileExists(path)) {
+    S2D_Error("S2D_CreateImage", "Image file `%s` not found", path);
+    return NULL;
+  }
+
+  // Allocate the image structure
+  S2D_Image *img = (S2D_Image *) malloc(sizeof(S2D_Image));
+  if (!img) {
+    S2D_Error("S2D_CreateImage", "Out of memory!");
+    return NULL;
+  }
+
+  // Load image from file as SDL_Surface
+  img->surface = IMG_Load(path);
+  if (!img->surface) {
+    S2D_Error("IMG_Load", IMG_GetError());
+    free(img);
+    return NULL;
+  }
+
+  int bits_per_color = img->surface->format->Amask == 0 ?
+    img->surface->format->BitsPerPixel / 3 :
+    img->surface->format->BitsPerPixel / 4;
+
+  if (bits_per_color < 8) {
+    S2D_Log(S2D_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
+
+  Uint32 r = img->surface->format->Rmask;
+  Uint32 g = img->surface->format->Gmask;
+  Uint32 a = img->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 tmp;
+    for (int i = 0; i < bpp * w * h; i += bpp) {
+      if (a&0xFF) {
+        tmp = p[i];
+        p[i] = p[i+3];
+        p[i+3] = tmp;
+      }
+      if (g&0xFF0000) {
+        tmp = p[i+1];
+        p[i+1] = p[i+2];
+        p[i+2] = tmp;
+      }
+      if (r&0xFF0000) {
+        tmp = p[i];
+        p[i] = p[i+2];
+        p[i+2] = tmp;
+      }
+    }
+  }
+
+  return img;
+}
+
+
+/*
+ * Rotate an image
+ */
+void S2D_RotateImage(S2D_Image *img, GLfloat angle, int position) {
+
+  S2D_GL_Point p = S2D_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 S2D_DrawImage(S2D_Image *img) {
+  if (!img) return;
+
+  if (img->texture_id == 0) {
+    S2D_GL_CreateTexture(&img->texture_id, img->format,
+                         img->orig_width, img->orig_height,
+                         img->surface->pixels, GL_NEAREST);
+    SDL_FreeSurface(img->surface);
+  }
+
+  S2D_GL_DrawImage(img);
+}
+
+
+/*
+ * Free an image
+ */
+void S2D_FreeImage(S2D_Image *img) {
+  if (!img) return;
+  S2D_GL_FreeTexture(&img->texture_id);
+  free(img);
+}

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

@@ -0,0 +1,48 @@
+// input.c
+
+#include "../include/simple2d.h"
+
+
+/*
+ * Get the mouse coordinates relative to the viewport
+ */
+void S2D_GetMouseOnViewport(S2D_Window *window, int wx, int wy, int *x, int *y) {
+
+  double scale;  // viewport scale factor
+  int w, h;      // width and height of scaled viewport
+
+  switch (window->viewport.mode) {
+
+    case S2D_FIXED: case S2D_EXPAND:
+      *x = wx / (window->orig_width  / (double)window->viewport.width);
+      *y = wy / (window->orig_height / (double)window->viewport.height);
+      break;
+
+    case S2D_SCALE:
+      S2D_GL_GetViewportScale(window, &w, &h, &scale);
+      *x = wx * 1 / scale - (window->width  - w) / (2.0 * scale);
+      *y = wy * 1 / scale - (window->height - h) / (2.0 * scale);
+      break;
+
+    case S2D_STRETCH:
+      *x = wx * window->viewport.width  / (double)window->width;
+      *y = wy * window->viewport.height / (double)window->height;
+      break;
+  }
+}
+
+
+/*
+ * Show the cursor over the window
+ */
+void S2D_ShowCursor() {
+  SDL_ShowCursor(SDL_ENABLE);
+}
+
+
+/*
+ * Hide the cursor over the window
+ */
+void S2D_HideCursor() {
+  SDL_ShowCursor(SDL_DISABLE);
+}

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

@@ -0,0 +1,114 @@
+// music.c
+
+#include "../include/simple2d.h"
+
+
+/*
+ * Create the music
+ */
+S2D_Music *S2D_CreateMusic(const char *path) {
+  S2D_Init();
+
+  // Check if music file exists
+  if (!S2D_FileExists(path)) {
+    S2D_Error("S2D_CreateMusic", "Music file `%s` not found", path);
+    return NULL;
+  }
+
+  // Allocate the music structure
+  S2D_Music *mus = (S2D_Music *) malloc(sizeof(S2D_Music));
+  if (!mus) {
+    S2D_Error("S2D_CreateMusic", "Out of memory!");
+    return NULL;
+  }
+
+  // Load the music data from file
+  mus->data = Mix_LoadMUS(path);
+  if (!mus->data) {
+    S2D_Error("Mix_LoadMUS", Mix_GetError());
+    free(mus);
+    return NULL;
+  }
+
+  // Initialize values
+  mus->path = path;
+
+  return mus;
+}
+
+
+/*
+ * Play the music
+ */
+void S2D_PlayMusic(S2D_Music *mus, bool loop) {
+  if (!mus) return;
+
+  // If looping, set to -1 times; else 0
+  int times = loop ? -1 : 0;
+
+  // times: 0 == once, -1 == forever
+  if (Mix_PlayMusic(mus->data, times) == -1) {
+    // No music for you
+    S2D_Error("S2D_PlayMusic", Mix_GetError());
+  }
+}
+
+
+/*
+ * Pause the playing music
+ */
+void S2D_PauseMusic() {
+  Mix_PauseMusic();
+}
+
+
+/*
+ * Resume the current music
+ */
+void S2D_ResumeMusic() {
+  Mix_ResumeMusic();
+}
+
+
+/*
+ * Stop the playing music; interrupts fader effects
+ */
+void S2D_StopMusic() {
+  Mix_HaltMusic();
+}
+
+
+/*
+ * Get the music volume
+ */
+int S2D_GetMusicVolume() {
+  // Get music volume as percentage of maximum mix volume
+  return ceil(Mix_VolumeMusic(-1) * (100.0 / MIX_MAX_VOLUME));
+}
+
+
+/*
+ * Set the music volume a given percentage
+ */
+void S2D_SetMusicVolume(int volume) {
+  // Set volume to be a percentage of the maximum mix volume
+  Mix_VolumeMusic((volume / 100.0) * MIX_MAX_VOLUME);
+}
+
+
+/*
+ * Fade out the playing music
+ */
+void S2D_FadeOutMusic(int ms) {
+  Mix_FadeOutMusic(ms);
+}
+
+
+/*
+ * Free the music
+ */
+void S2D_FreeMusic(S2D_Music *mus) {
+  if (!mus) return;
+  Mix_FreeMusic(mus->data);
+  free(mus);
+}

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

@@ -0,0 +1,154 @@
+// shapes.c
+
+#include "../include/simple2d.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
+ */
+S2D_GL_Point S2D_RotatePoint(S2D_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
+ */
+S2D_GL_Point S2D_GetRectRotationPoint(int x, int y, int w, int h, int position) {
+
+  S2D_GL_Point p;
+
+  switch (position) {
+    case S2D_CENTER:
+      p.x = x + (w / 2.0);
+      p.y = y + (h / 2.0);
+      break;
+    case S2D_TOP_LEFT:
+      p.x = x;
+      p.y = y;
+      break;
+    case S2D_TOP_RIGHT:
+      p.x = x + w;
+      p.y = y;
+      break;
+    case S2D_BOTTOM_LEFT:
+      p.x = x;
+      p.y = y + h;
+      break;
+    case S2D_BOTTOM_RIGHT:
+      p.x = x + w;
+      p.y = y + h;
+      break;
+  }
+
+  return p;
+}
+
+
+/*
+ * Draw a triangle
+ */
+void S2D_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,
+                      x2, y2, r2, g2, b2, a2,
+                      x3, y3, r3, g3, b3, a3);
+}
+
+
+/*
+ * Draw a quad, using two triangles
+ */
+void S2D_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) {
+
+  S2D_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,
+                      x4, y4, r4, g4, b4, a4,
+                      x1, y1, r1, g1, b1, a1);
+};
+
+
+/*
+ * Draw a line from a quad
+ */
+void S2D_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;
+
+  S2D_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 S2D_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);
+
+    S2D_GL_DrawTriangle( x,  y, r, g, b, a,
+                        x1, y1, r, g, b, a,
+                        x2, y2, r, g, b, a);
+  }
+}