cyross-ruby-miyako 2.0.0 → 2.0.5.1.0

data/miyako_collision.c

@@ -0,0 +1,403 @@
+/*
+--
+Miyako v2.0 Extend Library "Miyako no Katana"
+Copyright (C) 2008  Cyross Makoto
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+++
+*/
+
+/*
+=拡張ライブラリmiyako_no_katana
+Authors:: サイロス誠
+Version:: 2.0
+Copyright:: 2007-2009 Cyross Makoto
+License:: LGPL2.1
+ */
+#include "defines.h"
+
+static VALUE mSDL = Qnil;
+static VALUE mMiyako = Qnil;
+static VALUE eMiyakoError = Qnil;
+static VALUE cCollision = Qnil;
+static VALUE cCircleCollision = Qnil;
+static VALUE cCollisions = Qnil;
+static VALUE nZero = Qnil;
+static VALUE nOne = Qnil;
+static volatile ID id_update = Qnil;
+static volatile ID id_kakko  = Qnil;
+static volatile ID id_render = Qnil;
+static volatile ID id_to_a   = Qnil;
+static volatile int zero = Qnil;
+static volatile int one = Qnil;
+
+/*
+:nodoc:
+*/
+static VALUE collision_get_position(VALUE pos, VALUE *x, VALUE *y)
+{
+  VALUE *tmp;
+  switch(TYPE(pos))
+  {
+  case T_ARRAY:
+    if(RARRAY_LEN(pos) < 2)
+      rb_raise(eMiyakoError, "pairs have illegal array!");
+    tmp = RARRAY_PTR(pos);
+    *x = *tmp++;
+    *y = *tmp;
+    break;
+  case T_STRUCT:
+    if(RSTRUCT_LEN(pos) < 2)
+      rb_raise(eMiyakoError, "pairs have illegal struct!");
+    tmp = RSTRUCT_PTR(pos);
+    *x = *tmp++;
+    *y = *tmp;
+    break;
+  default:
+    *x = rb_funcall(pos, rb_intern("x"), 0);
+    *y = rb_funcall(pos, rb_intern("y"), 0);
+    break;
+  }
+  return Qnil;
+}
+
+/*
+:nodoc:
+*/
+static VALUE collision_c_collision(VALUE self, VALUE c1, VALUE pos1, VALUE c2, VALUE pos2)
+{
+  VALUE *prect1 = RSTRUCT_PTR(rb_iv_get(c1, "@rect"));
+  VALUE *prect2 = RSTRUCT_PTR(rb_iv_get(c2, "@rect"));
+  VALUE x1, y1, x2, y2;
+  collision_get_position(pos1, &x1, &y1);
+  collision_get_position(pos2, &x2, &y2);
+  double l1 = NUM2DBL(x1) + NUM2DBL(*prect1);
+  double t1 = NUM2DBL(y1) + NUM2DBL(*(prect1+1));
+  double r1 = l1 + NUM2DBL(*(prect1+2)) - 1;
+  double b1 = t1 + NUM2DBL(*(prect1+3)) - 1;
+  double l2 = NUM2DBL(x2) + NUM2DBL(*prect2);
+  double t2 = NUM2DBL(y2) + NUM2DBL(*(prect2+1));
+  double r2 = l2 + NUM2DBL(*(prect2+2)) - 1;
+  double b2 = t2 + NUM2DBL(*(prect2+3)) - 1;
+
+  if(l1 <= l2 && l2 <= r1 && t1 <= t2 && t2 <= b1) return Qtrue;
+  if(l1 <= r2 && r2 <= r1 && t1 <= b2 && b2 <= b1) return Qtrue;
+  if(l2 <= l1 && l1 <= r2 && t2 <= t1 && t1 <= b2) return Qtrue;
+  if(l2 <= r1 && r1 <= r2 && t2 <= b1 && b1 <= b2) return Qtrue;
+  return Qfalse;
+}
+
+/*
+:nodoc:
+*/
+static VALUE collision_c_meet(VALUE self, VALUE c1, VALUE pos1, VALUE c2, VALUE pos2)
+{
+  VALUE *prect1 = RSTRUCT_PTR(rb_iv_get(c1, "@rect"));
+  VALUE *prect2 = RSTRUCT_PTR(rb_iv_get(c2, "@rect"));
+  VALUE x1, y1, x2, y2;
+  collision_get_position(pos1, &x1, &y1);
+  collision_get_position(pos2, &x2, &y2);
+  double l1 = NUM2DBL(x1) + NUM2DBL(*prect1);
+  double t1 = NUM2DBL(y1) + NUM2DBL(*(prect1+1));
+  double r1 = l1 + NUM2DBL(*(prect1+2)) - 1;
+  double b1 = t1 + NUM2DBL(*(prect1+3)) - 1;
+  double l2 = NUM2DBL(x2) + NUM2DBL(*prect2);
+  double t2 = NUM2DBL(y2) + NUM2DBL(*(prect2+1));
+  double r2 = l2 + NUM2DBL(*(prect2+2)) - 1;
+  double b2 = t2 + NUM2DBL(*(prect2+3)) - 1;
+
+  if(r1 == l2 || b1 == t2 || l1 == r2 || t1 == b2) return Qtrue;
+  return Qfalse;
+}
+
+/*
+:nodoc:
+*/
+static VALUE collision_c_cover(VALUE self, VALUE c1, VALUE pos1, VALUE c2, VALUE pos2)
+{
+  VALUE *prect1 = RSTRUCT_PTR(rb_iv_get(c1, "@rect"));
+  VALUE *prect2 = RSTRUCT_PTR(rb_iv_get(c2, "@rect"));
+  VALUE x1, y1, x2, y2;
+  collision_get_position(pos1, &x1, &y1);
+  collision_get_position(pos2, &x2, &y2);
+  double l1 = NUM2DBL(x1) + NUM2DBL(*prect1);
+  double t1 = NUM2DBL(y1) + NUM2DBL(*(prect1+1));
+  double r1 = l1 + NUM2DBL(*(prect1+2)) - 1;
+  double b1 = t1 + NUM2DBL(*(prect1+3)) - 1;
+  double l2 = NUM2DBL(x2) + NUM2DBL(*prect2);
+  double t2 = NUM2DBL(y2) + NUM2DBL(*(prect2+1));
+  double r2 = l2 + NUM2DBL(*(prect2+2)) - 1;
+  double b2 = t2 + NUM2DBL(*(prect2+3)) - 1;
+
+  if(l1 >= l2 && r1 <= r2 && t1 >= t2 && b1 <= b2) return Qtrue;
+  if(l1 <= l2 && r1 >= r2 && t1 <= t2 && b1 >= b2) return Qtrue;
+  if(l2 >= l1 && r2 <= r1 && t2 >= t1 && b2 <= b1) return Qtrue;
+  if(l2 <= l1 && r2 >= r1 && t2 <= t1 && b2 >= b1) return Qtrue;
+  return Qfalse;
+}
+
+/*
+:nodoc:
+*/
+static VALUE collision_collision(VALUE self, VALUE pos1, VALUE c2, VALUE pos2)
+{
+  return collision_c_collision(cCollision, self, pos1, c2, pos2);
+}
+
+/*
+:nodoc:
+*/
+static VALUE collision_meet(VALUE self, VALUE pos1, VALUE c2, VALUE pos2)
+{
+  return collision_c_meet(cCollision, self, pos1, c2, pos2);
+}
+
+/*
+:nodoc:
+*/
+static VALUE collision_cover(VALUE self, VALUE pos1, VALUE c2, VALUE pos2)
+{
+  return collision_c_cover(cCollision, self, pos1, c2, pos2);
+}
+
+/*
+:nodoc:
+*/
+static VALUE circlecollision_c_collision(VALUE self, VALUE c1, VALUE pos1, VALUE c2, VALUE pos2)
+{
+  VALUE *pcenter1 = RSTRUCT_PTR(rb_iv_get(c1, "@center"));
+  VALUE *pcenter2 = RSTRUCT_PTR(rb_iv_get(c2, "@center"));
+  double r1 = NUM2DBL(rb_iv_get(c1, "@radius"));
+  double r2 = NUM2DBL(rb_iv_get(c2, "@radius"));
+  double r  = (r1 + r2) * (r1 + r2);
+  VALUE x1, y1, x2, y2;
+  collision_get_position(pos1, &x1, &y1);
+  collision_get_position(pos2, &x2, &y2);
+  double cx1 = NUM2DBL(x1) + NUM2DBL(*pcenter1);
+  double cy1 = NUM2DBL(y1) + NUM2DBL(*(pcenter1+1));
+  double cx2 = NUM2DBL(x2) + NUM2DBL(*pcenter2);
+  double cy2 = NUM2DBL(y2) + NUM2DBL(*(pcenter2+1));
+  double d   = (cx1-cx2) * (cx1-cx2) + (cy1-cy2) * (cy1-cy2);
+
+  if(d <= r) return Qtrue;
+  return Qfalse;
+}
+
+/*
+:nodoc:
+*/
+static VALUE circlecollision_c_meet(VALUE self, VALUE c1, VALUE pos1, VALUE c2, VALUE pos2)
+{
+  VALUE *pcenter1 = RSTRUCT_PTR(rb_iv_get(c1, "@center"));
+  VALUE *pcenter2 = RSTRUCT_PTR(rb_iv_get(c2, "@center"));
+  double r1 = NUM2DBL(rb_iv_get(c1, "@radius"));
+  double r2 = NUM2DBL(rb_iv_get(c2, "@radius"));
+  double r  = (r1 + r2) * (r1 + r2);
+  VALUE x1, y1, x2, y2;
+  collision_get_position(pos1, &x1, &y1);
+  collision_get_position(pos2, &x2, &y2);
+  double cx1 = NUM2DBL(x1) + NUM2DBL(*pcenter1);
+  double cy1 = NUM2DBL(y1) + NUM2DBL(*(pcenter1+1));
+  double cx2 = NUM2DBL(x2) + NUM2DBL(*pcenter2);
+  double cy2 = NUM2DBL(y2) + NUM2DBL(*(pcenter2+1));
+  double d   = (cx1-cx2) * (cx1-cx2) + (cy1-cy2) * (cy1-cy2);
+
+  if(d == r) return Qtrue;
+  return Qfalse;
+}
+
+/*
+:nodoc:
+*/
+static VALUE circlecollision_c_cover(VALUE self, VALUE c1, VALUE pos1, VALUE c2, VALUE pos2)
+{
+  VALUE *pcenter1 = RSTRUCT_PTR(rb_iv_get(c1, "@center"));
+  VALUE *pcenter2 = RSTRUCT_PTR(rb_iv_get(c2, "@center"));
+  double r1 = NUM2DBL(rb_iv_get(c1, "@radius"));
+  double r2 = NUM2DBL(rb_iv_get(c2, "@radius"));
+  double r = (r1 - r2) * (r1 - r2); // y = (x-a)^2 -> y = x^2 - 2ax + a^2
+  VALUE x1, y1, x2, y2;
+  collision_get_position(pos1, &x1, &y1);
+  collision_get_position(pos2, &x2, &y2);
+  double cx1 = NUM2DBL(x1) + NUM2DBL(*pcenter1);
+  double cy1 = NUM2DBL(y1) + NUM2DBL(*(pcenter1+1));
+  double cx2 = NUM2DBL(x2) + NUM2DBL(*pcenter2);
+  double cy2 = NUM2DBL(y2) + NUM2DBL(*(pcenter2+1));
+  double d   = (cx1-cx2) * (cx1-cx2) + (cy1-cy2) * (cy1-cy2);
+
+  if(d <= r) return Qtrue;
+  return Qfalse;
+}
+
+/*
+:nodoc:
+*/
+static VALUE circlecollision_collision(VALUE self, VALUE pos1, VALUE c2, VALUE pos2)
+{
+  return circlecollision_c_collision(cCircleCollision, self, pos1, c2, pos2);
+}
+
+/*
+:nodoc:
+*/
+static VALUE circlecollision_meet(VALUE self, VALUE pos1, VALUE c2, VALUE pos2)
+{
+  return circlecollision_c_meet(cCircleCollision, self, pos1, c2, pos2);
+}
+
+/*
+:nodoc:
+*/
+static VALUE circlecollision_cover(VALUE self, VALUE pos1, VALUE c2, VALUE pos2)
+{
+  return circlecollision_c_cover(cCircleCollision, self, pos1, c2, pos2);
+}
+
+/*
+:nodoc:
+*/
+static VALUE collisions_collision(VALUE self, VALUE c, VALUE pos)
+{
+  VALUE collisions = rb_iv_get(self, "@collisions");
+  int i=0;
+  for(i=0; i<RARRAY_LEN(collisions); i++){
+    VALUE cs = *(RARRAY_PTR(collisions) + i);
+    VALUE *cc = RARRAY_PTR(cs);
+    if(collision_collision(c, pos, *cc, *(cc+1)) == Qtrue){ return cs; }
+  }
+  return Qnil;
+}
+
+/*
+:nodoc:
+*/
+static VALUE collisions_meet(VALUE self, VALUE c, VALUE pos)
+{
+  VALUE collisions = rb_iv_get(self, "@collisions");
+  int i=0;
+  for(i=0; i<RARRAY_LEN(collisions); i++){
+    VALUE cs = *(RARRAY_PTR(collisions) + i);
+    VALUE *cc = RARRAY_PTR(cs);
+    if(collision_meet(c, pos, *cc, *(cc+1)) == Qtrue){ return cs; }
+  }
+  return Qnil;
+}
+
+/*
+:nodoc:
+*/
+static VALUE collisions_cover(VALUE self, VALUE c, VALUE pos)
+{
+  VALUE collisions = rb_iv_get(self, "@collisions");
+  int i=0;
+  for(i=0; i<RARRAY_LEN(collisions); i++){
+    VALUE cs = *(RARRAY_PTR(collisions) + i);
+    VALUE *cc = RARRAY_PTR(cs);
+    if(collision_cover(c, pos, *cc, *(cc+1)) == Qtrue){ return cs; }
+  }
+  return Qnil;
+}
+
+/*
+:nodoc:
+*/
+static VALUE collisions_collision_all(VALUE self, VALUE c, VALUE pos)
+{
+  VALUE collisions = rb_iv_get(self, "@collisions");
+  VALUE ret = rb_ary_new();
+  int i=0;
+  for(i=0; i<RARRAY_LEN(collisions); i++){
+    VALUE cs = *(RARRAY_PTR(collisions) + i);
+    VALUE *cc = RARRAY_PTR(cs);
+    if(collision_collision(c, pos, *cc, *(cc+1)) == Qtrue){ rb_ary_push(ret, cs); }
+  }
+  if(RARRAY_LEN(ret) == 0){ return Qnil; }
+  return ret;
+}
+
+/*
+:nodoc:
+*/
+static VALUE collisions_meet_all(VALUE self, VALUE c, VALUE pos)
+{
+  VALUE collisions = rb_iv_get(self, "@collisions");
+  VALUE ret = rb_ary_new();
+  int i=0;
+  for(i=0; i<RARRAY_LEN(collisions); i++){
+    VALUE cs = *(RARRAY_PTR(collisions) + i);
+    VALUE *cc = RARRAY_PTR(cs);
+    if(collision_meet(c, pos, *cc, *(cc+1)) == Qtrue){ rb_ary_push(ret, cs); }
+  }
+  if(RARRAY_LEN(ret) == 0){ return Qnil; }
+  return ret;
+}
+
+/*
+:nodoc:
+*/
+static VALUE collisions_cover_all(VALUE self, VALUE c, VALUE pos)
+{
+  VALUE collisions = rb_iv_get(self, "@collisions");
+  VALUE ret = rb_ary_new();
+  int i=0;
+  for(i=0; i<RARRAY_LEN(collisions); i++){
+    VALUE cs = *(RARRAY_PTR(collisions) + i);
+    VALUE *cc = RARRAY_PTR(cs);
+    if(collision_cover(c, pos, *cc, *(cc+1)) == Qtrue){ rb_ary_push(ret, cs); }
+  }
+  if(RARRAY_LEN(ret) == 0){ return Qnil; }
+  return ret;
+}
+
+void Init_miyako_collision()
+{
+  mSDL = rb_define_module("SDL");
+  mMiyako = rb_define_module("Miyako");
+  eMiyakoError  = rb_define_class_under(mMiyako, "MiyakoError", rb_eException);
+  cCollision = rb_define_class_under(mMiyako, "Collision", rb_cObject);
+  cCircleCollision = rb_define_class_under(mMiyako, "CircleCollision", rb_cObject);
+  cCollisions = rb_define_class_under(mMiyako, "Collisions", rb_cObject);
+
+  id_update = rb_intern("update");
+  id_kakko  = rb_intern("[]");
+  id_render = rb_intern("render");
+  id_to_a   = rb_intern("to_a");
+
+  zero = 0;
+  nZero = INT2NUM(zero);
+  one = 1;
+  nOne = INT2NUM(one);
+
+  rb_define_singleton_method(cCollision, "collision?", collision_c_collision, 4);
+  rb_define_singleton_method(cCollision, "meet?", collision_c_meet, 4);
+  rb_define_singleton_method(cCollision, "cover?", collision_c_cover, 4);
+  rb_define_method(cCollision, "collision?", collision_collision, 3);
+  rb_define_method(cCollision, "meet?", collision_meet, 3);
+  rb_define_method(cCollision, "cover?", collision_cover, 3);
+
+  rb_define_singleton_method(cCircleCollision, "collision?", circlecollision_c_collision, 4);
+  rb_define_singleton_method(cCircleCollision, "meet?", circlecollision_c_meet, 4);
+  rb_define_singleton_method(cCircleCollision, "cover?", circlecollision_c_cover, 4);
+  rb_define_method(cCircleCollision, "collision?", circlecollision_collision, 3);
+  rb_define_method(cCircleCollision, "meet?", circlecollision_meet, 3);
+  rb_define_method(cCircleCollision, "cover?", circlecollision_cover, 3);
+
+  rb_define_method(cCollisions, "collision?", collisions_collision, 2);
+  rb_define_method(cCollisions, "meet?", collisions_meet, 2);
+  rb_define_method(cCollisions, "cover?", collisions_cover, 2);
+  rb_define_method(cCollisions, "collision_all?", collisions_collision_all, 2);
+  rb_define_method(cCollisions, "meet_all?", collisions_meet_all, 2);
+  rb_define_method(cCollisions, "cover_all?", collisions_cover_all, 2);
+}

