gosu 0.7.33 → 0.7.35

data/GosuImpl/Graphics/BitmapGDIplus.cpp

@@ -2,16 +2,21 @@
 #include <Gosu/Bitmap.hpp>
 #include <Gosu/IO.hpp>
 #include <Gosu/Platform.hpp>
+#include <Gosu/TR1.hpp>
 #include <Gosu/Utility.hpp>
 #include <Gosu/WinUtility.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/algorithm/string.hpp>
+#include <cwctype>
 #include <map>
 
 #include <objidl.h>
 #include <gdiplus.h>
 #include <windows.h>
 
+using namespace std;
+
+// TODO: Move into proper internal header
+namespace Gosu { bool isExtension(const wchar_t* str, const wchar_t* ext); }
+
 namespace
 {
     bool initialized = false;
@@ -23,7 +28,7 @@ namespace
     {
         // Since GDI+ only supports ARGB=BGRA formats, we
         // manually exchange the R and B channels to get to ABGR=RGBA.
-        boost::uint32_t* p = reinterpret_cast<boost::uint32_t*>(bitmap.data());
+        std::tr1::uint32_t* p = reinterpret_cast<std::tr1::uint32_t*>(bitmap.data());
         for (int i = bitmap.width() * bitmap.height(); i > 0; --i, ++p)
             *p = (*p & 0xff00ff00) | ((*p << 16) & 0x00ff0000) | ((*p >> 16) & 0x000000ff);
     }    
@@ -31,7 +36,7 @@ namespace
     void check(Gdiplus::Status status, const char* action)
     {
         if (status != Gdiplus::Ok)
-            throw std::runtime_error(std::string("A GDI+ error occured while ") + action);
+            throw runtime_error(string("A GDI+ error occured while ") + action);
     }
 
     void closeGDIplus()
@@ -48,9 +53,8 @@ namespace
         atexit(closeGDIplus);
     }
 
-    Gosu::Bitmap gdiPlusToGosu(Gdiplus::Bitmap& bitmap)
+    void gdiPlusToGosu(Gosu::Bitmap& result, Gdiplus::Bitmap& bitmap)
     {
-        Gosu::Bitmap result;
         result.resize(bitmap.GetWidth(), bitmap.GetHeight());
 
         GUID guid;
@@ -79,11 +83,9 @@ namespace
                 
         if (guid == Gdiplus::ImageFormatBMP)
             applyColorKey(result, Gosu::Color::FUCHSIA);
-        
-        return result;
     }
 
-    boost::shared_ptr<IStream> readToIStream(Gosu::Reader reader)
+    tr1::shared_ptr<IStream> readToIStream(Gosu::Reader reader)
     {
         unsigned remaining = reader.resource().size() - reader.position();
         HGLOBAL buffer = ::GlobalAlloc(GMEM_MOVEABLE, remaining);
@@ -100,14 +102,14 @@ namespace
         if (::CreateStreamOnHGlobal(buffer, TRUE, &stream) != S_OK)
         {
             ::GlobalFree(buffer);
-            throw std::runtime_error("Could not create IStream");
+            throw runtime_error("Could not create IStream");
         }
         return Gosu::Win::shareComPtr(stream);
     }
     
-    CLSID& encoderFromMimeType(const std::wstring& mimeType)
+    CLSID& encoderFromMimeType(const wstring& mimeType)
     {
-        static std::map<std::wstring, CLSID> cache;
+        static map<wstring, CLSID> cache;
         if (cache.count(mimeType))
             return cache[mimeType];
 
@@ -115,25 +117,27 @@ namespace
         check(Gdiplus::GetImageEncodersSize(&num, &size), "counting encoders");
         // Do the eleet int-based ceil(size / sizeof)
         unsigned vecSize = (size + sizeof(Gdiplus::ImageCodecInfo) - 1) / sizeof(Gdiplus::ImageCodecInfo);
-        std::vector<Gdiplus::ImageCodecInfo> codecs(vecSize);
+        vector<Gdiplus::ImageCodecInfo> codecs(vecSize);
         check(Gdiplus::GetImageEncoders(num, size,
             &codecs[0]), "enumerating encoders");
         for (int i = 0; i < num; ++i)
             if (codecs[i].MimeType == mimeType)
                 return cache[mimeType] = codecs[i].Clsid;
-        throw std::runtime_error("No encoder found for " + Gosu::wstringToUTF8(mimeType));
+        throw runtime_error("No encoder found for " + Gosu::wstringToUTF8(mimeType));
     }
 
