ray 0.0.1 → 0.1.0.pre1

data/ext/input.cpp

@@ -0,0 +1,74 @@
+#include "ray.hpp"
+
+VALUE ray_mInput = Qnil;
+
+const sf::Input &ray_input() {
+   return ray_screen.GetInput();
+}
+
+/*
+  @overload holding?(key)
+    @param [Integer] key Key code
+    @return [true, false] True if key is pressed
+*/
+VALUE ray_input_holding(VALUE self, VALUE key) {
+   return ray_input().IsKeyDown((sf::Key::Code)NUM2INT(key)) ? Qtrue : Qfalse;
+}
+
+/*
+  @overload mouse_button_down?(button)
+    @param [Integer] button Mouse button code
+    @return [true, false] True if the button is pressed
+*/
+VALUE ray_input_mouse_button_down(VALUE self, VALUE button) {
+   return ray_input().IsMouseButtonDown((sf::Mouse::Button)NUM2INT(button)) ?
+      Qtrue : Qfalse;
+}
+
+/*
+  @overload jostick_button_down?(joy_id, button)
+    @param [Integer] joy_id Id of the joytick
+    @param [Integer] button button id
+    @return [true, false] True if the button is pressed
+*/
+VALUE ray_input_joystick_button_down(VALUE self, VALUE joy_id, VALUE button) {
+   return ray_input().IsJoystickButtonDown(NUM2INT(joy_id),
+                                           NUM2INT(button)) ?
+      Qtrue : Qfalse;
+}
+
+/* @return [Integer] mouse x position */
+VALUE ray_input_mouse_x(VALUE self) {
+   return INT2FIX(ray_input().GetMouseX());
+}
+
+/* @return [Integer] mouse y position */
+VALUE ray_input_mouse_y(VALUE self) {
+   return INT2FIX(ray_input().GetMouseY());
+}
+
+/*
+  @overload axis_position(joy_id, axis_id)
+    @param [Integer] joy_id Id of the joystick
+    @param [Integer] axis_id Id of the axis
+    @return [Float] current position of the axis, between -100 and 100.
+*/
+VALUE ray_input_axis_position(VALUE self, VALUE joy_id, VALUE axis_id) {
+   return rb_float_new(ray_input().GetJoystickAxis(NUM2INT(joy_id),
+                                                   (sf::Joy::Axis)NUM2INT(axis_id)));
+}
+
+void Init_ray_input() {
+   ray_mInput = rb_define_module_under(ray_mRay, "Input");
+
+   rb_define_module_function(ray_mInput, "holding?", ray_input_holding, 1);
+   rb_define_module_function(ray_mInput, "mouse_button_down?",
+                             ray_input_mouse_button_down, 1);
+   rb_define_module_function(ray_mInput, "jostick_button_down?",
+                             ray_input_joystick_button_down, 2);
+
+   rb_define_module_function(ray_mInput, "mouse_x", ray_input_mouse_x, 0);
+   rb_define_module_function(ray_mInput, "mouse_y", ray_input_mouse_y, 0);
+
+   rb_define_module_function(ray_mInput, "axis_position", ray_input_axis_position, 2);
+}

data/ext/ray.cpp

