rubysdl 1.3.0

data/rubysdl_rwops.c

@@ -0,0 +1,90 @@
+/*
+  Ruby/SDL   Ruby extension library for SDL
+
+  Copyright (C) 2001-2007 Ohbayashi Ippei
+  
+  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
+  */
+#include "rubysdl.h"
+
+static int rubyio_read(SDL_RWops* context, void* ptr, int size, int maxnum)
+{
+  volatile VALUE io = (VALUE)context->hidden.unknown.data1;
+  volatile VALUE str;
+  str = rb_funcall(io, rb_intern("read"), 1, INT2NUM(size*maxnum));
+  StringValue(str);
+  
+  memcpy(ptr, RSTRING(str)->ptr, RSTRING(str)->len);
+  return RSTRING(str)->len/size;
+}
+
+static int rubyio_write(SDL_RWops* context, const void* ptr, int size, int num)
+{
+  rb_raise(rb_eTypeError, "not implemented yet RWops write");
+}
+
+static int rubyio_pseudo_seek(SDL_RWops* context, int offset, int whence)
+{
+  volatile VALUE io = (VALUE)context->hidden.unknown.data1;
+  volatile VALUE str; 
+  if(offset < 0)
+    rb_raise(eSDLError, "cannot seek backward");
+  
+  
+  switch(whence){
+  case SEEK_SET:
+    rb_funcall(io, rb_intern("rewind"), 0);
+    rb_funcall(io, rb_intern("read"), 1, INT2NUM(offset));
+    break;
+  case SEEK_CUR:
+    str = rb_funcall(io, rb_intern("read"), 1, INT2NUM(offset));
+    break;
+  case SEEK_END:
+    rb_raise(eSDLError, "cannot seek SEEK_END");
+  default:
+    SDL_SetError("Unknown value for 'whence'");
+    return(-1);
+  }
+  return NUM2INT(rb_funcall(io, rb_intern("tell"), 0));
+}
+
+static int rubyio_close(SDL_RWops* context)
+{
+  if(context)
+    SDL_FreeRW(context);
+  return 0;
+}
+
+/* WARNING: +obj+ is not marked when GC starts,
+   so you should use `volatile' when this function is used
+   and you should not take out this RWops pointer to ruby's world.
+ */
+SDL_RWops* rubysdl_RWops_from_ruby_obj(VALUE obj)
+{
+  SDL_RWops* rwops;
+
+  rwops = SDL_AllocRW();
+  if( rwops == NULL )
+    rb_raise(eSDLError, "Out of memory:%s", SDL_GetError());
+
+  rwops->seek = rubyio_pseudo_seek;
+  rwops->read = rubyio_read;
+  rwops->write = rubyio_write;
+  rwops->close = rubyio_close;
+  rwops->hidden.unknown.data1 = (void*)obj;
+
+  return rwops;
+}
+

data/rubysdl_sdlskk.c

