gosu 0.14.0.pre2 → 0.14.0

data/src/Text.cpp

@@ -12,6 +12,9 @@ using namespace std;
 double Gosu::text_width(const u32string& text,
                         const string& font_name, double font_height, unsigned font_flags)
 {
+    if (font_height <= 0)              throw invalid_argument("font_height must be > 0");
+    if (font_flags >= FF_COMBINATIONS) throw invalid_argument("Invalid font_flags");
+    
     auto& font = font_by_name(font_name, font_flags);
     return font.draw_text(text, font_height, nullptr, 0, 0, Gosu::Color::NONE);
 }
@@ -19,66 +22,90 @@ double Gosu::text_width(const u32string& text,
 double Gosu::draw_text(Bitmap& bitmap, double x, double y, Color c, const u32string& text,
                        const string& font_name, double font_height, unsigned font_flags)
 {
+    if (font_height <= 0)              throw invalid_argument("font_height must be > 0");
+    if (font_flags >= FF_COMBINATIONS) throw invalid_argument("Invalid font_flags");
+
     auto& font = font_by_name(font_name, font_flags);
     return font.draw_text(text, font_height, &bitmap, x, y, c);
 }
 
-Gosu::Bitmap Gosu::create_text(const string& text, const string& font_name, double font_height,
-                               double line_spacing, int width, Alignment align, unsigned font_flags)
+Gosu::Bitmap Gosu::layout_text(const string& text, const string& font_name,
+                               double font_height, double line_spacing,
+                               int width, Alignment align, unsigned font_flags)
 {
-    if (font_height <= 0)            throw invalid_argument("font_height must be > 0");
-    if (width <= 0)                  throw invalid_argument("width must be > 0");
-    if (line_spacing < -font_height) throw invalid_argument("line_spacing must be ≥ -font_height");
-
-    TextBuilder text_builder(font_name, font_height, line_spacing, width, align);
-    
-    // Feed all formatted substrings to the TextBuilder, which will construct the resulting bitmap.
-    // Split the input string into words here, because this method implements word-wrapping.
-    MarkupParser(text.c_str(), font_flags, true, [&text_builder](vector<FormattedString> word) {
-        text_builder.feed_word(move(word));
-    }).parse();
-    
-    return text_builder.move_into_bitmap();
+    return layout_markup(escape_markup(text), font_name,
+                         font_height, line_spacing,
+                         width, align, font_flags);
 }
 
-Gosu::Bitmap Gosu::create_text(const string& text, const string& font_name, double font_height,
-                               unsigned font_flags)
+Gosu::Bitmap Gosu::layout_markup(const string& markup, const string& font_name,
+                                 double font_height, double line_spacing,
+                                 int width, Alignment align, unsigned font_flags)
 {
-    if (font_height <= 0) throw invalid_argument("font_height must be > 0");
-
-    vector<vector<FormattedString>> lines;
-
-    // Split the text into lines (split_words = false) since this method does not break lines.
-    MarkupParser(text.c_str(), font_flags, false, [&lines](vector<FormattedString>&& line) {
-        // Remove trailing \n characters from each line to avoid errors from Gosu::text_width().
-        if (line.back().text.back() == '\n') {
-            line.back().text.pop_back();
-        }
-        
-        lines.emplace_back(line);
-    }).parse();
+    if (font_height <= 0)              throw invalid_argument("font_height must be > 0");
+    if (line_spacing < -font_height)   throw invalid_argument("line_spacing must be ≥ -font_height");
+    if (font_flags >= FF_COMBINATIONS) throw invalid_argument("Invalid font_flags");
     
-    // Measure every part of every line.
-    int width = 0;
-    for (auto& line : lines) {
-        int line_width = 0;
-        for (auto& part : line) {
-            line_width += text_width(part.text, font_name, font_height, part.flags);
-        }
-        width = max(width, line_width);
+    if (width >= 0) {
+        TextBuilder text_builder(font_name, font_height, line_spacing, width, align);
+        
+        // Feed all formatted substrings to the TextBuilder, which will construct the result.
+        // Split the input string into words, because this method implements word-wrapping.
+        MarkupParser parser(font_flags, true, [&text_builder](vector<FormattedString> word) {
+            text_builder.feed_word(move(word));
+        });
+        parser.parse(markup);
+        
+        return text_builder.move_into_bitmap();
     }
-    
-    Bitmap result(width, static_cast<int>(ceil(lines.size() * font_height)));
-    
-    // Render every part of every line.
-    int y = 0;
-    for (auto& line : lines) {
-        int x = 0;
-        for (auto& part : line) {
-            x += draw_text(result, x, y, part.color, part.text, font_name, font_height);
+    else {
+        vector<vector<FormattedString>> lines;
+        
+        // Split the text into lines (split_words = false) since this method does not wrap lines.
+        MarkupParser parser(font_flags, false, [&lines](vector<FormattedString>&& line) {
+            // Remove trailing \n characters from each line to avoid errors from Gosu::text_width().
+            if (line.back().text.back() == '\n') {
+                line.back().text.pop_back();
+            }
+            
+            lines.emplace_back(line);
+        });
+        parser.parse(markup);
+        
+        if (lines.empty()) return Bitmap();
+        
+        // Measure every part of every line.
+        vector<double> line_widths;
+        double max_width = 0;
+        for (auto& line : lines) {
+            line_widths.push_back(0);
+            for (auto& part : line) {
+                line_widths.back() += text_width(part.text, font_name, font_height, part.flags);
+            }
+            max_width = max(max_width, line_widths.back());
         }
-        y += font_height;
+        
+        double height = lines.size() * font_height + (lines.size() - 1) * line_spacing;
+        Bitmap result(ceil(max_width), ceil(height));
+        
+        // Render every part of every line.
+        double y = 0;
+        for (int i = 0; i < lines.size(); ++i) {
+            double x = 0;
+            if (align == AL_CENTER) {
+                x = (result.width() - line_widths[i]) / 2;
+            }
+            else if (align == AL_RIGHT) {
+                x = result.width() - line_widths[i];
+            }
+            
+            for (auto& part : lines[i]) {
+                x = draw_text(result, x, y, part.color, part.text,
+                              font_name, font_height, part.flags);
+            }
+            y += (font_height + line_spacing);
+        }
+        
+        return result;
     }
-    
-    return result;
 }

data/src/TextBuilder.cpp

@@ -21,7 +21,7 @@ Gosu::WordInfo::WordInfo(const string& font_name, double font_height, vector<For
     
     width = 0;
     for (const auto& part : parts) {
-        assert (! part.text.empty());
+        assert (is_end_of_line || ! part.text.empty());
         
         width += text_width(part.text, font_name, font_height, part.flags);
     }

data/src/TimingUnix.cpp

@@ -17,7 +17,7 @@ unsigned long Gosu::milliseconds()
     timeval tp;
     gettimeofday(&tp, nullptr);
 
-    if (!start) {
+    if (start == 0) {
         start = tp.tv_usec / 1000UL + tp.tv_sec * 1000UL;
     }
 

data/src/TrueTypeFont.cpp

@@ -70,16 +70,8 @@ struct Gosu::TrueTypeFont::Impl
                     // Missing characters often come in clusters, so build a substring of
                     // codepoints that this font doesn't contain and then defer to the fallback
                     // font.
-                    u32string fallback_string;
-                    for (; index < text.size(); ++index) {
-                        auto codepoint = text[index];
-                        // Skip control characters.
-                        if (codepoint < ' ') continue;
-                        // Stop as soon as a glyph is available in the current font.
-                        if (stbtt_FindGlyphIndex(&info, codepoint) != 0) break;
-                        
-                        fallback_string.push_back(codepoint);
-                    }
+                    u32string fallback_string = string_of_missing_glyphs(text, index);
+                    index += fallback_string.length();
                     x = fallback->pimpl->draw_text(fallback_string, index == text.size(), height,
                                                    bitmap, x, y, c);
                     last_glyph = 0;
@@ -130,6 +122,21 @@ struct Gosu::TrueTypeFont::Impl
         return max<double>(0, x);
     }
     
+    u32string string_of_missing_glyphs(const u32string& text, u32string::size_type from_index)
+    {
+        u32string result;
+        
+        for (u32string::size_type index = from_index; index < text.size(); ++index) {
+            auto codepoint = text[index];
+            // Stop as soon as a glyph (except control characters) is available in the current font.
+            if (codepoint >= ' ' && stbtt_FindGlyphIndex(&info, codepoint) != 0) break;
+            
+            result.push_back(codepoint);
+        }
+        
+        return result;
+    }
+    
     void draw_glyph(Bitmap& bitmap, double fx, double fy, Color c, int glyph, double scale)
     {
         int x = static_cast<int>(fx);
@@ -146,15 +153,13 @@ struct Gosu::TrueTypeFont::Impl
         free(pixels);
     }
     
-    // This implements the "over" alpha compositing operator, see:
-    // https://en.wikipedia.org/wiki/Alpha_compositing
     void blend_into_bitmap(Bitmap& bitmap, const unsigned char* pixels, int x, int y, int w, int h,
                            Color c)
     {
         int stride = w;
         
         // Instead of transferring all pixels in the range [0; w) x [0; h) into the bitmap, clip
-        // these values because Bitmap::set_pixel does not perform bounds checking.
+        // these values because Bitmap::blend_pixel does not perform bounds checking.
         
         int src_x = 0;
         if (x < 0) {
@@ -175,18 +180,9 @@ struct Gosu::TrueTypeFont::Impl
         
         for (int rel_y = 0; rel_y < h; ++rel_y) {
             for (int rel_x = 0; rel_x < w; ++rel_x) {
-                auto src_alpha = pixels[(src_y + rel_y) * stride + (src_x + rel_x)] * c.alpha() / 255;
-                auto inv_src_alpha = 255 - src_alpha;
-
-                if (src_alpha == 0) continue;
-
-                Color dest = bitmap.get_pixel(x + rel_x, y + rel_y);
-                dest.set_alpha(src_alpha + (dest.alpha() * inv_src_alpha) / 255);
-                dest.set_red  ((c.red()   * src_alpha + dest.red()   * inv_src_alpha) / src_alpha);
-                dest.set_green((c.green() * src_alpha + dest.green() * inv_src_alpha) / src_alpha);
-                dest.set_blue ((c.blue()  * src_alpha + dest.blue()  * inv_src_alpha) / src_alpha);
-                
-                bitmap.set_pixel(x + rel_x, y + rel_y, dest);
+                int pixel = pixels[(src_y + rel_y) * stride + src_x + rel_x];
+                Color c_with_alpha(pixel * c.alpha() / 255, c.red(), c.green(), c.blue());
+                bitmap.blend_pixel(x + rel_x, y + rel_y, c_with_alpha);
             }
         }
     }
@@ -203,9 +199,12 @@ double Gosu::TrueTypeFont::draw_text(const u32string &text, double height,
     return pimpl->draw_text(text, true, height, bitmap, x, y, c);
 }
 
-bool Gosu::TrueTypeFont::verify_font_name(const unsigned char* ttf_data, const string& font_name)
+bool Gosu::TrueTypeFont::verify_font_name(const unsigned char* ttf_data, const string& font_name, unsigned font_flags)
 {
-    return stbtt_FindMatchingFont(ttf_data, font_name.c_str(), STBTT_MACSTYLE_NONE) >= 0 ||
+    // Gosu's FontFlags enum mostly uses the same values as the STBTT_ macros.
+    int flags = (font_flags == 0 ? STBTT_MACSTYLE_NONE : font_flags);
+
+    return stbtt_FindMatchingFont(ttf_data, font_name.c_str(), font_flags) >= 0 ||
            stbtt_FindMatchingFont(ttf_data, font_name.c_str(), STBTT_MACSTYLE_DONTCARE) >= 0;
 }
 

data/src/TrueTypeFont.hpp

@@ -25,7 +25,8 @@ namespace Gosu
                          Bitmap* bitmap, double x, double y, Color c);
         
         //! Returns true if the supplied buffer seems to be a font of the given name.
-        static bool verify_font_name(const unsigned char* ttf_data, const std::string& font_name);
+        static bool verify_font_name(const unsigned char* ttf_data, 
+                                     const std::string& font_name, unsigned font_flags);
     };
     
     TrueTypeFont& font_by_name(const std::string& font_name, unsigned font_flags);

data/src/TrueTypeFontUnix.cpp

@@ -80,7 +80,7 @@ const unsigned char* Gosu::ttf_fallback_data()
     static const unsigned char* unifont = ttf_data_by_name("Unifont", 0);
     if (unifont) return unifont;
     
-    return ttf_data_from_file("/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf", 0);
+    return ttf_data_from_file("/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf");
 }
 
 string Gosu::default_font_name()

data/src/TrueTypeFontWin.cpp

@@ -27,16 +27,16 @@ const unsigned char* Gosu::ttf_data_by_name(const string& font_name, unsigned fo
     if (buffer_ptr) return static_cast<const unsigned char*>(buffer_ptr->data());
 
     LOGFONT logfont = {
-        20 /* arbitrary font height */, 0, 0, 0,
+        0, 0, 0, 0,
         (font_flags & Gosu::FF_BOLD) ? FW_BOLD : FW_NORMAL,
         (font_flags & Gosu::FF_ITALIC) ? TRUE : FALSE,
         (font_flags & Gosu::FF_UNDERLINE) ? TRUE : FALSE,
         FALSE /* no strikethrough */,
-        DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, ANTIALIASED_QUALITY,
+        ANSI_CHARSET, OUT_OUTLINE_PRECIS, CLIP_DEFAULT_PRECIS, ANTIALIASED_QUALITY,
         DEFAULT_PITCH | FF_DONTCARE
     };
     
-    wstring wfont_name = utf8_to_wstring(font_name);
+    wstring wfont_name = utf8_to_utf16(font_name);
     wcsncpy(logfont.lfFaceName, wfont_name.c_str(), LF_FACESIZE);
     logfont.lfFaceName[LF_FACESIZE - 1] = 0;
     
@@ -49,7 +49,7 @@ const unsigned char* Gosu::ttf_data_by_name(const string& font_name, unsigned fo
                 buffer->resize(ttf_buffer_size);
                 if (GetFontData(hdc, 0, 0, buffer->data(), buffer->size()) != GDI_ERROR) {
                     auto data = static_cast<const unsigned char*>(buffer->data());
-                    if (TrueTypeFont::verify_font_name(data, font_name)) {
+                    if (TrueTypeFont::verify_font_name(data, font_name, font_flags)) {
                         buffer_ptr = buffer;
                     }
                 }

data/src/Utility.cpp

@@ -3,64 +3,10 @@
 
 #include "utf8proc.h"
 
-#include <cstddef>
-#include <cstdlib>
 #include <cstring>
-#include <cwchar>
-#include <cwctype>
-#include <algorithm>
 #include <stdexcept>
-#include <vector>
 using namespace std;
 
-#ifndef GOSU_IS_IPHONE
-
-#ifndef GOSU_IS_WIN
-#include "Iconv.hpp"
-#endif
-using namespace std;
-
-#ifndef GOSU_IS_WIN
-namespace
-{
-    extern const char UTF_8[] = "UTF-8";
-#ifdef __BIG_ENDIAN__
-    extern const char UCS_4_INTERNAL[] = "UCS-4BE";
-#else
-    extern const char UCS_4_INTERNAL[] = "UCS-4LE";
-#endif
-}
-
-wstring Gosu::utf8_to_wstring(const string& s)
-{
-    return iconvert<wstring, UCS_4_INTERNAL, UTF_8>(s);
-}
-string Gosu::wstring_to_utf8(const wstring& ws)
-{
-    return iconvert<string, UTF_8, UCS_4_INTERNAL>(ws);
-}
-
-#else
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif
-#include <windows.h>
-wstring Gosu::utf8_to_wstring(const string& utf8)
-{
-    vector<wchar_t> buffer(utf8.size() + 1);
-    MultiByteToWideChar(CP_UTF8, 0, utf8.c_str(), utf8.size() + 1, &buffer[0], buffer.size());
-    return &buffer[0];
-}
-string Gosu::wstring_to_utf8(const wstring& ws)
-{
-    unsigned size = WideCharToMultiByte(CP_UTF8, 0, ws.c_str(), ws.size(), 0, 0, 0, 0);
-    vector<char> buffer(size + 1);
-    WideCharToMultiByte(CP_UTF8, 0, ws.c_str(), ws.size(), &buffer[0], buffer.size(), 0, 0);
-    return &buffer[0];
-}
-#endif
-#endif
-
 u32string Gosu::utf8_to_composed_utc4(const string& utf8)
 {
     u32string utc4;

data/src/UtilityApple.cpp

@@ -3,43 +3,8 @@
 
 #import <Gosu/Utility.hpp>
 #import <Foundation/Foundation.h>
-#import <stdexcept>
-#import <vector>
 using namespace std;
 
-#ifdef GOSU_IS_IPHONE
-wstring Gosu::utf8_to_wstring(const string& s)
-{
-    if (s.empty()) return wstring();
-    
-    NSString* string = [NSString stringWithUTF8String:s.c_str()];
-    vector<wchar_t> buffer(s.size());
-    NSUInteger buffer_size;
-    if (![string getBytes:&buffer[0]
-                maxLength:buffer.size() * sizeof(wchar_t)
-               usedLength:&buffer_size
-                 encoding:NSUTF32LittleEndianStringEncoding
-                  options:0
-                    range:NSMakeRange(0, string.length)
-           remainingRange:nullptr]) {
-        throw runtime_error("String " + s + " could not be converted to UTF-32");
-    }
-    return wstring(&buffer[0], &buffer[0] + buffer_size / sizeof(wchar_t));
-}
-
-string Gosu::wstring_to_utf8(const wstring& ws)
-{
-    if (ws.empty()) return string();
-
-    @autoreleasepool {
-        NSString* string = [[NSString alloc] initWithBytes:ws.data()
-                                                    length:ws.size() * sizeof(wchar_t)
-                                                  encoding:NSUTF32LittleEndianStringEncoding];
-        return string.UTF8String ?: "";
-    }
-}
-#endif
-
 string Gosu::language()
 {
     @autoreleasepool {

data/src/WinUtility.cpp

@@ -1,42 +1,61 @@
-#include <Gosu/Platform.hpp>
-#if defined(GOSU_IS_WIN)
-
-#include "WinUtility.hpp"
-#include <Gosu/Utility.hpp>
-#include <stdexcept>
+#include <Gosu/Platform.hpp>
+#if defined(GOSU_IS_WIN)
+
+#include "WinUtility.hpp"
+#include <Gosu/Utility.hpp>
+#include <stdexcept>
 #include <windows.h>
-using namespace std;
-
-void Gosu::throw_last_winapi_error(const string& action)
-{
-    // Obtain error message from Windows.
-    wchar_t* buffer;
-                 
-    if (!FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
-                        FORMAT_MESSAGE_FROM_SYSTEM |
-                        FORMAT_MESSAGE_IGNORE_INSERTS, 0, GetLastError(),
-                        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPWSTR) &buffer, 0, 0)
-            || buffer == nullptr) {
-        throw runtime_error("Unknown error");
-    }
-
-    // Safely move the message into a string.
-    string message;
-    try {
-        message = wstring_to_utf8(buffer);
-    }
-    catch (...) {
-        LocalFree(buffer);
-        throw;
-    }
-    LocalFree(buffer);
-    
-    // Optionally prepend the action.
-    if (!action.empty()) {
-        message = "While " + action + ", the following error occured: " + message;
-    }
-
-    throw runtime_error(message);
-}
-
-#endif
+using namespace std;
+
+wstring Gosu::utf8_to_utf16(const string& utf8)
+{
+    wstring utf16(utf8.size(), '\0');
+    auto len = MultiByteToWideChar(CP_UTF8, 0, utf8.data(), utf8.size(),
+                                   const_cast<wchar_t*>(utf16.data()), utf16.size());
+    utf16.resize(len);
+    return utf16;
+}
+
+string Gosu::utf16_to_utf8(const wstring& utf16)
+{
+    auto len = WideCharToMultiByte(CP_UTF8, 0, utf16.c_str(), utf16.size(),
+                                   nullptr, 0, nullptr, nullptr);
+    string utf8(len, '\0');
+    WideCharToMultiByte(CP_UTF8, 0, utf16.c_str(), utf16.size(),
+                        const_cast<char*>(utf8.data()), utf8.size(), nullptr, nullptr);
+    return utf8;
+}
+
+void Gosu::throw_last_winapi_error(const string& action)
+{
+    // Obtain error message from Windows.
+    wchar_t* buffer;
+                 
+    if (!FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+                        FORMAT_MESSAGE_FROM_SYSTEM |
+                        FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, GetLastError(),
+                        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPWSTR) &buffer, 0, nullptr)
+            || buffer == nullptr) {
+        throw runtime_error("Unknown error");
+    }
+
+    // Safely move the message into a string.
+    string message;
+    try {
+        message = utf16_to_utf8(buffer);
+    }
+    catch (...) {
+        LocalFree(buffer);
+        throw;
+    }
+    LocalFree(buffer);
+    
+    // Optionally prepend the action.
+    if (!action.empty()) {
+        message = "While " + action + ", the following error occured: " + message;
+    }
+
+    throw runtime_error(message);
+}
+
+#endif