ruby2d 0.9.0 → 0.9.5

data/ext/ruby2d/extconf.rb

@@ -1,8 +1,25 @@
 require 'mkmf'
-require_relative '../../lib/ruby2d/colorize'
+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 /mingw/
+  $platform = :windows
+else
+  $platform = nil
+end
+
 
-S2D_VERSION = '1.1.0'  # Simple 2D minimum version required
-$errors = []  # Array to capture errors
+# Helper functions #############################################################
 
 # Print installation errors
 def print_errors
@@ -12,42 +29,71 @@ def print_errors
 #{"======================================================================"}"
 end
 
-# Check that Simple 2D is installed and meets minimum version requirements
-def check_s2d
 
-  # Simple 2D not installed
-  if `which simple2d`.empty?
-    $errors << "Ruby 2D uses a native library called Simple 2D, which was not found." <<
-    "To install, follow the instructions at #{"ruby2d.com/learn".bold}"
-    print_errors
-    exit
+# Add compiler and linker flags
+def add_flags(type, flags)
+  case type
+  when :c
+    $CFLAGS << " #{flags} "
+  when :ld
+    $LDFLAGS << " #{flags} "
+  end
+end
 
-  # Simple 2D installed, checking version
-  else
-    unless Gem::Version.new(`bash simple2d --version`) >= Gem::Version.new(S2D_VERSION)
-      $errors << "Simple 2D needs to be updated for this version of Ruby 2D." <<
-                 "Run the following, then try reinstalling this gem:\n" <<
-                 "  simple2d update".bold
-      print_errors
-      exit
+
+# Check SDL libraries on Linux
+def check_sdl_linux
+  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."
+
+    # 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
+
+    $errors << "" << "See #{"ruby2d.com".bold} for additional help."
+    print_errors; exit
   end
 end
 
-# Use the Simple 2D, SDL, and other libraries installed by the user (not those bundled with the gem)
-def use_usr_libs
-  check_s2d
 
-  # Add flags
-  $CFLAGS << ' -std=c11 -I/usr/local/include'
-  if `cat /etc/os-release` =~ /raspbian/  # Raspberry Pi
-    $CFLAGS << ' -I/opt/vc/include'
+# 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
-  $LDFLAGS << ' ' << `bash simple2d --libs`
-  $LDFLAGS.gsub!(/\n/, ' ')  # remove newlines in flags, they cause problems
 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'
@@ -55,27 +101,31 @@ if ARGV.include? 'libs'
 
 # Use libraries provided by the gem (default)
 else
-  $CFLAGS << ' -std=c11 -I../../assets/include'
-  case RUBY_PLATFORM
+  add_flags(:c, '-std=c11')
 
-  # macOS
-  when /darwin/
-    # $LDFLAGS << " -L../../assets/macos/lib -lsimple2d -lSDL2 -lSDL2_image -lSDL2_mixer -lSDL2_ttf -ljpeg -lpng16 -ltiff -lwebp -lmpg123 -logg -lflac -lvorbis -lvorbisfile -lfreetype -Wl,-framework,Cocoa -Wl,-framework,ForceFeedback"
+  case $platform
 
+  when :macos
+    add_flags(:c, '-I../../assets/include')
     ldir = "#{Dir.pwd}/../../assets/macos/lib"
-    $LDFLAGS << " #{ldir}/libsimple2d.a #{ldir}/libSDL2.a #{ldir}/libSDL2_image.a #{ldir}/libSDL2_mixer.a #{ldir}/libSDL2_ttf.a \
-                  #{ldir}/libjpeg.a #{ldir}/libpng16.a #{ldir}/libtiff.a #{ldir}/libwebp.a \
-                  #{ldir}/libmpg123.a #{ldir}/libogg.a #{ldir}/libflac.a #{ldir}/libvorbis.a #{ldir}/libvorbisfile.a \
-                  #{ldir}/libfreetype.a -Wl,-framework,Cocoa -Wl,-framework,ForceFeedback"
-
-  # Linux
-  when /linux/
-    # TODO: Implement static compilation for Linux
-    use_usr_libs
 
-  # Windows / MinGW
-  when /mingw/
-    $LDFLAGS << " -L../../assets/mingw/lib -lsimple2d -lSDL2 -lSDL2_image -lSDL2_mixer -lSDL2_ttf -lmingw32 -lopengl32 -lglew32"
+    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")
+    add_flags(:ld, "-Wl,-framework,Cocoa -Wl,-framework,ForceFeedback")
+
+  when :linux, :linux_rpi
+    check_sdl_linux
+
+    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
@@ -83,6 +133,7 @@ else
   end
 end
 
