gosu 0.7.22 → 0.7.23

data/GosuImpl/Graphics/Image.cpp

@@ -107,57 +107,6 @@ void Gosu::Image::drawRot(double x, double y, ZPos z,
                c, z, mode);
 }
 
-void Gosu::Image::drawRotFlip(double x, double y, ZPos z,
-    RotFlip rf,
-    double factorX, double factorY,
-    Color c,
-    AlphaMode mode) const
-{
-    drawRotFlipMod(x, y, z, rf, factorX, factorY, c, c, c, c, mode);
-}
-
-void Gosu::Image::drawRotFlipMod(double x, double y, ZPos z,
-    RotFlip rf,
-    double factorX, double factorY,
-    Color c1, Color c2, Color c3, Color c4,
-    AlphaMode mode) const
-{
-    double offsetX;
-    double offsetY;
-
-    if (rf.rotated())
-    {
-        offsetX = height() * factorY / 2;
-        offsetY = width() * factorX / 2;
-    }
-    else
-    {
-        offsetX = width() * factorX / 2;
-        offsetY = height() * factorY / 2;
-    }
-
-    struct Point
-    {
-        double x, y;
-    };
-
-    Point corners[4] = { { x - offsetX, y - offsetY },
-                         { x + offsetX, y - offsetY },
-                         { x - offsetX, y + offsetY },
-                         { x + offsetX, y + offsetY } };
-
-    Point* vertices[4] =
-        { &corners[rf.mapCorner(0)], &corners[rf.mapCorner(1)],
-          &corners[rf.mapCorner(2)], &corners[rf.mapCorner(3)] };
-
-    data->draw(
-        vertices[0]->x, vertices[0]->y, c1,
-        vertices[1]->x, vertices[1]->y, c2,
-        vertices[2]->x, vertices[2]->y, c3,
-        vertices[3]->x, vertices[3]->y, c4,
-        z, mode);
-}
-
 const Gosu::ImageData& Gosu::Image::getData() const
 {
     return *data;

data/GosuImpl/Graphics/Macro.hpp

@@ -4,6 +4,7 @@
 #include <Gosu/Fwd.hpp>
 #include <Gosu/ImageData.hpp>
 #include <GosuImpl/Graphics/Common.hpp>
+#include <GosuImpl/Graphics/DrawOpQueue.hpp>
 #include <boost/foreach.hpp>
 #include <boost/scoped_ptr.hpp>
 #include <cmath>

data/GosuImpl/Graphics/RenderState.hpp

@@ -0,0 +1,107 @@
+#ifndef GOSUIMPL_GRAPHICS_RENDERSTATE_HPP
+#define GOSUIMPL_GRAPHICS_RENDERSTATE_HPP
+
+#include <GosuImpl/Graphics/Common.hpp>
+
+class Gosu::RenderState
+{
+    GLuint texName;
+    Transform* transform;
+    unsigned clipX, clipY, clipWidth, clipHeight;
+    AlphaMode mode;
+    
+public:
+    RenderState()
+    :   texName(NO_TEXTURE), transform(0), clipWidth(NO_CLIPPING), mode(amDefault)
+    {
+        glMatrixMode(GL_MODELVIEW);
+        glPushMatrix();
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    }
+    
+    ~RenderState()
+    {
+        setClipRect(NO_CLIPPING, NO_CLIPPING, NO_CLIPPING, NO_CLIPPING);
+        setTexName(NO_TEXTURE);
+        glPopMatrix();
+    }
+    
+    void setTransform(Transform* newTransform)
+    {
+        if (newTransform == transform)
+            return;
+            
+        glPopMatrix();
+        glPushMatrix();
+        #ifndef GOSU_IS_IPHONE
+        glMultMatrixd(newTransform->data());
+        #else
+        boost::array<float, 16> matrix;
+        matrix = *newTransform;
+        glMultMatrixf(matrix.data());
+        #endif
+        transform = newTransform;
+    }
+
+    void setTexName(GLuint newTexName)
+    {
+        if (newTexName == texName)
+            return;
+    
+        if (newTexName != NO_TEXTURE)
+        {
+            if (texName == NO_TEXTURE)
+                glEnable(GL_TEXTURE_2D);
+            glBindTexture(GL_TEXTURE_2D, newTexName);
+        }
+        else if (texName != NO_TEXTURE)
+            glDisable(GL_TEXTURE_2D);
+        texName = newTexName;
+    }
+    
+    void setClipRect(unsigned newClipX, unsigned newClipY,
+        unsigned newClipWidth, unsigned newClipHeight)
+    {
+        if (newClipWidth == NO_CLIPPING)
+        {
+            // Disable clipping
+            if (clipWidth != NO_CLIPPING)
+            {
+                glDisable(GL_SCISSOR_TEST);
+                clipWidth = NO_CLIPPING;
+            }
+        }
+        else
+        {
+            // Enable clipping if off
+            if (clipWidth == NO_CLIPPING)
+            {
+                glEnable(GL_SCISSOR_TEST);
+                glScissor(clipX = newClipX, clipY = newClipY,
+                    clipWidth = newClipWidth, clipHeight = newClipHeight);
+            }
+            // Adjust clipping if necessary
+            else if (clipX != newClipX || clipY != newClipY ||
+                clipWidth != newClipWidth || clipHeight != newClipHeight)
+            {
+                glScissor(clipX = newClipX, clipY = newClipY,
+                    clipWidth = newClipWidth, clipHeight = newClipHeight);
+            }
+        }
+    }
+    
+    void setAlphaMode(AlphaMode newMode)
+    {
+        if (newMode == mode)
+            return;
+        mode = newMode;
+        if (mode == amAdditive)
+            glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+        else if (mode == amMultiply)
+            glBlendFunc(GL_DST_COLOR, GL_ZERO);
+        else
+            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    }
+};
+    
+#endif

data/GosuImpl/Graphics/TexChunk.cpp

@@ -1,6 +1,6 @@
 #include <GosuImpl/Graphics/TexChunk.hpp>
 #include <GosuImpl/Graphics/Texture.hpp>
-#include <GosuImpl/Graphics/DrawOp.hpp>
+#include <GosuImpl/Graphics/DrawOpQueue.hpp>
 #include <Gosu/Bitmap.hpp>
 #include <Gosu/Graphics.hpp>
 
@@ -49,15 +49,6 @@ void Gosu::TexChunk::draw(double x1, double y1, Color c1,
     
     reorderCoordinatesIfNecessary(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4);
     
-    x1 *= graphics->factorX();
-    y1 *= graphics->factorY();
-    x2 *= graphics->factorX();
-    y2 *= graphics->factorY();
-    x3 *= graphics->factorX();
-    y3 *= graphics->factorY();
-    x4 *= graphics->factorX();
-    y4 *= graphics->factorY();
-    
     newDrawOp.usedVertices = 4;
     newDrawOp.vertices[0] = DrawOp::Vertex(x1, y1, c1);
     newDrawOp.vertices[1] = DrawOp::Vertex(x2, y2, c2);

data/GosuImpl/Graphics/Text.cpp

@@ -56,7 +56,8 @@ namespace Gosu
             unsigned usedLines, allocatedLines;
 
             wstring fontName;
-            unsigned fontHeight, lineSpacing;
+            unsigned fontHeight;
+            int lineSpacing;
             TextAlign align;
 
             unsigned spaceWidth_;
@@ -68,14 +69,14 @@ namespace Gosu
                 {
                     allocatedLines += 10;
                     bmp.resize(bmp.width(),
-                        (lineSpacing + fontHeight) * allocatedLines,
+                        fontHeight * allocatedLines + lineSpacing * (allocatedLines - 1),
                         Color::NONE);
                 }
             }
 
         public:
             TextBlockBuilder(const wstring& fontName, unsigned fontHeight,
-                unsigned lineSpacing, unsigned width, TextAlign align)
+                int lineSpacing, unsigned width, TextAlign align)
             {
                 usedLines = 0;
                 allocatedLines = 10;
@@ -118,8 +119,9 @@ namespace Gosu
                 unsigned words = end - begin;
                 
                 unsigned totalSpacing = 0;
-                for (Words::const_iterator i = begin; i != end - 1; ++i)
-                    totalSpacing += i->spaceWidth;
+                if (begin < end)
+                    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);
@@ -182,7 +184,7 @@ namespace Gosu
             {
                 Bitmap result = bmp;
                 result.resize(result.width(),
-                    usedLines * (lineSpacing + fontHeight));
+                    fontHeight * usedLines + lineSpacing * (usedLines - 1));
                 return result;
             }
             
