ruby2d 0.9.0 → 0.9.1

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

@@ -0,0 +1,185 @@
+// Simple 2D Shared functions and data
+
+#include "../include/simple2d.h"
+
+// Initalize S2D shared data
+bool S2D_diagnostics = false;
+
+// S2D initialization status
+static bool initted = false;
+
+
+/*
+ * Provide a `vasprintf()` implementation for Windows
+ */
+#if WINDOWS && !MINGW
+int vasprintf(char **strp, const char *fmt, va_list ap) {
+  int r = -1, size = _vscprintf(fmt, ap);
+  if ((size >= 0) && (size < INT_MAX)) {
+    *strp = (char *)malloc(size + 1);
+    if (*strp) {
+      r = vsnprintf(*strp, size + 1, fmt, ap);
+      if (r == -1) free(*strp);
+    }
+  } else { *strp = 0; }
+  return(r);
+}
+#endif
+
+
+/*
+ * Checks if a file exists and can be accessed
+ */
+bool S2D_FileExists(const char *path) {
+  if (!path) return false;
+
+  if (access(path, F_OK) != -1) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+
+/*
+ * Logs standard messages to the console
+ */
+void S2D_Log(int type, const char *msg, ...) {
+
+  // Always log if diagnostics set, or if a warning or error message
+  if (S2D_diagnostics || type != S2D_INFO) {
+
+    va_list args;
+    va_start(args, msg);
+
+    switch (type) {
+      case S2D_INFO:
+        printf("\033[1;36mInfo:\033[0m ");
+        break;
+      case S2D_WARN:
+        printf("\033[1;33mWarning:\033[0m ");
+        break;
+      case S2D_ERROR:
+        printf("\033[1;31mError:\033[0m ");
+        break;
+    }
+
+    vprintf(msg, args);
+    printf("\n");
+    va_end(args);
+  }
+}
+
+
+/*
+ * Logs Simple 2D errors to the console, with caller and message body
+ */
+void S2D_Error(const char *caller, const char *msg, ...) {
+  va_list args;
+  va_start(args, msg);
+  char *fmsg;
+  vasprintf(&fmsg, msg, args);
+  S2D_Log(S2D_ERROR, "(%s) %s", caller, fmsg);
+  free(fmsg);
+  va_end(args);
+}
+
+
+/*
+ * Enable/disable logging of diagnostics
+ */
+void S2D_Diagnostics(bool status) {
+  S2D_diagnostics = status;
+}
+
+
+/*
+ * Enable terminal colors in Windows
+ */
+void S2D_Windows_EnableTerminalColors() {
+  #if WINDOWS
+    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
+    DWORD dwMode = 0;
+    GetConsoleMode(hOut, &dwMode);
+    dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+    SetConsoleMode(hOut, dwMode);
+  #endif
+}
+
+
+/*
+ * Initialize Simple 2D subsystems
+ */
+bool S2D_Init() {
+  if (initted) return true;
+
+  // Enable terminal colors in Windows
+  S2D_Windows_EnableTerminalColors();
+
+  S2D_Log(S2D_INFO, "Initializing Simple 2D");
+
+  // Initialize SDL
+  if (SDL_Init(SDL_INIT_EVERYTHING) != 0) {
+    S2D_Error("SDL_Init", SDL_GetError());
+    return false;
+  }
+
+  // Initialize SDL_ttf
+  if (TTF_Init() != 0) {
+    S2D_Error("TTF_Init", TTF_GetError());
+    return false;
+  }
+
+  // Initialize SDL_mixer
+  int mix_flags = MIX_INIT_FLAC | MIX_INIT_OGG | MIX_INIT_MP3;
+  int mix_initted = Mix_Init(mix_flags);
+
+  // Bug in SDL2_mixer 2.0.2:
+  //   Mix_Init should return OR'ed flags if successful, but returns 0 instead.
+  //   Fixed in: https://hg.libsdl.org/SDL_mixer/rev/7fa15b556953
+  const SDL_version *linked_version = Mix_Linked_Version();
+  if (linked_version->major == 2 && linked_version->minor == 0 && linked_version->patch == 2) {
+    // It's version 2.0.2, don't check for Mix_Init errors
+  } else {
+    if ((mix_initted&mix_flags) != mix_flags) {
+      S2D_Error("Mix_Init", Mix_GetError());
+    }
+  }
+
+  if (Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 4096) != 0) {
+    S2D_Error("Mix_OpenAudio", Mix_GetError());
+    return false;
+  }
+
+  // Call `S2D_Quit` at program exit
+  atexit(S2D_Quit);
+
+  // All subsystems initted
+  initted = true;
+  return true;
+}
+
+
+/*
+ * Gets the primary display's dimentions
+ */
+void S2D_GetDisplayDimensions(int *w, int *h) {
+  S2D_Init();
+  SDL_DisplayMode dm;
+  SDL_GetCurrentDisplayMode(0, &dm);
+  *w = dm.w;
+  *h = dm.h;
+}
+
+
+/*
+ * Quits Simple 2D subsystems
+ */
+void S2D_Quit() {
+  IMG_Quit();
+  Mix_CloseAudio();
+  Mix_Quit();
+  TTF_Quit();
+  SDL_Quit();
+  initted = false;
+}

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

