ruby2d-rpeck-windows 0.11.1

data/ext/ruby2d/common.c

@@ -0,0 +1,185 @@
+// Ruby 2D Shared functions and data
+
+#include "ruby2d.h"
+
+// Initalize shared data
+bool R2D_diagnostics = false;
+
+// 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 R2D_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 R2D_Log(int type, const char *msg, ...) {
+
+  // Always log if diagnostics set, or if a warning or error message
+  if (R2D_diagnostics || type != R2D_INFO) {
+
+    va_list args;
+    va_start(args, msg);
+
+    switch (type) {
+      case R2D_INFO:
+        printf("\033[1;36mInfo:\033[0m ");
+        break;
+      case R2D_WARN:
+        printf("\033[1;33mWarning:\033[0m ");
+        break;
+      case R2D_ERROR:
+        printf("\033[1;31mError:\033[0m ");
+        break;
+    }
+
+    vprintf(msg, args);
+    printf("\n");
+    va_end(args);
+  }
+}
+
+
+/*
+ * Logs Ruby 2D errors to the console, with caller and message body
+ */
+void R2D_Error(const char *caller, const char *msg, ...) {
+  va_list args;
+  va_start(args, msg);
+  char *fmsg;
+  vasprintf(&fmsg, msg, args);
+  R2D_Log(R2D_ERROR, "(%s) %s", caller, fmsg);
+  free(fmsg);
+  va_end(args);
+}
+
+
+/*
+ * Enable/disable logging of diagnostics
+ */
+void R2D_Diagnostics(bool status) {
+  R2D_diagnostics = status;
+}
+
+
+/*
+ * Enable terminal colors in Windows
+ */
+void R2D_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 Ruby 2D subsystems
+ */
+bool R2D_Init() {
+  if (initted) return true;
+
+  // Enable terminal colors in Windows
+  R2D_Windows_EnableTerminalColors();
+
+  R2D_Log(R2D_INFO, "Initializing Ruby 2D");
+
+  // Initialize SDL
+  if (SDL_Init(SDL_INIT_EVERYTHING) != 0) {
+    R2D_Error("SDL_Init", SDL_GetError());
+    return false;
+  }
+
+  // Initialize SDL_ttf
+  if (TTF_Init() != 0) {
+    R2D_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) {
+      R2D_Error("Mix_Init", Mix_GetError());
+    }
+  }
+
+  if (Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 4096) != 0) {
+    R2D_Error("Mix_OpenAudio", Mix_GetError());
+    return false;
+  }
+
+  // Call `R2D_Quit` at program exit
+  atexit(R2D_Quit);
+
+  // All subsystems initted
+  initted = true;
+  return true;
+}
+
+
+/*
+ * Gets the primary display's dimensions
+ */
+void R2D_GetDisplayDimensions(int *w, int *h) {
+  R2D_Init();
+  SDL_DisplayMode dm;
+  SDL_GetCurrentDisplayMode(0, &dm);
+  *w = dm.w;
+  *h = dm.h;
+}
+
+
+/*
+ * Quits Ruby 2D subsystems
+ */
+void R2D_Quit() {
+  IMG_Quit();
+  Mix_CloseAudio();
+  Mix_Quit();
+  TTF_Quit();
+  SDL_Quit();
+  initted = false;
+}

data/ext/ruby2d/controllers.c

