gosu 0.7.33 → 0.7.35

data/GosuImpl/Graphics/LargeImageData.hpp

@@ -3,8 +3,7 @@
 
 #include <Gosu/Fwd.hpp>
 #include <Gosu/ImageData.hpp>
-#include <boost/none.hpp>
-#include <boost/shared_ptr.hpp>
+#include <Gosu/TR1.hpp>
 #include <vector>
 
 namespace Gosu
@@ -12,7 +11,7 @@ namespace Gosu
     class LargeImageData : public ImageData
     {
         unsigned fullWidth, fullHeight, partsX, partsY, partWidth, partHeight;
-        std::vector<boost::shared_ptr<ImageData> > parts;
+        std::vector<std::tr1::shared_ptr<ImageData> > parts;
 
     public:
         LargeImageData(Graphics& graphics, const Bitmap& source,
@@ -27,9 +26,9 @@ namespace Gosu
             double x4, double y4, Color c4,
             ZPos z, AlphaMode mode) const;
             
-        boost::optional<GLTexInfo> glTexInfo() const
+        const GLTexInfo* glTexInfo() const
         {
-            return boost::none;
+            return 0;
         }
         
         Bitmap toBitmap() const;

data/GosuImpl/Graphics/Macro.hpp

@@ -3,13 +3,12 @@
 
 #include <Gosu/Fwd.hpp>
 #include <Gosu/ImageData.hpp>
+#include <Gosu/TR1.hpp>
 #include <GosuImpl/Graphics/Common.hpp>
 #include <GosuImpl/Graphics/DrawOpQueue.hpp>
-#include <boost/bind.hpp>
-#include <boost/foreach.hpp>
-#include <boost/scoped_ptr.hpp>
 #include <cmath>
 #include <algorithm>
+#include <memory>
 
 class Gosu::Macro : public Gosu::ImageData
 {
@@ -23,12 +22,13 @@ public:
     {
         queue.compileTo(vertexArray);
         double left = 0, right = 0, top = 0, bottom = 0;
-        BOOST_FOREACH (const ArrayVertex& av, vertexArray)
+        for (VertexArray::const_iterator it = vertexArray.begin(),
+             end = vertexArray.end(); it != end; ++it)
         {
-            left = std::min<double>(left, av.vertices[0]);
-            right = std::max<double>(right, av.vertices[0]);
-            top = std::min<double>(top, av.vertices[1]);
-            bottom = std::max<double>(bottom, av.vertices[1]);
+            left   = std::min<double>(left,   it->vertices[0]);
+            right  = std::max<double>(right,  it->vertices[0]);
+            top    = std::min<double>(top,    it->vertices[1]);
+            bottom = std::max<double>(bottom, it->vertices[1]);
         }
         w = std::ceil(right - left);
         h = std::ceil(bottom - top);
@@ -50,7 +50,7 @@ public:
               double x4, double y4, Color c4,
               ZPos z, AlphaMode mode) const
     {
-        boost::function<void()> f = boost::bind(&Macro::realDraw, this, x1, y1, x2, y2, x3, y3);
+        std::tr1::function<void()> f = std::tr1::bind(&Macro::realDraw, this, x1, y1, x2, y2, x3, y3);
         graphics.scheduleGL(f, z);
     }
     
@@ -83,9 +83,9 @@ public:
     #endif
     }
     
-    boost::optional<Gosu::GLTexInfo> glTexInfo() const
+    const Gosu::GLTexInfo* glTexInfo() const
     {
-        return boost::none;
+        return 0;
     }
     
     Gosu::Bitmap toBitmap() const

data/GosuImpl/Graphics/RenderState.hpp

@@ -34,11 +34,12 @@ public:
         glPopMatrix();
         glPushMatrix();
         #ifndef GOSU_IS_IPHONE
-        glMultMatrixd(newTransform->data());
+        glMultMatrixd(&(*newTransform)[0]);
         #else
-        boost::array<float, 16> matrix;
-        matrix = *newTransform;
-        glMultMatrixf(matrix.data());
+        float matrix[16];
+        for (int i = 0; i < 16; ++i)
+            matrix[i] = (*newTransform)[i];
+        glMultMatrixf(matrix);
         #endif
         transform = newTransform;
     }

