ray 0.0.1 → 0.1.0.pre1

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

@@ -1,14 +1,13 @@
-#include "ray.h"
+#include "ray.hpp"
 
 VALUE ray_cRect = Qnil;
 
 void ray_free_rect(ray_rect *ptr) {
-   free(ptr);
+   delete ptr;
 }
 
-VALUE ray_rect2rb(ray_rect rect) {
-   ray_rect *ptr = malloc(sizeof(ray_rect));
-   memcpy(ptr, &rect, sizeof(ray_rect));
+VALUE ray_rect2rb(const ray_rect &rect) {
+   ray_rect *ptr = new ray_rect(rect);
 
    VALUE obj = Data_Wrap_Struct(ray_cRect, NULL, ray_free_rect, ptr);
    return obj;
@@ -29,20 +28,14 @@ ray_rect ray_rb2rect(VALUE obj) {
 ray_rect ray_convert_to_rect(VALUE obj) {
    if (RAY_IS_A(obj, ray_cRect))
       return ray_rb2rect(obj);
-   else if (RAY_IS_A(obj, rb_cArray))
-      return ray_rb2rect(rb_apply(ray_cRect, RAY_METH("new"), obj));
    else {
-      rb_raise(rb_eTypeError, "Can't convert %s into Ray::Rect",
-               RAY_OBJ_CLASSNAME(obj));
+      obj = rb_funcall(obj, RAY_METH("to_rect"), 0);
+      return ray_rb2rect(obj);
    }
-
-   /* Should never happen */
-   ray_rect empty_rect = {0, 0, 0, 0};
-   return empty_rect;
 }
 
 VALUE ray_alloc_rect(VALUE self) {
-   ray_rect *rect = malloc(sizeof(ray_rect));
+   ray_rect *rect = new ray_rect;
    VALUE ret = Data_Wrap_Struct(self, 0, ray_free_rect, rect);
 
    return ret;
@@ -58,10 +51,13 @@ VALUE ray_alloc_rect(VALUE self) {
   @overload initialize(hash)
     Creates a new rect according to the keys specified in hash.
 
-    @option hash [Integer] :x
-    @option hash [Integer] :y
-    @option hash [Integer, optional] :width
-    @option hash [Integer, optional] :height required if width is set
+    @option hash [Float] :x
+    @option hash [Float] :y
+    @option hash [Float, optional] :width
+    @option hash [Float, optional] :height required if width is set
+
+    @option hash [Float, optional] :w alias for :width
+    @option hash [Float, optional] :h alias for :height
 */
 VALUE ray_init_rect(int argc, VALUE *argv, VALUE self) {
    VALUE x_or_hash, y, w, h;
@@ -106,51 +102,60 @@ VALUE ray_init_rect(int argc, VALUE *argv, VALUE self) {
    ray_rect *rect;
    Data_Get_Struct(self, ray_rect, rect);
 
-   rect->x = NUM2INT(x_or_hash);
-   rect->y = NUM2INT(y);
+   rect->Left = NUM2DBL(x_or_hash);
+   rect->Top = NUM2DBL(y);
 
    if (!NIL_P(w)) {
-      rect->w = NUM2INT(w);
-      rect->h = NUM2INT(h);
+      rect->Width = NUM2DBL(w);
+      rect->Height = NUM2DBL(h);
    }
    else {
-      rect->w = 0;
-      rect->h = 0;
+      rect->Width = 0;
+      rect->Height = 0;
    }
 
    return Qnil;
 }
 
-/* @return [Integer] position of the rect */
+VALUE ray_init_rect_copy(VALUE self, VALUE other) {
+   ray_rect *rect = NULL, *source = NULL;
+   Data_Get_Struct(self,  ray_rect, rect);
+   Data_Get_Struct(other, ray_rect, source);
+
+   *rect = *source;
+   return self;
+}
+
+/* @return [Float] position of the rect */
 VALUE ray_rect_x(VALUE self) {
    ray_rect *rect;
    Data_Get_Struct(self, ray_rect, rect);
 
-   return INT2FIX(rect->x);
+   return rb_float_new(rect->Left);
 }
 
-/* @return [Integer] position of the rect */
+/* @return [Float] position of the rect */
 VALUE ray_rect_y(VALUE self) {
    ray_rect *rect;
    Data_Get_Struct(self, ray_rect, rect);
 
-   return INT2FIX(rect->y);
+   return rb_float_new(rect->Top);
 }
 
-/* @return [Integer] size of the rect */
+/* @return [Float] size of the rect */
 VALUE ray_rect_w(VALUE self) {
    ray_rect *rect;
    Data_Get_Struct(self, ray_rect, rect);
 
-   return INT2FIX(rect->w);
+   return rb_float_new(rect->Width);
 }
 
-/* @return [Integer] size of the rect */
+/* @return [Float] size of the rect */
 VALUE ray_rect_h(VALUE self) {
    ray_rect *rect;
    Data_Get_Struct(self, ray_rect, rect);
 
-   return INT2FIX(rect->h);
+   return rb_float_new(rect->Height);
 }
 
 /*
@@ -158,10 +163,12 @@ VALUE ray_rect_h(VALUE self) {
     Sets the position of the rect
 */
 VALUE ray_rect_set_x(VALUE self, VALUE val) {
+   rb_check_frozen(self);
+
    ray_rect *rect;
    Data_Get_Struct(self, ray_rect, rect);
 
-   rect->x = NUM2INT(val);
+   rect->Left = NUM2DBL(val);
 
    return val;
 }
@@ -171,10 +178,12 @@ VALUE ray_rect_set_x(VALUE self, VALUE val) {
     Sets the position of the rect
 */
 VALUE ray_rect_set_y(VALUE self, VALUE val) {
+   rb_check_frozen(self);
+
    ray_rect *rect;
    Data_Get_Struct(self, ray_rect, rect);
 
-   rect->y = NUM2INT(val);
+   rect->Top = NUM2DBL(val);
 
    return val;
 }
@@ -184,10 +193,12 @@ VALUE ray_rect_set_y(VALUE self, VALUE val) {
     Sets the size of the rect
 */
 VALUE ray_rect_set_w(VALUE self, VALUE val) {
+   rb_check_frozen(self);
+
    ray_rect *rect;
    Data_Get_Struct(self, ray_rect, rect);
 
-   rect->w = NUM2INT(val);
+   rect->Width = NUM2DBL(val);
 
    return val;
 }
@@ -197,10 +208,12 @@ VALUE ray_rect_set_w(VALUE self, VALUE val) {
     Sets the size of the rect
 */
 VALUE ray_rect_set_h(VALUE self, VALUE val) {
+   rb_check_frozen(self);
+
    ray_rect *rect;
    Data_Get_Struct(self, ray_rect, rect);
 
-   rect->h = NUM2INT(val);
+   rect->Height = NUM2DBL(val);
 
    return val;
 }
@@ -208,7 +221,7 @@ VALUE ray_rect_set_h(VALUE self, VALUE val) {
 /*
   Document-class: Ray::Rect
 
-  Rects are used to represent a part of a surface, using
+  Rects are used to represent a part of an image, using
   two attributes to represent its position, and two
   others to represent its size.
 */
@@ -218,6 +231,7 @@ void Init_ray_rect() {
 
    rb_define_alloc_func(ray_cRect, ray_alloc_rect);
    rb_define_method(ray_cRect, "initialize", ray_init_rect, -1);
+   rb_define_method(ray_cRect, "initialize_copy", ray_init_rect_copy, 1);
 
    rb_define_method(ray_cRect, "x", ray_rect_x, 0);
    rb_define_method(ray_cRect, "y", ray_rect_y, 0);

data/ext/shader.cpp

@@ -0,0 +1,169 @@
+#include "ray.hpp"
+
+VALUE ray_cShader = Qnil;
+
+void ray_free_shader(sf::Shader *shader) {
+   delete shader;
+}
+
+VALUE ray_alloc_shader(VALUE self) {
+   sf::Shader *shader = new sf::Shader;
+   return Data_Wrap_Struct(self, 0, ray_free_shader, shader);
+}
+
+sf::Shader *ray_rb2shader(VALUE self) {
+   if (!RAY_IS_A(self, ray_cShader)) {
+      rb_raise(rb_eTypeError, "Can't convert %s into Ray::Shader",
+               RAY_OBJ_CLASSNAME(self));
+   }
+
+   sf::Shader *shader = NULL;
+   Data_Get_Struct(self, sf::Shader, shader);
+
+   return shader;
+}
+
+/*
+  @return [true, false] True if it is possible to use shaders.
+*/
+VALUE ray_shader_available(VALUE self) {
+   return sf::Shader::IsAvailable() ? Qtrue : Qfalse;
+}
+
+/*
+  @overload initialize(filename_or_io)
+    Creates a new Shader with the source code found
+    in a file or in an IO object.
+
+    @example
+      shader = Ray::Shader.new StringIO.new(<<-SHADER)
+        // Code of the shader
+      SHADER
+ */
+VALUE ray_init_shader(VALUE self, VALUE argument) {
+   sf::Shader *shader = ray_rb2shader(self);
+
+   if (RAY_IS_A(argument, rb_cString)) {
+      if (!shader->LoadFromFile(StringValuePtr(argument)))
+         rb_raise(rb_eRuntimeError, "Couldn't load the shader");
+   }
+   else if (rb_respond_to(argument, RAY_METH("read"))) {
+      VALUE string = rb_funcall2(argument, RAY_METH("read"), 0, NULL);
+      char *c_string = StringValuePtr(string);
+
+      if (!shader->LoadFromMemory(c_string))
+         rb_raise(rb_eRuntimeError, "Couldn't load the shader");
+   }
+   else {
+      rb_raise(rb_eArgError, "Can't convert %s into String",
+               RAY_OBJ_CLASSNAME(argument));
+   }
+
+   return self;
+}
+
+/*
+  @overload []=(name, argument)
+    Sets one of the variables of the shader.
+    argument can be:
+      - a float
+      - an array of 1, 2, 3, or 4 floats (for vectors)
+      - a Vector2 or Vector3
+      - an image, or :current which is a magic value to set a
+        texture to the current one.
+*/
+VALUE ray_shader_set(VALUE self, VALUE param, VALUE arg) {
+   rb_check_frozen(self);
+
+   sf::Shader *shader = ray_rb2shader(self);
+   char *name = StringValuePtr(param);
+
+   if (RAY_IS_A(arg, rb_cArray)) {
+      switch (RARRAY_LEN(arg)) {
+         case 1:
+            shader->SetParameter(name, NUM2DBL(rb_ary_entry(arg, 0)));
+            break;
+         case 2:
+            shader->SetParameter(name, NUM2DBL(rb_ary_entry(arg, 0)),
+                                 NUM2DBL(rb_ary_entry(arg, 1)));
+            break;
+         case 3:
+            shader->SetParameter(name, NUM2DBL(rb_ary_entry(arg, 0)),
+                                 NUM2DBL(rb_ary_entry(arg, 1)),
+                                 NUM2DBL(rb_ary_entry(arg, 2)));
+            break;
+         case 4:
+            shader->SetParameter(name, NUM2DBL(rb_ary_entry(arg, 0)),
+                                 NUM2DBL(rb_ary_entry(arg, 1)),
+                                 NUM2DBL(rb_ary_entry(arg, 2)),
+                                 NUM2DBL(rb_ary_entry(arg, 3)));
+            break;
+         default:
+            rb_raise(rb_eArgError, "Can't set vectors of %ld components",
+                     RARRAY_LEN(arg));
+            break;
+      }
+   }
+   else {
+      if (RAY_IS_A(arg, ray_cImage)) {
+         ray_image *img = ray_rb2image(arg);
+         if (img->is_image())
+            shader->SetTexture(name, img->image());
+         else
+            rb_raise(rb_eArgError, "Can't set the screen as a texture");
+      }
+      else if (arg == RAY_SYM("current"))
+         shader->SetTexture(name, sf::Shader::CurrentTexture);
+      else if (RAY_IS_A(arg, ray_cVector2))
+         shader->SetParameter(name, ray_convert_to_vector2(arg));
+      else if (RAY_IS_A(arg, ray_cVector3))
+         shader->SetParameter(name, ray_convert_to_vector3(arg));
+      else
+         shader->SetParameter(name, NUM2DBL(arg));
+   }
+
+   return arg;
+}
+
+VALUE ray_shader_ensure_unbind(VALUE self) {
+   ray_rb2shader(self)->Unbind();
+   return self;
+}
+
+/*
+  Binds the shader (for custom OpenGL drawing).
+  If a block is given, it is executed. The shader is then unbound.
+*/
+VALUE ray_shader_bind(VALUE self) {
+   ray_rb2shader(self)->Bind();
+
+   if (rb_block_given_p())
+      rb_ensure(rb_yield, Qnil, ray_shader_ensure_unbind, self);
+
+   return self;
+}
+
+/* Unbinds the shader (useful when doing custom OpenGL drawing) */
+VALUE ray_shader_unbind(VALUE self) {
+   return ray_shader_ensure_unbind(self);
+}
+
+/*
+  Document-class: Ray::Shader
+
+  Class used to load OpenGL pixel shaders, which are written
+  in the GLSL language (a C-like language).
+*/
+
+void Init_ray_shader() {
+   ray_cShader = rb_define_class_under(ray_mRay, "Shader", rb_cObject);
+   rb_define_alloc_func(ray_cShader, ray_alloc_shader);
+   rb_define_method(ray_cShader, "initialize", ray_init_shader, 1);
+
+   rb_define_singleton_method(ray_cShader, "available?", ray_shader_available, 0);
+
+   rb_define_method(ray_cShader, "[]=", ray_shader_set, 2);
+
+   rb_define_method(ray_cShader, "bind", ray_shader_bind, 0);
+   rb_define_method(ray_cShader, "unbind", ray_shader_unbind, 0);
+}

data/ext/shape.cpp

@@ -0,0 +1,409 @@
+#include "ray.hpp"
+
+VALUE ray_cShape = Qnil;
+
+void ray_free_shape(sf::Shape *shape) {
+   delete shape;
+}
+
+VALUE ray_alloc_shape(VALUE self) {
+   sf::Shape *shape = new sf::Shape;
+   return Data_Wrap_Struct(self, 0, ray_free_shape, shape);
+}
+
+sf::Shape *ray_rb2shape(VALUE self) {
+   if (!RAY_IS_A(self, ray_cShape)) {
+      rb_raise(rb_eTypeError, "Can't convert %s into Ray::Shape",
+               RAY_OBJ_CLASSNAME(self));
+   }
+
+   sf::Shape *shape = NULL;
+   Data_Get_Struct(self, sf::Shape, shape);
+
+   return shape;
+}
+
+VALUE ray_shape2rb(const sf::Shape &shape) {
+   sf::Shape *copy = new sf::Shape(shape);
+   return Data_Wrap_Struct(ray_cShape, 0, ray_free_shape, copy);
+}
+
+VALUE ray_init_shape_copy(VALUE self, VALUE other) {
+   *ray_rb2shape(self) = *ray_rb2shape(other);
+   return self;
+}
+
+/*
+  @overload line(from, to, size = 1.0, color = Ray::Color.white,
+                 outline_width = 0.0, outline_color = Ray::Color.none)
+    @param [Ray::Vector2, #to_vector2] from First point of the line
+    @param [Ray::Vector2, #to_vector2] to Last point of the line
+
+    @param [Float] size Width of the line
+    @param [Color] color Color of the line
+
+    @param [Float] outline_width Width of the outline
+    @param [Color] outline_color Color of the outline
+
+    @return [Shape] a line.
+*/
+VALUE ray_shape_line(int argc, VALUE *argv, VALUE self) {
+   VALUE from, to, size;
+   VALUE color;
+   VALUE outline_width, outline_color;
+
+   rb_scan_args(argc, argv, "24", &from, &to, &size, &color, &outline_width,
+                &outline_color);
+
+   ray_vector2 from_point = ray_convert_to_vector2(from);
+   ray_vector2 to_point   = ray_convert_to_vector2(to);
+
+   float c_size = 1.0f;
+   if (!NIL_P(size)) c_size = (float)NUM2DBL(size);
+
+   float c_outline_width = 1.0f;
+   if (!NIL_P(outline_width)) c_outline_width = (float)NUM2DBL(outline_width);
+
+   ray_color sf_color(0, 0, 0);
+   if (!NIL_P(color)) sf_color = ray_rb2col(color);
+
+   ray_color sf_outline_color(0, 0, 0);
+   if (!NIL_P(outline_color)) sf_outline_color = ray_rb2col(outline_color);
+
+   return ray_shape2rb(sf::Shape::Line(from_point, to_point,
+                                       c_size, sf_color,
+                                       c_outline_width, sf_outline_color));
+}
+
+/*
+  @overload rectangle(rect, color = Ray::Color.white,
+                      outline_width = 0.0, outline_color = Ray::Color.none)
+    @param [Ray::Rect, Array<Integer>] Rect used by this shape
+    @param [Color] color Color of the rect
+    @param [Float] outline_width (See Shape.line)
+    @param [Color] outline_color (See Shape.line)
+
+    @return [Shape] A rectangle.
+*/
+VALUE ray_shape_rectangle(int argc, VALUE *argv, VALUE self) {
+   VALUE rect, color, outline_width, outline_color;
+   rb_scan_args(argc, argv, "13", &rect, &color, &outline_width, &outline_color);
+
+   ray_rect c_rect = ray_convert_to_rect(rect);
+
+   ray_color c_color = ray_rb2col(color);
+   ray_color c_outline_color(0, 0, 0);
+   if (!NIL_P(outline_color))
+      c_outline_color = ray_rb2col(outline_color);
+
+   float c_outline_width = 0;
+   if (!NIL_P(outline_width))
+      c_outline_width = (float)NUM2DBL(outline_width);
+
+   return ray_shape2rb(sf::Shape::Rectangle(c_rect.Left, c_rect.Top,
+                                            c_rect.Width, c_rect.Height,
+                                            c_color, c_outline_width,
+                                            c_outline_color));
+}
+
+/*
+   @overload circle(center, radius, color = Ray::Color.white,
+                    outline_width = 0.0, outline_color = Ray::Color.none)
+     @param [Ray::Vector2, #to_vector2] center Center of the circle
+     @param [Float] radius Radius of the circle.
+     @param [Color] color Color of the cirlce.
+
+     @param [Float] outline_width (See Shape.line)
+     @param [Color] outline_color (See Shape.line)
+
+     @return [Shape] A circle.
+*/
+VALUE ray_shape_circle(int argc, VALUE *argv, VALUE self) {
+   VALUE center, radius, color, outline_width, outline_color;
+   rb_scan_args(argc, argv, "23", &center, &radius, &color,
+                &outline_width, &outline_color);
+
+   ray_vector2 c_center = ray_convert_to_vector2(center);
+   float c_radius = (float)NUM2DBL(radius);
+
+   ray_color c_color = ray_rb2col(color);
+   ray_color c_outline_color(0, 0, 0);
+   if (!NIL_P(outline_color))
+      c_outline_color = ray_rb2col(outline_color);
+
+   float c_outline_width = 0;
+   if (!NIL_P(outline_width))
+      c_outline_width = (float)NUM2DBL(outline_width);
+
+   return ray_shape2rb(sf::Shape::Circle(c_center, c_radius,
+                                         c_color, c_outline_width,
+                                         c_outline_color));
+}
+
+/* @return [Ray::Vector2] Position of the shape */
+VALUE ray_shape_pos(VALUE self) {
+   return ray_vector2_to_rb(ray_rb2shape(self)->GetPosition());
+}
+
+/* Sets the position of the shape */
+VALUE ray_shape_set_pos(VALUE self, VALUE pos) {
+   rb_check_frozen(self);
+   ray_rb2shape(self)->SetPosition(ray_convert_to_vector2(pos));
+   return pos;
+}
+
+/*
+  @overload add_point(pos, color = Ray::Color.white, outline_color = Ray::Color.none)
+    Adds a new point to the shape.
+
+    @param [Ray::Vector2, #to_vector2] Position of the point.
+    @param [Color] color Color of the shape at that point.
+    @param [Color] outline_color Color of the outline at that point.
+*/
+VALUE ray_shape_add_point(int argc, VALUE *argv, VALUE self) {
+   rb_check_frozen(self);
+
+   sf::Shape *shape = ray_rb2shape(self);
+
+   VALUE rb_pos, rb_color, rb_outline_color;
+
+   ray_vector2 pos;
+   ray_color color(255, 255, 255), outline_color(255, 255, 255);
+
+   rb_scan_args(argc, argv, "12", &rb_pos, &rb_color, &rb_outline_color);
+
+   pos = ray_convert_to_vector2(rb_pos);
+
+   if (!NIL_P(rb_color))
+      color = ray_rb2col(rb_color);
+
+   if (!NIL_P(rb_outline_color))
+      outline_color = ray_rb2col(rb_outline_color);
+
+   shape->AddPoint(pos, color, outline_color);
+   return self;
+}
+
+/*
+  @return [Integer] the amount of points in this shape.
+*/
+VALUE ray_shape_point_count(VALUE self) {
+   sf::Shape *shape = ray_rb2shape(self);
+   return INT2FIX(shape->GetPointsCount());
+}
+
+/*
+  Sets whether the shape should be filled. Defaults to true.
+*/
+VALUE ray_shape_set_filled(VALUE self, VALUE val) {
+   rb_check_frozen(self);
+
+   sf::Shape *shape = ray_rb2shape(self);
+   shape->EnableFill(RTEST(val));
+
+   return val;
+}
+
+/*
+  Sets whether the outline of the shape should be drawn. Defaults to true.
+*/
+VALUE ray_shape_set_outlined(VALUE self, VALUE val) {
+   rb_check_frozen(self);
+
+   sf::Shape *shape = ray_rb2shape(self);
+   shape->EnableOutline(RTEST(val));
+
+   return val;
+}
+
+/*
+  @overload set_position_of(id, pos)
+    Changes the position of a point.
+
+    @param [Integer] id Id of the point to modify.
+    @param [Ray::Vector2, #to_vector2] pos New position of that point.
+ */
+VALUE ray_shape_set_position_of(VALUE self, VALUE id, VALUE pos) {
+   rb_check_frozen(self);
+
+   sf::Shape *shape = ray_rb2shape(self);
+
+   unsigned int c_id = NUM2UINT(id);
+   if (c_id >= shape->GetPointsCount())
+      rb_raise(rb_eArgError, "%d out of bounds", c_id);
+
+   shape->SetPointPosition(c_id, ray_convert_to_vector2(pos));
+
+   return pos;
+}
+
+/*
+  @overload set_color_of(id, col)
+    Changes the color of a point.
+
+    @param [Integer] id Id of the point to modify.
+    @param [Color] col New color of that point.
+ */
+VALUE ray_shape_set_color_of(VALUE self, VALUE id, VALUE col) {
+   rb_check_frozen(self);
+
+   sf::Shape *shape = ray_rb2shape(self);
+
+   unsigned int c_id = NUM2UINT(id);
+   if (c_id >= shape->GetPointsCount())
+      rb_raise(rb_eArgError, "%d out of bounds", c_id);
+
+   shape->SetPointColor(c_id, ray_rb2col(col));
+   return col;
+}
+
+/*
+  @overload set_outline_of(id, col)
+    Changes the outline color of a point.
+
+    @param [Integer] id Id of the point to modify.
+    @param [Color] col New outline color of that point.
+*/
+VALUE ray_shape_set_outline_of(VALUE self, VALUE id, VALUE col) {
+   rb_check_frozen(self);
+
+   sf::Shape *shape = ray_rb2shape(self);
+
+   unsigned int c_id = NUM2UINT(id);
+   if (c_id >= shape->GetPointsCount())
+      rb_raise(rb_eArgError, "%d out of bounds", c_id);
+
+   shape->SetPointOutlineColor(c_id, ray_rb2col(col));
+   return col;
+}
+
+/*
+  Sets the width of the outline of this shape.
+*/
+VALUE ray_shape_set_outline_width(VALUE self, VALUE width) {
+   rb_check_frozen(self);
+
+   sf::Shape *shape = ray_rb2shape(self);
+   shape->SetOutlineThickness(NUM2INT(width));
+
+   return width;
+}
+
+/*
+  @overload position_of(id)
+    @return [Ray::Vector2] Position of that point.
+*/
+VALUE ray_shape_position_of(VALUE self, VALUE id) {
+   sf::Shape *shape = ray_rb2shape(self);
+
+   unsigned int c_id = NUM2UINT(id);
+   if (c_id >= shape->GetPointsCount())
+      return Qnil;
+
+   sf::Vector2f point = shape->GetPointPosition(c_id);
+   return ray_vector2_to_rb(point);
+}
+
+/*
+  @overload color_of(id)
+    @return [Color] Color of that point.
+*/
+VALUE ray_shape_color_of(VALUE self, VALUE id) {
+   sf::Shape *shape = ray_rb2shape(self);
+
+   unsigned int c_id = NUM2UINT(id);
+   if (c_id >= shape->GetPointsCount())
+      return Qnil;
+
+   return ray_col2rb(shape->GetPointColor(c_id));
+}
+
+/*
+  @overload outline_of(id)
+    @return [Color] Outline of that point.
+*/
+VALUE ray_shape_outline_of(VALUE self, VALUE id) {
+   sf::Shape *shape = ray_rb2shape(self);
+
+   unsigned int c_id = NUM2UINT(id);
+   if (c_id >= shape->GetPointsCount())
+      return Qnil;
+
+   return ray_col2rb(shape->GetPointOutlineColor(c_id));
+}
+
+/* @return [Float] Outline width of this shape */
+VALUE ray_shape_outline_width(VALUE self) {
+   sf::Shape *shape = ray_rb2shape(self);
+   return INT2FIX((int)(shape->GetOutlineThickness()));
+}
+
+/* @return [Float] Rotation applied to this shape when it is drawn (in degrees) */
+VALUE ray_shape_angle(VALUE self) {
+   sf::Shape *shape = ray_rb2shape(self);
+   return rb_float_new(shape->GetRotation());
+}
+
+/* Sets the rotation applied to this object when it is drawn (in degrees) */
+VALUE ray_shape_set_angle(VALUE self, VALUE angle) {
+   rb_check_frozen(self);
+
+   sf::Shape *shape = ray_rb2shape(self);
+   shape->SetRotation((float)NUM2DBL(angle));
+
+   return angle;
+}
+
+/* @return [Ray::Vector2] scale for width and height. */
+VALUE ray_shape_scale(VALUE self) {
+   sf::Shape *shape = ray_rb2shape(self);
+   sf::Vector2f scale(shape->GetScale());
+
+   return ray_vector2_to_rb(scale);
+}
+
+/* Sets scale for width and height, using a vector. */
+VALUE ray_shape_set_scale(VALUE self, VALUE val) {
+   rb_check_frozen(self);
+
+   sf::Shape *shape = ray_rb2shape(self);
+   shape->SetScale(ray_convert_to_vector2(val));
+
+   return val;
+}
+
+void Init_ray_shape() {
+   ray_cShape = rb_define_class_under(ray_mRay, "Shape", rb_cObject);
+   rb_define_alloc_func(ray_cShape, ray_alloc_shape);
+   rb_define_method(ray_cShape, "initialize_copy", ray_init_shape_copy, 1);
+
+   rb_define_singleton_method(ray_cShape, "line", ray_shape_line, -1);
+   rb_define_singleton_method(ray_cShape, "rectangle", ray_shape_rectangle, -1);
+   rb_define_singleton_method(ray_cShape, "circle", ray_shape_circle, -1);
+
+   rb_define_method(ray_cShape, "pos", ray_shape_pos, 0);
+   rb_define_method(ray_cShape, "pos=", ray_shape_set_pos, 1);
+
+   rb_define_method(ray_cShape, "add_point", ray_shape_add_point, -1);
+   rb_define_method(ray_cShape, "point_count", ray_shape_point_count, 0);
+
+   rb_define_method(ray_cShape, "filled=", ray_shape_set_filled, 1);
+   rb_define_method(ray_cShape, "outlined=", ray_shape_set_outlined, 1);
+
+   rb_define_method(ray_cShape, "outline_width=", ray_shape_set_outline_width, 1);
+   rb_define_method(ray_cShape, "outline_width", ray_shape_outline_width, 0);
+
+   rb_define_method(ray_cShape, "set_position_of", ray_shape_set_position_of, 2);
+   rb_define_method(ray_cShape, "set_color_of", ray_shape_set_color_of, 2);
+   rb_define_method(ray_cShape, "set_outline_of", ray_shape_set_outline_of, 2);
+
+   rb_define_method(ray_cShape, "position_of", ray_shape_position_of, 1);
+   rb_define_method(ray_cShape, "color_of", ray_shape_color_of, 1);
+   rb_define_method(ray_cShape, "outline_of", ray_shape_outline_of, 1);
+
+   rb_define_method(ray_cShape, "angle", ray_shape_angle, 0);
+   rb_define_method(ray_cShape, "angle=", ray_shape_set_angle, 1);
+
+   rb_define_method(ray_cShape, "scale", ray_shape_scale, 0);
+   rb_define_method(ray_cShape, "scale=", ray_shape_set_scale, 1);
+}