gosu 0.7.38 → 0.7.39

data/Gosu/Graphics.hpp

@@ -67,8 +67,6 @@ namespace Gosu
         //! Schedules a custom GL functor to be executed at a certain Z level.
         //! The functor is called in a clean GL context (as given by beginGL/endGL).
         //! Gosu's rendering up to the Z level may not yet have been glFlush()ed.
-        //! Note: Unlike normal drawing operations on the same Z level, the order
-        //! of custom GL functors is NOT DEFINED.
         //! Note: You may not call any Gosu rendering functions from within the
         //! functor, and you must schedule it from within Window::draw's call tree.
         void scheduleGL(const std::tr1::function<void()>& functor, ZPos z);
@@ -81,8 +79,11 @@ namespace Gosu
         //! Starts recording a macro. Cannot be nested.
         void beginRecording();
         //! Finishes building the macro and returns it as a drawable object.
+        //! The width and height affect nothing about the recording process,
+        //! the resulting macro will simply return these values when you ask
+        //! it.
         //! Most usually, the return value is passed to Image::Image().
-        std::auto_ptr<Gosu::ImageData> endRecording();
+        std::auto_ptr<Gosu::ImageData> endRecording(int width, int height);
         
         //! Pushes one transformation onto the transformation stack.
         void pushTransform(const Transform& transform);

data/Gosu/Image.hpp

@@ -87,7 +87,7 @@ namespace Gosu
     //! \param tileHeight See tileWidth.
     //! \param appendTo STL container to which the images will be appended.
     //! Must provide a push_back member function; vector<tr1::shared_ptr<Image>>
-    //! or std::tr1::ptr_vector<Image> are good choices.
+    //! or boost::ptr_vector<Image> are good choices.
     template<typename Container>
     void imagesFromTiledBitmap(Graphics& graphics, const std::wstring& filename,
         int tileWidth, int tileHeight, bool tileable, Container& appendTo)
@@ -104,7 +104,7 @@ namespace Gosu
     //! \param tileHeight See tileWidth.
     //! \param appendTo STL container to which the images will be appended.
     //! Must provide a push_back member function; std::vector<std::tr1::shared_ptr<Image>>
-    //! or std::tr1::ptr_vector<Image> are good choices.
+    //! or boost::ptr_vector<Image> are good choices.
     template<typename Container>
     void imagesFromTiledBitmap(Graphics& graphics, const Bitmap& bmp,
         int tileWidth, int tileHeight, bool tileable, Container& appendTo)

data/Gosu/ImageData.hpp

@@ -38,8 +38,8 @@ namespace Gosu
         {
         }
 
-        virtual unsigned width() const = 0;
-        virtual unsigned height() const = 0;
+        virtual int width() const = 0;
+        virtual int height() const = 0;
 
         virtual void draw(double x1, double y1, Color c1,
             double x2, double y2, Color c2,

data/Gosu/Version.hpp

@@ -3,8 +3,8 @@
 
 #define GOSU_MAJOR_VERSION 0
 #define GOSU_MINOR_VERSION 7
-#define GOSU_POINT_VERSION 38
-#define GOSU_VERSION "0.7.38"
+#define GOSU_POINT_VERSION 39
+#define GOSU_VERSION "0.7.39"
 
 #define GOSU_COPYRIGHT_NOTICE \
   " " \

data/GosuImpl/Audio/AudioOpenAL.cpp

@@ -382,7 +382,6 @@ public:
     {
         if (alChannelManagement.get())
         {
-            stop();
             alDeleteBuffers(2, buffers);
         }
     }

data/GosuImpl/Audio/OggFile.hpp

@@ -4,7 +4,6 @@
 #include <GosuImpl/Audio/AudioFile.hpp>
 #include <Gosu/IO.hpp>
 #include <vorbis/vorbisfile.h>
-#include <cassert>
 #include <algorithm>
 #include <stdexcept>
 
@@ -91,14 +90,12 @@ namespace Gosu
                 result = ov_read(&file_, ptr + size, length - size,
                                  OGG_ENDIANNESS, 2 /* 16-bit */,
                                  1 /* signed */, &section);
-                assert(section == 0);
                 if (result > 0)
                     size += result;
+                else if (result < 0)
+                    throw std::runtime_error("error reading vorbis stream");
                 else
-                    if (result < 0)
-                        throw std::runtime_error("error reading vorbis stream");
-                    else
-                        break;
+                    break;
             }
             
             return size;

data/GosuImpl/Graphics/ClipRectStack.hpp