data/GosuImpl/Graphics/TexChunk.cpp

@@ -5,7 +5,7 @@
 #include <Gosu/Graphics.hpp>
 
 Gosu::TexChunk::TexChunk(Graphics& graphics, Transforms& transforms, DrawOpQueueStack& queues,
-    boost::shared_ptr<Texture> texture, int x, int y, int w, int h, int padding)
+    std::tr1::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)
 {
@@ -48,9 +48,9 @@ void Gosu::TexChunk::draw(double x1, double y1, Color c1,
     queues->back().scheduleDrawOp(newDrawOp, z);
 }
 
-boost::optional<Gosu::GLTexInfo> Gosu::TexChunk::glTexInfo() const
+const Gosu::GLTexInfo* Gosu::TexChunk::glTexInfo() const
 {
-    return info;
+    return &info;
 }
 
 Gosu::Bitmap Gosu::TexChunk::toBitmap() const

data/GosuImpl/Graphics/TexChunk.hpp

@@ -3,18 +3,18 @@
 
 #include <Gosu/Fwd.hpp>
 #include <Gosu/ImageData.hpp>
+#include <Gosu/TR1.hpp>
 #include <GosuImpl/Graphics/Common.hpp>
 #include <memory>
 #include <vector>
 #include <stdexcept>
-#include <boost/shared_ptr.hpp>
 
 class Gosu::TexChunk : public Gosu::ImageData
 {
     Graphics* graphics;
     Transforms* transforms;
     DrawOpQueueStack* queues;
-    boost::shared_ptr<Texture> texture;
+    std::tr1::shared_ptr<Texture> texture;
     int x, y, w, h, padding;
     
     // Cached for faster access.
@@ -22,7 +22,7 @@ class Gosu::TexChunk : public Gosu::ImageData
 
 public:
     TexChunk(Graphics& graphics, Transforms& transforms, DrawOpQueueStack& queues,
-             boost::shared_ptr<Texture> texture, int x, int y, int w, int h, int padding);
+             std::tr1::shared_ptr<Texture> texture, int x, int y, int w, int h, int padding);
     ~TexChunk();
 
     unsigned int width() const
@@ -54,7 +54,7 @@ public:
         double x4, double y4, Color c4,
         ZPos z, AlphaMode mode) const;
         
-    boost::optional<GLTexInfo> glTexInfo() const;
+    const GLTexInfo* glTexInfo() const;
     Gosu::Bitmap toBitmap() const;
     void insert(const Bitmap& bitmap, int x, int y);
 };

data/GosuImpl/Graphics/Text.cpp

@@ -3,13 +3,10 @@
 #include <Gosu/Graphics.hpp>
 #include <Gosu/Image.hpp>
 #include <Gosu/Math.hpp>
+#include <Gosu/TR1.hpp>
 #include <Gosu/Utility.hpp>
 #include <GosuImpl/Graphics/Common.hpp>
 #include <GosuImpl/Graphics/FormattedString.hpp>
-#include <boost/algorithm/string.hpp>
-#include <boost/bind.hpp>
-#include <boost/foreach.hpp>
-#include <boost/shared_ptr.hpp>
 #include <cassert>
 #include <cmath>
 #include <algorithm>
@@ -104,10 +101,10 @@ namespace Gosu
                 if (text.entityAt(0))
                     return entityBitmap(text.entityAt(0)).width();
                 
-                std::vector<FormattedString> parts = text.splitParts();
+                vector<FormattedString> parts = text.splitParts();
                 unsigned result = 0;
