sdl2-win93 1.0.0

data/ext/sdl2_ext/gl.c.m4

@@ -0,0 +1,351 @@
+/* -*- 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);
+}
+
+/*
+ * Document-module: SDL2::GL
+ *
+ * This module provides the initialize/shutdown functions of OpenGL.
+ *
+ */
+
+/*
+ * Document-class: SDL2::GL::Context
+ *
+ * This class represents an OpenGL context.
+ *
+ * You must create a new OpenGL context before using
+ * OpenGL functions.
+ *
+ * @!method destroy?
+ *   Return true if the context is {#destroy destroyed}.
+ */
+
+/*
+ * @overload create(window)
+ *   Create an OpenGL context for use with an OpenGL window, and make it
+ *   current.
+ *
+ *   @param window [SDL2::Window] the window associate with a new context
+ *   @return [SDL2::GL::Context]
+ *
+ *   @see #delete
+ *
+ *   @example
+ *
+ *     SDL2.init(SDL2::INIT_EVERYTHING)
+ *     # You need to create a window with `OPENGL' flag
+ *     window = SDL2::Window.create("testgl", 0, 0, WINDOW_W, WINDOW_H,
+ *                                  SDL2::Window::Flags::OPENGL)
+ *                                  
+ *     # Create a OpenGL context attached to the window
+ *     context = SDL2::GL::Context.create(window)
+ *
+ *     # You can use OpenGL functions
+ *          :
+ *          
+ *     # Delete the context after using OpenGL functions
+ *     context.destroy
+ */
+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));
+}
+
+/*
+ * Delete the OpenGL context.
+ *
+ * @return [nil]
+ *
+ * @see #destroy?
+ */
+static VALUE GLContext_destroy(VALUE self)
+{
+    GLContext* c = Get_GLContext(self);
+    if (c->context)
+        SDL_GL_DeleteContext(c->context);
+    c->context = NULL;
+    return Qnil;
+}
+
+/*
+ * @overload make_current(window)
+ *   Set the OpenGL context for rendering into an OpenGL window.
+ *
+ *   @param window [SDL2::Window] the window to associate with the context
+ *   @return [nil]
+ */
+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;
+}
+
+/*
+ * Get the current OpenGL context.
+ *
+ * @return [SDL2::GL::Context] the curren context
+ * @return [nil] if there is no current context
+ *
+ * @see #make_current
+ */
+static VALUE GLContext_s_current(VALUE self)
+{
+    return current_context;
+}
+
+/*
+ * @overload extension_supported?(extension) 
+ *   Return true if the current context supports **extension**
+ *
+ *   @param extension [String] the name of an extension
+ *   @example
+ *     SDL2::GL.extension_supported?("GL_EXT_framebuffer_blit")
+ */
+static VALUE GL_s_extension_supported_p(VALUE self, VALUE extension)
+{
+    return INT2BOOL(SDL_GL_ExtensionSupported(StringValueCStr(extension)));
+}
+
+/*
+ * Get the state of swap interval of the current context.
+ *
+ * @return [Integer]
+ *   return 0 when vsync is not used,
+ *   return 1 when vsync is used,
+ *   and return -1 when vsync is not supported by the system (OS).
+ *   
+ */
+static VALUE GL_s_swap_interval(VALUE self)
+{
+    return INT2NUM(SDL_GL_GetSwapInterval());
+}
+
+
+/*
+ * @overload swap_interval=(interval) 
+ *   Set the state of swap interval of the current context.
+ *
+ *   @param interval [Integer]
+ *     0 if you don't want to wait for vsync,
+ *     1 if you want to wait for vsync,
+ *     -1 if you want to use late swap tearing
+ *   @return [nil]
+ *   
+ */
+static VALUE GL_s_set_swap_interval(VALUE self, VALUE interval)
+{
+    HANDLE_ERROR(SDL_GL_SetSwapInterval(NUM2INT(interval)));
+    return Qnil;
+}
+
+/*
+ * @overload get_attribute(attr)
+ *   Get the acutal value for an attribute from current context.
+ *   
+ *   @param attr [Integer] the OpenGL attribute to query
+ *   @return [Integer] 
+ */
+static VALUE GL_s_get_attribute(VALUE self, VALUE attr)
+{
+    int value;
+    HANDLE_ERROR(SDL_GL_GetAttribute(NUM2INT(attr), &value));
+    return INT2NUM(value);
+}
+
+/*
+ * @overload set_attribute(attr, value)
+ *   Set an OpenGL window attribute before window creation.
+ *   
+ *   @param attr [Integer] the OpenGL attribute to set
+ *   @param value [Integer] the desired value for the attribute
+ *   @return [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);
+    /*
+     * INT2NUM(SDL_GL_CONTEXT_FLAGS):
+     * 
+     * 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}
+     *
+     * These flags are mapped to some OpenGL extensions. Please see
+     * the documentation of each constant for more details.
+     *
+     * https://wiki.libsdl.org/SDL_GLcontextFlag
+     */
+    DEFINE_GL_ATTR_CONST(CONTEXT_FLAGS);
+    /* INT2NUM(SDL_GL_CONTEXT_PROFILE_MASK):
+     *
+     * OpenGL attribute - type of GL context, one of the following constants,
+     * defaults depends on platform
+     *
+     * * {CONTEXT_PROFILE_CORE}
+     * * {CONTEXT_PROFILE_COMPATIBILITY}
+     * * {CONTEXT_PROFILE_ES}
+     *
+     * https://wiki.libsdl.org/SDL_GLprofile
+     */
+    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))') */
+
+    /* This flag maps to GLX_CONTEXT_DEBUG_BIT_ARB in
+     * the GLX_ARB_create_context extension for X11
+     * and WGL_CONTEXT_DEBUG_BIT_ARB in the WGL_ARB_create_context
+     * extension for Windows.
+     */
+    DEFINE_GL_CONTEXT_CONST(DEBUG_FLAG);
+    /*
+     * This flag maps to GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB in the
+     * GLX_ARB_create_context extension for X11 and
+     * WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB in the WGL_ARB_create_context
+     * extension for Windows.
+     */
+    DEFINE_GL_CONTEXT_CONST(FORWARD_COMPATIBLE_FLAG);
+    /*
+     * This flag maps to GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB in the
+     * GLX_ARB_create_context_robustness extension for X11 and
+     * WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB in the WGL_ARB_create_context_robustness
+     * extension for Windows. 
+     */
+    DEFINE_GL_CONTEXT_CONST(ROBUST_ACCESS_FLAG);
+    /*
+     * This flag maps to GLX_CONTEXT_RESET_ISOLATION_BIT_ARB in the
+     * GLX_ARB_robustness_isolation extension for X11 and
+     * WGL_CONTEXT_RESET_ISOLATION_BIT_ARB in the WGL_ARB_create_context_robustness
+     * extension for Windows.
+     */
+    DEFINE_GL_CONTEXT_CONST(RESET_ISOLATION_FLAG);
+
+    /*
+     * OpenGL core profile - deprecated
+     * functions are disabled
+     */
+    DEFINE_GL_CONTEXT_CONST(PROFILE_CORE);
+    /*
+     * OpenGL compatibility profile -
+     * deprecated functions are allowed
+     */
+    DEFINE_GL_CONTEXT_CONST(PROFILE_COMPATIBILITY);
+    /*
+     * OpenGL ES profile - only a subset of the
+     * base OpenGL functionality is available
+     */
+    DEFINE_GL_CONTEXT_CONST(PROFILE_ES);
+    
+    rb_gc_register_address(&current_context);
+}