@@ -0,0 +1,88 @@
+#ifndef GOSUIMPL_GRAPHICS_CLIPRECTSTACK_HPP
+#define GOSUIMPL_GRAPHICS_CLIPRECTSTACK_HPP
+
+class Gosu::ClipRectStack
+{
+    std::vector<ClipRect> stack;
+    bool hasEffectiveRect; // is effectiveRect valid?
+    ClipRect effectiveRect;
+    
+    void updateEffectiveRect()
+    {
+        // Nothing to do, no clipping in place.
+        if (stack.empty())
+        {
+            hasEffectiveRect = false;
+            return;
+        }
+        
+        ClipRect result = { 0, 0, 0x7fffffff, 0x7fffffff };
+        for (int i = 0, end = stack.size(); i < end; ++i)
+        {
+            const ClipRect& rect = stack[i];
+            int resultRight = std::min(result.x + result.width, rect.x + rect.width);
+            int resultBottom = std::min(result.y + result.height, rect.y + rect.height);
+            result.x = std::max(result.x, rect.x);
+            result.y = std::max(result.y, rect.y);
+            
+            if (result.x >= resultRight || result.y >= resultBottom)
+            {
+                // We have clipped the world away!
+                hasEffectiveRect = false;
+                return;
+            }
+            
+            result.width = resultRight - result.x;
+            result.height = resultBottom - result.y;
+        }
+        
+        // On the iPhone, we may have to multiple everything by 2 for retina displays.
+        // TODO: This should be handled by a global transform.
+        int fac = clipRectBaseFactor();
+        result.x *= fac, result.y *= fac, result.width *= fac, result.height *= fac;
+        
+        // Normal clipping.
+        effectiveRect = result;
+        hasEffectiveRect = true;
+    }
+    
+public:    
+    ClipRectStack()
+    : hasEffectiveRect(false)
+    {
+    }
+    
+    void beginClipping(int x, int y, int width, int height)
+    {
+        ClipRect rect = { x, y, width, height };
+        stack.push_back(rect);
+        updateEffectiveRect();
+    }
+    
+    void endClipping()
+    {
+        stack.pop_back();
+        updateEffectiveRect();
+    }
+    
+    void swap(ClipRectStack& other)
+    {
+        stack.swap(other.stack); // don't trust ADL :/
+        std::swap(hasEffectiveRect, other.hasEffectiveRect);
+        std::swap(effectiveRect, other.effectiveRect);
+    }
+    
+    const ClipRect* maybeEffectiveRect() const
+    {
+        return hasEffectiveRect ? &effectiveRect : 0;
+    }
+    
+    bool clippedWorldAway() const
+    {
+        // When we have no effective rect but the stack is not empty, we have clipped
+        // the whole world away and don't need to render things.
+        return !hasEffectiveRect && !stack.empty();
+    }
+};
+
+#endif

data/GosuImpl/Graphics/Common.hpp

@@ -24,19 +24,54 @@
 #include <list>
 #include <vector>
 