@@ -0,0 +1,56 @@
+// sound.c
+
+#include "../include/simple2d.h"
+
+
+/*
+ * Create a sound, given an audio file path
+ */
+S2D_Sound *S2D_CreateSound(const char *path) {
+  S2D_Init();
+
+  // Check if sound file exists
+  if (!S2D_FileExists(path)) {
+    S2D_Error("S2D_CreateSound", "Sound file `%s` not found", path);
+    return NULL;
+  }
+
+  // Allocate the sound structure
+  S2D_Sound *snd = (S2D_Sound *) malloc(sizeof(S2D_Sound));
+  if (!snd) {
+    S2D_Error("S2D_CreateSound", "Out of memory!");
+    return NULL;
+  }
+
+  // Load the sound data from file
+  snd->data = Mix_LoadWAV(path);
+  if (!snd->data) {
+    S2D_Error("Mix_LoadWAV", Mix_GetError());
+    free(snd);
+    return NULL;
+  }
+
+  // Initialize values
+  snd->path = path;
+
+  return snd;
+}
+
+
+/*
+ * Play the sound
+ */
+void S2D_PlaySound(S2D_Sound *snd) {
+  if (!snd) return;
+  Mix_PlayChannel(-1, snd->data, 0);
+}
+
+
+/*
+ * Free the sound
+ */
+void S2D_FreeSound(S2D_Sound *snd) {
+  if (!snd) return;
+  Mix_FreeChunk(snd->data);
+  free(snd);
+}

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

@@ -0,0 +1,147 @@
+// sprite.c
+
+#include "../include/simple2d.h"
+
+
+/*
+ * Create a sprite, given an image file path
+ */
+S2D_Sprite *S2D_CreateSprite(const char *path) {
+
+  // Check if image file exists
+  if (!S2D_FileExists(path)) {
+    S2D_Error("S2D_CreateSprite", "Sprite image file `%s` not found", path);
+    return NULL;
+  }
+
+  // Allocate the sprite structure
+  S2D_Sprite *spr = (S2D_Sprite *) malloc(sizeof(S2D_Sprite));
+  if (!spr) {
+    S2D_Error("S2D_CreateSprite", "Out of memory!");
+    return NULL;
+  }
+
+  // Load the sprite image file
+  spr->img = S2D_CreateImage(path);
+  if (!spr->img) {
+    S2D_Error("S2D_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 S2D_ClipSprite(S2D_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 S2D_RotateSprite(S2D_Sprite *spr, GLfloat angle, int position) {
+
+  S2D_GL_Point p = S2D_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 S2D_DrawSprite(S2D_Sprite *spr) {
+  if (!spr) return;
+
+  if (spr->img->texture_id == 0) {
+    S2D_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);
+}
+
+
+/*
+ * Free a sprite
+ */
+void S2D_FreeSprite(S2D_Sprite *spr) {
+  if (!spr) return;
+  S2D_FreeImage(spr->img);
+  free(spr);
+}

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

@@ -0,0 +1,129 @@
+// text.c
+
+#include "../include/simple2d.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();
+
+  // Check if font file exists
+  if (!S2D_FileExists(font)) {
+    S2D_Error("S2D_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
+  S2D_Text *txt = (S2D_Text *) malloc(sizeof(S2D_Text));
+  if (!txt) {
+    S2D_Error("S2D_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());
+    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_SizeText(txt->font_data, txt->msg, &txt->width, &txt->height);
+
+  return txt;
+}
+
+
+/*
+ * Set the text message
+ */
+void S2D_SetText(S2D_Text *txt, const char *msg, ...) {
+  if (!txt) return;
+
+  // `msg` cannot be an empty string or NULL for TTF_SizeText
+  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_SizeText(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);
+}
+
+
+/*
+ * Rotate text
+ */
+void S2D_RotateText(S2D_Text *txt, GLfloat angle, int position) {
+
+  S2D_GL_Point p = S2D_GetRectRotationPoint(
+    txt->x, txt->y, txt->width, txt->height, position
+  );
+
+  txt->rotate = angle;
+  txt->rx = p.x;
+  txt->ry = p.y;
+}
+
+
+/*
+ * Draw text
+ */
+void S2D_DrawText(S2D_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);
+    if (!txt->surface) {
+      S2D_Error("TTF_RenderText_Blended", TTF_GetError());
+      return;
+    }
+    S2D_GL_CreateTexture(&txt->texture_id, GL_RGBA,
+                         txt->width, txt->height,
+                         txt->surface->pixels, GL_NEAREST);
+    SDL_FreeSurface(txt->surface);
+  }
+
+  S2D_GL_DrawText(txt);
+}
+
+
+/*
+ * Free the text
+ */
+void S2D_FreeText(S2D_Text *txt) {
+  if (!txt) return;
+  free(txt->msg);
+  S2D_GL_FreeTexture(&txt->texture_id);
+  TTF_CloseFont(txt->font_data);
+  free(txt);
+}