-                BOOST_FOREACH (const FormattedString& part, parts)
-                    result += Gosu::textWidth(part.unformat(), fontName, fontHeight, part.flagsAt(0));
+                for (unsigned i = 0; i < parts.size(); ++i)
+                    result += Gosu::textWidth(parts[i].unformat(), fontName, fontHeight, parts[i].flagsAt(0));
                 return result;
             }
 
@@ -145,13 +142,15 @@ namespace Gosu
                 default:
                     pos = 0;
                 }
-
+                
                 for (Words::const_iterator cur = begin; cur != end; ++cur)
                 {
-                    std::vector<FormattedString> parts = cur->text.splitParts();
+                    vector<FormattedString> parts = cur->text.splitParts();
                     int x = 0;
-                    BOOST_FOREACH (const FormattedString& part, parts)
+                    for (int i = 0; i < parts.size(); ++i)
                     {
+                        FormattedString& part = parts[i];
+                        
                         if (part.entityAt(0))
                         {
                             Gosu::Bitmap entity = entityBitmap(part.entityAt(0));
@@ -161,7 +160,7 @@ namespace Gosu
                             continue;
                         }
                         
-                        std::wstring unformattedPart = part.unformat();
+                        wstring unformattedPart = part.unformat();
                         drawText(bmp, unformattedPart, trunc(pos) + x, trunc(top),
                             part.colorAt(0), fontName, fontHeight, part.flagsAt(0));
                         x += Gosu::textWidth(unformattedPart, fontName, fontHeight,
@@ -294,20 +293,20 @@ namespace Gosu
         void processText(TextBlockBuilder& builder, const FormattedString& text)
         {
             vector<FormattedString> paragraphs = text.splitLines();
-            BOOST_FOREACH (FormattedString& fs, paragraphs)
-                processParagraph(builder, fs);
+            for (int i = 0; i < paragraphs.size(); ++i)
+                processParagraph(builder, paragraphs[i]);
         }
     }
 }
 
-Gosu::Bitmap Gosu::createText(const std::wstring& text,
-    const std::wstring& fontName, unsigned fontHeight, int lineSpacing,
+Gosu::Bitmap Gosu::createText(const wstring& text,
+    const wstring& fontName, unsigned fontHeight, int lineSpacing,
     unsigned maxWidth, TextAlign align, unsigned fontFlags)
 {
     if (lineSpacing <= -static_cast<int>(fontHeight))
-        throw std::logic_error("negative line spacing of more than line height impossible");
+        throw logic_error("negative line spacing of more than line height impossible");
 
-    FormattedString fs(boost::replace_all_copy(text, L"\r\n", L"\n"), fontFlags);
+    FormattedString fs(text.c_str(), fontFlags);
     if (fs.length() == 0)
         return Bitmap(maxWidth, fontHeight);
     
@@ -323,10 +322,10 @@ Gosu::Bitmap Gosu::createText(const std::wstring& text,
 }
 
 // Very easy special case.
-Gosu::Bitmap Gosu::createText(const std::wstring& text,
-    const std::wstring& fontName, unsigned fontHeight, unsigned fontFlags)
+Gosu::Bitmap Gosu::createText(const wstring& text,
+    const wstring& fontName, unsigned fontHeight, unsigned fontFlags)
 {
-    FormattedString fs(boost::replace_all_copy(text, L"\r\n", L"\n"), fontFlags);
+    FormattedString fs(text.c_str(), fontFlags);
     if (fs.length() == 0)
         return Bitmap(1, fontHeight);
     
@@ -340,7 +339,7 @@ Gosu::Bitmap Gosu::createText(const std::wstring& text,
             continue;
         
         unsigned x = 0;
-        std::vector<FormattedString> parts = lines[i].splitParts();
+        vector<FormattedString> parts = lines[i].splitParts();
         for (int p = 0; p < parts.size(); ++p)
         {
             const FormattedString& part = parts[p];
@@ -348,17 +347,17 @@ Gosu::Bitmap Gosu::createText(const std::wstring& text,
             {
                 Gosu::Bitmap entity = entityBitmap(part.entityAt(0));
                 multiplyBitmapAlpha(entity, part.colorAt(0).alpha());
-                bmp.resize(std::max(bmp.width(), x + entity.width()), bmp.height());
+                bmp.resize(max(bmp.width(), x + entity.width()), bmp.height());
                 bmp.insert(entity, x, i * fontHeight);
                 x += entity.width();
                 continue;
             }
                 
             assert(part.length() > 0);
-            std::wstring unformattedText = part.unformat();
+            wstring unformattedText = part.unformat();
             unsigned partWidth =
                 textWidth(unformattedText, fontName, fontHeight, part.flagsAt(0));
-            bmp.resize(std::max(bmp.width(), x + partWidth), bmp.height());
+            bmp.resize(max(bmp.width(), x + partWidth), bmp.height());
             drawText(bmp, unformattedText, x, i * fontHeight, part.colorAt(0),
                 fontName, fontHeight, part.flagsAt(0));
             x += partWidth;
@@ -370,23 +369,23 @@ Gosu::Bitmap Gosu::createText(const std::wstring& text,
 
 namespace
 {
-    std::map<std::wstring, boost::shared_ptr<Gosu::Bitmap> > entities;
+    map<wstring, tr1::shared_ptr<Gosu::Bitmap> > entities;
 }
 
-void Gosu::registerEntity(const std::wstring& name, const Gosu::Bitmap& replacement)
+void Gosu::registerEntity(const wstring& name, const Gosu::Bitmap& replacement)
 {
     entities[name].reset(new Bitmap(replacement));
 }
 
-bool Gosu::isEntity(const std::wstring& name)
+bool Gosu::isEntity(const wstring& name)
 {
     return entities[name];
 }
 
-const Gosu::Bitmap& Gosu::entityBitmap(const std::wstring& name)
+const Gosu::Bitmap& Gosu::entityBitmap(const wstring& name)
 {
-    boost::shared_ptr<Gosu::Bitmap>& ptr = entities[name];
+    tr1::shared_ptr<Gosu::Bitmap>& ptr = entities[name];
     if (!ptr)
-        throw std::runtime_error("Unknown entity: " + Gosu::wstringToUTF8(name));
+        throw runtime_error("Unknown entity: " + Gosu::wstringToUTF8(name));
     return *ptr;
 }

data/GosuImpl/Graphics/TextMac.cpp

@@ -4,11 +4,10 @@
 
 #include <Gosu/Bitmap.hpp>
 #include <Gosu/Text.hpp>
+#include <Gosu/TR1.hpp>
 #include <Gosu/Utility.hpp>
 #include <Gosu/IO.hpp>
 #include <GosuImpl/MacUtility.hpp>
-#include <boost/utility.hpp>
-#include <boost/cstdint.hpp>
 #include <cmath>
 #include <stdexcept>
 #include <map>
@@ -29,17 +28,20 @@ namespace Gosu
 
 namespace
 {
-    class MacBitmap : boost::noncopyable
+    class MacBitmap
     {
-        boost::uint32_t* buf;
+        std::tr1::uint32_t* buf;
         unsigned width, height;
         CGContextRef ctx;
+        
+        MacBitmap(const MacBitmap&);
+        MacBitmap& operator=(const MacBitmap&);
 
     public:
-        MacBitmap(boost::uint32_t* buf, unsigned width, unsigned height)
+        MacBitmap(std::tr1::uint32_t* buf, unsigned width, unsigned height)
         : buf(buf), width(width), height(height)
         {
-            CGColorSpaceRef colorSpace = CGColorSpaceCreateWithName(kCGColorSpaceUserRGB); 
+            CGColorSpaceRef colorSpace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB); 
             ctx = CGBitmapContextCreate (buf, width, height, 8, width * 4, colorSpace,
                 kCGImageAlphaPremultipliedLast);
 
@@ -224,7 +226,7 @@ void Gosu::drawText(Bitmap& bitmap, const std::wstring& text, int x, int y,
     ATSULayoutAndStyle atlas(text, fontName, fontHeight, fontFlags);
     Rect rect = atlas.textExtents();
     unsigned width = rect.right + 1 - rect.left + 1; // add one pixel on OS X
-    std::vector<boost::uint32_t> buf(width * fontHeight);
+    std::vector<std::tr1::uint32_t> buf(width * fontHeight);
     {
         MacBitmap helper(&buf[0], width, fontHeight);
         atlas.drawToContext(X2Fix(-rect.left), X2Fix(fontHeight / font.heightAt1Pt * font.descentAt1Pt),

data/GosuImpl/Graphics/TextTTFWin.cpp

@@ -1,4 +1,6 @@
 #include <windows.h>
+#include <cassert>
+#include <cstdio>
 #include <Gosu/Utility.hpp>
 
 // Adapted from http://www.codeproject.com/KB/GDI/xfont.aspx.
@@ -197,7 +199,7 @@ std::wstring getNameFromTTFFile(const std::wstring& filename)
 
 				if (szTemp[0] != 0)
 				{
-					_ASSERTE(strlen(szTemp) < sizeof(lpFontProps->csName));
+					assert (strlen(szTemp) < sizeof(lpFontProps->csName));
 
 					switch (ttRecord.uNameID)
 					{

data/GosuImpl/Graphics/TextTouch.mm

@@ -6,7 +6,6 @@
 #include <Gosu/Bitmap.hpp>
 #include <Gosu/Utility.hpp>
 #include <GosuImpl/MacUtility.hpp>
-#include <boost/algorithm/string.hpp>
 #include <map>
 #include <cmath>
 using namespace std;

data/GosuImpl/Graphics/TextUnix.cpp

@@ -7,7 +7,6 @@
 #include <glib.h>
 #include <SDL/SDL_ttf.h>
 
-#include <boost/utility.hpp>
 #include <string>
 #include <cstring>
 #include <stdexcept>
@@ -21,8 +20,11 @@ namespace Gosu
 {
     // Used for system fonts
     // Adapted from original version by Jan Lücker
-    class PangoRenderer : boost::noncopyable
+    class PangoRenderer
     {
+        PangoRenderer(const PangoRenderer&);
+        PangoRenderer& operator=(const PangoRenderer&);
+        
         int width, height;
 
         PangoContext* context;
@@ -161,12 +163,18 @@ namespace Gosu
 
     // Used for custom TTF files
     // Adapted from customFont class by José Tomás Tocino García (TheOm3ga)
-    class SDLTTFRenderer : boost::noncopyable
+    class SDLTTFRenderer
     {
+        SDLTTFRenderer(const SDLTTFRenderer&);
+        SDLTTFRenderer& operator=(const SDLTTFRenderer&);
+        
         TTF_Font* font;
         
-        class SDLSurface : boost::noncopyable
+        class SDLSurface
         {
+            SDLSurface(const SDLSurface&);
+            SDLSurface& operator=(const SDLSurface&);
+            
             SDL_Surface* surface;
             
         public:

data/GosuImpl/Graphics/TextWin.cpp

@@ -5,7 +5,6 @@
 #include <Gosu/Text.hpp>
 #include <Gosu/Utility.hpp>
 #include <Gosu/WinUtility.hpp>
-#include <boost/utility.hpp>
 #include <cstdlib>
 #include <cwchar>
 #include <algorithm>
@@ -27,8 +26,11 @@ namespace Gosu
 
     namespace
     {
-        class WinBitmap : boost::noncopyable
+        class WinBitmap
         {
+            WinBitmap(const WinBitmap&);
+            WinBitmap& operator=(const WinBitmap&);
+            
             HDC dc;
             HBITMAP bitmap;
             char* pixels;