ray 0.0.0.pre2 → 0.0.1

data/ext/image.c

@@ -69,6 +69,36 @@ void ray_init_image_with_filename(VALUE self, VALUE filename) {
 #endif
 }
 
+void ray_init_image_with_io(VALUE self, VALUE io) {
+   VALUE string = rb_funcall2(io, RAY_METH("read"), 0, NULL);
+   char *content = StringValuePtr(string);
+
+   SDL_RWops *data = SDL_RWFromMem(content, (int)RSTRING_LEN(string));
+   
+   if (!data) {
+      rb_raise(rb_eRuntimeError, "Could not create image data (%s)",
+               SDL_GetError());
+   }
+
+   ray_image *image = ray_rb2image(self);
+
+#ifdef HAVE_SDL_IMAGE
+   image->surface = IMG_Load_RW(data, 1);
+   
+   if (!image->surface) {
+      rb_raise(rb_eRuntimeError, "Could not create the image (%s)",
+               IMG_GetError());
+   }
+#else
+   image->surface = SDL_LoadBMP_RW(data, 1);
+
+   if (!image->surface) {
+      rb_raise(rb_eRuntimeError, "Could not create the image (%s)",
+               SDL_GetError());
+   }
+#endif
+}
+
 /*
   Creates a new image.
 
@@ -80,20 +110,26 @@ void ray_init_image_with_filename(VALUE self, VALUE filename) {
     @option hash [Integer] :h Alias for height
 
     @option hash [Integer] :bits_per_pixel See Ray.create_window
-    @option hash [Integer] :pp Alias for bits_per_pixel
+    @option hash [Integer] :bpp Alias for bits_per_pixel
 
     @option hash [true, false] :hw_surface See Ray.create_window
     @option hash [true, false] :sw_surface See Ray.create_window
 
   @overload initialize(filename)
     Loads the image from a file.
-    @param [String, #to_str] filename The name of the file to open 
- */
+    @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));
@@ -102,8 +138,21 @@ VALUE ray_init_image(VALUE self, VALUE arg) {
    return Qnil;
 }
 
+VALUE ray_init_image_copy(VALUE self, VALUE obj) {
+   ray_image *img = ray_rb2image(self);
+   
+   SDL_Surface *src = ray_rb2surface(obj);
+   img->surface = SDL_ConvertSurface(src, src->format, src->flags);
+   if (!img->surface) {
+      rb_raise(rb_eRuntimeError, "Could not create the image (%s)",
+               SDL_GetError());
+   }
+
+   return self;
+}
+
 void ray_free_image(ray_image *ptr) {
-   if (ptr->mustFree && ptr->surface) SDL_FreeSurface(ptr->surface);
+   if (ptr->must_free && ptr->surface) SDL_FreeSurface(ptr->surface);
    free(ptr);
 }
 
@@ -111,10 +160,18 @@ VALUE ray_create_image(SDL_Surface *surface) {
    ray_image *ptr = malloc(sizeof(ray_image));
    VALUE ret = Data_Wrap_Struct(ray_cImage, 0, ray_free_image, ptr);
 
-   ptr->self    = ret;
-   ptr->surface = surface;
+   ptr->surface   = surface;
+   ptr->must_free = 0;
+
+   return ret;
+}
+
+VALUE ray_create_gc_image(SDL_Surface *surface) {
+   ray_image *ptr = malloc(sizeof(ray_image));
+   VALUE ret = Data_Wrap_Struct(ray_cImage, 0, ray_free_image, ptr);
 
-   ptr->mustFree = 0;
+   ptr->surface   = surface;
+   ptr->must_free = 1;
 
    return ret;
 }
@@ -123,10 +180,8 @@ VALUE ray_alloc_image(VALUE self) {
    ray_image *ptr = malloc(sizeof(ray_image));
    VALUE ret = Data_Wrap_Struct(self, 0, ray_free_image, ptr);
 
-   ptr->self    = ret;
    ptr->surface = NULL;
-
-   ptr->mustFree = 1;
+   ptr->must_free = 1;
 
    return ret;
 }