data/ext/sdl2_ext/hint.c

@@ -0,0 +1,99 @@
+#include "rubysdl2_internal.h"
+#include <SDL_hints.h>
+
+static VALUE sym_priority;
+
+/*
+ * Document-module: SDL2::Hints
+ *
+ * This module enables you to get and set configuration hints.
+ *
+ */
+
+/*
+ * Clear all hints set by {.[]=}.
+ *
+ * @return [nil]
+ */
+static VALUE Hints_s_clear(VALUE self)
+{
+    SDL_ClearHints();
+    return Qnil;
+}
+
+/*
+ * @overload [](hint)
+ *   Get the value of a hint.
+ *
+ *   @param hint [String] the name of the hint to query
+ *   
+ * @return [String] the string value of a hint
+ * @return [nil] if the hint isn't set
+ */
+static VALUE Hints_s_aref(VALUE self, VALUE name)
+{
+    const char* value = SDL_GetHint(StringValueCStr(name));
+    if (value)
+        return utf8str_new_cstr(value);
+    else
+        return Qnil;
+}
+
+/*
+ * Set the value of a hint.
+ * 
+ * @overload []=(hint, value)
+ *   Set a hint with normal priority.
+ *
+ *   @param hint [String] the name of the hint to query
+ *   @param value [String] the value of the hint varaible
+ *
+ * @overload []=(hint, priority: , value)
+ *   Set a hint with given priority.
+ *
+ *   @param hint [String] the name of the hint to query
+ *   @param priority [Integer] the priority, one of the
+ *     {DEFAULT}, {NORMAL}, or {OVERRIDE}.
+ *   @param value [String] the value of the hint varaible
+ *   
+ * @return [Boolean] return true if the hint was set
+ *
+ * @example
+ *   SDL2::Hints["SDL_HINT_XINPUT_ENABLED", priority: SDL2::Hints::OVERRIDE] = "0"
+ *
+ */
+static VALUE Hints_s_aset(int argc, VALUE* argv, VALUE self)
+{
+    VALUE name, pri, value;
+    rb_scan_args(argc, argv, "21", &name, &pri, &value);
+    
+    if (argc == 2) {
+        value = pri;
+        return INT2BOOL(SDL_SetHint(StringValueCStr(name), StringValueCStr(value)));
+    } else {
+        Check_Type(pri, T_HASH);
+        return INT2BOOL(SDL_SetHintWithPriority(StringValueCStr(name),
+                                                StringValueCStr(value),
+                                                NUM2INT(rb_hash_aref(pri, sym_priority))));
+    }
+        
+    return Qnil;
+}
+
+void rubysdl2_init_hints(void)
+{
+    VALUE mHints = rb_define_module_under(mSDL2, "Hints");
+    
+    rb_define_singleton_method(mHints, "clear", Hints_s_clear, 0);
+    rb_define_singleton_method(mHints, "get", Hints_s_aref, 1);
+    rb_define_singleton_method(mHints, "[]=", Hints_s_aset, -1);
+
+    /* low priority, used fro default values */
+    rb_define_const(mHints, "DEFAULT", INT2NUM(SDL_HINT_DEFAULT));
+    /* medium priority, overrided by an environment variable */
+    rb_define_const(mHints, "NORMAL", INT2NUM(SDL_HINT_NORMAL));
+    /* high priority, this priority overrides the value by environment variables */
+    rb_define_const(mHints, "OVERRIDE", INT2NUM(SDL_HINT_OVERRIDE));
+
+    sym_priority = ID2SYM(rb_intern("priority"));
+}