@@ -299,9 +301,12 @@ namespace Gosu
 }
 
 Gosu::Bitmap Gosu::createText(const std::wstring& text,
-    const std::wstring& fontName, unsigned fontHeight, unsigned lineSpacing,
+    const std::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");
+
     FormattedString fs(boost::replace_all_copy(text, L"\r\n", L"\n"), fontFlags);
     if (fs.length() == 0)
     {
@@ -312,8 +317,7 @@ Gosu::Bitmap Gosu::createText(const std::wstring& text,
     
     // Set up the builder object which will manage all the drawing and
     // conversions for us.
-    TextBlockBuilder builder(fontName, fontHeight,
-        lineSpacing, maxWidth, align);
+    TextBlockBuilder builder(fontName, fontHeight, lineSpacing, maxWidth, align);
     
     // Let the process* functions draw everything.
     processText(builder, fs);
@@ -381,7 +385,15 @@ void Gosu::registerEntity(const std::wstring& name, const Gosu::Bitmap& replacem
     entities[name].reset(new Bitmap(replacement));
 }
 
+bool Gosu::isEntity(const std::wstring& name)
+{
+    return entities[name];
+}
+
 const Gosu::Bitmap& Gosu::entityBitmap(const std::wstring& name)
 {
-    return *entities[name];
+    boost::shared_ptr<Gosu::Bitmap>& ptr = entities[name];
+    if (!ptr)
+        throw std::runtime_error("Unknown entity: " + Gosu::wstringToUTF8(name));
+    return *ptr;
 }

data/GosuImpl/Graphics/TextMac.cpp

@@ -223,8 +223,6 @@ void Gosu::drawText(Bitmap& bitmap, const std::wstring& text, int x, int y,
                             helper.context());
     }
 
-    Bitmap wholeText;
-    wholeText.resize(width, fontHeight);
     for (unsigned relY = 0; relY < fontHeight; ++relY)
         for (unsigned relX = 0; relX < width; ++relX)
         {
@@ -233,9 +231,9 @@ void Gosu::drawText(Bitmap& bitmap, const std::wstring& text, int x, int y,
 #else
             Color::Channel alpha = Color(buf[relY * width + relX]).alpha();
 #endif
-            wholeText.setPixel(relX, relY, Color(alpha, 0xff, 0xff, 0xff));
+            if (alpha != 0)
+                bitmap.setPixel(x + relX, y + relY, multiply(c, Color(alpha, 0xff, 0xff, 0xff)));
         }
-    bitmap.insert(wholeText, x, y);
 }
 
 #endif

data/GosuImpl/Graphics/TextTouch.mm

@@ -21,17 +21,9 @@ typedef NSFont OSXFont;
 
 namespace
 {
-    // TODO: Merge with InputMac.mm
-    template<typename CFTypeRef>
-    class CFScope : boost::noncopyable
-    {
-        CFTypeRef ref;
-    public:
-        explicit CFScope(CFTypeRef ref) : ref(ref) {}
-        ~CFScope() { CFRelease(ref); }
-        CFTypeRef get() { return ref; }
-    };
-    
+    using Gosu::ObjRef;
+    using Gosu::CFRef;
+
     // If a font is a filename, loads the font and returns its family name that can be used
     // like any system font. Otherwise, just returns the family name.
     std::wstring normalizeFont(const std::wstring& fontName)
@@ -49,32 +41,32 @@ namespace
         if (familyOfFiles.count(fontName) > 0)
             return familyOfFiles[fontName];
         
-        CFScope<CFStringRef> urlString(
+        CFRef<CFStringRef> urlString(
             CFStringCreateWithBytes(NULL,
                 reinterpret_cast<const UInt8*>(fontName.c_str()),
                 fontName.length() * sizeof(wchar_t),
                 kCFStringEncodingUTF32LE, NO));
-        CFScope<CFURLRef> url(
-            CFURLCreateWithFileSystemPath(NULL, urlString.get(),
+        CFRef<CFURLRef> url(
+            CFURLCreateWithFileSystemPath(NULL, urlString.obj(),
                 kCFURLPOSIXPathStyle, YES));
         if (!url.get())
             return familyOfFiles[fontName] = Gosu::defaultFontName();
             
-        CFScope<CFArrayRef> array(
-            CTFontManagerCreateFontDescriptorsFromURL(url.get()));
+        CFRef<CFArrayRef> array(
+            CTFontManagerCreateFontDescriptorsFromURL(url.obj()));
 
-        if (array.get() == NULL || CFArrayGetCount(array.get()) < 1 ||
-            !CTFontManagerRegisterFontsForURL(url.get(),
+        if (array.get() == NULL || CFArrayGetCount(array.obj()) < 1 ||
+            !CTFontManagerRegisterFontsForURL(url.obj(),
                     kCTFontManagerScopeProcess, NULL))
             return familyOfFiles[fontName] = Gosu::defaultFontName();
 
         CTFontDescriptorRef ref =
             (CTFontDescriptorRef)CFArrayGetValueAtIndex(array.get(), 0);
-        CFScope<CFStringRef> fontNameStr(
+        CFRef<CFStringRef> fontNameStr(
             (CFStringRef)CTFontDescriptorCopyAttribute(ref, kCTFontFamilyNameAttribute));
                 
         const char* utf8FontName =
-            [(NSString*)fontNameStr.get() cStringUsingEncoding: NSUTF8StringEncoding];
+            [(NSString*)fontNameStr.obj() cStringUsingEncoding: NSUTF8StringEncoding];
         return familyOfFiles[fontName] = Gosu::utf8ToWstring(utf8FontName);
         #endif
     }
@@ -88,7 +80,7 @@ namespace
         OSXFont* result = usedFonts[make_pair(fontName, make_pair(fontFlags, height))];
         if (!result)
         {
-            Gosu::ObjRef<NSString> name([[NSString alloc] initWithUTF8String: Gosu::wstringToUTF8(fontName).c_str()]);
+            ObjRef<NSString> name([[NSString alloc] initWithUTF8String: Gosu::wstringToUTF8(fontName).c_str()]);
             #ifdef GOSU_IS_IPHONE
             result = [OSXFont fontWithName: name.obj() size: height];
             #else
@@ -184,6 +176,7 @@ void Gosu::drawText(Bitmap& bitmap, const wstring& text, int x, int y,
     // Get the width and height of the image
     Bitmap bmp;
     bmp.resize(width, fontHeight);
+    bmp.insert(bitmap, -x, -y);
     
     // Use a temporary context to draw the CGImage to the buffer.
     CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();

data/GosuImpl/Graphics/TextWin.cpp

@@ -109,10 +109,11 @@ namespace Gosu
                         fontName = customFonts[fontName];
                 }
                 
-                static std::map<std::pair<std::wstring, unsigned>, HFONT> loadedFonts;
+				static std::map<std::pair<std::wstring, unsigned>, HFONT> loadedFonts;
                 
                 HFONT font;
-                std::pair<std::wstring, unsigned> key = std::make_pair(fontName, fontHeight);
+				std::pair<std::wstring, unsigned> key =
+					std::make_pair(fontName, fontHeight | fontFlags << 16);
                 if (loadedFonts.count(key) == 0)
                 {
                     LOGFONT logfont = { fontHeight, 0, 0, 0,
@@ -174,6 +175,8 @@ void Gosu::drawText(Bitmap& bitmap, const std::wstring& text, int x, int y,
         {
             Color pixel = c;
             Color::Channel srcAlpha = GetPixel(helper.context(), relX, relY) & 0xff;
+            if (srcAlpha == 0)
+                continue;
             pixel = multiply(c, Color(srcAlpha, 255, 255, 255));
             if (pixel != 0 && x + relX >= 0 && x + relX < bitmap.width() &&
                 y + relY >= 0 && y + relY < bitmap.height())

data/GosuImpl/Graphics/Texture.cpp

@@ -9,12 +9,17 @@
 #define GL_BGRA 0x80E1
 #endif
 
-// TODO: Not threadsafe.
+// TODO: Move from Texture:: to local namespace and use MAX_TEXTURE_SIZE instead.
 unsigned Gosu::Texture::maxTextureSize()
 {
 #if defined(GOSU_IS_MAC)
     // Includes the iPhone
     return 1024;
+#elif defined(GOSU_IS_UNIX)
+    // Since we cannot get the max. texture size until after context creation, we have to
+    // just be pessimistic about it until Gosu is restructured to create the context
+    // earlier. Otherwise, libGL will segfault left and right.
+    return 512;
 #else
     const static unsigned MIN_SIZE = 256, MAX_SIZE = 1024;
 
@@ -35,7 +40,7 @@ unsigned Gosu::Texture::maxTextureSize()
 #endif
 }
 
-//const unsigned Gosu::MAX_TEXTURE_SIZE = Gosu::Texture::maxTextureSize();
+const unsigned Gosu::MAX_TEXTURE_SIZE = Gosu::Texture::maxTextureSize();
 
 namespace Gosu
 {
@@ -147,18 +152,13 @@ void Gosu::Texture::free(unsigned x, unsigned y)
 
 Gosu::Bitmap Gosu::Texture::toBitmap(unsigned x, unsigned y, unsigned width, unsigned height) const
 {
-#if defined(__BIG_ENDIAN__)
-    unsigned format = GL_RGBA;
-#elif defined(GOSU_IS_IPHONE)
-    unsigned format = GL_RGBA;
+#ifdef GOSU_IS_IPHONE
+    throw std::logic_error("Texture::toBitmap not supported on iOS");
 #else
-    unsigned format = GL_BGRA;
-#endif
-    
     Gosu::Bitmap fullTexture;
     fullTexture.resize(size(), size());
     glBindTexture(GL_TEXTURE_2D, name);
-    glGetTexImage(GL_TEXTURE_2D, 0, format, GL_UNSIGNED_BYTE, fullTexture.data());
+    glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_BYTE, fullTexture.data());
     Gosu::Bitmap bitmap;
     bitmap.resize(width, height);
     bitmap.insert(fullTexture, -int(x), -int(y));
@@ -174,4 +174,5 @@ Gosu::Bitmap Gosu::Texture::toBitmap(unsigned x, unsigned y, unsigned width, uns
 #endif
     
     return bitmap;
+#endif
 }