gosu 0.10.9.pre1 → 0.11.0

data/{ext/gosu/gosu_wrap.h → src/RubyGosu.h}

@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------------
  * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 3.0.10
+ * Version 3.0.11
  *
  * This file is not intended to be easily readable and contains a number of
  * coding conventions designed to improve portability and efficiency. Do not make
@@ -21,25 +21,25 @@ class SwigDirector_TextInput : public Gosu::TextInput, public Swig::Director {
 public:
     SwigDirector_TextInput(VALUE self);
     virtual ~SwigDirector_TextInput();
-    virtual std::wstring filter(std::wstring const &text) const;
+    virtual std::string filter(std::string text) const;
 };
 
 
 class SwigDirector_Window : public Gosu::Window, public Swig::Director {
 
 public:
-    SwigDirector_Window(VALUE self, unsigned int width, unsigned int height, bool fullscreen = false, double updateInterval = 16.666666);
+    SwigDirector_Window(VALUE self, unsigned int width, unsigned int height, bool fullscreen = false, double update_interval = 16.666666);
     virtual ~SwigDirector_Window();
     virtual void show();
     virtual bool tick();
     virtual void update();
     virtual void draw();
-    virtual bool needsRedraw() const;
-    virtual bool needsCursor() const;
-    virtual void loseFocus();
-    virtual void releaseMemory();
-    virtual void buttonDown(Gosu::Button arg0);
-    virtual void buttonUp(Gosu::Button arg0);
+    virtual bool needs_redraw() const;
+    virtual bool needs_cursor() const;
+    virtual void lose_focus();
+    virtual void release_memory();
+    virtual void button_down(Gosu::Button arg0);
+    virtual void button_up(Gosu::Button arg0);
 };
 
 

data/src/{Audio/SndFile.hpp → SndFile.hpp}

@@ -1,11 +1,15 @@
-#ifndef GOSU_SRC_AUDIO_SNDFILE_HPP
-#define GOSU_SRC_AUDIO_SNDFILE_HPP
+#pragma once
 
 #include <Gosu/Audio.hpp>
 #include <Gosu/Platform.hpp>
 #include <Gosu/Utility.hpp>
 #include <sndfile.h>
 
