gosu 0.7.10.1

data/GosuImpl/Graphics/Text.cpp

@@ -0,0 +1,223 @@
+#include <Gosu/Text.hpp>
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/Graphics.hpp>
+#include <Gosu/Image.hpp>
+#include <Gosu/Math.hpp>
+#include <boost/bind.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/tokenizer.hpp>
+#include <cassert>
+#include <cmath>
+#include <algorithm>
+#include <vector>
+using namespace std;
+
+namespace Gosu
+{
+    namespace
+    {
+        struct WordInfo
+        {
+            wstring text;
+            unsigned width;
+        };
+        typedef vector<WordInfo> Words;
+
+        // Local helper class which manages building the bitmap from the
+        // collected words.
+        class TextBlockBuilder
+        {
+            Bitmap bmp;
+            unsigned usedLines, allocatedLines;
+
+            wstring fontName;
+            unsigned fontHeight, fontFlags, lineSpacing;
+            TextAlign align;
+
+            unsigned spaceWidth;
+
+            void allocNextLine()
+            {
+                ++usedLines;
+                if (usedLines == allocatedLines)
+                {
+                    allocatedLines += 10;
+                    bmp.resize(bmp.width(),
+                        (lineSpacing + fontHeight) * allocatedLines,
+                        Colors::none);
+                }
+            }
+
+        public:
+            TextBlockBuilder(const wstring& fontName, unsigned fontHeight,
+                unsigned fontFlags, unsigned lineSpacing, unsigned width,
+                TextAlign align)
+            {
+                usedLines = 0;
+                allocatedLines = 10;
+                
+                bmp.resize(width, (lineSpacing + fontHeight) * allocatedLines, 0x00ffffff);
+
+                this->fontName = fontName;
+                this->fontHeight = fontHeight;
+                this->fontFlags = fontFlags;
+                this->lineSpacing = lineSpacing;
+                this->align = align;
+
+                spaceWidth = textWidth(L" ");
+            }
+
+            unsigned width() const
+            {
+                return bmp.width();
+            }
+
+            unsigned textWidth(const std::wstring& text) const
+            {
+                return Gosu::textWidth(text, fontName, fontHeight, fontFlags);
+            }
+
+            void addLine(Words::const_iterator begin, Words::const_iterator end,
+                unsigned wordsWidth, bool overrideAlign)
+            {
+                allocNextLine();
+                
+                unsigned words = end - begin;
+
+                // Where does the line start? (y)
+                unsigned top = (usedLines - 1) * (fontHeight + lineSpacing);
+
+                // Where does the line start? (x)
+                double pos;
+                switch (align)
+                {
+                // Start so that the text touches the right border.
+                case taRight:
+                    pos = bmp.width() - wordsWidth - (words - 1) * spaceWidth;
+                    break;
+
+                // Start so that the text is centered.
+                case taCenter:
+                    pos = bmp.width() - wordsWidth - (words - 1) * spaceWidth;
+                    pos /= 2;
+                    break;
+
+                // Just start at the left border.
+                default:
+                    pos = 0;
+                }
+
+                // How much space is between each word?
+                double spacing;
+                if (align == taJustify && !overrideAlign)
+                    spacing = (bmp.width() - wordsWidth) / (words - 1.0);
+                else
+                    spacing = spaceWidth;
+
+                for (Words::const_iterator cur = begin; cur != end; ++cur)
+                {
+                    drawText(bmp, cur->text, trunc(pos), trunc(top),
+                        Colors::white, fontName, fontHeight, fontFlags);
+                    pos += cur->width + spacing;
+                }
+            }
+
+            Bitmap result() const
+            {
+                Bitmap result = bmp;
+                result.resize(result.width(),
+                    usedLines * (lineSpacing + fontHeight));
+                return result;
+            }
+        };
+
+        void processWords(TextBlockBuilder& builder, const Words& words)
+        {
+            // Index into words to the first word in the current line.
+            Words::const_iterator lineBegin = words.begin();
+
+            const unsigned spaceWidth = builder.textWidth(L" "); // IMPR.
+
+            // Used width, in pixels, of the words [lineBegin..w[.
+            unsigned wordsWidth = 0;
+
+            // Used width of the spaces between (w-lineBegin) words.
+            unsigned spacesWidth = 0;
+
+            for (Words::const_iterator w = words.begin(); w != words.end(); ++w)
+            {
+                unsigned newWordsWidth = wordsWidth + w->width;
+
+                if (newWordsWidth + spacesWidth <= builder.width())
+                {
+                    // There's enough space for the words [lineBegin..w] plus
+                    // the spaces between them: Proceed with the next word.
+                    wordsWidth = newWordsWidth;
+                    spacesWidth += spaceWidth;
+                }
+                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.addLine(lineBegin, w, wordsWidth, false);
+
+                    lineBegin = w;
+                    wordsWidth = w->width;
+                    spacesWidth = spaceWidth;
+                }
+            }
+
+            // Draw the last line as well.
+            if (words.empty() || lineBegin != words.end())
+                builder.addLine(lineBegin, words.end(), wordsWidth, true);
+        }
+
+        typedef boost::tokenizer<boost::char_separator<wchar_t>,
+            wstring::const_iterator, wstring> Tokenizer;
+
+        void processParagraph(TextBlockBuilder& builder,
+            const wstring& paragraph)
+        {
+            Words collectedWords;
+
+            boost::char_separator<wchar_t> sep(L" ");
+            Tokenizer words(paragraph, sep);
+            for (Tokenizer::iterator i = words.begin(); i != words.end(); ++i)
+            {
+                WordInfo newWord;
+                newWord.text = *i;
+                newWord.width = builder.textWidth(newWord.text);
+                collectedWords.push_back(newWord);
+            }
+
+            processWords(builder, collectedWords);
+        }
+
+        void processText(TextBlockBuilder& builder, const wstring& text)
+        {
+            vector<wstring> paragraphs;
+            wstring processedText = boost::replace_all_copy(text, L"\r\n", L"\n");
+            boost::split(paragraphs, processedText,
+                boost::is_any_of(L"\r\n"));
+            for_each(paragraphs.begin(), paragraphs.end(),
+                boost::bind(processParagraph, boost::ref(builder), _1));
+        }
+    }
+}
+
+Gosu::Bitmap Gosu::createText(const std::wstring& text,
+    const std::wstring& fontName, unsigned fontHeight, unsigned lineSpacing,
+    unsigned maxWidth, TextAlign align, unsigned fontFlags)
+{
+    // Set up the builder object which will manage all the drawing and
+    // conversions for us.
+    TextBlockBuilder builder(fontName, fontHeight, fontFlags,
+        lineSpacing, maxWidth, align);
+
+    // Let the process* functions draw everything.
+    processText(builder, text);
+
+    // Done!
+    return builder.result();
+}

