ray 0.1.0.pre1 → 0.1.0

data/ext/font.cpp

@@ -1,190 +0,0 @@
-#include "ray.hpp"
-
-typedef struct {
-   unsigned long style;
-   int font_size;
-} ray_font_style;
-
-VALUE ray_cFont = Qnil;
-
-void ray_free_font(ray_font *font) {
-   delete font;
-}
-
-VALUE ray_font2rb(const ray_font &font) {
-   ray_font *ptr = new ray_font(font);
-   return Data_Wrap_Struct(ray_cFont, 0, ray_free_font, ptr);
-}
-
-ray_font *ray_rb2font(VALUE object) {
-   if (!RAY_IS_A(object, ray_cFont)) {
-      rb_raise(rb_eTypeError, "Can't convert %s into Ray::Font",
-               RAY_OBJ_CLASSNAME(object));
-   }
-
-   ray_font *ptr = NULL;
-   Data_Get_Struct(object, ray_font, ptr);
-
-   return ptr;
-}
-
-VALUE ray_alloc_font(VALUE self) {
-   ray_font *ptr = new ray_font;
-   VALUE ret = Data_Wrap_Struct(self, 0, ray_free_font, ptr);
-
-   return ret;
-}
-
-/* @return [Ray::Font] The default font */
-VALUE ray_font_default(VALUE self) {
-   return ray_font2rb(sf::Font::GetDefaultFont());
-}
-
-void ray_init_font_with_filename(VALUE self, VALUE filename) {
-   ray_font *font = NULL;
-   Data_Get_Struct(self, ray_font, font);
-
-   if (!font->LoadFromFile(StringValuePtr(filename))) {
-      rb_raise(rb_eRuntimeError, "Could not load the font");
-   }
-}
-
-void ray_init_font_with_io(VALUE self, VALUE io) {
-   ray_font *font = NULL;
-   Data_Get_Struct(self, ray_font, font);
-
-   VALUE string = rb_funcall2(io, RAY_METH("read"), 0, NULL);
-   char *content = StringValuePtr(string);
-
-   if (!font->LoadFromMemory(content, (int)RSTRING_LEN(string))) {
-      rb_raise(rb_eRuntimeError, "Could not load the font");
-   }
-}
-
-/*
-  Creates a new font.
-  @param [String, #read] arg Filename or IO object.
-*/
-VALUE ray_init_font(VALUE self, VALUE arg) {
-   if (rb_respond_to(arg, RAY_METH("to_str")))
-      ray_init_font_with_filename(self, rb_String(arg));
-   else if (rb_respond_to(arg, RAY_METH("read")))
-      ray_init_font_with_io(self, arg);
-   else {
-      rb_raise(rb_eTypeError, "Can't convert %s into String",
-               RAY_OBJ_CLASSNAME(arg));
-   }
-
-   return Qnil;
-}
-
-ray_font_style ray_parse_font_style(VALUE opts) {
-   ray_font_style style;
-
-   VALUE font_size = rb_hash_aref(opts, RAY_SYM("size"));
-   if (!NIL_P(font_size))
-      style.font_size = NUM2INT(font_size);
-   else
-      rb_raise(rb_eArgError, "Character size not specified");
-
-   style.style = sf::Text::Regular;
-   VALUE font_style = Qnil;
-   if (!NIL_P(font_style = rb_hash_aref(opts, RAY_SYM("style"))))
-      style.style = NUM2INT(font_style);
-
-   return style;
-}
-
-/* @return [Integer] the recommended spacing between lines for this font */
-VALUE ray_font_line_skip(VALUE self, VALUE size) {
-   ray_font *font = ray_rb2font(self);
-   return INT2FIX(font->GetLineSpacing(NUM2INT(size)));
-}
-
-VALUE ray_font_simple_size_of(VALUE self, VALUE str, VALUE opts) {
-   ray_font *font = ray_rb2font(self);
-   ray_font_style style = ray_parse_font_style(opts);
-
-   char *c_str = StringValuePtr(str);
-   sf::String string((uint32_t*)c_str);
-
-   sf::Text text(string, *font);
-   text.SetStyle(style.style);
-   text.SetCharacterSize(style.font_size);
-
-   ray_rect rect = RAY_RECT(text.GetRect());
-   return ray_vector2_to_rb(sf::Vector2f(rect.Width, rect.Height));
-}
-
-VALUE ray_font_simple_draw(VALUE self, VALUE str, VALUE hash) {
-   ray_font *font = ray_rb2font(self);
-   ray_font_style style = ray_parse_font_style(hash);
-
-   VALUE rb_color = rb_hash_aref(hash, RAY_SYM("color"));
-   ray_color c_color(255, 255, 255, 255);
-   if (!NIL_P(rb_color))
-      c_color = ray_rb2col(rb_color);
-
-   char *c_str = StringValuePtr(str);
-   sf::String string((uint32_t*)c_str);
-
-   sf::Text text(string, *font);
-   text.SetStyle(style.style);
-   text.SetCharacterSize(style.font_size);
-   text.SetColor(c_color);
-
-   ray_rect rect = RAY_RECT(text.GetRect());
-
-   ray_vector2 pos(0, 0);
-   VALUE rb_pos = rb_hash_aref(hash, RAY_SYM("at"));
-   if (NIL_P(rb_pos))
-      rb_pos = rb_hash_aref(hash, RAY_SYM("to"));
-   if (!NIL_P(rb_pos))
-      pos = ray_convert_to_vector2(rb_pos);
-
-   text.SetPosition(pos.x, pos.y);
-
-   VALUE on = rb_hash_aref(hash, RAY_SYM("on"));
-   if (NIL_P(on)) {
-      VALUE image_hash = rb_hash_new();
-      rb_hash_aset(image_hash, RAY_SYM("width"),  INT2FIX(rect.Width));
-      rb_hash_aset(image_hash, RAY_SYM("height"), INT2FIX(rect.Height));
-
-      on = rb_funcall(ray_cImage, RAY_METH("new"), 1, image_hash);
-   }
-
-   ray_image *image = ray_rb2image(on);
-   image->draw(text);
-
-   return on;
-}
-
-/*
-  Doucment-class: Ray::Font
-
-  Class used to draw text.
-  It can render text on an image:
-    font.draw("Hello world!", :on => image, :at => [10, 20]) # => image
-  Or create a new image containing the text, to use it later (which is
-  potentially better than rendering the same string a great amount of
-  times):
-    font.draw("Hello world!") # => a new image
-*/
-
-void Init_ray_font() {
-   ray_cFont = rb_define_class_under(ray_mRay, "Font", rb_cObject);
-   rb_define_alloc_func(ray_cFont, ray_alloc_font);
-   rb_define_method(ray_cFont, "initialize", ray_init_font, 1);
-
-   rb_define_singleton_method(ray_cFont, "default", ray_font_default, 0);
-
-   rb_define_method(ray_cFont, "line_skip", ray_font_line_skip, 1);
-   rb_define_method(ray_cFont, "simple_size_of", ray_font_simple_size_of, 2);
-
-   rb_define_method(ray_cFont, "simple_draw", ray_font_simple_draw, 2);
-
-   rb_define_const(ray_cFont, "STYLE_NORMAL", INT2FIX(sf::Text::Regular));
-   rb_define_const(ray_cFont, "STYLE_ITALIC", INT2FIX(sf::Text::Italic));
-   rb_define_const(ray_cFont, "STYLE_BOLD", INT2FIX(sf::Text::Bold));
-   rb_define_const(ray_cFont, "STYLE_UNDERLINE", INT2FIX(sf::Text::Underlined));
-}

