ruby2d 0.9.0 → 0.9.1

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

@@ -0,0 +1,403 @@
+// window.c
+
+#include "../include/simple2d.h"
+
+
+/*
+ * Create a window
+ */
+S2D_Window *S2D_CreateWindow(const char *title, int width, int height,
+                             S2D_Update update, S2D_Render render, int flags) {
+
+  S2D_Init();
+
+  SDL_DisplayMode dm;
+  SDL_GetCurrentDisplayMode(0, &dm);
+  S2D_Log(S2D_INFO, "Current display mode is %dx%dpx @ %dhz", dm.w, dm.h, dm.refresh_rate);
+
+  width  = width  == S2D_DISPLAY_WIDTH  ? dm.w : width;
+  height = height == S2D_DISPLAY_HEIGHT ? dm.h : height;
+
+  // Allocate window and set default values
+  S2D_Window *window      = (S2D_Window *) malloc(sizeof(S2D_Window));
+  window->sdl             = NULL;
+  window->glcontext       = NULL;
+  window->title           = title;
+  window->width           = width;
+  window->height          = height;
+  window->orig_width      = width;
+  window->orig_height     = height;
+  window->viewport.width  = width;
+  window->viewport.height = height;
+  window->viewport.mode   = S2D_SCALE;
+  window->update          = update;
+  window->render          = render;
+  window->flags           = flags;
+  window->on_key          = NULL;
+  window->on_mouse        = NULL;
+  window->on_controller   = NULL;
+  window->vsync           = true;
+  window->fps_cap         = 60;
+  window->background.r    = 0.0;
+  window->background.g    = 0.0;
+  window->background.b    = 0.0;
+  window->background.a    = 1.0;
+  window->icon            = NULL;
+  window->close           = true;
+
+  // Return the window structure
+  return window;
+}
+
+
+/*
+ * Show the window
+ */
+int S2D_Show(S2D_Window *window) {
+
+  if (!window) {
+    S2D_Error("S2D_Show", "Window cannot be shown (because it's NULL)");
+    return 1;
+  }
+
+  // Create SDL window
+  window->sdl = SDL_CreateWindow(
+    window->title,                                   // title
+    SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,  // window position
+    window->width, window->height,                   // window size
+    SDL_WINDOW_OPENGL | window->flags                // flags
+  );
+
+  if (!window->sdl) S2D_Error("SDL_CreateWindow", SDL_GetError());
+  if (window->icon) S2D_SetIcon(window, window->icon);
+
+  // The window created by SDL might not actually be the requested size.
+  // If it's not the same, retrieve and store the actual window size.
+  int actual_width, actual_height;
+  SDL_GetWindowSize(window->sdl, &actual_width, &actual_height);
+
+  if ((window->width != actual_width) || (window->height != actual_height)) {
+    S2D_Log(S2D_INFO,
+      "Scaling window to %ix%i (requested size was %ix%i)",
+      actual_width, actual_height, window->width, window->height
+    );
+    window->width  = actual_width;
+    window->height = actual_height;
+    window->orig_width  = actual_width;
+    window->orig_height = actual_height;
+  }
+
+  // Set Up OpenGL /////////////////////////////////////////////////////////////
+
+  S2D_GL_Init(window);
+
+  // Set Main Loop Data ////////////////////////////////////////////////////////
+
+  const Uint8 *key_state;
+
+  Uint32 frames = 0;           // Total frames since start
+  Uint32 frames_last_sec = 0;  // Frames in the last second
+  Uint32 start_ms = SDL_GetTicks();  // Elapsed time since start
+  Uint32 next_second_ms = SDL_GetTicks(); // The last time plus a second
+  Uint32 begin_ms = start_ms;  // Time at beginning of loop
+  Uint32 end_ms;               // Time at end of loop
+  Uint32 elapsed_ms;           // Total elapsed time
+  Uint32 loop_ms;              // Elapsed time of loop
+  int delay_ms;                // Amount of delay to achieve desired frame rate
+  const double decay_rate = 0.5;  // Determines how fast an average decays over time
+  double fps = window->fps_cap;   // Moving average of actual FPS, initial value a guess
+
+  // Enable VSync
+  if (window->vsync) {
+    if (!SDL_SetHint(SDL_HINT_RENDER_VSYNC, "1")) {
+      S2D_Log(S2D_WARN, "VSync cannot be enabled");
+    }
+  }
+
+  window->close = false;
+
+  // Main Loop /////////////////////////////////////////////////////////////////
+
+  while (!window->close) {
+
+    // Clear Frame /////////////////////////////////////////////////////////////
+
+    S2D_GL_Clear(window->background);
+
+    // Set FPS /////////////////////////////////////////////////////////////////
+
+    frames++;
+    frames_last_sec++;
+    end_ms = SDL_GetTicks();
+    elapsed_ms = end_ms - start_ms;
+
+    // Calculate the frame rate using an exponential moving average
+    if (next_second_ms < end_ms) {
+      fps = decay_rate * fps + (1.0 - decay_rate) * frames_last_sec;
+      frames_last_sec = 0;
+      next_second_ms = SDL_GetTicks() + 1000;
+    }
+
+    loop_ms = end_ms - begin_ms;
+    delay_ms = (1000 / window->fps_cap) - loop_ms;
+
+    if (delay_ms < 0) delay_ms = 0;
+
+    // Note: `loop_ms + delay_ms` should equal `1000 / fps_cap`
+
+    SDL_Delay(delay_ms);
+    begin_ms = SDL_GetTicks();
+
+    // Handle Input and Window Events //////////////////////////////////////////
+
+    int mx, my;  // mouse x, y coordinates
+
+    SDL_Event e;
+    while (SDL_PollEvent(&e)) {
+      switch (e.type) {
+
+        case SDL_KEYDOWN:
+          if (window->on_key && e.key.repeat == 0) {
+            S2D_Event event = {
+              .type = S2D_KEY_DOWN, .key = SDL_GetScancodeName(e.key.keysym.scancode)
+            };
+            window->on_key(event);
+          }
+          break;
+
+        case SDL_KEYUP:
+          if (window->on_key) {
+            S2D_Event event = {
+              .type = S2D_KEY_UP, .key = SDL_GetScancodeName(e.key.keysym.scancode)
+            };
+            window->on_key(event);
+          }
+          break;
+
+        case SDL_MOUSEBUTTONDOWN: case SDL_MOUSEBUTTONUP:
+          if (window->on_mouse) {
+            S2D_GetMouseOnViewport(window, e.button.x, e.button.y, &mx, &my);
+            S2D_Event event = {
+              .button = e.button.button, .x = mx, .y = my
+            };
+            event.type = e.type == SDL_MOUSEBUTTONDOWN ? S2D_MOUSE_DOWN : S2D_MOUSE_UP;
+            event.dblclick = e.button.clicks == 2 ? true : false;
+            window->on_mouse(event);
+          }
+          break;
+
+        case SDL_MOUSEWHEEL:
+          if (window->on_mouse) {
+            S2D_Event event = {
+              .type = S2D_MOUSE_SCROLL, .direction = e.wheel.direction,
+              .delta_x = e.wheel.x, .delta_y = -e.wheel.y
+            };
+            window->on_mouse(event);
+          }
+          break;
+
+        case SDL_MOUSEMOTION:
+          if (window->on_mouse) {
+            S2D_GetMouseOnViewport(window, e.motion.x, e.motion.y, &mx, &my);
+            S2D_Event event = {
+              .type = S2D_MOUSE_MOVE,
+              .x = mx, .y = my, .delta_x = e.motion.xrel, .delta_y = e.motion.yrel
+            };
+            window->on_mouse(event);
+          }
+          break;
+
+        case SDL_CONTROLLERAXISMOTION:
+          if (window->on_controller) {
+            S2D_Event event = {
+              .which = e.caxis.which, .type = S2D_AXIS,
+              .axis = e.caxis.axis, .value = e.caxis.value
+            };
+            window->on_controller(event);
+          }
+          break;
+
+        case SDL_JOYAXISMOTION:
+          if (window->on_controller && !S2D_IsController(e.jbutton.which)) {
+            S2D_Event event = {
+              .which = e.jaxis.which, .type = S2D_AXIS,
+              .axis = e.jaxis.axis, .value = e.jaxis.value
+            };
+            window->on_controller(event);
+          }
+          break;
+
+        case SDL_CONTROLLERBUTTONDOWN: case SDL_CONTROLLERBUTTONUP:
+          if (window->on_controller) {
+            S2D_Event event = {
+              .which = e.cbutton.which, .button = e.cbutton.button
+            };
+            event.type = e.type == SDL_CONTROLLERBUTTONDOWN ? S2D_BUTTON_DOWN : S2D_BUTTON_UP;
+            window->on_controller(event);
+          }
+          break;
+
+        case SDL_JOYBUTTONDOWN: case SDL_JOYBUTTONUP:
+          if (window->on_controller && !S2D_IsController(e.jbutton.which)) {
+            S2D_Event event = {
+              .which = e.jbutton.which, .button = e.jbutton.button
+            };
+            event.type = e.type == SDL_JOYBUTTONDOWN ? S2D_BUTTON_DOWN : S2D_BUTTON_UP;
+            window->on_controller(event);
+          }
+          break;
+
+        case SDL_JOYDEVICEADDED:
+          S2D_Log(S2D_INFO, "Controller connected (%i total)", SDL_NumJoysticks());
+          S2D_OpenControllers();
+          break;
+
+        case SDL_JOYDEVICEREMOVED:
+          if (S2D_IsController(e.jdevice.which)) {
+            S2D_Log(S2D_INFO, "Controller #%i: %s removed (%i remaining)", e.jdevice.which, SDL_GameControllerName(SDL_GameControllerFromInstanceID(e.jdevice.which)), SDL_NumJoysticks());
+            SDL_GameControllerClose(SDL_GameControllerFromInstanceID(e.jdevice.which));
+          } else {
+            S2D_Log(S2D_INFO, "Controller #%i: %s removed (%i remaining)", e.jdevice.which, SDL_JoystickName(SDL_JoystickFromInstanceID(e.jdevice.which)), SDL_NumJoysticks());
+            SDL_JoystickClose(SDL_JoystickFromInstanceID(e.jdevice.which));
+          }
+          break;
+
+        case SDL_WINDOWEVENT:
+          switch (e.window.event) {
+            case SDL_WINDOWEVENT_RESIZED:
+              // Store new window size, set viewport
+              window->width  = e.window.data1;
+              window->height = e.window.data2;
+              S2D_GL_SetViewport(window);
+              break;
+          }
+          break;
+
+        case SDL_QUIT:
+          S2D_Close(window);
+          break;
+      }
+    }
+
+    // Detect keys held down
+    int num_keys;
+    key_state = SDL_GetKeyboardState(&num_keys);
+
+    for (int i = 0; i < num_keys; i++) {
+      if (window->on_key) {
+        if (key_state[i] == 1) {
+          S2D_Event event = {
+            .type = S2D_KEY_HELD, .key = SDL_GetScancodeName(i)
+          };
+          window->on_key(event);
+        }
+      }
+    }
+
+    // Get and store mouse position relative to the viewport
+    int wx, wy;  // mouse x, y coordinates relative to the window
+    SDL_GetMouseState(&wx, &wy);
+    S2D_GetMouseOnViewport(window, wx, wy, &window->mouse.x, &window->mouse.y);
+
+    // Update Window State /////////////////////////////////////////////////////
+
+    // Store new values in the window
+    window->frames     = frames;
+    window->elapsed_ms = elapsed_ms;
+    window->loop_ms    = loop_ms;
+    window->delay_ms   = delay_ms;
+    window->fps        = fps;
+
+    // Call update and render callbacks
+    if (window->update) window->update();
+    if (window->render) window->render();
+
+    // Draw Frame //////////////////////////////////////////////////////////////
+    SDL_GL_SwapWindow(window->sdl);
+  }
+
+  return 0;
+}
+
+
+/*
+ * Set the icon for the window
+ */
+void S2D_SetIcon(S2D_Window *window, const char *icon) {
+  S2D_Image *img = S2D_CreateImage(icon);
+  if (img) {
+    window->icon = icon;
+    SDL_SetWindowIcon(window->sdl, img->surface);
+    S2D_FreeImage(img);
+  } else {
+    S2D_Log(S2D_WARN, "Could not set window icon");
+  }
+}
+
+
+/*
+ * Take a screenshot of the window
+ */
+void S2D_Screenshot(S2D_Window *window, const char *path) {
+
+  #if GLES
+    S2D_Error("S2D_Screenshot", "Not supported in OpenGL ES");
+  #else
+    // Create a surface the size of the window
+    SDL_Surface *surface = SDL_CreateRGBSurface(
+      SDL_SWSURFACE, window->width, window->height, 24,
+      0x000000FF, 0x0000FF00, 0x00FF0000, 0
+    );
+
+    // Grab the pixels from the front buffer, save to surface
+    glReadBuffer(GL_FRONT);
+    glReadPixels(0, 0, window->width, window->height, GL_RGB, GL_UNSIGNED_BYTE, surface->pixels);
+
+    // Flip image vertically
+
+    void *temp_row = (void *)malloc(surface->pitch);
+    if (!temp_row) {
+      S2D_Error("S2D_Screenshot", "Out of memory!");
+      SDL_FreeSurface(surface);
+      return;
+    }
+
+    int height_div_2 = (int) (surface->h * 0.5);
+
+    for (int index = 0; index < height_div_2; index++) {
+      memcpy((Uint8 *)temp_row,(Uint8 *)(surface->pixels) + surface->pitch * index, surface->pitch);
+      memcpy((Uint8 *)(surface->pixels) + surface->pitch * index, (Uint8 *)(surface->pixels) + surface->pitch * (surface->h - index-1), surface->pitch);
+      memcpy((Uint8 *)(surface->pixels) + surface->pitch * (surface->h - index-1), temp_row, surface->pitch);
+    }
+
+    free(temp_row);
+
+    // Save image to disk
+    IMG_SavePNG(surface, path);
+    SDL_FreeSurface(surface);
+  #endif
+}
+
+
+/*
+ * Close the window
+ */
+int S2D_Close(S2D_Window *window) {
+  if (!window->close) {
+    S2D_Log(S2D_INFO, "Closing window");
+    window->close = true;
+  }
+  return 0;
+}
+
+
+/*
+ * Free all resources
+ */
+int S2D_FreeWindow(S2D_Window *window) {
+  S2D_Close(window);
+  SDL_GL_DeleteContext(window->glcontext);
+  SDL_DestroyWindow(window->sdl);
+  free(window);
+  return 0;
+}

