gosu 0.13.3 → 0.14.0.pre2

data/src/TrueTypeFont.cpp

@@ -0,0 +1,282 @@
+#include "TrueTypeFont.hpp"
+#include <Gosu/IO.hpp>
+#include <Gosu/Text.hpp>
+
+// Disable comma warnings in stb headers.
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcomma"
+#endif
+
+#define STB_TRUETYPE_IMPLEMENTATION
+#include "stb_truetype.h"
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+#include <algorithm>
+#include <map>
+using namespace std;
+
+struct Gosu::TrueTypeFont::Impl
+{
+    stbtt_fontinfo info;
+    shared_ptr<TrueTypeFont> fallback;
+    
+    // The ascent in internal font metrics (an arbitrary integer scale), that is, the part of the
+    // font above the baseline, which TrueType considers to be at y = 0.
+    int ascent;
+    
+    // Scaling factor from internal font metrics (an arbitrary integer scale) to a font with
+    // height = 1px.
+    double base_scale;
+    
+    Impl(const unsigned char* ttf_data, shared_ptr<TrueTypeFont> fallback)
+    : fallback(move(fallback))
+    {
+        auto offset = stbtt_GetFontOffsetForIndex(ttf_data, 0);
+        int success = stbtt_InitFont(&info, ttf_data, offset);
+        if (!success) throw runtime_error("Invalid TrueType font data");
+        
+        // Calculate metrics.
+        int descent, lineGap;
+        stbtt_GetFontVMetrics(&info, &ascent, &descent, &lineGap);
+        int height = ascent - descent + lineGap;
+        base_scale = 1.0f / height;
+    }
+    
+    // This method always measures text, and also draws it if (bitmap != nullptr).
+    double draw_text(const u32string& text, bool is_end, double height,
+                     Bitmap* bitmap, double x, double y, Color c)
+    {
+        if (text.empty()) return 0;
+
+        // The 'x' parameter is used as the running cursor variable in this method.
+        
+        double scale = base_scale * height;
+        int last_glyph = 0;
+        int last_advance = 0;
+
+        for (u32string::size_type index = 0; index < text.size(); ++index) {
+            auto codepoint = text[index];
+            // Silently skip control characters, including the \r in Windows-style line breaks.
+            if (codepoint < ' ') continue;
+            
+            int glyph = stbtt_FindGlyphIndex(&info, codepoint);
+            // Handle missing characters in this font...
+            if (glyph == 0) {
+                if (fallback) {
+                    // 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);
+                    }
+                    x = fallback->pimpl->draw_text(fallback_string, index == text.size(), height,
+                                                   bitmap, x, y, c);
+                    last_glyph = 0;
+                }
+                continue;
+            }
+            
+            if (last_glyph) {
+                x += stbtt_GetGlyphKernAdvance(&info, last_glyph, glyph) * scale;
+            }
+            
+            // Now finally draw the glyph (if a bitmap was passed).
+            if (bitmap) {
+                // Do not take lsb into account when positioning the glyph: It seems to correspond
+                // to the 'xoff' value returned by stbtt_GetGlyphBitmapSubpixel, and adding both
+                // adds too much spacing between letters.
+                // Ref: https://github.com/nothings/stb/issues/281#issuecomment-361264014
+                draw_glyph(*bitmap, x, y, c, glyph, scale);
+            }
+            
+            int advance;
+            stbtt_GetGlyphHMetrics(&info, glyph, &advance, nullptr);
+            
+            x += advance * scale;
+            last_glyph = glyph;
+            last_advance = advance;
+        }
+        
+        // If this is the end of the string, we need to take another look at the last glyph to avoid
+        // cutting off some pixels that extend to the right of the character.
+        if (is_end && last_glyph) {
+            int ix = static_cast<int>(x);
+            int last_xoff, last_width;
+            // TODO: Don't allocate a buffer just to get metrics!
+            free(stbtt_GetGlyphBitmapSubpixel(&info, scale, scale, x - ix, 0, last_glyph,
+                                              &last_width, nullptr, &last_xoff, nullptr));
+            // Move the cursor to the right if pixels have been touched by draw_glyph that are
+            // to the right of the current cursor.
+            // If the last character extends to the right of the cursor, then this prevents the
+            // rightmost pixels from being truncated.
+            // If the last character was whitespace, then last_width will be 0 (no pixel data)
+            // and the cursor is what counts.
+            x = max<double>(x, x - last_advance * scale + last_xoff + last_width);
+        }
+        
+        // Never return a negative value from this method because it is used to determine bitmap
+        // dimensions.
+        return max<double>(0, x);
+    }
+    
+    void draw_glyph(Bitmap& bitmap, double fx, double fy, Color c, int glyph, double scale)
+    {
+        int x = static_cast<int>(fx);
+        int y = static_cast<int>(fy);
+        int w, h, xoff, yoff;
+        
+        // As an optimization, this method/class could try to re-use a buffer for rasterization
+        // instead of having stb_truetype allocate a fresh one for each draw_glyph call.
+        unsigned char* pixels = stbtt_GetGlyphBitmapSubpixel(&info, scale, scale, fx - x, fy - y,
+                                                             glyph, &w, &h, &xoff, &yoff);
+        
+        blend_into_bitmap(bitmap, pixels, x + xoff, y + ascent * scale + yoff, w, h, c);
+        
+        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.
+        
+        int src_x = 0;
+        if (x < 0) {
+            src_x -= x;
+            w += x;
+            x = 0;
+        }
+        
+        int src_y = 0;
+        if (y < 0) {
+            src_y -= y;
+            h += y;
+            y = 0;
+        }
+        
+        w = min<int>(w, bitmap.width() - x);
+        h = min<int>(h, bitmap.height() - y);
+        
+        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);
+            }
+        }
+    }
+};
+
+Gosu::TrueTypeFont::TrueTypeFont(const unsigned char* ttf_data, shared_ptr<TrueTypeFont> fallback)
+: pimpl(new Impl(ttf_data, fallback))
+{
+}
+
+double Gosu::TrueTypeFont::draw_text(const u32string &text, double height,
+                                     Bitmap *bitmap, double x, double y, Color c)
+{
+    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)
+{
+    return stbtt_FindMatchingFont(ttf_data, font_name.c_str(), STBTT_MACSTYLE_NONE) >= 0 ||
+           stbtt_FindMatchingFont(ttf_data, font_name.c_str(), STBTT_MACSTYLE_DONTCARE) >= 0;
+}
+
+static Gosu::TrueTypeFont& font_with_stack(vector<const unsigned char*> ttf_stack)
+{
+    // TODO: Make this cache thread-safe.
+    static map<const unsigned char*, shared_ptr<Gosu::TrueTypeFont>> cache_by_data;
+    
+    // Filter out any fonts that could not be found, as well as duplicates.
+    auto end = unique(ttf_stack.begin(), ttf_stack.end());
+    end = remove(ttf_stack.begin(), end, nullptr);
+    ttf_stack.erase(end, ttf_stack.end());
+    
+    // This cannot happen because ttf_stack contains ttf_fallback_data(), which never returns null.
+    if (ttf_stack.empty()) throw logic_error("Empty font stack");
+    
+    shared_ptr<Gosu::TrueTypeFont> head_of_stack = nullptr;
+    for (const unsigned char* ttf_data : ttf_stack) {
+        auto& font_ptr = cache_by_data[ttf_data];
+        if (!font_ptr) {
+            font_ptr = make_shared<Gosu::TrueTypeFont>(ttf_data, head_of_stack);
+        }
+        head_of_stack = font_ptr;
+    }
+    return *head_of_stack;
+}
+
+Gosu::TrueTypeFont& Gosu::font_by_name(const string& font_name, unsigned font_flags)
+{
+    // TODO: Make this cache thread-safe.
+    static map<pair<string, unsigned>, TrueTypeFont*> cache_by_name_and_flags;
+    
+    auto& font_ptr = cache_by_name_and_flags[make_pair(font_name, font_flags)];
+    if (!font_ptr) {
+        // Build a stack from worst-case fallback to the desired font.
+        vector<const unsigned char*> ttf_stack;
+        ttf_stack.push_back(ttf_fallback_data());
+        ttf_stack.push_back(ttf_data_by_name(default_font_name(), 0));
+        ttf_stack.push_back(ttf_data_by_name(default_font_name(), font_flags));
+        
+        if (font_name.find_first_of("./\\") != string::npos) {
+            // A filename? Load it and add it to the stack.
+            ttf_stack.push_back(ttf_data_from_file(font_name));
+        } else if (font_name != default_font_name()) {
+            // A font name? Add it to the stack, both with font_flags and without.
+            ttf_stack.push_back(ttf_data_by_name(font_name, 0));
+            ttf_stack.push_back(ttf_data_by_name(font_name, font_flags));
+        }
+        
+        font_ptr = &font_with_stack(move(ttf_stack));
+    }
+    
+    return *font_ptr;
+}
+
+const unsigned char* Gosu::ttf_data_from_file(const string& filename)
+{
+    // TODO: Make this cache thread-safe.
+    static map<string, shared_ptr<Buffer>> ttf_file_cache;
+    
+    auto& buffer_ptr = ttf_file_cache[filename];
+    if (!buffer_ptr) {
+        buffer_ptr = make_shared<Buffer>();
+        try {
+            load_file(*buffer_ptr, filename);
+        }
+        catch (...) {
+            // Prevent partially loaded files from getting stuck in the cache.
+            buffer_ptr = nullptr;
+            throw;
+        }
+    }
+    return static_cast<const unsigned char*>(buffer_ptr->data());
+}

