gosu 0.7.20 → 0.7.21

data/GosuImpl/Graphics/FormattedString.hpp

@@ -0,0 +1,248 @@
+#ifndef GOSUIMPL_GRAPHICS_TEXTFORMATTING
+#define GOSUIMPL_GRAPHICS_TEXTFORMATTING
+
+#include <Gosu/Color.hpp>
+#include <Gosu/Utility.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/foreach.hpp>
+#include <stdexcept>
+#include <vector>
+#include <cwchar>
+
+namespace Gosu
+{
+    class FormattedString
+    {
+        struct FormattedChar
+        {
+            wchar_t wc;
+            Gosu::Color color;
+            unsigned flags;
+            std::wstring entity;
+            
+            bool sameStyleAs(const FormattedChar& other) const
+            {
+                return wc && other.wc && color == other.color && flags == other.flags;
+            }
+        };
+        std::vector<FormattedChar> chars;
+        
+        static unsigned flags(int b, int u, int i)
+        {
+            unsigned flags = 0;
+            if (b > 0) flags |= ffBold;
+            if (u > 0) flags |= ffUnderline;
+            if (i > 0) flags |= ffItalic;
+            return flags;
+        }
+        
+    public:
+        FormattedString()
+        {
+        }
+        
+        explicit FormattedString(const std::wstring& html, unsigned baseFlags)
+        {
+            unsigned pos = 0;
+            int b = (baseFlags & ffBold) ? 1 : 0,
+                u = (baseFlags & ffUnderline) ? 1 : 0,
+                i = (baseFlags & ffItalic) ? 1 : 0;
+            std::vector<Gosu::Color> c;
+            c.push_back(0xffffffff);
+            while (pos < html.length())
+            {
+                // TODO: range checking for the color ops so .at() doesn't crash valid strings
+            
+                if (html.substr(pos, 3) == L"<b>")
+                {
+                    b += 1;
+                    pos += 3;
+                    continue;
+                }
+                if (html.substr(pos, 4) == L"</b>")
+                {
+                    b -= 1;
+                    pos += 4;
+                    continue;
+                }
+                if (html.substr(pos, 3) == L"<u>")
+                {
+                    u += 1;
+                    pos += 3;
+                    continue;
+                }
+                if (html.substr(pos, 4) == L"</u>")
+                {
+                    u -= 1;
+                    pos += 4;
+                    continue;
+                }
+                if (html.substr(pos, 3) == L"<i>")
+                {
+                    i += 1;
+                    pos += 3;
+                    continue;
+                }
+                if (html.substr(pos, 4) == L"</i>")
+                {
+                    i -= 1;
+                    pos += 4;
+                    continue;
+                }
+                if (html.substr(pos, 3) == L"<c=" &&
+                    html.at(pos + 9) == L'>')
+                {
+                    using namespace std;
+                    boost::uint32_t rgb =
+                        std::wcstoul(html.c_str() + pos + 3, 0, 16);
+                    c.push_back(0xff000000 | rgb);
+                    pos += 10;
+                    continue;
+                }
+                if (html.substr(pos, 3) == L"<c=" &&
+                    html.at(pos + 11) == L'>')
+                {
+                    using namespace std;
+                    boost::uint32_t argb =
+                        std::wcstoul(html.c_str() + pos + 3, 0, 16);
+                    c.push_back(argb);
+                    pos += 12;
+                    continue;
+                }
+                if (html.substr(pos, 4) == L"</c>")
+                {
+                    c.pop_back();
+                    pos += 4;
+                    continue;
+                }
+                if (html.substr(pos, 4) == L"&lt;")
+                {
+                    FormattedChar fc = { L'<', c.back(), flags(b,u,i) };
+                    chars.push_back(fc);
+                    pos += 4;
+                    continue;
+                }
+                if (html.substr(pos, 4) == L"&gt;")
+                {
+                    FormattedChar fc = { L'>', c.back(), flags(b,u,i) };
+                    chars.push_back(fc);
+                    pos += 4;
+                    continue;
+                }
+                if (html.substr(pos, 5) == L"&amp;")
+                {
+                    FormattedChar fc = { L'&', c.back(), flags(b,u,i) };
+                    chars.push_back(fc);
+                    pos += 5;
+                    continue;
+                }
+                if (html[pos] == L'&' && pos < html.length() - 1)
+                {
+                    int endOfEntity = pos + 1;
+                    while (html[endOfEntity] != L';')
+                    {
+                        using namespace std; // never know where the wchar_t stuff is ...
+                        if (!iswalnum(static_cast<wint_t>(html[endOfEntity])))
+                            goto normalCharacter;
+                        endOfEntity += 1;
+                        if (endOfEntity >= html.size())
+                            goto normalCharacter;
+                    }
+                    FormattedChar fc = { 0, c.back(), 0, std::wstring(html.begin() + pos + 1, html.begin() + endOfEntity) };
+                    chars.push_back(fc);
+                    pos = endOfEntity + 1;
+                    continue;
+                }
+                
+            normalCharacter:                
+                FormattedChar fc = { html[pos], c.back(), flags(b,u,i) };
+                chars.push_back(fc);
+                pos += 1;
+            }
+        }
+        
+        std::wstring unformat() const
+        {
+            std::wstring result(length(), L' ');
+            for (int i = 0; i < chars.size(); ++i)
+                result[i] = chars[i].wc;
+            return result;
+        }
+        
+        const wchar_t* entityAt(unsigned index) const
+        {
+            if (chars[index].wc != 0 || chars[index].entity.empty())
+                return 0;
+            return chars[index].entity.c_str();
+        }
+        
+        wchar_t charAt(unsigned index) const
+        {
+            return chars[index].wc;
+        }
+        
+        unsigned flagsAt(unsigned index) const
+        {
+            return chars[index].flags;
+        }
+        
+        Gosu::Color colorAt(unsigned index) const
+        {
+            return chars[index].color;
+        }
+        
+        unsigned length() const
+        {
+            return chars.size();
+        }
+        
+        FormattedString range(unsigned begin, unsigned end) const
+        {
+            FormattedString result;
+            result.chars.assign(chars.begin() + begin, chars.begin() + end);
+            return result;
+        }
+        
+        std::vector<FormattedString> splitLines() const
+        {
+            std::vector<FormattedString> result;
+            unsigned begin = 0;
+            for (unsigned cur = 0; cur < length(); ++cur)
+            {
+                if (charAt(cur) == L'\n')
+                {
+                    FormattedString line;
+                    line.chars.assign(chars.begin() + begin, chars.begin() + cur);
+                    result.push_back(line);
+                    begin = cur + 1;
+                }
+            }
+            FormattedString line;
+            line.chars.assign(chars.begin() + begin, chars.end());
+            result.push_back(line);
+            return result;
+        }
+        
+        std::vector<FormattedString> splitParts() const
+        {
+            std::vector<FormattedString> result;
+            unsigned begin = 0;
+            for (unsigned cur = 1; cur < length(); ++cur)
+            {
+                if (!chars[begin].sameStyleAs(chars[cur]))
+                {
+                    FormattedString line;
+                    line.chars.assign(chars.begin() + begin, chars.begin() + cur);
+                    result.push_back(line);
+                    begin = cur;
+                }
+            }
+            FormattedString line;
+            line.chars.assign(chars.begin() + begin, chars.end());
+            result.push_back(line);
+            return result;
+        }
+    };
+}
+
+#endif