@@ -0,0 +1,168 @@
+#include "ray.hpp"
+
+VALUE ray_mRay = Qnil;
+sf::RenderWindow ray_screen;
+
+ray_video_mode ray_parse_video_mode(VALUE hash) {
+   VALUE width  = rb_hash_aref(hash, RAY_SYM("width"));
+   VALUE height = rb_hash_aref(hash, RAY_SYM("height"));
+
+   if (NIL_P(width))  width  = rb_hash_aref(hash, RAY_SYM("w"));
+   if (NIL_P(height)) height = rb_hash_aref(hash, RAY_SYM("h"));
+
+   if (NIL_P(width) || NIL_P(height))
+      rb_raise(rb_eArgError, "Missing parameter: width or height");
+
+   VALUE bitsperpixel = rb_hash_aref(hash, RAY_SYM("bits_per_pixel"));
+   if (NIL_P(bitsperpixel)) bitsperpixel = rb_hash_aref(hash, RAY_SYM("bpp"));
+
+   if (NIL_P(bitsperpixel))
+      bitsperpixel = INT2FIX(32);
+
+   uint32_t flags = sf::Style::None;
+
+   if (RTEST(rb_hash_aref(hash, RAY_SYM("fullscreen"))))
+      flags |= sf::Style::Fullscreen;
+
+   if (!RTEST(rb_hash_aref(hash, RAY_SYM("no_frame")))) {
+      flags |= sf::Style::Titlebar;
+      flags |= sf::Style::Close;
+   }
+
+   if (RTEST(rb_hash_aref(hash, RAY_SYM("resizable"))))
+      flags |= sf::Style::Resize;
+
+   ray_video_mode mode = {
+      NUM2INT(width),
+      NUM2INT(height),
+
+      NUM2INT(bitsperpixel),
+
+      flags
+   };
+
+   return mode;
+}
+
+/*
+  @overload create_window(hash)
+    Creates a new window.
+
+    If both hw_surface and sws_urface are false, hw_surface
+    will be considered as true. :sw_surface should be true
+    if you want to acess
+
+    @return [Ray::Image] An image representing the window
+
+    @option hash [Integer] :width Width of the window
+    @option hash [Integer] :height Height of the window
+
+    @option hash [Integer] :w Alias for width
+    @option hash [Integer] :h Alias for height
+
+    @option hash [Integer] :bits_per_pixel Bits per pixel. Valid values are
+                                           8, 15, 16, 24, and 32.
+    @option hash [Integer] :bpp Alias for bits_per_pixel
+
+    @option hash [true, false] :hw_surface Creates the surface in video memory
+                                        (default)
+    @option hash [true, false] :sw_surface Creates the surface in system memory
+    @option hash [true, false] :async_blit Enables asynchronous updates of the
+                                           the surface
+    @option hash [true, false] :double_buf Enables double buffering. Ignored
+                                           if sw_surface is set.
+    @option hash [true, false] :fullscreen Creates a full screen window.
+    @option hash [true, false] :resizable  Creates a resizable window.
+    @option hash [true, false] :no_frame   Disables window decoration if
+                                           possible.
+ */
+VALUE ray_create_window(VALUE self, VALUE hash) {
+   ray_video_mode mode = ray_parse_video_mode(hash);
+
+   sf::VideoMode sfml_mode(mode.width, mode.height, mode.bpp);
+   if (mode.flags & sf::Style::Fullscreen) {
+      if (!sfml_mode.IsValid())
+         rb_raise(rb_eRuntimeError, "Invalid fullscreen mode");
+   }
+
+   ray_screen.Create(sfml_mode, "", mode.flags);
+
+   return ray_create_screen();
+}
+
+/*
+  @overload icon=(icon)
+    Sets the window icon
+    @param [Ray::Image] icon The icon to display
+*/
+VALUE ray_set_icon(VALUE self, VALUE icon) {
+   ray_image *image =  ray_rb2image(icon);
+   ray_screen.SetIcon(image->width(), image->height(),
+                      image->pixels());
+   return Qnil;
+}
+
+/*
+  @overload window_title=(title)
+    Sets the window title
+*/
+VALUE ray_set_window_title(VALUE self, VALUE title) {
+   if (!NIL_P(title)) {
+      title = rb_String(title);
+      ray_screen.SetTitle(StringValuePtr(title));
+   }
+   else
+      ray_screen.SetTitle("");
+
+   return title;
+}
+
+/* @return [Ray::Image, nil] The current screen, created by create_window */
+VALUE ray_get_screen(VALUE self) {
+   if (!ray_screen.IsOpened())
+      return Qnil;
+   return ray_create_screen();
+}
+
+/* Starts outputing error to stderr */
+VALUE ray_verbose(VALUE self) {
+   sf::Err().rdbuf(std::cerr.rdbuf());
+   return Qnil;
+}
+
+/* Stops outputing errors to stderr (default) */
+VALUE ray_quiet(VALUE self) {
+   sf::Err().rdbuf(NULL);
+   return Qnil;
+}
+
+extern "C"
+void Init_ray_ext() {
+   sf::Err().rdbuf(NULL); /* Don't put errors in stderr */
+
+   ray_mRay = rb_define_module("Ray");
+
+   rb_define_module_function(ray_mRay, "create_window", ray_create_window, 1);
+   rb_define_module_function(ray_mRay, "screen", ray_get_screen, 0);
+
+   rb_define_module_function(ray_mRay, "icon=", ray_set_icon, 1);
+   rb_define_module_function(ray_mRay, "window_title=", ray_set_window_title,
+                             1);
+
+   rb_define_module_function(ray_mRay, "verbose!", ray_verbose, 0);
+   rb_define_module_function(ray_mRay, "quiet!", ray_quiet, 0);
+
+   Init_ray_image();
+   Init_ray_sprite();
+   Init_ray_color();
+   Init_ray_rect();
+   Init_ray_vector();
+   Init_ray_event();
+   Init_ray_input();
+   Init_ray_shape();
+   Init_ray_font();
+   Init_ray_text();
+   Init_ray_audio();
+   Init_ray_drawable();
+   Init_ray_shader();
+}

