gosu 0.7.22 → 0.7.23

data/GosuImpl/Graphics/Common.hpp

@@ -6,7 +6,9 @@
 #include <Gosu/Platform.hpp>
 
 #if defined(GOSU_IS_WIN)
+#ifndef NOMINMAX
 #define NOMINMAX
+#endif
 #include <windows.h>
 #include <GL/gl.h>
 #elif defined(GOSU_IS_IPHONE)
@@ -26,19 +28,23 @@ namespace Gosu
 {
     class Texture;
     class TexChunk;
+    class RenderState;
     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;
+    
     template<typename T>
     bool isPToTheLeftOfAB(T xa, T ya,
         T xb, T yb, T xp, T yp)
     {
         return (xb - xa) * (yp - ya) - (xp - xa) * (yb - ya) > 0;
     }
-        
+    
     template<typename T, typename C>
     void reorderCoordinatesIfNecessary(T& x1, T& y1,
         T& x2, T& y2, T& x3, T& y3, C& c3, T& x4, T& y4, C& c4)
@@ -62,6 +68,17 @@ namespace Gosu
         return result;
     }
     
+    inline void applyTransform(const Transform& transform, double& x, double& y)
+    {
+        double in[4] = { x, y, 0, 1 };
+        double out[4] = { 0, 0, 0, 0 };
+        for (int i = 0; i < 4; ++i)
+            for (int j = 0; j < 4; ++j)
+                out[i] += in[j] * transform[j * 4 + i];
+        x = out[0] / out[3];
+        y = out[1] / out[3];
+    }
+    
     inline void multiplyBitmapAlpha(Bitmap& bmp, Color::Channel alpha)
     {
         for (int y = 0; y < bmp.height(); ++y)
@@ -73,6 +90,13 @@ namespace Gosu
             }
     }
     
+    #ifdef GOSU_IS_IPHONE
+    int clipRectBaseFactor();
+    #else
+    inline int clipRectBaseFactor() { return 1; }
+    #endif
+    
+    bool isEntity(const std::wstring& name);
     const Bitmap& entityBitmap(const std::wstring& name);
 }
 

data/GosuImpl/Graphics/DrawOp.hpp

@@ -5,15 +5,11 @@
 #include <Gosu/Color.hpp>
 #include <GosuImpl/Graphics/Common.hpp>
 #include <GosuImpl/Graphics/TexChunk.hpp>
-#include <boost/bind.hpp>
+#include <GosuImpl/Graphics/RenderState.hpp>
 #include <boost/cstdint.hpp>