@@ -0,0 +1,312 @@
+/*
+  Ruby/SDL   Ruby extension library for SDL
+
+  Copyright (C) 2001-2007 Ohbayashi Ippei
+  
+  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
+  */
+#ifdef HAVE_SDLSKK
+#include "rubysdl.h"
+#include <sdlskk.h>
+#include <SDL_ttf.h>
+
+typedef SDL_Surface* (*Renderer)(SDLSKK_Context*,TTF_Font*,SDL_Color);
+
+static void skk_error_handler(SDLSKK_Error err)
+{
+  switch( err ){
+  case SDLSKK_NOERROR:
+    return;
+  case SDLSKK_MEMERROR:
+    rb_fatal("SDLSKK: memory allocation error");
+  }
+}
+
+static VALUE skk_set_encoding(VALUE mod,VALUE encoding)
+{
+  SDLSKK_set_encoding( NUM2INT(encoding) );
+  return Qnil;
+}
+
+static VALUE skk_get_encoding(VALUE mod)
+{
+  return INT2FIX(SDLSKK_get_encoding());
+}
+
+
+static VALUE skk_Context_new(VALUE class,VALUE dict,VALUE rule_table,
+			     VALUE keybind, VALUE use_minibuffer )
+{
+  SDLSKK_Context* c_context;
+  SDLSKK_RomKanaRuleTable* c_table;
+  SDLSKK_Dictionary* c_dict;
+  SDLSKK_Keybind* c_bind;
+  VALUE context;
+  
+  if( !rb_obj_is_kind_of(dict,cDictionary) )
+    rb_raise(rb_eArgError,"type mismatch(expect SDL::SKK::Dictionary)");
+  if( !rb_obj_is_kind_of(rule_table,cRomKanaRuleTable) )
+    rb_raise(rb_eArgError,"type mismatch(expect SDL::SKK::RomKanaRuleTable)");
+  if( !rb_obj_is_kind_of(keybind,cKeybind) )
+    rb_raise(rb_eArgError,"type mismatch(expect SDL::SKK::Keybind)");
+  
+  Data_Get_Struct(dict,SDLSKK_Dictionary,c_dict);
+  Data_Get_Struct(rule_table,SDLSKK_RomKanaRuleTable,c_table);
+  Data_Get_Struct(keybind,SDLSKK_Keybind,c_bind);
+  
+  c_context = SDLSKK_Context_new( c_dict, c_table, c_bind, RTEST(use_minibuffer) );
+  if( c_context == NULL )
+    rb_raise(eSDLError,"Couldn't create Context");
+
+  context = Data_Wrap_Struct(class,0,SDLSKK_Context_delete,c_context);
+  rb_iv_set(context,"dict",dict);
+  rb_iv_set(context,"rule_table",rule_table);
+  
+  return context;
+}
+
+static VALUE skk_Context_input_event(VALUE obj,VALUE event)
+{
+  SDLSKK_Context* context;
+  SDL_Event *ev;
+  
+  Data_Get_Struct(obj,SDLSKK_Context,context);
+  if( rb_obj_is_kind_of( event,cEvent ) ){
+    Data_Get_Struct(event,SDL_Event,ev);
+    SDLSKK_Context_input_event( context, ev );
+    return Qnil;
+  }
+  
+#ifdef DEF_EVENT2
+  if( rb_obj_is_kind_of( event,cEvent2 ) ){
+    if( rb_obj_is_kind_of( event,cKeyDownEvent ) ){
+      SDL_Event ev2;
+      ev2.type = SDL_KEYDOWN;
+      ev2.key.keysym.sym = NUM2INT( rb_iv_get(event,"@sym") );
+      ev2.key.keysym.unicode = NUM2UINT( rb_iv_get(event,"@unicode") );
+      ev2.key.keysym.mod = NUM2INT( rb_iv_get(event,"@mod"));
+      SDLSKK_Context_input_event( context, &ev2 );
+      return Qnil;
+    }else{
+      return Qnil;
+    }
+  }
+    
+#endif
+  rb_raise( rb_eArgError,"type mismatch(expect SDL::Event or SDL::Event2)");
+
+  /* NOT REACHED */
+}
+
+static VALUE skk_Context_get_str(VALUE obj)
+{
+  SDLSKK_Context* context;
+  char cstr[10000];
+  
+  Data_Get_Struct(obj,SDLSKK_Context,context);
+
+  SDLSKK_Context_get_str(context,cstr,sizeof(cstr));
+
+  return rb_str_new2(cstr);
+}
+
+static VALUE render_str(VALUE obj,VALUE font,VALUE r,VALUE g,VALUE b,
+			Renderer func)
+{
+  SDLSKK_Context* context;
+  SDL_Surface* surface;
+  TTF_Font* ttf_font;
+  SDL_Color color;
+
+  if( !rb_obj_is_kind_of(font,cTTF) )
+    rb_raise( rb_eArgError,"type mismatch(expect SDL::TTF)");
+  
+  color.r = NUM2UINT(r);
+  color.g = NUM2UINT(g);
+  color.b = NUM2UINT(b);
+  
+  Data_Get_Struct(obj,SDLSKK_Context,context);
+  Data_Get_Struct(font,TTF_Font,ttf_font);
+  
+  surface = func(context,ttf_font,color);
+
+  if( surface == NULL )
+    return Qnil;
+
+  return Data_Wrap_Struct(cSurface,0,sdl_freeSurface,surface);  
+}
+
+static VALUE skk_Context_render_str(VALUE obj,VALUE font,VALUE r,VALUE g,
+				    VALUE b)
+{
+  return render_str(obj,font,r,g,b,SDLSKK_Context_render_display_str);
+}
+
+static VALUE skk_Context_render_minibuffer_str(VALUE obj,VALUE font,VALUE r,
+						VALUE g,VALUE b)
+{
+  return render_str(obj,font,r,g,b,SDLSKK_Context_render_minibuffer_str);
+}
+
+static VALUE skk_Context_get_basic_mode(VALUE obj)
+{
+  SDLSKK_Context* context;
+  
+  Data_Get_Struct(obj,SDLSKK_Context,context);
+  return BOOL(SDLSKK_Context_get_basic_mode(context));
+}
+
+static VALUE skk_Context_clear(VALUE obj)
+{
+  SDLSKK_Context* context;
+  
+  Data_Get_Struct(obj,SDLSKK_Context,context);
+  SDLSKK_Context_clear(context);
+  return Qnil;
+}
+
+static VALUE skk_Context_clear_text(VALUE obj)
+{
+  SDLSKK_Context* context;
+  
+  Data_Get_Struct(obj,SDLSKK_Context,context);
+  SDLSKK_Context_clear_text(context);
+  return Qnil;
+}
+
+static VALUE skk_Dictionary_new(VALUE class)
+{
+  SDLSKK_Dictionary* dict;
+
+  dict = SDLSKK_Dict_new();
+  if( dict == NULL )
+    rb_raise(eSDLError,"Couldn't create SDL::SKK::Dictionary" );
+  
+  return Data_Wrap_Struct(class,0,SDLSKK_Dict_delete,dict);
+}
+
+static VALUE skk_Dict_load(VALUE obj,VALUE filename,VALUE users)
+{
+  SDLSKK_Dictionary* dict;
+
+  Data_Get_Struct(obj,SDLSKK_Dictionary,dict);
+  
+  if( !SDLSKK_Dict_load(dict,GETCSTR(filename),RTEST(users)) )
+    rb_raise(eSDLError,"Couldn't load %s",GETCSTR(filename));
+
+  return Qnil;
+}
+
+static VALUE skk_Dict_save(VALUE obj, VALUE filename)
+{
+  SDLSKK_Dictionary* dict;
+
+  Data_Get_Struct(obj,SDLSKK_Dictionary,dict);
+
+  if( !SDLSKK_Dict_save_user_dict(dict,GETCSTR(filename)) )
+    rb_raise(eSDLError,"Couldn't save %s",GETCSTR(filename));
+  
+  return Qnil;
+}
+
+static VALUE skk_RomKanaRuleTable_new(VALUE class,VALUE table_file)
+{
+  SDLSKK_RomKanaRuleTable* rule_table;
+
+  rule_table = SDLSKK_RomKanaRuleTable_new( GETCSTR(table_file) );
+
+  if( rule_table == NULL )
+    rb_raise(eSDLError,"Couldn't load %s",GETCSTR(table_file));
+  
+  return Data_Wrap_Struct(class,0,SDLSKK_RomKanaRuleTable_delete,rule_table);
+}
+
+static VALUE skk_Keybind_new(VALUE class)
+{
+  return Data_Wrap_Struct(class,0,SDLSKK_Keybind_delete,SDLSKK_Keybind_new());
+}
+
+static VALUE skk_Keybind_set_key(VALUE obj,VALUE key_str,VALUE cmd_str)
+{
+  SDLSKK_Keybind* keybind;
+  
+  Data_Get_Struct(obj,SDLSKK_Keybind,keybind);
+  SDLSKK_Keybind_set_key(keybind,GETCSTR(key_str),GETCSTR(cmd_str));
+  return Qnil;
+}
+
+static VALUE skk_Keybind_set_default_key(VALUE obj)
+{
+  SDLSKK_Keybind* keybind;
+  
+  Data_Get_Struct(obj,SDLSKK_Keybind,keybind);
+  SDLSKK_Keybind_set_default_key(keybind);
+  return Qnil;
+}
+
+static VALUE skk_Keybind_unset_key(VALUE obj,VALUE key_str)
+{
+  SDLSKK_Keybind* keybind;
+  
+  Data_Get_Struct(obj,SDLSKK_Keybind,keybind);
+  SDLSKK_Keybind_unset_key(keybind,GETCSTR(key_str));
+  return Qnil;
+}
+
+static void defineConstForSDLSKK(void)
+{
+  rb_define_const(mSDLSKK,"EUCJP",INT2NUM(SDLSKK_EUCJP));
+  rb_define_const(mSDLSKK,"UTF8",INT2NUM(SDLSKK_UTF8));
+  rb_define_const(mSDLSKK,"SJIS",INT2NUM(SDLSKK_SJIS));
+}
+
+void init_sdlskk(void)
+{
+  mSDLSKK = rb_define_module_under(mSDL,"SKK");
+  cContext = rb_define_class_under(mSDLSKK,"Context",rb_cObject);
+  cDictionary = rb_define_class_under(mSDLSKK,"Dictionary",rb_cObject);
+  cRomKanaRuleTable = rb_define_class_under(mSDLSKK,"RomKanaRuleTable",
+					    rb_cObject);
+  cKeybind = rb_define_class_under(mSDLSKK,"Keybind",rb_cObject);
+  
+  rb_define_module_function(mSDLSKK,"encoding=",skk_set_encoding,1);
+  rb_define_module_function(mSDLSKK,"encoding",skk_get_encoding,0);
+  
+  rb_define_singleton_method(cContext,"new",skk_Context_new,4);
+  rb_define_method(cContext,"input",skk_Context_input_event,1);
+  rb_define_method(cContext,"str",skk_Context_get_str,0);
+  rb_define_method(cContext,"render_str",skk_Context_render_str,4);
+  rb_define_method(cContext,"render_minibuffer_str",skk_Context_render_minibuffer_str,4);
+  rb_define_method(cContext,"get_basic_mode",skk_Context_get_basic_mode,0);
+  rb_define_method(cContext,"clear",skk_Context_clear,0);
+  rb_define_method(cContext,"clear_text",skk_Context_clear_text,0);
+  
+  rb_define_singleton_method(cDictionary,"new",skk_Dictionary_new,0);
+  rb_define_method(cDictionary,"load",skk_Dict_load,2);
+  rb_define_method(cDictionary,"save",skk_Dict_save,1);
+  
+  rb_define_singleton_method(cRomKanaRuleTable,"new",
+			     skk_RomKanaRuleTable_new,1);
+
+  rb_define_singleton_method(cKeybind,"new",skk_Keybind_new,0);
+  rb_define_method(cKeybind,"set_key",skk_Keybind_set_key,2);
+  rb_define_method(cKeybind,"set_default_key",skk_Keybind_set_default_key,0);
+  rb_define_method(cKeybind,"unset_key",skk_Keybind_unset_key,1);
+  
+  SDLSKK_set_error_func(skk_error_handler);
+  
+  defineConstForSDLSKK();
+}
+#endif /* HAVE_SDLSKK */