data/ext/sdl2_ext/joystick.c

@@ -0,0 +1,339 @@
+/* -*- mode: C -*- */
+#include "rubysdl2_internal.h"
+#include <SDL_joystick.h>
+#include <SDL_gamecontroller.h>
+
+static VALUE cJoystick;
+static VALUE cDeviceInfo;
+static VALUE mHat;
+
+typedef struct Joystick {
+    SDL_Joystick* joystick;
+} Joystick;
+
+static void Joystick_free(Joystick* j)
+{
+    if (rubysdl2_is_active() && j->joystick)
+        SDL_JoystickClose(j->joystick);
+    free(j);
+}
+
+static VALUE Joystick_new(SDL_Joystick* joystick)
+{
+    Joystick* j = ALLOC(Joystick);
+    j->joystick = joystick;
+    return Data_Wrap_Struct(cJoystick, 0, Joystick_free, j);
+}
+
+DEFINE_WRAPPER(SDL_Joystick, Joystick, joystick, cJoystick, "SDL2::Joystick");
+
+/*
+ * Document-class: SDL2::Joystick
+ *
+ * This class represents a joystick connected to the machine.
+ *
+ * In order to use joystick subsystem, {SDL2.init} must have been called
+ * with the SDL2::INIT_JOYSTICK flag.
+ *
+ * @!method destroy?
+ *   Return true if the device is alread closed.
+ *   @see #destroy
+ */
+
+/*
+ * Get the number of connected joysticks.
+ *
+ * @return [Integer]
+ */
+static VALUE Joystick_s_num_connected_joysticks(VALUE self)
+{
+    return INT2FIX(HANDLE_ERROR(SDL_NumJoysticks()));
+}
+
+static VALUE GUID_to_String(SDL_JoystickGUID guid)
+{
+    char buf[128];
+    SDL_JoystickGetGUIDString(guid, buf, sizeof(buf));
+    return rb_usascii_str_new_cstr(buf);
+}
+
+/*
+ * Get the information of connected joysticks
+ *
+ * @return [Array<SDL2::Joystick::DeviceInfo>] information of connected devices
+ */
+static VALUE Joystick_s_devices(VALUE self)
+{
+    int num_joysticks = SDL_NumJoysticks();
+    int i;
+    VALUE devices = rb_ary_new2(num_joysticks);
+    for (i=0; i<num_joysticks; ++i) {
+        VALUE device = rb_obj_alloc(cDeviceInfo);
+        rb_iv_set(device, "@GUID", GUID_to_String(SDL_JoystickGetDeviceGUID(i)));
+        rb_iv_set(device, "@name", utf8str_new_cstr(SDL_JoystickNameForIndex(i)));
+        rb_ary_push(devices, device);
+    }
+    return devices;
+}
+
+/*
+ * @overload open(device_index)
+ *   Open a joystick for use.
+ *
+ *   @param [Integer] device_index device index
+ *   @return [SDL2::Joystick] opended joystick object
+ *   @raise [SDL2::Error] raised when device open is failed.
+ *     for exmaple, device_index is out of range.
+ */
+static VALUE Joystick_s_open(VALUE self, VALUE device_index)
+{
+    SDL_Joystick* joystick = SDL_JoystickOpen(NUM2INT(device_index));
+    if (!joystick)
+        SDL_ERROR();
+    return Joystick_new(joystick);
+}
+
+/*
+ * @overload game_controller?(index)
+ *   Return true if the joystick of given index supports the game controller
+ *   interface.
+ *
+ *   @param [Integer] index the joystick device index
+ *   @see SDL2::GameController
+ * 
+ */
+static VALUE Joystick_s_game_controller_p(VALUE self, VALUE index)
+{
+    return INT2BOOL(SDL_IsGameController(NUM2INT(index)));
+}
+
+/*
+ * Return true a joystick has been opened and currently connected.
+ */
+static VALUE Joystick_attached_p(VALUE self)
+{
+    Joystick* j = Get_Joystick(self);
+    if (!j->joystick)
+        return Qfalse;
+    return INT2BOOL(SDL_JoystickGetAttached(j->joystick));
+}
+
+/*
+ * Get the joystick GUID
+ *
+ * @return [String] GUID string
+ */
+static VALUE Joystick_GUID(VALUE self)
+{
+    SDL_JoystickGUID guid;
+    char buf[128];
+    guid = SDL_JoystickGetGUID(Get_SDL_Joystick(self));
+    SDL_JoystickGetGUIDString(guid, buf, sizeof(buf));
+    return rb_usascii_str_new_cstr(buf);
+}
+
+/*
+ * Get the index of a joystick
+ *
+ * @return [Integer] index
+ */
+static VALUE Joystick_index(VALUE self)
+{
+    return INT2NUM(HANDLE_ERROR(SDL_JoystickInstanceID(Get_SDL_Joystick(self))));
+}
+
+/*
+ * Close a joystick device.
+ * 
+ * @return [nil]
+ * @see #destroy?
+ */
+static VALUE Joystick_destroy(VALUE self)
+{
+    Joystick* j = Get_Joystick(self);
+    if (j->joystick)
+        SDL_JoystickClose(j->joystick);
+    j->joystick = NULL;
+    return Qnil;
+}
+
+/*
+ * Get the name of a joystick
+ *
+ * @return [String] name
+ */
+static VALUE Joystick_name(VALUE self)
+{
+    return utf8str_new_cstr(SDL_JoystickName(Get_SDL_Joystick(self)));
+}
+
+/*
+ * Get the number of general axis controls on a joystick.
+ * @return [Integer]
+ * @see #axis
+ */
+static VALUE Joystick_num_axes(VALUE self)
+{
+    return INT2FIX(SDL_JoystickNumAxes(Get_SDL_Joystick(self)));
+}
+
+/*
+ * Get the number of trackball on a joystick
+ * @return [Integer]
+ * @see #ball
+ */
+static VALUE Joystick_num_balls(VALUE self)
+{
+    return INT2FIX(SDL_JoystickNumBalls(Get_SDL_Joystick(self)));
+}
+
+/*
+ * Get the number of button on a joystick
+ * @return [Integer]
+ * @see #button
+ */
+static VALUE Joystick_num_buttons(VALUE self)
+{
+    return INT2FIX(SDL_JoystickNumButtons(Get_SDL_Joystick(self)));
+}
+
+/*
+ * Get the number of POV hats on a joystick
+ * @return [Integer]
+ * @see #hat
+ */
+static VALUE Joystick_num_hats(VALUE self)
+{
+    return INT2FIX(SDL_JoystickNumHats(Get_SDL_Joystick(self)));
+}
+
+/*
+ * @overload axis(which) 
+ *   Get the current state of an axis control on a joystick.
+ *   
+ *   @param [Integer] which an index of an axis, started at index 0
+ *   @return [Integer] state value, ranging from -32768 to 32767.
+ *   @see #num_axes
+ */
+static VALUE Joystick_axis(VALUE self, VALUE which)
+{
+    return INT2FIX(SDL_JoystickGetAxis(Get_SDL_Joystick(self), NUM2INT(which)));
+}
+
+/*
+ * @overload ball(which) 
+ *   Get the current state of a trackball on a joystick.
+ *   
+ *   @param [Integer] which an index of a trackball, started at index 0
+ *   @return [[Integer,Integer]] dx and dy
+ *   @see #num_balls
+ */
+static VALUE Joystick_ball(VALUE self, VALUE which)
+{
+    int dx, dy;
+    HANDLE_ERROR(SDL_JoystickGetBall(Get_SDL_Joystick(self), NUM2INT(which), &dx, &dy));
+    return rb_ary_new3(2, INT2NUM(dx), INT2NUM(dy));
+}
+
+/*
+ * @overload button(which)
+ *   Get the current state of a button on a joystick.
+ *
+ *   @param [Integer] which an index of a button, started at index 0
+ *   @return [Boolean] true if the button is pressed
+ *   @see #num_buttons
+ */
+static VALUE Joystick_button(VALUE self, VALUE which)
+{
+    return INT2BOOL(SDL_JoystickGetButton(Get_SDL_Joystick(self), NUM2INT(which)));
+}
+
+/*
+ * @overload hat(which)
+ *   Get the current state of a POV hat on a joystick.
+ *
+ *   @param [Integer] which an index of a hat, started at index 0
+ *   @return [Integer] hat state
+ *   @see #num_hats
+ */
+static VALUE Joystick_hat(VALUE self, VALUE which)
+{
+    return UINT2NUM(SDL_JoystickGetHat(Get_SDL_Joystick(self), NUM2INT(which)));
+}
+
+/*
+ * Document-class: SDL2::Joystick::DeviceInfo
+ *
+ * This class represents joystick device information, its name and GUID.
+ *
+ * You can get the information with {SDL2::Joystick.devices}.
+ */
+
+/*
+ * Document-module: SDL2::Joystick::Hat
+ *
+ * This module provides constants of joysticks's hat positions used by {SDL2::Joystick} class.
+ * The position of the hat is represented by OR'd bits of {RIGHT}, {LEFT}, {UP}, and {DOWN}.
+ * This means the center position ({CENTERED}) is represeted by 0 and
+ * the left up position {LEFTUP} is represeted by ({LEFT}|{UP}).
+ */
+
+void rubysdl2_init_joystick(void)
+{
+    cJoystick = rb_define_class_under(mSDL2, "Joystick", rb_cObject);
+    cDeviceInfo = rb_define_class_under(cJoystick, "DeviceInfo", rb_cObject);
+    
+    rb_define_singleton_method(cJoystick, "num_connected_joysticks",
+                               Joystick_s_num_connected_joysticks, 0);
+    rb_define_singleton_method(cJoystick, "devices", Joystick_s_devices, 0);
+    rb_define_singleton_method(cJoystick, "open", Joystick_s_open, 1);
+    rb_define_singleton_method(cJoystick, "game_controller?",
+                               Joystick_s_game_controller_p, 1);
+    rb_define_method(cJoystick, "destroy?", Joystick_destroy_p, 0);
+    rb_define_alias(cJoystick, "close?", "destroy?");
+    rb_define_method(cJoystick, "attached?", Joystick_attached_p, 0);
+    rb_define_method(cJoystick, "GUID", Joystick_GUID, 0);
+    rb_define_method(cJoystick, "index", Joystick_index, 0);
+    rb_define_method(cJoystick, "destroy", Joystick_destroy, 0);
+    rb_define_alias(cJoystick, "close", "destroy");
+    rb_define_method(cJoystick, "name", Joystick_name, 0);
+    rb_define_method(cJoystick, "num_axes", Joystick_num_axes, 0);
+    rb_define_method(cJoystick, "num_balls", Joystick_num_balls, 0);
+    rb_define_method(cJoystick, "num_buttons", Joystick_num_buttons, 0);
+    rb_define_method(cJoystick, "num_hats", Joystick_num_hats, 0);
+    rb_define_method(cJoystick, "axis", Joystick_axis, 1);
+    rb_define_method(cJoystick, "ball", Joystick_ball, 1);
+    rb_define_method(cJoystick, "button", Joystick_button, 1);
+    rb_define_method(cJoystick, "hat", Joystick_hat, 1);
+
+    mHat = rb_define_module_under(cJoystick, "Hat");
+    
+    /*  */
+    /* Center position. Equal to 0. */
+    rb_define_const(mHat, "CENTERED", INT2NUM(SDL_HAT_CENTERED));
+    /* Up position. */
+    rb_define_const(mHat, "UP", INT2NUM(SDL_HAT_UP));
+    /* Right position. */
+    rb_define_const(mHat, "RIGHT", INT2NUM(SDL_HAT_RIGHT));
+    /* Down position. */
+    rb_define_const(mHat, "DOWN", INT2NUM(SDL_HAT_DOWN));
+    /* Left position. */
+    rb_define_const(mHat, "LEFT", INT2NUM(SDL_HAT_LEFT));
+    /* Right Up position. Equal to ({RIGHT} | {UP}) */
+    rb_define_const(mHat, "RIGHTUP", INT2NUM(SDL_HAT_RIGHTUP));
+    /* Right Down position. Equal to ({RIGHT} | {DOWN}) */
+    rb_define_const(mHat, "RIGHTDOWN", INT2NUM(SDL_HAT_RIGHTDOWN));
+    /* Left Up position. Equal to ({LEFT} | {UP}) */
+    rb_define_const(mHat, "LEFTUP", INT2NUM(SDL_HAT_LEFTUP));
+    /* Left Down position. Equal to ({LEFT} | {DOWN}) */
+    rb_define_const(mHat, "LEFTDOWN", INT2NUM(SDL_HAT_LEFTDOWN));
+
+    /* Device GUID
+     * @return [String] */
+    rb_define_attr(cDeviceInfo, "GUID", 1, 0);
+    /* Device name
+     * @return [String] */
+    rb_define_attr(cDeviceInfo, "name", 1, 0);
+
+    
+}