-    CLSID encoderFromHint(const std::wstring& formatHint)
+    CLSID encoderFromHint(const wstring& formatHint)
     {
-        std::wstring::size_type idx = formatHint.rfind('.');
-        std::wstring mimeType = L"image/";
-        if (idx == std::wstring::npos)
+        wstring::size_type idx = formatHint.rfind('.');
+        wstring mimeType = L"image/";
+        if (idx == wstring::npos)
             mimeType += formatHint;
         else
             mimeType += formatHint.substr(idx + 1);
-        boost::to_lower(mimeType);
-
+            
+        for (int i = 0; i < mimeType.size(); ++i)
+            mimeType[i] = towlower((wint_t)mimeType[i]);
+        
         // Fix pitfalls
         if (mimeType == L"image/jpg")
             mimeType = L"image/jpeg";
@@ -144,31 +148,31 @@ namespace
     }
 }
 
-Gosu::Bitmap Gosu::loadImageFile(const std::wstring& filename)
+void Gosu::loadImageFile(Gosu::Bitmap& result, const wstring& filename)
 {
     requireGDIplus();
 
     Gdiplus::Bitmap bitmap(filename.c_str());
     check(bitmap.GetLastStatus(), ("loading " + wstringToUTF8(filename)).c_str());
-    return gdiPlusToGosu(bitmap);
+    gdiPlusToGosu(result, bitmap);
 }
 
-Gosu::Bitmap Gosu::loadImageFile(Reader reader)
+void Gosu::loadImageFile(Gosu::Bitmap& result, Reader reader)
 {
     requireGDIplus();
 
-    boost::shared_ptr<IStream> stream = readToIStream(reader);
+    tr1::shared_ptr<IStream> stream = readToIStream(reader);
     Gdiplus::Bitmap bitmap(stream.get());
     check(bitmap.GetLastStatus(), "loading a bitmap from memory");
-    return gdiPlusToGosu(bitmap);
+    gdiPlusToGosu(result, bitmap);
 }
 
-void Gosu::saveImageFile(const Bitmap& bitmap, const std::wstring& filename)
+void Gosu::saveImageFile(const Bitmap& bitmap, const wstring& filename)
 {
     requireGDIplus();
 
     Bitmap input = bitmap;
-    if (boost::iends_with(filename, "bmp"))
+    if (isExtension(filename.c_str(), L".bmp"))
         unapplyColorKey(input, Color::FUCHSIA);
     reshuffleBitmap(input);
     Gdiplus::Bitmap output(input.width(), input.height(), input.width() * 4,
@@ -179,12 +183,12 @@ void Gosu::saveImageFile(const Bitmap& bitmap, const std::wstring& filename)
         ("writing to " + wstringToUTF8(filename)).c_str());
 }
 