+$LDFLAGS.gsub!(/\n/, ' ')  # remove newlines in flags, they can cause problems
 
-# Create the Makefile
+# Create Makefile
 create_makefile('ruby2d/ruby2d')

data/ext/ruby2d/gl.c

@@ -0,0 +1,430 @@
+// Ruby 2D OpenGL Functions
+
+#include "ruby2d.h"
+
+// Set to `true` to force OpenGL 2.1 (for testing)
+static bool FORCE_GL2 = false;
+
+// Flag set if using OpenGL 2.1
+static bool R2D_GL2 = false;
+
+// The orthographic projection matrix for 2D rendering.
+// Elements 0 and 5 are set in R2D_GL_SetViewport.
+static GLfloat orthoMatrix[16] =
+  {    0,    0,     0,    0,
+       0,    0,     0,    0,
+       0,    0,     0,    0,
+   -1.0f, 1.0f, -1.0f, 1.0f };
+
+
+/*
+ * Prints current GL error
+ */
+void R2D_GL_PrintError(char *error) {
+  R2D_Log(R2D_ERROR, "%s (%d)", error, glGetError());
+}
+
+
+/*
+ * Print info about the current OpenGL context
+ */
+void R2D_GL_PrintContextInfo(R2D_Window *window) {
+  R2D_Log(R2D_INFO,
+    "OpenGL Context\n"
+    "      GL_VENDOR: %s\n"
+    "      GL_RENDERER: %s\n"
+    "      GL_VERSION: %s\n"
+    "      GL_SHADING_LANGUAGE_VERSION: %s",
+    window->R2D_GL_VENDOR,
+    window->R2D_GL_RENDERER,
+    window->R2D_GL_VERSION,
+    window->R2D_GL_SHADING_LANGUAGE_VERSION
+  );
+}
+
+
+/*
+ * Store info about the current OpenGL context
+ */
+void R2D_GL_StoreContextInfo(R2D_Window *window) {
+
+  window->R2D_GL_VENDOR   = glGetString(GL_VENDOR);
+  window->R2D_GL_RENDERER = glGetString(GL_RENDERER);
+  window->R2D_GL_VERSION  = glGetString(GL_VERSION);
+
+  // These are not defined in GLES
+  #if GLES
+    window->R2D_GL_MAJOR_VERSION = 0;
+    window->R2D_GL_MINOR_VERSION = 0;
+  #else
+    glGetIntegerv(GL_MAJOR_VERSION, &window->R2D_GL_MAJOR_VERSION);
+    glGetIntegerv(GL_MINOR_VERSION, &window->R2D_GL_MINOR_VERSION);
+  #endif
+
+  window->R2D_GL_SHADING_LANGUAGE_VERSION = glGetString(GL_SHADING_LANGUAGE_VERSION);
+};
+
+
+/*
+ * Creates a shader object, loads shader string, and compiles.
+ * Returns 0 if shader could not be compiled.
+ */
+GLuint R2D_GL_LoadShader(GLenum type, const GLchar *shaderSrc, char *shaderName) {
+
+  // Create the shader object
+  GLuint shader = glCreateShader(type);
+
+  if (shader == 0) {
+    R2D_GL_PrintError("Failed to create shader program");
+    return 0;
+  }
+
+  // Load the shader source
+  glShaderSource(shader, 1, &shaderSrc, NULL);
+
+  // Compile the shader
+  glCompileShader(shader);
+
+  // Check the compile status
+  GLint compiled;
+  glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
+
+  if (!compiled) {
+    GLint infoLen = 0;
+    glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
+
+    if (infoLen > 1) {
+      char *infoLog = malloc(sizeof(char) * infoLen);
+      glGetShaderInfoLog(shader, infoLen, NULL, infoLog);
+      printf("Error compiling shader \"%s\":\n%s\n", shaderName, infoLog);
+      free(infoLog);
+    }
+
+    glDeleteShader(shader);
+    return 0;
+  }
+
+  return shader;
+}
+
+
+/*
+ * Check if shader program was linked
+ */
+int R2D_GL_CheckLinked(GLuint program, char *name) {
+
+  GLint linked;
+  glGetProgramiv(program, GL_LINK_STATUS, &linked);
+
+  if (!linked) {
+    GLint infoLen = 0;
+    glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLen);
+
+    if (infoLen > 1) {
+      char *infoLog = malloc(sizeof(char) * infoLen);
+      glGetProgramInfoLog(program, infoLen, NULL, infoLog);
+      printf("Error linking program `%s`: %s\n", name, infoLog);
+      free(infoLog);
+    }
+
+    glDeleteProgram(program);
+    return GL_FALSE;
+  }
+
+  return GL_TRUE;
+}
+
+
+/*
+ * Calculate the viewport's scaled width and height
+ */
+void R2D_GL_GetViewportScale(R2D_Window *window, int *w, int *h, double *scale) {
+
+  double s = fmin(
+    window->width  / (double)window->viewport.width,
+    window->height / (double)window->viewport.height
+  );
+
+  *w = window->viewport.width  * s;
+  *h = window->viewport.height * s;
+
+  if (scale) *scale = s;
+}
+
+
+/*
+ * Sets the viewport and matrix projection
+ */
+void R2D_GL_SetViewport(R2D_Window *window) {
+
+  int ortho_w = window->viewport.width;
+  int ortho_h = window->viewport.height;
+  int x, y, w, h;  // calculated GL viewport values
+
+  x = 0; y = 0; w = window->width; h = window->height;
+
+  switch (window->viewport.mode) {
+
+    case R2D_FIXED:
+      w = window->orig_width;
+      h = window->orig_height;
+      y = window->height - h;
+      break;
+
+    case R2D_EXPAND:
+      ortho_w = w;
+      ortho_h = h;
+      break;
+
+    case R2D_SCALE:
+      R2D_GL_GetViewportScale(window, &w, &h, NULL);
+      // Center the viewport
+      x = window->width  / 2.0 - w/2.0;
+      y = window->height / 2.0 - h/2.0;
+      break;
+
+    case R2D_STRETCH:
+      break;
+  }
+
+  glViewport(x, y, w, h);
+
+  // Set orthographic projection matrix
+  orthoMatrix[0] =  2.0f / (GLfloat)ortho_w;
+  orthoMatrix[5] = -2.0f / (GLfloat)ortho_h;
+
+  #if GLES
+    R2D_GLES_ApplyProjection(orthoMatrix);
+  #else
+    if (R2D_GL2) {
+      R2D_GL2_ApplyProjection(ortho_w, ortho_h);
+    } else {
+      R2D_GL3_ApplyProjection(orthoMatrix);
+    }
+  #endif
+}
+
+
+/*
+ * Initialize OpenGL
+ */
+int R2D_GL_Init(R2D_Window *window) {
+
+  // Specify OpenGL contexts and set attributes
+  #if GLES
+    SDL_GL_SetAttribute(SDL_GL_RED_SIZE,   8);
+    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
+    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE,  8);
+    SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
+  #else
+    // Use legacy OpenGL 2.1
+    if (FORCE_GL2) {
+      SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
+      SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
+
+    // Request an OpenGL 3.3 forward-compatible core profile
+    } else {
+      SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
+      SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
+      SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
+    }
+  #endif
+
+  // Create and store the OpenGL context
+  if (FORCE_GL2) {
+    window->glcontext = NULL;
+  } else {
+    // Ask SDL to create an OpenGL context
+    window->glcontext = SDL_GL_CreateContext(window->sdl);
+  }
+
+  // Check if a valid OpenGL context was created
+  if (window->glcontext) {
+    // Valid context found
+
+    // Initialize OpenGL ES 2.0
+    #if GLES
+      R2D_GLES_Init();
+      R2D_GL_SetViewport(window);
+
+    // Initialize OpenGL 3.3+
+    #else
+      // Initialize GLEW on Windows
+      #if WINDOWS
+        GLenum err = glewInit();
+        if (GLEW_OK != err) R2D_Error("GLEW", glewGetErrorString(err));
+      #endif
+      R2D_GL3_Init();
+      R2D_GL_SetViewport(window);
+    #endif
+
+  // Context could not be created
+  } else {
+
+    #if GLES
+      R2D_Error("GLES / SDL_GL_CreateContext", SDL_GetError());
+
+    #else
+      // Try to fallback using an OpenGL 2.1 context
+      SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
+      SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
+
+      // Try creating the context again
+      window->glcontext = SDL_GL_CreateContext(window->sdl);
+
+      // Check if this context was created
+      if (window->glcontext) {
+        // Valid context found
+        R2D_GL2 = true;
+        R2D_GL2_Init();
+        R2D_GL_SetViewport(window);
+
+      // Could not create any OpenGL contexts, hard failure
+      } else {
+        R2D_Error("GL2 / SDL_GL_CreateContext", SDL_GetError());
+        R2D_Log(R2D_ERROR, "An OpenGL context could not be created");
+        return -1;
+      }
+    #endif
+  }
+
+  // Store the context and print it if diagnostics is enabled
+  R2D_GL_StoreContextInfo(window);
+  if (R2D_diagnostics) R2D_GL_PrintContextInfo(window);
+
+  return 0;
+}
+
+
+/*
+ * Creates a texture for rendering
+ */
+void R2D_GL_CreateTexture(GLuint *id, GLint format,
+                          int w, int h,
+                          const GLvoid *data, GLint filter) {
+
+  // If 0, then a new texture; generate name
+  if (*id == 0) glGenTextures(1, id);
+
+  // Bind the named texture to a texturing target
+  glBindTexture(GL_TEXTURE_2D, *id);
+
+  // Specifies the 2D texture image
+  glTexImage2D(
+    GL_TEXTURE_2D, 0, format, w, h,
+    0, format, GL_UNSIGNED_BYTE, data
+  );
+
+  // Set the filtering mode
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
+}
+
+
+/*
+ * Free a texture
+ */
+void R2D_GL_FreeTexture(GLuint *id) {
+  if (*id != 0) {
+    glDeleteTextures(1, id);
+    *id = 0;
+  }
+}
+
+
+/*
+ * Draw a triangle
+ */
+void R2D_GL_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) {
+
+  #if GLES
+    R2D_GLES_DrawTriangle(x1, y1, r1, g1, b1, a1,
+                          x2, y2, r2, g2, b2, a2,
+                          x3, y3, r3, g3, b3, a3);
+  #else
+    if (R2D_GL2) {
+      R2D_GL2_DrawTriangle(x1, y1, r1, g1, b1, a1,
+                           x2, y2, r2, g2, b2, a2,
+                           x3, y3, r3, g3, b3, a3);
+    } else {
+      R2D_GL3_DrawTriangle(x1, y1, r1, g1, b1, a1,
+                           x2, y2, r2, g2, b2, a2,
+                           x3, y3, r3, g3, b3, a3);
+    }
+  #endif
+}
+
+
+/*
+ * Draw an image
+ */
+void R2D_GL_DrawImage(R2D_Image *img) {
+  #if GLES
+    R2D_GLES_DrawImage(img);
+  #else
+    if (R2D_GL2) {
+      R2D_GL2_DrawImage(img);
+    } else {
+      R2D_GL3_DrawImage(img);
+    }
+  #endif
+}
+
+
+/*
+ * Draw sprite
+ */
+void R2D_GL_DrawSprite(R2D_Sprite *spr) {
+  #if GLES
+    R2D_GLES_DrawSprite(spr);
+  #else
+    if (R2D_GL2) {
+      R2D_GL2_DrawSprite(spr);
+    } else {
+      R2D_GL3_DrawSprite(spr);
+    }
+  #endif
+}
+
+
+/*
+ * Draw text
+ */
+void R2D_GL_DrawText(R2D_Text *txt) {
+  #if GLES
+    R2D_GLES_DrawText(txt);
+  #else
+    if (R2D_GL2) {
+      R2D_GL2_DrawText(txt);
+    } else {
+      R2D_GL3_DrawText(txt);
+    }
+  #endif
+}
+
+
+/*
+ * Render and flush OpenGL buffers
+ */
+void R2D_GL_FlushBuffers() {
+  // Only implemented in our OpenGL 3.3+ and ES 2.0 renderers
+  #if GLES
+    // TODO: R2D_GLES_FlushBuffers();
+  #else
+    if (!R2D_GL2) R2D_GL3_FlushBuffers();
+  #endif
+}
+
+
+/*
+ * Clear buffers to given color values
+ */
+void R2D_GL_Clear(R2D_Color clr) {
+  glClearColor(clr.r, clr.g, clr.b, clr.a);
+  glClear(GL_COLOR_BUFFER_BIT);
+}