ray 0.0.1 → 0.1.0.pre1

data/ext/{color.c → color.cpp}

@@ -1,4 +1,4 @@
-#include "ray.h"
+#include "ray.hpp"
 
 VALUE ray_cColor = Qnil;
 
@@ -14,21 +14,21 @@ ray_color ray_rb2col(VALUE object) {
    return *ret;
 }
 
-VALUE ray_col2rb(ray_color color) {
+VALUE ray_col2rb(const ray_color &color) {
    VALUE ret = rb_funcall(ray_cColor, RAY_METH("new"), 4,
                           INT2FIX(color.r),
                           INT2FIX(color.g),
                           INT2FIX(color.b),
-                          INT2FIX(color.a));   
+                          INT2FIX(color.a));
    return ret;
 }
 
 void ray_free_color(ray_color *color) {
-   free(color);
+   delete color;
 }
 
 VALUE ray_alloc_color(VALUE self) {
-   ray_color *ptr = malloc(sizeof(ray_color));
+   ray_color *ptr = new ray_color;
    VALUE ret = Data_Wrap_Struct(self, 0, ray_free_color, ptr);
 
    return ret;
@@ -55,6 +55,15 @@ VALUE ray_init_color(int argc, VALUE *argv, VALUE self) {
    return Qnil;
 }
 
+VALUE ray_init_color_copy(VALUE self, VALUE other) {
+   ray_color *color = NULL, *source = NULL;
+   Data_Get_Struct(self,  ray_color, color);
+   Data_Get_Struct(other, ray_color, source);
+
+   *color = *source;
+   return self;
+}
+
 /* @return [Integer] red intensity */
 VALUE ray_color_r(VALUE self) {
    ray_color *ret;
@@ -89,6 +98,8 @@ VALUE ray_color_a(VALUE self) {
 
 /* Sets the red intensity */
 VALUE ray_color_set_r(VALUE self, VALUE val) {
+   rb_check_frozen(self);
+
    ray_color *ret;
    Data_Get_Struct(self, ray_color, ret);
 
@@ -98,6 +109,8 @@ VALUE ray_color_set_r(VALUE self, VALUE val) {
 
 /* Sets the green intensity */
 VALUE ray_color_set_g(VALUE self, VALUE val) {
+   rb_check_frozen(self);
+
    ray_color *ret;
    Data_Get_Struct(self, ray_color, ret);
 
@@ -107,6 +120,8 @@ VALUE ray_color_set_g(VALUE self, VALUE val) {
 
 /* Sets the blue intensity */
 VALUE ray_color_set_b(VALUE self, VALUE val) {
+   rb_check_frozen(self);
+
    ray_color *ret;
    Data_Get_Struct(self, ray_color, ret);
 
@@ -116,6 +131,8 @@ VALUE ray_color_set_b(VALUE self, VALUE val) {
 
 /* Sets the alpha intensity */
 VALUE ray_color_set_a(VALUE self, VALUE val) {
+   rb_check_frozen(self);
+
    ray_color *ret;
    Data_Get_Struct(self, ray_color, ret);
 
@@ -123,18 +140,13 @@ VALUE ray_color_set_a(VALUE self, VALUE val) {
    return val;
 }
 
-/*
-  Document-class: Ray::Color
-
-  Represents a color, which does not rely on the pixel format of any
-  surfaces.
-*/
 void Init_ray_color() {
    ray_cColor = rb_define_class_under(ray_mRay, "Color", rb_cObject);
-   
+
    rb_define_alloc_func(ray_cColor, ray_alloc_color);
    rb_define_method(ray_cColor, "initialize", ray_init_color, -1);
-   
+   rb_define_method(ray_cColor, "initialize_copy", ray_init_color_copy, 1);
+
    rb_define_method(ray_cColor, "r", ray_color_r, 0);
    rb_define_method(ray_cColor, "g", ray_color_g, 0);
    rb_define_method(ray_cColor, "b", ray_color_b, 0);

data/ext/drawable.cpp

@@ -0,0 +1,91 @@
+#include "ray.hpp"
+
+VALUE ray_cDrawable = Qnil;
+
+ray_drawable::~ray_drawable() {
+   if (!NIL_P(block))
+      rb_gc_unregister_address(&block);
+}
+
+void ray_drawable::set_block(VALUE val) {
+   block = val;
+   rb_gc_register_address(&block);
+}
+
+void ray_drawable::render(VALUE image) {
+   ray_image *c_image = ray_rb2image(image);
+   c_image->activate();
+
+   glMatrixMode(GL_PROJECTION);
+   glLoadIdentity();
+   glOrtho(0, c_image->width(), c_image->height(), 0, -1, 1);
+
+   glMatrixMode(GL_MODELVIEW);
+
+   glPushMatrix();
+   rb_funcall(block, RAY_METH("call"), 1, image);
+   glPopMatrix();
+}
+
+ray_drawable *ray_rb2drawable(VALUE obj) {
+   if (!RAY_IS_A(obj, ray_cDrawable)) {
+      rb_raise(rb_eTypeError, "Can't convert %s into Ray::Drawable",
+               RAY_OBJ_CLASSNAME(obj));
+   }
+
+   ray_drawable *drawable;
+   Data_Get_Struct(obj, ray_drawable, drawable);
+
+   return drawable;
+}
+
+void ray_free_drawable(ray_drawable *drawable) {
+   delete drawable;
+}
+
+VALUE ray_alloc_drawable(VALUE self) {
+   ray_drawable *ptr = new ray_drawable;
+
+   VALUE obj = Data_Wrap_Struct(ray_cDrawable, NULL, ray_free_drawable, ptr);
+   return obj;
+}
+
+/*
+  Creates a new Drawables.
+  Requires a block to be passed. This block will be run when this object
+  will be drawn.
+*/
+VALUE ray_init_drawable(VALUE self) {
+   rb_need_block();
+   ray_rb2drawable(self)->set_block(rb_block_proc());
+   return self;
+}
+
+/*
+  Document-class: Ray::Drawable
+
+  Drawables allow to use plain OpenGL to draw stuff. The projection matrix is
+  automatically set so (0, 0) is the upper left corner and (width, height) the
+  bottom right one.
+
+  @see Ray::Image#activate
+
+  @example
+    drawable = Ray::Drawable.new do |img|
+      # img is the image you are drawing on
+
+      # Draw using some OpenGL binding.
+      GL.begin GL::Triangles do
+        GL.color(1, 0, 0); GL.vertex(300, 300)
+        GL.color(1, 1, 0); GL.vertex(300, 100)
+        GL.color(1, 1, 1); GL.vertex(100, 300)
+      end
+    end
+
+    drawable.draw_on image
+*/
+void Init_ray_drawable() {
+   ray_cDrawable = rb_define_class_under(ray_mRay, "Drawable", rb_cObject);
+   rb_define_alloc_func(ray_cDrawable, ray_alloc_drawable);
+   rb_define_method(ray_cDrawable, "initialize", ray_init_drawable, 0);
+}

data/ext/event.cpp

@@ -0,0 +1,460 @@
+#include "ray.hpp"
+
+VALUE ray_cEvent = Qnil;
+
+typedef enum {
+   RAY_MOD_NONE  = 0,
+   RAY_MOD_CTRL  = 1 << 0,
+   RAY_MOD_ALT   = 1 << 1,
+   RAY_MOD_SHIFT = 1 << 2
+} ray_mod_keys;
+
+ray_event *ray_rb2event(VALUE obj) {
+   if (!RAY_IS_A(obj, ray_cEvent)) {
+      rb_raise(rb_eTypeError, "Can't convert %s into Ray::Event",
+               RAY_OBJ_CLASSNAME(obj));
+   }
+
+   ray_event *ptr;
+   Data_Get_Struct(obj, ray_event, ptr);
+
+   return ptr;
+}
+
+void ray_free_event(ray_event *ptr) {
+   delete ptr;
+}
+
+VALUE ray_alloc_event(VALUE self) {
+   ray_event *ptr = new ray_event;
+   VALUE ret = Data_Wrap_Struct(self, 0L, ray_free_event, ptr);
+
+   return ret;
+}
+
+/*
+  Creates the event according to the next event of the stack.
+*/
+VALUE ray_init_event(VALUE self) {
+   ray_event *event = ray_rb2event(self);
+   if (!ray_screen.GetEvent(*event))
+      event->Type = sf::Event::Count;
+
+   return Qnil;
+}
+
+/*
+  Waits for an event and returns it.
+  @return [Ray::Event] The event that has just happened.
+*/
+VALUE ray_wait_event(VALUE self) {
+   ray_event *event = new ray_event;
+   if (!ray_screen.WaitEvent(*event))
+      event->Type = sf::Event::Count;
+
+   return Data_Wrap_Struct(self, 0, ray_free_event, event);
+}
+
+/*
+  Updates the object according to what's happening now.
+*/
+VALUE ray_event_poll(VALUE self) {
+   if (!ray_screen.GetEvent(*ray_rb2event(self)))
+      ray_rb2event(self)->Type = sf::Event::Count;
+
+   return self;
+}
+
+/*
+  Waits for an event and updates this object.
+*/
+VALUE ray_event_wait(VALUE self) {
+   if (!ray_screen.GetEvent(*ray_rb2event(self)))
+      ray_rb2event(self)->Type = sf::Event::Count;
+   return self;
+}
+
+/*
+  Returns the type of the event. See the TYPE_* constants.
+*/
+VALUE ray_event_type(VALUE self) {
+   return INT2FIX(ray_rb2event(self)->Type);
+}
+
+/*
+  @return [true, false, nil] true if the key is pressed.
+*/
+VALUE ray_event_key_pressed(VALUE self) {
+   ray_event *ev = ray_rb2event(self);
+
+   if (ev->Type == sf::Event::KeyReleased)
+      return Qfalse;
+   else if (ev->Type == sf::Event::KeyPressed)
+      return Qtrue;
+   return Qnil;
+}
+
+/*
+  @return [Integer, nil] An integer representing the key, if any.
+*/
+VALUE ray_event_key(VALUE self) {
+   ray_event *ev = ray_rb2event(self);
+   if (ev->Type != sf::Event::KeyReleased && ev->Type != sf::Event::KeyPressed)
+      return Qnil;
+
+   return INT2FIX(ev->Key.Code);
+}
+
+/*
+  @return [Integer, nil] OR'd combination of the mod keys
+                         (control, alt, and shift) pressed
+                         at the same time.
+*/
+VALUE ray_event_mod_keys(VALUE self) {
+   ray_event *ev = ray_rb2event(self);
+   if (ev->Type != sf::Event::KeyReleased && ev->Type != sf::Event::KeyPressed)
+      return Qnil;
+
+   int ret = RAY_MOD_NONE;
+   if (ev->Key.Alt)     ret |= RAY_MOD_ALT;
+   if (ev->Key.Control) ret |= RAY_MOD_CTRL;
+   if (ev->Key.Shift)   ret |= RAY_MOD_SHIFT;
+
+   return INT2FIX(ret);
+}
+
+/*
+  @return [true, false] True if this event means we gained
+                             focus.
+ */
+VALUE ray_event_is_gain(VALUE self) {
+   ray_event *ev = ray_rb2event(self);
+   return ev->Type == sf::Event::GainedFocus ? Qtrue : Qfalse;
+}
+
+/*
+  @return [Integer, nil] The position of the mouse
+*/
+VALUE ray_event_mouse_x(VALUE self) {
+   ray_event *ev = ray_rb2event(self);
+
+   if (ev->Type == sf::Event::MouseButtonPressed ||
+       ev->Type == sf::Event::MouseButtonReleased)
+      return INT2FIX(ev->MouseButton.X);
+   else if (ev->Type == sf::Event::MouseMoved)
+      return INT2FIX(ev->MouseMove.X);
+   else if (ev->Type == sf::Event::MouseWheelMoved)
+      return INT2FIX(ev->MouseWheel.X);
+
+   return Qnil;
+}
+
+/*
+  @return [Integer, nil] The position of the mouse
+*/
+VALUE ray_event_mouse_y(VALUE self) {
+   ray_event *ev = ray_rb2event(self);
+
+   if (ev->Type == sf::Event::MouseButtonPressed ||
+       ev->Type == sf::Event::MouseButtonReleased)
+      return INT2FIX(ev->MouseButton.Y);
+   else if (ev->Type == sf::Event::MouseMoved)
+      return INT2FIX(ev->MouseMove.Y);
+   else if (ev->Type == sf::Event::MouseWheelMoved)
+      return INT2FIX(ev->MouseWheel.Y);
+
+   return Qnil;
+}
+
+/*
+  @return [Integer, nil] the button that has been pressed
+*/
+VALUE ray_event_mouse_button(VALUE self) {
+   ray_event *ev = ray_rb2event(self);
+   if (ev->Type != sf::Event::MouseButtonPressed &&
+       ev->Type != sf::Event::MouseButtonReleased)
+      return Qnil;
+
+   return INT2FIX(ev->MouseButton.Button);
+}
+
+/*
+  @return [Integer, nil] Ammount of ticks the wheel has moved
+*/
+VALUE ray_event_wheel_delta(VALUE self) {
+   ray_event *ev = ray_rb2event(self);
+   if (ev->Type != sf::Event::MouseWheelMoved)
+      return Qnil;
+   return INT2FIX(ev->MouseWheel.Delta);
+}
+
+/* @return [Integer, nil] The joystick device index */
+VALUE ray_event_joystick_id(VALUE self) {
+   ray_event *ev = ray_rb2event(self);
+
+   if (ev->Type == sf::Event::JoyMoved)
+      return INT2FIX(ev->JoyMove.JoystickId);
+   else if (ev->Type == sf::Event::JoyButtonPressed ||
+            ev->Type == sf::Event::JoyButtonReleased)
+      return INT2FIX(ev->JoyButton.JoystickId);
+
+   return Qnil;
+}
+
+/* @return [Integer, nil] The joystick axis index */
+VALUE ray_event_axis_id(VALUE self) {
+   ray_event *ev = ray_rb2event(self);
+   if (ev->Type == sf::Event::JoyMoved)
+      return INT2FIX(ev->JoyMove.Axis);
+
+   return Qnil;
+}
+
+/* @return [Float, nil] The axis value, from -100 upto 100 */
+VALUE ray_event_axis_value(VALUE self) {
+   ray_event *ev = ray_rb2event(self);
+   if (ev->Type == sf::Event::JoyMoved) {
+      return rb_float_new(ev->JoyMove.Position);
+   }
+
+   return Qnil;
+}
+
+/* @return [Integer, nil] The button which was pressed or released */
+VALUE ray_event_joystick_button(VALUE self) {
+   ray_event *ev = ray_rb2event(self);
+   if (ev->Type == sf::Event::JoyButtonPressed ||
+       ev->Type == sf::Event::JoyButtonReleased)
+      return INT2FIX(ev->JoyButton.Button);
+
+   return Qnil;
+}
+
+/* @return [Integer, nil] The new width of the window */
+VALUE ray_event_window_w(VALUE self) {
+   ray_event *ev = ray_rb2event(self);
+   if (ev->Type == sf::Event::Resized)
+      return INT2FIX(ev->Size.Width);
+
+   return Qnil;
+}
+
+/* @return [Integer, nil] The new height of the window */
+VALUE ray_event_window_h(VALUE self) {
+   ray_event *ev = ray_rb2event(self);
+   if (ev->Type == sf::Event::Resized)
+      return INT2FIX(ev->Size.Height);
+
+   return Qnil;
+}
+
+/*
+  @return [String, nil] Text entered by the user. A single UTF-32 character,
+                        using native endianness.
+*/
+VALUE ray_event_entered_text(VALUE self) {
+   ray_event *ev = ray_rb2event(self);
+   if (ev->Type != sf::Event::TextEntered)
+      return Qnil;
+
+   uint32_t character = ev->Text.Unicode;
+   char *ptr = (char*)&character;
+   return rb_str_new(ptr, 4);
+}
+
+void Init_ray_event() {
+   ray_cEvent = rb_define_class_under(ray_mRay, "Event", rb_cObject);
+   rb_define_alloc_func(ray_cEvent, ray_alloc_event);
+   rb_define_method(ray_cEvent, "initialize", ray_init_event, 0);
+
+   rb_define_module_function(ray_cEvent, "wait", ray_wait_event, 0);
+
+   rb_define_method(ray_cEvent, "poll!", ray_event_poll, 0);
+   rb_define_method(ray_cEvent, "wait!", ray_event_wait, 0);
+
+   rb_define_method(ray_cEvent, "type", ray_event_type, 0);
+
+   rb_define_method(ray_cEvent, "key_pressed?", ray_event_key_pressed, 0);
+   rb_define_method(ray_cEvent, "key", ray_event_key, 0);
+   rb_define_method(ray_cEvent, "mod_keys", ray_event_mod_keys, 0);
+
+   rb_define_method(ray_cEvent, "is_gain?", ray_event_is_gain, 0);
+
+   rb_define_method(ray_cEvent, "mouse_x", ray_event_mouse_x, 0);
+   rb_define_method(ray_cEvent, "mouse_y", ray_event_mouse_y, 0);
+   rb_define_method(ray_cEvent, "mouse_button", ray_event_mouse_button, 0);
+   rb_define_method(ray_cEvent, "wheel_delta", ray_event_wheel_delta, 0);
+
+   rb_define_method(ray_cEvent, "joystick_id", ray_event_joystick_id, 0);
+   rb_define_method(ray_cEvent, "axis_id", ray_event_axis_id, 0);
+   rb_define_method(ray_cEvent, "axis_value", ray_event_axis_value, 0);
+   rb_define_method(ray_cEvent, "joystick_button", ray_event_joystick_button, 0);
+
+   rb_define_method(ray_cEvent, "window_w", ray_event_window_w, 0);
+   rb_define_method(ray_cEvent, "window_h", ray_event_window_h, 0);
+
+   rb_define_method(ray_cEvent, "entered_text", ray_event_entered_text, 0);
+
+   rb_define_const(ray_cEvent, "TYPE_NOEVENT", INT2FIX(sf::Event::Count));
+
+   rb_define_const(ray_cEvent, "TYPE_FOCUS_GAIN", INT2FIX(sf::Event::GainedFocus));
+   rb_define_const(ray_cEvent, "TYPE_FOCUS_LOSS", INT2FIX(sf::Event::LostFocus));
+
+   rb_define_const(ray_cEvent, "TYPE_MOUSE_ENTERED", INT2FIX(sf::Event::MouseEntered));
+   rb_define_const(ray_cEvent, "TYPE_MOUSE_LEFT", INT2FIX(sf::Event::MouseLeft));
+
+   rb_define_const(ray_cEvent, "TYPE_KEYDOWN", INT2FIX(sf::Event::KeyPressed));
+   rb_define_const(ray_cEvent, "TYPE_KEYUP", INT2FIX(sf::Event::KeyReleased));
+
+   rb_define_const(ray_cEvent, "TYPE_MOUSEMOTION", INT2FIX(sf::Event::MouseMoved));
+   rb_define_const(ray_cEvent, "TYPE_MOUSEWHEELMOVED",
+                   INT2FIX(sf::Event::MouseWheelMoved));
+   rb_define_const(ray_cEvent, "TYPE_MOUSEBUTTONDOWN",
+                   INT2FIX(sf::Event::MouseButtonPressed));
+   rb_define_const(ray_cEvent, "TYPE_MOUSEBUTTONUP",
+                   INT2FIX(sf::Event::MouseButtonReleased));
+
+   rb_define_const(ray_cEvent, "TYPE_JOYAXISMOTION",
+                   INT2FIX(sf::Event::JoyMoved));
+   rb_define_const(ray_cEvent, "TYPE_JOYBUTTONDOWN",
+                   INT2FIX(sf::Event::JoyButtonPressed));
+   rb_define_const(ray_cEvent, "TYPE_JOYBUTTONUP",
+                   INT2FIX(sf::Event::JoyButtonReleased));
+   rb_define_const(ray_cEvent, "TYPE_QUIT", INT2FIX(sf::Event::Closed));
+   rb_define_const(ray_cEvent, "TYPE_VIDEORESIZE", INT2FIX(sf::Event::Resized));
+
+   rb_define_const(ray_cEvent, "TYPE_TEXT_ENTERED", INT2FIX(sf::Event::TextEntered));
+
+   rb_define_const(ray_cEvent, "AXIS_X", INT2FIX(sf::Joy::AxisX));
+   rb_define_const(ray_cEvent, "AXIS_Y", INT2FIX(sf::Joy::AxisY));
+   rb_define_const(ray_cEvent, "AXIS_Z", INT2FIX(sf::Joy::AxisZ));
+   rb_define_const(ray_cEvent, "AXIS_R", INT2FIX(sf::Joy::AxisR));
+   rb_define_const(ray_cEvent, "AXIS_U", INT2FIX(sf::Joy::AxisU));
+   rb_define_const(ray_cEvent, "AXIS_V", INT2FIX(sf::Joy::AxisV));
+
+   /* Point of view axis. Its value is an angle, therefore in the 0..360 range. */
+   rb_define_const(ray_cEvent, "AXIS_POV", INT2FIX(sf::Joy::AxisPOV));
+
+   rb_define_const(ray_cEvent, "KEY_BACKSPACE", INT2FIX(sf::Key::Back));
+   rb_define_const(ray_cEvent, "KEY_TAB", INT2FIX(sf::Key::Tab));
+   rb_define_const(ray_cEvent, "KEY_RETURN", INT2FIX(sf::Key::Return));
+   rb_define_const(ray_cEvent, "KEY_PAUSE", INT2FIX(sf::Key::Pause));
+   rb_define_const(ray_cEvent, "KEY_ESCAPE", INT2FIX(sf::Key::Escape));
+   rb_define_const(ray_cEvent, "KEY_SPACE", INT2FIX(sf::Key::Space));
+   rb_define_const(ray_cEvent, "KEY_QUOTE", INT2FIX(sf::Key::Quote));
+   rb_define_const(ray_cEvent, "KEY_ASTERISK", INT2FIX(sf::Key::Multiply));
+   rb_define_const(ray_cEvent, "KEY_PLUS", INT2FIX(sf::Key::Add));
+   rb_define_const(ray_cEvent, "KEY_COMMA", INT2FIX(sf::Key::Comma));
+   rb_define_const(ray_cEvent, "KEY_MINUS", INT2FIX(sf::Key::Subtract));
+   rb_define_const(ray_cEvent, "KEY_PERIOD", INT2FIX(sf::Key::Period));
+   rb_define_const(ray_cEvent, "KEY_SLASH", INT2FIX(sf::Key::Divide));
+
+   rb_define_const(ray_cEvent, "KEY_0", INT2FIX(sf::Key::Num0));
+   rb_define_const(ray_cEvent, "KEY_1", INT2FIX(sf::Key::Num1));
+   rb_define_const(ray_cEvent, "KEY_2", INT2FIX(sf::Key::Num2));
+   rb_define_const(ray_cEvent, "KEY_3", INT2FIX(sf::Key::Num3));
+   rb_define_const(ray_cEvent, "KEY_4", INT2FIX(sf::Key::Num4));
+   rb_define_const(ray_cEvent, "KEY_5", INT2FIX(sf::Key::Num5));
+   rb_define_const(ray_cEvent, "KEY_6", INT2FIX(sf::Key::Num6));
+   rb_define_const(ray_cEvent, "KEY_7", INT2FIX(sf::Key::Num7));
+   rb_define_const(ray_cEvent, "KEY_8", INT2FIX(sf::Key::Num8));
+   rb_define_const(ray_cEvent, "KEY_9", INT2FIX(sf::Key::Num9));
+
+   rb_define_const(ray_cEvent, "KEY_SEMICOLON", INT2FIX(sf::Key::SemiColon));
+   rb_define_const(ray_cEvent, "KEY_EQUALS", INT2FIX(sf::Key::Equal));
+   rb_define_const(ray_cEvent, "KEY_LEFTBRACKET", INT2FIX(sf::Key::LBracket));
+   rb_define_const(ray_cEvent, "KEY_BACKSLASH", INT2FIX(sf::Key::BackSlash));
+   rb_define_const(ray_cEvent, "KEY_RIGHTBRACKET", INT2FIX(sf::Key::RBracket));
+
+   rb_define_const(ray_cEvent, "KEY_a", INT2FIX(sf::Key::A));
+   rb_define_const(ray_cEvent, "KEY_b", INT2FIX(sf::Key::B));
+   rb_define_const(ray_cEvent, "KEY_c", INT2FIX(sf::Key::C));
+   rb_define_const(ray_cEvent, "KEY_d", INT2FIX(sf::Key::D));
+   rb_define_const(ray_cEvent, "KEY_e", INT2FIX(sf::Key::E));
+   rb_define_const(ray_cEvent, "KEY_f", INT2FIX(sf::Key::F));
+   rb_define_const(ray_cEvent, "KEY_g", INT2FIX(sf::Key::G));
+   rb_define_const(ray_cEvent, "KEY_h", INT2FIX(sf::Key::H));
+   rb_define_const(ray_cEvent, "KEY_i", INT2FIX(sf::Key::I));
+   rb_define_const(ray_cEvent, "KEY_j", INT2FIX(sf::Key::J));
+   rb_define_const(ray_cEvent, "KEY_k", INT2FIX(sf::Key::K));
+   rb_define_const(ray_cEvent, "KEY_l", INT2FIX(sf::Key::L));
+   rb_define_const(ray_cEvent, "KEY_m", INT2FIX(sf::Key::M));
+   rb_define_const(ray_cEvent, "KEY_n", INT2FIX(sf::Key::N));
+   rb_define_const(ray_cEvent, "KEY_o", INT2FIX(sf::Key::O));
+   rb_define_const(ray_cEvent, "KEY_p", INT2FIX(sf::Key::P));
+   rb_define_const(ray_cEvent, "KEY_q", INT2FIX(sf::Key::Q));
+   rb_define_const(ray_cEvent, "KEY_r", INT2FIX(sf::Key::R));
+   rb_define_const(ray_cEvent, "KEY_s", INT2FIX(sf::Key::S));
+   rb_define_const(ray_cEvent, "KEY_t", INT2FIX(sf::Key::T));
+   rb_define_const(ray_cEvent, "KEY_u", INT2FIX(sf::Key::U));
+   rb_define_const(ray_cEvent, "KEY_v", INT2FIX(sf::Key::V));
+   rb_define_const(ray_cEvent, "KEY_w", INT2FIX(sf::Key::W));
+   rb_define_const(ray_cEvent, "KEY_x", INT2FIX(sf::Key::X));
+   rb_define_const(ray_cEvent, "KEY_y", INT2FIX(sf::Key::Y));
+   rb_define_const(ray_cEvent, "KEY_z", INT2FIX(sf::Key::Z));
+
+   rb_define_const(ray_cEvent, "KEY_DELETE", INT2FIX(sf::Key::Delete));
+
+   rb_define_const(ray_cEvent, "KEY_KP0", INT2FIX(sf::Key::Numpad0));
+   rb_define_const(ray_cEvent, "KEY_KP1", INT2FIX(sf::Key::Numpad1));
+   rb_define_const(ray_cEvent, "KEY_KP2", INT2FIX(sf::Key::Numpad2));
+   rb_define_const(ray_cEvent, "KEY_KP3", INT2FIX(sf::Key::Numpad3));
+   rb_define_const(ray_cEvent, "KEY_KP4", INT2FIX(sf::Key::Numpad4));
+   rb_define_const(ray_cEvent, "KEY_KP5", INT2FIX(sf::Key::Numpad5));
+   rb_define_const(ray_cEvent, "KEY_KP6", INT2FIX(sf::Key::Numpad6));
+   rb_define_const(ray_cEvent, "KEY_KP7", INT2FIX(sf::Key::Numpad7));
+   rb_define_const(ray_cEvent, "KEY_KP8", INT2FIX(sf::Key::Numpad8));
+   rb_define_const(ray_cEvent, "KEY_KP9", INT2FIX(sf::Key::Numpad9));
+
+   rb_define_const(ray_cEvent, "KEY_UP", INT2FIX(sf::Key::Up));
+   rb_define_const(ray_cEvent, "KEY_DOWN", INT2FIX(sf::Key::Down));
+   rb_define_const(ray_cEvent, "KEY_RIGHT", INT2FIX(sf::Key::Right));
+   rb_define_const(ray_cEvent, "KEY_LEFT", INT2FIX(sf::Key::Left));
+
+   rb_define_const(ray_cEvent, "KEY_INSERT", INT2FIX(sf::Key::Insert));
+   rb_define_const(ray_cEvent, "KEY_HOME", INT2FIX(sf::Key::Home));
+   rb_define_const(ray_cEvent, "KEY_END", INT2FIX(sf::Key::End));
+   rb_define_const(ray_cEvent, "KEY_PAGEUP", INT2FIX(sf::Key::PageUp));
+   rb_define_const(ray_cEvent, "KEY_PAGEDOWN", INT2FIX(sf::Key::PageDown));
+
+   rb_define_const(ray_cEvent, "KEY_F1", INT2FIX(sf::Key::F1));
+   rb_define_const(ray_cEvent, "KEY_F2", INT2FIX(sf::Key::F2));
+   rb_define_const(ray_cEvent, "KEY_F3", INT2FIX(sf::Key::F3));
+   rb_define_const(ray_cEvent, "KEY_F4", INT2FIX(sf::Key::F4));
+   rb_define_const(ray_cEvent, "KEY_F5", INT2FIX(sf::Key::F5));
+   rb_define_const(ray_cEvent, "KEY_F6", INT2FIX(sf::Key::F6));
+   rb_define_const(ray_cEvent, "KEY_F7", INT2FIX(sf::Key::F7));
+   rb_define_const(ray_cEvent, "KEY_F8", INT2FIX(sf::Key::F8));
+   rb_define_const(ray_cEvent, "KEY_F9", INT2FIX(sf::Key::F9));
+   rb_define_const(ray_cEvent, "KEY_F10", INT2FIX(sf::Key::F10));
+   rb_define_const(ray_cEvent, "KEY_F11", INT2FIX(sf::Key::F11));
+   rb_define_const(ray_cEvent, "KEY_F12", INT2FIX(sf::Key::F12));
+   rb_define_const(ray_cEvent, "KEY_F13", INT2FIX(sf::Key::F13));
+   rb_define_const(ray_cEvent, "KEY_F14", INT2FIX(sf::Key::F14));
+   rb_define_const(ray_cEvent, "KEY_F15", INT2FIX(sf::Key::F15));
+
+   rb_define_const(ray_cEvent, "KEY_RSHIFT", INT2FIX(sf::Key::RShift));
+   rb_define_const(ray_cEvent, "KEY_LSHIFT", INT2FIX(sf::Key::LShift));
+
+   rb_define_const(ray_cEvent, "KEY_RCTRL", INT2FIX(sf::Key::RControl));
+   rb_define_const(ray_cEvent, "KEY_LCTRL", INT2FIX(sf::Key::LControl));
+
+   rb_define_const(ray_cEvent, "KEY_RALT", INT2FIX(sf::Key::RAlt));
+   rb_define_const(ray_cEvent, "KEY_LALT", INT2FIX(sf::Key::LAlt));
+
+   rb_define_const(ray_cEvent, "KEY_LSUPER", INT2FIX(sf::Key::LSystem));
+   rb_define_const(ray_cEvent, "KEY_RSUPER", INT2FIX(sf::Key::RSystem));
+
+   rb_define_const(ray_cEvent, "KEY_MENU", INT2FIX(sf::Key::Menu));
+
+   rb_define_const(ray_cEvent, "KMOD_NONE", INT2FIX(RAY_MOD_NONE));
+   rb_define_const(ray_cEvent, "KMOD_ALT", INT2FIX(RAY_MOD_ALT));
+   rb_define_const(ray_cEvent, "KMOD_CTRL", INT2FIX(RAY_MOD_CTRL));
+   rb_define_const(ray_cEvent, "KMOD_SHIFT", INT2FIX(RAY_MOD_SHIFT));
+
+   rb_define_const(ray_cEvent, "BUTTON_LEFT", INT2FIX(sf::Mouse::Left));
+   rb_define_const(ray_cEvent, "BUTTON_MIDDLE", INT2FIX(sf::Mouse::Middle));
+   rb_define_const(ray_cEvent, "BUTTON_RIGHT", INT2FIX(sf::Mouse::Right));
+   rb_define_const(ray_cEvent, "BUTTON_EXTRA1", INT2FIX(sf::Mouse::XButton1));
+   rb_define_const(ray_cEvent, "BUTTON_EXTRA2", INT2FIX(sf::Mouse::XButton2));
+}