-#include <algorithm>
-#include <set>
 
 namespace Gosu
 {
-    const GLuint NO_TEXTURE = static_cast<GLuint>(-1);
-
     struct ArrayVertex
     {
         GLfloat texCoords[2];
@@ -42,90 +38,15 @@ namespace Gosu
         const TexChunk* chunk;
         AlphaMode mode;
 
-        DrawOp(Gosu::Transform& transform) : transform(&transform) { clipWidth = 0xffffffff; usedVertices = 0; chunk = 0; }
-        
-#ifndef GOSU_IS_IPHONE
-        void perform(GLuint& currentTexName, Transform*& currentTransform, const void*) const
+        DrawOp(Gosu::Transform& transform)
+        :   transform(&transform), clipWidth(NO_CLIPPING),
+            usedVertices(0), chunk(0)
         {
-            if (clipWidth != 0xffffffff)
-            {
-                glEnable(GL_SCISSOR_TEST);
-                glScissor(clipX, clipY, clipWidth, clipHeight);
-            }
-            
-            if (transform != currentTransform) {
-                glPopMatrix();
-                glPushMatrix();
-                glMultMatrixd(transform->data());
-                currentTransform = transform;
-            }
-            
-            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);
-
-            if (chunk)
-            {
-                if (currentTexName == NO_TEXTURE)
-                    glEnable(GL_TEXTURE_2D);
-                if (chunk->texName() != currentTexName)
-                    glBindTexture(GL_TEXTURE_2D, chunk->texName());
-                currentTexName = chunk->texName();
-            }
-            else if (currentTexName != NO_TEXTURE)
-            {
-                glDisable(GL_TEXTURE_2D);
-                currentTexName = NO_TEXTURE;
-            }
-
-            if (usedVertices == 2)
-                glBegin(GL_LINES);
-            else if (usedVertices == 3)
-                glBegin(GL_TRIANGLES);
-            else if (usedVertices == 4)
-                glBegin(GL_QUADS);
-
-            double left, top, right, bottom;
-            if (chunk)
-                chunk->getCoords(left, top, right, bottom);
-            
-            for (unsigned i = 0; i < usedVertices; i++)
-            {
-                glColor4f(vertices[i].c.red() / 255.0, vertices[i].c.green() / 255.0,
-                          vertices[i].c.blue() / 255.0, vertices[i].c.alpha() / 255.0);
-                if (chunk)
-                    switch (i)
-                    {
-                    case 0:
-                        glTexCoord2d(left, top);
-                        break;
-                    case 1:
-                        glTexCoord2d(right, top);
-                        break;
-                    case 2:
-                        glTexCoord2d(right, bottom);
-                        break;
-                    case 3:
-                        glTexCoord2d(left, bottom);
-                        break;
-                    }
-                glVertex2d(vertices[i].x, vertices[i].y);
-            }
-            
-            glEnd();
-            
-            if (clipWidth != 0xffffffff)
-                glDisable(GL_SCISSOR_TEST);
         }
-#else
-        void perform(unsigned& currentTexName, Transform*& currentTransform, const DrawOp* next) const
+        
+        void perform(RenderState& current, const DrawOp* next) const
         {
-            if (usedVertices != 4)
-                return; // No triangles, no lines on iPhone
-            
+            #ifdef GOSU_IS_IPHONE
             static const unsigned MAX_AUTOGROUP = 24;
             
             static int spriteCounter = 0;
@@ -147,36 +68,17 @@ namespace Gosu
                 
                 isSetup = true;
             }
+            #endif
             
-            if (transform != currentTransform) {
-                glPopMatrix();
-                glPushMatrix();
-                glMultMatrixd(transform->data());
-                currentTransform = transform;
-            }
-            
-            if (clipWidth != 0xffffffff)
-            {
-                glEnable(GL_SCISSOR_TEST);
-                glScissor(clipX, clipY, clipWidth, clipHeight);
-            }
-            
-            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);
+            current.setClipRect(clipX, clipY, clipWidth, clipHeight);
+            current.setTransform(transform);
+            current.setAlphaMode(mode);
             
             if (chunk)
             {
-                if (currentTexName == NO_TEXTURE)
-                    glEnable(GL_TEXTURE_2D);
-                if (chunk->texName() != currentTexName)
-                {
-                    glBindTexture(GL_TEXTURE_2D, chunk->texName());
-                }
+                current.setTexName(chunk->texName());
                 
+                #ifdef GOSU_IS_IPHONE
                 double left, top, right, bottom;
                 chunk->getCoords(left, top, right, bottom);
                 spriteTexcoords[spriteCounter*12 + 0] = left;
@@ -192,15 +94,48 @@ namespace Gosu
                 spriteTexcoords[spriteCounter*12 + 9] = bottom;
                 spriteTexcoords[spriteCounter*12 + 10] = right;
                 spriteTexcoords[spriteCounter*12 + 11] = bottom;
-                
-                currentTexName = chunk->texName();
+                #endif
             }
