ray 0.0.1 → 0.1.0.pre1

data/ext/extconf.rb

@@ -1,111 +1,12 @@
 require 'mkmf'
 
-def find_macosx_framework(name)
-  paths = [
-           "/opt/local/Library/Frameworks",
-           "/Library/Frameworks",
-           "/Network/Library/Frameworks",
-           "/System/Library/Frameworks"
-          ]
-  paths.reverse!
+$CFLAGS << " -Wextra -Wall -Wno-unused-parameter -Wno-long-long"
 
-  paths.each do |dir|
-    dir = File.join(dir, "#{name}.framework")
-    next unless File.directory? dir
+# Fix errors from missing.h when compiling as C++
+have_func("ffs")
 
-    return dir
-  end
-
-  nil
-end
-
-def have_framework(name)
-  print "checking for framweork #{name}... "
-  ret = find_macosx_framework(name)
-
-  if ret
-    puts "yes"
-
-    $LDFLAGS << " -F#{File.dirname(ret)}"
-    $LDFLAGS << " -framework #{name}"
-    $CFLAGS  << " -I#{File.join(ret, "Headers")}"
-    $CFLAGS  << " -DHAVE_#{name.upcase}"
-  else
-    puts "no"
-  end
-  ret
-end
-
-def have_sdl_ext(name, header)
-  if res = have_framework(name)
-    ending = header.upcase.tr('/', '_').gsub(/\.H$/, "_H")
-    $CFLAGS << " -DHAVE_#{ending}"
-
-    return res
-  end
-
-  if res = have_library(name)
-    unless have_header(header) or have_header("SDL/#{header}")
-      return false
-    end
-
-    return res
-  end
-end
-
-$CFLAGS << " -pedantic -Wall -std=c99 -Wno-unused-parameter"
-
-unless RUBY_PLATFORM =~ /darwin/
-  unless have_library("SDL", "SDL_Init")
-    $stdder.puts "SDL not found"
-  end
-
-  unless (have_header("SDL/SDL.h") or have_header("SDL.h"))
-    $stderr.puts "SDL.h not found."
-    exit 1
-  end
-
-  unless have_library("SDLmain")
-    $stderr.puts "SDL_main not found."
-    exit 1
-  end
-
-  if have_library("SDL_image")
-    have_header("SDL/SDL_image.h") or have_header("SDL_image.h")
-  end
-
-  if have_library("SDL_gfx")
-    have_header("SDL/SDL_rotozoom.h") or have_header("SDL_rotozoom.h")
-  end
-
-  if have_library("SDL_ttf")
-    have_header("SDL/SDL_ttf.h") or have_header("SDL_ttf.h")
-  end
-
-  if have_library("SDL_mixer")
-    have_header("SDL/SDL_mixer.h") or have_header("SDL_mixer.h")
-  end
-
-  create_makefile("ray_ext")
-
-  data = File.read("Makefile").gsub("ray_osx.o", "")
-  open("Makefile", 'w') { |f| f.write(data) }
-else
-  $CFLAGS  << " #{ENV["CFLAGS"]}"
-  $LDFLAGS << " #{ENV["LDFLAGS"]}"
-
-  $CFLAGS << " -DRAY_USE_FRAMEWORK"
-
-  unless have_framework("SDL") and have_framework("Cocoa") and
-      have_framework("Foundation")
-    $stderr.puts "missing frameworks"
-    exit 1
-  end
-
-  have_sdl_ext("SDL_image", "SDL_image.h")
-  have_sdl_ext("SDL_gfx", "SDL_rotozoom.h")
-  have_sdl_ext("SDL_ttf", "SDL_ttf.h")
-  have_sdl_ext("SDL_mixer", "SDL_mixer.h")
+sfml_exts = %w(audio graphics window system)
 
+if sfml_exts.all? { |ext| have_library("sfml-#{ext}") }
   create_makefile("ray_ext")
 end

data/ext/font.cpp

@@ -0,0 +1,190 @@
+#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

@@ -0,0 +1,733 @@
+#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);
+}