gosu 0.13.3 → 0.14.0.pre2

data/src/MarkupParser.hpp

@@ -0,0 +1,61 @@
+#pragma once
+
+#include "GraphicsImpl.hpp"
+#include <functional>
+#include <vector>
+
+namespace Gosu
+{
+    struct FormattedString
+    {
+        std::u32string text;
+        Color color = Color::WHITE;
+        unsigned flags = 0;
+        
+        bool can_be_merged_with(const FormattedString& other) const
+        {
+            return color == other.color && flags == other.flags;
+        }
+    };
+
+    class MarkupParser
+    {
+        // The current parser position.
+        const char* markup;
+        // A substring that will be built up during parsing, then passed to the consumer.
+        std::string substring;
+
+        // Current b/i/u counters. An opening tag increases by 1, a closing tag decreases by 1.
+        // Text is bold/italic/underline when the respective counter is > 0.
+        int b, i, u;
+
+        // Current color stack.
+        std::vector<Color> c{ Color::WHITE };
+
+        enum { IGNORE_WORDS, ADDING_WORD, ADDING_WHITESPACE } word_state;
+        std::vector<FormattedString> substrings;
+        std::function<void (std::vector<FormattedString>)> consumer;
+
+        unsigned flags() const;
+
+        template<size_t N>
+        bool match_and_skip(const char (&chars)[N])
+        {
+            return match_and_skip(chars, N - 1 /* do not match terminating zero */);
+        }
+
+        bool match_and_skip(const char* chars, std::size_t length);
+
+        bool parse_markup();
+        bool parse_escape_entity();
+
+        void add_current_substring();
+        void add_composed_substring(std::u32string&& substring);
+        void flush_to_consumer();
+
+    public:
+        MarkupParser(const char* markup, unsigned base_flags, bool split_words,
+                     std::function<void (std::vector<FormattedString>)> consumer);
+        void parse();
+    };
+}

data/src/Math.cpp

@@ -46,7 +46,7 @@ int Gosu::wrap(int value, int min, int max)
 
 float Gosu::wrap(float value, float min, float max)
 {
-    double result = fmod(value - min, max - min);
+    float result = fmodf(value - min, max - min);
     return result < 0 ? result + max : result + min;
 }
 

data/src/OffScreenTarget.cpp