@@ -154,28 +209,32 @@ VALUE ray_image_flip(VALUE self) {
 }
 
 /*
-  Blits the receiver on another image.
+  @overload blit(hash)
+    Blits the receiver on another image.
   
-  @option hash [Ray::Rect, Array] :at Rects in which the image will be
-                                      drawn. If an array is given, it
-                                      passed to Ray::Rect.new. Only the
-                                      position is read.
-  @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, required] :to Alias for on.
+    @option hash [Ray::Rect, Array] :at Rects in which the image will be
+                                        drawn. If an array is given, it
+                                        passed to Ray::Rect.new. Only the
+                                        position is read.
+    @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, required] :to Alias for on.
+
+    @option hash [Float] :angle Rotation in degrees.
+    @option hash [Float] :zoom Zoom level. 1.0 for the current size.
 */
 VALUE ray_image_blit(VALUE self, VALUE hash) {
    SDL_Surface *origin = ray_rb2surface(self);
 
-   SDL_Rect from_rect = {0, 0, origin->w, origin->h};
+   SDL_Rect from_rect = {0, 0, 0, 0};
    SDL_Rect to_rect   = {0, 0, 0, 0};
    
    VALUE rect = rb_hash_aref(hash, RAY_SYM("at"));
@@ -202,21 +261,64 @@ VALUE ray_image_blit(VALUE self, VALUE hash) {
                RAY_OBJ_CLASSNAME(rect));
    }
 
+   VALUE surf = rb_hash_aref(hash, RAY_SYM("on"));
+   if (surf == Qnil) surf = rb_hash_aref(hash, RAY_SYM("to"));
+
+   /* avoid raising an exception, which would prevent us from  freeing  the surface */
+   SDL_Surface *target = ray_rb2surface(surf);
+
+#ifdef HAVE_SDL_GFX
+   VALUE rb_angle = Qnil, rb_zoom = Qnil;
+   double angle = 0.0, zoom = 1.0; 
+
+   if (!NIL_P(rb_angle = rb_hash_aref(hash, RAY_SYM("angle"))))
+      angle = NUM2DBL(rb_angle);
+
+   if (!NIL_P(rb_zoom = rb_hash_aref(hash, RAY_SYM("zoom"))))
+      zoom = NUM2DBL(rb_zoom);
+
+   if (!NIL_P(rb_angle) || !NIL_P(rb_zoom)) {
+      SDL_Surface *res = rotozoomSurface(origin, angle, zoom, 1);
+      if (!res) {
+         rb_raise(rb_eRuntimeError, "Could not create the image (%s)",
+                  SDL_GetError());
+      }
+
+      if (from_rect.w == 0 && from_rect.h == 0) {
+         from_rect.w = res->w;
+         from_rect.h = res->h;
+      }
+
+      if (SDL_BlitSurface(res, &from_rect,  target, &to_rect) == -1) {
+         SDL_FreeSurface(res); /* Don't leak when an error occurs */
+         rb_raise(rb_eRuntimeError, "Couldn't blit the image (%s)",
+                  SDL_GetError());
+      }
+
+      SDL_FreeSurface(res);
+      
+      return surf;
+   }
+#endif
+
    if (from_rect.w == 0 && from_rect.h == 0) {
       from_rect.w = origin->w;
       from_rect.h = origin->h;
    }
 
