ruby-sdl2 0.1.0

data/mouse.c

@@ -0,0 +1,286 @@
+#include "rubysdl2_internal.h"
+#include <SDL_mouse.h>
+#include <SDL_events.h>
+
+static VALUE mMouse;
+static VALUE cCursor;
+static VALUE cState;
+
+/*
+ * Document-module: SDL2::Mouse
+ *
+ * This module have mouse input handling functions.
+ * 
+ */
+
+/*
+ * Document-class: SDL2::Mouse::Cursor
+ *
+ * This class represents mouse cursor shape, and
+ * have some class-methods for a mouse cursor.
+ */
+
+/*
+ * Document-class: SDL2::Mouse::State
+ *
+ * This class represents mouse stetes.
+ *
+ * You can get a mouse state with {SDL2::Mouse.state}.
+ *
+ * @attribute x
+ *   the x coordinate of the mouse cursor.
+ *
+ *   For {SDL2::Mouse.state}, this attribute means the x coordinate
+ *   relative to the window.
+ *   For {SDL2::Mouse.relative_state}, this attribute means the x coordinate
+ *   relative to the previous call of {SDL2::Mouse.relative_state}.
+ *   
+ *   @return [Integer]
+ *
+ * @attribute y
+ *   the y coordinate of the mouse cursor
+ *
+ *   For {SDL2::Mouse.state}, this attribute means the y coordinate
+ *   relative to the window.
+ *   For {SDL2::Mouse.relative_state}, this attribute means the y coordinate
+ *   relative to the previous call of {SDL2::Mouse.relative_state}.
+ *   
+ *   @return [Integer]
+ *
+ * @attribute button_bits
+ *   button bits
+ *   @return [Integer]
+ *   @see #pressed?
+ */
+
+static VALUE State_new(int x, int y, Uint32 buttons)
+{
+    VALUE state = rb_obj_alloc(cState);
+    rb_iv_set(state, "@x", INT2FIX(x));
+    rb_iv_set(state, "@y", INT2FIX(y));
+    rb_iv_set(state, "@button_bits", UINT2NUM(buttons));
+    return state;
+}
+
+static VALUE mouse_state(Uint32 (*func)(int*,int*))
+{
+    int x, y;
+    Uint32 state;
+    state = func(&x, &y);
+    return State_new(x, y, state);
+}
+
+#if SDL_VERSION_ATLEAST(2,0,4)
+/*
+ * Get the current mouse state in relation to the desktop.
+ *
+ * The return value contains the x and y coordinates of the cursor
+ * relative to the desktop and the state of mouse buttons.
+ *
+ * @note This module function is available since SDL 2.0.4.
+ * @return [SDL2::Mouse::State] current state
+ */
+static VALUE Mouse_s_global_state(VALUE self)
+{
+    return mouse_state(SDL_GetGlobalMouseState);
+}
+#endif
+
+/*
+ * Get the current state of the mouse.
+ *
+ * The return value contains the x and y coordinates of the cursor and
+ * the state of mouse buttons.
+ * 
+ * @return [SDL2::Mouse::State] current state
+ */
+static VALUE Mouse_s_state(VALUE self)
+{
+    return mouse_state(SDL_GetMouseState);
+}
+
+/*
+ * Return true if relative mouse mode is enabled.
+ * 
+ * @see .relative_mode=
+ */
+static VALUE Mouse_s_relative_mode_p(VALUE self)
+{
+    return INT2BOOL(SDL_GetRelativeMouseMode());
+}
+
+/*
+ * @overload relative_mode=(bool)
+ *   @param [Boolean] bool true if you want to enable relative mouse mode
+ *
+ * Set relative mouse mode.
+ *
+ * While the mouse is in relative mode, the cursor is hidden, and the
+ * driver will try to report continuous motion in the current window.
+ * Only relative motion events will be delivered, the mouse position
+ * will not change.
+ *
+ * @note This function will flush any pending mouse motion.
+ * 
+ * @return [bool]
+ * @see .relative_mode?
+ */
+static VALUE Mouse_s_set_relative_mode(VALUE self, VALUE enabled)
+{
+    HANDLE_ERROR(SDL_SetRelativeMouseMode(RTEST(enabled)));
+    return enabled;
+}
+
+/*
+ * Get the relative state of the mouse.
+ *
+ * The button state is same as {.state} and
+ * x and y of the returned object are set to the
+ * mouse deltas since the last call to this method.
+ *
+ * @return [SDL2::Mouse::State] 
+ */
+static VALUE Mouse_s_relative_state(VALUE self)
+{
+    return mouse_state(SDL_GetRelativeMouseState);
+}
+
+/*
+ * Get the window which has mouse focus.
+ *
+ * @return [SDL2::Window] the window which has mouse focus
+ * @return [nil] if no window governed by SDL has mouse focus
+ */
+static VALUE Mouse_s_focused_window(VALUE self)
+{
+    SDL_Window* window = SDL_GetMouseFocus();
+    if (!window)
+        return Qnil;
+    else
+        return find_window_by_id(SDL_GetWindowID(window));
+}
+
+/*
+ * Show the mouse cursor.
+ * @return [nil]
+ */
+static VALUE Cursor_s_show(VALUE self)
+{
+    HANDLE_ERROR(SDL_ShowCursor(SDL_ENABLE));
+    return Qnil;
+}
+
+/*
+ * Hide the mouse cursor.
+ * @return [nil]
+ */
+static VALUE Cursor_s_hide(VALUE self)
+{
+    HANDLE_ERROR(SDL_ShowCursor(SDL_DISABLE));
+    return Qnil;
+}
+
+/*
+ * Return true if the mouse cursor is shown.
+ */
+static VALUE Cursor_s_shown_p(VALUE self)
+{
+    return INT2BOOL(HANDLE_ERROR(SDL_ShowCursor(SDL_QUERY)));
+}
+
+/*
+ * @overload warp(window, x, y) 
+ *   Move the mouse cursor to the given position within the window.
+ *
+ *   @param [SDL::Window] window the window to move the mouse cursor into
+ *   @param [Integer] x the x coordinate within the window
+ *   @param [Integer] y the y coordinate within the window
+ *   @return [nil]
+ */
+static VALUE Cursor_s_warp(VALUE self, VALUE window, VALUE x, VALUE y)
+{
+    SDL_WarpMouseInWindow(Get_SDL_Window(window), NUM2INT(x), NUM2INT(y));
+    return Qnil;
+}
+
+#if SDL_VERSION_ATLEAST(2,0,4)
+/*
+ * @overload warp_globally(x, y) 
+ *   Move the mouse cursor to the given position within the desktop.
+ *
+ *   @note This class module function is available since SDL 2.0.4.
+ *   @param [Integer] x the x coordinate within the desktop
+ *   @param [Integer] y the y coordinate within the desktop
+ *   @return [nil]
+ */
+static VALUE Cursor_s_warp_globally(VALUE self, VALUE x, VALUE y)
+{
+    SDL_WarpMouseGlobal(NUM2INT(x), NUM2INT(y));
+    return Qnil;
+}
+#endif
+
+/*
+ * @overload pressed?(index)
+ *   Return true a mouse button is pressed.
+ *
+ *   @param [Integer] index the index of a mouse button, start at index 0
+ * 
+ */
+static VALUE State_pressed_p(VALUE self, VALUE index)
+{
+    int idx = NUM2INT(index);
+    if (idx < 0 || idx >= 32)
+        rb_raise(rb_eArgError, "button index out of range (%d for 1..32)", idx);
+    return INT2BOOL(NUM2UINT(rb_iv_get(self, "@button_bits")) & SDL_BUTTON(idx));
+}
+
+/* @return [String] inspection string */
+static VALUE State_inspect(VALUE self)
+{
+    int i;
+    Uint32 buttons = NUM2UINT(rb_iv_get(self, "@button_bits"));
+    VALUE pressed = rb_ary_new();
+    VALUE string_for_pressed;
+    for (i=1; i<=32; ++i) 
+        if (buttons & SDL_BUTTON(i)) 
+            rb_ary_push(pressed, rb_sprintf("%d", i));
+    
+    string_for_pressed = rb_ary_join(pressed, rb_str_new2(" "));
+    return rb_sprintf("<%s:%p x=%d y=%d pressed=[%s]>",
+                      rb_obj_classname(self), (void*)self,
+                      NUM2INT(rb_iv_get(self, "@x")), NUM2INT(rb_iv_get(self, "@y")),
+                      StringValueCStr(string_for_pressed));
+}
+
+void rubysdl2_init_mouse(void)
+{
+    mMouse = rb_define_module_under(mSDL2, "Mouse");
+    
+#if SDL_VERSION_ATLEAST(2,0,4)
+    rb_define_module_function(mMouse, "global_state", Mouse_s_global_state, 0);
+#endif
+    rb_define_module_function(mMouse, "state", Mouse_s_state, 0);
+    rb_define_module_function(mMouse, "relative_mode?", Mouse_s_relative_mode_p, 0);
+    rb_define_module_function(mMouse, "relative_mode=", Mouse_s_set_relative_mode, 1);
+    rb_define_module_function(mMouse, "relative_state", Mouse_s_relative_state, 0);
+    rb_define_module_function(mMouse, "focused_window", Mouse_s_focused_window, 0);
+    
+    cCursor = rb_define_class_under(mMouse, "Cursor", rb_cObject);
+    
+    rb_define_singleton_method(cCursor, "show", Cursor_s_show, 0);
+    rb_define_singleton_method(cCursor, "hide", Cursor_s_hide, 0);
+    rb_define_singleton_method(cCursor, "shown?", Cursor_s_shown_p, 0);
+    rb_define_singleton_method(cCursor, "warp", Cursor_s_warp, 3);
+#if SDL_VERSION_ATLEAST(2,0,4)
+    rb_define_singleton_method(cCursor, "warp_globally", Cursor_s_warp_globally, 3);
+#endif
+    
+    
+    cState = rb_define_class_under(mMouse, "State", rb_cObject);
+
+    rb_undef_method(rb_singleton_class(cState), "new");
+    define_attr_readers(cState, "x", "y", "button_bits", NULL);
+    rb_define_method(cState, "pressed?", State_pressed_p, 1);
+    rb_define_method(cState, "inspect", State_inspect, 0);
+}