data/GosuImpl/Graphics/Graphics.cpp

@@ -6,6 +6,8 @@
 #include <GosuImpl/Graphics/LargeImageData.hpp>
 #include <GosuImpl/Graphics/Macro.hpp>
 #include <Gosu/Bitmap.hpp>
+#include <Gosu/Image.hpp>
+#include <boost/foreach.hpp>
 #if 0
 #include <boost/thread.hpp>
 #endif
@@ -22,10 +24,20 @@ struct Gosu::Graphics::Impl
     DrawOpQueueStack queues;
     typedef std::vector<boost::shared_ptr<Texture> > Textures;
     Textures textures;
+    Transforms currentTransforms;
+    Transforms absoluteTransforms;
     
 #if 0
     boost::mutex texMutex;
 #endif
+    
+    void calculateAbsoluteTransform()
+    {
+        Transform result = scale(1);
+        BOOST_FOREACH (const Transform& tf, currentTransforms)
+            result = multiply(result, tf);
+        absoluteTransforms.push_back(result);
+    }
 };
 
 Gosu::Graphics::Graphics(unsigned physWidth, unsigned physHeight, bool fullscreen)
@@ -57,6 +69,9 @@ Gosu::Graphics::Graphics(unsigned physWidth, unsigned physHeight, bool fullscree
     
     // Create default draw-op queue.
     pimpl->queues.resize(1);
+    
+    // Push one identity matrix as the default transform.
+    pimpl->absoluteTransforms.push_back(scale(1));
 }
 
 Gosu::Graphics::~Graphics()
