ray 0.0.1 → 0.1.0.pre1

data/ext/sprite.cpp

@@ -0,0 +1,306 @@
+#include "ray.hpp"
+
+ray_sprite::ray_sprite():
+   self(Qnil)
+{}
+
+ray_sprite::~ray_sprite()
+{}
+
+void ray_sprite::copy(const ray_sprite &other) {
+   sprite = other.sprite;
+}
+
+void ray_sprite::set_self(VALUE new_self) {
+   self = new_self;
+}
+
+ray_rect ray_sprite::from_rect() const {
+   return RAY_RECT(sprite.GetSubRect());
+}
+
+void ray_sprite::set_from_rect(const ray_rect &rect) {
+   sprite.SetSubRect(RAY_INT_RECT(rect));
+}
+
+ray_vector2 ray_sprite::position() const {
+   return sprite.GetPosition();
+}
+
+void ray_sprite::set_position(const ray_vector2 &pos) {
+   sprite.SetPosition(pos);
+}
+
+float ray_sprite::angle() const {
+   return sprite.GetRotation();
+}
+
+void ray_sprite::set_angle(float angle) {
+   sprite.SetRotation(angle);
+}
+
+ray_vector2 ray_sprite::scale() const {
+   return sprite.GetScale();
+}
+void ray_sprite::set_scale(const ray_vector2 &scale) {
+   sprite.SetScale(scale);
+}
+
+ray_color ray_sprite::color() const {
+   return sprite.GetColor();
+}
+
+void ray_sprite::set_color(const ray_color &color) {
+   sprite.SetColor(color);
+}
+
+VALUE ray_sprite::get_shader() const {
+   return rb_iv_get(self, "@shader");
+}
+
+void ray_sprite::set_shader(VALUE new_shader) {
+   rb_iv_set(self, "@shader", new_shader);
+}
+
+VALUE ray_sprite::get_image() const {
+   return rb_iv_get(self, "@image");
+}
+
+void ray_sprite::set_image(VALUE new_image) {
+   rb_iv_set(self, "@image", new_image);
+
+   ray_image *img_ptr = ray_rb2image(new_image);
+   if (img_ptr->is_image())
+      sprite.SetImage(img_ptr->image(), true);
+   else
+      sprite.SetSubRect(sf::IntRect(0, 0, img_ptr->width(), img_ptr->height()));
+}
+
+void ray_sprite::draw_on(ray_image &target) {
+   ray_image *img_ptr = ray_rb2image(get_image());
+
+   sf::Image screen_copy;
+   if (!img_ptr->is_image()) {
+      if (!screen_copy.CopyScreen(ray_screen, sf::IntRect(0, 0, img_ptr->width(),
+                                                          img_ptr->height()))) {
+         return;
+      }
+
+      sprite.SetImage(screen_copy);
+   }
+
+   sf::Shader *shader_ptr = NULL;
+   VALUE shader = get_shader();
+   if (!NIL_P(shader))
+      shader_ptr = ray_rb2shader(shader);
+
+   if (shader_ptr)
+      target.target().Draw(sprite, *shader_ptr);
+   else
+      target.target().Draw(sprite, *shader_ptr);
+}
+
+VALUE ray_cSprite = Qnil;
+
+void ray_free_sprite(ray_sprite *ptr) {
+   delete ptr;
+}
+
+VALUE ray_alloc_sprite(VALUE self) {
+   ray_sprite *sprite = new ray_sprite;
+   VALUE ret = Data_Wrap_Struct(self, 0, ray_free_sprite, sprite);
+   sprite->set_self(ret);
+
+   return ret;
+}
+
+ray_sprite *ray_rb2sprite(VALUE obj) {
+   if (!RAY_IS_A(obj, ray_cSprite)) {
+      rb_raise(rb_eTypeError, "Can't convert %s into Ray::Sprite",
+               RAY_OBJ_CLASSNAME(obj));
+   }
+
+   ray_sprite *sprite;
+   Data_Get_Struct(obj, ray_sprite, sprite);
+
+   return sprite;
+}
+
+/*
+  @overload initialize(image, opts = {})
+    Creates a sprite.
+
+    @param [String, Ray::Image] The image this object will wrap;
+    @option opts [Ray::Vecor2, #to_Vector2] :at Position of the sprite
+                                                 (defaults to 0,0)
+    @option opts [Ray::Rect, Array<Integer>] :rect Rect of the image which will
+                                                   be drawn (defaults to the
+                                                   whole image)
+    @option opts [Float] :angle The angle which will be used to draw the image
+                                 in degrees. Defaults to 0.
+    @option opts [Ray::Vector2] :zoom The zoom level which will be used to draw the image.
+    @option opts [Ray::Vector2] :scale Alias for :zoom
+    @option opts [Ray::Shader] :shader Shader used when drawing the sprite
+    @option opts [Ray::Color] :color Color used, multiplying each pixel of the sprite.
+*/
+VALUE ray_init_sprite(int argc, VALUE *argv, VALUE self) {
+   ray_sprite *sprite = ray_rb2sprite(self);
+
+   VALUE image, opts;
+   rb_scan_args(argc, argv, "11", &image, &opts);
+
+   if (RAY_IS_A(image, rb_cString))
+      image = rb_funcall(rb_path2class("Ray::ImageSet"), RAY_METH("[]"), 1, image);
+
+   sprite->set_image(image);
+
+   if (NIL_P(opts))
+      opts = rb_hash_new();
+
+   VALUE from_rect = rb_hash_aref(opts, RAY_SYM("rect"));
+   if (!NIL_P(from_rect))
+      sprite->set_from_rect(ray_convert_to_rect(from_rect));
+
+   VALUE pos = rb_hash_aref(opts, RAY_SYM("at"));
+   if (!NIL_P(pos))
+      sprite->set_position(ray_convert_to_vector2(pos));
+
+   VALUE angle = rb_hash_aref(opts, RAY_SYM("angle"));
+   if (!NIL_P(angle))
+      sprite->set_angle(NUM2DBL(angle));
+
+   VALUE zoom = rb_hash_aref(opts, RAY_SYM("zoom"));
+   if (NIL_P(zoom)) zoom = rb_hash_aref(opts, RAY_SYM("scale"));
+   if (!NIL_P(zoom))
+      sprite->set_scale(ray_convert_to_vector2(zoom));
+
+   sprite->set_shader(rb_hash_aref(opts, RAY_SYM("shader")));
+
+   VALUE color = rb_hash_aref(opts, RAY_SYM("color"));
+   if (!NIL_P(color))
+      sprite->set_color(ray_rb2col(color));
+
+   return self;
+}
+
+VALUE ray_init_sprite_copy(VALUE self, VALUE other) {
+   ray_rb2sprite(self)->copy(*ray_rb2sprite(other));
+   return self;
+}
+
+/* @return [Ray::Image] */
+VALUE ray_sprite_image(VALUE self) {
+   return ray_rb2sprite(self)->get_image();
+}
+
+/* @return [Ray::Rect] The part of the image which will be drawn */
+VALUE ray_sprite_from_rect(VALUE self) {
+   return ray_rect2rb(ray_rb2sprite(self)->from_rect());
+}
+
+/* Sets the part of the image which will be displayed */
+VALUE ray_sprite_set_from_rect(VALUE self, VALUE rect) {
+   rb_check_frozen(self);
+   ray_rb2sprite(self)->set_from_rect(ray_convert_to_rect(rect));
+   return rect;
+}
+
+/* @return [Ray::Shader] shader used when drawing the sprite */
+VALUE ray_sprite_shader(VALUE self) {
+   return ray_rb2sprite(self)->get_shader();
+}
+
+/* Sets the shader used when drawing the sprite */
+VALUE ray_sprite_set_shader(VALUE self, VALUE shader) {
+   rb_check_frozen(self);
+   ray_rb2sprite(self)->set_shader(shader);
+   return shader;
+}
+
+/* @return [Ray::Color] Color used when drawing the sprite */
+VALUE ray_sprite_color(VALUE self) {
+   return ray_col2rb(ray_rb2sprite(self)->color());
+}
+
+/* Sets the color used when drawing the sprite */
+VALUE ray_sprite_set_color(VALUE self, VALUE color) {
+   rb_check_frozen(self);
+   ray_rb2sprite(self)->set_color(ray_rb2col(color));
+   return color;
+}
+
+/* @return [Ray::Vector2] The position of the sprite */
+VALUE ray_sprite_pos(VALUE self) {
+   return ray_vector2_to_rb(ray_rb2sprite(self)->position());
+}
+
+/* Sets the position of the sprite */
+VALUE ray_sprite_set_pos(VALUE self, VALUE pos) {
+   rb_check_frozen(self);
+   ray_rb2sprite(self)->set_position(ray_convert_to_vector2(pos));
+   return pos;
+}
+
+/* @return [Float] The angle used when the sprite is drawn */
+VALUE ray_sprite_angle(VALUE self) {
+   return rb_float_new(ray_rb2sprite(self)->angle());
+}
+
+/* Sets the angle used when the sprite is drawn */
+VALUE ray_sprite_set_angle(VALUE self, VALUE angle) {
+   rb_check_frozen(self);
+   ray_rb2sprite(self)->set_angle(NUM2DBL(angle));
+   return angle;
+}
+
+/* @return [Ray::Vector2] The scale applied to the image when it is drawn */
+VALUE ray_sprite_scale(VALUE self) {
+   return ray_vector2_to_rb(ray_rb2sprite(self)->scale());
+}
+
+/* Set the scale applied to the image */
+VALUE ray_sprite_set_scale(VALUE self, VALUE scale) {
+   rb_check_frozen(self);
+   ray_rb2sprite(self)->set_scale(ray_convert_to_vector2(scale));
+   return scale;
+}
+
+/*
+  @overload draw_on(imaage)
+    Draws the sprite on an image.
+    @param [Ray::Image] image The image to draw on.
+*/
+VALUE ray_sprite_draw_on(VALUE self, VALUE image) {
+   rb_check_frozen(image);
+   ray_rb2sprite(self)->draw_on(*ray_rb2image(image));
+   return image;
+}
+
+void Init_ray_sprite() {
+   ray_cSprite = rb_define_class_under(ray_mRay, "Sprite", rb_cObject);
+   rb_define_alloc_func(ray_cSprite, ray_alloc_sprite);
+   rb_define_method(ray_cSprite, "initialize", ray_init_sprite, -1);
+   rb_define_method(ray_cSprite, "initialize_copy", ray_init_sprite_copy, 1);
+
+   rb_define_method(ray_cSprite, "image", ray_sprite_image, 0);
+
+   rb_define_method(ray_cSprite, "from_rect", ray_sprite_from_rect, 0);
+   rb_define_method(ray_cSprite, "from_rect=", ray_sprite_set_from_rect, 1);
+
+   rb_define_method(ray_cSprite, "shader", ray_sprite_shader, 0);
+   rb_define_method(ray_cSprite, "shader=", ray_sprite_set_shader, 1);
+
+   rb_define_method(ray_cSprite, "color", ray_sprite_color, 0);
+   rb_define_method(ray_cSprite, "color=", ray_sprite_set_color, 1);
+
+   rb_define_method(ray_cSprite, "pos", ray_sprite_pos, 0);
+   rb_define_method(ray_cSprite, "pos=", ray_sprite_set_pos, 1);
+
+   rb_define_method(ray_cSprite, "angle", ray_sprite_angle, 0);
+   rb_define_method(ray_cSprite, "angle=", ray_sprite_set_angle, 1);
+
+   rb_define_method(ray_cSprite, "scale", ray_sprite_scale, 0);
+   rb_define_method(ray_cSprite, "scale=", ray_sprite_set_scale, 1);
+
+   rb_define_method(ray_cSprite, "draw_on", ray_sprite_draw_on, 1);
+}