-void Gosu::saveImageFile(const Bitmap& bitmap, Writer writer, const std::wstring& formatHint)
+void Gosu::saveImageFile(const Bitmap& bitmap, Writer writer, const wstring& formatHint)
 {
     requireGDIplus();
 
     Bitmap input = bitmap;
-    if (boost::iends_with(formatHint, "bmp"))
+    if (isExtension(formatHint.c_str(), L".bmp"))
         unapplyColorKey(input, Color::FUCHSIA);
     reshuffleBitmap(input);
     Gdiplus::Bitmap output(input.width(), input.height(), input.width() * 4,
@@ -193,8 +197,8 @@ void Gosu::saveImageFile(const Bitmap& bitmap, Writer writer, const std::wstring
     
     IStream* stream = NULL;
     if (CreateStreamOnHGlobal(0, TRUE, &stream) != S_OK)
-        throw std::runtime_error("Could not create IStream for writing");
-    boost::shared_ptr<IStream> streamGuard(Gosu::Win::shareComPtr(stream));
+        throw runtime_error("Could not create IStream for writing");
+    tr1::shared_ptr<IStream> streamGuard(Gosu::Win::shareComPtr(stream));
     check(output.Save(stream, &encoderFromHint(formatHint)),
         "saving a bitmap to memory");
 

data/GosuImpl/Graphics/BitmapUtils.cpp

@@ -5,7 +5,7 @@
 
 Gosu::Reader Gosu::loadFromPNG(Bitmap& bitmap, Reader reader)
 {
-    bitmap = loadImageFile(reader);
+    loadImageFile(bitmap, reader);
     reader.setPosition(reader.resource().size());
     return reader;
 }

data/GosuImpl/Graphics/BlockAllocator.cpp

@@ -72,24 +72,23 @@ unsigned Gosu::BlockAllocator::height() const
     return pimpl->height;
 }
 
-boost::optional<Gosu::BlockAllocator::Block>
-    Gosu::BlockAllocator::alloc(unsigned aWidth, unsigned aHeight)
+bool Gosu::BlockAllocator::alloc(unsigned aWidth, unsigned aHeight, Block& b)
 {
     // The rect wouldn't even fit onto the texture!
     if (aWidth > width() || aHeight > height())
-        return boost::optional<Block>();
+        return false;
 
     // We know there's no space left.
     if (aWidth > pimpl->maxW && aHeight > pimpl->maxH)
-        return boost::optional<Block>();
+        return false;
     
     // Start to look for a place next to the last returned rect. Chances are
     // good we'll find a place there.
-    Block b = Block(pimpl->firstX, pimpl->firstY, aWidth, aHeight);
+    b = Block(pimpl->firstX, pimpl->firstY, aWidth, aHeight);
     if (pimpl->isBlockFree(b))
     {
         pimpl->markBlockUsed(b, aWidth, aHeight);
-        return b;
+        return true;
     }
 
     // Brute force: Look for a free place on this texture.
@@ -110,13 +109,13 @@ boost::optional<Gosu::BlockAllocator::Block>
                 --x;
             
             pimpl->markBlockUsed(b, aWidth, aHeight);
-            return b;
+            return true;
         }
 
     // So there was no space for the bitmap. Remember this for later.
     pimpl->maxW = aWidth - 1;
     pimpl->maxH = aHeight - 1;
-    return boost::optional<Block>();
+    return false;
 }
 
 void Gosu::BlockAllocator::free(unsigned left, unsigned top)

data/GosuImpl/Graphics/BlockAllocator.hpp

@@ -1,15 +1,14 @@
 #ifndef GOSUIMPL_BLOCKALLOCATOR_HPP
 #define GOSUIMPL_BLOCKALLOCATOR_HPP
 
-#include <boost/optional.hpp>
-#include <boost/scoped_ptr.hpp>
+#include <memory>
 
 namespace Gosu
 {
     class BlockAllocator
     {
         struct Impl;
-        boost::scoped_ptr<Impl> pimpl;
+        const std::auto_ptr<Impl> pimpl;
 
     public:
         struct Block
@@ -26,7 +25,7 @@ namespace Gosu
         unsigned width() const;
         unsigned height() const;
 
-        boost::optional<Block> alloc(unsigned width, unsigned height);
+        bool alloc(unsigned width, unsigned height, Block& block);
         void free(unsigned left, unsigned top);
     };
 }

data/GosuImpl/Graphics/Common.hpp

@@ -61,10 +61,11 @@ namespace Gosu
     inline Transform multiply(const Transform& left, const Transform& right)
     {
         Gosu::Transform result;
-        result.assign(0);
-        for (int i = 0; i < 16; ++i)
+        for (int i = 0; i < 16; ++i) {
+            result[i] = 0;
             for (int j = 0; j < 4; ++j)
                 result[i] += left[i / 4 * 4 + j] * right[i % 4 + j * 4];
+        }
         return result;
     }
     

data/GosuImpl/Graphics/DrawOp.hpp

@@ -6,14 +6,13 @@
 #include <GosuImpl/Graphics/Common.hpp>
 #include <GosuImpl/Graphics/TexChunk.hpp>
 #include <GosuImpl/Graphics/RenderState.hpp>
-#include <boost/cstdint.hpp>
 
 namespace Gosu
 {
     struct ArrayVertex
     {
         float texCoords[2];
-        boost::uint32_t color;
+        unsigned color;
         float vertices[3];
     };
     typedef std::vector<ArrayVertex> VertexArray;
@@ -52,7 +51,7 @@ namespace Gosu
             static int spriteCounter = 0;
             static float spriteVertices[12 * MAX_AUTOGROUP];
             static float spriteTexcoords[12 * MAX_AUTOGROUP];
-            static boost::uint32_t spriteColors[6 * MAX_AUTOGROUP];
+            static unsigned spriteColors[6 * MAX_AUTOGROUP];
             
             // iPhone specific setup
             static bool isSetup = false;

data/GosuImpl/Graphics/DrawOpQueue.hpp

@@ -1,11 +1,10 @@
 #ifndef GOSUIMPL_GRAPHICS_DRAWOPQUEUE_HPP
 #define GOSUIMPL_GRAPHICS_DRAWOPQUEUE_HPP
 
+#include <Gosu/TR1.hpp>
 #include <GosuImpl/Graphics/Common.hpp>
 #include <GosuImpl/Graphics/DrawOp.hpp>
-#include <boost/foreach.hpp>
-#include <boost/function.hpp>
-#include <boost/optional.hpp>
+#include <cassert>
 #include <algorithm>
 #include <map>
 #include <vector>
@@ -14,7 +13,7 @@ class Gosu::DrawOpQueue
 {
     typedef std::vector<DrawOp> DrawOps;
     DrawOps ops;
-    typedef std::multimap<ZPos, boost::function<void()> > CodeMap;
+    typedef std::multimap<ZPos, std::tr1::function<void()> > CodeMap;
     CodeMap code;
 
     struct ClipRect
@@ -23,15 +22,21 @@ class Gosu::DrawOpQueue
         unsigned width, height;
     };
     std::vector<ClipRect> clipRectStack;
-    boost::optional<ClipRect> effectiveRect;
+    ClipRect effectiveRect;
+    bool haveEffectiveRect; // is effectiveRect valid?
+    
     void updateEffectiveRect()
     {
         if (clipRectStack.empty())
-            return effectiveRect.reset();
-
+        {
+            haveEffectiveRect = false;
+            return;
+        }
+        
         ClipRect result = { 0, 0, 0x7fffffff, 0x7fffffff };
-        BOOST_FOREACH (const ClipRect& rect, clipRectStack)
+        for (int i = 0; i < clipRectStack.size(); ++i)
         {
+            const ClipRect& rect = clipRectStack[i];
             int right = std::min<int>(result.x + result.width, rect.x + rect.width);
             int bottom = std::min<int>(result.y + result.height, rect.y + rect.height);
             result.x = std::max<int>(result.x, rect.x);
@@ -39,7 +44,7 @@ class Gosu::DrawOpQueue
             
             if (result.x >= right || result.y >= bottom)
             {
-                effectiveRect.reset();
+                haveEffectiveRect = false;
                 return;
             }
             
@@ -51,14 +56,18 @@ class Gosu::DrawOpQueue
         result.x *= fac, result.y *= fac, result.width *= fac, result.height *= fac;
         
         effectiveRect = result;
+        haveEffectiveRect = true;
     }
 
 public:
+    DrawOpQueue() : haveEffectiveRect(false) {}
+    
     // I really wish I would trust ADL. :|
     void swap(DrawOpQueue& other)
     {
         clipRectStack.swap(other.clipRectStack);
         std::swap(effectiveRect, other.effectiveRect);
+        std::swap(haveEffectiveRect, other.haveEffectiveRect);
         ops.swap(other.ops);
         code.swap(other.code);
     }
@@ -70,13 +79,12 @@ public:
         assert (op.usedVertices == 4);
         #endif
         
-        if (effectiveRect)
+        if (haveEffectiveRect)
         {
-            const ClipRect& rect = *effectiveRect;
-            op.clipX = rect.x;
-            op.clipY = rect.y;
-            op.clipWidth = rect.width;
-            op.clipHeight = rect.height;
+            op.clipX      = effectiveRect.x;
+            op.clipY      = effectiveRect.y;
+            op.clipWidth  = effectiveRect.width;
+            op.clipHeight = effectiveRect.height;
         }
         else if (!clipRectStack.empty())
             // When we have no effect rect but the stack is not empty, we have clipped
@@ -87,7 +95,7 @@ public:
         ops.push_back(op);
     }
     
-    void scheduleGL(boost::function<void()> customCode, ZPos z)
+    void scheduleGL(std::tr1::function<void()> customCode, ZPos z)
     {
         code.insert(std::make_pair(z, customCode));
     }
@@ -110,8 +118,8 @@ public:
         // Allows us to make some assumptions.
         if (ops.empty())
         {
-            BOOST_FOREACH (const CodeMap::value_type& fn, code)
-                fn.second();
+            for (CodeMap::iterator it = code.begin(), end = code.end(); it != end; ++it)
+                it->second();
             return;
         }
         
@@ -179,8 +187,8 @@ public:
         
         va.reserve(ops.size());
         std::stable_sort(ops.begin(), ops.end());
-        BOOST_FOREACH (const DrawOp& op, ops)
-            op.compileTo(va);
+        for (DrawOps::const_iterator op = ops.begin(), end = ops.end(); op != end; ++op)
+            op->compileTo(va);
     }
 };
 