-   VALUE surf = rb_hash_aref(hash, RAY_SYM("on"));
-   if (surf == Qnil) surf = rb_hash_aref(hash, RAY_SYM("to"));
-   SDL_BlitSurface(origin, &from_rect,  ray_rb2surface(surf), &to_rect);
+   if (SDL_BlitSurface(origin, &from_rect, target,
+                       &to_rect) == -1) {
+      rb_raise(rb_eRuntimeError, "Couldn't blit the image (%s)",
+                  SDL_GetError());
+   }
 
    return surf;
 }
 
 /*
-  Sets the alpha transparency.
-  @param [Integer, 0..255] alpha the new transparency
+  @overload alpha=(alpha)
+    Sets the alpha transparency.
+    @param [Integer, 0..255] alpha the new transparency
 */
 VALUE ray_image_set_alpha(VALUE self, VALUE alpha) {
    SDL_SetAlpha(ray_rb2surface(self), SDL_SRCALPHA | SDL_RLEACCEL,
@@ -245,14 +347,529 @@ VALUE ray_image_height(VALUE self) {
 
 /* @return [Integer] Bits per pixel */
 VALUE ray_image_bpp(VALUE self) {
-   return INT2FIX(ray_rb2surface(self)->format->BitsPerPixel);
+   SDL_Surface *surf = ray_rb2surface(self);
+   if (surf->format)
+      return INT2FIX(ray_rb2surface(self)->format->BitsPerPixel);
+   return Qnil;
+}
+
+/*
+  @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;
+
+   SDL_Surface *first_surface = ray_rb2surface(self);
+   SDL_Surface *sec_surface = ray_rb2surface(obj);
+
+   return (first_surface == sec_surface) ? Qtrue : Qfalse;
+}
+
+VALUE ray_image_ensure_unlock(VALUE self) {
+   SDL_Surface *surface = ray_rb2surface(self);
+   SDL_UnlockSurface(surface);
+
+   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) {
+   SDL_Surface *surface = ray_rb2surface(self);
+   SDL_LockSurface(surface);
+
+   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) {
+   SDL_Surface *surface = ray_rb2surface(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 >= surface->w || y >= surface->h)
+      return Qnil;
+
+   int bytes = surface->format->BytesPerPixel;
+   
+   uint8_t *pix = (uint8_t*)surface->pixels + y * surface->pitch + x * bytes;
+   
+   uint32_t res;
+   switch (bytes) {
+      case 1:
+         res = *pix;
+         break;
+      case 2:
+         res = *(uint16_t*)pix;
+         break;
+      case 3:
+         if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
+            res = pix[0] << 16 | pix[1] << 8 | pix[2];
+         else
+            res = pix[0] | pix[1] << 8 | pix[2] << 16;
+         break;
+      case 4:
+         res = *(uint32_t*)pix;
+         break;
+      default: /* should never happen */
+         res = 0;
+         break;
+   }
+
+   ray_color col;
+   SDL_GetRGBA(res, surface->format, &(col.r), &(col.g), &(col.b), &(col.a));
+   
+   return ray_col2rb(col);
+}
+
+/*
+  @overload [](x, y, color)
+    Sets the color of the point at (x, y)
+    @raise ArgumentError If (x, y) is outside the image.
+*/
+VALUE ray_image_set_at(VALUE self, VALUE rb_x, VALUE rb_y, VALUE rb_col) {
+   SDL_Surface *surface = ray_rb2surface(self);
+      
+   int x = NUM2INT(rb_x);
+   int y = NUM2INT(rb_y);
+
+   if (x >= surface->w || y >= surface->h) {
+      VALUE inspect = rb_inspect(self);
+      rb_raise(rb_eArgError, "(%d, %d) is outside %s",
+               x, y, StringValuePtr(inspect));
+   }
+
+   int bytes = surface->format->BytesPerPixel;
+   
+   uint8_t *pix = (uint8_t*)surface->pixels + y * surface->pitch + x * bytes;
+   
+   ray_color col = ray_rb2col(rb_col);
+
+   uint32_t val = SDL_MapRGBA(surface->format, col.r, col.g, col.b, col.a);
+
+   switch (bytes) {
+      case 1:
+         *pix = val;
+         break;
+      case 2:
+         *(uint16_t*)pix = val;
+         break;
+      case 3:
+         if (SDL_BYTEORDER == SDL_BIG_ENDIAN) {
+            pix[0] = (val >> 16) & 0xff;
+            pix[1] = (val >> 8) & 0xff;
+            pix[2] = val & 0xff;
+         }
+         else {
+            pix[0] = val & 0xff;
+            pix[1] = (val >> 8) & 0xff;
+            pix[2] = (val >> 16) & 0xff;
+         }
+         break;
+      case 4:
+         *(uint32_t*)pix = val;
+         break;
+   }
+
+   return rb_col;
+}
+
+VALUE ray_image_ensure_unclip(VALUE ary) {
+   SDL_Surface *surface = ray_rb2surface(rb_ary_entry(ary, 0));
+   SDL_Rect rect = ray_rb2rect(rb_ary_entry(ary, 1));
+
+   SDL_SetClipRect(surface, &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);
+
+   SDL_Rect old_rect;
+   SDL_GetClipRect(ray_rb2surface(self), &old_rect);
+
+   if (NIL_P(rb_rect))
+      return ray_rect2rb(old_rect);
+   
+   SDL_Rect rect = ray_convert_to_rect(rb_rect);
+   SDL_SetClipRect(ray_rb2surface(self), &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);
+}
+
+#ifdef HAVE_SDL_GFX
+
+/*
+  @overload rotozoom(angle, zoom)
+    Rotates and zoomes on the image.
+    @param [Float] angle Angle in degrees
+    @param [Float] zoom
+    @return [SDL::Image] the modified image.
+    
+    @see #rotozoom!
+*/
+VALUE ray_image_rotozoom(VALUE self, VALUE angle, VALUE zoom) {
+   SDL_Surface *surface = ray_rb2surface(self);
+   SDL_Surface *res = rotozoomSurface(surface, NUM2DBL(angle),
+                                      NUM2DBL(zoom), 1);
+   
+   if (!res) {
+      rb_raise(rb_eRuntimeError, "Could not create the image (%s)",
+               SDL_GetError());
+   }
+
+   return ray_create_gc_image(res);
+}
+
+/*
+  @overload rotozoom!(angle, zoom)
+    Rotates and zoomes on the image, but does not create a new instance
+    of Ray::Image, which may be better for memory management.
+    
+    Notice Ray.create_window(...).rotozoom!(...) will not modify
+    the image used as the screen.
+    
+    @see #rotozoom
+*/
+VALUE ray_image_rotozoom_bang(VALUE self, VALUE angle, VALUE zoom) {
+   ray_image *img = ray_rb2image(self);
+   SDL_Surface *res = rotozoomSurface(img->surface, NUM2DBL(angle),
+                                      NUM2DBL(zoom), 1);
+   
+   if (!res) {
+      rb_raise(rb_eRuntimeError, "Could not create the image (%s)",
+               SDL_GetError());
+   }
+
+   if (img->must_free)
+      SDL_FreeSurface(img->surface);
+
+   img->surface   = res;
+   img->must_free = 1;
+
+   return self;
+}
+
+/*
+  @overload draw_pixel(point, color)
+    Draws a point.
+
+    @param [Ray::Rect, Array<Integer>] point The point which should be changed.
+    @param [Ray::Color] color Its new color.
+*/
+VALUE ray_image_draw_pixel(VALUE self, VALUE rb_point, VALUE rb_color) {
+   SDL_Surface *surface = ray_rb2surface(self);
+
+   SDL_Rect point = ray_convert_to_rect(rb_point);
+   ray_color color = ray_rb2col(rb_color);
+   
+   pixelRGBA(surface, point.x, point.y, color.r, color.g, color.b, color.a);
+
+   return self;
+}
+
+/*
+  @overload draw_line(p1, p2, color)
+    Draws a line.
+  
+    @param [Ray::Rect, Array<Integer>] p1 First point of the line.
+    @param [Ray::Rect, Array<Integer>] p2 Second point of the line.
+    @param [Ray::Color] color Color of the line.
+*/
+VALUE ray_image_draw_line(VALUE self, VALUE p1, VALUE p2, VALUE rb_color) {
+   SDL_Surface *surface = ray_rb2surface(self);
+
+   SDL_Rect first_point  = ray_convert_to_rect(p1);
+   SDL_Rect second_point = ray_convert_to_rect(p2);   
+   ray_color color = ray_rb2col(rb_color);
+   
+   aalineRGBA(surface, first_point.x, first_point.y,
+              second_point.x, second_point.y,
+              color.r, color.g, color.b, color.a);
+   return self;
+}
+
+/*
+  @overload draw_rect(rect, color)
+    Draws a rect.
+
+    @param [Ray::Rect, Array<Integer>] rect Rect to draw
+    @param [Ray::Color] color color of the rect
+*/
+VALUE ray_image_draw_rect(VALUE self, VALUE rb_rect, VALUE rb_color) {
+   SDL_Surface *surface = ray_rb2surface(self);
+   SDL_Rect rect = ray_convert_to_rect(rb_rect);
+   ray_color color = ray_rb2col(rb_color);
+
+   rectangleRGBA(surface, rect.x, rect.y, rect.x + rect.w, rect.y + rect.h,
+                 color.r, color.g, color.b, color.a);
+
+   return self;
+}
+
+/*
+  @overload draw_filled_rect(rect, color)
+    Draws a filled rect.
+
+    @param [Ray::Rect, Array<Integer>] rb_rect Rect to draw.
+    @param [Ray::Color] rb_color Color of the rect.
+*/
+VALUE ray_image_draw_filled_rect(VALUE self, VALUE rb_rect, VALUE rb_color) {
+   SDL_Surface *surface = ray_rb2surface(self);
+   SDL_Rect rect = ray_convert_to_rect(rb_rect);
+   ray_color color = ray_rb2col(rb_color);
+
+   boxRGBA(surface, rect.x, rect.y, rect.x + rect.w, rect.y + rect.h,
+           color.r, color.g, color.b, color.a);
+
+   return self;
+}
+
+/*
+  @overload draw_circle(center, radius, color)
+    Draws a circle
+
+    @param [Ray::Rect, Array<Integer>] center Center of the circle.
+    @param [Integer] radius Radius of the circle.
+    @param [Ray::Color] color Color of the circle.
+*/
+VALUE ray_image_draw_circle(VALUE self, VALUE center, VALUE radius,
+                            VALUE rb_color) {
+   SDL_Surface *surface = ray_rb2surface(self);
+   SDL_Rect rect = ray_convert_to_rect(center);
+   ray_color color = ray_rb2col(rb_color);
+
+   aacircleRGBA(surface, rect.x, rect.y, NUM2INT(radius),
+                color.r, color.g, color.b, color.a);
+
+   return self;
+}
+
+/*
+  @overload draw_filled_circle(center, radius, color)
+    Draws a filled circle
+
+    @param [Ray::Rect, Array<Integer>] center Center of the circle.
+    @param [Integer] radius Radius of the circle.
+    @param [Ray::Color] color Color of the circle.
+*/
+VALUE ray_image_draw_filled_circle(VALUE self, VALUE center, VALUE radius,
+                            VALUE rb_color) {
+   SDL_Surface *surface = ray_rb2surface(self);
+   SDL_Rect rect = ray_convert_to_rect(center);
+   ray_color color = ray_rb2col(rb_color);
+
+   filledCircleRGBA(surface, rect.x, rect.y, NUM2INT(radius),
+                color.r, color.g, color.b, color.a);
+
+   return self;
+}
+
+/*
+  @overload draw_ellipse(rect, color)
+    Draws an ellipse.
+  
+    @param [Ray::Rect, Array<Integer>] rect Rect in which the ellipse should be drawn.
+    @param [Ray::Color] color Color in which the ellipse should be drawn.
+*/
+VALUE ray_image_draw_ellipse(VALUE self, VALUE rb_rect, VALUE rb_color) {
+   SDL_Surface *surface = ray_rb2surface(self);
+   SDL_Rect rect = ray_convert_to_rect(rb_rect);
+   ray_color color = ray_rb2col(rb_color);
+
+   aaellipseRGBA(surface, rect.x + rect.w / 2,
+                 rect.y + rect.h / 2, rect.w / 2, rect.h / 2,
+                 color.r, color.g, color.b, color.a);
+   return self;
+}
+
+/*
+  @overload draw_flled_ellipse(rect, color)
+    Draws a filled ellipse.
+  
+    @param [Ray::Rect, Array<Integer>] rect Rect in which the ellipse should be drawn.
+    @param [Ray::Color] color Color in which the ellipse should be drawn.
+*/
+VALUE ray_image_draw_filled_ellipse(VALUE self, VALUE rb_rect, VALUE rb_color) {
+   SDL_Surface *surface = ray_rb2surface(self);
+   SDL_Rect rect = ray_convert_to_rect(rb_rect);
+   ray_color color = ray_rb2col(rb_color);
+
+   filledEllipseRGBA(surface, rect.x + rect.w / 2,
+                     rect.y + rect.h / 2, rect.w / 2, rect.h / 2,
+                     color.r, color.g, color.b, color.a);
+   return self;
+}
+
+/*
+  @overload draw_triangle(p1, p2, p3, color)
+    Draws a triangle.
+*/
+VALUE ray_image_draw_triangle(VALUE self, VALUE p1, VALUE p2, VALUE p3,
+                              VALUE rb_color) {
+   SDL_Surface *surface = ray_rb2surface(self);
+
+   SDL_Rect first_point  = ray_convert_to_rect(p1);
+   SDL_Rect second_point = ray_convert_to_rect(p2);
+   SDL_Rect third_point  = ray_convert_to_rect(p3);
+   
+   ray_color color = ray_rb2col(rb_color);
+
+   aatrigonRGBA(surface, first_point.x, first_point.y,
+              second_point.x, second_point.y,
+              third_point.x, third_point.y,
+              color.r, color.g, color.b, color.a);
+
+   return self;
 }
 
+/*
+  @overload draw_filled_triangle(p1, p2, p3, color)
+    Draws a filled triangle.
+*/
+VALUE ray_image_draw_filled_triangle(VALUE self, VALUE p1, VALUE p2, VALUE p3,
+                                     VALUE rb_color) {
+   SDL_Surface *surface = ray_rb2surface(self);
+
+   SDL_Rect first_point  = ray_convert_to_rect(p1);
+   SDL_Rect second_point = ray_convert_to_rect(p2);
+   SDL_Rect third_point  = ray_convert_to_rect(p3);
+   
+   ray_color color = ray_rb2col(rb_color);
+
+   filledTrigonRGBA(surface, first_point.x, first_point.y,
+                    second_point.x, second_point.y,
+                    third_point.x, third_point.y,
+                    color.r, color.g, color.b, color.a);
+
+   return self;
+}
+
+/*
+  @overload draw_polygon(points, color)
+    Draws a polygon.
+
+    @param [Array<Array<Integer>, Ray::Rect>] points Points which should be joined
+                                                     to draw the polygon.
+    @param [Ray::Color] color The color in which the polygon should be drawn.
+*/
+VALUE ray_image_draw_polygon(VALUE self, VALUE points, VALUE rb_color) {
+   SDL_Surface *surface = ray_rb2surface(self);
+
+   size_t size = RARRAY_LEN(points);
+   int16_t *x_array = malloc(sizeof(int16_t) * size);
+   int16_t *y_array = malloc(sizeof(int16_t) * size);
+
+   size_t i = 0;
+   for (; i < size; i++) {
+      SDL_Rect rect = ray_convert_to_rect(rb_ary_entry(points, i));
+      
+      x_array[i] = (int16_t)rect.x;
+      y_array[i] = (int16_t)rect.y;
+   }
+
+   ray_color color = ray_rb2col(rb_color);
+   aapolygonRGBA(surface, x_array, y_array, (int)size,
+                 color.r, color.g, color.b, color.a);
+
+   free(x_array);
+   free(y_array);
+
+   return self;
+}
+
+/*
+  @overload draw_filled_polygon(points, color)
+    Draws a filled polygon.
+
+    @param [Array<Array<Integer>, Ray::Rect>] points Points which should be joined
+                                                     to draw the polygon.
+    @param [Ray::Color] color The color in which the polygon should be drawn.
+*/
+VALUE ray_image_draw_filled_polygon(VALUE self, VALUE points, VALUE rb_color) {
+   SDL_Surface *surface = ray_rb2surface(self);
+
+   size_t size = RARRAY_LEN(points);
+   int16_t *x_array = malloc(sizeof(int16_t) * size);
+   int16_t *y_array = malloc(sizeof(int16_t) * size);
+
+   size_t i = 0;
+   for (; i < size; i++) {
+      SDL_Rect rect = ray_convert_to_rect(rb_ary_entry(points, i));
+      
+      x_array[i] = (int16_t)rect.x;
+      y_array[i] = (int16_t)rect.y;
+   }
+
+   ray_color color = ray_rb2col(rb_color);
+   filledPolygonRGBA(surface, x_array, y_array, (int)size,
+                 color.r, color.g, color.b, color.a);
+
+   free(x_array);
+   free(y_array);
+
+   return self;
+}
+
+#endif
+
 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_method(ray_cImage, "fill", ray_image_fill, 1);
    rb_define_method(ray_cImage, "flip", ray_image_flip, 0);
@@ -267,6 +884,38 @@ void Init_ray_image() {
    rb_define_method(ray_cImage, "height", ray_image_height, 0);
    rb_define_method(ray_cImage, "bpp", ray_image_bpp, 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);
+
+#ifdef HAVE_SDL_GFX
+   rb_define_method(ray_cImage, "rotozoom", ray_image_rotozoom, 2);
+   rb_define_method(ray_cImage, "rotozoom!", ray_image_rotozoom_bang, 2);
+   
+   rb_define_method(ray_cImage, "draw_pixel", ray_image_draw_pixel, 2);
+   rb_define_method(ray_cImage, "draw_line", ray_image_draw_line, 3);
+   rb_define_method(ray_cImage, "draw_rect", ray_image_draw_rect, 2);
+   rb_define_method(ray_cImage, "draw_filled_rect", ray_image_draw_filled_rect,
+                    2);
+   rb_define_method(ray_cImage, "draw_circle", ray_image_draw_circle, 3);
+   rb_define_method(ray_cImage, "draw_filled_circle",
+                    ray_image_draw_filled_circle, 3);
+   rb_define_method(ray_cImage, "draw_ellipse", ray_image_draw_ellipse, 2);
+   rb_define_method(ray_cImage, "draw_filled_ellipse",
+                    ray_image_draw_filled_ellipse, 2);
+   rb_define_method(ray_cImage, "draw_triangle", ray_image_draw_triangle, 4);
+   rb_define_method(ray_cImage, "draw_filled_triangle",
+                    ray_image_draw_filled_triangle, 4);
+   rb_define_method(ray_cImage, "draw_polygon", ray_image_draw_polygon, 2);
+   rb_define_method(ray_cImage, "draw_filled_polygon",
+                    ray_image_draw_filled_polygon, 2);
+#endif
+
    rb_define_const(ray_cImage, "FLAG_ANYFORMAT", INT2FIX(SDL_ANYFORMAT));
    rb_define_const(ray_cImage, "FLAG_ASYNCBLIT", INT2FIX(SDL_ASYNCBLIT));
    rb_define_const(ray_cImage, "FLAG_DOUBLEBUF", INT2FIX(SDL_DOUBLEBUF));