data/ext/text.cpp

@@ -0,0 +1,181 @@
+#include "ray.hpp"
+
+VALUE ray_cText = Qnil;
+
+sf::Text *ray_rb2text(VALUE obj) {
+   if (!RAY_IS_A(obj, ray_cText)) {
+      rb_raise(rb_eTypeError, "can't convert %s into Ray::Text",
+               RAY_OBJ_CLASSNAME(obj));
+   }
+
+   sf::Text *text = NULL;
+   Data_Get_Struct(obj, sf::Text, text);
+
+   return text;
+}
+
+void ray_free_text(sf::Text *text) {
+   delete text;
+}
+
+VALUE ray_alloc_text(VALUE self) {
+   sf::Text *text = new sf::Text;
+   return Data_Wrap_Struct(self, 0, ray_free_text, text);
+}
+
+VALUE ray_init_text_copy(VALUE self, VALUE other) {
+   *ray_rb2text(self) = *ray_rb2text(other);
+   return self;
+}
+
+VALUE ray_text_basic_set_content(VALUE self, VALUE content) {
+   rb_check_frozen(self);
+
+   sf::Text *text = ray_rb2text(self);
+
+   char *c_str = StringValuePtr(content);
+   sf::String str((uint32_t*)c_str);
+
+   text->SetString(str);
+
+   return content;
+}
+
+VALUE ray_text_basic_content(VALUE self) {
+   const sf::String &str = ray_rb2text(self)->GetString();
+
+   const uint32_t *c_str = str.GetData();
+   return rb_str_new((char*)c_str, str.GetSize() * 4);
+}
+
+VALUE ray_text_basic_set_style(VALUE self, VALUE style) {
+   rb_check_frozen(self);
+   ray_rb2text(self)->SetStyle(NUM2INT(style));
+   return style;
+}
+
+/* @return [Integer] The style of the text */
+VALUE ray_text_style(VALUE self) {
+   return INT2FIX(ray_rb2text(self)->GetStyle());
+}
+
+/* Sets the position of the text */
+VALUE ray_text_set_pos(VALUE self, VALUE val) {
+   rb_check_frozen(self);
+   ray_rb2text(self)->SetPosition(ray_convert_to_vector2(val));
+   return val;
+}
+
+/* @return [Vector2] The position of the tet */
+VALUE ray_text_pos(VALUE self) {
+   return ray_vector2_to_rb(ray_rb2text(self)->GetPosition());
+}
+
+/* Sets the scale applied to the text */
+VALUE ray_text_set_scale(VALUE self, VALUE val) {
+   rb_check_frozen(self);
+   ray_rb2text(self)->SetScale(ray_convert_to_vector2(val));
+   return val;
+}
+
+/* @return [Ray::Vector2] The scale applied to the text */
+VALUE ray_text_scale(VALUE self) {
+   return ray_vector2_to_rb(ray_rb2text(self)->GetScale());
+}
+
+/* Sets the rotation applied to the text when it is drawn. */
+VALUE ray_text_set_angle(VALUE self, VALUE val) {
+   ray_rb2text(self)->SetRotation(NUM2DBL(val));
+   return val;
+}
+
+/* @return [Float] The rotation applied to the text when it is drawn. */
+VALUE ray_text_angle(VALUE self) {
+   return rb_float_new(ray_rb2text(self)->GetRotation());
+}
+
+/* @return [Integer] The character size of the text */
+VALUE ray_text_character_size(VALUE self) {
+   return INT2FIX(ray_rb2text(self)->GetCharacterSize());
+}
+
+/* Sets the character size of the text */
+VALUE ray_text_set_character_size(VALUE self, VALUE val) {
+   rb_check_frozen(self);
+   ray_rb2text(self)->SetCharacterSize(NUM2INT(val));
+   return val;
+}
+
+/* @return [Ray::Font] The font used to draw the text */
+VALUE ray_text_font(VALUE self) {
+   return ray_font2rb(ray_rb2text(self)->GetFont());
+}
+
+/* Sets the font used to draw the text */
+VALUE ray_text_set_font(VALUE self, VALUE val) {
+   ray_rb2text(self)->SetFont(*ray_rb2font(val));
+   rb_iv_set(self, "@font", val); /* Keep a reference to the font */
+
+   return val;
+}
+
+/* @return [Ray::Color] Returns the color used to draw the text */
+VALUE ray_text_color(VALUE self) {
+   return ray_col2rb(ray_rb2text(self)->GetColor());
+}
+
+/* Sets the color used to draw the text */
+VALUE ray_text_set_color(VALUE self, VALUE val) {
+   rb_check_frozen(self);
+   ray_rb2text(self)->SetColor(ray_rb2col(val));
+   return val;
+}
+
+/* @return [Ray::Rect] Rect occupied by the text. Scale is taken in acount. */
+VALUE ray_text_rect(VALUE self) {
+   ray_rect rect(ray_rb2text(self)->GetRect());
+   return ray_rect2rb(rect);
+}
+
+/*
+  @overload draw_on(image)
+    Draws the text on an image.
+*/
+VALUE ray_text_draw_on(VALUE self, VALUE target) {
+   ray_rb2image(target)->draw(*ray_rb2text(self));
+   return target;
+}
+
+void Init_ray_text() {
+   ray_cText = rb_define_class_under(ray_mRay, "Text", rb_cObject);
+   rb_define_alloc_func(ray_cText, ray_alloc_text);
+   rb_define_method(ray_cText, "initialize_copy", ray_init_text_copy, 1);
+
+   rb_define_method(ray_cText, "basic_set_content", ray_text_basic_set_content, 1);
+   rb_define_method(ray_cText, "basic_content", ray_text_basic_content, 0);
+
+   rb_define_method(ray_cText, "basic_set_style", ray_text_basic_set_style, 1);
+   rb_define_method(ray_cText, "style", ray_text_style, 0);
+
+   rb_define_method(ray_cText, "pos=", ray_text_set_pos, 1);
+   rb_define_method(ray_cText, "pos", ray_text_pos, 0);
+
+   rb_define_method(ray_cText, "scale=", ray_text_set_scale, 1);
+   rb_define_method(ray_cText, "scale", ray_text_scale, 0);
+
+   rb_define_method(ray_cText, "angle", ray_text_angle, 0);
+   rb_define_method(ray_cText, "angle=", ray_text_set_angle, 1);
+
+   rb_define_method(ray_cText, "character_size", ray_text_character_size, 0);
+   rb_define_method(ray_cText, "character_size=", ray_text_set_character_size, 1);
+
+   rb_define_method(ray_cText, "font", ray_text_font, 0);
+   rb_define_method(ray_cText, "font=", ray_text_set_font, 1);
+
+   rb_define_method(ray_cText, "color", ray_text_color, 0);
+   rb_define_method(ray_cText, "color=", ray_text_set_color, 1);
+
+   rb_define_method(ray_cText, "rect", ray_text_rect, 0);
+
+   rb_define_method(ray_cText, "draw_on", ray_text_draw_on, 1);
+}