data/ext/ruby2d/extconf.rb

@@ -2,7 +2,25 @@ require 'mkmf'
 require_relative '../../lib/ruby2d/colorize'
 
 S2D_VERSION = '1.1.0'  # Simple 2D minimum version required
-$errors = []  # Array to capture errors
+$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
+
+
+# Helper functions #############################################################
 
 # Print installation errors
 def print_errors
@@ -12,15 +30,15 @@ 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
+               "To install, follow the instructions at #{"ruby2d.com".bold}"
+    print_errors; exit
 
   # Simple 2D installed, checking version
   else
@@ -28,26 +46,79 @@ def check_s2d
       $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
+      print_errors; exit
     end
   end
 end
 
+
+# Add compiler and linker flags
+def add_flags(type, flags)
+  case type
+  when :c
+    $CFLAGS << " #{flags} "
+  when :ld
+    $LDFLAGS << " #{flags} "
+  end
+end
+
+
+# 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
+
+
+# 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 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'
-  end
-  $LDFLAGS << ' ' << `bash simple2d --libs`
-  $LDFLAGS.gsub!(/\n/, ' ')  # remove newlines in flags, they cause problems
+  set_rpi_flags
+  add_flags(:c, '-I/usr/local/include')
+  add_flags(:ld, `bash simple2d --libs`)
 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 +126,36 @@ 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}/libsimple2d.a")
+    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
+    simple2d_dir = "#{Dir.pwd}/../../assets/linux/simple2d"
+
+    `(cd #{simple2d_dir} && make)`
+
+    set_rpi_flags
+    add_flags(:c, "-I#{simple2d_dir}/include")
+    add_flags(:ld, "#{simple2d_dir}/build/libsimple2d.a -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 -lsimple2d -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 +163,7 @@ else
   end
 end
 
+$LDFLAGS.gsub!(/\n/, ' ')  # remove newlines in flags, they can cause problems
 
 # Create the Makefile
 create_makefile('ruby2d/ruby2d')