data/src/TrueTypeFont.hpp

@@ -0,0 +1,66 @@
+#pragma once
+
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/IO.hpp>
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace Gosu
+{
+    class TrueTypeFont
+    {
+        struct Impl;
+        std::shared_ptr<Impl> pimpl;
+        
+    public:
+        //! The caller must ensure that the ttf_data pointer will remain valid indefinitely.
+        TrueTypeFont(const unsigned char* ttf_data, std::shared_ptr<TrueTypeFont> fallback);
+        
+        //! Returns the right edge of a string when rendered onto a bitmap at the given position,
+        //! and with the given height.
+        //! If (bitmap != nullptr), the text is also rendered onto the bitmap.
+        double draw_text(const std::u32string& text, double height,
+                         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);
+    };
+    
+    TrueTypeFont& font_by_name(const std::string& font_name, unsigned font_flags);
+    
+    //! Loads the contents of a file into memory and returns a pointer to it.
+    //! The pointer is guaranteed to be valid indefinitely.
+    //! In case of failure, this method must not return nullptr, but raise an exception.
+    //! Note that this method does not accept any font flags, and so it will always load the first
+    //! font in a TTC font collection.
+    const unsigned char* ttf_data_from_file(const std::string& filename);
+    
+    //! This method loads a TODO
+    //! This method has a different implementation on each platform.
+    //! In case of failure, this method returns nullptr.
+    const unsigned char* ttf_data_by_name(const std::string& font_name, unsigned font_flags);
+    
+    //! This method has a different implementation on each platform.
+    //! In case of failure, this method must not return nullptr, but raise an exception.
+    const unsigned char* ttf_fallback_data();
+
+    // TODO still true? ↓
+    // These functions do not yet support Gosu::FontFlags. This is fine for system fonts like Arial,
+    // where the callers of these methods will typically load the correct file (e.g. ArialBold.ttf).
+    // However, games which ship with their own font files (which is a good idea) can't use bold or
+    // italic text using <b> or <i> markup because there is no way to associate one TTF file as the
+    // "bold variant" of another.
+    //
+    // Options for the future:
+    // 1. Use stbtt_FindMatchingFont. This will only work for TTC font collections, and we will
+    //    have to patch stb_truetype to look for fonts only based on `int flags`, while ignoring
+    //    the name of fonts inside a bundle (who wants to deal with strings, anyway).
+    // 2. Maybe Gosu should accept filename patterns like "LibreBaskerville-*.ttf" as the font
+    //    name and then replace the * with "Regular", "Bold", "Italic" etc.?
+    // 3. As a last resort, Gosu could implement faux bold and faux italics. I think faux
+    //    underlines are a must anyway, since no font provides a dedicated TTF file for that.
+    // These options are not mutually exclusive.
+    
+}

