ruby-sdl2 0.1.0

data/extconf.rb

@@ -0,0 +1,53 @@
+require 'mkmf'
+
+def add_cflags(str)
+  $CFLAGS += " " + str
+end
+
+def add_libs(str)
+  $LOCAL_LIBS += " " + str
+end
+
+def run_config_program(*args)
+  IO.popen([*args], "r") do |io|
+    io.gets.chomp
+  end
+end
+
+def config(pkg_config, header, libnames)
+  if system("pkg-config", pkg_config, "--exists")
+    puts("Use pkg-config #{pkg_config}")
+    add_cflags(run_config_program("pkg-config", pkg_config, "--cflags"))
+    add_libs(run_config_program("pkg-config", pkg_config, "--libs"))
+  else
+    libnames.each{|libname| break if have_library(libname) }
+  end
+  
+  have_header(header)
+end
+
+def sdl2config_with_command
+  sdl2_config = with_config('sdl2-config', 'sdl2-config')
+  add_cflags(run_config_program(sdl2_config, "--cflags"))
+  add_libs(run_config_program(sdl2_config, "--libs"))
+end
+
+def sdl2config_on_mingw
+  have_library("mingw32")
+  have_library("SDL2")
+  add_libs("-mwindows")
+end
+
+case RbConfig::CONFIG["arch"]
+when /mingw/
+  sdl2config_on_mingw
+else
+  sdl2config_with_command
+end
+
+config("SDL2_image", "SDL_image.h", ["SDL2_image", "SDL_image"])
+config("SDL2_mixer", "SDL_mixer.h", ["SDL2_mixer", "SDL_mixer"])
+config("SDL2_ttf", "SDL_ttf.h", ["SDL2_ttf", "SDL_ttf"])
+have_header("SDL_filesystem.h")
+
+create_makefile('sdl2_ext')

data/filesystem.c

@@ -0,0 +1,36 @@
+#ifdef HAVE_SDL_FILESYSTEM_H
+#include "rubysdl2_internal.h"
+#include <SDL_filesystem.h>
+
+static VALUE SDL2_s_base_path(VALUE self)
+{
+    char* path = SDL_GetBasePath();
+    VALUE str;
+    if (!path)
+        SDL_ERROR();
+    str = utf8str_new_cstr(path);
+    SDL_free(path);
+    return str;
+}
+
+static VALUE SDL2_s_preference_path(VALUE self, VALUE org, VALUE app)
+{
+    char* path = SDL_GetPrefPath(StringValueCStr(org), StringValueCStr(app));
+    VALUE str;
+    if (!path)
+        SDL_ERROR();
+    str = utf8str_new_cstr(path);
+    SDL_free(path);
+    return str;
+}
+
+void rubysdl2_init_filesystem(void)
+{
+    rb_define_module_function(mSDL2, "base_path", SDL2_s_base_path, 0);
+    rb_define_module_function(mSDL2, "preference_path", SDL2_s_preference_path, 2);
+}
+#else
+void rubysdl2_init_filesystem(void)
+{
+}
+#endif

data/gamecontroller.c