data/GosuImpl/Graphics/TextMac.cpp

@@ -0,0 +1,242 @@
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/Text.hpp>
+#include <Gosu/Utility.hpp>
+#include <Gosu/IO.hpp>
+#include <boost/utility.hpp>
+#include <boost/cstdint.hpp>
+#include <cmath>
+#include <stdexcept>
+#include <map>
+#include <vector>
+#include <ApplicationServices/ApplicationServices.h>
+
+std::wstring Gosu::defaultFontName()
+{
+    // OF COURSE Helvetica is better - but the dots above my capital umlauts get
+    // eaten when I use it with Gosu. Until this is fixed, keep Arial. (TODO)
+    return L"Arial";
+}
+
+namespace Gosu
+{
+    std::vector<unsigned short> wstringToUniChars(const std::wstring& ws);
+}
+
+#include <iostream>
+#include <ostream>
+#include <sstream>
+void throwError(OSStatus status, unsigned line)
+{
+    std::ostringstream str;
+    str << "Error on line " << line << " (Code " << status << "): "
+        << GetMacOSStatusErrorString(status)
+        << " (" << GetMacOSStatusCommentString(status) << ")";
+    throw std::runtime_error(str.str());
+}
+
+#define checkErr(status) if (!(status)) {} else throwError(status, __LINE__)
+
+namespace
+{
+    class MacBitmap : boost::noncopyable
+    {
+        boost::uint32_t* buf;
+        unsigned width, height;
+        CGContextRef ctx;
+
+    public:
+        MacBitmap(boost::uint32_t* buf, unsigned width, unsigned height)
+        : buf(buf), width(width), height(height)
+        {
+            CGColorSpaceRef colorSpace = CGColorSpaceCreateWithName(kCGColorSpaceUserRGB); 
+            ctx = CGBitmapContextCreate (buf, width, height, 8, width * 4, colorSpace,
+                kCGImageAlphaPremultipliedLast);
+
+            CGColorSpaceRelease( colorSpace ); 
+        }
+
+        ~MacBitmap()
+        {
+            CGContextRelease(ctx);
+        }
+
+        CGContextRef context() const
+        {
+            return ctx;
+        }
+    };
+    
+    struct CachedFontInfo
+    {
+        ATSUFontID fontId;
+        double heightAt1Pt;
+        double descentAt1Pt;
+    };
+    CachedFontInfo& getFont(const std::wstring& fontName)
+    {
+        static std::map<std::wstring, CachedFontInfo> fonts;
+        
+        if (fonts.count(fontName))
+            return fonts[fontName];
+        
+        // Get reference to font, loaded from the system or a file.
+        ATSFontRef atsRef;
+        if (fontName.find(L"/") == std::wstring::npos)
+        {
+            // System font
+            CFStringRef cfName = CFStringCreateWithCString(NULL, Gosu::narrow(fontName).c_str(), kCFStringEncodingASCII);
+            atsRef = ATSFontFindFromName(cfName, kATSOptionFlagsDefault);
+            if (!atsRef)
+                throw std::runtime_error("Cannot find font " + Gosu::narrow(fontName));
+            CFRelease(cfName);
+        }
+        else
+        {
+            // Filename to font
+            Gosu::Buffer buf;
+            Gosu::loadFile(buf, fontName);
+            
+            ATSFontContainerRef container; 
+            checkErr( ATSFontActivateFromMemory(buf.data(), buf.size(),
+                          kATSFontContextLocal, kATSFontFormatUnspecified, 
+                          NULL, kATSOptionFlagsDefault, &container) );
+            
+            ATSFontRef fontRefs[1024]; 
+            ItemCount  fontCount; 
+            checkErr( ATSFontFindFromContainer(container, kATSOptionFlagsDefault, 
+                          1024, fontRefs, &fontCount) );
+            if (fontCount == 0)
+                throw std::runtime_error("No font found in " + Gosu::narrow(fontName));
+
+            atsRef = fontRefs[0];
+        }
+        
+        // Calculate metrics (for space allocations) and create CachedFontInfo entry.
+        CachedFontInfo newFont;
+        newFont.fontId = FMGetFontFromATSFontRef(atsRef);
+
+        ATSFontMetrics metrics;
+        checkErr(ATSFontGetHorizontalMetrics(newFont.fontId, kATSOptionFlagsDefault, &metrics));
+        newFont.heightAt1Pt = metrics.ascent - metrics.descent;
+        newFont.descentAt1Pt = -metrics.descent;
+        fonts[fontName] = newFont;
+        return fonts[fontName];
+    }
+    
+    class ATSULayoutAndStyle
+    {
+        ATSUStyle style;
+        ATSUTextLayout layout;
+        std::vector<UniChar> utf16; // More like UCS-2-INTERNAL.
+
+        template<typename T>
+        void setAttribute(ATSUAttributeTag tag, T value)
+        {
+            ByteCount size = sizeof value;
+            ATSUAttributeValuePtr ptr = &value;
+            checkErr( ATSUSetAttributes(style, 1, &tag, &size, &ptr) );
+        }
+        
+        template<typename T>
+        void setLayoutControl(ATSUAttributeTag tag, T value)
+        {
+            ByteCount size = sizeof value;
+            ATSUAttributeValuePtr ptr = &value;
+            checkErr( ATSUSetLayoutControls(layout, 1, &tag, &size, &ptr) );
+        }
+        
+    public:
+        ATSULayoutAndStyle(const std::wstring& text, const std::wstring& fontName, unsigned fontHeightPx, unsigned fontFlags)
+        {
+            utf16 = Gosu::wstringToUniChars(text);
+        
+            checkErr( ATSUCreateStyle(&style) );
+            
+            CachedFontInfo& font = getFont(fontName);
+            
+            setAttribute<ATSUFontID>(kATSUFontTag, font.fontId);
+            
+            setAttribute<Fixed>(kATSUSizeTag, X2Fix(fontHeightPx / font.heightAt1Pt));
+            if (fontFlags & Gosu::ffBold)
+                setAttribute<Boolean>(kATSUQDBoldfaceTag, TRUE);
+            if (fontFlags & Gosu::ffItalic)
+                setAttribute<Boolean>(kATSUQDItalicTag, TRUE);
+            if (fontFlags & Gosu::ffUnderline)
+                setAttribute<Boolean>(kATSUQDUnderlineTag, TRUE);
+
+            UniCharCount runLength = utf16.size();
+            checkErr( ATSUCreateTextLayoutWithTextPtr(&utf16[0], kATSUFromTextBeginning,
+                            kATSUToTextEnd, utf16.size(), 1, &runLength, &style, &layout) );
+        }
+        
+        ~ATSULayoutAndStyle()
+        {
+            checkErr( ATSUDisposeStyle(style) );
+            checkErr( ATSUDisposeTextLayout(layout) );
+        }
+
+        Rect textExtents() const
+        {
+            Rect rect;
+            checkErr( ATSUSetTransientFontMatching(layout, TRUE) );
+            checkErr( ATSUMeasureTextImage(layout, kATSUFromTextBeginning,
+                                           kATSUToTextEnd, X2Fix(0), X2Fix(0), &rect) );
+            return rect;
+        }
+        
+        void drawToContext(Fixed x, Fixed y, CGContextRef context)
+        {
+            // Always draw in black - recoloring to white happens in drawText itself.
+            // Reason: Text drawn using fallback fonts seems to always be black anyway :(
+            
+            RGBColor color = { 0, 0, 0 };
+            setAttribute<RGBColor>(kATSUColorTag, color);
+            setLayoutControl<CGContextRef>(kATSUCGContextTag, context);
+            checkErr( ATSUSetTransientFontMatching(layout, TRUE) );
+            checkErr( ATSUDrawText(layout, kATSUFromTextBeginning, kATSUToTextEnd, x, y) );
+        }
+    };
+}
+
+unsigned Gosu::textWidth(const std::wstring& text,
+    const std::wstring& fontName, unsigned fontHeight, unsigned fontFlags)
+{
+    // TODO: special case :///7
+    if (text == L" ")
+        return fontHeight / 3;
+    
+    ATSULayoutAndStyle atlas(text, fontName, fontHeight, fontFlags);
+    Rect rect = atlas.textExtents();
+    return rect.right + 1 - rect.left;
+}
+
+void Gosu::drawText(Bitmap& bitmap, const std::wstring& text, int x, int y,
+    Color c, const std::wstring& fontName, unsigned fontHeight,
+    unsigned fontFlags)
+{
+    CachedFontInfo& font = getFont(fontName);
+    
+    ATSULayoutAndStyle atlas(text, fontName, fontHeight, fontFlags);
+    Rect rect = atlas.textExtents();
+    unsigned width = rect.right + 1 - rect.left;
+    std::vector<boost::uint32_t> buf(width * fontHeight);
+    {
+        MacBitmap helper(&buf[0], width, fontHeight);
+        atlas.drawToContext(X2Fix(-rect.left), X2Fix(fontHeight / font.heightAt1Pt * font.descentAt1Pt),
+                            helper.context());
+    }
+
+    Bitmap wholeText;
+    wholeText.resize(width, fontHeight);
+    for (unsigned relY = 0; relY < fontHeight; ++relY)
+        for (unsigned relX = 0; relX < width; ++relX)
+        {
+#ifdef __BIG_ENDIAN__
+            Color::Channel alpha = buf[relY * width + relX];
+#else
+            Color::Channel alpha = Color(buf[relY * width + relX]).alpha();
+#endif
+            wholeText.setPixel(relX, relY, Color(alpha, 0xff, 0xff, 0xff));
+        }
+    bitmap.insert(wholeText, x, y);
+}