data/ext/image.cpp

@@ -1,733 +0,0 @@
-#include "ray.hpp"
-
-VALUE ray_cImage = Qnil;
-
-ray_image::ray_image(bool should_be_screen):
-   is_screen(should_be_screen),
-   pixel_modifier(NULL)
-{}
-
-ray_image::~ray_image() {
-   if (pixel_modifier) delete pixel_modifier;
-}
-
-bool ray_image::create_with_size(int w, int h) {
-   return render_image.Create(w, h);
-}
-
-bool ray_image::create_with_filename(const std::string &filename) {
-   sf::Image temp_image;
-   if (!temp_image.LoadFromFile(filename))
-      return false;
-
-   sf::Sprite temp_sprite(temp_image);
-
-   if (!create_with_size(temp_image.GetWidth(), temp_image.GetHeight()))
-      return false;
-
-   render_image.Draw(temp_sprite);
-   sprite.SetImage(render_image.GetImage());
-
-   update();
-
-   return true;
-}
-
-bool ray_image::create_with_io(VALUE io) {
-   VALUE string = rb_funcall2(io, RAY_METH("read"), 0, NULL);
-   char *content = StringValuePtr(string);
-
-   sf::Image temp_image;
-   if (!temp_image.LoadFromMemory(content, RSTRING_LEN(string)))
-      return false;
-
-   sf::Sprite temp_sprite(temp_image);
-
-   if (!create_with_size(temp_image.GetWidth(), temp_image.GetHeight()))
-      return false;
-
-   render_image.Draw(temp_sprite);
-   sprite.SetImage(render_image.GetImage());
-
-   update();
-
-   return true;
-}
-
-bool ray_image::create_with_image(ray_image &src) {
-   sf::Sprite &src_sprite = src.get_sprite();
-   sf::Vector2f size = src_sprite.GetSize();
-
-   if (!create_with_size(src.width(), src.height()))
-      return false;
-
-   draw_image(src, ray_rect(0, 0, src.width(), src.height()),
-              ray_vector2(0, 0),
-              0.f, ray_vector2(1.f, 1.f));
-   update();
-
-   return true;
-}
-
-bool ray_image::save_as(const std::string &filename) const {
-   if (is_screen) {
-      sf::Image screen_copy;
-
-      if (!screen_copy.CopyScreen(ray_screen, sf::IntRect(0, 0, width(),
-                                                          height()))) {
-         return false;
-      }
-
-      return screen_copy.SaveToFile(filename);
-   }
-   else {
-      return render_image.GetImage().SaveToFile(filename);
-   }
-}
-
-int ray_image::width()  const { return target().GetWidth();  }
-int ray_image::height() const { return target().GetHeight(); }
-
-void ray_image::update() {
-   if (is_screen)
-      ray_screen.Display();
-   else
-      render_image.Display();
-}
-
-void ray_image::fill(sf::Color color) {
-   target().Clear(color);
-}
-
-void ray_image::draw(const sf::Drawable &drawable,
-                     sf::Shader *shader) {
-   if (shader)
-      target().Draw(drawable, *shader);
-   else
-      target().Draw(drawable);
-}
-
-void ray_image::draw_image(ray_image &image,
-                           const ray_rect &src_rect,
-                           const ray_vector2 &dest_pos,
-                           float angle, const ray_vector2 &zoom,
-                           sf::Shader *shader,
-                           const ray_color &color) {
-   sf::Image screen_copy;
-
-   if (image.is_screen) {
-      if (!screen_copy.CopyScreen(ray_screen, sf::IntRect(0, 0, image.width(),
-                                                          image.height()))) {
-         return;
-      }
-
-      sprite = sf::Sprite(screen_copy);
-   }
-   else {
-      sprite = sf::Sprite(image.render_image.GetImage());
-   }
-
-   sprite.SetSubRect(RAY_INT_RECT(src_rect));
-
-   sprite.SetPosition(dest_pos);
-
-   sprite.SetScale(zoom);
-   sprite.SetRotation(angle);
-
-   sprite.SetColor(color);
-
-   if (!shader)
-      target().Draw(sprite);
-   else
-      target().Draw(sprite, *shader);
-}
-
-ray_color ray_image::at(int x, int y) const {
-   if (pixel_modifier)
-      return pixel_modifier->GetPixel(x, y);
-
-   if (is_screen) {
-      sf::Image img;
-      img.CopyScreen(ray_screen, sf::IntRect(x, y, 1, 1));
-      return img.GetPixel(0, 0);
-   }
-
-   return render_image.GetImage().GetPixel(x, y);
-}
-
-bool ray_image::set_at(int x, int y, const ray_color &color) {
-   if (!pixel_modifier) return false;
-
-   pixel_modifier->SetPixel(x, y, color);
-   return true;
-}
-
-const uint8_t *ray_image::pixels() const {
-   return render_image.GetImage().GetPixelsPtr();
-}
-
-ray_rect ray_image::clip() const {
-   sf::FloatRect rect = target().GetView().GetViewport();
-   return ray_rect(rect.Left * width(), rect.Top * height(),
-                   rect.Width * width(), rect.Height * height());
-}
-
-void ray_image::set_clip(const ray_rect &other) {
-   sf::FloatRect rect(other.Left   / (float)width(),
-                      other.Top    / (float)height(),
-                      other.Width  / (float)width(),
-                      other.Height / (float)height());
-   sf::View view(target().GetDefaultView());
-   view.SetViewport(rect);
-
-   target().SetView(view);
-}
-
-bool ray_image::lock() {
-   if (pixel_modifier) return true;
-
-   if (is_screen) {
-      pixel_modifier = new sf::Image;
-
-      if (!pixel_modifier->CopyScreen(ray_screen,
-                                      sf::IntRect(0, 0, width(), height()))) {
-         delete pixel_modifier;
-         pixel_modifier = NULL;
-
-         return false;
-      }
-   }
-   else
-      pixel_modifier = new sf::Image(render_image.GetImage());
-
-   return true;
-}
-
-void ray_image::unlock() {
-   if (!pixel_modifier) return;
-
-   target().Clear(ray_color(0, 0, 0, 0));
-   sf::Sprite tmp_sprite(*pixel_modifier);
-   target().Draw(tmp_sprite);
-
-   delete pixel_modifier;
-   pixel_modifier = NULL;
-}
-
-void ray_image::activate() {
-   if (is_screen)
-      ray_screen.SetActive();
-   else
-      render_image.SetActive();
-}
-
-void ray_image::bind() {
-   render_image.GetImage().Bind();
-}
-
-bool ray_image::is_image() const {
-   return !is_screen;
-}
-
-const sf::Image &ray_image::image() const {
-   return render_image.GetImage();
-}
-
-bool ray_image::operator==(const ray_image &other) const {
-   return (&(target()) == &(other.target()));
-}
-
-sf::RenderTarget &ray_image::target() {
-   return is_screen ? (sf::RenderTarget&)ray_screen :
-      (sf::RenderTarget&)render_image;
-}
-
-const sf::RenderTarget &ray_image::target() const {
-   return is_screen ? (sf::RenderTarget&)ray_screen :
-      (sf::RenderTarget&)render_image;
-}
-
-ray_image *ray_rb2image(VALUE object) {
-   if (!RAY_IS_A(object, ray_cImage)) {
-      rb_raise(rb_eTypeError, "Can't convert %s into Ray::Image",
-               RAY_OBJ_CLASSNAME(object));
-   }
-
-   ray_image *ptr = NULL;
-   Data_Get_Struct(object, ray_image, ptr);
-
-   return ptr;
-}
-
-/*
-  @return [true, false] True if it is possible to draw on an image.
-    If this is false, many methods won't work as expected.
-*/
-VALUE ray_image_available(VALUE self) {
-   return sf::RenderImage::IsAvailable() ? Qtrue : Qfalse;
-}
-
-void ray_init_image_with_hash(VALUE self, VALUE arg) {
-   VALUE width = rb_hash_aref(arg, RAY_SYM("width"));
-   if (NIL_P(width)) width = rb_hash_aref(arg, RAY_SYM("w"));
-
-   VALUE height = rb_hash_aref(arg, RAY_SYM("height"));
-   if (NIL_P(height)) height = rb_hash_aref(arg, RAY_SYM("h"));
-
-   ray_image *image = ray_rb2image(self);
-   bool res = image->create_with_size(NUM2INT(width), NUM2INT(height));
-
-   if (!res)
-      rb_raise(rb_eRuntimeError, "Could not create the image");
-}
-
-void ray_init_image_with_filename(VALUE self, VALUE filename) {
-   char *c_filename = StringValuePtr(filename);
-   ray_image *image = ray_rb2image(self);
-
-   if (!image->create_with_filename(c_filename))
-      rb_raise(rb_eRuntimeError, "Could not create the image");
-}
-
-void ray_init_image_with_io(VALUE self, VALUE io) {
-   ray_image *image = ray_rb2image(self);
-   if (!image->create_with_io(io))
-      rb_raise(rb_eRuntimeError, "Could not create the image");
-}
-
-/*
-  Creates a new image.
-
-  @overload initialize(hash)
-    @option hash [Integer] :width Width of the surface
-    @option hash [Integer] :height Height of the surface
-
-    @option hash [Integer] :w Alias for width
-    @option hash [Integer] :h Alias for height
-
-  @overload initialize(filename)
-    Loads the image from a file.
-    @param [String, #to_str] filename The name of the file to open
-
-  @overload initialize(io)
-    Loads the image friom an IO object.
-    @param [IO, #read] io Object the data will be loaded from.
-*/
-VALUE ray_init_image(VALUE self, VALUE arg) {
-   if (RAY_IS_A(arg, rb_cHash))
-      ray_init_image_with_hash(self, arg);
-   else if (rb_respond_to(arg, RAY_METH("to_str")))
-      ray_init_image_with_filename(self, rb_String(arg));
-   else if (rb_respond_to(arg, RAY_METH("read")))
-      ray_init_image_with_io(self, arg);
-   else {
-      rb_raise(rb_eTypeError, "Can't convert %s into Hash",
-               RAY_OBJ_CLASSNAME(arg));
-   }
-
-   return Qnil;
-}
-
-VALUE ray_init_image_copy(VALUE self, VALUE obj) {
-   ray_image *img = ray_rb2image(self);
-   ray_image *src = ray_rb2image(obj);
-
-   if (!img->create_with_image(*src))
-      rb_raise(rb_eRuntimeError, "Could not create the image");
-
-   return self;
-}
-
-void ray_free_image(ray_image *ptr) {
-   delete ptr;
-}
-
-VALUE ray_alloc_image(VALUE self) {
-   ray_image *ptr = new ray_image(false);
-   VALUE ret = Data_Wrap_Struct(self, 0, ray_free_image, ptr);
-
-   return ret;
-}
-
-VALUE ray_create_screen() {
-   ray_image *ptr = new ray_image(true);
-   VALUE ret = Data_Wrap_Struct(ray_cImage, 0, ray_free_image, ptr);
-
-   return ret;
-}
-
-/*
-  @overload save_as(filename)
-    Saves the image in a file.
-*/
-VALUE ray_image_save_as(VALUE self, VALUE filename) {
-   if (!ray_rb2image(self)->save_as(StringValuePtr(filename))) {
-      rb_raise(rb_eRuntimeError, "Couldn't save image to file");
-   }
-
-   return self;
-}
-
-/*
-  @overload fill(col)
-    Fills the image with a given color.
-    @param [Ray::Color] col The color used to fill the image.
- */
-VALUE ray_image_fill(VALUE self, VALUE col) {
-   rb_check_frozen(self);
-
-   ray_image *img = ray_rb2image(self);
-   img->fill(ray_rb2col(col));
-
-   return self;
-}
-
-/* Updates the image. */
-VALUE ray_image_flip(VALUE self) {
-   rb_check_frozen(self);
-   ray_rb2image(self)->update();
-   return self;
-}
-
-/*
-  @overload blit(hash)
-    Blits the receiver on another image.
-
-    @option hash [Ray::Vector2, #to_vector2] :at Position where the receiver
-      should be drawn.
-    @option hash [Ray::Rect, Array] :rect Rects that will be copied.
-                                          If an array is given, it
-                                          passed to Ray::Rect.new.
-                                          If the size is (0, 0), it will
-                                          be reset to the image's size.
-    @option hash [Ray::Rect, Array] :from Alias for rect
-
-    @option hash [Ray::Image, required] :on The image on which the receiver should
-                                            be drawn.
-
-    @option hash [Ray::Image] :to Alias for on.
-
-    @option hash [Float] :angle Rotation in degrees.
-    @option hash [Ray::Vector2, Float] :zoom Zoom level. If a float is
-      specified, Vector2[zoom, zoom] will be used.
-
-    @option hash [Ray::Shader] :shader Shader to be used.
-
-    @option hash [Ray::Color] :color (Ray::Color.white) Color used, affecting
-      the whole image. Each pixel is multiplied by this color.
- */
-VALUE ray_image_blit(VALUE self, VALUE hash) {
-   ray_image *origin = ray_rb2image(self);
-
-   ray_rect from_rect;
-   ray_vector2 dest_pos;
-
-   VALUE pos = rb_hash_aref(hash, RAY_SYM("at"));
-   if (!NIL_P(pos))
-      dest_pos = ray_convert_to_vector2(pos);
-
-   VALUE rect = rb_hash_aref(hash, RAY_SYM("rect"));
-   if (NIL_P(rect)) rect = rb_hash_aref(hash, RAY_SYM("from"));
-
-   if (!NIL_P(rect))
-      from_rect = ray_convert_to_rect(rect);
-
-   VALUE surf = rb_hash_aref(hash, RAY_SYM("on"));
-   if (surf == Qnil) surf = rb_hash_aref(hash, RAY_SYM("to"));
-
-   rb_check_frozen(surf);
-
-   ray_image *target = ray_rb2image(surf);
-
-   VALUE rb_angle = Qnil, rb_zoom = Qnil;
-   float angle = 0.0f;
-   ray_vector2 zoom(1.0f, 1.0f);
-
-   if (!NIL_P(rb_angle = rb_hash_aref(hash, RAY_SYM("angle"))))
-      angle = (float)NUM2DBL(rb_angle);
-
-   if (!NIL_P(rb_zoom = rb_hash_aref(hash, RAY_SYM("zoom")))) {
-      if (RAY_IS_A(rb_zoom, rb_cFloat)) {
-         float zoom_val = (float)NUM2DBL(rb_zoom);
-         zoom = ray_vector2(zoom_val, zoom_val);
-      }
-      else
-         zoom = ray_convert_to_vector2(rb_zoom);
-   }
-
-   if (from_rect.Width == 0 && from_rect.Height == 0) {
-      from_rect.Width  = origin->width();
-      from_rect.Height = origin->height();
-   }
-
-   VALUE rb_shader = rb_hash_aref(hash, RAY_SYM("shader"));
-   sf::Shader *shader = NULL;
-   if (!NIL_P(rb_shader))
-      shader = ray_rb2shader(rb_shader);
-
-   ray_color color(255, 255, 255);
-   VALUE rb_color = rb_hash_aref(hash, RAY_SYM("color"));
-   if (!NIL_P(rb_color))
-      color = ray_rb2col(rb_color);
-
-   target->draw_image(*origin, from_rect, dest_pos, angle, zoom,
-                      shader, color);
-
-   return surf;
-}
-
-/* @return [Integer] Width of the surface */
-VALUE ray_image_width(VALUE self) {
-   return INT2FIX(ray_rb2image(self)->width());
-}
-
-/* @return [Integer] Height of the surface */
-VALUE ray_image_height(VALUE self) {
-   return INT2FIX(ray_rb2image(self)->height());
-}
-
-/*
-  @overload ==(obj)
-    @return [true, false] true if obj manipulates the same surface as the
-                          receiver.
-*/
-VALUE ray_image_is_equal(VALUE self, VALUE obj) {
-   if (!RAY_IS_A(obj, ray_cImage))
-      return Qfalse;
-
-   ray_image *first_img = ray_rb2image(self);
-   ray_image *sec_img   = ray_rb2image(obj);
-
-   return (*first_img == *sec_img) ? Qtrue : Qfalse;
-}
-
-
-VALUE ray_image_ensure_unlock(VALUE self) {
-   rb_check_frozen(self);
-   ray_rb2image(self)->unlock();
-   return self;
-}
-
-/*
-  Locks the image (allow pixel-per-pixel modifications).
-  Don't forget to call unlock when you're done. You can also
-  pass a bock which will be called before the image gets unlocked
-  automatically.
-*/
-VALUE ray_image_lock(VALUE self) {
-   rb_check_frozen(self);
-
-   ray_image *image = ray_rb2image(self);
-   if (!image->lock())
-      rb_raise(rb_eRuntimeError, "Couldn't lock the image");
-
-   if (rb_block_given_p())
-      rb_ensure(rb_yield, Qnil, ray_image_ensure_unlock, self);
-
-   return self;
-}
-
-/*
-  Unlocks the image. You must call this once you are done
-  modifying the image.
-*/
-VALUE ray_image_unlock(VALUE self) {
-   return ray_image_ensure_unlock(self);
-}
-
-/*
-  @overload [](x, y)
-    @return [Ray::Color, nil] Pixel at (x, y). Nil if the point is outside the
-                              image.
-*/
-VALUE ray_image_at(VALUE self, VALUE rb_x, VALUE rb_y) {
-   ray_image *image = ray_rb2image(self);
-
-   int x = NUM2INT(rb_x);
-   int y = NUM2INT(rb_y);
-
-   /* (w, h) is not a valid point. Surfaces use 0-based indexing. */
-   if (x >= image->width() || y >= image->height())
-      return Qnil;
-
-   return ray_col2rb(image->at(x, y));
-}
-
-/*
-  @overload []=(x, y, color)
-    Sets the color of the point at (x, y)
-    @raise ArgumentError If (x, y) is outside the image.
-    @note Don't call this if the image isn't locked.
-    @example
-      img.lock { img[0, 0] = Ray::Color.red }
-*/
-VALUE ray_image_set_at(VALUE self, VALUE rb_x, VALUE rb_y, VALUE rb_col) {
-   rb_check_frozen(self);
-
-   ray_image *image = ray_rb2image(self);
-
-   int x = NUM2INT(rb_x);
-   int y = NUM2INT(rb_y);
-
-   if (x >= image->width() || y >= image->height()) {
-      VALUE inspect = rb_inspect(self);
-      rb_raise(rb_eArgError, "(%d, %d) is outside %s",
-               x, y, StringValuePtr(inspect));
-   }
-
-   if (!image->set_at(x, y, ray_rb2col(rb_col)))
-      rb_raise(rb_eRuntimeError, "Trying to set pixel on a non locked image");
-
-   return rb_col;
-}
-
-VALUE ray_image_ensure_unclip(VALUE ary) {
-   ray_image *image = ray_rb2image(rb_ary_entry(ary, 0));
-   ray_rect    rect = ray_rb2rect(rb_ary_entry(ary, 1));
-
-   image->set_clip(rect);
-   rb_gc_unregister_address(&ary);
-
-   return Qnil;
-}
-
-/*
-  @overload clip
-    @return [Ray::Rect] The current clipping rect
-
-  @overload clip(rect)
-    Changes the clipping rect (the rect which will be changed if something is
-    drawn on this image, the rest of the image being ignored.)
-
-    If a block is given, it is executed, and the old clipping rect is reset
-    afterwards.
-
-    @param [Ray::Rect, Array<Integer>] rect New clipping rect.
-*/
-VALUE ray_image_clip(int argc, VALUE *argv, VALUE self) {
-   VALUE rb_rect = Qnil;
-   rb_scan_args(argc, argv, "01", &rb_rect);
-
-   ray_image *image = ray_rb2image(self);
-
-   ray_rect old_rect = image->clip();
-
-   if (NIL_P(rb_rect))
-      return ray_rect2rb(old_rect);
-
-   rb_check_frozen(self);
-
-   ray_rect rect = ray_convert_to_rect(rb_rect);
-   image->set_clip(rect);
-
-   if (rb_block_given_p()) {
-      VALUE ary = rb_ary_new();
-      rb_ary_push(ary, self);
-      rb_ary_push(ary, ray_rect2rb(old_rect));
-
-      rb_gc_register_address(&ary);
-
-      rb_ensure(rb_yield, Qnil, ray_image_ensure_unclip, ary);
-   }
-
-   return ray_rect2rb(rect);
-}
-
-/*
-  Binds the image to use it as an OpenGL texture.
-*/
-VALUE ray_image_bind(VALUE self) {
-   ray_image *img = ray_rb2image(self);
-   if (!img->is_image())
-      rb_raise(rb_eRuntimeError, "Can't bind screen");
-
-   img->bind();
-   return self;
-}
-
-/* Activates the image to draw on it using OpenGL. */
-VALUE ray_image_activate(VALUE self) {
-   rb_check_frozen(self);
-   ray_rb2image(self)->activate();
-
-   return self;
-}
-
-/*
-  @overload draw_shape(shape, shader = nil, color = Ray::Color.white)
-    Draws a shape on the image
-
-    @param [Ray::Shape] shape The shape to be drawn
-    @param [Ray::Shader] shader The shader to use with the shape
-    @param [Ray::Color] color The color used to multiply each pixel of the
-      shape.
-*/
-VALUE ray_image_draw_shape(int argc, VALUE *argv, VALUE self) {
-   rb_check_frozen(self);
-
-   VALUE shape, shader, color;
-   rb_scan_args(argc, argv, "12", &shape, &shader, &color);
-
-   rb_check_frozen(self);
-
-   ray_image *image = ray_rb2image(self);
-
-   sf::Shape *c_shape = ray_rb2shape(shape);
-   sf::Shader *c_shader = NULL;
-   if (!NIL_P(shader)) c_shader = ray_rb2shader(shader);
-
-   ray_color c_color(sf::Color::White);
-   if (!NIL_P(color)) c_color = ray_rb2col(color);
-
-   c_shape->SetColor(c_color);
-
-   image->draw(*c_shape, c_shader);
-   return self;
-}
-
-/*
-  @overload draw_drawable(drawable)
-    Draws a drawable on the image
-*/
-VALUE ray_image_draw_drawable(VALUE self, VALUE drawable) {
-   rb_check_frozen(self);
-
-   ray_drawable *c_drawable = ray_rb2drawable(drawable);
-   c_drawable->render(self);
-
-   return self;
-}
-
-void Init_ray_image() {
-   ray_cImage = rb_define_class_under(ray_mRay, "Image", rb_cObject);
-   rb_define_alloc_func(ray_cImage, ray_alloc_image);
-   rb_define_method(ray_cImage, "initialize", ray_init_image, 1);
-   rb_define_method(ray_cImage, "initialize_copy", ray_init_image_copy, 1);
-
-   rb_define_singleton_method(ray_cImage, "available?", ray_image_available, 0);
-
-   rb_define_method(ray_cImage, "save_as", ray_image_save_as, 1);
-
-   rb_define_method(ray_cImage, "fill", ray_image_fill, 1);
-   rb_define_method(ray_cImage, "flip", ray_image_flip, 0);
-
-   rb_define_method(ray_cImage, "blit", ray_image_blit, 1);
-
-   rb_define_method(ray_cImage, "width", ray_image_width, 0);
-   rb_define_method(ray_cImage, "height", ray_image_height, 0);
-
-   rb_define_method(ray_cImage, "==", ray_image_is_equal, 1);
-
-   rb_define_method(ray_cImage, "lock", ray_image_lock, 0);
-   rb_define_method(ray_cImage, "unlock", ray_image_unlock, 0);
-   rb_define_method(ray_cImage, "[]", ray_image_at, 2);
-   rb_define_method(ray_cImage, "[]=", ray_image_set_at, 3);
-
-   rb_define_method(ray_cImage, "clip", ray_image_clip, -1);
-
-   rb_define_method(ray_cImage, "bind", ray_image_bind, 0);
-   rb_define_method(ray_cImage, "activate", ray_image_activate, 0);
-
-   rb_define_method(ray_cImage, "draw_shape", ray_image_draw_shape, -1);
-   rb_define_method(ray_cImage, "draw_drawable", ray_image_draw_drawable, 1);
-}