rubysdl 1.3.0

data/rubysdl_smpeg.c

@@ -0,0 +1,341 @@
+/*
+  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_SMPEG
+#include "rubysdl.h"
+#include "smpeg/smpeg.h"
+
+#ifdef HAVE_SDL_MIXER
+#include "SDL_mixer.h"
+#endif
+
+static SMPEG_Filter* filters[3];
+#define NULL_FILTER 0
+#define BILINEAR_FILTER 1
+#define DEBLOCKING_FILTER 2
+#define NUM_FILTERS 3
+
+static void setInfoToSMPEGInfo(VALUE obj,SMPEG_Info info)
+{
+  rb_iv_set(obj,"@has_audio",BOOL(info.has_audio));
+  rb_iv_set(obj,"@has_video",BOOL(info.has_video));
+  rb_iv_set(obj,"@width",INT2NUM(info.width));
+  rb_iv_set(obj,"@height",INT2NUM(info.height));
+  rb_iv_set(obj,"@current_frame",INT2NUM(info.current_frame));
+  rb_iv_set(obj,"@current_fps",INT2NUM(info.current_fps));
+  rb_iv_set(obj,"@audio_string",rb_str_new2(info.audio_string));
+  rb_iv_set(obj,"@audio_current_frame",INT2NUM(info.audio_current_frame));
+  rb_iv_set(obj,"@current_offset",UINT2NUM(info.current_offset));
+  rb_iv_set(obj,"@total_size",UINT2NUM(info.total_size));
+  rb_iv_set(obj,"@current_time",UINT2NUM(info.current_time));
+  rb_iv_set(obj,"@total_time",UINT2NUM(info.total_time));
+}
+
+static VALUE smpeg_load(VALUE class,VALUE filename)
+{
+  SMPEG *mpeg;
+  VALUE obj;
+  char error_msg[2048];
+    
+  mpeg = SMPEG_new(GETCSTR(filename),NULL,0);
+  if( SMPEG_error(mpeg) ){
+    snprintf(error_msg,sizeof(error_msg),"Couldn't load %s: %s",
+	     GETCSTR(filename),SMPEG_error(mpeg));
+    SMPEG_delete(mpeg);
+    rb_raise(eSDLError,"%s",error_msg);
+  }
+
+  obj = Data_Wrap_Struct(cMPEG,0,SMPEG_delete,mpeg);
+  rb_iv_set(obj,"enable_audio",Qtrue);
+  return obj;
+}
+
+static VALUE smpeg_getInfo(VALUE obj,VALUE infoObj)
+{
+  SMPEG *mpeg;
+  SMPEG_Info info;
+  
+  if( !rb_obj_is_kind_of(infoObj,cMPEGInfo) )
+    rb_raise(rb_eArgError,"type mismatch(expect SDL::MPEG::Info)");
+  Data_Get_Struct(obj,SMPEG,mpeg);
+
+  SMPEG_getinfo(mpeg,&info);
+  setInfoToSMPEGInfo(infoObj,info);
+  
+  return Qnil;
+}
+
+static VALUE smpeg_enableAudio(VALUE obj,VALUE enable)
+{
+  SMPEG *mpeg;
+  Data_Get_Struct(obj,SMPEG,mpeg);
+  rb_iv_set(obj,"enable_audio",enable);
+  return Qnil;
+}
+
+static VALUE smpeg_enableVideo(VALUE obj,VALUE enable)
+{
+  SMPEG *mpeg;
+  Data_Get_Struct(obj,SMPEG,mpeg);
+  SMPEG_enablevideo(mpeg,RTEST(enable));
+  return Qnil;
+}
+
+static VALUE smpeg_status(VALUE obj)
+{
+  SMPEG *mpeg;
+  Data_Get_Struct(obj,SMPEG,mpeg);
+  return INT2FIX(SMPEG_status(mpeg));
+}
+
+static VALUE smpeg_setVolume(VALUE obj,VALUE volume)
+{
+  SMPEG *mpeg;
+  Data_Get_Struct(obj,SMPEG,mpeg);
+  SMPEG_setvolume(mpeg,NUM2INT(volume));
+  return Qnil;
+}
+
+static VALUE smpeg_setDisplay(VALUE obj,VALUE dst)
+{
+  SMPEG *mpeg;
+  SDL_Surface *surface;
+  if( !rb_obj_is_kind_of(dst,cSurface) )
+    rb_raise(rb_eArgError,"type mismatchi(expect Surface)");
+  
+  Data_Get_Struct(obj,SMPEG,mpeg);
+  Data_Get_Struct(dst,SDL_Surface,surface);
+
+  SMPEG_setdisplay(mpeg,surface,NULL,NULL);
+  rb_iv_set(obj,"surface",dst);
+  return Qnil;
+}
+
+static VALUE smpeg_setLoop(VALUE obj,VALUE repeat)
+{
+  SMPEG *mpeg;
+  Data_Get_Struct(obj,SMPEG,mpeg);
+  SMPEG_loop(mpeg,RTEST(repeat));
+  return Qnil;
+}
+
+static VALUE smpeg_scaleXY(VALUE obj,VALUE w,VALUE h)
+{
+  SMPEG *mpeg;
+  Data_Get_Struct(obj,SMPEG,mpeg);
+  SMPEG_scaleXY(mpeg,NUM2INT(w),NUM2INT(h));
+  return Qnil;
+}
+
+static VALUE smpeg_scale(VALUE obj,VALUE scale)
+{
+  SMPEG *mpeg;
+  Data_Get_Struct(obj,SMPEG,mpeg);
+  SMPEG_scale(mpeg,NUM2INT(scale));
+  return Qnil;
+}
+
+static VALUE smpeg_move(VALUE obj,VALUE x,VALUE y)
+{
+  SMPEG *mpeg;
+  Data_Get_Struct(obj,SMPEG,mpeg);
+  SMPEG_move(mpeg,NUM2INT(x),NUM2INT(y));
+  return Qnil;
+}
+
+static VALUE smpeg_setDisplayRegion(VALUE obj,VALUE x,VALUE y,VALUE w,
+				    VALUE h)
+{
+  SMPEG *mpeg;
+  Data_Get_Struct(obj,SMPEG,mpeg);
+  SMPEG_setdisplayregion(mpeg,NUM2INT(x),NUM2INT(y),NUM2INT(w),NUM2INT(h));
+  return Qnil;
+}
+
+static VALUE smpeg_play(VALUE obj)
+{
+  SMPEG *mpeg;
+  int use_audio;
+  
+  Data_Get_Struct(obj,SMPEG,mpeg);
+
+#if HAVE_SDL_MIXER
+  use_audio = RTEST(rb_iv_get(obj,"enable_audio")) &&
+    Mix_QuerySpec( NULL, NULL, NULL );
+
+  if( use_audio ){
+    SDL_AudioSpec audiofmt;
+    Uint16 format;
+    int freq, channels;
+    
+    SMPEG_enableaudio(mpeg, 0);
+    /* Tell SMPEG what the audio format is */
+    Mix_QuerySpec(&freq, &format, &channels);
+    audiofmt.format = format;
+    audiofmt.freq = freq;
+    audiofmt.channels = channels;
+    SMPEG_actualSpec(mpeg, &audiofmt);
+
+    /* Hook in the MPEG music mixer */
+    Mix_HookMusic(NULL,NULL);
+    Mix_HookMusic(SMPEG_playAudioSDL, mpeg);
+    SMPEG_enableaudio(mpeg, 1);
+  }
+#else
+  SMPEG_enableaudio(mpeg, RTEST(rb_iv_get(obj,"enable_audio")));
+#endif
+  
+  SMPEG_play(mpeg);
+  return Qnil;
+}
+
+static VALUE smpeg_pause(VALUE obj)
+{
+  SMPEG *mpeg;
+  Data_Get_Struct(obj,SMPEG,mpeg);
+  SMPEG_pause(mpeg);
+  return Qnil;
+}
+
+static VALUE smpeg_stop(VALUE obj)
+{
+  SMPEG *mpeg;
+  Data_Get_Struct(obj,SMPEG,mpeg);
+  SMPEG_stop(mpeg);
+  Mix_HookMusic(NULL,NULL);
+  return Qnil;
+}
+
+static VALUE smpeg_rewind(VALUE obj)
+{
+  SMPEG *mpeg;
+  Data_Get_Struct(obj,SMPEG,mpeg);
+  SMPEG_rewind(mpeg);
+  return Qnil;
+}
+
+static VALUE smpeg_seek(VALUE obj,VALUE bytes)
+{
+  SMPEG *mpeg;
+  Data_Get_Struct(obj,SMPEG,mpeg);
+  SMPEG_seek(mpeg,NUM2INT(bytes));
+  return Qnil;
+}
+
+static VALUE smpeg_skip(VALUE obj,VALUE seconds)
+{
+  SMPEG *mpeg;
+  Data_Get_Struct(obj,SMPEG,mpeg);
+  SMPEG_skip(mpeg,NUM2DBL(seconds));
+  return Qnil;
+}
+
+static VALUE smpeg_renderFrame(VALUE obj,VALUE framenum)
+{
+  SMPEG *mpeg;
+  Data_Get_Struct(obj,SMPEG,mpeg);
+  SMPEG_renderFrame(mpeg,NUM2INT(framenum));
+  return Qnil;
+}
+
+static VALUE smpeg_renderFinal(VALUE obj,VALUE dst, VALUE x, VALUE y)
+{
+  SMPEG *mpeg;
+  SDL_Surface *surface;
+  if( !rb_obj_is_kind_of(dst,cSurface) )
+    rb_raise(rb_eArgError,"type mismatchi(expect Surface)");
+  
+  Data_Get_Struct(obj,SMPEG,mpeg);
+  Data_Get_Struct(dst,SDL_Surface,surface);
+  
+  SMPEG_renderFinal(mpeg, surface, NUM2INT(x), NUM2INT(y));
+  return Qnil;
+}
+  
+static VALUE smpeg_setFilter(VALUE obj,VALUE filter)
+{
+  SMPEG *mpeg;
+  
+  Data_Get_Struct(obj,SMPEG,mpeg);
+  if( (NUM2INT(filter)<0) || (NUM2INT(filter)>=NUM_FILTERS) )
+    rb_raise(eSDLError,"There isn't that filter");
+  SMPEG_filter(mpeg,filters[NUM2INT(filter)]);
+  return Qnil;
+}
+
+static void defineConstForSMPEG()
+{
+  rb_define_const(cMPEG,"ERROR",INT2FIX(SMPEG_ERROR));
+  rb_define_const(cMPEG,"STOPPED",INT2FIX(SMPEG_STOPPED));
+  rb_define_const(cMPEG,"PLAYING",INT2FIX(SMPEG_PLAYING));
+  rb_define_const(cMPEG,"NULL_FILTER",INT2FIX(NULL_FILTER));
+  rb_define_const(cMPEG,"BILINEAR_FILTER",INT2FIX(BILINEAR_FILTER));
+  rb_define_const(cMPEG,"DEBLOCKING_FILTER",INT2FIX(DEBLOCKING_FILTER));
+}
+
+void init_smpeg()
+{
+  cMPEG = rb_define_class_under(mSDL,"MPEG",rb_cObject);
+  cMPEGInfo = rb_define_class_under(cMPEG,"Info",rb_cObject);
+
+  filters[NULL_FILTER] = SMPEGfilter_null();
+  filters[BILINEAR_FILTER] = SMPEGfilter_bilinear();
+  filters[DEBLOCKING_FILTER] = SMPEGfilter_deblocking();
+
+  defineConstForSMPEG();
+  
+  rb_define_attr(cMPEGInfo,"has_audio",1,0);
+  rb_define_attr(cMPEGInfo,"has_video",1,0);
+  rb_define_attr(cMPEGInfo,"width",1,0);
+  rb_define_attr(cMPEGInfo,"height",1,0);
+  rb_define_attr(cMPEGInfo,"current_frame",1,0);
+  rb_define_attr(cMPEGInfo,"current_fps",1,0);
+  rb_define_attr(cMPEGInfo,"audio_string",1,0);
+  rb_define_attr(cMPEGInfo,"audio_current_frame",1,0);
+  rb_define_attr(cMPEGInfo,"current_offset",1,0);
+  rb_define_attr(cMPEGInfo,"total_size",1,0);
+  rb_define_attr(cMPEGInfo,"current_time",1,0);
+  rb_define_attr(cMPEGInfo,"total_time",1,0);
+
+  rb_define_singleton_method(cMPEG,"load",smpeg_load,1);
+  rb_define_singleton_method(cMPEG,"new",smpeg_load,1);
+
+  rb_define_method(cMPEG,"info",smpeg_getInfo,1);
+  rb_define_method(cMPEG,"enableAudio",smpeg_enableAudio,1);
+  rb_define_method(cMPEG,"enableVideo",smpeg_enableVideo,1);
+  rb_define_method(cMPEG,"status",smpeg_status,0);
+  rb_define_method(cMPEG,"setVolume",smpeg_setVolume,1);
+  rb_define_method(cMPEG,"setDisplay",smpeg_setDisplay,1);
+  rb_define_method(cMPEG,"setLoop",smpeg_setLoop,1);
+  rb_define_method(cMPEG,"scaleXY",smpeg_scaleXY,2);
+  rb_define_method(cMPEG,"scale",smpeg_scale,1);
+  rb_define_method(cMPEG,"move",smpeg_move,1);
+  rb_define_method(cMPEG,"setDisplayRegion",smpeg_setDisplayRegion,4);
+  rb_define_method(cMPEG,"play",smpeg_play,0);
+  rb_define_method(cMPEG,"pause",smpeg_pause,0);
+  rb_define_method(cMPEG,"stop",smpeg_stop,0);
+  rb_define_method(cMPEG,"rewind",smpeg_rewind,0);
+  rb_define_method(cMPEG,"seek",smpeg_seek,1);
+  rb_define_method(cMPEG,"skip",smpeg_skip,1);
+  rb_define_method(cMPEG,"renderFrame",smpeg_renderFrame,1);
+  rb_define_method(cMPEG,"renderFinal",smpeg_renderFinal,3);
+  rb_define_method(cMPEG,"setFilter",smpeg_setFilter,1);
+  
+}
+#endif /* HAVE_SMPEG */