-            else if (currentTexName != NO_TEXTURE)
+            else
+                current.setTexName(NO_TEXTURE);
+
+            #ifndef GOSU_IS_IPHONE
+            if (usedVertices == 2)
+                glBegin(GL_LINES);
+            else if (usedVertices == 3)
+                glBegin(GL_TRIANGLES);
+            else if (usedVertices == 4)
+                glBegin(GL_QUADS);
+
+            double left, top, right, bottom;
+            if (chunk)
+                chunk->getCoords(left, top, right, bottom);
+            
+            for (unsigned i = 0; i < usedVertices; i++)
             {
-                glDisable(GL_TEXTURE_2D);
-                currentTexName = NO_TEXTURE;
+                glColor4f(vertices[i].c.red() / 255.0, vertices[i].c.green() / 255.0,
+                          vertices[i].c.blue() / 255.0, vertices[i].c.alpha() / 255.0);
+                if (chunk)
+                    switch (i)
+                    {
+                    case 0:
+                        glTexCoord2d(left, top);
+                        break;
+                    case 1:
+                        glTexCoord2d(right, top);
+                        break;
+                    case 2:
+                        glTexCoord2d(right, bottom);
+                        break;
+                    case 3:
+                        glTexCoord2d(left, bottom);
+                        break;
+                    }
+                glVertex2d(vertices[i].x, vertices[i].y);
             }
             
+            glEnd();
+            #else
             for (int i = 0; i < 3; ++i)
             {
                 spriteVertices[spriteCounter*12 + i*2] = vertices[i].x;
@@ -216,26 +151,18 @@ namespace Gosu
             
             ++spriteCounter;
             if (spriteCounter == MAX_AUTOGROUP or next == 0 or
-                chunk == 0 or next->chunk == 0 or 
+                chunk == 0 or next->chunk == 0 or next->transform != transform or
                 next->chunk->texName() != chunk->texName() or next->mode != mode or
-                clipWidth != 0xffffffff or next->clipWidth != 0xffffffff)
+                clipWidth != NO_CLIPPING or next->clipWidth != NO_CLIPPING)
             {
                 glDrawArrays(GL_TRIANGLES, 0, 6 * spriteCounter);
                 //if (spriteCounter > 1)
                 //    printf("grouped %d quads\n", spriteCounter);
                 spriteCounter = 0;
             }
-            
-            if (clipWidth != 0xffffffff)
-                glDisable(GL_SCISSOR_TEST);
+            #endif
         }
         
-        unsigned texName() const
-        {
-            return chunk ? chunk->texName() : NO_TEXTURE;
-        }
-#endif
-        
         void compileTo(VertexArray& va) const
         {
             ArrayVertex result[4];
@@ -263,101 +190,6 @@ namespace Gosu
             return z < other.z;
         }
     };
-
-    class DrawOpQueue
-    {
-        int clipX, clipY;
-        unsigned clipWidth, clipHeight;
-        std::multiset<DrawOp> set;
-
-    public:
-        DrawOpQueue()
-        : clipWidth(0xffffffff)
-        {
-        }
-        
-        void swap(DrawOpQueue& other)
-        {
-            std::swap(clipX, other.clipX);
-            std::swap(clipY, other.clipY);
-            std::swap(clipWidth, other.clipWidth);
-            std::swap(clipHeight, other.clipHeight);
-            set.swap(other.set);
-        }
-        
-        void addDrawOp(DrawOp op, ZPos z)
-        {
-            if (clipWidth != 0xffffffff)
-            {
-                op.clipX = clipX;
-                op.clipY = clipY;
-                op.clipWidth = clipWidth;
-                op.clipHeight = clipHeight;
-            }
-            
-            if (z == zImmediate)
-            {
-                GLuint currentTexName = NO_TEXTURE;
-                Transform* currentTransform = 0;
-                glMatrixMode(GL_MODELVIEW);
-                glPushMatrix();
-                op.perform(currentTexName, currentTransform, 0);
-                glPopMatrix();
-                if (currentTexName != NO_TEXTURE)
-                    glDisable(GL_TEXTURE_2D);
-            }
-            
-            op.z = z;
-            set.insert(op);
-        }
-        
-        void beginClipping(int x, int y, unsigned width, unsigned height)
-        {
-            clipX = x;
-            clipY = y;
-            clipWidth = width;
-            clipHeight = height;
-        }
-        
-        void endClipping()
-        {
-            clipWidth = 0xffffffff;
-        }
-
-        void performDrawOps() const
-        {
-            GLuint currentTexName = NO_TEXTURE;
-            Transform* currentTransform = 0;
-            
-            glMatrixMode(GL_MODELVIEW);
-            glPushMatrix();
-            
-            std::multiset<DrawOp>::const_iterator last, cur = set.begin(), end = set.end();
-            while (cur != end)
-            {
-                last = cur;
-                ++cur;
-                last->perform(currentTexName, currentTransform, cur == end ? 0 : &*cur);
-            }
-            
-            glPopMatrix();
-            
-            if (currentTexName != NO_TEXTURE)
-                glDisable(GL_TEXTURE_2D);
-        }
-        
-        void clear()
-        {
-            set.clear();
-        }
-        
-        void compileTo(VertexArray& va) const
-        {
-            va.resize(set.size());
-            std::for_each(set.begin(), set.end(),
-                          boost::bind(&DrawOp::compileTo, _1, boost::ref(va)));
-        }
-    };
 }
 
 #endif