@@ -107,7 +122,12 @@ void Gosu::Graphics::setResolution(unsigned virtualWidth, unsigned virtualHeight
 bool Gosu::Graphics::begin(Gosu::Color clearWithColor)
 {
     // If there is a recording in process, stop it.
+    // TODO: Raise exception?
     pimpl->queues.resize(1);
+    
+    // If there are transformations in progress, clear them.
+    pimpl->currentTransforms.resize(0);
+    pimpl->absoluteTransforms.resize(1);
 
     // Flush leftover clippings
     endClipping();
@@ -229,11 +249,23 @@ std::auto_ptr<Gosu::ImageData> Gosu::Graphics::endRecording()
     return result;
 }
 
+void Gosu::Graphics::pushTransform(const Gosu::Transform& transform)
+{
+    pimpl->currentTransforms.push_back(transform);
+    pimpl->calculateAbsoluteTransform();
+}
+
+void Gosu::Graphics::popTransform()
+{
+    pimpl->currentTransforms.pop_back();
+    pimpl->calculateAbsoluteTransform();
+}
+
 void Gosu::Graphics::drawLine(double x1, double y1, Color c1,
     double x2, double y2, Color c2,
     ZPos z, AlphaMode mode)
 {
-    DrawOp op;
+    DrawOp op(pimpl->absoluteTransforms.back());
     
     x1 *= factorX();
     y1 *= factorY();
@@ -253,7 +285,7 @@ void Gosu::Graphics::drawTriangle(double x1, double y1, Color c1,
     double x3, double y3, Color c3,
     ZPos z, AlphaMode mode)
 {
-    DrawOp op;
+    DrawOp op(pimpl->absoluteTransforms.back());
     
     x1 *= factorX();
     y1 *= factorY();
@@ -283,7 +315,7 @@ void Gosu::Graphics::drawQuad(double x1, double y1, Color c1,
 {
     reorderCoordinatesIfNecessary(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4);
 
-    DrawOp op;
+    DrawOp op(pimpl->absoluteTransforms.back());
 
     x1 *= factorX();
     y1 *= factorY();
@@ -332,7 +364,7 @@ std::auto_ptr<Gosu::ImageData> Gosu::Graphics::createImage(
         if (srcX == 0 && srcWidth == src.width() &&
             srcY == 0 && srcHeight == src.height())
         {
-            data = texture->tryAlloc(*this, pimpl->queues, texture,
+            data = texture->tryAlloc(*this, pimpl->absoluteTransforms, pimpl->queues, texture,
                     src, 0, 0, src.width(), src.height(), 0);
         }
         else
@@ -340,7 +372,7 @@ std::auto_ptr<Gosu::ImageData> Gosu::Graphics::createImage(
             Bitmap trimmedSrc;
             trimmedSrc.resize(srcWidth, srcHeight);
             trimmedSrc.insert(src, 0, 0, srcX, srcY, srcWidth, srcHeight);
-            data = texture->tryAlloc(*this, pimpl->queues, texture,
+            data = texture->tryAlloc(*this, pimpl->absoluteTransforms, pimpl->queues, texture,
                     trimmedSrc, 0, 0, trimmedSrc.width(), trimmedSrc.height(), 0);
         }
         
@@ -373,7 +405,7 @@ std::auto_ptr<Gosu::ImageData> Gosu::Graphics::createImage(
         boost::shared_ptr<Texture> texture(*i);
         
         std::auto_ptr<ImageData> data;
-        data = texture->tryAlloc(*this, pimpl->queues, texture, bmp, 0, 0, bmp.width(), bmp.height(), 1);
+        data = texture->tryAlloc(*this, pimpl->absoluteTransforms, pimpl->queues, texture, bmp, 0, 0, bmp.width(), bmp.height(), 1);
         if (data.get())
             return data;
     }
@@ -385,7 +417,7 @@ std::auto_ptr<Gosu::ImageData> Gosu::Graphics::createImage(
     pimpl->textures.push_back(texture);
     
     std::auto_ptr<ImageData> data;
-    data = texture->tryAlloc(*this, pimpl->queues, texture, bmp, 0, 0, bmp.width(), bmp.height(), 1);
+    data = texture->tryAlloc(*this, pimpl->absoluteTransforms, pimpl->queues, texture, bmp, 0, 0, bmp.width(), bmp.height(), 1);
     if (!data.get())
         throw std::logic_error("Internal texture block allocation error");
 

data/GosuImpl/Graphics/LargeImageData.cpp

@@ -116,3 +116,13 @@ void Gosu::LargeImageData::draw(double x1, double y1, Color c1,
                 absXBL, absYBL, absCBL, absXBR, absYBR, absCBR, z, mode);
         }
 }
+
+Gosu::Bitmap Gosu::LargeImageData::toBitmap() const
+{
+    Bitmap bitmap;
+    bitmap.resize(width(), height());
+    for (int x = 0; x < partsX; ++x)
+        for (int y = 0; y < partsY; ++y)
+            bitmap.insert(parts[y * partsX + x]->toBitmap(), x * partWidth, y * partHeight);
+    return bitmap;
+}

data/GosuImpl/Graphics/LargeImageData.hpp

@@ -31,6 +31,8 @@ namespace Gosu
         {
             return boost::none;
         }
+        
+        Bitmap toBitmap() const;
     };
 }
 

data/GosuImpl/Graphics/Macro.hpp

@@ -73,6 +73,11 @@ public:
     {
         return boost::none;
     }
+    
+    Gosu::Bitmap toBitmap() const
+    {
+        throw std::logic_error("Gosu::Macro cannot be rendered to Gosu::Bitmap");
+    }
 };
 
 #endif

data/GosuImpl/Graphics/TexChunk.cpp

@@ -4,10 +4,10 @@
 #include <Gosu/Bitmap.hpp>
 #include <Gosu/Graphics.hpp>
 
-Gosu::TexChunk::TexChunk(Graphics& graphics, DrawOpQueueStack& queues,
-                                 boost::shared_ptr<Texture> texture,
-                                 int x, int y, int w, int h, int padding)
-: graphics(&graphics), queues(&queues), texture(texture), x(x), y(y), w(w), h(h), padding(padding)
+Gosu::TexChunk::TexChunk(Graphics& graphics, Transforms& transforms, DrawOpQueueStack& queues,
+    boost::shared_ptr<Texture> texture, int x, int y, int w, int h, int padding)
+:   graphics(&graphics), transforms(&transforms), queues(&queues),
+    texture(texture), x(x), y(y), w(w), h(h), padding(padding)
 {
 }
 
@@ -45,7 +45,7 @@ void Gosu::TexChunk::draw(double x1, double y1, Color c1,
     double x4, double y4, Color c4,
     ZPos z, AlphaMode mode) const
 {
-    DrawOp newDrawOp;
+    DrawOp newDrawOp(transforms->back());
     
     reorderCoordinatesIfNecessary(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4);
     
@@ -82,3 +82,8 @@ boost::optional<Gosu::GLTexInfo> Gosu::TexChunk::glTexInfo() const
     getCoords(info.left, info.top, info.right, info.bottom);
     return info;
 }
+
+Gosu::Bitmap Gosu::TexChunk::toBitmap() const
+{
+    return texture->toBitmap(x, y, w, h);
+}

data/GosuImpl/Graphics/TexChunk.hpp

@@ -12,13 +12,14 @@
 class Gosu::TexChunk : public Gosu::ImageData
 {
     Graphics* graphics;
+    Transforms* transforms;
     DrawOpQueueStack* queues;
     boost::shared_ptr<Texture> texture;
     int x, y, w, h, padding;
 
 public:
-    TexChunk(Graphics& graphics, DrawOpQueueStack& queues, boost::shared_ptr<Texture> texture,
-             int x, int y, int w, int h, int padding);
+    TexChunk(Graphics& graphics, Transforms& transforms, DrawOpQueueStack& queues,
+             boost::shared_ptr<Texture> texture, int x, int y, int w, int h, int padding);
     ~TexChunk();
 
     unsigned int width() const;
@@ -34,6 +35,7 @@ public:
         ZPos z, AlphaMode mode) const;
         
     boost::optional<GLTexInfo> glTexInfo() const;
+    Gosu::Bitmap toBitmap() const;
 };
 
 #endif