gosu 0.7.12 → 0.7.13

data/GosuImpl/Graphics/Graphics.cpp

@@ -30,18 +30,18 @@ struct Gosu::Graphics::Impl
 Gosu::Graphics::Graphics(unsigned physWidth, unsigned physHeight, bool fullscreen)
 : pimpl(new Impl)
 {
-    pimpl->physWidth  = pimpl->virtWidth  = physWidth;
-    pimpl->physHeight = pimpl->virtHeight = physHeight;
+    pimpl->virtWidth  = pimpl->physWidth  = physWidth;
+    pimpl->virtHeight = pimpl->physHeight = physHeight;
     pimpl->factorX = pimpl->factorY = 1.0;
     pimpl->fullscreen = fullscreen;
-    
+
     glMatrixMode(GL_PROJECTION);
     glLoadIdentity();
     glViewport(0, 0, pimpl->physWidth, pimpl->physHeight);
     #ifdef GOSU_IS_IPHONE
-    glOrthof(0, pimpl->virtWidth, pimpl->virtHeight, 0, -1, 1);
+    glOrthof(0, pimpl->physWidth, pimpl->physHeight, 0, -1, 1);
     #else
-    glOrtho(0, pimpl->virtWidth, pimpl->virtHeight, 0, -1, 1);
+    glOrtho(0, pimpl->physWidth, pimpl->physHeight, 0, -1, 1);
     #endif
     
     glMatrixMode(GL_MODELVIEW);
@@ -49,6 +49,7 @@ Gosu::Graphics::Graphics(unsigned physWidth, unsigned physHeight, bool fullscree
     #ifdef GOSU_IS_IPHONE
     glTranslatef(physWidth, 0, 0);
     glRotatef(90, 0, 0, 1);
+    glScalef(3.0/2, 2.0/3, 0);
     #endif
 
     glEnable(GL_BLEND);
@@ -101,10 +102,8 @@ void Gosu::Graphics::setResolution(unsigned virtualWidth, unsigned virtualHeight
 
 bool Gosu::Graphics::begin(Gosu::Color clearWithColor)
 {
-#ifndef GOSU_IS_IPHONE
     // Flush leftover clippings
     endClipping();
-#endif
 
     glClearColor(clearWithColor.red()/255.0,
                  clearWithColor.green()/255.0,
@@ -171,27 +170,27 @@ void Gosu::Graphics::endGL()
 
 void Gosu::Graphics::beginClipping(int x, int y, unsigned width, unsigned height)
 {
-#ifdef GOSU_IS_IPHONE
-    throw std::logic_error("Clipping is unsupported on the iPhone");
-#else
     // In doubt, make the clipping region smaller than requested.
     
+#ifndef GOSU_IS_IPHONE
     int physX = static_cast<int>(std::ceil(x * factorX()));
     int physY = static_cast<int>(std::ceil((0.0 + this->height() - y - height) * factorY()));
     unsigned physWidth  = static_cast<unsigned>(width  * factorX());
     unsigned physHeight = static_cast<unsigned>(height * factorY());
+#else
+    // Make up for rotation
+    int physX = 320 - static_cast<int>(std::ceil(320.0 * (0.0 + y + height) / this->height()));
+    int physY = 480 - static_cast<int>(std::ceil(480.0 * (0.0 + x + width) / this->width()));
+    unsigned physWidth  = static_cast<unsigned>(320.0 * height / this->height());
+    unsigned physHeight = static_cast<unsigned>(480.0 * width / this->width());
+#endif
 
     pimpl->queue.beginClipping(physX, physY, physWidth, physHeight);
-#endif
 }
 
 void Gosu::Graphics::endClipping()
 {
-#ifdef GOSU_IS_IPHONE
-    throw std::logic_error("Clipping is unsupported on the iPhone");
-#else
     pimpl->queue.endClipping();
-#endif
 }
 
 void Gosu::Graphics::drawLine(double x1, double y1, Color c1,
@@ -242,6 +241,8 @@ void Gosu::Graphics::drawQuad(double x1, double y1, Color c1,
     double x4, double y4, Color c4,
     ZPos z, AlphaMode mode)
 {
+    reorderCoordinatesIfNecessary(x1, y1, x2, y2, x3, y3, x4, y4);
+
     DrawOp op;
 
     x1 *= factorX();
@@ -278,9 +279,8 @@ std::auto_ptr<Gosu::ImageData> Gosu::Graphics::createImage(
     // Special case: If the texture is supposed to have hard borders,
     // is quadratic, has a size that is at least 64 pixels but less than 256
     // pixels and a power of two, create a single texture just for this image.
-    /*if ((borderFlags & bfHard) == bfHard &&
+    if ((borderFlags & bfHard) == bfHard &&
         srcWidth == srcHeight &&
-        srcWidth >= 64 && srcWidth <= 256 &&
         (srcWidth & (srcWidth - 1)) == 0)
     {
         boost::shared_ptr<Texture> texture(new Texture(srcWidth));
@@ -306,7 +306,7 @@ std::auto_ptr<Gosu::ImageData> Gosu::Graphics::createImage(
         if (!data.get())
             throw std::logic_error("Internal texture block allocation error");
         return data;
-    }*/
+    }
     
     // Too large to fit on a single texture. 
     if (srcWidth > maxSize - 2 || srcHeight > maxSize - 2)

data/GosuImpl/Graphics/LargeImageData.cpp

@@ -1,4 +1,5 @@
 #include <GosuImpl/Graphics/LargeImageData.hpp>
+#include <GosuImpl/Graphics/Common.hpp>
 #include <Gosu/Bitmap.hpp>
 #include <Gosu/Graphics.hpp>
 #include <Gosu/Math.hpp>
@@ -84,6 +85,8 @@ void Gosu::LargeImageData::draw(double x1, double y1, Color c1,
     if (parts.empty())
         return;
 
+    reorderCoordinatesIfNecessary(x1, y1, x2, y2, x3, y3, x4, y4);
+    
     for (unsigned py = 0; py < partsY; ++py)
         for (unsigned px = 0; px < partsX; ++px)
         {

data/GosuImpl/Graphics/TexChunk.cpp

@@ -46,7 +46,9 @@ void Gosu::TexChunk::draw(double x1, double y1, Color c1,
     ZPos z, AlphaMode mode) const
 {
     DrawOp newDrawOp;
-
+    
+    reorderCoordinatesIfNecessary(x1, y1, x2, y2, x3, y3, x4, y4);
+    
     x1 *= graphics->factorX();
     y1 *= graphics->factorY();
     x2 *= graphics->factorX();
@@ -73,7 +75,6 @@ void Gosu::TexChunk::draw(double x1, double y1, Color c1,
     queue->addDrawOp(newDrawOp, z);
 }
 
-
 boost::optional<Gosu::GLTexInfo> Gosu::TexChunk::glTexInfo() const
 {
     Gosu::GLTexInfo info;

data/GosuImpl/Graphics/Text.cpp

@@ -3,6 +3,7 @@
 #include <Gosu/Graphics.hpp>
 #include <Gosu/Image.hpp>
 #include <Gosu/Math.hpp>
+#include <Gosu/Utility.hpp>
 #include <boost/bind.hpp>
 #include <boost/algorithm/string.hpp>
 #include <boost/tokenizer.hpp>
@@ -16,10 +17,30 @@ namespace Gosu
 {
     namespace
     {
+        // Just a very simple heuristic that should make Chinese and Japanese text working in most
+        // of the cases.
+        bool isBreakingAsianGlyph(wchar_t ch)
+        {
+            if (ch >= 0x3040 && ch <= 0x3096)
+                return true; // Hiragana
+            
+            if (ch >= 0x30a0 && ch <= 0x30fa)
+                return true; // Katakana
+            
+            if (ch >= 0x4e00 && ch <= 0x9fff)
+                return true; // CJK Unified Ideographs
+                
+            if (ch >= 0x3400 && ch <= 0x4db5)
+                return true; // CJK Unified Ideographs Extension A
+            
+            return false;
+        }
+    
         struct WordInfo
         {
             wstring text;
             unsigned width;
+            unsigned spaceWidth;
         };
         typedef vector<WordInfo> Words;
 
@@ -83,6 +104,10 @@ namespace Gosu
                 allocNextLine();
                 
                 unsigned words = end - begin;
+                
+                unsigned totalSpacing = 0;
+                for (Words::const_iterator i = begin; i != end - 1; ++i)
+                    totalSpacing += i->spaceWidth;
 
                 // Where does the line start? (y)
                 unsigned top = (usedLines - 1) * (fontHeight + lineSpacing);
@@ -93,12 +118,12 @@ namespace Gosu
                 {
                 // Start so that the text touches the right border.
                 case taRight:
-                    pos = bmp.width() - wordsWidth - (words - 1) * spaceWidth;
+                    pos = bmp.width() - wordsWidth - totalSpacing;
                     break;
 
                 // Start so that the text is centered.
                 case taCenter:
-                    pos = bmp.width() - wordsWidth - (words - 1) * spaceWidth;
+                    pos = bmp.width() - wordsWidth - totalSpacing;
                     pos /= 2;
                     break;
 
@@ -107,20 +132,22 @@ namespace Gosu
                     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;
+
+                    if (align == taJustify && !overrideAlign)
+                        pos += cur->width + 1.0 * (width() - wordsWidth) / (words - 1);
+                    else
+                        pos += cur->width + cur->spaceWidth;
                 }
             }
+            
+            void addEmptyLine()
+            {
+                allocNextLine();
+            }
 
             Bitmap result() const
             {
@@ -133,11 +160,12 @@ namespace Gosu
 
         void processWords(TextBlockBuilder& builder, const Words& words)
         {
+            if (words.empty())
+                return builder.addEmptyLine();
+
             // 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;
 
@@ -153,7 +181,7 @@ namespace Gosu
                     // There's enough space for the words [lineBegin..w] plus
                     // the spaces between them: Proceed with the next word.
                     wordsWidth = newWordsWidth;
-                    spacesWidth += spaceWidth;
+                    spacesWidth += w->spaceWidth;
                 }
                 else
                 {
@@ -164,7 +192,7 @@ namespace Gosu
 
                     lineBegin = w;
                     wordsWidth = w->width;
-                    spacesWidth = spaceWidth;
+                    spacesWidth = w->spaceWidth;
                 }
             }
 
@@ -181,14 +209,51 @@ namespace Gosu
         {
             Words collectedWords;
 
-            boost::char_separator<wchar_t> sep(L" ");
-            Tokenizer words(paragraph, sep);
-            for (Tokenizer::iterator i = words.begin(); i != words.end(); ++i)
+            const unsigned spaceWidth = builder.textWidth(L" ");
+
+            unsigned beginOfWord = 0;
+            
+            for (unsigned cur = 0; cur < paragraph.length(); ++cur)
             {
                 WordInfo newWord;
-                newWord.text = *i;
-                newWord.width = builder.textWidth(newWord.text);
-                collectedWords.push_back(newWord);
+
+                if (paragraph[cur] == L' ')
+                {
+                    // Whitespace: Add last word to list if existent
+                    if (beginOfWord != cur)
+                    {
+                        newWord.text.assign(paragraph.begin() + beginOfWord, paragraph.begin() + cur);
+                        newWord.width = builder.textWidth(newWord.text);
+                        newWord.spaceWidth = spaceWidth;
+                        collectedWords.push_back(newWord);
+                    }
+                    beginOfWord = cur + 1;
+                }
+                else if (isBreakingAsianGlyph(paragraph[cur]))
+                {
+                    // Whitespace: Add last word to list if existent
+                    if (beginOfWord != cur)
+                    {
+                        newWord.text.assign(paragraph.begin() + beginOfWord, paragraph.begin() + cur);
+                        newWord.width = builder.textWidth(newWord.text);
+                        newWord.spaceWidth = 0;
+                        collectedWords.push_back(newWord);
+                    }
+                    // Add glyph as a single "word"
+                    newWord.text = wstring(1, paragraph[cur]);
+                    newWord.width = builder.textWidth(newWord.text);
+                    newWord.spaceWidth = 0;
+                    collectedWords.push_back(newWord);
+                    beginOfWord = cur + 1;
+                }
+            }
+            if (beginOfWord < paragraph.length())
+            {
+                WordInfo lastWord;
+                lastWord.text.assign(paragraph.begin() + beginOfWord, paragraph.end());
+                lastWord.width = builder.textWidth(lastWord.text);
+                lastWord.spaceWidth = 0;
+                collectedWords.push_back(lastWord);
             }
 
             processWords(builder, collectedWords);

data/GosuImpl/Graphics/TextMac.cpp

@@ -2,6 +2,7 @@
 #include <Gosu/Text.hpp>
 #include <Gosu/Utility.hpp>
 #include <Gosu/IO.hpp>
+#include <GosuImpl/MacUtility.hpp>
 #include <boost/utility.hpp>
 #include <boost/cstdint.hpp>
 #include <cmath>
@@ -22,20 +23,6 @@ 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
@@ -97,13 +84,13 @@ namespace
             Gosu::loadFile(buf, fontName);
             
             ATSFontContainerRef container; 
-            checkErr( ATSFontActivateFromMemory(buf.data(), buf.size(),
+            CHECK_OS( ATSFontActivateFromMemory(buf.data(), buf.size(),
                           kATSFontContextLocal, kATSFontFormatUnspecified, 
                           NULL, kATSOptionFlagsDefault, &container) );
             
             ATSFontRef fontRefs[1024]; 
             ItemCount  fontCount; 
-            checkErr( ATSFontFindFromContainer(container, kATSOptionFlagsDefault, 
+            CHECK_OS( ATSFontFindFromContainer(container, kATSOptionFlagsDefault, 
                           1024, fontRefs, &fontCount) );
             if (fontCount == 0)
                 throw std::runtime_error("No font found in " + Gosu::narrow(fontName));
@@ -116,7 +103,7 @@ namespace
         newFont.fontId = FMGetFontFromATSFontRef(atsRef);
 
         ATSFontMetrics metrics;
-        checkErr(ATSFontGetHorizontalMetrics(newFont.fontId, kATSOptionFlagsDefault, &metrics));
+        CHECK_OS(ATSFontGetHorizontalMetrics(newFont.fontId, kATSOptionFlagsDefault, &metrics));
         newFont.heightAt1Pt = metrics.ascent - metrics.descent;
         newFont.descentAt1Pt = -metrics.descent;
         fonts[fontName] = newFont;
@@ -134,7 +121,7 @@ namespace
         {
             ByteCount size = sizeof value;
             ATSUAttributeValuePtr ptr = &value;
-            checkErr( ATSUSetAttributes(style, 1, &tag, &size, &ptr) );
+            CHECK_OS( ATSUSetAttributes(style, 1, &tag, &size, &ptr) );
         }
         
         template<typename T>
@@ -142,7 +129,7 @@ namespace
         {
             ByteCount size = sizeof value;
             ATSUAttributeValuePtr ptr = &value;
-            checkErr( ATSUSetLayoutControls(layout, 1, &tag, &size, &ptr) );
+            CHECK_OS( ATSUSetLayoutControls(layout, 1, &tag, &size, &ptr) );
         }
         
     public:
@@ -150,7 +137,7 @@ namespace
         {
             utf16 = Gosu::wstringToUniChars(text);
         
-            checkErr( ATSUCreateStyle(&style) );
+            CHECK_OS( ATSUCreateStyle(&style) );
             
             CachedFontInfo& font = getFont(fontName);
             
@@ -165,21 +152,21 @@ namespace
                 setAttribute<Boolean>(kATSUQDUnderlineTag, TRUE);
 
             UniCharCount runLength = utf16.size();
-            checkErr( ATSUCreateTextLayoutWithTextPtr(&utf16[0], kATSUFromTextBeginning,
+            CHECK_OS( ATSUCreateTextLayoutWithTextPtr(&utf16[0], kATSUFromTextBeginning,
                             kATSUToTextEnd, utf16.size(), 1, &runLength, &style, &layout) );
         }
         
         ~ATSULayoutAndStyle()
         {
-            checkErr( ATSUDisposeStyle(style) );
-            checkErr( ATSUDisposeTextLayout(layout) );
+            CHECK_OS( ATSUDisposeStyle(style) );
+            CHECK_OS( ATSUDisposeTextLayout(layout) );
         }
 
         Rect textExtents() const
         {
             Rect rect;
-            checkErr( ATSUSetTransientFontMatching(layout, TRUE) );
-            checkErr( ATSUMeasureTextImage(layout, kATSUFromTextBeginning,
+            CHECK_OS( ATSUSetTransientFontMatching(layout, TRUE) );
+            CHECK_OS( ATSUMeasureTextImage(layout, kATSUFromTextBeginning,
                                            kATSUToTextEnd, X2Fix(0), X2Fix(0), &rect) );
             return rect;
         }
@@ -192,8 +179,8 @@ namespace
             RGBColor color = { 0, 0, 0 };
             setAttribute<RGBColor>(kATSUColorTag, color);
             setLayoutControl<CGContextRef>(kATSUCGContextTag, context);
-            checkErr( ATSUSetTransientFontMatching(layout, TRUE) );
-            checkErr( ATSUDrawText(layout, kATSUFromTextBeginning, kATSUToTextEnd, x, y) );
+            CHECK_OS( ATSUSetTransientFontMatching(layout, TRUE) );
+            CHECK_OS( ATSUDrawText(layout, kATSUFromTextBeginning, kATSUToTextEnd, x, y) );
         }
     };
 }

data/GosuImpl/Graphics/TextTouch.mm

@@ -0,0 +1,89 @@
+#import <Gosu/Text.hpp>
+#import <Gosu/Bitmap.hpp>
+#import <Gosu/Utility.hpp>
+#import <GosuImpl/MacUtility.hpp>
+#import <UIKit/UIKit.h>
+#import <CoreGraphics/CoreGraphics.h>
+#import <map>
+#import <cmath>
+using namespace std;
+
+namespace
+{
+    map<pair<wstring, double>, UIFont*> usedFonts;
+
+    UIFont* getFont(const wstring& name, double height)
+    {
+        UIFont* result = usedFonts[make_pair(name, height)];
+        if (!result)
+        {
+            Gosu::ObjRef<NSString> fontName([[NSString alloc] initWithUTF8String: Gosu::wstringToUTF8(name).c_str()]);
+            result = [UIFont fontWithName: fontName.obj() size: height];
+        }
+        return result;
+    }
+}
+
+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";
+}
+
+unsigned Gosu::textWidth(const wstring& text,
+    const wstring& fontName, unsigned fontHeight, unsigned fontFlags)
+{
+    UIFont* font = getFont(fontName, fontHeight);
+
+    // This will, of course, compute a too large size; fontHeight is in pixels, the method expects point.
+    ObjRef<NSString> string([[NSString alloc] initWithUTF8String: wstringToUTF8(text).c_str()]);
+    CGSize size = [string.obj() sizeWithFont: font];
+                           
+    // Now adjust the scaling...
+    return ceil(size.width / size.height * fontHeight);
+}
+
+void Gosu::drawText(Bitmap& bitmap, const wstring& text, int x, int y,
+    Color c, const wstring& fontName, unsigned fontHeight,
+    unsigned fontFlags)
+{
+    UIFont* font = getFont(fontName, fontHeight);
+    ObjRef<NSString> string([[NSString alloc] initWithUTF8String: wstringToUTF8(text).c_str()]);
+
+    // This will, of course, compute a too large size; fontHeight is in pixels, the method expects point.
+    CGSize size = [string.obj() sizeWithFont: font];
+    
+    unsigned width = ceil(size.width / size.height * fontHeight);
+
+    // Get the width and height of the image
+    Bitmap bmp;
+    bmp.resize(width, fontHeight);
+    
+    // Use a temporary context to draw the CGImage to the buffer.
+    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+    CGContextRef context =
+        CGBitmapContextCreate(bmp.data(),
+                              bmp.width(), bmp.height(), 8, bmp.width() * 4,
+                              colorSpace,
+                              kCGImageAlphaPremultipliedLast);
+    CGColorSpaceRelease(colorSpace);
+    CGFloat color[] = { c.green() / 255.0, c.blue() / 255.0, c.red() / 255.0, 0 };
+    CGContextSetStrokeColor(context, color);
+    CGContextSetFillColor(context, color);
+    
+    // TODO: Should probably use CGShowText instead of all the ObjC bloat.
+    
+    // Use new font with proper size this time.
+    font = getFont(fontName, fontHeight * fontHeight / size.height);
+    
+    CGContextTranslateCTM(context, 0, fontHeight);
+    CGContextScaleCTM(context, 1, -1);
+    UIGraphicsPushContext(context);
+    [string.obj() drawAtPoint: CGPointZero withFont: font];
+    UIGraphicsPopContext();
+    CGContextRelease(context);
+
+    // Done!
+    bitmap.insert(bmp, x, y);
+}