data/GosuImpl/Graphics/DrawOpQueue.hpp

@@ -0,0 +1,127 @@
+#ifndef GOSUIMPL_GRAPHICS_DRAWOPQUEUE_HPP
+#define GOSUIMPL_GRAPHICS_DRAWOPQUEUE_HPP
+
+#include <GosuImpl/Graphics/Common.hpp>
+#include <GosuImpl/Graphics/DrawOp.hpp>
+#include <boost/foreach.hpp>
+#include <boost/optional.hpp>
+#include <algorithm>
+#include <set>
+#include <vector>
+
+class Gosu::DrawOpQueue
+{
+    std::multiset<DrawOp> set;
+
+    struct ClipRect
+    {
+        int x, y;
+        unsigned width, height;
+    };
+    std::vector<ClipRect> clipRectStack;
+    boost::optional<ClipRect> effectiveRect;
+    void updateEffectiveRect()
+    {
+        if (clipRectStack.empty())
+            return effectiveRect.reset();
+
+        ClipRect result = { 0, 0, 0x7fffffff, 0x7fffffff };
+        BOOST_FOREACH (const ClipRect& rect, clipRectStack)
+        {
+            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)
+            {
+                effectiveRect.reset();
+                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;
+    }
+
+public:
+    // I really wish I would trust ADL. :|
+    void swap(DrawOpQueue& other)
+    {
+        clipRectStack.swap(other.clipRectStack);
+        std::swap(effectiveRect, other.effectiveRect);
+        set.swap(other.set);
+    }
+    
+    void addDrawOp(DrawOp op, ZPos z)
+    {
+        #ifdef GOSU_IS_IPHONE
+        // No triangles, no lines supported
+        assert(op.usedVertices == 4);
+        #endif
+        
+        if (effectiveRect)
+        {
+            const ClipRect& rect = *effectiveRect;
+            op.clipX = rect.x;
+            op.clipY = rect.y;
+            op.clipWidth = rect.width;
+            op.clipHeight = rect.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;
+        set.insert(op);
+    }
+    
+    void beginClipping(int x, int y, unsigned width, unsigned height)
+    {
+        ClipRect rect = { x, y, width, height };
+        clipRectStack.push_back(rect);
+        updateEffectiveRect();
+    }
+    
+    void endClipping()
+    {
+        clipRectStack.pop_back();
+        updateEffectiveRect();
+    }
+
+    void performDrawOps() const
+    {
+        RenderState current;
+        
+        std::multiset<DrawOp>::const_iterator last, cur = set.begin(), end = set.end();
+        while (cur != end)
+        {
+            last = cur;
+            ++cur;
+            last->perform(current, cur == end ? 0 : &*cur);
+        }
+    }
+    
+    void clear()
+    {
+        // Not sure if Graphics::begin() should implicitly do that.
+        //clipRectStack.clear();
+        //effectiveRect.reset();
+        set.clear();
+    }
+    
+    void compileTo(VertexArray& va) const
+    {
+        va.reserve(set.size());
+        BOOST_FOREACH (const DrawOp& op, set)
+            op.compileTo(va);
+    }
+};
+
+#endif