data/rubysdl_sge_video.c

@@ -0,0 +1,622 @@
+/*
+  Ruby/SDL   Ruby extension library for SDL
+
+  Copyright (C) 2001-2007 Ohbayashi Ippei
+  
+  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
+  */
+#ifdef HAVE_SGE
+
+#include "rubysdl.h"
+#include <sge.h>
+
+static VALUE sdl_get_autoLocking(VALUE mod)
+{
+  return BOOL(sge_getLock());
+}
+
+static VALUE  sdl_set_autoLocking(VALUE mod,VALUE bool)
+{
+  if(RTEST(bool))
+    sge_Lock_ON();
+  else
+    sge_Lock_OFF();
+  return Qnil;
+}
+
+     
+static VALUE sdl_getPixel(VALUE obj,VALUE x,VALUE y)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  return UINT2NUM( sge_GetPixel(surface,NUM2INT(x),NUM2INT(y)) );
+}
+static VALUE sdl_putPixel(VALUE obj,VALUE x,VALUE y,VALUE color)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_PutPixel(surface,NUM2INT(x),NUM2INT(y),VALUE2COLOR(color,surface->format));
+  return Qnil;
+}
+static VALUE sdl_drawLine(VALUE obj,VALUE x1,VALUE y1,VALUE x2,VALUE y2,VALUE color)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_Line( surface,NUM2INT(x1),NUM2INT(y1),NUM2INT(x2),NUM2INT(y2),
+	    VALUE2COLOR(color,surface->format) );
+  return Qnil;
+}
+static VALUE sdl_drawAALine(VALUE obj,VALUE x1,VALUE y1,VALUE x2,VALUE y2,VALUE color)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_AALine( surface,NUM2INT(x1),NUM2INT(y1),NUM2INT(x2),NUM2INT(y2),
+	    VALUE2COLOR(color,surface->format) );
+  return Qnil;
+}
+static VALUE sdl_drawLineAlpha(VALUE obj,VALUE x1,VALUE y1,VALUE x2,VALUE y2,VALUE color,VALUE alpha)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_LineAlpha( surface,NUM2INT(x1),NUM2INT(y1),NUM2INT(x2),NUM2INT(y2),
+                 VALUE2COLOR(color,surface->format), NUM2UINT(alpha) );
+  return Qnil;
+}
+static VALUE sdl_drawAALineAlpha(VALUE obj,VALUE x1,VALUE y1,VALUE x2,VALUE y2,VALUE color,VALUE alpha)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_AALineAlpha( surface,NUM2INT(x1),NUM2INT(y1),NUM2INT(x2),NUM2INT(y2),
+                   VALUE2COLOR(color,surface->format),NUM2UINT(alpha) );
+  return Qnil;
+}
+
+static VALUE sdl_drawRect(VALUE obj,VALUE x,VALUE y,VALUE w,VALUE h,VALUE color)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_Rect( surface,NUM2INT(x),NUM2INT(y),NUM2INT(x)+NUM2INT(w),
+	    NUM2INT(y)+NUM2INT(h),VALUE2COLOR(color,surface->format) );
+  return Qnil;
+}
+static VALUE sdl_drawRectAlpha(VALUE obj,VALUE x,VALUE y,VALUE w,VALUE h,VALUE color,VALUE alpha)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_RectAlpha( surface,NUM2INT(x),NUM2INT(y),NUM2INT(x)+NUM2INT(w),
+                 NUM2INT(y)+NUM2INT(h),VALUE2COLOR(color,surface->format),
+                 NUM2UINT(alpha) );
+  return Qnil;
+}
+static VALUE sdl_drawFilledRectAlpha(VALUE obj,VALUE x,VALUE y,VALUE w,VALUE h,VALUE color,VALUE alpha)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_FilledRectAlpha( surface,NUM2INT(x),NUM2INT(y),NUM2INT(x)+NUM2INT(w),
+                       NUM2INT(y)+NUM2INT(h),VALUE2COLOR(color,surface->format),
+                       NUM2UINT(alpha) );
+  return Qnil;
+}
+static VALUE sdl_drawCircle(VALUE obj,VALUE x,VALUE y,VALUE r,VALUE color)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_Circle( surface,NUM2INT(x),NUM2INT(y),NUM2INT(r),
+	      VALUE2COLOR(color,surface->format) );
+  return Qnil;
+}
+static VALUE sdl_drawAACircle(VALUE obj,VALUE x,VALUE y,VALUE r,VALUE color)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_AACircle( surface,NUM2INT(x),NUM2INT(y),NUM2INT(r),
+	      VALUE2COLOR(color,surface->format) );
+  return Qnil;
+}
+static VALUE sdl_drawCircleAlpha(VALUE obj,VALUE x,VALUE y,VALUE r,VALUE color,VALUE alpha)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_CircleAlpha( surface,NUM2INT(x),NUM2INT(y),NUM2INT(r),
+                   VALUE2COLOR(color,surface->format),NUM2UINT(alpha) );
+  return Qnil;
+}
+static VALUE sdl_drawAACircleAlpha(VALUE obj,VALUE x,VALUE y,VALUE r,VALUE color,
+                                   VALUE alpha)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_AACircleAlpha( surface,NUM2INT(x),NUM2INT(y),NUM2INT(r),
+                     VALUE2COLOR(color,surface->format),NUM2UINT(alpha) );
+  return Qnil;
+}
+static VALUE sdl_drawFilledCircle(VALUE obj,VALUE x,VALUE y,VALUE r,VALUE color)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_FilledCircle( surface,NUM2INT(x),NUM2INT(y),NUM2INT(r),
+		    VALUE2COLOR(color,surface->format) );
+  return Qnil;
+}
+static VALUE sdl_drawAAFilledCircle(VALUE obj,VALUE x,VALUE y,VALUE r,VALUE color)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_AAFilledCircle( surface,NUM2INT(x),NUM2INT(y),NUM2INT(r),
+		    VALUE2COLOR(color,surface->format) );
+  return Qnil;
+}
+static VALUE sdl_drawFilledCircleAlpha(VALUE obj,VALUE x,VALUE y,VALUE r,VALUE color,VALUE alpha)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_FilledCircleAlpha( surface,NUM2INT(x),NUM2INT(y),NUM2INT(r),
+                         VALUE2COLOR(color,surface->format),NUM2UINT(alpha) );
+  return Qnil;
+}
+static VALUE sdl_drawEllipse(VALUE obj,VALUE x,VALUE y,VALUE rx,VALUE ry,
+			     VALUE color)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_Ellipse( surface,NUM2INT(x),NUM2INT(y),NUM2INT(rx),NUM2INT(ry),
+	       VALUE2COLOR(color,surface->format) );
+  return Qnil;
+}
+static VALUE sdl_drawAAEllipse(VALUE obj,VALUE x,VALUE y,VALUE rx,VALUE ry,
+			     VALUE color)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_AAEllipse( surface,NUM2INT(x),NUM2INT(y),NUM2INT(rx),NUM2INT(ry),
+	       VALUE2COLOR(color,surface->format) );
+  return Qnil;
+}
+static VALUE sdl_drawEllipseAlpha(VALUE obj,VALUE x,VALUE y,VALUE rx,VALUE ry,
+                                  VALUE color,VALUE alpha)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_EllipseAlpha( surface,NUM2INT(x),NUM2INT(y),NUM2INT(rx),NUM2INT(ry),
+                    VALUE2COLOR(color,surface->format),NUM2UINT(alpha) );
+  return Qnil;
+}
+static VALUE sdl_drawAAEllipseAlpha(VALUE obj,VALUE x,VALUE y,VALUE rx,VALUE ry,
+                                    VALUE color,VALUE alpha)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_AAEllipseAlpha( surface,NUM2INT(x),NUM2INT(y),NUM2INT(rx),NUM2INT(ry),
+                      VALUE2COLOR(color,surface->format),NUM2UINT(alpha) );
+  return Qnil;
+}
+static VALUE sdl_drawFilledEllipse(VALUE obj,VALUE x,VALUE y,VALUE rx,VALUE ry,
+				   VALUE color)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_FilledEllipse( surface,NUM2INT(x),NUM2INT(y),NUM2INT(rx),NUM2INT(ry),
+		     VALUE2COLOR(color,surface->format) );
+  return Qnil;
+}
+static VALUE sdl_drawAAFilledEllipse(VALUE obj,VALUE x,VALUE y,VALUE rx,VALUE ry,
+				   VALUE color)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_AAFilledEllipse( surface,NUM2INT(x),NUM2INT(y),NUM2INT(rx),NUM2INT(ry),
+		     VALUE2COLOR(color,surface->format) );
+  return Qnil;
+}
+static VALUE sdl_drawFilledEllipseAlpha(VALUE obj,VALUE x,VALUE y,VALUE rx,VALUE ry,
+                                        VALUE color,VALUE alpha)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_FilledEllipseAlpha( surface,NUM2INT(x),NUM2INT(y),NUM2INT(rx),NUM2INT(ry),
+                          VALUE2COLOR(color,surface->format),NUM2UINT(alpha) );
+  return Qnil;
+}
+
+static VALUE sdl_drawBezier(VALUE obj,VALUE x1,VALUE y1,VALUE x2,VALUE y2,
+                            VALUE x3,VALUE y3,VALUE x4,VALUE y4,
+                            VALUE level,VALUE color)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_Bezier(surface,NUM2INT(x1),NUM2INT(y1),NUM2INT(x2),NUM2INT(y2),
+             NUM2INT(x3),NUM2INT(y3),NUM2INT(x4),NUM2INT(y4),
+             NUM2INT(level),VALUE2COLOR(color,surface->format));
+  return Qnil;
+}
+
+static VALUE sdl_drawBezierAlpha(VALUE obj,VALUE x1,VALUE y1,VALUE x2,VALUE y2,
+                                 VALUE x3,VALUE y3,VALUE x4,VALUE y4,
+                                 VALUE level,VALUE color,VALUE alpha)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_BezierAlpha(surface,NUM2INT(x1),NUM2INT(y1),NUM2INT(x2),NUM2INT(y2),
+                  NUM2INT(x3),NUM2INT(y3),NUM2INT(x4),NUM2INT(y4),
+                  NUM2INT(level),VALUE2COLOR(color,surface->format),
+                  NUM2UINT(alpha));
+  return Qnil;
+}
+
+static VALUE sdl_drawAABezier(VALUE obj,VALUE x1,VALUE y1,VALUE x2,VALUE y2,
+                              VALUE x3,VALUE y3,VALUE x4,VALUE y4,
+                              VALUE level,VALUE color)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_AABezier(surface,NUM2INT(x1),NUM2INT(y1),NUM2INT(x2),NUM2INT(y2),
+               NUM2INT(x3),NUM2INT(y3),NUM2INT(x4),NUM2INT(y4),
+               NUM2INT(level),VALUE2COLOR(color,surface->format));
+  return Qnil;
+}
+
+static VALUE sdl_drawAABezierAlpha(VALUE obj,VALUE x1,VALUE y1,VALUE x2,VALUE y2,
+                                 VALUE x3,VALUE y3,VALUE x4,VALUE y4,
+                                 VALUE level,VALUE color,VALUE alpha)
+{
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  sge_AABezierAlpha(surface,NUM2INT(x1),NUM2INT(y1),NUM2INT(x2),NUM2INT(y2),
+                    NUM2INT(x3),NUM2INT(y3),NUM2INT(x4),NUM2INT(y4),
+                    NUM2INT(level),VALUE2COLOR(color,surface->format),
+                    NUM2UINT(alpha));
+  return Qnil;
+}
+
+static VALUE sdl_rotateScaledSurface(VALUE obj,VALUE angle,VALUE scale,VALUE bgcolor)
+{
+  SDL_Surface *surface,*result;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  result=sge_rotate_scaled_surface(surface,NUM2INT(angle),NUM2DBL(scale),
+				   VALUE2COLOR(bgcolor,surface->format) );
+  if( result==NULL )
+    rb_raise( eSDLError,"Couldn't Create Surface: %s",SDL_GetError() );
+  return Data_Wrap_Struct(cSurface,0,sdl_freeSurface,result);
+}
+/* doesn't respect ColorKey */
+static VALUE sdl_rotateXYScaled(VALUE mod,VALUE src,VALUE dst,VALUE x,
+				VALUE y,VALUE angle,VALUE xscale,
+				VALUE yscale)
+{
+  SDL_Surface *srcSurface,*dstSurface;
+  if( !rb_obj_is_kind_of(src,cSurface) || !rb_obj_is_kind_of(dst,cSurface) )
+    rb_raise(rb_eArgError,"type mismatch(expect Surface)");
+  Data_Get_Struct(src,SDL_Surface,srcSurface);
+  Data_Get_Struct(dst,SDL_Surface,dstSurface);
+  sge_rotate_xyscaled(dstSurface,srcSurface,NUM2INT(x),NUM2INT(y),
+		      NUM2INT(angle),NUM2DBL(xscale),NUM2DBL(yscale));
+  return Qnil;
+}
+static VALUE sdl_rotateScaledBlit(VALUE mod,VALUE src,VALUE dst,VALUE x,
+				  VALUE y,VALUE angle,VALUE scale)
+{
+  SDL_Surface *srcSurface,*dstSurface,*tmpSurface;
+  SDL_Rect destRect;
+  Uint32 colorkey;
+  Uint32 flags;
+  int result;
+  
+  if( !rb_obj_is_kind_of(src,cSurface) || !rb_obj_is_kind_of(dst,cSurface) )
+    rb_raise(rb_eArgError,"type mismatch(expect Surface)");
+  Data_Get_Struct(src,SDL_Surface,srcSurface);
+  Data_Get_Struct(dst,SDL_Surface,dstSurface);
+  colorkey=srcSurface->format->colorkey;
+  flags = srcSurface->flags & ( SDL_RLEACCEL|SDL_SRCCOLORKEY );
+  tmpSurface = sge_rotate_scaled_surface(srcSurface,NUM2INT(angle),
+					 NUM2DBL(scale),colorkey);
+  if( tmpSurface==NULL )
+    rb_raise(eSDLError,"SDL memory allocate failed :%s",SDL_GetError());
+  SDL_SetColorKey(tmpSurface,flags,colorkey);
+  destRect.x=NUM2INT(x)-tmpSurface->h/2;
+  destRect.y=NUM2INT(y)-tmpSurface->w/2;
+  result = SDL_BlitSurface(tmpSurface,NULL,dstSurface,&destRect);
+  SDL_FreeSurface(tmpSurface);
+  if( result == -1 ){
+    rb_raise(eSDLError,"SDL_BlitSurface fail: %s",SDL_GetError());
+  }
+  return INT2NUM(result);
+}
+
+static VALUE sdl_transform(VALUE mod,VALUE src,VALUE dst,VALUE angle,
+			   VALUE xscale,VALUE yscale,VALUE px,VALUE py,
+			   VALUE qx,VALUE qy,VALUE flags)
+{
+  SDL_Surface *srcSurface,*dstSurface;
+  if( !rb_obj_is_kind_of(src,cSurface) || !rb_obj_is_kind_of(dst,cSurface) )
+    rb_raise(rb_eArgError,"type mismatch(expect Surface)");
+  Data_Get_Struct(src,SDL_Surface,srcSurface);
+  Data_Get_Struct(dst,SDL_Surface,dstSurface);
+  sge_transform(srcSurface,dstSurface,NUM2DBL(angle),NUM2DBL(xscale),
+		NUM2DBL(yscale),NUM2INT(px),NUM2INT(py),NUM2INT(qx),
+		NUM2INT(qy),NUM2UINT(flags));
+  return Qnil;
+}
+
+static VALUE sdl_transformSurface(VALUE obj,VALUE bgcolor,VALUE angle,
+				  VALUE xscale,VALUE yscale,VALUE flags)
+{
+  SDL_Surface *surface,*result;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  result = sge_transform_surface(surface,VALUE2COLOR(bgcolor,surface->format),
+				 NUM2DBL(angle),NUM2DBL(xscale),
+				 NUM2DBL(yscale),NUM2UINT(flags));
+  if( result==NULL )
+    rb_raise( eSDLError,"Couldn't Create Surface: %s",SDL_GetError() );
+  return Data_Wrap_Struct(cSurface,0,sdl_freeSurface,result);
+}
+
+static VALUE sdl_makeCollisionMap(VALUE obj)
+{
+  sge_cdata * cdata;
+  SDL_Surface *surface;
+  Data_Get_Struct(obj,SDL_Surface,surface);
+  cdata = sge_make_cmap(surface);
+  if( cdata==NULL )
+    rb_raise( eSDLError,"Couldn't Create CollisionMap: %s",SDL_GetError() );
+  return Data_Wrap_Struct(cCollisionMap,0,sge_destroy_cmap,cdata);
+}
+
+static sge_cdata * value_to_collision_map(VALUE value)
+{
+  sge_cdata * cdata;
+  if( !rb_obj_is_kind_of(value, cCollisionMap) )
+    rb_raise(rb_eArgError,"type mismatch(expect CollisionMap)");
+  Data_Get_Struct(value, sge_cdata, cdata);
+  return cdata;
+}
+
+static VALUE sdl_classBoundingBoxCheck(VALUE class,
+                                       VALUE x1, VALUE y1, VALUE w1, VALUE h1,
+                                       VALUE x2, VALUE y2, VALUE w2, VALUE h2)
+{
+  return BOOL(_sge_bbcheck
+              ((Sint16) NUM2INT(x1), (Sint16) NUM2INT(y1),
+               (Sint16) NUM2INT(w1), (Sint16) NUM2INT(h1),
+               (Sint16) NUM2INT(x2), (Sint16) NUM2INT(y2),
+               (Sint16) NUM2INT(w2), (Sint16) NUM2INT(h2)));
+}
+
+static VALUE sdl_collisionCheck(VALUE collisionMap1, VALUE x1, VALUE y1,
+                                VALUE collisionMap2, VALUE x2, VALUE y2)
+{
+  sge_cdata * cdata1 = value_to_collision_map(collisionMap1);
+  sge_cdata * cdata2 = value_to_collision_map(collisionMap2);
+  int collided;
+  collided = sge_cmcheck
+    (cdata1, (Sint16) NUM2INT(x1), (Sint16) NUM2INT(y1),
+     cdata2, (Sint16) NUM2INT(x2), (Sint16) NUM2INT(y2));
+  if(!collided)
+    return Qnil;
+  return rb_ary_new3(2, INT2NUM(sge_get_cx()), INT2NUM(sge_get_cy()));
+}
+
+static VALUE sdl_boundingBoxCheck(VALUE collisionMap1, VALUE x1, VALUE y1,
+                                  VALUE collisionMap2, VALUE x2, VALUE y2)
+{
+  sge_cdata * cdata1 = value_to_collision_map(collisionMap1);
+  sge_cdata * cdata2 = value_to_collision_map(collisionMap2);
+  return BOOL(sge_bbcheck
+              (cdata1, (Sint16) NUM2INT(x1), (Sint16) NUM2INT(y1),
+               cdata2, (Sint16) NUM2INT(x2), (Sint16) NUM2INT(y2)));
+}
+
+static VALUE sdl_set_cdata(VALUE obj, VALUE vx, VALUE vy, VALUE vw, VALUE vh)
+{
+  sge_cdata * cdata = value_to_collision_map(obj);
+  Sint16 x, y, w, h;
+  
+  x = NUM2INT(vx);
+  y = NUM2INT(vy);
+  w = NUM2INT(vw);
+  h = NUM2INT(vh);
+  if( x < 0 || y < 0 || x+w > cdata->w || y+h > cdata->h ){
+    rb_raise(eSDLError,"Couldn't clear that area");
+  }
+  sge_set_cdata(cdata, x, y, w, h );
+  return Qnil;
+}
+
+static VALUE sdl_unset_cdata(VALUE obj, VALUE vx, VALUE vy, VALUE vw, VALUE vh)
+{
+  sge_cdata * cdata = value_to_collision_map(obj);
+  Sint16 x, y, w, h;
+  
+  x = NUM2INT(vx);
+  y = NUM2INT(vy);
+  w = NUM2INT(vw);
+  h = NUM2INT(vh);
+  if( x < 0 || y < 0 || x+w > cdata->w || y+h > cdata->h ){
+    rb_raise(eSDLError,"Couldn't clear that area");
+  }
+  sge_unset_cdata(cdata, x, y, w, h);
+  return Qnil;
+}
+
+static VALUE sdl_w_cdata(VALUE obj)
+{
+  sge_cdata * cdata = value_to_collision_map(obj);
+  return INT2FIX(cdata->w);
+}
+
+static VALUE sdl_h_cdata(VALUE obj)
+{
+  sge_cdata * cdata = value_to_collision_map(obj);
+  return INT2FIX(cdata->h);
+}
+
+/* bitmap font */
+static void sdl_bf_close(sge_bmpFont* font)
+{
+  if(!rubysdl_is_quit()){
+    sge_BF_CloseFont(font);
+  }
+}
+
+static VALUE sdl_bf_open(VALUE obj, VALUE file, VALUE flags)
+{
+  sge_bmpFont* font;
+
+  font = sge_BF_OpenFont(GETCSTR(file),NUM2UINT(flags));
+  if( font == NULL )
+    rb_raise(eSDLError,"Couldn't open font: %s", GETCSTR(file));
+  
+  return Data_Wrap_Struct(cBMFont,0,sdl_bf_close,font);
+}
+
+static VALUE sdl_bf_setColor(VALUE obj,VALUE r,VALUE g,VALUE b)
+{
+  sge_bmpFont* font;
+  Data_Get_Struct(obj,sge_bmpFont,font);
+  
+  sge_BF_SetColor(font,NUM2UINT(r),NUM2UINT(g),NUM2UINT(b));
+  return Qnil;
+}
+
+static VALUE sdl_bf_getHeight(VALUE obj)
+{
+  sge_bmpFont* font;
+  Data_Get_Struct(obj,sge_bmpFont,font);
+  return INT2FIX(sge_BF_GetHeight(font));
+}
+
+static VALUE sdl_bf_getWidth(VALUE obj)
+{
+  sge_bmpFont* font;
+  Data_Get_Struct(obj,sge_bmpFont,font);
+  return INT2FIX(sge_BF_GetWidth(font));
+}
+
+static VALUE sdl_bf_textSize(VALUE obj, VALUE text)
+{
+  sge_bmpFont* font;
+  SDL_Rect rect;
+  Data_Get_Struct(obj,sge_bmpFont,font);
+  rect = sge_BF_TextSize(font, GETCSTR(text));
+  return rb_ary_new3(2, INT2FIX(rect.w), INT2FIX(rect.h));
+}
+
+static VALUE sdl_bf_textout(VALUE obj,VALUE surface,VALUE string,
+                            VALUE x, VALUE y)
+{
+  sge_bmpFont* font;
+  SDL_Surface* target;
+  
+  if(!rb_obj_is_kind_of(surface,cSurface))
+    rb_raise( rb_eArgError,"type mismatch(expect Surface)" );
+  Data_Get_Struct(obj,sge_bmpFont,font);
+  Data_Get_Struct(surface,SDL_Surface,target);
+  sge_BF_textout(target,font,GETCSTR(string),NUM2INT(x),NUM2INT(y));
+  return Qnil;
+}
+
+static void defineConstForSGE()
+{
+  rb_define_const(mSDL,"TRANSFORM_AA",UINT2NUM(SGE_TAA));
+  rb_define_const(mSDL,"TRANSFORM_SAFE",UINT2NUM(SGE_TSAFE));
+  rb_define_const(mSDL,"TRANSFORM_TMAP",UINT2NUM(SGE_TTMAP));
+
+  rb_define_const(cBMFont,"TRANSPARENT",UINT2NUM(SGE_BFTRANSP));
+  rb_define_const(cBMFont,"NOCONVERT",UINT2NUM(SGE_BFNOCONVERT));
+  rb_define_const(cBMFont,"SFONT",UINT2NUM(SGE_BFSFONT));
+  rb_define_const(cBMFont,"PALETTE",UINT2NUM(SGE_BFPALETTE));
+}
+
+void init_sge_video()
+{
+  sge_Update_OFF();
+  sge_Lock_ON();
+
+  rb_define_module_function(mSDL,"autoLock",sdl_get_autoLocking,0);
+  rb_define_module_function(mSDL,"autoLock=",sdl_set_autoLocking,1);
+
+  rb_define_method(cSurface,"getPixel",sdl_getPixel,2);
+  rb_define_method(cSurface,"putPixel",sdl_putPixel,3);
+  rb_define_method(cSurface,"[]",sdl_getPixel,2);
+  rb_define_method(cSurface,"[]=",sdl_putPixel,3);
+
+  /* primitive drawing */
+  rb_define_method(cSurface,"drawLine",sdl_drawLine,5);
+  rb_define_method(cSurface,"drawRect",sdl_drawRect,5);
+  rb_define_method(cSurface,"drawCircle",sdl_drawCircle,4);
+  rb_define_method(cSurface,"drawFilledCircle",sdl_drawFilledCircle,4);
+  rb_define_method(cSurface,"drawEllispe",sdl_drawEllipse,5);
+  rb_define_method(cSurface,"drawFilledEllispe",sdl_drawFilledEllipse,5);
+  rb_define_method(cSurface,"drawEllipse",sdl_drawEllipse,5);
+  rb_define_method(cSurface,"drawFilledEllipse",sdl_drawFilledEllipse,5);
+  rb_define_method(cSurface,"drawBezier",sdl_drawBezier,10);
+    
+  /* antialiased primitive drawing */
+  rb_define_method(cSurface,"drawAALine",sdl_drawAALine,5);
+  rb_define_method(cSurface,"drawAACircle",sdl_drawAACircle,4);
+  rb_define_method(cSurface,"drawAAFilledCircle",sdl_drawAAFilledCircle,4);
+  rb_define_method(cSurface,"drawAAEllipse",sdl_drawAAEllipse,5);
+  rb_define_method(cSurface,"drawAAFilledEllipse",sdl_drawAAFilledEllipse,5);
+  rb_define_method(cSurface,"drawAABezier",sdl_drawAABezier,10);
+    
+  /* primitive drawing with alpha */
+  rb_define_method(cSurface,"drawLineAlpha",sdl_drawLineAlpha,6);
+  rb_define_method(cSurface,"drawRectAlpha",sdl_drawRectAlpha,6);
+  rb_define_method(cSurface,"drawFilledRectAlpha",sdl_drawFilledRectAlpha,6);
+  rb_define_method(cSurface,"drawCircleAlpha",sdl_drawCircleAlpha,5);
+  rb_define_method(cSurface,"drawFilledCircleAlpha",sdl_drawFilledCircleAlpha,5);
+  rb_define_method(cSurface,"drawEllipseAlpha",sdl_drawEllipseAlpha,6);
+  rb_define_method(cSurface,"drawFilledEllipseAlpha",sdl_drawFilledEllipseAlpha,6);
+  rb_define_method(cSurface,"drawBezierAlpha",sdl_drawBezierAlpha,11);
+    
+  /* antialiased primitive drawing with alpha */
+  rb_define_method(cSurface,"drawAALineAlpha",sdl_drawAALineAlpha,6);
+  rb_define_method(cSurface,"drawAACircleAlpha",sdl_drawAACircleAlpha,5);
+  rb_define_method(cSurface,"drawAAEllipseAlpha",sdl_drawAAEllipseAlpha,6);
+  rb_define_method(cSurface,"drawAABezierAlpha",sdl_drawAABezierAlpha,11);
+    
+  /* rotation and scaling */
+  rb_define_method(cSurface,"rotateScaledSurface",sdl_rotateScaledSurface,3);
+  rb_define_module_function(mSDL,"rotateScaledBlit",sdl_rotateScaledBlit,6);
+  rb_define_module_function(mSDL,"rotateXYScaled",sdl_rotateXYScaled,7);
+
+  rb_define_module_function(mSDL,"transform",sdl_transform,10);
+  rb_define_method(cSurface,"transformSurface",sdl_transformSurface,5);
+
+  /* collision detection */
+  rb_define_method(cSurface,"makeCollisionMap", sdl_makeCollisionMap, 0);
+
+  cCollisionMap = rb_define_class_under(mSDL,"CollisionMap",rb_cObject);
+  rb_define_singleton_method(cCollisionMap,"boundingBoxCheck",
+                             sdl_classBoundingBoxCheck, 8);
+  rb_define_method(cCollisionMap,"collisionCheck", sdl_collisionCheck, 5);
+  rb_define_method(cCollisionMap,"boundingBoxCheck", sdl_boundingBoxCheck, 5);
+  rb_define_method(cCollisionMap,"clear", sdl_unset_cdata, 4);
+  rb_define_method(cCollisionMap,"set", sdl_set_cdata, 4);
+  rb_define_method(cCollisionMap,"w", sdl_w_cdata, 0);
+  rb_define_method(cCollisionMap,"h", sdl_h_cdata, 0);
+
+  /* bitmap font */
+  cBMFont = rb_define_class_under(mSDL,"BMFont",rb_cObject);
+  rb_define_singleton_method(cBMFont,"open",sdl_bf_open,2);
+
+  rb_define_method(cBMFont,"setColor",sdl_bf_setColor,3);
+  rb_define_method(cBMFont,"height",sdl_bf_getHeight,0);
+  rb_define_method(cBMFont,"width",sdl_bf_getWidth,0);
+  rb_define_method(cBMFont,"textSize",sdl_bf_textSize, 1);
+  rb_define_method(cBMFont,"textout",sdl_bf_textout,4);
+
+  defineConstForSGE();
+}
+#endif /* HAVE_SGE */