@@ -0,0 +1,99 @@
+#include "OffScreenTarget.hpp"
+#include "Texture.hpp"
+#include <Gosu/Image.hpp>
+#include <Gosu/Platform.hpp>
+#ifndef GOSU_IS_IPHONE
+#include <SDL.h>
+#endif
+using namespace std;
+
+#ifdef GOSU_IS_OPENGLES
+    #define GOSU_LOAD_GL_EXT(fn, type) \
+        static auto fn = fn ## OES;
+
+    #define GOSU_GL_CONST(name) \
+        name ## _OES
+
+    #define GOSU_GL_DEPTH_COMPONENT \
+        GL_DEPTH_COMPONENT16_OES
+#else
+    #define GOSU_LOAD_GL_EXT(fn, type) \
+        static auto fn = (type) SDL_GL_GetProcAddress(#fn); \
+        if (!fn) throw runtime_error("Unable to load " #fn);
+
+    #define GOSU_GL_CONST(name) \
+        name
+
+    #define GOSU_GL_DEPTH_COMPONENT \
+        GL_DEPTH_COMPONENT
+#endif
+
+Gosu::OffScreenTarget::OffScreenTarget(int width, int height)
+{
+#ifndef GOSU_IS_IPHONE
+    if (!SDL_GL_ExtensionSupported("GL_EXT_framebuffer_object")) {
+        throw runtime_error("Missing GL_EXT_framebuffer_object extension");
+    }
+#endif
+    
+    // Create a new texture that will be our rendering target.
+    texture = make_shared<Texture>(width, height, false);
+    // Mark the full texture as blocked for our TexChunk.
+    texture->block(0, 0, width, height);
+    
+    // Besides the texture, also create a renderbuffer for depth information.
+    // Gosu doesn't use this, but custom OpenGL code could might.
+    GOSU_LOAD_GL_EXT(glGenRenderbuffers, PFNGLGENRENDERBUFFERSPROC);
+    glGenRenderbuffers(1, &renderbuffer);
+    
+    GOSU_LOAD_GL_EXT(glBindRenderbuffer, PFNGLBINDRENDERBUFFERPROC);
+    glBindRenderbuffer(GOSU_GL_CONST(GL_RENDERBUFFER), renderbuffer);
+    
+    GOSU_LOAD_GL_EXT(glRenderbufferStorage, PFNGLRENDERBUFFERSTORAGEPROC);
+    glRenderbufferStorage(GOSU_GL_CONST(GL_RENDERBUFFER), GOSU_GL_DEPTH_COMPONENT, width, height);
+    glBindRenderbuffer(GOSU_GL_CONST(GL_RENDERBUFFER), 0);
+    
+    // Now tie everything together.
+    GOSU_LOAD_GL_EXT(glGenFramebuffers, PFNGLGENFRAMEBUFFERSPROC);
+    glGenFramebuffers(1, &framebuffer);
+    
+    GOSU_LOAD_GL_EXT(glBindFramebuffer, PFNGLBINDFRAMEBUFFERPROC);
+    glBindFramebuffer(GOSU_GL_CONST(GL_FRAMEBUFFER), framebuffer);
+    
+    GOSU_LOAD_GL_EXT(glFramebufferTexture2D, PFNGLFRAMEBUFFERTEXTURE2DPROC);
+    glFramebufferTexture2D(GOSU_GL_CONST(GL_FRAMEBUFFER), GOSU_GL_CONST(GL_COLOR_ATTACHMENT0),
+                           GL_TEXTURE_2D, texture->tex_name(), 0);
+    
+    GOSU_LOAD_GL_EXT(glFramebufferRenderbuffer, PFNGLFRAMEBUFFERRENDERBUFFERPROC);
+    glFramebufferRenderbuffer(GOSU_GL_CONST(GL_FRAMEBUFFER), GOSU_GL_CONST(GL_DEPTH_ATTACHMENT),
+                              GOSU_GL_CONST(GL_RENDERBUFFER), renderbuffer);
+}
+
+Gosu::OffScreenTarget::~OffScreenTarget()
+{
+    try {
+        GOSU_LOAD_GL_EXT(glDeleteRenderbuffers, PFNGLDELETERENDERBUFFERSPROC);
+        glDeleteRenderbuffers(1, &renderbuffer);
+        
+        GOSU_LOAD_GL_EXT(glDeleteFramebuffers, PFNGLDELETEFRAMEBUFFERSPROC);
+        glDeleteFramebuffers(1, &framebuffer);
+    } catch (...) {
+        // If we can't load these functions, just accept the resource leak.
+    }
+}
+
+Gosu::Image Gosu::OffScreenTarget::render(const std::function<void ()>& f)
+{
+    GOSU_LOAD_GL_EXT(glBindFramebuffer, PFNGLBINDFRAMEBUFFERPROC);
+    glBindFramebuffer(GOSU_GL_CONST(GL_FRAMEBUFFER), framebuffer);
+    
+    GOSU_LOAD_GL_EXT(glCheckFramebufferStatus, PFNGLCHECKFRAMEBUFFERSTATUSPROC);
+    GLenum status = glCheckFramebufferStatus(GOSU_GL_CONST(GL_FRAMEBUFFER));
+    if (status != GOSU_GL_CONST(GL_FRAMEBUFFER_COMPLETE)) throw runtime_error("Incomplete framebuffer");
+    
+    f();
+    glBindFramebuffer(GOSU_GL_CONST(GL_FRAMEBUFFER), 0);
+
+    unique_ptr<ImageData> tex_chunk(new TexChunk(texture, 0, 0, texture->width(), texture->height(), 0));
+    return Image(move(tex_chunk));
+}

data/src/OffScreenTarget.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "GraphicsImpl.hpp"
+
+namespace Gosu
+{
+    class OffScreenTarget
+    {
+        std::shared_ptr<Texture> texture;
+        GLuint renderbuffer;
+        GLuint framebuffer;
+        
+        OffScreenTarget(const OffScreenTarget& other) = delete;
+        OffScreenTarget& operator=(const OffScreenTarget& other) = delete;
+        OffScreenTarget(OffScreenTarget&& other) = delete;
+        OffScreenTarget& operator=(OffScreenTarget&& other) = delete;
+        
+    public:
+        OffScreenTarget(int width, int height);
+        ~OffScreenTarget();
+        Gosu::Image render(const std::function<void ()>& f);
+    };
+}

data/src/OggFile.hpp

@@ -5,9 +5,19 @@
 #include <stdexcept>
 #include <string>
 
+// Disable comma warnings in stb headers.
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcomma"
+#endif
+
 #define STB_VORBIS_HEADER_ONLY
 #include "stb_vorbis.c"
 
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
 namespace Gosu
 {
     class OggFile : public AudioFile

data/src/RenderState.hpp

@@ -130,8 +130,6 @@ public:
         if (new_texture == texture) return;
 
         if (new_texture) {
-            // New texture *is* really a texture - change to it.
-            
             if (!texture) {
                 glEnable(GL_TEXTURE_2D);
             }

data/src/Resolution.cpp

@@ -75,12 +75,12 @@ unsigned Gosu::screen_height()
 #if !defined(GOSU_IS_MAC)
 unsigned Gosu::available_width()
 {
-    return Gosu::screen_width() * 0.9;
+    return static_cast<unsigned>(Gosu::screen_width() * 0.9);
 }
 
 unsigned Gosu::available_height()
 {
-    return Gosu::screen_height() * 0.8;
+    return static_cast<unsigned>(Gosu::screen_height() * 0.8);
 }
 #endif
 #endif

data/src/RubyGosu.cxx

@@ -2269,23 +2269,13 @@ namespace Gosu
     }
     
     void al_shutdown();
-    
-    void register_entity(const std::string& name, Gosu::Image* image)
-    {
-        register_entity(name, image->data().to_bitmap());
-    }
 }
 
 #include <cstring>
 #include <ctime>
 #include <sstream>
 
-// Preprocessor check for 1.9 or higher (thanks banister)
-#if defined(ROBJECT_EMBED_LEN_MAX)
 #define ENFORCE_UTF8(val) rb_funcall(val, rb_intern("force_encoding"), 1, rb_str_new2("UTF-8"))
-#else
-#define ENFORCE_UTF8(val)
-#endif
 
 namespace Gosu
 {
@@ -2308,8 +2298,8 @@ namespace Gosu
         VALUE conversion = rb_str_new2("to_blob { self.format = 'RGBA'; self.depth = 8 }");
         VALUE blob = rb_obj_instance_eval(1, &conversion, val);
         rb_check_safe_obj(blob);
-        unsigned width  = NUM2ULONG(rb_funcall(val, rb_intern("columns"), 0));
-        unsigned height = NUM2ULONG(rb_funcall(val, rb_intern("rows"), 0));
+        int width  = NUM2ULONG(rb_funcall(val, rb_intern("columns"), 0));
+        int height = NUM2ULONG(rb_funcall(val, rb_intern("rows"), 0));
         
         std::size_t size = width * height * 4;
         bitmap.resize(width, height, Gosu::Color::NONE);
@@ -2418,6 +2408,10 @@ namespace Gosu
         return new Gosu::Image(Gosu::Graphics::record(width, height, [] { rb_yield(Qnil); }));
     }
     
+    Gosu::Image* render(int width, int height) {
+        return new Gosu::Image(Gosu::Graphics::render(width, height, [] { rb_yield(Qnil); }));
+    }
+    
     // This method cannot be called "transform" because then it would be an ambiguous overload of
     // Gosu::Transform Gosu::transform(...).
     // So it has to be renamed via %rename below... :( - same for the other transformations.
@@ -2787,10 +2781,10 @@ SWIG_AsVal_int (VALUE obj, int *val)
   return res;
 }
 
-SWIGINTERN Gosu::Font *new_Gosu_Font__SWIG_0(Gosu::Window &window,std::string const &font_name,unsigned int height){
+SWIGINTERN Gosu::Font *new_Gosu_Font__SWIG_0(Gosu::Window &window,std::string const &font_name,int height){
         return new Gosu::Font(height, font_name);
     }
-SWIGINTERN Gosu::Font *new_Gosu_Font__SWIG_1(unsigned int height,VALUE options=0){
+SWIGINTERN Gosu::Font *new_Gosu_Font__SWIG_1(int height,VALUE options=0){
         std::string font_name = Gosu::default_font_name();
         
         if (options) {
@@ -2821,78 +2815,6 @@ SWIGINTERN Gosu::Font *new_Gosu_Font__SWIG_1(unsigned int height,VALUE options=0
         
         return new Gosu::Font(height, font_name);
     }
-SWIGINTERN void Gosu_Font_set_image(Gosu::Font *self,wchar_t wc,VALUE source){
-        Gosu::Bitmap bitmap;
-        Gosu::load_bitmap(bitmap, source);
-        self->set_image(wc, Gosu::Image(bitmap, Gosu::IF_SMOOTH));
-    }
-
-#include <float.h>
-
-
-#include <math.h>
-
-
-/* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */
-#ifndef SWIG_isfinite
-/* isfinite() is a macro for C99 */
-# if defined(isfinite)
-#  define SWIG_isfinite(X) (isfinite(X))
-# elif defined __cplusplus && __cplusplus >= 201103L
-/* Use a template so that this works whether isfinite() is std::isfinite() or
- * in the global namespace.  The reality seems to vary between compiler
- * versions.
- *
- * Make sure namespace std exists to avoid compiler warnings.
- *
- * extern "C++" is required as this fragment can end up inside an extern "C" { } block
- */
-namespace std { }
-extern "C++" template<typename T>
-inline int SWIG_isfinite_func(T x) {
-  using namespace std;
-  return isfinite(x);
-}
-#  define SWIG_isfinite(X) (SWIG_isfinite_func(X))
-# elif defined(_MSC_VER)
-#  define SWIG_isfinite(X) (_finite(X))
-# elif defined(__sun) && defined(__SVR4)
-#  include <ieeefp.h>
-#  define SWIG_isfinite(X) (finite(X))
-# endif
-#endif
-
-
-/* Accept infinite as a valid float value unless we are unable to check if a value is finite */
-#ifdef SWIG_isfinite
-# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX) && SWIG_isfinite(X))
-#else
-# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX))
-#endif
-
-
-SWIGINTERN int
-SWIG_AsVal_float (VALUE obj, float *val)
-{
-  double v;
-  int res = SWIG_AsVal_double (obj, &v);
-  if (SWIG_IsOK(res)) {
-    if (SWIG_Float_Overflow_Check(v)) {
-      return SWIG_OverflowError;
-    } else {
-      if (val) *val = static_cast< float >(v);
-    }
-  }  
-  return res;
-}
-
-
-SWIGINTERNINLINE VALUE
-SWIG_From_float  (float value)
-{    
-  return SWIG_From_double  (value);
-}
-
 SWIGINTERN Gosu::Image *new_Gosu_Image(VALUE source,VALUE options=0){
         Gosu::Bitmap bmp;
         Gosu::load_bitmap(bmp, source);
@@ -2955,10 +2877,10 @@ SWIGINTERN Gosu::Image *Gosu_Image_subimage(Gosu::Image *self,int x,int y,int w,
         std::unique_ptr<Gosu::ImageData> image_data = self->data().subimage(x, y, w, h);
         return image_data.get() ? new Gosu::Image(std::move(image_data)) : nullptr;
     }
-SWIGINTERN Gosu::Image *Gosu_Image_from_text(std::string const &text,unsigned int font_height,VALUE options=0){
+SWIGINTERN Gosu::Image *Gosu_Image_from_text(std::string const &text,int font_height,VALUE options=0){
         std::string font = Gosu::default_font_name();
-        unsigned width = 0xfefefefe;
-        unsigned spacing = 0;
+        int width = 0;
+        int spacing = 0;
         Gosu::Alignment align = Gosu::AL_LEFT;
         unsigned flags = 0;
         
@@ -3016,7 +2938,7 @@ SWIGINTERN Gosu::Image *Gosu_Image_from_text(std::string const &text,unsigned in
         }
         
         Gosu::Bitmap bitmap;
-        if (width == 0xfefefefe) {
+        if (width == 0) {
             bitmap = Gosu::create_text(text, font, font_height);
         }
         else {
@@ -3104,6 +3026,38 @@ SWIGINTERN void Gosu_Image_insert(Gosu::Image *self,VALUE source,int x,int y){
         Gosu::load_bitmap(bmp, source);
         self->data().insert(bmp, x, y);
     }
+SWIGINTERN std::string Gosu_Image_inspect(Gosu::Image const *self,int max_width=80){
+        try {
+            Gosu::Bitmap bmp = self->data().to_bitmap();
+            // This is the scaled image width inside the ASCII art border, so make sure
+            // there will be room for a leading and trailing '#' character.
+            int w = Gosu::clamp<int>(max_width - 2, 0, bmp.width());
+            // For images with width == 0, the output will have one line per pixel.
+            // Otherwise, scale proportionally.
+            int h = (w ? bmp.height() * w / bmp.width() : bmp.height());
+            
+            // This is the length of one row in the string output, including the border
+            // and a trailing newline.
+            int stride = w + 3;
+            std::string str(stride * (h + 2), '#');
+            str[stride - 1] = '\n'; // first newline
+            str.back()      = '\n'; // last newline
+
+            for (int y = 0; y < h; ++y) {
+                for (int x = 0; x < w; ++x) {
+                    int scaled_x = x * bmp.width()  / w;
+                    int scaled_y = y * bmp.height() / h;
+                    int alpha3bit = bmp.get_pixel(scaled_x, scaled_y).alpha() / 32;
+                    str[(y + 1) * stride + (x + 1)] = " .:ioVM@"[alpha3bit];
+                }
+                str[(y + 1) * stride + (w + 2)] = '\n'; // newline after row of pixels
+            }
+            return str;
+        }
+        catch (...) {
+            return "<Gosu::Image without bitmap representation>";
+        }
+    }
 SWIGINTERN VALUE Gosu_TextInput_caret_pos(Gosu::TextInput *self){
         std::string prefix = self->text().substr(0, self->caret_pos());
         VALUE rb_prefix = rb_str_new2(prefix.c_str());
@@ -5150,7 +5104,7 @@ _wrap_Font_name(int argc, VALUE *argv, VALUE self) {
   Gosu::Font *arg1 = (Gosu::Font *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  std::string result;
+  std::string *result = 0 ;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -5163,13 +5117,13 @@ _wrap_Font_name(int argc, VALUE *argv, VALUE self) {
   arg1 = reinterpret_cast< Gosu::Font * >(argp1);
   {
     try {
-      result = ((Gosu::Font const *)arg1)->name();
+      result = (std::string *) &((Gosu::Font const *)arg1)->name();
     }
     catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  vresult = SWIG_From_std_string(static_cast< std::string >(result));
+  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
   return vresult;
 fail:
   return Qnil;
@@ -5181,7 +5135,7 @@ _wrap_Font_height(int argc, VALUE *argv, VALUE self) {
   Gosu::Font *arg1 = (Gosu::Font *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  unsigned int result;
+  int result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -5194,13 +5148,13 @@ _wrap_Font_height(int argc, VALUE *argv, VALUE self) {
   arg1 = reinterpret_cast< Gosu::Font * >(argp1);
   {
     try {
-      result = (unsigned int)((Gosu::Font const *)arg1)->height();
+      result = (int)((Gosu::Font const *)arg1)->height();
     }
     catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  vresult = SWIG_From_int(static_cast< int >(result));
   return vresult;
 fail:
   return Qnil;
@@ -5702,15 +5656,184 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_Font_set_image__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  Gosu::Font *arg1 = (Gosu::Font *) 0 ;
+  std::string arg2 ;
+  unsigned int arg3 ;
+  Gosu::Image *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val3 ;
+  int ecode3 = 0 ;
+  void *argp4 ;
+  int res4 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Font, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Font *","set_image", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::Font * >(argp1);
+  {
+    std::string *ptr = (std::string *)0;
+    int res = SWIG_AsPtr_std_string(argv[0], &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","set_image", 2, argv[0] )); 
+    }
+    arg2 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","set_image", 3, argv[1] ));
+  } 
+  arg3 = static_cast< unsigned int >(val3);
+  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Gosu__Image,  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Gosu::Image const &","set_image", 4, argv[2] )); 
+  }
+  if (!argp4) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Gosu::Image const &","set_image", 4, argv[2])); 
+  }
+  arg4 = reinterpret_cast< Gosu::Image * >(argp4);
+  {
+    try {
+      (arg1)->set_image(arg2,arg3,(Gosu::Image const &)*arg4);
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Font_set_image__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  Gosu::Font *arg1 = (Gosu::Font *) 0 ;
+  std::string arg2 ;
+  Gosu::Image *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Font, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Font *","set_image", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::Font * >(argp1);
+  {
+    std::string *ptr = (std::string *)0;
+    int res = SWIG_AsPtr_std_string(argv[0], &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","set_image", 2, argv[0] )); 
+    }
+    arg2 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Gosu__Image,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Gosu::Image const &","set_image", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Gosu::Image const &","set_image", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< Gosu::Image * >(argp3);
+  {
+    try {
+      (arg1)->set_image(arg2,(Gosu::Image const &)*arg3);
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_Font_set_image(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 5) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gosu__Font, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Gosu__Image, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_Font_set_image__SWIG_1(nargs, args, self);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gosu__Font, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Gosu__Image, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            return _wrap_Font_set_image__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 5, "Font.set_image", 
+    "    void Font.set_image(std::string codepoint, unsigned int font_flags, Gosu::Image const &image)\n"
+    "    void Font.set_image(std::string codepoint, Gosu::Image const &image)\n");
+  
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_new_Font__SWIG_0(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = 0 ;
   std::string *arg2 = 0 ;
-  unsigned int arg3 ;
+  int arg3 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   int res2 = SWIG_OLDOBJ ;
-  unsigned int val3 ;
+  int val3 ;
   int ecode3 = 0 ;
   const char *classname SWIGUNUSED = "Gosu::Font";
   Gosu::Font *result = 0 ;
@@ -5737,11 +5860,11 @@ _wrap_new_Font__SWIG_0(int argc, VALUE *argv, VALUE self) {
     }
     arg2 = ptr;
   }
-  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
+  ecode3 = SWIG_AsVal_int(argv[2], &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","Font", 3, argv[2] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","Font", 3, argv[2] ));
   } 
-  arg3 = static_cast< unsigned int >(val3);
+  arg3 = static_cast< int >(val3);
   {
     try {
       result = (Gosu::Font *)new_Gosu_Font__SWIG_0(*arg1,(std::string const &)*arg2,arg3);
@@ -5777,9 +5900,9 @@ _wrap_Font_allocate(int argc, VALUE *argv, VALUE self)
 
 SWIGINTERN VALUE
 _wrap_new_Font__SWIG_1(int argc, VALUE *argv, VALUE self) {
-  unsigned int arg1 ;
+  int arg1 ;
   VALUE arg2 = (VALUE) 0 ;
-  unsigned int val1 ;
+  int val1 ;
   int ecode1 = 0 ;
   const char *classname SWIGUNUSED = "Gosu::Font";
   Gosu::Font *result = 0 ;
@@ -5787,11 +5910,11 @@ _wrap_new_Font__SWIG_1(int argc, VALUE *argv, VALUE self) {
   if ((argc < 1) || (argc > 2)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
+  ecode1 = SWIG_AsVal_int(argv[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned int","Font", 1, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Font", 1, argv[0] ));
   } 
-  arg1 = static_cast< unsigned int >(val1);
+  arg1 = static_cast< int >(val1);
   if (argc > 1) {
     arg2 = argv[1];
   }
@@ -5824,7 +5947,7 @@ SWIGINTERN VALUE _wrap_new_Font(int nargs, VALUE *args, VALUE self) {
   if ((argc >= 1) && (argc <= 2)) {
     int _v;
     {
-      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
+      int res = SWIG_AsVal_int(argv[0], NULL);
       _v = SWIG_CheckState(res);
     }
     if (_v) {
@@ -5847,7 +5970,7 @@ SWIGINTERN VALUE _wrap_new_Font(int nargs, VALUE *args, VALUE self) {
       _v = SWIG_CheckState(res);
       if (_v) {
         {
-          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
+          int res = SWIG_AsVal_int(argv[2], NULL);
           _v = SWIG_CheckState(res);
         }
         if (_v) {
@@ -5859,55 +5982,13 @@ SWIGINTERN VALUE _wrap_new_Font(int nargs, VALUE *args, VALUE self) {
   
 fail:
   Ruby_Format_OverloadedError( argc, 3, "Font.new", 
-    "    Font.new(Gosu::Window &window, std::string const &font_name, unsigned int height)\n"
-    "    Font.new(unsigned int height, VALUE options)\n");
+    "    Font.new(Gosu::Window &window, std::string const &font_name, int height)\n"
+    "    Font.new(int height, VALUE options)\n");
   
   return Qnil;
 }
 
 
-SWIGINTERN VALUE
-_wrap_Font_set_image(int argc, VALUE *argv, VALUE self) {
-  Gosu::Font *arg1 = (Gosu::Font *) 0 ;
-  wchar_t arg2 ;
-  VALUE arg3 = (VALUE) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  
-  if ((argc < 2) || (argc > 2)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Font, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Font *","set_image", 1, self )); 
-  }
-  arg1 = reinterpret_cast< Gosu::Font * >(argp1);
-  {
-    VALUE ruby_string = rb_obj_as_string(argv[0]);
-    char* utf8_string = StringValueCStr(ruby_string);
-    std::wstring ucs_string = Gosu::utf8_to_wstring(utf8_string);
-    if (ucs_string.length() != 1) {
-      rb_raise(rb_eArgError,
-        "A single-character string was expected, but `%s' given",
-        utf8_string);
-    }
-    arg2 = ucs_string[0];
-  }
-  arg3 = argv[1];
-  {
-    try {
-      Gosu_Font_set_image(arg1,arg2,arg3);
-    }
-    catch (const std::exception& e) {
-      SWIG_exception(SWIG_RuntimeError, e.what());
-    }
-  }
-  return Qnil;
-fail:
-  return Qnil;
-}
-
-
 SWIGINTERN void
 free_Gosu_Font(void *self) {
     Gosu::Font *arg1 = (Gosu::Font *)self;
@@ -5973,10 +6054,10 @@ fail:
 SWIGINTERN VALUE
 _wrap_GLTexInfo_left_set(int argc, VALUE *argv, VALUE self) {
   Gosu::GLTexInfo *arg1 = (Gosu::GLTexInfo *) 0 ;
-  float arg2 ;
+  double arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  float val2 ;
+  double val2 ;
   int ecode2 = 0 ;
   
   if ((argc < 1) || (argc > 1)) {
@@ -5987,11 +6068,11 @@ _wrap_GLTexInfo_left_set(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::GLTexInfo *","left", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::GLTexInfo * >(argp1);
-  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","left", 2, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","left", 2, argv[0] ));
   } 
-  arg2 = static_cast< float >(val2);
+  arg2 = static_cast< double >(val2);
   if (arg1) (arg1)->left = arg2;
   return Qnil;
 fail:
@@ -6004,7 +6085,7 @@ _wrap_GLTexInfo_left_get(int argc, VALUE *argv, VALUE self) {
   Gosu::GLTexInfo *arg1 = (Gosu::GLTexInfo *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  float result;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -6015,8 +6096,8 @@ _wrap_GLTexInfo_left_get(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::GLTexInfo *","left", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::GLTexInfo * >(argp1);
-  result = (float) ((arg1)->left);
-  vresult = SWIG_From_float(static_cast< float >(result));
+  result = (double) ((arg1)->left);
+  vresult = SWIG_From_double(static_cast< double >(result));
   return vresult;
 fail:
   return Qnil;
@@ -6026,10 +6107,10 @@ fail:
 SWIGINTERN VALUE
 _wrap_GLTexInfo_right_set(int argc, VALUE *argv, VALUE self) {
   Gosu::GLTexInfo *arg1 = (Gosu::GLTexInfo *) 0 ;
-  float arg2 ;
+  double arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  float val2 ;
+  double val2 ;
   int ecode2 = 0 ;
   
   if ((argc < 1) || (argc > 1)) {
@@ -6040,11 +6121,11 @@ _wrap_GLTexInfo_right_set(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::GLTexInfo *","right", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::GLTexInfo * >(argp1);
-  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","right", 2, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","right", 2, argv[0] ));
   } 
-  arg2 = static_cast< float >(val2);
+  arg2 = static_cast< double >(val2);
   if (arg1) (arg1)->right = arg2;
   return Qnil;
 fail:
@@ -6057,7 +6138,7 @@ _wrap_GLTexInfo_right_get(int argc, VALUE *argv, VALUE self) {
   Gosu::GLTexInfo *arg1 = (Gosu::GLTexInfo *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  float result;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -6068,8 +6149,8 @@ _wrap_GLTexInfo_right_get(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::GLTexInfo *","right", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::GLTexInfo * >(argp1);
-  result = (float) ((arg1)->right);
-  vresult = SWIG_From_float(static_cast< float >(result));
+  result = (double) ((arg1)->right);
+  vresult = SWIG_From_double(static_cast< double >(result));
   return vresult;
 fail:
   return Qnil;
@@ -6079,10 +6160,10 @@ fail:
 SWIGINTERN VALUE
 _wrap_GLTexInfo_top_set(int argc, VALUE *argv, VALUE self) {
   Gosu::GLTexInfo *arg1 = (Gosu::GLTexInfo *) 0 ;
-  float arg2 ;
+  double arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  float val2 ;
+  double val2 ;
   int ecode2 = 0 ;
   
   if ((argc < 1) || (argc > 1)) {
@@ -6093,11 +6174,11 @@ _wrap_GLTexInfo_top_set(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::GLTexInfo *","top", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::GLTexInfo * >(argp1);
-  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","top", 2, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","top", 2, argv[0] ));
   } 
-  arg2 = static_cast< float >(val2);
+  arg2 = static_cast< double >(val2);
   if (arg1) (arg1)->top = arg2;
   return Qnil;
 fail:
@@ -6110,7 +6191,7 @@ _wrap_GLTexInfo_top_get(int argc, VALUE *argv, VALUE self) {
   Gosu::GLTexInfo *arg1 = (Gosu::GLTexInfo *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  float result;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -6121,8 +6202,8 @@ _wrap_GLTexInfo_top_get(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::GLTexInfo *","top", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::GLTexInfo * >(argp1);
-  result = (float) ((arg1)->top);
-  vresult = SWIG_From_float(static_cast< float >(result));
+  result = (double) ((arg1)->top);
+  vresult = SWIG_From_double(static_cast< double >(result));
   return vresult;
 fail:
   return Qnil;
@@ -6132,10 +6213,10 @@ fail:
 SWIGINTERN VALUE
 _wrap_GLTexInfo_bottom_set(int argc, VALUE *argv, VALUE self) {
   Gosu::GLTexInfo *arg1 = (Gosu::GLTexInfo *) 0 ;
-  float arg2 ;
+  double arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  float val2 ;
+  double val2 ;
   int ecode2 = 0 ;
   
   if ((argc < 1) || (argc > 1)) {
@@ -6146,11 +6227,11 @@ _wrap_GLTexInfo_bottom_set(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::GLTexInfo *","bottom", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::GLTexInfo * >(argp1);
-  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","bottom", 2, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","bottom", 2, argv[0] ));
   } 
-  arg2 = static_cast< float >(val2);
+  arg2 = static_cast< double >(val2);
   if (arg1) (arg1)->bottom = arg2;
   return Qnil;
 fail:
@@ -6163,7 +6244,7 @@ _wrap_GLTexInfo_bottom_get(int argc, VALUE *argv, VALUE self) {
   Gosu::GLTexInfo *arg1 = (Gosu::GLTexInfo *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  float result;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -6174,8 +6255,8 @@ _wrap_GLTexInfo_bottom_get(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::GLTexInfo *","bottom", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::GLTexInfo * >(argp1);
-  result = (float) ((arg1)->bottom);
-  vresult = SWIG_From_float(static_cast< float >(result));
+  result = (double) ((arg1)->bottom);
+  vresult = SWIG_From_double(static_cast< double >(result));
   return vresult;
 fail:
   return Qnil;
@@ -7048,10 +7129,10 @@ fail:
 SWIGINTERN VALUE
 _wrap_Image_from_text(int argc, VALUE *argv, VALUE self) {
   std::string *arg1 = 0 ;
-  unsigned int arg2 ;
+  int arg2 ;
   VALUE arg3 = (VALUE) 0 ;
   int res1 = SWIG_OLDOBJ ;
-  unsigned int val2 ;
+  int val2 ;
   int ecode2 = 0 ;
   Gosu::Image *result = 0 ;
   VALUE vresult = Qnil;
@@ -7070,11 +7151,11 @@ _wrap_Image_from_text(int argc, VALUE *argv, VALUE self) {
     }
     arg1 = ptr;
   }
-  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
+  ecode2 = SWIG_AsVal_int(argv[1], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","Gosu_Image_from_text", 2, argv[1] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Gosu_Image_from_text", 2, argv[1] ));
   } 
-  arg2 = static_cast< unsigned int >(val2);
+  arg2 = static_cast< int >(val2);
   if (argc > 2) {
     arg3 = argv[2];
   }
@@ -7480,93 +7561,88 @@ fail:
 }
 
 
-SWIGINTERN void
-free_Gosu_Image(void *self) {
-    Gosu::Image *arg1 = (Gosu::Image *)self;
-    SWIG_RubyRemoveTracking(arg1);
-    delete arg1;
-}
 
+/*
+  Document-method: Gosu::Image.inspect
+
+  call-seq:
+    inspect(max_width=80) -> std::string
+
+Inspect class and its contents.
+*/
 SWIGINTERN VALUE
-_wrap_fps(int argc, VALUE *argv, VALUE self) {
-  int result;
+_wrap_Image_inspect(int argc, VALUE *argv, VALUE self) {
+  Gosu::Image *arg1 = (Gosu::Image *) 0 ;
+  int arg2 = (int) 80 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  std::string result;
   VALUE vresult = Qnil;
   
-  if ((argc < 0) || (argc > 0)) {
+  if ((argc < 0) || (argc > 1)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Image, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Image const *","inspect", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::Image * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_int(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","inspect", 2, argv[0] ));
+    } 
+    arg2 = static_cast< int >(val2);
+  }
   {
     try {
-      result = (int)Gosu::fps();
+      result = Gosu_Image_inspect((Gosu::Image const *)arg1,arg2);
     }
     catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  vresult = SWIG_From_int(static_cast< int >(result));
+  vresult = SWIG_From_std_string(static_cast< std::string >(result));
   return vresult;
 fail:
   return Qnil;
 }
 
 
-static swig_class SwigClassChannel;
-
-SWIGINTERN VALUE
-#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
-_wrap_Channel_allocate(VALUE self)
-#else
-_wrap_Channel_allocate(int argc, VALUE *argv, VALUE self)
-#endif
-{
-  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Gosu__Channel);
-#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
-  rb_obj_call_init(vresult, argc, argv);
-#endif
-  return vresult;
+SWIGINTERN void
+free_Gosu_Image(void *self) {
+    Gosu::Image *arg1 = (Gosu::Image *)self;
+    SWIG_RubyRemoveTracking(arg1);
+    delete arg1;
 }
 
-
 SWIGINTERN VALUE
-_wrap_new_Channel(int argc, VALUE *argv, VALUE self) {
-  int arg1 ;
-  int arg2 ;
-  int val1 ;
-  int ecode1 = 0 ;
-  int val2 ;
-  int ecode2 = 0 ;
-  const char *classname SWIGUNUSED = "Gosu::Channel";
-  Gosu::Channel *result = 0 ;
+_wrap_fps(int argc, VALUE *argv, VALUE self) {
+  int result;
+  VALUE vresult = Qnil;
   
-  if ((argc < 2) || (argc > 2)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  ecode1 = SWIG_AsVal_int(argv[0], &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Channel", 1, argv[0] ));
-  } 
-  arg1 = static_cast< int >(val1);
-  ecode2 = SWIG_AsVal_int(argv[1], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Channel", 2, argv[1] ));
-  } 
-  arg2 = static_cast< int >(val2);
   {
     try {
-      result = (Gosu::Channel *)new Gosu::Channel(arg1,arg2);
-      DATA_PTR(self) = result;
-      SWIG_RubyAddTracking(result, self);
+      result = (int)Gosu::fps();
     }
     catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  return self;
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
 fail:
   return Qnil;
 }
 
 
+static swig_class SwigClassChannel;
+
 SWIGINTERN VALUE
 _wrap_Channel_current_channel(int argc, VALUE *argv, VALUE self) {
   Gosu::Channel *arg1 = (Gosu::Channel *) 0 ;
@@ -7929,7 +8005,7 @@ _wrap_Sample_play(int argc, VALUE *argv, VALUE self) {
   int ecode3 = 0 ;
   bool val4 ;
   int ecode4 = 0 ;
-  SwigValueWrapper< Gosu::Channel > result;
+  Gosu::Channel result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 3)) {
@@ -7993,7 +8069,7 @@ _wrap_Sample_play_pan(int argc, VALUE *argv, VALUE self) {
   int ecode4 = 0 ;
   bool val5 ;
   int ecode5 = 0 ;
-  SwigValueWrapper< Gosu::Channel > result;
+  Gosu::Channel result;
   VALUE vresult = Qnil;
   
   if ((argc < 1) || (argc > 4)) {
@@ -8564,6 +8640,100 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_TextInput_insert_text(int argc, VALUE *argv, VALUE self) {
+  Gosu::TextInput *arg1 = (Gosu::TextInput *) 0 ;
+  std::string arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__TextInput, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::TextInput *","insert_text", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::TextInput * >(argp1);
+  {
+    std::string *ptr = (std::string *)0;
+    int res = SWIG_AsPtr_std_string(argv[0], &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "std::string","insert_text", 2, argv[0] )); 
+    }
+    arg2 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  {
+    try {
+      (arg1)->insert_text(arg2);
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_TextInput_delete_forward(int argc, VALUE *argv, VALUE self) {
+  Gosu::TextInput *arg1 = (Gosu::TextInput *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__TextInput, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::TextInput *","delete_forward", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::TextInput * >(argp1);
+  {
+    try {
+      (arg1)->delete_forward();
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_TextInput_delete_backward(int argc, VALUE *argv, VALUE self) {
+  Gosu::TextInput *arg1 = (Gosu::TextInput *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__TextInput, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::TextInput *","delete_backward", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::TextInput * >(argp1);
+  {
+    try {
+      (arg1)->delete_backward();
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_TextInput_caret_pos(int argc, VALUE *argv, VALUE self) {
   Gosu::TextInput *arg1 = (Gosu::TextInput *) 0 ;
@@ -10910,6 +11080,45 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_render(int argc, VALUE *argv, VALUE self) {
+  int arg1 ;
+  int arg2 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  Gosu::Image *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_int(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Gosu::render", 1, argv[0] ));
+  } 
+  arg1 = static_cast< int >(val1);
+  ecode2 = SWIG_AsVal_int(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Gosu::render", 2, argv[1] ));
+  } 
+  arg2 = static_cast< int >(val2);
+  {
+    try {
+      result = (Gosu::Image *)Gosu::render(arg1,arg2);
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gosu__Image, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_transform(int argc, VALUE *argv, VALUE self) {
   double arg1 ;
@@ -11760,6 +11969,7 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_method(SwigClassImage.klass, "rows", VALUEFUNC(_wrap_Image_rows), -1);
   rb_define_method(SwigClassImage.klass, "save", VALUEFUNC(_wrap_Image_save), -1);
   rb_define_method(SwigClassImage.klass, "insert", VALUEFUNC(_wrap_Image_insert), -1);
+  rb_define_method(SwigClassImage.klass, "inspect", VALUEFUNC(_wrap_Image_inspect), -1);
   SwigClassImage.mark = 0;
   SwigClassImage.destroy = (void (*)(void *)) free_Gosu_Image;
   SwigClassImage.trackObjects = 1;
@@ -11767,8 +11977,7 @@ SWIGEXPORT void Init_gosu(void) {
   
   SwigClassChannel.klass = rb_define_class_under(mGosu, "Channel", rb_cObject);
   SWIG_TypeClientData(SWIGTYPE_p_Gosu__Channel, (void *) &SwigClassChannel);
-  rb_define_alloc_func(SwigClassChannel.klass, _wrap_Channel_allocate);
-  rb_define_method(SwigClassChannel.klass, "initialize", VALUEFUNC(_wrap_new_Channel), -1);
+  rb_undef_alloc_func(SwigClassChannel.klass);
   rb_define_method(SwigClassChannel.klass, "current_channel", VALUEFUNC(_wrap_Channel_current_channel), -1);
   rb_define_method(SwigClassChannel.klass, "playing?", VALUEFUNC(_wrap_Channel_playingq___), -1);
   rb_define_method(SwigClassChannel.klass, "paused?", VALUEFUNC(_wrap_Channel_pausedq___), -1);
@@ -12033,6 +12242,9 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_method(SwigClassTextInput.klass, "text", VALUEFUNC(_wrap_TextInput_text), -1);
   rb_define_method(SwigClassTextInput.klass, "text=", VALUEFUNC(_wrap_TextInput_texte___), -1);
   rb_define_method(SwigClassTextInput.klass, "filter", VALUEFUNC(_wrap_TextInput_filter), -1);
+  rb_define_method(SwigClassTextInput.klass, "insert_text", VALUEFUNC(_wrap_TextInput_insert_text), -1);
+  rb_define_method(SwigClassTextInput.klass, "delete_forward", VALUEFUNC(_wrap_TextInput_delete_forward), -1);
+  rb_define_method(SwigClassTextInput.klass, "delete_backward", VALUEFUNC(_wrap_TextInput_delete_backward), -1);
   rb_define_method(SwigClassTextInput.klass, "caret_pos", VALUEFUNC(_wrap_TextInput_caret_pos), -1);
   rb_define_method(SwigClassTextInput.klass, "caret_pos=", VALUEFUNC(_wrap_TextInput_caret_pose___), -1);
   rb_define_method(SwigClassTextInput.klass, "selection_start", VALUEFUNC(_wrap_TextInput_selection_start), -1);
@@ -12094,6 +12306,7 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_module_function(mGosu, "unsafe_gl", VALUEFUNC(_wrap_unsafe_gl), -1);
   rb_define_module_function(mGosu, "clip_to", VALUEFUNC(_wrap_clip_to), -1);
   rb_define_module_function(mGosu, "record", VALUEFUNC(_wrap_record), -1);
+  rb_define_module_function(mGosu, "render", VALUEFUNC(_wrap_render), -1);
   rb_define_module_function(mGosu, "transform", VALUEFUNC(_wrap_transform), -1);
   rb_define_module_function(mGosu, "rotate", VALUEFUNC(_wrap_rotate), -1);
   rb_define_module_function(mGosu, "scale", VALUEFUNC(_wrap_scale), -1);