data/src/TrueTypeFontApple.cpp

@@ -0,0 +1,65 @@
+#include <Gosu/Platform.hpp>
+#if defined(GOSU_IS_MAC)
+
+#include "TrueTypeFont.hpp"
+
+#include <Gosu/IO.hpp>
+#include <Gosu/Text.hpp>
+
+#import <CoreText/CoreText.h>
+#import <Foundation/Foundation.h>
+
+#include <map>
+using namespace std;
+
+const unsigned char* Gosu::ttf_data_by_name(const string& font_name, unsigned font_flags)
+{
+    // TODO: Make this cache thread-safe.
+    static map<pair<string, unsigned>, const unsigned char*> ttf_file_cache;
+    
+    auto& ttf_ptr = ttf_file_cache[make_pair(font_name, font_flags)];
+    if (ttf_ptr) return ttf_ptr;
+
+    unsigned symbolic_traits = 0;
+    if (font_flags & Gosu::FF_BOLD)   symbolic_traits |= kCTFontBoldTrait;
+    if (font_flags & Gosu::FF_ITALIC) symbolic_traits |= kCTFontItalicTrait;
+
+    NSDictionary *attributes = @{
+        ((__bridge id) kCTFontNameAttribute): [NSString stringWithUTF8String:font_name.c_str()],
+        ((__bridge id) kCTFontTraitsAttribute): @{
+            ((__bridge id) kCTFontSymbolicTrait): @(symbolic_traits)
+        }
+    };
+    CTFontDescriptorRef descriptor =
+        CTFontDescriptorCreateWithAttributes((__bridge CFDictionaryRef) attributes);
+
+    if (descriptor) {
+        CTFontRef font = CTFontCreateWithFontDescriptorAndOptions(descriptor, 20, nullptr, 0);
+        if (font) {
+            NSURL *url = CFBridgingRelease(CTFontCopyAttribute(font, kCTFontURLAttribute));
+            if (url && url.fileSystemRepresentation) {
+                ttf_ptr = ttf_data_from_file(url.fileSystemRepresentation);
+            }
+            CFRelease(font);
+        }
+        CFRelease(descriptor);
+    }
+    
+    return ttf_ptr;
+}
+
+const unsigned char* Gosu::ttf_fallback_data()
+{
+    // Prefer Arial Unicode MS as a fallback because it covers a lot of Unicode.
+    static const unsigned char* arial_unicode = ttf_data_by_name("Arial Unicode MS", 0);
+    if (arial_unicode) return arial_unicode;
+    
+    return ttf_data_from_file("/Library/Fonts/Arial.ttf");
+}
+
+string Gosu::default_font_name()
+{
+    return "Arial";
+}
+
+#endif

