gosu 0.7.38 → 0.7.39

data/GosuImpl/Graphics/GosuView.mm

@@ -67,7 +67,7 @@ int Gosu::clipRectBaseFactor()
         CAEAGLLayer *eaglLayer = (CAEAGLLayer *)self.layer;
         
         eaglLayer.opaque = YES;
-        /*eaglLayer.drawableProperties = [NSDictionary new]; /*dictionaryWithObjectsAndKeys:
+        /*eaglLayer.drawableProperties = dictionaryWithObjectsAndKeys:
                                         [NSNumber numberWithBool:NO], kEAGLDrawablePropertyRetainedBacking,
                                         kEAGLColorFormatRGBA8, kEAGLDrawablePropertyColorFormat, nil];*/
         

data/GosuImpl/Graphics/Graphics.cpp

@@ -83,7 +83,9 @@ Gosu::Graphics::Graphics(unsigned physWidth, unsigned physHeight, bool fullscree
     std::swap(pimpl->virtWidth, pimpl->virtHeight);
     #endif
     pimpl->fullscreen = fullscreen;
-
+    
+    // Should be merged into RenderState altogether.
+    
     glMatrixMode(GL_PROJECTION);
     glLoadIdentity();
     glViewport(0, 0, physWidth, physHeight);
@@ -252,14 +254,14 @@ namespace
 
 void Gosu::Graphics::scheduleGL(const std::tr1::function<void()>& functor, Gosu::ZPos z)
 {
-    pimpl->queues.back().scheduleGL(RunGLFunctor(*this, functor), z);
+    pimpl->queues.back().scheduleGL(pimpl->absoluteTransforms.back(), RunGLFunctor(*this, functor), z);
 }
 #endif
 
 void Gosu::Graphics::beginClipping(double x, double y, double width, double height)
 {
     if (pimpl->queues.size() > 1)
-        throw std::logic_error("Clipping not allowed while creating a macro");
+        throw std::logic_error("Clipping not allowed while creating a macro yet");
     
     // Apply current transformation.
     
@@ -293,12 +295,12 @@ void Gosu::Graphics::beginRecording()
     pimpl->queues.resize(pimpl->queues.size() + 1);
 }
 
-std::auto_ptr<Gosu::ImageData> Gosu::Graphics::endRecording()
+std::auto_ptr<Gosu::ImageData> Gosu::Graphics::endRecording(int width, int height)
 {
     if (pimpl->queues.size() == 1)
         throw std::logic_error("No macro recording in progress that can be captured");
     
-    std::auto_ptr<ImageData> result(new Macro(*this, pimpl->queues.back()));
+    std::auto_ptr<ImageData> result(new Macro(*this, pimpl->queues.back(), width, height));
     pimpl->queues.pop_back();
     return result;
 }
@@ -318,6 +320,9 @@ namespace
 
 void Gosu::Graphics::pushTransform(const Gosu::Transform& transform)
 {
+    if (pimpl->queues.size() > 1)
+        throw std::logic_error("Transforms not allowed while creating a macro yet");
+    
     pimpl->currentTransforms.push_back(transform);
     Transform result = multiply(transform, pimpl->absoluteTransforms.back());
     ensureBackOfList(pimpl->absoluteTransforms, result);
@@ -339,14 +344,14 @@ void Gosu::Graphics::drawLine(double x1, double y1, Color c1,
     double x2, double y2, Color c2,
     ZPos z, AlphaMode mode)
 {
-    DrawOp op(pimpl->absoluteTransforms.back());
-    
-    op.mode = mode;
-    op.usedVertices = 2;
+    DrawOp op;
+    op.renderState.transform = &pimpl->absoluteTransforms.back();
+    op.renderState.mode = mode;
+    op.verticesOrBlockIndex = 2;
     op.vertices[0] = DrawOp::Vertex(x1, y1, c1);
     op.vertices[1] = DrawOp::Vertex(x2, y2, c2);
-
-    pimpl->queues.back().scheduleDrawOp(op, z);
+    op.z = z;
+    pimpl->queues.back().scheduleDrawOp(op);
 }
 
 void Gosu::Graphics::drawTriangle(double x1, double y1, Color c1,
@@ -354,19 +359,19 @@ void Gosu::Graphics::drawTriangle(double x1, double y1, Color c1,
     double x3, double y3, Color c3,
     ZPos z, AlphaMode mode)
 {
-    DrawOp op(pimpl->absoluteTransforms.back());
-        
-    op.mode = mode;
-    op.usedVertices = 3;
+    DrawOp op;
+    op.renderState.transform = &pimpl->absoluteTransforms.back();
+    op.renderState.mode = mode;
+    op.verticesOrBlockIndex = 3;
     op.vertices[0] = DrawOp::Vertex(x1, y1, c1);
     op.vertices[1] = DrawOp::Vertex(x2, y2, c2);
     op.vertices[2] = DrawOp::Vertex(x3, y3, c3);
 #ifdef GOSU_IS_IPHONE
-    op.usedVertices = 4;
+    op.verticesOrBlockIndex = 4;
     op.vertices[3] = op.vertices[2];
 #endif
-    
-    pimpl->queues.back().scheduleDrawOp(op, z);
+    op.z = z;
+    pimpl->queues.back().scheduleDrawOp(op);
 }
 
 void Gosu::Graphics::drawQuad(double x1, double y1, Color c1,
@@ -377,10 +382,10 @@ void Gosu::Graphics::drawQuad(double x1, double y1, Color c1,
 {
     reorderCoordinatesIfNecessary(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4);
 
-    DrawOp op(pimpl->absoluteTransforms.back());
-    
-    op.mode = mode;
-    op.usedVertices = 4;
+    DrawOp op;
+    op.renderState.transform = &pimpl->absoluteTransforms.back();
+    op.renderState.mode = mode;
+    op.verticesOrBlockIndex = 4;
     op.vertices[0] = DrawOp::Vertex(x1, y1, c1);
     op.vertices[1] = DrawOp::Vertex(x2, y2, c2);
 // TODO: Should be harmonized
@@ -391,8 +396,8 @@ void Gosu::Graphics::drawQuad(double x1, double y1, Color c1,
     op.vertices[3] = DrawOp::Vertex(x3, y3, c3);
     op.vertices[2] = DrawOp::Vertex(x4, y4, c4);
 #endif
-
-    pimpl->queues.back().scheduleDrawOp(op, z);
+    op.z = z;
+    pimpl->queues.back().scheduleDrawOp(op);
 }
 
 std::auto_ptr<Gosu::ImageData> Gosu::Graphics::createImage(

data/GosuImpl/Graphics/LargeImageData.cpp

@@ -48,12 +48,12 @@ Gosu::LargeImageData::LargeImageData(Graphics& graphics,
         }
 }
 
-unsigned Gosu::LargeImageData::width() const
+int Gosu::LargeImageData::width() const
 {
     return fullWidth;
 }
 
-unsigned Gosu::LargeImageData::height() const
+int Gosu::LargeImageData::height() const
 {
     return fullHeight;
 }

data/GosuImpl/Graphics/LargeImageData.hpp

@@ -17,8 +17,8 @@ namespace Gosu
         LargeImageData(Graphics& graphics, const Bitmap& source,
             unsigned partWidth, unsigned partHeight, unsigned borderFlags);
 
-        unsigned width() const;
-        unsigned height() const;
+        int width() const;
+        int height() const;
 
         void draw(double x1, double y1, Color c1,
             double x2, double y2, Color c2,

data/GosuImpl/Graphics/Macro.hpp

@@ -9,82 +9,85 @@
 #include <cmath>
 #include <algorithm>
 #include <memory>
+#include <stdexcept>
 
 class Gosu::Macro : public Gosu::ImageData
 {
-    VertexArray vertexArray;
-    unsigned w, h;
-    
     Graphics& graphics;
-public:
-    Macro(Graphics& graphics, DrawOpQueue& queue)
-    :   graphics(graphics)
+    VertexArrays vertexArrays;
+    std::vector<Transform> embeddedTransforms;
+    int givenWidth, givenHeight;
+    
+    void realDraw(double x1, double y1, double x2, double y3) const
     {
-        queue.compileTo(vertexArray);
-        double left = 0, right = 0, top = 0, bottom = 0;
-        for (VertexArray::const_iterator it = vertexArray.begin(),
-             end = vertexArray.end(); it != end; ++it)
+        // TODO: Macros should not be split up because they have different transforms! This is insane.
+        // They should be premultiplied and have the same transform by definition. Then, the transformation
+        // only had to be performed here once.
+        
+        #ifndef GOSU_IS_IPHONE
+        glEnable(GL_BLEND);
+        glMatrixMode(GL_MODELVIEW);
+        
+        for (VertexArrays::const_iterator it = vertexArrays.begin(), end = vertexArrays.end(); it != end; ++it)
         {
-            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]);
+            glPushMatrix();
+            it->renderState.apply();
+            
+            glTranslated(x1, y1, 0);
+            glScaled((x2 - x1) / width(), (y3 - y1) / height(), 1);
+            
+            glInterleavedArrays(GL_T2F_C4UB_V3F, 0, &it->vertices[0]);
+            glDrawArrays(GL_QUADS, 0, it->vertices.size());
+            glPopMatrix();
         }
-        w = std::ceil(right - left);
-        h = std::ceil(bottom - top);
+        #endif
     }
     
-    unsigned int width() const
+public:
+    Macro(Graphics& graphics, DrawOpQueue& queue, int width, int height)
+    : graphics(graphics), givenWidth(width), givenHeight(height)
     {
-        return w;
+        queue.compileTo(vertexArrays);
+        
+        // Very important fix: RenderState only contains a (non-owned) pointer to a Transform.
+        // If we want to use this Macro in more than a single frame, the pointer would be
+        // invalidated. Hence, we copy the transform into this macro and just let the
+        // RenderState refer to that one.
+        
+        // TODO: As the next step, we should flatten all the transforms into a single one. But
+        // maybe not here, as the VertexArrays are already split up, possibly because their
+        // transforms differed.
+        
+        embeddedTransforms.reserve(vertexArrays.size());
+        for (VertexArrays::iterator it = vertexArrays.begin(), end = vertexArrays.end(); it != end; ++it)
+        {
+            embeddedTransforms.push_back(*it->renderState.transform);
+            it->renderState.transform = &embeddedTransforms.back();
+        }
     }
     
-    unsigned int height() const
+    int width() const
     {
-        return h;
+        return givenWidth;
     }
     
-    void draw(double x1, double y1, Color c1,
-              double x2, double y2, Color c2,
-              double x3, double y3, Color c3,
-              double x4, double y4, Color c4,
-              ZPos z, AlphaMode mode) const
+    int height() const
     {
-        std::tr1::function<void()> f = std::tr1::bind(&Macro::realDraw, this, x1, y1, x2, y2, x3, y3);
-        graphics.scheduleGL(f, z);
+        return givenHeight;
     }
     
-    void realDraw(double x1, double y1,
-              double x2, double y2,
-              double x3, double y3) const
+    void draw(double x1, double y1, Color c1,
+        double x2, double y2, Color c2,
+        double x3, double y3, Color c3,
+        double x4, double y4, Color c4,
+        ZPos z, AlphaMode mode) const
     {
-        // Empty record- avoid division by zero.
-        if (vertexArray.empty())
-            return;        
-        
-        // TODO: Commented out for now on the iPhone.
-        // To work, it would need to reset the VertexPointer etc. after doing its work.
-    #ifndef GOSU_IS_IPHONE
-        glEnable(GL_BLEND);
-        RenderState rs;
-        rs.setTexName(1);
-        rs.setAlphaMode(amDefault);
-        
-        // TODO: We should apply current transformations either here or in draw(), or both.
-        // TODO: Also, calculate the transform as a matrix and use RenderState::setTransform.
-        
-        glMatrixMode(GL_MODELVIEW);
-        //glPushMatrix();
-        glTranslated(x1, y1, 0);
-        glScaled((x2 - x1) / width(), (y3 - y1) / height(), 1);
-        
-        glInterleavedArrays(GL_T2F_C4UB_V3F, 0, &vertexArray[0]);
-        
-        glDrawArrays(GL_QUADS, 0, vertexArray.size());
-        glFlush();
-
-        //glPopMatrix();
-    #endif
+        if (x1 != x3 || x2 != x4 || y1 != y2 || y3 != y4)
+            throw std::invalid_argument("Macros cannot be rotated yet");
+        if (c1 != 0xffffffff || c2 != 0xffffffff || c3 != 0xffffffff || c4 != 0xffffffff)
+            throw std::invalid_argument("Macros cannot be tinted with colors yet");
+        std::tr1::function<void()> f = std::tr1::bind(&Macro::realDraw, this, x1, y1, x2, y3);
+        graphics.scheduleGL(f, z);
     }
     
     const Gosu::GLTexInfo* glTexInfo() const
@@ -94,14 +97,13 @@ public:
     
     Gosu::Bitmap toBitmap() const
     {
-        throw std::logic_error("Gosu::Macro cannot be rendered as Gosu::Bitmap");
+        throw std::logic_error("Gosu::Macro cannot be rendered as Gosu::Bitmap yet");
     }
     
     void insert(const Bitmap& bitmap, int x, int y)
     {
-        throw std::logic_error("Gosu::Macro cannot be updated with a Gosu::Bitmap");
+        throw std::logic_error("Gosu::Macro cannot be updated with a Gosu::Bitmap yet");
     }
 };
 
 #endif
-

data/GosuImpl/Graphics/RenderState.hpp

@@ -3,47 +3,121 @@
 
 #include <GosuImpl/Graphics/Common.hpp>
 
-class Gosu::RenderState
+// Properties that potentially need to be changed between each draw operation.
+// This does not include the color or vertex data of the actual quads.
+struct Gosu::RenderState
 {
     GLuint texName;
     Transform* transform;
-    unsigned clipX, clipY, clipWidth, clipHeight;
+    ClipRect clipRect;
     AlphaMode mode;
     
-public:
     RenderState()
-    :   texName(NO_TEXTURE), transform(0), clipWidth(NO_CLIPPING), mode(amDefault)
+    : texName(NO_TEXTURE), transform(0), mode(amDefault)
     {
-        glMatrixMode(GL_MODELVIEW);
-        glPushMatrix();
-        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        clipRect.width = NO_CLIPPING;
     }
     
-    ~RenderState()
+    bool operator==(const RenderState& rhs) const
     {
-        setClipRect(NO_CLIPPING, NO_CLIPPING, NO_CLIPPING, NO_CLIPPING);
-        setTexName(NO_TEXTURE);
-        glPopMatrix();
+        return texName == rhs.texName && transform == rhs.transform &&
+            clipRect == rhs.clipRect && mode == rhs.mode;
     }
     
-    void setTransform(Transform* newTransform)
+    void applyTexture() const
     {
-        if (newTransform == transform)
-            return;
-            
+        if (texName == NO_TEXTURE)
+            glDisable(GL_TEXTURE_2D);
+        else
+        {
+            glEnable(GL_TEXTURE_2D);
+            glBindTexture(GL_TEXTURE_2D, texName);
+        }
+    }
+    
+    void applyAlphaMode() const
+    {
+        if (mode == amAdd)
+            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);
+    }
+    
+    void applyClipRect() const
+    {
+        if (clipRect.width == NO_CLIPPING)
+            glDisable(GL_SCISSOR_TEST);
+        else
+        {
+            glEnable(GL_SCISSOR_TEST);
+            glScissor(clipRect.x, clipRect.y, clipRect.width, clipRect.height);
+        }
+    }
+    
+    // Only used by Macro so far
+    #ifndef GOSU_IS_IPHONE
+    void apply() const
+    {
+        applyTexture();
+        glMultMatrixd(&(*transform)[0]);
+        // cliprect from the outside is okay
+        applyAlphaMode();
+    }
+    #endif
+};
+
+// Manages the OpenGL rendering state. It caches the current state, only forwarding the
+// changes to OpenGL if the new state is really different.
+class Gosu::RenderStateManager : private Gosu::RenderState
+{
+    // Not copyable
+    RenderStateManager(const RenderStateManager&);
+    RenderStateManager& operator=(const RenderStateManager&);
+    
+    void applyTransform() const
+    {
+        glMatrixMode(GL_MODELVIEW);
         glPopMatrix();
         glPushMatrix();
+        
         #ifndef GOSU_IS_IPHONE
-        glMultMatrixd(&(*newTransform)[0]);
+        glMultMatrixd(&(*transform)[0]);
         #else
-        float matrix[16];
+        // TODO: Ouch, should always use floats!
+        GLfloat matrix[16];
         for (int i = 0; i < 16; ++i)
-            matrix[i] = (*newTransform)[i];
+            matrix[i] = (*transform)[i];
         glMultMatrixf(matrix);
         #endif
-        transform = newTransform;
     }
-
+    
+public:
+    RenderStateManager()
+    {
+        glMatrixMode(GL_MODELVIEW);
+        glPushMatrix();
+        applyAlphaMode();
+    }
+    
+    ~RenderStateManager()
+    {
+        ClipRect noClipping;
+        noClipping.width = NO_CLIPPING;
+        setClipRect(noClipping);
+        setTexName(NO_TEXTURE);
+        glPopMatrix();
+    }
+    
+    void setRenderState(const RenderState& rs)
+    {
+        setTexName(rs.texName);
+        setTransform(rs.transform);
+        setClipRect(rs.clipRect);
+        setAlphaMode(rs.mode);
+    }
+    
     void setTexName(GLuint newTexName)
     {
         if (newTexName == texName)
@@ -60,33 +134,40 @@ public:
         texName = newTexName;
     }
     
-    void setClipRect(unsigned newClipX, unsigned newClipY,
-        unsigned newClipWidth, unsigned newClipHeight)
+    void setTransform(Transform* newTransform)
     {
-        if (newClipWidth == NO_CLIPPING)
+        if (newTransform == transform)
+            return;
+        transform = newTransform;
+        
+        applyTransform();
+    }
+
+    void setClipRect(const ClipRect& newClipRect)
+    {
+        if (newClipRect.width == NO_CLIPPING)
         {
             // Disable clipping
-            if (clipWidth != NO_CLIPPING)
+            if (clipRect.width != NO_CLIPPING)
             {
                 glDisable(GL_SCISSOR_TEST);
-                clipWidth = NO_CLIPPING;
+                clipRect.width = NO_CLIPPING;
             }
         }
         else
         {
             // Enable clipping if off
-            if (clipWidth == NO_CLIPPING)
+            if (clipRect.width == NO_CLIPPING)
             {
                 glEnable(GL_SCISSOR_TEST);
-                glScissor(clipX = newClipX, clipY = newClipY,
-                    clipWidth = newClipWidth, clipHeight = newClipHeight);
+                clipRect = newClipRect;
+                glScissor(clipRect.x, clipRect.y, clipRect.width, clipRect.height);
             }
             // Adjust clipping if necessary
-            else if (clipX != newClipX || clipY != newClipY ||
-                clipWidth != newClipWidth || clipHeight != newClipHeight)
+            else if (!(clipRect == newClipRect))
             {
-                glScissor(clipX = newClipX, clipY = newClipY,
-                    clipWidth = newClipWidth, clipHeight = newClipHeight);
+                clipRect = newClipRect;
+                glScissor(clipRect.x, clipRect.y, clipRect.width, clipRect.height);
             }
         }
     }
@@ -96,12 +177,19 @@ public:
         if (newMode == mode)
             return;
         mode = newMode;
-        if (mode == amAdd)
-            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);
+        applyAlphaMode();
+    }
+    
+    // The cached values may have been messed with. Reset them again.
+    void enforceAfterUntrustedGL() const
+    {
+        // TODO: Actually, we don't have to worry about anything pushed
+        // using glPushAttribs because beginGL/endGL will take care of that.
+        
+        applyTexture();
+        applyTransform();
+        applyClipRect();
+        applyAlphaMode();
     }
 };