data/ext/ray.hpp

@@ -0,0 +1,356 @@
+#ifndef RAY_H_
+#define RAY_H_
+
+#include "ruby.h"
+
+#include <SFML/Graphics.hpp>
+#include <SFML/OpenGL.hpp>
+#include <SFML/Audio.hpp>
+
+#include <iostream>
+
+extern sf::RenderWindow ray_screen;
+
+/* Classes and modules */
+extern VALUE ray_mRay;
+
+extern VALUE ray_cImage;
+extern VALUE ray_cSprite;
+extern VALUE ray_cShape;
+extern VALUE ray_cColor;
+extern VALUE ray_cRect;
+extern VALUE ray_cVector2;
+extern VALUE ray_cVector3;
+extern VALUE ray_cEvent;
+extern VALUE ray_mInput;
+extern VALUE ray_cFont;
+extern VALUE ray_cText;
+extern VALUE ray_mAudio;
+extern VALUE ray_cAudioSource;
+extern VALUE ray_cSound;
+extern VALUE ray_cMusic;
+extern VALUE ray_cDrawable;
+extern VALUE ray_cShader;
+
+/* Macros for Ruby's C API */
+
+#define RAY_IS_A(obj, klass) (RTEST(rb_obj_is_kind_of(obj, klass)))
+
+#define RAY_OBJ_CLASSNAME(obj) (rb_class2name(rb_class_of(obj)))
+
+#define RAY_SYM(string) (ID2SYM(rb_intern(string)))
+#define RAY_METH(string) (rb_intern(string))
+
+#define RAY_FLOAT_RECT(rect) \
+   (sf::FloatRect(rect.Left, rect.Top, rect.Width, rect.Height))
+#define RAY_INT_RECT(rect) \
+   (sf::IntRect(rect.Left, rect.Top, rect.Width, rect.Height))
+#define RAY_RECT(rect) \
+   (ray_rect(rect.Left, rect.Top, rect.Width, rect.Height))
+
+/* Data types */
+
+typedef struct {
+   int width;
+   int height;
+
+   int bpp;
+
+   uint32_t flags;
+} ray_video_mode;
+
+typedef sf::Color ray_color;
+
+typedef sf::FloatRect ray_rect;
+typedef sf::Vector2f  ray_vector2;
+typedef sf::Vector3f  ray_vector3;
+
+class ray_image {
+public:
+   ray_image(bool should_be_screen = false);
+   ~ray_image();
+
+   bool create_with_size(int w, int h);
+   bool create_with_filename(const std::string &filename);
+   bool create_with_io(VALUE io);
+   bool create_with_image(ray_image &src);
+
+   bool save_as(const std::string &filename) const;
+
+   int width() const;
+   int height() const;
+
+   void update();
+
+   sf::Sprite &get_sprite() { return sprite; }
+
+   void fill(sf::Color color);
+   void draw(const sf::Drawable &drawable,
+             sf::Shader *shader = NULL);
+
+   void draw_image(ray_image &image,
+                   const ray_rect &src_rect, const ray_vector2 &dest_pos,
+                   float angle, const ray_vector2 &zoom,
+                   sf::Shader *shader = NULL,
+                   const ray_color &color = sf::Color::White);
+
+   ray_color at(int x, int y) const;
+   bool set_at(int x, int y, const ray_color &color);
+
+   const uint8_t *pixels() const;
+
+   bool operator==(const ray_image &other) const;
+
+   ray_rect clip() const;
+   void set_clip(const ray_rect &other);
+
+   bool lock();
+   void unlock();
+
+   void activate();
+   void bind();
+
+   bool is_image() const;
+   const sf::Image &image() const;
+
+   sf::RenderTarget &target();
+   const sf::RenderTarget &target() const;
+private:
+   bool is_screen;
+
+   sf::RenderImage render_image;
+   sf::Sprite      sprite;
+
+   sf::Image *pixel_modifier;
+};
+
+class ray_sprite {
+public:
+   ray_sprite();
+   ~ray_sprite();
+
+   void copy(const ray_sprite &sprite);
+
+   void set_self(VALUE self);
+
+   ray_rect from_rect() const;
+   void set_from_rect(const ray_rect &rect);
+
+   ray_vector2 position() const;
+   void set_position(const ray_vector2 &pos);
+
+   float angle() const;
+   void set_angle(float angle);
+
+   ray_vector2 scale() const;
+   void set_scale(const ray_vector2 &scale);
+
+   ray_color color() const;
+   void set_color(const ray_color &color);
+
+   VALUE get_shader() const;
+   void set_shader(VALUE shader);
+
+   VALUE get_image() const;
+   void set_image(VALUE image);
+
+   void draw_on(ray_image &image);
+private:
+   sf::Sprite sprite;
+   VALUE self;
+};
+
+typedef sf::Font ray_font;
+
+class ray_audio_source {
+public:
+   virtual ~ray_audio_source() {}
+
+   void set_pitch(float value);
+   float pitch() const;
+
+   void set_position(const ray_vector3 &vector);
+   ray_vector3 position() const;
+
+   void set_relative(bool value);
+   bool is_relative() const;
+
+   void set_min_distance(float value);
+   float min_distance() const;
+
+   void set_attenuation(float value);
+   float attenuation() const;
+
+   void set_volume(float value);
+   float volume() const;
+protected:
+   virtual sf::SoundSource &source() = 0;
+   virtual const sf::SoundSource &source() const = 0;
+};
+
+class ray_sound : public ray_audio_source {
+public:
+   bool load_from_io(VALUE io);
+   bool load_from_filename(const std::string &filename);
+   bool create_from_sound(const ray_sound &sound);
+
+   void play();
+   void pause();
+   void stop();
+
+   sf::SoundSource::Status status() const;
+
+   void set_loop(bool value);
+   bool is_looping() const;
+
+   void set_current_time(float value);
+   float current_time() const;
+protected:
+   sf::SoundSource &source();
+   const sf::SoundSource &source() const;
+private:
+   sf::SoundBuffer sound_buffer;
+   sf::Sound sound;
+};
+
+class ray_music : public ray_audio_source {
+public:
+   bool load_from_io(VALUE self, VALUE io);
+   bool load_from_filename(const std::string &filename);
+
+   void play();
+   void pause();
+   void stop();
+
+   sf::SoundSource::Status status() const;
+
+   void set_loop(bool value);
+   bool is_looping() const;
+
+   void set_current_time(float value);
+   float current_time() const;
+
+   float duration() const;
+
+   int sample_rate() const;
+   int channel_count() const;
+protected:
+   sf::SoundSource &source();
+   const sf::SoundSource &source() const;
+private:
+   sf::Music music;
+};
+
+typedef sf::Event ray_event;
+
+class ray_drawable {
+public:
+   ray_drawable(): block(Qnil) {}
+   ~ray_drawable();
+
+   void render(VALUE image);
+
+   void set_block(VALUE val);
+private:
+   VALUE block;
+};
+
+/* Convertion functions */
+
+/** Converts a color into a ruby object */
+VALUE ray_col2rb(const ray_color &color);
+
+/** Converts a rect into a ruby object */
+VALUE ray_rect2rb(const ray_rect &rect);
+
+VALUE ray_vector2_to_rb(const ray_vector2 &vector);
+VALUE ray_vector3_to_rb(const ray_vector3 &vector);
+
+/** Converts a font into a ruby object */
+VALUE ray_font2rb(const ray_font &font);
+
+/** Converts a ruby object into a color */
+ray_color ray_rb2col(VALUE object);
+
+/** Parses a hash to create a video mode */
+ray_video_mode ray_parse_video_mode(VALUE hash);
+
+/** Converts a ruby object into an image*/
+ray_image *ray_rb2image(VALUE object);
+
+/** Returns a Ruby object representing the screen */
+VALUE ray_create_screen();
+
+/** Converts a ruby object into a rect */
+ray_rect ray_rb2rect(VALUE object);
+
+/** Converts a ruby object into a shape */
+sf::Shape *ray_rb2shape(VALUE object);
+
+/** Converts a ruby object into a shader */
+sf::Shader *ray_rb2shader(VALUE object);
+
+/**
+   Converts a ruby object into a rect even if it's not an instance
+   of Ray::Rect.
+ */
+ray_rect ray_convert_to_rect(VALUE obj);
+
+/** Converts a ruby object into a vector2 using #to_vector2 */
+ray_vector2 ray_convert_to_vector2(VALUE obj);
+
+/** Converts a ruby object into a vector3 using #to_vector3 */
+ray_vector3 ray_convert_to_vector3(VALUE obj);
+
+/** Converts a ruby object into an event */
+ray_event *ray_rb2event(VALUE object);
+
+/** Converts a ruby object into a font */
+ray_font *ray_rb2font(VALUE object);
+
+/** Converts a ruby object into an audio source */
+ray_audio_source *ray_rb2source(VALUE object);
+
+/** Converts a ruby object into a sound */
+ray_sound *ray_rb2sound(VALUE object);
+
+/** Converts a ruby object into a music */
+ray_music *ray_rb2music(VALUE object);
+
+/** Converts a ruby object into a drawable */
+ray_drawable *ray_rb2drawable(VALUE obj);
+
+/* Initializers */
+
+extern "C" void Init_ray_ext();
+void Init_ray_image();
+void Init_ray_sprite();
+void Init_ray_color();
+void Init_ray_rect();
+void Init_ray_vector();
+void Init_ray_event();
+void Init_ray_input();
+void Init_ray_shape();
+void Init_ray_font();
+void Init_ray_text();
+void Init_ray_audio();
+void Init_ray_drawable();
+void Init_ray_shader();
+
+/* Hack to make it compile, and still let YARD parse the source code: */
+
+#if !RUBINIUS /* Won't work on Rubinius, and unneeded */
+# define rb_define_method(klass, name, func, argc) \
+   rb_define_method(klass, name, (VALUE (*)(...))(func), argc)
+
+# define rb_define_singleton_method(klass, name, func, argc) \
+   rb_define_singleton_method(klass, name, (VALUE (*)(...))(func), argc)
+#endif
+
+#define rb_define_module_function(klass, name, func, argc) \
+   rb_define_module_function(klass, name, (VALUE (*)(...))(func), argc)
+
+#define rb_ensure(func1, arg1, func2, arg2) \
+   rb_ensure((VALUE (*)(...))(func1), arg1, (VALUE (*)(...))func2, arg2)
+
+#endif