@@ -0,0 +1,110 @@
+// controllers.c
+
+#include "ruby2d.h"
+
+// Stores the last joystick instance ID seen by the system. These instance IDs
+// are unique and increment with each new joystick connected.
+static int last_intance_id = -1;
+
+
+/*
+ * Add controller mapping from string
+ */
+void R2D_AddControllerMapping(const char *map) {
+  int result = SDL_GameControllerAddMapping(map);
+
+  char guid[33];
+  strncpy(guid, map, 32);
+
+  switch (result) {
+    case 1:
+      R2D_Log(R2D_INFO, "Mapping added for GUID: %s", guid);
+      break;
+    case 0:
+      R2D_Log(R2D_INFO, "Mapping updated for GUID: %s", guid);
+      break;
+    case -1:
+      R2D_Error("SDL_GameControllerAddMapping", SDL_GetError());
+      break;
+  }
+}
+
+
+/*
+ * Add controller mappings from the specified file
+ */
+void R2D_AddControllerMappingsFromFile(const char *path) {
+  if (!R2D_FileExists(path)) {
+    R2D_Log(R2D_WARN, "Controller mappings file not found: %s", path);
+    return;
+  }
+
+  int mappings_added = SDL_GameControllerAddMappingsFromFile(path);
+  if (mappings_added == -1) {
+    R2D_Error("SDL_GameControllerAddMappingsFromFile", SDL_GetError());
+  } else {
+    R2D_Log(R2D_INFO, "Added %i controller mapping(s)", mappings_added);
+  }
+}
+
+
+/*
+ * Check if joystick is a controller
+ */
+bool R2D_IsController(SDL_JoystickID id) {
+  return SDL_GameControllerFromInstanceID(id) == NULL ? false : true;
+}
+
+
+/*
+ * Open controllers and joysticks
+ */
+void R2D_OpenControllers() {
+
+  char guid_str[33];
+
+  // Enumerate joysticks
+  for (int device_index = 0; device_index < SDL_NumJoysticks(); ++device_index) {
+
+    // Check if joystick supports SDL's game controller interface (a mapping is available)
+    if (SDL_IsGameController(device_index)) {
+      SDL_GameController *controller = SDL_GameControllerOpen(device_index);
+      SDL_JoystickID intance_id = SDL_JoystickInstanceID(SDL_GameControllerGetJoystick(controller));
+
+      SDL_JoystickGetGUIDString(
+        SDL_JoystickGetGUID(SDL_GameControllerGetJoystick(controller)),
+        guid_str, 33
+      );
+
+      if (intance_id > last_intance_id) {
+        if (controller) {
+          R2D_Log(R2D_INFO, "Controller #%i: %s\n      GUID: %s", intance_id, SDL_GameControllerName(controller), guid_str);
+        } else {
+          R2D_Log(R2D_ERROR, "Could not open controller #%i: %s", intance_id, SDL_GetError());
+        }
+        last_intance_id = intance_id;
+      }
+
+    // Controller interface not supported, try to open as joystick
+    } else {
+      SDL_Joystick *joy = SDL_JoystickOpen(device_index);
+      SDL_JoystickID intance_id = SDL_JoystickInstanceID(joy);
+
+      if (!joy) {
+        R2D_Log(R2D_ERROR, "Could not open controller");
+      } else if(intance_id > last_intance_id) {
+        SDL_JoystickGetGUIDString(
+          SDL_JoystickGetGUID(joy),
+          guid_str, 33
+        );
+        R2D_Log(R2D_INFO,
+          "Controller #%i: %s\n      GUID: %s\n      Axes: %d\n      Buttons: %d\n      Balls: %d",
+          intance_id, SDL_JoystickName(joy), guid_str, SDL_JoystickNumAxes(joy),
+          SDL_JoystickNumButtons(joy), SDL_JoystickNumBalls(joy)
+        );
+        R2D_Log(R2D_WARN, "Controller #%i does not have a mapping available", intance_id);
+        last_intance_id = intance_id;
+      }
+    }
+  }
+}

data/ext/ruby2d/extconf.rb