+#ifdef GOSU_IS_WIN
+#define NOMINMAX
+#include <windows.h>
+#endif
+
 namespace Gosu
 {
     class SndFile : public AudioFile
@@ -21,60 +25,65 @@ namespace Gosu
         static HMODULE dll()
         {
             static HMODULE dll = LoadLibrary(L"libsndfile.dll");
-            if (!dll)
-                throw std::runtime_error("Cannot find libsndfile.dll");
-
+            if (!dll) throw std::runtime_error("Cannot find libsndfile.dll");
             return dll;
         }
         
         #define CREATE_STUB(NAME, RETURN, PARAMS, NAMES)                    \
         static RETURN NAME PARAMS                                           \
         {                                                                   \
-            typedef RETURN (__cdecl *NAME##_ptr) PARAMS;                            \
+            typedef RETURN (__cdecl *NAME##_ptr) PARAMS;                    \
             static NAME##_ptr f = (NAME##_ptr)GetProcAddress(dll(), #NAME); \
-            if (!f)                                                         \
+            if (!f) {                                                       \
                 throw std::runtime_error("Cannot find " ## #NAME);          \
+            }                                                               \
             return f NAMES;                                                 \
         }
         CREATE_STUB(sf_open_virtual, SNDFILE*,
             (SF_VIRTUAL_IO* sfvirtual, int mode, SF_INFO* sfinfo, void* user_data),
             (sfvirtual, mode, sfinfo, user_data))
         CREATE_STUB(sf_close, int,
-            (SNDFILE *sndfile),
+            (SNDFILE* sndfile),
             (sndfile))
         CREATE_STUB(sf_readf_short, sf_count_t,
-            (SNDFILE *sndfile, short *ptr, sf_count_t items),
+            (SNDFILE* sndfile, short* ptr, sf_count_t items),
             (sndfile, ptr, items))
         CREATE_STUB(sf_seek, sf_count_t,
-            (SNDFILE *sndfile, sf_count_t frames, int whence),
+            (SNDFILE* sndfile, sf_count_t frames, int whence),
             (sndfile, frames, whence))
         CREATE_STUB(sf_strerror, const char*,
             (SNDFILE* sndfile),
             (sndfile))
+        #undef CREATE_STUB
         #endif
         
-        static sf_count_t get_filelen(SndFile *self)
+        static sf_count_t get_filelen(SndFile* self)
         {
             return self->buffer.size();
         }
         
-        static sf_count_t seek(sf_count_t offset, int whence, SndFile *self)
+        static sf_count_t seek(sf_count_t offset, int whence, SndFile* self)
         {
-            switch (whence)
-            {
-            case SEEK_SET: self->reader.setPosition(offset); break;
-            case SEEK_CUR: self->reader.seek(offset); break;
-            case SEEK_END: self->reader.setPosition(self->buffer.size() - offset); break;
+            switch (whence) {
+            case SEEK_SET:
+                self->reader.set_position(offset);
+                break;
+            case SEEK_CUR:
+                self->reader.seek(offset);
+                break;
+            case SEEK_END:
+                self->reader.set_position(self->buffer.size() - offset);
+                break;
             }
 
             if (self->reader.position() > self->buffer.size()) {
-                self->reader.setPosition(self->buffer.size());
+                self->reader.set_position(self->buffer.size());
             }
-			
+            
             return 0;
         }
         
-        static sf_count_t read(void *ptr, sf_count_t count, SndFile *self)
+        static sf_count_t read(void* ptr, sf_count_t count, SndFile* self)
         {
             sf_count_t avail = self->buffer.size() - self->reader.position();
             count = std::min(avail, count);
@@ -82,58 +91,62 @@ namespace Gosu
             return count;
         }
         
-        static sf_count_t tell(SndFile *self)
+        static sf_count_t tell(SndFile* self)
         {
             return self->reader.position();
         }
         
-        static SF_VIRTUAL_IO* ioInterface()
+        static SF_VIRTUAL_IO* io_interface()
         {
             static SF_VIRTUAL_IO io;
             io.get_filelen = (sf_vio_get_filelen)&get_filelen;
             io.seek        = (sf_vio_seek)&seek;
             io.read        = (sf_vio_read)&read;
             io.tell        = (sf_vio_tell)&tell;
-            io.write       = NULL;
+            io.write       = nullptr;
             return &io;
         }
         
     public:
         SndFile(Reader reader)
-        :   file(NULL), reader(buffer.frontReader())
+        : file(nullptr), reader(buffer.front_reader())
         {
             info.format = 0;
             buffer.resize(reader.resource().size() - reader.position());
             reader.read(buffer.data(), buffer.size());
-            file = sf_open_virtual(ioInterface(), SFM_READ, &info, this);
-            if (!file)
-                throw std::runtime_error(std::string(sf_strerror(NULL)));
+            file = sf_open_virtual(io_interface(), SFM_READ, &info, this);
+            if (!file) {
+                throw std::runtime_error(sf_strerror(nullptr));
+            }
         }
         
-        SndFile(const std::wstring& filename)
-        :   file(NULL), reader(buffer.frontReader())
+        SndFile(const std::string& filename)
+        : file(nullptr), reader(buffer.front_reader())
         {
             info.format = 0;
+            // TODO: Not sure if this is still necessary.
+            // Can libsndfile open UTF-8 filenames on Windows?
             #ifdef GOSU_IS_WIN
-            loadFile(buffer, filename);
-            file = sf_open_virtual(ioInterface(), SFM_READ, &info, this);
+            load_file(buffer, filename);
+            file = sf_open_virtual(io_interface(), SFM_READ, &info, this);
             #else
-            file = sf_open(wstringToUTF8(filename).c_str(), SFM_READ, &info);
+            file = sf_open(filename.c_str(), SFM_READ, &info);
             #endif
-            if (!file)
-                throw std::runtime_error(std::string(sf_strerror(NULL)));
+            if (!file) {
+                throw std::runtime_error(sf_strerror(nullptr));
+            }
         }
         
         ~SndFile()
         {
-            if (file)
+            if (file) {
                 sf_close(file);
+            }
         }
         
         ALenum format() const
         {
-            switch (info.channels)
-            {
+            switch (info.channels) {
             case 1:
                 return AL_FORMAT_MONO16;
             case 2:
@@ -143,15 +156,15 @@ namespace Gosu
             };
         }
         
-        ALuint sampleRate() const
+        ALuint sample_rate() const
         {
             return info.samplerate;
         }
         
-        std::size_t readData(void* dest, std::size_t length)
+        std::size_t read_data(void* dest, std::size_t length)
         {
-            int frameSize = sizeof(short) * info.channels;
-            return sf_readf_short(file, (short*)dest, length / frameSize) * frameSize;
+            int frame_size = sizeof(short) * info.channels;
+            return sf_readf_short(file, (short*)dest, length / frame_size) * frame_size;
         }
         
         void rewind()
@@ -160,5 +173,3 @@ namespace Gosu
         }
     };
 }
-
-#endif

data/src/TexChunk.cpp

@@ -0,0 +1,117 @@
+#include "TexChunk.hpp"
+#include "DrawOpQueue.hpp"
+#include "Texture.hpp"
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/Graphics.hpp>
+
+void Gosu::TexChunk::set_tex_info()
+{
+    info.tex_name = texture->tex_name();
+    float texture_size = texture->size();
+    info.left = x / texture_size;
+    info.top = y / texture_size;
+    info.right = (x + w) / texture_size;
+    info.bottom = (y + h) / texture_size;
+}
+
+Gosu::TexChunk::TexChunk(std::shared_ptr<Texture> texture, int x, int y, int w, int h, int padding)
+: texture(texture), x(x), y(y), w(w), h(h), padding(padding)
+{
+    set_tex_info();
+}
+
+Gosu::TexChunk::TexChunk(const TexChunk& parent_chunk, int x, int y, int w, int h)
+: texture(parent_chunk.texture), x(parent_chunk.x + x), y(parent_chunk.y + y), w(w), h(h),
+  padding(0)
+{
+    set_tex_info();
+    texture->block(this->x, this->y, this->w, this->h);
+}
+
+Gosu::TexChunk::~TexChunk()
+{
+    texture->free(x - padding, y - padding, w + 2 * padding, h + 2 * padding);
+}
+
+void Gosu::TexChunk::draw(double x1, double y1, Color c1, double x2, double y2, Color c2,
+    double x3, double y3, Color c3, double x4, double y4, Color c4, ZPos z, AlphaMode mode) const
+{
+    DrawOp op;
+    op.render_state.texture = texture;
+    op.render_state.mode = mode;
+    
+    normalize_coordinates(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4);
+    
+    op.vertices_or_block_index = 4;
+    op.vertices[0] = DrawOp::Vertex(x1, y1, c1);
+    op.vertices[1] = DrawOp::Vertex(x2, y2, c2);
+// TODO: Should be harmonized
+#ifdef GOSU_IS_OPENGLES
+    op.vertices[2] = DrawOp::Vertex(x3, y3, c3);
+    op.vertices[3] = DrawOp::Vertex(x4, y4, c4);
+#else
+    op.vertices[3] = DrawOp::Vertex(x3, y3, c3);
+    op.vertices[2] = DrawOp::Vertex(x4, y4, c4);
+#endif
+    op.left = info.left;
+    op.top = info.top;
+    op.right = info.right;
+    op.bottom = info.bottom;
+    
+    op.z = z;
+    Graphics::schedule_draw_op(op);
+}
+
+const Gosu::GLTexInfo* Gosu::TexChunk::gl_tex_info() const
+{
+    return &info;
+}
+
+Gosu::Bitmap Gosu::TexChunk::to_bitmap() const
+{
+    return texture->to_bitmap(x, y, w, h);
+}
+
+std::unique_ptr<Gosu::ImageData> Gosu::TexChunk::subimage(int x, int y, int width, int height) const
+{
+    return std::unique_ptr<Gosu::ImageData>(new TexChunk(*this, x, y, width, height));
+}
+
+void Gosu::TexChunk::insert(const Bitmap& original, int x, int y)
+{
+    // TODO: Should respect border_flags.
+    
+    Bitmap alternate;
+    const Bitmap* bitmap = &original;
+    
+    if (x < 0 || y < 0 || x + original.width() > w || y + original.height() > h) {
+        int offset_x = 0, offset_y = 0;
+        int trimmed_width = original.width(), trimmed_height = original.height();
+        if (x < 0) {
+            offset_x = x;
+            trimmed_width += x;
+            x = 0;
+        }
+        if (y < 0) {
+            offset_y = y;
+            trimmed_height += y;
+            y = 0;
+        }
+        if (x + trimmed_width > w) {
+            trimmed_width -= (w - x - trimmed_width);
+        }
+        if (y + trimmed_height > h) {
+            trimmed_height -= (h - y - trimmed_height);
+        }
+
+        if (trimmed_width <= 0 || trimmed_height <= 0) return;
+        
+        alternate.resize(trimmed_width, trimmed_height);
+        alternate.insert(original, offset_x, offset_y);
+        bitmap = &alternate;
+    }
+    
+    glBindTexture(GL_TEXTURE_2D, tex_name());
+    glTexSubImage2D(GL_TEXTURE_2D, 0, this->x + x, this->y + y, bitmap->width(), bitmap->height(),
+        Color::GL_FORMAT, GL_UNSIGNED_BYTE, bitmap->data());
+}

data/src/{Graphics/TexChunk.hpp → TexChunk.hpp}

@@ -1,27 +1,25 @@
-#ifndef GOSU_SRC_GRAPHICS_TEXCHUNK_HPP
-#define GOSU_SRC_GRAPHICS_TEXCHUNK_HPP
+#pragma once
 
+#include "GraphicsImpl.hpp"
 #include <Gosu/Fwd.hpp>
 #include <Gosu/ImageData.hpp>
-#include <Gosu/TR1.hpp>
-#include "Common.hpp"
 #include <memory>
-#include <vector>
 #include <stdexcept>
+#include <vector>
 
 class Gosu::TexChunk : public Gosu::ImageData
 {
-    std::tr1::shared_ptr<Texture> texture;
+    std::shared_ptr<Texture> texture;
     int x, y, w, h, padding;
     
     // Cached for faster access.
     GLTexInfo info;
     
-    void setTexInfo();
+    void set_tex_info();
     
 public:
-    TexChunk(std::tr1::shared_ptr<Texture> texture, int x, int y, int w, int h, int padding);
-    TexChunk(const TexChunk& parentChunk, int x, int y, int w, int h);
+    TexChunk(std::shared_ptr<Texture> texture, int x, int y, int w, int h, int padding);
+    TexChunk(const TexChunk& parent_chunk, int x, int y, int w, int h);
     ~TexChunk();
 
     int width() const
@@ -34,9 +32,9 @@ public:
         return h;
     }
     
-    GLuint texName() const
+    GLuint tex_name() const
     {
-        return info.texName;
+        return info.tex_name;
     }
     
     void draw(double x1, double y1, Color c1,
@@ -44,12 +42,9 @@ public:
         double x3, double y3, Color c3,
         double x4, double y4, Color c4,
         ZPos z, AlphaMode mode) const;
-        
-    const GLTexInfo* glTexInfo() const;
-    Gosu::Bitmap toBitmap() const;
-    GOSU_UNIQUE_PTR<ImageData> subimage(int x, int y, int width, int height) const;
+
+    const GLTexInfo* gl_tex_info() const;
+    Gosu::Bitmap to_bitmap() const;
+    std::unique_ptr<ImageData> subimage(int x, int y, int width, int height) const;
     void insert(const Bitmap& bitmap, int x, int y);
 };
-
-#endif
-

data/src/Text.cpp

@@ -0,0 +1,371 @@
+#include "FormattedString.hpp"
+#include "GraphicsImpl.hpp"
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/Graphics.hpp>
+#include <Gosu/Image.hpp>
+#include <Gosu/Math.hpp>
+#include <Gosu/Text.hpp>
+#include <Gosu/Utility.hpp>
+#include <cassert>
+#include <cmath>
+#include <algorithm>
+#include <map>
+#include <vector>
+using namespace std;
+
+namespace Gosu
+{
+    namespace
+    {
+        // Just a very simple heuristic that should make Chinese and Japanese text working in most
+        // of the cases.
+        bool is_breaking_asian_glyph(wchar_t ch)
+        {
+            return (ch >= 0x3040 && ch <= 0x3096) || // Hiragana
+                   (ch >= 0x30a0 && ch <= 0x30fa) || // Katakana
+                   (ch >= 0x4e00 && ch <= 0x9fff) || // CJK Unfied Ideographs
+                   (ch >= 0x3400 && ch <= 0x4db5);   // CJK Unified Ideographs Extension A
+        }
+
+        struct WordInfo
+        {
+            FormattedString text;
+            unsigned width;
+            unsigned space_width;
+        };
+        typedef vector<WordInfo> Words;
+
+        // Local helper class which manages building the bitmap from the
+        // collected words.
+        class TextBlockBuilder
+        {
+            Bitmap bmp;
+            unsigned used_lines, allocated_lines;
+
+            string font_name;
+            unsigned font_height;
+            int line_spacing;
+            Alignment align;
+
+            unsigned space_width_;
+
+            void alloc_next_line()
+            {
+                ++used_lines;
+                if (used_lines == allocated_lines) {
+                    allocated_lines += 10;
+                    bmp.resize(bmp.width(),
+                        font_height * allocated_lines + line_spacing * (allocated_lines - 1),
+                        0x00ffffff);
+                }
+            }
+
+        public:
+            TextBlockBuilder(const string& font_name, unsigned font_height, int line_spacing,
+                unsigned width, Alignment align)
+            {
+                used_lines = 0;
+                allocated_lines = 10;
+                
+                bmp.resize(width, (line_spacing + font_height) * allocated_lines, 0x00ffffff);
+
+                this->font_name = font_name;
+                this->font_height = font_height;
+                this->line_spacing = line_spacing;
+                this->align = align;
+
+                space_width_ = text_width(FormattedString(L" ", 0));
+            }
+
+            unsigned width() const
+            {
+                return bmp.width();
+            }
+
+            unsigned text_width(const FormattedString& text) const
+            {
+                if (text.length() == 0) {
+                    return 0;
+                }
+                
+                if (text.entity_at(0)) {
+                    return entity_bitmap(text.entity_at(0)).width();
+                }
+                
+                vector<FormattedString> parts = text.split_parts();
+                unsigned result = 0;
+                for (auto& part : parts) {
+                    string text = wstring_to_utf8(part.unformat());
+                    result += Gosu::text_width(text, font_name, font_height, part.flags_at(0));
+                }
+                return result;
+            }
+
+            void add_line(Words::const_iterator begin, Words::const_iterator end,
+                unsigned words_width, bool override_align)
+            {
+                alloc_next_line();
+                
+                unsigned words = end - begin;
+                
+                unsigned total_spacing = 0;
+                if (begin < end) {
+                    for (auto i = begin; i != end - 1; ++i) {
+                        total_spacing += i->space_width;
+                    }
+                }
+
+                // Where does the line start? (y)
+                unsigned top = (used_lines - 1) * (font_height + line_spacing);
+
+                // Where does the line start? (x)
+                double pos;
+                switch (align) {
+                // Start so that the text touches the right border.
+                case AL_RIGHT:
+                    pos = bmp.width() - words_width - total_spacing;
+                    break;
+
+                // Start so that the text is centered.
+                case AL_CENTER:
+                    pos = bmp.width() - words_width - total_spacing;
+                    pos /= 2;
+                    break;
+
+                // Just start at the left border.
+                default:
+                    pos = 0;
+                }
+                
+                for (auto cur = begin; cur != end; ++cur) {
+                    vector<FormattedString> parts = cur->text.split_parts();
+                    int x = 0;
+                    for (auto& part : parts) {
+                        if (part.entity_at(0)) {
+                            Gosu::Bitmap entity = entity_bitmap(part.entity_at(0));
+                            multiply_bitmap_alpha(entity, part.color_at(0).alpha());
+                            bmp.insert(entity, trunc(pos) + x, trunc(top));
+                            x += entity.width();
+                            continue;
+                        }
+                        
+                        string unformatted_part = wstring_to_utf8(part.unformat());
+                        draw_text(bmp, unformatted_part, trunc(pos) + x, trunc(top),
+                            part.color_at(0), font_name, font_height, part.flags_at(0));
+                        
+                        x += Gosu::text_width(unformatted_part, font_name, font_height,
+                                              part.flags_at(0));
+                    }
+                    
+                    if (align == AL_JUSTIFY && !override_align) {
+                        pos += cur->width + 1.0 * (width() - words_width) / (words - 1);
+                    }
+                    else {
+                        pos += cur->width + cur->space_width;
+                    }
+                }
+            }
+            
+            void add_empty_line()
+            {
+                alloc_next_line();
+            }
+
+            Bitmap result() const
+            {
+                Bitmap result = bmp;
+                result.resize(result.width(),
+                              font_height * used_lines + line_spacing * (used_lines - 1),
+                              0x00ffffff);
+                return result;
+            }
+            
+            unsigned space_width() const
+            {
+                return space_width_;
+            }
+        };
+
+        void process_words(TextBlockBuilder& builder, const Words& words)
+        {
+            if (words.empty()) return builder.add_empty_line();
+
+            // Index into words to the first word in the current line.
+            auto line_begin = words.begin();
+
+            // Used width, in pixels, of the words [line_begin..w[.
+            unsigned words_width = 0;
+
+            // Used width of the spaces between (w-line_begin) words.
+            unsigned spaces_width = 0;
+
+            for (auto w = words.begin(); w != words.end(); ++w) {
+                unsigned new_words_width = words_width + w->width;
+
+                if (new_words_width + spaces_width <= builder.width()) {
+                    // There's enough space for the words [line_begin..w] plus
+                    // the spaces between them: Proceed with the next word.
+                    words_width = new_words_width;
+                    spaces_width += w->space_width;
+                }
+                else {
+                    // No, this word wouldn't fit into the current line: Draw
+                    // the current line, then start a new line with the current
+                    // word.
+                    builder.add_line(line_begin, w, words_width, false);
+
+                    line_begin = w;
+                    words_width = w->width;
+                    spaces_width = w->space_width;
+                }
+            }
+
+            // Draw the last line as well.
+            if (words.empty() || line_begin != words.end()) {
+                builder.add_line(line_begin, words.end(), words_width, true);
+            }
+        }
+        
+        void process_paragraph(TextBlockBuilder& builder, const FormattedString& paragraph)
+        {
+            Words collected_words;
+            
+            unsigned begin_of_word = 0;
+            
+            for (unsigned cur = 0; cur < paragraph.length(); ++cur) {
+                WordInfo new_word;
+
+                if (paragraph.char_at(cur) == L' ') {
+                    // Whitespace:
+                    // Add last word to list if existent
+                    if (begin_of_word != cur) {
+                        new_word.text = paragraph.range(begin_of_word, cur);
+                        new_word.width = builder.text_width(new_word.text);
+                        new_word.space_width = builder.space_width();
+                        collected_words.push_back(new_word);
+                    }
+                    begin_of_word = cur + 1;
+                }
+                else if (is_breaking_asian_glyph(paragraph.char_at(cur))) {
+                    // Asian glyph (treat as single word):
+                    // Add last word to list if existent
+                    if (begin_of_word != cur) {
+                        new_word.text = paragraph.range(begin_of_word, cur);
+                        new_word.width = builder.text_width(new_word.text);
+                        new_word.space_width = 0;
+                        collected_words.push_back(new_word);
+                    }
+                    // Add glyph as a single "word"
+                    new_word.text = paragraph.range(cur, cur + 1);
+                    new_word.width = builder.text_width(new_word.text);
+                    new_word.space_width = 0;
+                    collected_words.push_back(new_word);
+                    begin_of_word = cur + 1;
+                }
+            }
+            if (begin_of_word < paragraph.length()) {
+                WordInfo last_word;
+                last_word.text = paragraph.range(begin_of_word, paragraph.length());
+                last_word.width = builder.text_width(last_word.text);
+                last_word.space_width = 0;
+                collected_words.push_back(last_word);
+            }
+            
+            process_words(builder, collected_words);
+        }
+
+        void process_text(TextBlockBuilder& builder, const FormattedString& text)
+        {
+            vector<FormattedString> paragraphs = text.split_lines();
+            for (auto& paragraph : paragraphs) {
+                process_paragraph(builder, paragraph);
+            }
+        }
+    }
+}
+
+Gosu::Bitmap Gosu::create_text(const string& text, const string& font_name, unsigned font_height,
+    int line_spacing, unsigned width, Alignment align, unsigned font_flags)
+{
+    if (line_spacing <= -static_cast<int>(font_height)) {
+        throw logic_error("negative line spacing of more than line height impossible");
+    }
+
+    wstring wtext = utf8_to_wstring(text);
+    FormattedString fs(wtext.c_str(), font_flags);
+    if (fs.length() == 0) {
+        return Bitmap(width, font_height);
+    }
+    
+    // Set up the builder object which will manage all the drawing and
+    // conversions for us.
+    TextBlockBuilder builder(font_name, font_height, line_spacing, width, align);
+    
+    // Let the process* functions draw everything.
+    process_text(builder, fs);
+    
+    // Done!
+    return builder.result();
+}
+
+// Very easy special case.
+Gosu::Bitmap Gosu::create_text(const string& text, const string& font_name, unsigned font_height,
+    unsigned font_flags)
+{
+    wstring wtext = utf8_to_wstring(text);
+    FormattedString fs(wtext.c_str(), font_flags);
+    if (fs.length() == 0) {
+        return Bitmap(1, font_height);
+    }
+    
+    vector<FormattedString> lines = fs.split_lines();
+    
+    Bitmap bmp(1, lines.size() * font_height);
+    
+    for (int i = 0; i < lines.size(); ++i) {
+        if (lines[i].length() == 0) continue;
+        
+        unsigned x = 0;
+        vector<FormattedString> parts = lines[i].split_parts();
+        for (auto& part : parts) {
+            if (part.length() == 1 && part.entity_at(0)) {
+                Gosu::Bitmap entity = entity_bitmap(part.entity_at(0));
+                multiply_bitmap_alpha(entity, part.color_at(0).alpha());
+                bmp.resize(max(bmp.width(), x + entity.width()), bmp.height(), 0x00ffffff);
+                bmp.insert(entity, x, i * font_height);
+                x += entity.width();
+                continue;
+            }
+
+            assert (part.length() > 0);
+            string unformatted_text = wstring_to_utf8(part.unformat());
+            unsigned part_width = text_width(unformatted_text, font_name, font_height,
+                                             part.flags_at(0));
+            bmp.resize(max(bmp.width(), x + part_width), bmp.height(), 0x00ffffff);
+            draw_text(bmp, unformatted_text, x, i * font_height, part.color_at(0), font_name,
+                font_height, part.flags_at(0));
+            x += part_width;
+        }
+    }
+    
+    return bmp;
+}
+
+static map<string, shared_ptr<Gosu::Bitmap>> entities;
+
+void Gosu::register_entity(const string& name, const Gosu::Bitmap& replacement)
+{
+    entities[name].reset(new Bitmap(replacement));
+}
+
+bool Gosu::is_entity(const string& name)
+{
+    return entities[name].get();
+}
+
+const Gosu::Bitmap& Gosu::entity_bitmap(const string& name)
+{
+    shared_ptr<Gosu::Bitmap>& ptr = entities[name];
+    if (!ptr) throw runtime_error("Unknown entity: " + name);
+    return *ptr;
+}