data/src/TrueTypeFontUnix.cpp

@@ -0,0 +1,91 @@
+#include <Gosu/Platform.hpp>
+#if defined(GOSU_IS_X)
+
+#include "TrueTypeFont.hpp"
+
+#include <Gosu/IO.hpp>
+#include <Gosu/Text.hpp>
+
+#include <fontconfig/fontconfig.h>
+
+#include <map>
+using namespace std;
+
+const unsigned char* Gosu::ttf_data_by_name(const string& font_name, unsigned font_flags)
+{
+    // TODO: Make this cache thread-safe.
+    static map<pair<string, unsigned>, const unsigned char*> ttf_file_cache;
+
+    auto& ttf_ptr = ttf_file_cache[make_pair(font_name, font_flags)];
+    if (ttf_ptr) return ttf_ptr;
+
+    static FcConfig* config = FcInitLoadConfigAndFonts();
+    if (config) {
+        // Our search pattern does not include weight or slant so that we can compromise on these.
+        FcPattern* pattern = FcPatternBuild(nullptr,
+                                            FC_FAMILY,  FcTypeString,  font_name.c_str(),
+                                            FC_OUTLINE, FcTypeBool,    FcTrue, /* no bitmap fonts */
+                                            nullptr);
+        FcObjectSet* props = FcObjectSetBuild(FC_FILE, FC_WEIGHT, FC_SLANT, nullptr);
+
+        if (FcFontSet* fonts = FcFontList(config, pattern, props)) {
+            // Among all matching fonts, find the variant that is the best fit for our font_flags.
+            string best_filename;
+            int best_diff;
+            
+            for (int i = 0; i < fonts->nfont; ++i) {
+                int weight, slant;
+                
+                FcPatternGetInteger(fonts->fonts[i], FC_WEIGHT, 0, &weight);
+                FcPatternGetInteger(fonts->fonts[i], FC_SLANT, 0, &slant);
+                
+                // Difference between found font weight/slant and desired weight/slant.
+                // Lower is better, so find the font with the lowest diff.
+                int diff = 0;
+                if (font_flags & Gosu::FF_BOLD) {
+                    diff += abs(weight - 200);
+                } else {
+                    diff += abs(weight - 80);
+                }
+                if (font_flags & Gosu::FF_ITALIC) {
+                    diff += abs(slant - 100);
+                } else {
+                    diff += abs(slant - 0);
+                }
+                
+                if (best_filename.empty() || diff < best_diff) {
+                    FcChar8 *file;
+                    FcPatternGetString(fonts->fonts[i], FC_FILE, 0, &file);
+                    best_filename = reinterpret_cast<char*>(file);
+                    best_diff = diff;
+                }
+            }
+            if (!best_filename.empty()) {
+                ttf_ptr = ttf_data_from_file(best_filename.c_str());
+            }
+            
+            FcFontSetDestroy(fonts);
+        }
+        
+        FcObjectSetDestroy(props);
+        FcPatternDestroy(pattern);
+    }
+
+    return ttf_ptr;
+}
+
+const unsigned char* Gosu::ttf_fallback_data()
+{
+    // Prefer Unifont as a fallback because it covers a lot of Unicode.
+    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);
+}
+
+string Gosu::default_font_name()
+{
+    return "Liberation";
+}
+
+#endif