data/miyako_drawing.c

@@ -0,0 +1,187 @@
+/*
+--
+Miyako v2.0 Extend Library "Miyako no Katana"
+Copyright (C) 2008  Cyross Makoto
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+++
+*/
+
+/*
+=拡張ライブラリmiyako_no_katana
+Authors:: サイロス誠
+Version:: 2.0
+Copyright:: 2007-2008 Cyross Makoto
+License:: LGPL2.1
+ */
+#include "defines.h"
+#include "extern.h"
+#include <sge.h>
+
+static VALUE mSDL = Qnil;
+static VALUE mMiyako = Qnil;
+static VALUE mScreen = Qnil;
+static VALUE mDrawing = Qnil;
+static VALUE eMiyakoError = Qnil;
+static VALUE cSurface = Qnil;
+static VALUE cColor = Qnil;
+
+// from rubysdl_video.c
+static GLOBAL_DEFINE_GET_STRUCT(Surface, GetSurface, cSurface, "SDL::Surface");
+
+static Uint32 value_2_color(VALUE color, SDL_PixelFormat *fmt, Uint8 *alpha)
+{
+  VALUE *array = RARRAY_PTR(color);
+  if(alpha != NULL){ *alpha = (Uint8)(NUM2INT(*(array+3))); }
+  return SDL_MapRGBA(fmt,
+                     (Uint8)(NUM2INT(*(array+0))),
+                     (Uint8)(NUM2INT(*(array+1))),
+                     (Uint8)(NUM2INT(*(array+2))),
+                     (Uint8)(NUM2INT(*(array+3)))
+                    );
+}
+
+/*
+:nodoc:
+*/
+static void get_position(VALUE pos, Sint16 *x, Sint16 *y)
+{
+  VALUE *tmp;
+  switch(TYPE(pos))
+  {
+  case T_ARRAY:
+    if(RARRAY_LEN(pos) < 2)
+      rb_raise(eMiyakoError, "pairs have illegal array!");
+    tmp = RARRAY_PTR(pos);
+    *x = (Sint16)(NUM2INT(*tmp++));
+    *y = (Sint16)(NUM2INT(*tmp));
+    break;
+  case T_STRUCT:
+    if(RSTRUCT_LEN(pos) < 2)
+      rb_raise(eMiyakoError, "pairs have illegal struct!");
+    tmp = RSTRUCT_PTR(pos);
+    *x = (Sint16)(NUM2INT(*tmp++));
+    *y = (Sint16)(NUM2INT(*tmp));
+    break;
+  default:
+    *x = (Sint16)(NUM2INT(rb_funcall(pos, rb_intern("x"), 0)));
+    *y = (Sint16)(NUM2INT(rb_funcall(pos, rb_intern("y"), 0)));
+    break;
+  }
+}
+
+/*
+ポリゴン描画
+*/
+static VALUE drawing_draw_polygon(int argc, VALUE *argv, VALUE self)
+{
+  VALUE vdst;
+  VALUE pairs;
+  VALUE mcolor;
+  VALUE fill;
+  VALUE aa;
+  Uint8 alpha;
+  Uint32 color;
+  int i, vertexes;
+  
+  rb_scan_args(argc, argv, "32", &vdst, &pairs, &mcolor, &fill, &aa);
+  
+  // bitmapメソッドを持っていれば、メソッドの値をvdstとする
+  VALUE methods = rb_funcall(vdst, rb_intern("methods"), 0);
+  if(rb_ary_includes(methods, rb_str_intern(rb_str_new2("to_unit"))) == Qfalse &&
+     rb_ary_includes(methods, rb_str_intern(rb_str_new2("bitmap"))) == Qfalse
+    )
+    rb_raise(eMiyakoError, "this method needs sprite have to_method or bitmap method!");
+  if(rb_ary_includes(methods, rb_str_intern(rb_str_new2("to_unit"))) == Qtrue)
+    vdst = rb_funcall(vdst, rb_intern("to_unit"), 0);
+  vdst = rb_funcall(vdst, rb_intern("bitmap"), 0);
+
+  vertexes = RARRAY_LEN(pairs);
+  // 頂点数チェック
+  if(vertexes > 65536)
+    rb_raise(eMiyakoError, "too many pairs. pairs is less than 65536.");
+  
+  // 範囲チェック
+  for(i=0; i<vertexes; i++)
+  {
+    VALUE vertex = *(RARRAY_PTR(pairs)+i);
+    Sint16 x, y;
+    get_position(vertex, &x, &y);
+  }
+  
+	SDL_Surface  *dst = GetSurface(vdst)->surface;
+
+  color = value_2_color(rb_funcall(cColor, rb_intern("to_rgb"), 1, mcolor), dst->format, &alpha);
+
+  if(RTEST(fill) && RTEST(aa) && alpha < 255)
+    rb_raise(eMiyakoError, "can't draw filled antialiased alpha polygon");
+
+  Sint16 *px = (Sint16 *)malloc(sizeof(Sint16) * vertexes);
+  Sint16 *py = (Sint16 *)malloc(sizeof(Sint16) * vertexes);
+  for(i=0; i<vertexes; i++)
+  {
+    VALUE vertex = *(RARRAY_PTR(pairs)+i);
+    get_position(vertex, px+i, py+i);
+  }
+  
+  if(!RTEST(fill) && !RTEST(aa) && alpha == 255)
+  {
+    for(i=0; i<vertexes-1; i++)
+      sge_Line(dst, px[i], py[i], px[i+1], py[i+1], color);
+    sge_Line(dst, px[vertexes-1], py[vertexes-1], px[0], py[0], color);
+  }
+  else if(!RTEST(fill) && !RTEST(aa) && alpha < 255)
+  {
+    for(i=0; i<vertexes-1; i++)
+      sge_LineAlpha(dst, px[i], py[i], px[i+1], py[i+1], color, alpha);
+    sge_LineAlpha(dst, px[vertexes-1], py[vertexes-1], px[0], py[0], color, alpha);
+  }
+  else if(!RTEST(fill) && RTEST(aa) && alpha == 255)
+  {
+    for(i=0; i<vertexes-1; i++)
+      sge_AALine(dst, px[i], py[i], px[i+1], py[i+1], color);
+    sge_AALine(dst, px[vertexes-1], py[vertexes-1], px[0], py[0], color);
+  }
+  else if(!RTEST(fill) && RTEST(aa) && alpha < 255)
+  {
+    for(i=0; i<vertexes-1; i++)
+      sge_AALineAlpha(dst, px[i], py[i], px[i+1], py[i+1], color, alpha);
+    sge_AALineAlpha(dst, px[vertexes-1], py[vertexes-1], px[0], py[0], color, alpha);
+  }
+  else if(RTEST(fill) && !RTEST(aa) && alpha == 255)
+    sge_FilledPolygon(dst, (Uint16)vertexes, px, py, color);
+  else if(RTEST(fill) && !RTEST(aa) && alpha < 255)
+    sge_FilledPolygonAlpha(dst, (Uint16)vertexes, px, py, color, alpha);
+  else if(RTEST(fill) && RTEST(aa) && alpha == 255)
+    sge_AAFilledPolygon(dst, (Uint16)vertexes, px, py, color);
+  
+  free(py);
+  free(px);
+
+  return Qnil;
+}
+
+void Init_miyako_drawing()
+{
+  mSDL = rb_define_module("SDL");
+  mMiyako = rb_define_module("Miyako");
+  mScreen = rb_define_module_under(mMiyako, "Screen");
+  mDrawing = rb_define_module_under(mMiyako, "Drawing");
+  eMiyakoError  = rb_define_class_under(mMiyako, "MiyakoError", rb_eException);
+  cSurface = rb_define_class_under(mSDL, "Surface", rb_cObject);
+  cColor = rb_define_class_under(mMiyako, "Color", rb_cObject);
+  
+  rb_define_singleton_method(mDrawing, "polygon", drawing_draw_polygon, -1);
+}