data/rubysdl2_internal.h

@@ -0,0 +1,125 @@
+/*
+ * Ruby/SDL2   Ruby extensiion library for SDL 2.x
+ * 
+ * Copyright (C) 2014 Ippei Obayashi
+ *
+ * This file is part of Ruby/SDL2.
+ * 
+ * Ruby/SDL2 is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Ruby/SDL2 is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Ruby/SDL2.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef RUBYSDL2_INTERNAL_H
+#define RUBYSDL2_INTERNAL_H
+
+#include <ruby.h>
+#include <ruby/encoding.h>
+#define SDL_MAIN_HANDLED
+#include <SDL_surface.h>
+#include <SDL_version.h>
+#include <SDL_video.h>
+
+#ifndef SDL2_EXTERN
+#define SDL2_EXTERN extern
+#endif
+
+/** utility functions */
+int rubysdl2_handle_error(int code, const char* cfunc);
+int rubysdl2_is_active(void);
+void rubysdl2_define_attr_readers(VALUE klass, ...);
+VALUE rubysdl2_utf8str_new_cstr(const char* str);
+VALUE rubysdl2_Surface_new(SDL_Surface* surface);
+SDL_Color rubysdl2_Array_to_SDL_Color(VALUE ary);
+VALUE rubysdl2_SDL_version_to_String(const SDL_version* ver);
+VALUE rubysdl2_SDL_version_to_Array(const SDL_version* ver);
+VALUE rubysdl2_find_window_by_id(Uint32 id);
+SDL_Rect* rubysdl2_Get_SDL_Rect(VALUE);
+SDL_Window* rubysdl2_Get_SDL_Window(VALUE);
+const char* rubysdl2_INT2BOOLCSTR(int);
+
+/** initialize interfaces */
+void rubysdl2_init_hints(void);
+void rubysdl2_init_video(void);
+void rubysdl2_init_gl(void);
+void rubysdl2_init_messagebox(void);
+void rubysdl2_init_event(void);
+void rubysdl2_init_key(void);
+void rubysdl2_init_mouse(void);
+void rubysdl2_init_joystick(void);
+void rubysdl2_init_timer(void);
+void rubysdl2_init_image(void);
+void rubysdl2_init_mixer(void);
+void rubysdl2_init_ttf(void);
+void rubysdl2_init_filesystem(void);
+void rubysdl2_init_clipboard(void);
+void rubysdl2_init_gamecontorller(void);
+
+/** macros */
+#define HANDLE_ERROR(c) (rubysdl2_handle_error((c), __func__))
+#define SDL_ERROR() (HANDLE_ERROR(-1))
+#define INT2BOOL(x) ((x)?Qtrue:Qfalse)
+#define NUM2UCHAR NUM2UINT
+#define UCHAR2NUM UINT2NUM
+#define rb_str_export_to_utf8(str) rb_str_export_to_enc((str), rb_utf8_encoding())
+
+#define DEFINE_GETTER(scope, ctype, var_class, classname)               \
+    scope ctype* Get_##ctype(VALUE obj)                                 \
+    {                                                                   \
+        ctype* s;                                                       \
+        if (!rb_obj_is_kind_of(obj, var_class))                         \
+            rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)", \
+                     rb_obj_classname(obj), classname);                 \
+        Data_Get_Struct(obj, ctype, s);                                 \
+                                                                        \
+        return s;                                                       \
+    }
+
+#define DEFINE_WRAP_GETTER(scope, SDL_typename, struct_name, field, classname) \
+    scope SDL_typename* Get_##SDL_typename(VALUE obj)                   \
+    {                                                                   \
+        struct_name* s = Get_##struct_name(obj);                        \
+            if (s->field == NULL)                                       \
+                HANDLE_ERROR(SDL_SetError(classname " is already destroyed")); \
+                                                                        \
+            return s->field;                                            \
+    }
+
+#define DEFINE_DESTROY_P(scope, struct_name, field)                     \
+    scope VALUE struct_name##_destroy_p(VALUE self)                     \
+    {                                                                   \
+        return INT2BOOL(Get_##struct_name(self)->field == NULL);        \
+    }
+
+#define DEFINE_WRAPPER(SDL_typename, struct_name, field, var_class, classname) \
+    DEFINE_GETTER(static, struct_name, var_class, classname);           \
+    DEFINE_WRAP_GETTER(static ,SDL_typename, struct_name, field, classname); \
+    DEFINE_DESTROY_P(static, struct_name, field);
+
+/** classes and modules */
+SDL2_EXTERN VALUE rubysdl2_mSDL2;
+SDL2_EXTERN VALUE rubysdl2_eSDL2Error;
+
+/** prefix macros */
+#define define_attr_readers rubysdl2_define_attr_readers
+#define utf8str_new_cstr rubysdl2_utf8str_new_cstr
+#define Surface_new rubysdl2_Surface_new
+#define Get_SDL_Rect rubysdl2_Get_SDL_Rect
+#define Get_SDL_Window rubysdl2_Get_SDL_Window
+#define Array_to_SDL_Color rubysdl2_Array_to_SDL_Color 
+#define mSDL2 rubysdl2_mSDL2
+#define eSDL2Error rubysdl2_eSDL2Error
+#define SDL_version_to_String rubysdl2_SDL_version_to_String
+#define SDL_version_to_Array rubysdl2_SDL_version_to_Array
+#define INT2BOOLCSTR  rubysdl2_INT2BOOLCSTR 
+#define find_window_by_id rubysdl2_find_window_by_id
+
+#endif

data/sample/chunk_destroy.rb

@@ -0,0 +1,16 @@
+require 'sdl2'
+
+SDL2::init(SDL2::INIT_AUDIO)
+
+SDL2::Mixer.init(SDL2::Mixer::INIT_FLAC|SDL2::Mixer::INIT_MOD|
+                 SDL2::Mixer::INIT_MP3|SDL2::Mixer::INIT_OGG)
+
+SDL2::Mixer.open(22050, SDL2::Mixer::DEFAULT_FORMAT, 2, 512)
+
+chunk = SDL2::Mixer::Chunk.load(ARGV[0])
+p chunk; chunk.destroy; p chunk; p chunk.destroy?
+
+mus = SDL2::Mixer::Music.load(ARGV[0])
+p mus; mus.destroy; p mus; p mus.destroy?
+
+GC.start

data/sample/memory_test/m1.rb

@@ -0,0 +1,28 @@
+require "sdl2"
+
+SDL2.init(SDL2::INIT_VIDEO|SDL2::INIT_EVENTS)
+
+window = SDL2::Window.create("testsprite",
+                             SDL2::Window::POS_CENTERED, SDL2::Window::POS_CENTERED,
+                             640, 480, 0)
+
+def f2(renderer)
+  surface = SDL2::Surface.load_bmp("icon.bmp")
+  10.times { renderer.create_texture_from(surface) }
+  p renderer.debug_info
+end
+
+def f1(window)
+  renderer = window.create_renderer(-1, 0)
+  p window.debug_info
+  p renderer.debug_info
+  f2(renderer)
+  GC.start
+  p renderer.debug_info
+end
+
+f1(window)
+GC.start
+p window.debug_info
+
+