+namespace Gosu
+{
+    struct RenderState;
+    class RenderStateManager;
+
+    const GLuint NO_TEXTURE = static_cast<GLuint>(-1);
+    const unsigned NO_CLIPPING = 0xffffffff;
+    
+    // In various places in Gosu, width==NO_CLIPPING conventionally means
+    // that no clipping should happen.
+    struct ClipRect
+    {
+        int x, y, width, height;
+        
+        bool operator==(const ClipRect& other) const
+        {
+            // No clipping
+            return (width == NO_CLIPPING && other.width == NO_CLIPPING) ||
+            // Clipping, but same
+                (x == other.x && y == other.y && width == other.width && height == other.height);
+        }
+    };
+}
+
+#include <GosuImpl/Graphics/RenderState.hpp>
+
 namespace Gosu
 {
     class Texture;
     class TexChunk;
-    class RenderState;
+    class ClipRectStack;
     struct DrawOp;
     class DrawOpQueue;
     typedef std::list<Transform> Transforms;
     typedef std::vector<DrawOpQueue> DrawOpQueueStack;
     class Macro;
-    
-    const GLuint NO_TEXTURE = static_cast<GLuint>(-1);
-    const unsigned NO_CLIPPING = 0xffffffff;
+    struct ArrayVertex
+    {
+        GLfloat texCoords[2];
+        GLuint color;
+        GLfloat vertices[3];
+    };
+    struct VertexArray
+    {
+        RenderState renderState;
+        std::vector<ArrayVertex> vertices;
+    };
+    typedef std::list<VertexArray> VertexArrays;
     
     template<typename T>
     bool isPToTheLeftOfAB(T xa, T ya,

data/GosuImpl/Graphics/DrawOp.hpp

@@ -5,26 +5,20 @@
 #include <Gosu/Color.hpp>
 #include <GosuImpl/Graphics/Common.hpp>
 #include <GosuImpl/Graphics/TexChunk.hpp>
-#include <GosuImpl/Graphics/RenderState.hpp>
+#include <cassert>
 
 namespace Gosu
 {
-    struct ArrayVertex
-    {
-        float texCoords[2];
-        unsigned color;
-        float vertices[3];
-    };
-    typedef std::vector<ArrayVertex> VertexArray;
-    
     struct DrawOp
     {
+        // For sorting before drawing the queue.
         ZPos z;
-                
-        Gosu::Transform* transform;
-        int clipX, clipY;
-        unsigned clipWidth, clipHeight;
         
+        RenderState renderState;
+        // Only valid if renderState.texName != NO_TEXTURE
+        GLfloat top, left, bottom, right;
+        
+        // TODO: Merge with Gosu::ArrayVertex.
         struct Vertex
         {
             float x, y;
@@ -32,19 +26,17 @@ namespace Gosu
             Vertex() {}
             Vertex(float x, float y, Color c) : x(x), y(y), c(c) {}
         };
-        
         Vertex vertices[4];
-        unsigned usedVertices;
-        const TexChunk* chunk;
-        AlphaMode mode;
         
-        DrawOp(Gosu::Transform& transform)
-        :   transform(&transform), clipWidth(NO_CLIPPING), chunk(0)
-        {
-        }
+        // Number of vertices used, or: complement index of code block
+        int verticesOrBlockIndex;
         
-        void perform(RenderState& current, const DrawOp* next) const
+        void perform(const DrawOp* next) const
         {
+            // This should not be called on GL code ops.
+            assert (verticesOrBlockIndex >= 2);
+            assert (verticesOrBlockIndex <= 4);
+            
             #ifdef GOSU_IS_IPHONE
             static const unsigned MAX_AUTOGROUP = 24;
             
@@ -70,17 +62,9 @@ namespace Gosu
             }
             #endif
             
-            current.setClipRect(clipX, clipY, clipWidth, clipHeight);
-            current.setTransform(transform);
-            current.setAlphaMode(mode);
-            
-            if (chunk)
+            #ifdef GOSU_IS_IPHONE
+            if (renderState.texName != NO_TEXTURE)
             {
-                current.setTexName(chunk->texName());
-                
-                #ifdef GOSU_IS_IPHONE
-                float left, top, right, bottom;
-                chunk->getCoords(left, top, right, bottom);
                 spriteTexcoords[spriteCounter*12 + 0] = left;
                 spriteTexcoords[spriteCounter*12 + 1] = top;
                 spriteTexcoords[spriteCounter*12 + 2] = right;
@@ -94,27 +78,21 @@ namespace Gosu
                 spriteTexcoords[spriteCounter*12 + 9] = bottom;
                 spriteTexcoords[spriteCounter*12 + 10] = right;
                 spriteTexcoords[spriteCounter*12 + 11] = bottom;
-                #endif
             }
-            else
-                current.setTexName(NO_TEXTURE);
-
+            #endif
+            
             #ifndef GOSU_IS_IPHONE
-            if (usedVertices == 2)
+            if (verticesOrBlockIndex == 2)
                 glBegin(GL_LINES);
-            else if (usedVertices == 3)
+            else if (verticesOrBlockIndex == 3)
                 glBegin(GL_TRIANGLES);
-            else if (usedVertices == 4)
+            else // if (verticesOrBlockIndex == 4)
                 glBegin(GL_QUADS);
-
-            float left, top, right, bottom;
-            if (chunk)
-                chunk->getCoords(left, top, right, bottom);
             
-            for (unsigned i = 0; i < usedVertices; i++)
+            for (unsigned i = 0; i < verticesOrBlockIndex; i++)
             {
                 glColor4ubv(reinterpret_cast<const GLubyte*>(&vertices[i].c));
-                if (chunk)
+                if (renderState.texName != NO_TEXTURE)
                     switch (i)
                     {
                     case 0:
@@ -149,10 +127,7 @@ namespace Gosu
             }
             
             ++spriteCounter;
-            if (spriteCounter == MAX_AUTOGROUP or next == 0 or
-                chunk == 0 or next->chunk == 0 or next->transform != transform or
-                next->chunk->texName() != chunk->texName() or next->mode != mode or
-                clipWidth != NO_CLIPPING or next->clipWidth != NO_CLIPPING)
+            if (spriteCounter == MAX_AUTOGROUP || next == 0 || !(next->renderState == renderState))
             {
                 glDrawArrays(GL_TRIANGLES, 0, 6 * spriteCounter);
                 //if (spriteCounter > 1)
@@ -162,10 +137,15 @@ namespace Gosu
             #endif
         }
         
-        void compileTo(VertexArray& va) const
+        void compileTo(VertexArrays& vas) const
         {
-            ArrayVertex result[4];
+            if (vas.empty() || !(vas.back().renderState == renderState))
+            {
+                vas.push_back(VertexArray());
+                vas.back().renderState = renderState;
+            }
             
+            ArrayVertex result[4];
             for (int i = 0; i < 4; ++i)
             {
                 result[i].vertices[0] = vertices[i].x;
@@ -173,15 +153,12 @@ namespace Gosu
                 result[i].vertices[2] = 0;
                 result[i].color = vertices[i].c.abgr();
             }
-
-            float left, top, right, bottom;
-            chunk->getCoords(left, top, right, bottom);
-            result[0].texCoords[0] = left,  result[0].texCoords[1] = top;
+            result[0].texCoords[0] = left, result[0].texCoords[1] = top;
             result[1].texCoords[0] = right, result[1].texCoords[1] = top;
             result[2].texCoords[0] = right, result[2].texCoords[1] = bottom;
-            result[3].texCoords[0] = left,  result[3].texCoords[1] = bottom;
-
-            va.insert(va.end(), result, result + 4);
+            result[3].texCoords[0] = left, result[3].texCoords[1] = bottom;
+            
+            vas.back().vertices.insert(vas.back().vertices.end(), result, result + 4);
         }
         
         bool operator<(const DrawOp& other) const

data/GosuImpl/Graphics/DrawOpQueue.hpp

@@ -3,6 +3,7 @@
 
 #include <Gosu/TR1.hpp>
 #include <GosuImpl/Graphics/Common.hpp>
+#include <GosuImpl/Graphics/ClipRectStack.hpp>
 #include <GosuImpl/Graphics/DrawOp.hpp>
 #include <cassert>
 #include <algorithm>
@@ -11,184 +12,120 @@
 
 class Gosu::DrawOpQueue
 {
+    ClipRectStack clipRectStack;
+    
     typedef std::vector<DrawOp> DrawOps;
     DrawOps ops;
-    typedef std::multimap<ZPos, std::tr1::function<void()> > CodeMap;
-    CodeMap code;
-
-    struct ClipRect
-    {
-        int x, y;
-        unsigned width, height;
-    };
-    std::vector<ClipRect> clipRectStack;
-    ClipRect effectiveRect;
-    bool haveEffectiveRect; // is effectiveRect valid?
+    typedef std::vector<std::tr1::function<void()> > GLBlocks;
+    GLBlocks glBlocks;
     
-    void updateEffectiveRect()
-    {
-        if (clipRectStack.empty())
-        {
-            haveEffectiveRect = false;
-            return;
-        }
-        
-        ClipRect result = { 0, 0, 0x7fffffff, 0x7fffffff };
-        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);
-            result.y = std::max<int>(result.y, rect.y);
-            
-            if (result.x >= right || result.y >= bottom)
-            {
-                haveEffectiveRect = false;
-                return;
-            }
-            
-            result.width = right - result.x;
-            result.height = bottom - result.y;
-        }
-        
-        int fac = clipRectBaseFactor();
-        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);
+        glBlocks.swap(other.glBlocks);
     }
     
-    void scheduleDrawOp(DrawOp op, ZPos z)
+    void scheduleDrawOp(DrawOp op)
     {
+        if (clipRectStack.clippedWorldAway())
+            return;
+        
         #ifdef GOSU_IS_IPHONE
         // No triangles, no lines supported
-        assert (op.usedVertices == 4);
+        assert (op.verticesOrBlockIndex == 4);
         #endif
         
-        if (haveEffectiveRect)
-        {
-            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
-            // the whole world away and don't need to render things.
-            return;
-        
-        op.z = z;
+        if (const ClipRect* cr = clipRectStack.maybeEffectiveRect())
+            op.renderState.clipRect = *cr;
         ops.push_back(op);
     }
     
-    void scheduleGL(std::tr1::function<void()> customCode, ZPos z)
+    void scheduleGL(Transform& transform, std::tr1::function<void()> glBlock, ZPos z)
     {
-        code.insert(std::make_pair(z, customCode));
+        // TODO: Document this case: Clipped-away GL blocks are *not* being run.
+        if (clipRectStack.clippedWorldAway())
+            return;
+        
+        int complementOfBlockIndex = ~(int)glBlocks.size();
+        glBlocks.push_back(glBlock);
+        
+        DrawOp op;
+        op.renderState.transform = &transform;
+        op.verticesOrBlockIndex = complementOfBlockIndex;
+        if (const ClipRect* cr = clipRectStack.maybeEffectiveRect())
+            op.renderState.clipRect = *cr;
+        op.z = z;
+        ops.push_back(op);
     }
     
-    void beginClipping(int x, int y, unsigned width, unsigned height)
+    void beginClipping(int x, int y, int width, int height)
     {
-        ClipRect rect = { x, y, width, height };
-        clipRectStack.push_back(rect);
-        updateEffectiveRect();
+        clipRectStack.beginClipping(x, y, width, height);
     }
     
     void endClipping()
     {
-        clipRectStack.pop_back();
-        updateEffectiveRect();
+        clipRectStack.endClipping();
     }
 
     void performDrawOpsAndCode()
     {
-        // Allows us to make some assumptions.
-        if (ops.empty())
-        {
-            for (CodeMap::iterator it = code.begin(), end = code.end(); it != end; ++it)
-                it->second();
-            return;
-        }
-        
         // Apply Z-Ordering.
         std::stable_sort(ops.begin(), ops.end());
         
-        // We will loop: Drawing DrawOps, execute custom code.
-        // This means if there is no code, we just draw one batch
-        // of DrawOps, so no performance is sacrified.
-        DrawOps::const_iterator current = ops.begin(), last = ops.begin();
-        CodeMap::const_iterator it = code.begin();
+        RenderStateManager manager;
+        #ifdef GOSU_IS_IPHONE
+        if (ops.empty())
+            return;
         
-        while (true)
+        DrawOps::const_iterator current = ops.begin(), last = ops.end() - 1;
+        for (; current != last; ++current)
         {
-            if (it == code.end())
-                // Last or only batch of DrawOps:
-                // Just draw everything.
-                last = ops.end() - 1;
-            else
-            {
-                // There is code waiting:
-                // Only draw up to this Z level.
-                while (last != ops.end() - 1 && (last + 1)->z < it->first)
-                    ++last;
-            }
-            
-            if (current <= last)
+            manager.setRenderState(current->renderState);
+            current->perform(&*(current + 1));
+        }
+        manager.setRenderState(last->renderState);
+        last->perform(0);
+        #else
+        for (DrawOps::const_iterator current = ops.begin(), last = ops.end();
+            current != last; ++current)
+        {
+            manager.setRenderState(current->renderState);
+            if (current->verticesOrBlockIndex >= 0)
             {
-                // Draw DrawOps until next code is due
-                RenderState renderState;
-                while (current < last)
-                {
-                    DrawOps::const_iterator next = current + 1;
-                    current->perform(renderState, &*next);
-                    current = next;
-                }
-                last->perform(renderState, 0);
-                ++current;
+                // Normal DrawOp, no GL code
+                current->perform(0); // next unused on desktop
             }
-            
-            // Draw next code, or break if there is none
-            if (it == code.end())
-                break;
             else
             {
-                it->second();
-                ++it;
+                // GL code
+                int blockIndex = ~current->verticesOrBlockIndex;
+                assert (blockIndex >= 0);
+                assert (blockIndex < glBlocks.size());
+                glBlocks[blockIndex]();
+                manager.enforceAfterUntrustedGL();
             }
         }
+        #endif
     }
     
     void clear()
     {
-        // Not sure if Graphics::begin() should implicitly do that.
-        //clipRectStack.clear();
-        //effectiveRect.reset();
-        code.clear();
+        glBlocks.clear();
         ops.clear();
     }
     
-    void compileTo(VertexArray& va)
+    void compileTo(VertexArrays& vas)
     {
-        if (!code.empty())
+        if (!glBlocks.empty())
             throw std::logic_error("Custom code cannot be recorded into a macro");
         
-        va.reserve(ops.size());
         std::stable_sort(ops.begin(), ops.end());
         for (DrawOps::const_iterator op = ops.begin(), end = ops.end(); op != end; ++op)
-            op->compileTo(va);
+            op->compileTo(vas);
     }
 };