@@ -0,0 +1,147 @@
+require 'mkmf'
+require_relative '../../lib/ruby2d/cli/colorize'
+
+$errors = []  # Holds errors
+
+# Set the OS platform
+case RUBY_PLATFORM
+when /darwin/
+  $platform = :macos
+when /linux/
+  $platform = :linux
+  if `cat /etc/os-release` =~ /raspbian/
+    $platform = :linux_rpi
+  end
+when /bsd/
+  $platform = :bsd
+when /mingw/
+  $platform = :windows
+else
+  $platform = nil
+end
+
+
+# Helper functions #############################################################
+
+# Print installation errors
+def print_errors
+  puts "
+#{"== #{"Ruby 2D Installation Errors".error} =======================================\n"}
+  #{$errors.join("\n  ")}\n
+#{"======================================================================"}"
+end
+
+
+# Add compiler and linker flags
+def add_flags(type, flags)
+  case type
+  when :c
+    $CFLAGS << " #{flags} "
+  when :ld
+    $LDFLAGS << " #{flags} "
+  end
+end
+
+
+# Check for SDL libraries
+def check_sdl
+  unless have_library('SDL2') && have_library('SDL2_image') && have_library('SDL2_mixer') && have_library('SDL2_ttf')
+
+    $errors << "Couldn't find packages needed by Ruby 2D."
+
+    case $platform
+    when :linux, :linux_rpi
+      # Fedora and CentOS
+      if system('which yum')
+        $errors << "Install the following packages using `yum` (or `dnf`) and try again:\n" <<
+        "  SDL2-devel SDL2_image-devel SDL2_mixer-devel SDL2_ttf-devel".bold
+
+      # Arch
+      elsif system('which pacman')
+        $errors << "Install the following packages using `pacman` and try again:\n" <<
+        "  sdl2 sdl2_image sdl2_mixer sdl2_ttf".bold
+
+      # openSUSE
+      elsif system('which zypper')
+        $errors << "Install the following packages using `zypper` and try again:\n" <<
+        "  libSDL2-devel libSDL2_image-devel libSDL2_mixer-devel libSDL2_ttf-devel".bold
+
+      # Ubuntu, Debian, and Mint
+      # `apt` must be last because openSUSE has it aliased to `zypper`
+      elsif system('which apt')
+        $errors << "Install the following packages using `apt` and try again:\n" <<
+        "  libsdl2-dev libsdl2-image-dev libsdl2-mixer-dev libsdl2-ttf-dev".bold
+      end
+    when :bsd
+      $errors << "Install the following packages using `pkg` and try again:\n" <<
+      "  sdl2 sdl2_image sdl2_mixer sdl2_ttf".bold
+    end
+
+    $errors << "" << "See #{"ruby2d.com".bold} for additional help."
+    print_errors; exit
+  end
+end
+
+
+# Set Raspberry Pi flags
+def set_rpi_flags
+  if $platform == :linux_rpi
+    add_flags(:c, '-I/opt/vc/include')
+    add_flags(:ld, '-L/opt/vc/lib -lbrcmGLESv2')
+  end
+end
+
+
+# Use SDL and other libraries installed by the user (not those bundled with the gem)
+def use_usr_libs
+  # Add flags
+  set_rpi_flags
+  add_flags(:c, '-I/usr/local/include')
+end
+
+
+# Configure native extension ###################################################
+
+# Build Ruby 2D native extention using libraries installed by user
+# To use install flag: `gem install ruby2d -- libs`
+if ARGV.include? 'libs'
+  use_usr_libs
+
+# Use libraries provided by the gem (default)
+else
+  add_flags(:c, '-std=c11')
+
+  case $platform
+
+  when :macos
+    add_flags(:c, '-I../../assets/include')
+    ldir = "#{Dir.pwd}/../../assets/macos/lib"
+
+    add_flags(:ld, "#{ldir}/libSDL2.a #{ldir}/libSDL2_image.a #{ldir}/libSDL2_mixer.a #{ldir}/libSDL2_ttf.a")
+    add_flags(:ld, "#{ldir}/libjpeg.a #{ldir}/libpng16.a #{ldir}/libtiff.a #{ldir}/libwebp.a")
+    add_flags(:ld, "#{ldir}/libmpg123.a #{ldir}/libogg.a #{ldir}/libFLAC.a #{ldir}/libvorbis.a #{ldir}/libvorbisfile.a")
+    add_flags(:ld, "#{ldir}/libfreetype.a #{ldir}/libmodplug.a")
+    add_flags(:ld, "-Wl,-framework,Cocoa -Wl,-framework,GameController -Wl,-framework,ForceFeedback")
+
+  when :linux, :linux_rpi, :bsd
+    check_sdl
+
+    set_rpi_flags
+    add_flags(:ld, "-lSDL2 -lSDL2_image -lSDL2_mixer -lSDL2_ttf -lm")
+    if $platform == :linux then add_flags(:ld, '-lGL') end
+
+  when :windows
+    add_flags(:c, '-I../../assets/include')
+    add_flags(:ld, '-L../../assets/mingw/lib -lSDL2 -lSDL2_image -lSDL2_mixer -lSDL2_ttf')
+    add_flags(:ld, '-lmingw32 -lopengl32 -lglew32')
+
+  # If can't detect the platform, use libraries installed by the user
+  else
+    use_usr_libs
+  end
+end
+
+$LDFLAGS.gsub!(/\n/, ' ')  # remove newlines in flags, they can cause problems
+
+# Create Makefile
+create_makefile('ruby2d/ruby2d')

data/ext/ruby2d/font.c

@@ -0,0 +1,35 @@
+// font.c
+
+#include "ruby2d.h"
+
+
+/*
+ * Create a TTF_Font object given a path to a font and a size
+ */
+TTF_Font *R2D_FontCreateTTFFont(const char *path, int size, const char *style) {
+
+ // Check if font file exists
+  if (!R2D_FileExists(path)) {
+    R2D_Error("R2D_FontCreateTTFFont", "Font file `%s` not found", path);
+    return NULL;
+  }
+
+  TTF_Font *font = TTF_OpenFont(path, size);
+
+  if (!font) {
+    R2D_Error("TTF_OpenFont", TTF_GetError());
+    return NULL;
+  }
+
+  if(strncmp(style, "bold", 4) == 0) {
+    TTF_SetFontStyle(font, TTF_STYLE_BOLD);
+  } else if(strncmp(style, "italic", 6) == 0) {
+    TTF_SetFontStyle(font, TTF_STYLE_ITALIC);
+  } else if(strncmp(style, "underline", 9) == 0) {
+    TTF_SetFontStyle(font, TTF_STYLE_UNDERLINE);
+  } else if(strncmp(style, "strikethrough", 13) == 0) {
+    TTF_SetFontStyle(font, TTF_STYLE_STRIKETHROUGH);
+  }
+
+  return font;
+}