@@ -0,0 +1,194 @@
+#include "rubysdl2_internal.h"
+#include <SDL_gamecontroller.h>
+
+static VALUE cGameController;
+
+typedef struct GameController {
+    SDL_GameController* controller;
+} GameController;
+
+static void GameController_free(GameController* g)
+{
+    if (rubysdl2_is_active() && g->controller)
+        SDL_GameControllerClose(g->controller);
+    free(g);
+}
+
+static VALUE GameController_new(SDL_GameController* controller)
+{
+    GameController* g = ALLOC(GameController);
+    g->controller = controller;
+    return Data_Wrap_Struct(cGameController, 0, GameController_free, g);
+}
+
+DEFINE_WRAPPER(SDL_GameController, GameController, controller, cGameController,
+               "SDL2::GameController");
+
+
+static VALUE GameController_s_add_mapping(VALUE self, VALUE string)
+{
+    int ret = HANDLE_ERROR(SDL_GameControllerAddMapping(StringValueCStr(string)));
+    return INT2NUM(ret);
+}
+
+static VALUE GameController_s_axis_name_of(VALUE self, VALUE axis)
+{
+    const char* name = SDL_GameControllerGetStringForAxis(NUM2INT(axis));
+    if (!name) {
+        SDL_SetError("Unknown axis %d", NUM2INT(axis));
+        SDL_ERROR();
+    }
+    return utf8str_new_cstr(name);
+}
+
+static VALUE GameController_s_button_name_of(VALUE self, VALUE button)
+{
+    const char* name = SDL_GameControllerGetStringForButton(NUM2INT(button));
+    if (!name) {
+        SDL_SetError("Unknown axis %d", NUM2INT(button));
+        SDL_ERROR();
+    }
+    return utf8str_new_cstr(name);
+}
+
+static VALUE GameController_s_axis_from_name(VALUE self, VALUE name)
+{
+    int axis = SDL_GameControllerGetAxisFromString(StringValueCStr(name));
+    if (axis < 0) {
+        SDL_SetError("Unknown axis name \"%s\"", StringValueCStr(name));
+        SDL_ERROR();
+    } 
+    return INT2FIX(axis);
+}
+
+static VALUE GameController_s_button_from_name(VALUE self, VALUE name)
+{
+    int button = SDL_GameControllerGetButtonFromString(StringValueCStr(name));
+    if (button < 0) {
+        SDL_SetError("Unknown button name \"%s\"", StringValueCStr(name));
+        SDL_ERROR();
+    }
+    return INT2FIX(button);
+}
+
+static VALUE GameController_s_device_names(VALUE self)
+{
+    int num_joysticks = SDL_NumJoysticks();
+    int i;
+    VALUE device_names = rb_ary_new2(num_joysticks);
+    for (i=0; i<num_joysticks; ++i) {
+        const char* name = SDL_GameControllerNameForIndex(i);
+        if (name)
+            rb_ary_push(device_names, utf8str_new_cstr(name));
+        else
+            rb_ary_push(device_names, Qnil);
+    }
+    return device_names;
+}
+
+static VALUE GameController_s_mapping_for(VALUE self, VALUE guid_string)
+{
+    SDL_JoystickGUID guid = SDL_JoystickGetGUIDFromString(StringValueCStr(guid_string));
+    return utf8str_new_cstr(SDL_GameControllerMappingForGUID(guid));
+}
+
+static VALUE GameController_s_open(VALUE self, VALUE index)
+{
+    SDL_GameController* controller = SDL_GameControllerOpen(NUM2INT(index));
+    if (!controller)
+        SDL_ERROR();
+    return GameController_new(controller);
+}
+
+static VALUE GameController_name(VALUE self)
+{
+    return utf8str_new_cstr(SDL_GameControllerName(Get_SDL_GameController(self)));
+}
+
+static VALUE GameController_attached_p(VALUE self)
+{
+    return INT2BOOL(SDL_GameControllerGetAttached(Get_SDL_GameController(self)));
+}
+
+static VALUE GameController_destroy(VALUE self)
+{
+    GameController* g = Get_GameController(self);
+    if (g->controller)
+        SDL_GameControllerClose(g->controller);
+    g->controller = NULL;
+    return Qnil;
+}
+
+static VALUE GameController_mapping(VALUE self)
+{
+    return utf8str_new_cstr(SDL_GameControllerMapping(Get_SDL_GameController(self)));
+}
+
+static VALUE GameController_axis(VALUE self, VALUE axis)
+{
+    return INT2FIX(SDL_GameControllerGetAxis(Get_SDL_GameController(self),
+                                             NUM2INT(axis)));
+}
+
+static VALUE GameController_button_pressed_p(VALUE self, VALUE button)
+{
+    return INT2BOOL(SDL_GameControllerGetButton(Get_SDL_GameController(self),
+                                                NUM2INT(button)));
+}
+
+void rubysdl2_init_gamecontorller(void)
+{
+    cGameController = rb_define_class_under(mSDL2, "GameController", rb_cObject);
+
+    rb_define_singleton_method(cGameController, "add_mapping",
+                               GameController_s_add_mapping, 1);
+    rb_define_singleton_method(cGameController, "device_names",
+                               GameController_s_device_names, 0);
+    rb_define_singleton_method(cGameController, "axis_name_of",
+                               GameController_s_axis_name_of, 1);
+    rb_define_singleton_method(cGameController, "button_name_of",
+                               GameController_s_button_name_of, 1);
+    rb_define_singleton_method(cGameController, "mapping_for",
+                               GameController_s_mapping_for, 1);
+    rb_define_singleton_method(cGameController, "button_from_name",
+                               GameController_s_button_from_name, 1);
+    rb_define_singleton_method(cGameController, "axis_from_name",
+                               GameController_s_axis_from_name, 1);
+    rb_define_singleton_method(cGameController, "open", GameController_s_open, 1);
+    rb_define_method(cGameController, "destroy?", GameController_destroy_p, 0);
+    rb_define_method(cGameController, "destroy", GameController_destroy, 0);
+    rb_define_method(cGameController, "name", GameController_name, 0);
+    rb_define_method(cGameController, "attached?", GameController_attached_p, 0);
+    rb_define_method(cGameController, "mapping", GameController_mapping, 0);
+    rb_define_method(cGameController, "axis", GameController_axis, 1);
+    rb_define_method(cGameController, "button_pressed?", GameController_button_pressed_p, 1);
+#define DEFINE_CONTROLLER_AXIS_CONST(type) \
+    rb_define_const(cGameController, "AXIS_" #type, INT2NUM(SDL_CONTROLLER_AXIS_##type))
+    DEFINE_CONTROLLER_AXIS_CONST(INVALID);
+    DEFINE_CONTROLLER_AXIS_CONST(LEFTX);
+    DEFINE_CONTROLLER_AXIS_CONST(LEFTY);
+    DEFINE_CONTROLLER_AXIS_CONST(RIGHTX);
+    DEFINE_CONTROLLER_AXIS_CONST(RIGHTY);
+    DEFINE_CONTROLLER_AXIS_CONST(TRIGGERLEFT);
+    DEFINE_CONTROLLER_AXIS_CONST(TRIGGERRIGHT);
+    DEFINE_CONTROLLER_AXIS_CONST(MAX);
+#define DEFINE_CONTROLLER_BUTTON_CONST(type) \
+    rb_define_const(cGameController, "BUTTON_" #type, INT2NUM(SDL_CONTROLLER_BUTTON_##type))
+    DEFINE_CONTROLLER_BUTTON_CONST(INVALID);
+    DEFINE_CONTROLLER_BUTTON_CONST(A);
+    DEFINE_CONTROLLER_BUTTON_CONST(B);
+    DEFINE_CONTROLLER_BUTTON_CONST(X);
+    DEFINE_CONTROLLER_BUTTON_CONST(Y);
+    DEFINE_CONTROLLER_BUTTON_CONST(BACK);
+    DEFINE_CONTROLLER_BUTTON_CONST(GUIDE);
+    DEFINE_CONTROLLER_BUTTON_CONST(START);
+    DEFINE_CONTROLLER_BUTTON_CONST(LEFTSTICK);
+    DEFINE_CONTROLLER_BUTTON_CONST(RIGHTSTICK);
+    DEFINE_CONTROLLER_BUTTON_CONST(LEFTSHOULDER);
+    DEFINE_CONTROLLER_BUTTON_CONST(RIGHTSHOULDER);
+    DEFINE_CONTROLLER_BUTTON_CONST(DPAD_UP);
+    DEFINE_CONTROLLER_BUTTON_CONST(DPAD_DOWN);
+    DEFINE_CONTROLLER_BUTTON_CONST(DPAD_LEFT);
+    DEFINE_CONTROLLER_BUTTON_CONST(DPAD_RIGHT);
+    DEFINE_CONTROLLER_BUTTON_CONST(MAX);
+}

data/gl.c.m4

@@ -0,0 +1,201 @@
+/* -*- mode: C -*- */
+#include "rubysdl2_internal.h"
+#include <SDL_video.h>
+#include <SDL_version.h>
+
+static VALUE mGL;
+static VALUE cGLContext;
+
+static VALUE current_context = Qnil;
+
+typedef struct GLContext {
+    SDL_GLContext context;
+} GLContext;
+
+DEFINE_WRAPPER(SDL_GLContext, GLContext, context, cGLContext, "SDL2::GL::Context");
+
+static void GLContext_free(GLContext* c)
+{
+    if (c->context)
+        SDL_GL_DeleteContext(c->context);
+    free(c);
+}
+
+static VALUE GLContext_new(SDL_GLContext context)
+{
+    GLContext* c = ALLOC(GLContext);
+    c->context = context;
+    return Data_Wrap_Struct(cGLContext, 0, GLContext_free, c);
+}
+/*
+ * @overload create(window)
+ *   Create an OpenGL context for use with an OpenGL window, and make it
+ *   current.
+ *
+ *   @param window [SDL2::Window] the window corresponding with a new context
+ *   @return [SDL2::GL::Context]
+ *
+ *   @see #delete
+ */
+static VALUE GLContext_s_create(VALUE self, VALUE window)
+{
+    SDL_GLContext context = SDL_GL_CreateContext(Get_SDL_Window(window));
+    if (!context)
+        SDL_ERROR();
+
+    return (current_context = GLContext_new(context));
+}
+
+static VALUE GLContext_destroy(VALUE self)
+{
+    GLContext* c = Get_GLContext(self);
+    if (c->context)
+        SDL_GL_DeleteContext(c->context);
+    c->context = NULL;
+    return Qnil;
+}
+
+static VALUE GLContext_make_current(VALUE self, VALUE window)
+{
+    HANDLE_ERROR(SDL_GL_MakeCurrent(Get_SDL_Window(window), Get_SDL_GLContext(self)));
+    current_context = self;
+    return Qnil;
+}
+
+static VALUE GLContext_s_current(VALUE self)
+{
+    return current_context;
+}
+
+static VALUE GL_s_extension_supported_p(VALUE self, VALUE extension)
+{
+    return INT2BOOL(SDL_GL_ExtensionSupported(StringValueCStr(extension)));
+}
+
+static VALUE GL_s_swap_interval(VALUE self)
+{
+    return INT2NUM(SDL_GL_GetSwapInterval());
+}
+
+static VALUE GL_s_set_swap_interval(VALUE self, VALUE interval)
+{
+    HANDLE_ERROR(SDL_GL_SetSwapInterval(NUM2INT(interval)));
+    return Qnil;
+}
+
+static VALUE GL_s_get_attribute(VALUE self, VALUE attr)
+{
+    int value;
+    HANDLE_ERROR(SDL_GL_GetAttribute(NUM2INT(attr), &value));
+    return INT2NUM(value);
+}
+
+static VALUE GL_s_set_attribute(VALUE self, VALUE attr, VALUE value)
+{
+    HANDLE_ERROR(SDL_GL_SetAttribute(NUM2INT(attr), NUM2INT(value)));
+    return value;
+}
+
+void rubysdl2_init_gl(void)
+{
+    mGL = rb_define_module_under(mSDL2, "GL");
+    cGLContext = rb_define_class_under(mGL, "Context", rb_cObject);
+
+    rb_define_singleton_method(cGLContext, "create", GLContext_s_create, 1);
+    rb_define_singleton_method(cGLContext, "current", GLContext_s_current, 0);
+    
+    rb_define_method(cGLContext, "destroy?", GLContext_destroy_p, 0);
+    rb_define_method(cGLContext, "destroy", GLContext_destroy, 0);
+    rb_define_method(cGLContext, "make_current", GLContext_make_current, 1);
+    
+    rb_define_module_function(mGL, "extension_supported?", GL_s_extension_supported_p, 1);
+    rb_define_module_function(mGL, "swap_interval", GL_s_swap_interval, 0);
+    rb_define_module_function(mGL, "swap_interval=", GL_s_set_swap_interval, 1);
+    rb_define_module_function(mGL, "get_attribute", GL_s_get_attribute, 1);
+    rb_define_module_function(mGL, "set_attribute", GL_s_set_attribute, 2);
+    
+    /* define(`DEFINE_GL_ATTR_CONST',`rb_define_const(mGL, "$1", INT2NUM(SDL_GL_$1))') */
+    /* OpenGL attribute - minimal bits of red channel in color buffer, default is 3 */
+    DEFINE_GL_ATTR_CONST(RED_SIZE);
+    /* OpenGL attribute - minimal bits of green channel in color buffer, default is 3 */
+    DEFINE_GL_ATTR_CONST(GREEN_SIZE);
+    /* OpenGL attribute - minimal bits of blue channel in color buffer, default is 2 */
+    DEFINE_GL_ATTR_CONST(BLUE_SIZE);
+    /* OpenGL attribute - minimal bits of alpha channel in color buffer, default is 0 */
+    DEFINE_GL_ATTR_CONST(ALPHA_SIZE);
+    /* OpenGL attribute - minimal bits of framebufer, default is 0 */
+    DEFINE_GL_ATTR_CONST(BUFFER_SIZE);
+    /* OpenGL attribute - whether the single buffer (0) or double buffer (1), default
+       is double buffer */
+    DEFINE_GL_ATTR_CONST(DOUBLEBUFFER);
+    /* OpenGL attribute - bits of depth buffer, default is 16 */
+    DEFINE_GL_ATTR_CONST(DEPTH_SIZE);
+    /* OpenGL attribute - bits of stencil buffer, default is 0 */
+    DEFINE_GL_ATTR_CONST(STENCIL_SIZE);
+    /* OpenGL attribute - minimal bits of red channel in accumlation buffer,
+       default is 0 */
+    DEFINE_GL_ATTR_CONST(ACCUM_RED_SIZE);
+    /* OpenGL attribute - minimal bits of green channel in accumlation buffer,
+       default is 0 */
+    DEFINE_GL_ATTR_CONST(ACCUM_GREEN_SIZE);
+    /* OpenGL attribute - minimal bits of blue channel in accumlation buffer,
+       default is 0 */
+    DEFINE_GL_ATTR_CONST(ACCUM_BLUE_SIZE);
+    /* OpenGL attribute - minimal bits of alpha channel in accumlation buffer,
+       default is 0 */
+    DEFINE_GL_ATTR_CONST(ACCUM_ALPHA_SIZE);
+    /* OpenGL attribute - whether output is stereo (1) or not (0), default is 0 */
+    DEFINE_GL_ATTR_CONST(STEREO);
+    /* OpenGL attribuite - the number of buffers used for multisampe anti-aliasing,
+       default is 0 */
+    DEFINE_GL_ATTR_CONST(MULTISAMPLEBUFFERS);
+    /* OpenGL attribute - the number of samples used around the current pixel
+       use for multisample anti-aliasing, default is 0 */
+    DEFINE_GL_ATTR_CONST(MULTISAMPLESAMPLES);
+    /* OpenGL attribute - 1 for requiring hardware acceleration, 0 for software rendering,
+       default is allowing either */
+    DEFINE_GL_ATTR_CONST(ACCELERATED_VISUAL);
+    /* OpenGL attribute - not used (deprecated) */
+    DEFINE_GL_ATTR_CONST(RETAINED_BACKING);
+    /* OpenGL attribute - OpenGL context major version */
+    DEFINE_GL_ATTR_CONST(CONTEXT_MAJOR_VERSION);
+    /* OpenGL attribute - OpenGL context minor version */
+    DEFINE_GL_ATTR_CONST(CONTEXT_MINOR_VERSION);
+    /* OpenGL attribute - the bit combination of following constants, or 0.
+     * default is 0
+     * 
+     * * {SDL2::GL::CONTEXT_DEBUG_FLAG}
+     * * {SDL2::GL::CONTEXT_FORWARD_COMPATIBLE_FLAG}
+     * * {SDL2::GL::CONTEXT_ROBUST_ACCESS_FLAG}
+     * * {SDL2::GL::CONTEXT_RESET_ISOLATION_FLAG}
+     */
+    DEFINE_GL_ATTR_CONST(CONTEXT_FLAGS);
+    /* OpenGL attribute - type of GL context, one of the following constants,
+     * defaults depends on platform
+     *
+     * * {SDL2::GL::CONTEXT::PROFILE_CORE}
+     * * {SDL2::GL::CONTEXT::PROFILE_COMPATIBLITY}
+     * * {SDL2::GL::CONTEXT::PROFILE_ES}
+     */
+    DEFINE_GL_ATTR_CONST(CONTEXT_PROFILE_MASK);
+    /* OpenGL attribute - OpenGL context sharing, default is 0 */
+    DEFINE_GL_ATTR_CONST(SHARE_WITH_CURRENT_CONTEXT);
+#if SDL_VERSION_ATLEAST(2,0,1)
+    /* OpenGL attribute - 1 for requesting sRGB capable visual, default to 0 */
+    DEFINE_GL_ATTR_CONST(FRAMEBUFFER_SRGB_CAPABLE);
+#endif
+    /* OpenGL attribute - not used (deprecated) */
+    DEFINE_GL_ATTR_CONST(CONTEXT_EGL);
+
+    /* define(`DEFINE_GL_CONTEXT_CONST',`rb_define_const(mGL, "CONTEXT_$1", INT2NUM(SDL_GL_CONTEXT_$1))') */
+    DEFINE_GL_CONTEXT_CONST(DEBUG_FLAG);
+    DEFINE_GL_CONTEXT_CONST(FORWARD_COMPATIBLE_FLAG);
+    DEFINE_GL_CONTEXT_CONST(ROBUST_ACCESS_FLAG);
+    DEFINE_GL_CONTEXT_CONST(RESET_ISOLATION_FLAG);
+    
+    DEFINE_GL_CONTEXT_CONST(PROFILE_CORE);
+    DEFINE_GL_CONTEXT_CONST(PROFILE_COMPATIBILITY);
+    DEFINE_GL_CONTEXT_CONST(PROFILE_ES);
+    
+    rb_gc_register_address(&current_context);
+}