data/rubysdl_time.c

@@ -0,0 +1,36 @@
+/*
+  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 VALUE sdl_getTicks(VALUE mod)
+{
+  return UINT2NUM(SDL_GetTicks());
+}
+static VALUE sdl_delay(VALUE mod,VALUE ms)
+{
+  SDL_Delay(NUM2UINT(ms));
+  return Qnil;
+}
+
+void init_time()
+{
+  rb_define_module_function(mSDL,"getTicks",sdl_getTicks,0);
+  rb_define_module_function(mSDL,"delay",sdl_delay,1);
+}

data/rubysdl_ttf.c

@@ -0,0 +1,324 @@
+/*
+  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_SDL_TTF
+#include "rubysdl.h"
+#include <SDL_ttf.h>
+
+typedef SDL_Surface* (*RenderFunc)(TTF_Font *,const char *,SDL_Color,SDL_Color);
+
+static int ttf_initialized=0;
+static int ttf_finalized=0;
+
+static void ttf_closeFont(TTF_Font *font)
+{
+  if( !ttf_finalized )
+    TTF_CloseFont(font);
+}
+static VALUE sdl_ttf_init(VALUE class)
+{
+  if( TTF_Init()== -1 )
+    rb_raise(eSDLError,"Couldn't initialize TTF engine: %s",TTF_GetError());
+  ttf_initialized=1;
+  return Qnil;
+}
+static VALUE sdl_ttf_wasInit(VALUE class)
+{
+  return BOOL(TTF_WasInit());
+}
+
+static VALUE sdl_ttf_open(int argc, VALUE *argv, VALUE class)
+{
+  TTF_Font *font;
+  VALUE filename, size, index;
+  rb_scan_args( argc, argv, "21", &filename, &size, &index );
+  if( NIL_P(index) )
+    font=TTF_OpenFont( GETCSTR(filename),NUM2INT(size) );
+  else
+#ifdef HAVE_TTF_OPENFONTINDEX
+    font=TTF_OpenFontIndex( GETCSTR(filename),NUM2INT(size),NUM2INT(index) );
+#else
+    if( index != 0)
+      rb_raise(rb_eRuntimeError,"Not supported for selecting indivisual font face by SDL_ttf. The feature is in SDL_ttf 2.0.4 or later.");
+    else
+      font=TTF_OpenFont( GETCSTR(filename),NUM2INT(size) );
+#endif
+  if( font==NULL )
+    rb_raise(eSDLError,"Couldn't open font %s: %s",GETCSTR(filename),
+	     TTF_GetError());
+  return Data_Wrap_Struct(class,0,ttf_closeFont,font);
+}
+static VALUE sdl_ttf_getFontStyle(VALUE obj)
+{
+  TTF_Font *font;
+  Data_Get_Struct(obj,TTF_Font,font);
+  return INT2FIX( TTF_GetFontStyle(font) );
+}
+static VALUE sdl_ttf_setFontStyle(VALUE obj,VALUE style)
+{
+  TTF_Font *font;
+  Data_Get_Struct(obj,TTF_Font,font);
+  TTF_SetFontStyle(font,NUM2UINT(style));
+  return Qnil;
+}
+static VALUE sdl_ttf_getFontFaces(VALUE obj)
+{
+#ifdef TTF_FONTFACES
+  TTF_Font *font;
+  Data_Get_Struct(obj,TTF_Font,font);
+  return UINT2NUM( TTF_FontFaces(font) );
+#else
+  rb_raise(rb_eRuntimeError,"Not supported. The feature is in SDL_ttf 2.0.4 or later.");
+#endif
+}
+static VALUE sdl_ttf_FontFaceIsFixedWidth(VALUE obj)
+{
+#ifdef TTF_FONTISFIXEDWIDTH
+  TTF_Font *font;
+  Data_Get_Struct(obj,TTF_Font,font);
+  if( TTF_FontFaceIsFixedWidth(font) )
+    return Qtrue;
+  else
+    return Qfalse;
+#else
+  rb_raise(rb_eRuntimeError,"Not supported. The feature is in SDL_ttf 2.0.4 or later.");
+#endif
+}
+static VALUE sdl_ttf_FontFaceFamilyName(VALUE obj)
+{
+#ifdef TTF_FONTFACEFAMILYNAME
+  TTF_Font *font;
+  char* name;
+  
+  Data_Get_Struct(obj,TTF_Font,font);
+  name = TTF_FontFaceFamilyName(font);
+  if(name == NULL)
+    return Qnil;
+  else
+    return rb_str_new2(name);
+#else
+  rb_raise(rb_eRuntimeError,"Not supported. The feature is in SDL_ttf 2.0.4 or later.");
+#endif
+}
+static VALUE sdl_ttf_FontFaceStyleName(VALUE obj)
+{
+#ifdef TTF_FONTFACESTYLENAME
+  TTF_Font *font;
+  char* name;
+  
+  Data_Get_Struct(obj,TTF_Font,font);
+  name = TTF_FontFaceStyleName(font);
+  if(name == NULL)
+    return Qnil;
+  else
+    return rb_str_new2( (const char *) );
+#else
+  rb_raise(rb_eRuntimeError,"Not supported. The feature is in SDL_ttf 2.0.4 or later.");
+#endif
+}
+static VALUE sdl_ttf_sizeText(VALUE obj,VALUE text)
+{
+  TTF_Font *font;
+  int w,h;
+  Data_Get_Struct(obj,TTF_Font,font);
+  TTF_SizeUTF8(font,GETCSTR(text),&w,&h);
+  return rb_ary_new3(2,INT2FIX(w),INT2FIX(h));
+}
+
+static VALUE sdl_ttf_fontHeight(VALUE obj)
+{
+  TTF_Font *font;
+  Data_Get_Struct(obj,TTF_Font,font);
+  return INT2FIX(TTF_FontHeight(font));
+}
+
+static VALUE sdl_ttf_fontAscent(VALUE obj)
+{
+  TTF_Font *font;
+  Data_Get_Struct(obj,TTF_Font,font);
+  return INT2FIX(TTF_FontAscent(font));
+}
+
+static VALUE sdl_ttf_fontDescent(VALUE obj)
+{
+  TTF_Font *font;
+  Data_Get_Struct(obj,TTF_Font,font);
+  return INT2FIX(TTF_FontDescent(font));
+}
+
+static VALUE sdl_ttf_fontLineSkip(VALUE obj)
+{
+  TTF_Font *font;
+  Data_Get_Struct(obj,TTF_Font,font);
+  return INT2FIX(TTF_FontLineSkip(font));
+}
+
+static VALUE ttf_draw(VALUE obj,VALUE dest,VALUE text,VALUE x,
+		      VALUE y,VALUE fgr,VALUE fgg,VALUE fgb,
+		      VALUE bgr,VALUE bgg,VALUE bgb,RenderFunc render)
+{
+  TTF_Font *font;
+  SDL_Surface *destSurface, *tmpSurface;
+  SDL_Color fg,bg;
+  SDL_Rect destRect;
+  int result;
+  char *ctext=GETCSTR(text);
+  /* If text=="" , TTF_RenderUTF8_Solid() and etc fail to render */
+  if( ctext[0]=='\0' )return INT2FIX(0);
+  
+  if( !rb_obj_is_kind_of( dest,cSurface ) )
+    rb_raise( rb_eArgError,"type mismatch(expect Surface)");
+  Data_Get_Struct(obj,TTF_Font,font);
+  Data_Get_Struct(dest,SDL_Surface,destSurface);
+  fg.r=NUM2UINT(fgr); fg.g=NUM2UINT(fgg); fg.b=NUM2UINT(fgb);
+  bg.r=NUM2UINT(bgr); bg.g=NUM2UINT(bgg); bg.b=NUM2UINT(bgb);
+  SetRect(destRect,x,y,1,1);
+  
+  tmpSurface=render(font,ctext,fg,bg);
+  if( tmpSurface==NULL )
+    rb_raise(eSDLError,"Text Render fail: %s",TTF_GetError());
+  
+  result=SDL_BlitSurface(tmpSurface,NULL,destSurface,&destRect);
+  SDL_FreeSurface(tmpSurface);
+  if( result == -1 ){
+    rb_raise(eSDLError,"SDL_BlitSurface fail: %s",SDL_GetError());
+  }
+  return INT2NUM(result);
+}
+
+
+static SDL_Surface* ttf_wrap_RenderUTF8_Solid(TTF_Font *font,
+					      const char *text,
+					      SDL_Color fg,
+					      SDL_Color bg)
+{
+  return TTF_RenderUTF8_Solid(font,text,fg);
+}
+
+static VALUE sdl_ttf_drawSolidUTF8(VALUE obj,VALUE dest,VALUE text,VALUE x,
+				   VALUE y,VALUE r,VALUE g,VALUE b)
+{
+  return ttf_draw(obj,dest,text,x,y,r,g,b,1,1,1,ttf_wrap_RenderUTF8_Solid);
+}
+static SDL_Surface* ttf_wrap_RenderUTF8_Blended(TTF_Font *font,
+						const char *text,
+						SDL_Color fg,
+						SDL_Color bg)
+{
+  return TTF_RenderUTF8_Blended(font,text,fg);
+}
+
+static VALUE sdl_ttf_drawBlendedUTF8(VALUE obj,VALUE dest,VALUE text,VALUE x,
+				   VALUE y,VALUE r,VALUE g,VALUE b)
+{
+  return ttf_draw(obj,dest,text,x,y,r,g,b,1,1,1,ttf_wrap_RenderUTF8_Blended);
+}
+
+static VALUE sdl_ttf_drawShadedUTF8(VALUE obj,VALUE dest, VALUE text,VALUE x,
+				    VALUE y,VALUE fgr,VALUE fgg,VALUE fgb,
+				    VALUE bgr,VALUE bgg,VALUE bgb)
+{
+  return ttf_draw(obj,dest,text,x,y,fgr,fgg,fgb,bgr,bgg,bgb,
+		  TTF_RenderUTF8_Shaded);
+}
+
+static VALUE ttf_render(VALUE obj,VALUE text,VALUE fgr,VALUE fgg,VALUE fgb,
+			VALUE bgr,VALUE bgg,VALUE bgb,RenderFunc render)
+{
+  TTF_Font *font;
+  SDL_Surface *surface;
+  SDL_Color fg,bg;
+  
+  Data_Get_Struct(obj,TTF_Font,font);
+  fg.r=NUM2UINT(fgr); fg.g=NUM2UINT(fgg); fg.b=NUM2UINT(fgb);
+  bg.r=NUM2UINT(bgr); bg.g=NUM2UINT(bgg); bg.b=NUM2UINT(bgb);
+  
+  surface = render( font, GETCSTR(text), fg, bg );
+
+  if( surface == NULL )
+    return Qnil;
+
+  return Data_Wrap_Struct(cSurface,0,sdl_freeSurface,surface);
+}
+
+static VALUE sdl_ttf_renderSolidUTF8(VALUE obj,VALUE text,VALUE r,
+				     VALUE g,VALUE b)
+{
+  return ttf_render(obj,text,r,g,b,1,1,1,ttf_wrap_RenderUTF8_Solid);
+}
+
+static VALUE sdl_ttf_renderBlendedUTF8(VALUE obj,VALUE text,VALUE r,
+				     VALUE g,VALUE b)
+{
+  return ttf_render(obj,text,r,g,b,1,1,1,ttf_wrap_RenderUTF8_Blended);
+}
+
+static VALUE sdl_ttf_renderShadedUTF8(VALUE obj,VALUE text,
+				      VALUE fgr,VALUE fgg,VALUE fgb,
+				      VALUE bgr,VALUE bgg,VALUE bgb)
+{
+  return ttf_render(obj,text,fgr,fgg,fgb,bgr,bgg,bgb,TTF_RenderUTF8_Shaded);
+}
+
+static void defineConstForTTF()
+{
+  rb_define_const(cTTF,"STYLE_NORMAL",UINT2NUM(TTF_STYLE_NORMAL));
+  rb_define_const(cTTF,"STYLE_BOLD",UINT2NUM(TTF_STYLE_BOLD));
+  rb_define_const(cTTF,"STYLE_ITALIC",UINT2NUM(TTF_STYLE_ITALIC));
+  rb_define_const(cTTF,"STYLE_UNDERLINE",UINT2NUM(TTF_STYLE_UNDERLINE));
+}
+void init_ttf()
+{
+  cTTF=rb_define_class_under(mSDL,"TTF",rb_cObject);
+  rb_define_singleton_method(cTTF,"init",sdl_ttf_init,0);
+  rb_define_singleton_method(cTTF,"init?",sdl_ttf_wasInit,0);
+  rb_define_singleton_method(cTTF,"open",sdl_ttf_open,-1);
+  
+  rb_define_method(cTTF,"style",sdl_ttf_getFontStyle,0);
+  rb_define_method(cTTF,"style=",sdl_ttf_setFontStyle,1);
+  rb_define_method(cTTF,"textSize",sdl_ttf_sizeText,1);
+  rb_define_method(cTTF,"faces",sdl_ttf_getFontFaces,0);
+  rb_define_method(cTTF,"fixedWidth?",sdl_ttf_FontFaceIsFixedWidth,0);
+  rb_define_method(cTTF,"familyName",sdl_ttf_FontFaceFamilyName,0);
+  rb_define_method(cTTF,"styleName",sdl_ttf_FontFaceStyleName,0);
+
+  rb_define_method(cTTF,"height",sdl_ttf_fontHeight,0);
+  rb_define_method(cTTF,"ascent",sdl_ttf_fontAscent,0);
+  rb_define_method(cTTF,"descent",sdl_ttf_fontDescent,0);
+  rb_define_method(cTTF,"lineSkip",sdl_ttf_fontLineSkip,0);
+  
+  rb_define_method(cTTF,"drawSolidUTF8",sdl_ttf_drawSolidUTF8,7);
+  rb_define_method(cTTF,"drawBlendedUTF8",sdl_ttf_drawBlendedUTF8,7);
+  rb_define_method(cTTF,"drawShadedUTF8",sdl_ttf_drawShadedUTF8,10);
+
+  rb_define_method(cTTF,"renderSolidUTF8",sdl_ttf_renderSolidUTF8,4);
+  rb_define_method(cTTF,"renderBlendedUTF8",sdl_ttf_renderBlendedUTF8,4);
+  rb_define_method(cTTF,"renderShadedUTF8",sdl_ttf_renderShadedUTF8,7);
+  
+  defineConstForTTF();
+}
+void quit_ttf()
+{
+  if(ttf_initialized){
+    TTF_Quit();
+    ttf_finalized=1;
+  }
+}
+
+#endif /* HAVE_SDL_TTF */