data/GosuImpl/Graphics/Font.cpp

@@ -3,10 +3,10 @@
 #include <Gosu/Image.hpp>
 #include <Gosu/Math.hpp>
 #include <Gosu/Text.hpp>
+#include <Gosu/TR1.hpp>
 #include <GosuImpl/Graphics/Common.hpp>
 #include <GosuImpl/Graphics/FormattedString.hpp>
-#include <boost/array.hpp>
-#include <boost/shared_ptr.hpp>
+#include <cassert>
 #include <map>
 using namespace std;
 
@@ -38,16 +38,16 @@ struct Gosu::Font::Impl
     // IMPR: I couldn't find a way to determine the size of wchar_t at compile
     // time, so I can't get rid of the magic numbers or even do some #ifdef
     // magic.
-    typedef boost::array<boost::scoped_ptr<Image>, 65536> CharChunk;
-    boost::scoped_ptr<CharChunk> chunks[65536][ffCombinations];
+    typedef tr1::array<auto_ptr<Image>, 65536> CharChunk;
+    auto_ptr<CharChunk> chunks[65536][ffCombinations];
     
-    std::map<std::wstring, boost::shared_ptr<Image> > entityCache;
+    map<wstring, tr1::shared_ptr<Image> > entityCache;
 
     const Image& imageAt(const FormattedString& fs, unsigned i)
     {
         if (fs.entityAt(i))
         {
-            boost::shared_ptr<Image>& ptr = entityCache[fs.entityAt(i)];
+            tr1::shared_ptr<Image>& ptr = entityCache[fs.entityAt(i)];
             if (!ptr)
                 ptr.reset(new Image(*graphics, entityBitmap(fs.entityAt(i)), false));
             return *ptr;
@@ -61,12 +61,12 @@ struct Gosu::Font::Impl
         size_t chunkIndex = wc / 65536;
         size_t charIndex = wc % 65536;
 
-        if (!chunks[chunkIndex][flags])
+        if (!chunks[chunkIndex][flags].get())
             chunks[chunkIndex][flags].reset(new CharChunk);
 
-        boost::scoped_ptr<Image>& imgPtr = (*chunks[chunkIndex][flags])[charIndex];
+        auto_ptr<Image>& imgPtr = (*chunks[chunkIndex][flags])[charIndex];
 
-        if (imgPtr)
+        if (imgPtr.get())
             return *imgPtr;
 
         wstring charString(1, wc);
@@ -99,7 +99,7 @@ Gosu::Font::Font(Graphics& graphics, const wstring& fontName, unsigned fontHeigh
     pimpl->flags = fontFlags;
 }
 
-std::wstring Gosu::Font::name() const
+wstring Gosu::Font::name() const
 {
     return pimpl->name;
 }
@@ -114,9 +114,9 @@ unsigned Gosu::Font::flags() const
     return pimpl->flags;
 }
 
-double Gosu::Font::textWidth(const std::wstring& text, double factorX) const
+double Gosu::Font::textWidth(const wstring& text, double factorX) const
 {
-    FormattedString fs(text, flags());
+    FormattedString fs(text.c_str(), flags());
     double result = 0;
     for (unsigned i = 0; i < fs.length(); ++i)
         result += pimpl->imageAt(fs, i).width() * pimpl->factorAt(fs, i);
@@ -126,7 +126,7 @@ double Gosu::Font::textWidth(const std::wstring& text, double factorX) const
 void Gosu::Font::draw(const wstring& text, double x, double y, ZPos z,
     double factorX, double factorY, Color c, AlphaMode mode) const
 {
-    FormattedString fs(text, flags());
+    FormattedString fs(text.c_str(), flags());
 
     enum {
         LTR = 1,