gosu 0.7.39 → 0.7.40

data/.yardopts

@@ -0,0 +1 @@
+reference/gosu.rb - README.txt COPYING reference/*.rdoc --output reference/rdoc

data/Gosu/Version.hpp

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

data/GosuImpl/Graphics/ClipRectStack.hpp

@@ -1,6 +1,10 @@
 #ifndef GOSUIMPL_GRAPHICS_CLIPRECTSTACK_HPP
 #define GOSUIMPL_GRAPHICS_CLIPRECTSTACK_HPP
 
+#include <GosuImpl/Graphics/Common.hpp>
+#include <cassert>
+#include <vector>
+
 class Gosu::ClipRectStack
 {
     std::vector<ClipRect> stack;
@@ -52,6 +56,12 @@ public:
     {
     }
     
+    void clear()
+    {
+        stack.clear();
+        hasEffectiveRect = false;
+    }
+    
     void beginClipping(int x, int y, int width, int height)
     {
         ClipRect rect = { x, y, width, height };
@@ -61,6 +71,7 @@ public:
     
     void endClipping()
     {
+        assert (!stack.empty());
         stack.pop_back();
         updateEffectiveRect();
     }

data/GosuImpl/Graphics/Common.hpp

@@ -104,10 +104,11 @@ namespace Gosu
         return result;
     }
     
-    inline void applyTransform(const Transform& transform, double& x, double& y)
+    template<typename Float>
+    void applyTransform(const Transform& transform, Float& x, Float& y)
     {
-        double in[4] = { x, y, 0, 1 };
-        double out[4] = { 0, 0, 0, 0 };
+        Float in[4] = { x, y, 0, 1 };
+        Float 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];

data/GosuImpl/Graphics/DrawOp.hpp

@@ -139,12 +139,9 @@ namespace Gosu
         
         void compileTo(VertexArrays& vas) const
         {
-            if (vas.empty() || !(vas.back().renderState == renderState))
-            {
-                vas.push_back(VertexArray());
-                vas.back().renderState = renderState;
-            }
-            
+            // Copy vertex data and apply & forget about the transform.
+            // This is important because the pointed-to transform will be gone by the next
+            // frame anyway.
             ArrayVertex result[4];
             for (int i = 0; i < 4; ++i)
             {
@@ -152,12 +149,22 @@ namespace Gosu
                 result[i].vertices[1] = vertices[i].y;
                 result[i].vertices[2] = 0;
                 result[i].color = vertices[i].c.abgr();
+                applyTransform(*renderState.transform, result[i].vertices[0], result[i].vertices[1]);
             }
+            RenderState vaRenderState = renderState;
+            vaRenderState.transform = 0;
+            
             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;
             
+            if (vas.empty() || !(vas.back().renderState == vaRenderState))
+            {
+                vas.push_back(VertexArray());
+                vas.back().renderState = vaRenderState;
+            }
+            
             vas.back().vertices.insert(vas.back().vertices.end(), result, result + 4);
         }
         

data/GosuImpl/Graphics/DrawOpQueue.hpp

@@ -12,6 +12,8 @@
 
 class Gosu::DrawOpQueue
 {
+    Transforms individualTransforms;
+    Transforms absoluteTransforms;
     ClipRectStack clipRectStack;
     
     typedef std::vector<DrawOp> DrawOps;
@@ -19,13 +21,29 @@ class Gosu::DrawOpQueue
     typedef std::vector<std::tr1::function<void()> > GLBlocks;
     GLBlocks glBlocks;
     
+    void makeCurrentTransform(const Transform& transform)
+    {
+        Transforms::iterator oldPosition =
+            std::find(absoluteTransforms.begin(), absoluteTransforms.end(), transform);
+        if (oldPosition == absoluteTransforms.end())
+            absoluteTransforms.push_back(transform);
+        else
+            absoluteTransforms.splice(absoluteTransforms.end(), absoluteTransforms, oldPosition);
+    }
+    
+    Transform& currentTransform()
+    {
+        return absoluteTransforms.back();
+    }
+    
 public:
-    // I really wish I would trust ADL. :|
-    void swap(DrawOpQueue& other)
+    DrawOpQueue()
     {
-        clipRectStack.swap(other.clipRectStack);
-        ops.swap(other.ops);
-        glBlocks.swap(other.glBlocks);
+        // Every queue has a base transform that is always the current transform.
+        // This keeps the code a bit more uniform, and allows the window to
+        // set a base transform in the main rendering queue.
+        individualTransforms.push_back(scale(1));
+        absoluteTransforms.push_back(scale(1));
     }
     
     void scheduleDrawOp(DrawOp op)
@@ -38,12 +56,13 @@ public:
         assert (op.verticesOrBlockIndex == 4);
         #endif
         
+        op.renderState.transform = &currentTransform();
         if (const ClipRect* cr = clipRectStack.maybeEffectiveRect())
             op.renderState.clipRect = *cr;
         ops.push_back(op);
     }
     
-    void scheduleGL(Transform& transform, std::tr1::function<void()> glBlock, ZPos z)
+    void scheduleGL(std::tr1::function<void()> glBlock, ZPos z)
     {
         // TODO: Document this case: Clipped-away GL blocks are *not* being run.
         if (clipRectStack.clippedWorldAway())
@@ -53,24 +72,71 @@ public:
         glBlocks.push_back(glBlock);
         
         DrawOp op;
-        op.renderState.transform = &transform;
         op.verticesOrBlockIndex = complementOfBlockIndex;
+        op.renderState.transform = &currentTransform();
         if (const ClipRect* cr = clipRectStack.maybeEffectiveRect())
             op.renderState.clipRect = *cr;
         op.z = z;
         ops.push_back(op);
     }
     
-    void beginClipping(int x, int y, int width, int height)
+    void beginClipping(int x, int y, int width, int height, int screenHeight)
     {
-        clipRectStack.beginClipping(x, y, width, height);
+        // Apply current transformation.
+        
+        double left = x, right = x + width;
+        double top = y, bottom = y + height;
+        
+        applyTransform(currentTransform(), left, top);
+        applyTransform(currentTransform(), right, bottom);
+        
+        int physX = std::min(left, right);
+        int physY = std::min(top, bottom);
+        int physWidth = std::abs(int(left - right));
+        int physHeight = std::abs(int(top - bottom));
+        
+        // Adjust for OpenGL having the wrong idea of where y=0 is.
+        // TODO: This should really happen *right before* setting up
+        // the glScissor.
+        physY = screenHeight - physY - physHeight;
+        
+        clipRectStack.beginClipping(physX, physY, physWidth, physHeight);
     }
     
     void endClipping()
     {
         clipRectStack.endClipping();
     }
-
+    
+    void setBaseTransform(const Transform& baseTransform)
+    {
+        assert (individualTransforms.size() == 1);
+        assert (absoluteTransforms.size() == 1);
+        
+        individualTransforms.front() = absoluteTransforms.front() = baseTransform;
+    }
+    
+    void pushTransform(const Transform& transform)
+    {
+        individualTransforms.push_back(transform);
+        Transform result = multiply(transform, currentTransform());
+        makeCurrentTransform(result);
+    }
+    
+    void popTransform()
+    {
+        assert (individualTransforms.size() > 1);
+        
+        individualTransforms.pop_back();
+        // TODO: If currentTransform() wouldn't have to be .back(), then I think
+        // this could be optimized away and just be pop_back too. Or not?
+        Transform result = scale(1);
+        for (Transforms::reverse_iterator it = individualTransforms.rbegin(),
+                end = individualTransforms.rend(); it != end; ++it)
+            result = multiply(result, *it);
+        makeCurrentTransform(result);
+    }
+    
     void performDrawOpsAndCode()
     {
         // Apply Z-Ordering.
@@ -95,10 +161,7 @@ public:
         {
             manager.setRenderState(current->renderState);
             if (current->verticesOrBlockIndex >= 0)
-            {
-                // Normal DrawOp, no GL code
-                current->perform(0); // next unused on desktop
-            }
+                current->perform(0);
             else
             {
                 // GL code
@@ -112,12 +175,6 @@ public:
         #endif
     }
     
-    void clear()
-    {
-        glBlocks.clear();
-        ops.clear();
-    }
-    
     void compileTo(VertexArrays& vas)
     {
         if (!glBlocks.empty())
@@ -127,6 +184,18 @@ public:
         for (DrawOps::const_iterator op = ops.begin(), end = ops.end(); op != end; ++op)
             op->compileTo(vas);
     }
+    
+    void clear()
+    {
+        absoluteTransforms.resize(1);
+        // Important!! Due to all the swapping, the first entry in the list is not necessarily
+        // the base matrix. We need to restore it.
+        absoluteTransforms.front() = scale(1);
+        individualTransforms.resize(1);
+        clipRectStack.clear();
+        glBlocks.clear();
+        ops.clear();
+    }
 };
 
 #endif

data/GosuImpl/Graphics/Graphics.cpp

@@ -28,8 +28,6 @@ struct Gosu::Graphics::Impl
     DrawOpQueueStack queues;
     typedef std::vector<std::tr1::shared_ptr<Texture> > Textures;
     Textures textures;
-    Transforms currentTransforms;
-    Transforms absoluteTransforms;
     
 #if 0
     std::mutex texMutex;
@@ -52,7 +50,7 @@ struct Gosu::Graphics::Impl
             result = multiply(scale(1.0 * physHeight / virtWidth, 1.0 * physWidth / virtHeight), result);
             return result;
         }
-    } 
+    }
     
     Orientation orientation;
     
@@ -66,7 +64,7 @@ struct Gosu::Graphics::Impl
         if (orientation != currentOrientation())
         {
             orientation = currentOrientation();
-            currentTransforms.front() = transformForOrientation(orientation);
+            queues.front().setBaseTransform(transformForOrientation(orientation));
         }
     }
 #endif
@@ -102,10 +100,6 @@ Gosu::Graphics::Graphics(unsigned physWidth, unsigned physHeight, bool fullscree
     
     // Create default draw-op queue.
     pimpl->queues.resize(1);
-    
-    // Push one identity matrix as the default transform.
-    pimpl->currentTransforms.push_back(scale(1));
-    pimpl->absoluteTransforms.push_back(scale(1));
 }
 
 Gosu::Graphics::~Graphics()
@@ -114,14 +108,12 @@ Gosu::Graphics::~Graphics()
 
 unsigned Gosu::Graphics::width() const
 {
-    double size[2] = { pimpl->virtWidth, pimpl->virtHeight };
-    return size[0];
+    return pimpl->virtWidth;
 }
 
 unsigned Gosu::Graphics::height() const
 {
-    double size[2] = { pimpl->virtWidth, pimpl->virtHeight };
-    return size[1];
+    return pimpl->virtHeight;
 }
 
 bool Gosu::Graphics::fullscreen() const
@@ -136,33 +128,28 @@ void Gosu::Graphics::setResolution(unsigned virtualWidth, unsigned virtualHeight
     
     pimpl->virtWidth = virtualWidth, pimpl->virtHeight = virtualHeight;
     #ifdef GOSU_IS_IPHONE
-    pimpl->orientation = static_cast<Gosu::Orientation>(-1);
+    pimpl->orientation = static_cast<Orientation>(-1);
     #else
     Transform baseTransform;
     baseTransform = scale(1.0 / virtualWidth  * pimpl->physWidth,
                           1.0 / virtualHeight * pimpl->physHeight);
-    pimpl->currentTransforms.front() = pimpl->absoluteTransforms.front() = baseTransform;
+    pimpl->queues.front().setBaseTransform(baseTransform);
     #endif
 }
 
 bool Gosu::Graphics::begin(Gosu::Color clearWithColor)
 {
-    // If there is a recording in process, stop it.
-    // TODO: Raise exception?
+    // If recording is in process, cancel it.
+    assert (pimpl->queues.size() == 1);
     pimpl->queues.resize(1);
     // Clear leftover clippings.
     pimpl->queues.front().clear();
     
-    pimpl->currentTransforms.resize(1);
     #ifdef GOSU_IS_IPHONE
     pimpl->updateBaseTransform();
     #endif
-    pimpl->absoluteTransforms = pimpl->currentTransforms;
-    
-    glClearColor(clearWithColor.red()/255.0,
-                 clearWithColor.green()/255.0,
-                 clearWithColor.blue()/255.0,
-                 clearWithColor.alpha()/255.0);
+    glClearColor(clearWithColor.red() / 255.f, clearWithColor.green() / 255.f,
+        clearWithColor.blue() / 255.f, clearWithColor.alpha() / 255.f);
     glClear(GL_COLOR_BUFFER_BIT);
     
     return true;
@@ -170,18 +157,22 @@ bool Gosu::Graphics::begin(Gosu::Color clearWithColor)
 
 void Gosu::Graphics::end()
 {
+    // If recording is in process, cancel it.
+    assert (pimpl->queues.size() == 1);
+    pimpl->queues.resize(1);
+    
     flush();
-
+    
     glFlush();
 }
 
 void Gosu::Graphics::flush()
 {
-    // If there is a recording in process, cancel it.
-    pimpl->queues.resize(1);
+    if (pimpl->queues.size() != 1)
+        throw std::logic_error("Flushing to screen is not allowed while creating a macro");
     
-    pimpl->queues.at(0).performDrawOpsAndCode();
-    pimpl->queues.at(0).clear();
+    pimpl->queues.front().performDrawOpsAndCode();
+    pimpl->queues.front().clear();
 }
 
 void Gosu::Graphics::beginGL()
@@ -225,14 +216,14 @@ void Gosu::Graphics::scheduleGL(const std::tr1::function<void()>& functor, Gosu:
     throw std::logic_error("Custom OpenGL is unsupported on the iPhone");
 }
 #else
-namespace
+namespace Gosu
 {
     struct RunGLFunctor
     {
-        Gosu::Graphics& graphics;
+        Graphics& graphics;
         std::tr1::function<void()> functor;
         
-        RunGLFunctor(Gosu::Graphics& graphics, const std::tr1::function<void()>& functor)
+        RunGLFunctor(Graphics& graphics, const std::tr1::function<void()>& functor)
         : graphics(graphics), functor(functor)
         {
         }
@@ -243,7 +234,7 @@ namespace
             glPushAttrib(GL_ALL_ATTRIB_BITS);
             glDisable(GL_BLEND);
             while (glGetError() != GL_NO_ERROR);
-
+            
             functor();
             
             // Does not have to be inlined.
@@ -254,39 +245,20 @@ namespace
 
 void Gosu::Graphics::scheduleGL(const std::tr1::function<void()>& functor, Gosu::ZPos z)
 {
-    pimpl->queues.back().scheduleGL(pimpl->absoluteTransforms.back(), RunGLFunctor(*this, functor), z);
+    pimpl->queues.back().scheduleGL(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 yet");
-    
-    // Apply current transformation.
-    
-    double left = x, right = x + width;
-    double top = y, bottom = y + height;
-    
-    applyTransform(pimpl->absoluteTransforms.back(), left, top);
-    applyTransform(pimpl->absoluteTransforms.back(), right, bottom);
-    
-    int physX = std::min(left, right);
-    int physY = std::min(top, bottom);
-    int physWidth = std::abs(left - right);
-    int physHeight = std::abs(top - bottom);
+        throw std::logic_error("Clipping is not allowed while creating a macro yet");
     
-    // Apply OpenGL's counting from the wrong side ;)
-    physY = pimpl->physHeight - physY - physHeight;
-    
-    pimpl->queues.back().beginClipping(physX, physY, physWidth, physHeight);
+    pimpl->queues.back().beginClipping(x, y, width, height, pimpl->physHeight);
 }
 
 void Gosu::Graphics::endClipping()
 {
-    if (pimpl->queues.size() > 1)
-        throw std::logic_error("Clipping is not allowed while creating a macro");
-    
     pimpl->queues.back().endClipping();
 }
 
@@ -305,47 +277,20 @@ std::auto_ptr<Gosu::ImageData> Gosu::Graphics::endRecording(int width, int heigh
     return result;
 }
 
-namespace
-{
-    void ensureBackOfList(Gosu::Transforms& list, const Gosu::Transform& transform)
-    {
-        Gosu::Transforms::iterator oldPosition =
-            std::find(list.begin(), list.end(), transform);
-        if (oldPosition == list.end())
-            list.push_back(transform);
-        else
-            list.splice(list.end(), list, oldPosition);
-    }
-}
-
 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);
+    pimpl->queues.back().pushTransform(transform);
 }
 
 void Gosu::Graphics::popTransform()
 {
-    pimpl->currentTransforms.pop_back();
-    Transform result = scale(1);
-    
-    for (Transforms::reverse_iterator it = pimpl->currentTransforms.rbegin(),
-         end = pimpl->currentTransforms.rend(); it != end; ++it)
-        result = multiply(result, *it);
-    
-    ensureBackOfList(pimpl->absoluteTransforms, result);
+    pimpl->queues.back().popTransform();
 }
 
 void Gosu::Graphics::drawLine(double x1, double y1, Color c1,
-    double x2, double y2, Color c2,
-    ZPos z, AlphaMode mode)
+    double x2, double y2, Color c2, ZPos z, AlphaMode mode)
 {
     DrawOp op;
-    op.renderState.transform = &pimpl->absoluteTransforms.back();
     op.renderState.mode = mode;
     op.verticesOrBlockIndex = 2;
     op.vertices[0] = DrawOp::Vertex(x1, y1, c1);
@@ -355,12 +300,10 @@ void Gosu::Graphics::drawLine(double x1, double y1, Color c1,
 }
 
 void Gosu::Graphics::drawTriangle(double x1, double y1, Color c1,
-    double x2, double y2, Color c2,
-    double x3, double y3, Color c3,
+    double x2, double y2, Color c2, double x3, double y3, Color c3,
     ZPos z, AlphaMode mode)
 {
     DrawOp op;
-    op.renderState.transform = &pimpl->absoluteTransforms.back();
     op.renderState.mode = mode;
     op.verticesOrBlockIndex = 3;
     op.vertices[0] = DrawOp::Vertex(x1, y1, c1);
@@ -375,15 +318,12 @@ void Gosu::Graphics::drawTriangle(double x1, double y1, Color c1,
 }
 
 void Gosu::Graphics::drawQuad(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)
+    double x2, double y2, Color c2, double x3, double y3, Color c3,
+    double x4, double y4, Color c4, ZPos z, AlphaMode mode)
 {
     reorderCoordinatesIfNecessary(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4);
 
     DrawOp op;
-    op.renderState.transform = &pimpl->absoluteTransforms.back();
     op.renderState.mode = mode;
     op.verticesOrBlockIndex = 4;
     op.vertices[0] = DrawOp::Vertex(x1, y1, c1);
@@ -422,14 +362,14 @@ std::auto_ptr<Gosu::ImageData> Gosu::Graphics::createImage(
         if (srcX == 0 && srcWidth == src.width() &&
             srcY == 0 && srcHeight == src.height())
         {
-            data = texture->tryAlloc(*this, pimpl->absoluteTransforms, pimpl->queues, texture, src, 0);
+            data = texture->tryAlloc(*this, pimpl->queues, texture, src, 0);
         }
         else
         {
             Bitmap trimmedSrc;
             trimmedSrc.resize(srcWidth, srcHeight);
             trimmedSrc.insert(src, 0, 0, srcX, srcY, srcWidth, srcHeight);
-            data = texture->tryAlloc(*this, pimpl->absoluteTransforms, pimpl->queues, texture, trimmedSrc, 0);
+            data = texture->tryAlloc(*this, pimpl->queues, texture, trimmedSrc, 0);
         }
         
         if (!data.get())
@@ -460,7 +400,7 @@ std::auto_ptr<Gosu::ImageData> Gosu::Graphics::createImage(
         std::tr1::shared_ptr<Texture> texture(*i);
         
         std::auto_ptr<ImageData> data;
-        data = texture->tryAlloc(*this, pimpl->absoluteTransforms, pimpl->queues, texture, bmp, 1);
+        data = texture->tryAlloc(*this, pimpl->queues, texture, bmp, 1);
         if (data.get())
             return data;
     }
@@ -472,7 +412,7 @@ std::auto_ptr<Gosu::ImageData> Gosu::Graphics::createImage(
     pimpl->textures.push_back(texture);
     
     std::auto_ptr<ImageData> data;
-    data = texture->tryAlloc(*this, pimpl->absoluteTransforms, pimpl->queues, texture, bmp, 1);
+    data = texture->tryAlloc(*this, pimpl->queues, texture, bmp, 1);
     if (!data.get())
         throw std::logic_error("Internal texture block allocation error");
 

data/GosuImpl/Graphics/Macro.hpp

@@ -15,7 +15,6 @@ class Gosu::Macro : public Gosu::ImageData
 {
     Graphics& graphics;
     VertexArrays vertexArrays;
-    std::vector<Transform> embeddedTransforms;
     int givenWidth, givenHeight;
     
     void realDraw(double x1, double y1, double x2, double y3) const
@@ -48,22 +47,6 @@ public:
     : graphics(graphics), givenWidth(width), givenHeight(height)
     {
         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();
-        }
     }
     
     int width() const

data/GosuImpl/Graphics/RenderState.hpp

@@ -61,8 +61,7 @@ struct Gosu::RenderState
     void apply() const
     {
         applyTexture();
-        glMultMatrixd(&(*transform)[0]);
-        // cliprect from the outside is okay
+        // TODO: No inner clipRect yet - how would this work?!
         applyAlphaMode();
     }
     #endif
@@ -79,8 +78,7 @@ class Gosu::RenderStateManager : private Gosu::RenderState
     void applyTransform() const
     {
         glMatrixMode(GL_MODELVIEW);
-        glPopMatrix();
-        glPushMatrix();
+        glLoadIdentity();
         
         #ifndef GOSU_IS_IPHONE
         glMultMatrixd(&(*transform)[0]);
@@ -96,9 +94,10 @@ class Gosu::RenderStateManager : private Gosu::RenderState
 public:
     RenderStateManager()
     {
+        applyAlphaMode();
+        // Preserve previous MV matrix
         glMatrixMode(GL_MODELVIEW);
         glPushMatrix();
-        applyAlphaMode();
     }
     
     ~RenderStateManager()
@@ -107,6 +106,8 @@ public:
         noClipping.width = NO_CLIPPING;
         setClipRect(noClipping);
         setTexName(NO_TEXTURE);
+        // Return to previous MV matrix
+        glMatrixMode(GL_MODELVIEW);
         glPopMatrix();
     }
     
@@ -139,7 +140,6 @@ public:
         if (newTransform == transform)
             return;
         transform = newTransform;
-        
         applyTransform();
     }
 

data/GosuImpl/Graphics/TexChunk.cpp

@@ -4,10 +4,9 @@
 #include <Gosu/Bitmap.hpp>
 #include <Gosu/Graphics.hpp>
 
-Gosu::TexChunk::TexChunk(Graphics& graphics, Transforms& transforms, DrawOpQueueStack& queues,
+Gosu::TexChunk::TexChunk(Graphics& graphics, DrawOpQueueStack& queues,
     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)
+: graphics(graphics), queues(queues), texture(texture), x(x), y(y), w(w), h(h), padding(padding)
 {
     info.texName = texture->texName();
     float textureSize = texture->size();
@@ -30,7 +29,6 @@ void Gosu::TexChunk::draw(double x1, double y1, Color c1,
 {
     DrawOp op;
     op.renderState.texName = texName();
-    op.renderState.transform = &transforms->back();
     op.renderState.mode = mode;
     
     reorderCoordinatesIfNecessary(x1, y1, x2, y2, x3, y3, c3, x4, y4, c4);
@@ -52,7 +50,7 @@ void Gosu::TexChunk::draw(double x1, double y1, Color c1,
     op.bottom = info.bottom;
     
     op.z = z;
-    queues->back().scheduleDrawOp(op);
+    queues.back().scheduleDrawOp(op);
 }
 
 const Gosu::GLTexInfo* Gosu::TexChunk::glTexInfo() const

data/GosuImpl/Graphics/TexChunk.hpp

@@ -11,9 +11,8 @@
 
 class Gosu::TexChunk : public Gosu::ImageData
 {
-    Graphics* graphics;
-    Transforms* transforms;
-    DrawOpQueueStack* queues;
+    Graphics& graphics;
+    DrawOpQueueStack& queues;
     std::tr1::shared_ptr<Texture> texture;
     int x, y, w, h, padding;
     
@@ -21,7 +20,7 @@ class Gosu::TexChunk : public Gosu::ImageData
     GLTexInfo info;
     
 public:
-    TexChunk(Graphics& graphics, Transforms& transforms, DrawOpQueueStack& queues,
+    TexChunk(Graphics& graphics, DrawOpQueueStack& queues,
              std::tr1::shared_ptr<Texture> texture, int x, int y, int w, int h, int padding);
     ~TexChunk();
 

data/GosuImpl/Graphics/Texture.cpp

@@ -61,9 +61,8 @@ GLuint Gosu::Texture::texName() const
 }
 
 std::auto_ptr<Gosu::TexChunk>
-    Gosu::Texture::tryAlloc(Graphics& graphics, Transforms& transforms,
-        DrawOpQueueStack& queues, std::tr1::shared_ptr<Texture> ptr,
-        const Bitmap& bmp, unsigned padding)
+    Gosu::Texture::tryAlloc(Graphics& graphics, DrawOpQueueStack& queues,
+        std::tr1::shared_ptr<Texture> ptr, const Bitmap& bmp, unsigned padding)
 {
     std::auto_ptr<Gosu::TexChunk> result;
     
@@ -71,7 +70,7 @@ std::auto_ptr<Gosu::TexChunk>
     if (!allocator.alloc(bmp.width(), bmp.height(), block))
         return result;
     
-    result.reset(new TexChunk(graphics, transforms, queues, ptr, block.left + padding, block.top + padding,
+    result.reset(new TexChunk(graphics, queues, ptr, block.left + padding, block.top + padding,
                               block.width - 2 * padding, block.height - 2 * padding, padding));
     
     glBindTexture(GL_TEXTURE_2D, name);

data/GosuImpl/Graphics/Texture.hpp

@@ -23,7 +23,7 @@ namespace Gosu
         unsigned size() const;
         GLuint texName() const;
         std::auto_ptr<TexChunk> 
-            tryAlloc(Graphics& graphics, Transforms& transforms, DrawOpQueueStack& queues,
+            tryAlloc(Graphics& graphics, DrawOpQueueStack& queues,
                 std::tr1::shared_ptr<Texture> ptr, const Bitmap& bmp, unsigned padding);
         void free(unsigned x, unsigned y);
         Gosu::Bitmap toBitmap(unsigned x, unsigned y, unsigned width, unsigned height) const;

data/GosuImpl/RubyGosu_wrap.cxx

@@ -11243,8 +11243,8 @@ SWIGEXPORT void Init_gosu(void) {
   SWIG_RubyInitializeTrackings();
   rb_define_const(mGosu, "MAJOR_VERSION", SWIG_From_int(static_cast< int >(0)));
   rb_define_const(mGosu, "MINOR_VERSION", SWIG_From_int(static_cast< int >(7)));
-  rb_define_const(mGosu, "POINT_VERSION", SWIG_From_int(static_cast< int >(39)));
-  rb_define_const(mGosu, "VERSION", SWIG_FromCharPtr("0.7.39"));
+  rb_define_const(mGosu, "POINT_VERSION", SWIG_From_int(static_cast< int >(40)));
+  rb_define_const(mGosu, "VERSION", SWIG_FromCharPtr("0.7.40"));
   rb_define_module_function(mGosu, "milliseconds", VALUEFUNC(_wrap_milliseconds), -1);
   rb_define_module_function(mGosu, "random", VALUEFUNC(_wrap_random), -1);
   rb_define_module_function(mGosu, "degrees_to_radians", VALUEFUNC(_wrap_degrees_to_radians), -1);

data/GosuImpl/WindowX.cpp

@@ -26,62 +26,68 @@
 
 using namespace std::tr1::placeholders;
 
-namespace
+namespace Gosu
 {
-    template<typename T>
-    class scoped_resource
+    namespace FPS
     {
-        T* pointer;
-        typedef std::tr1::function<void(T*)> Deleter;
-        Deleter deleter;
+        void registerFrame();
+    }
+
+    void screenMetrics(int *x_org, int *y_org, int *width, int *height){
+        // Open the X Display; passing NULL returns the default display.
+        Display* display = XOpenDisplay(NULL);
         
-    public:
-        scoped_resource(T* pointer, const Deleter& deleter)
-        : pointer(pointer), deleter(deleter)
-        {
-        }
+        // Raw screen information from the X server.
+        Screen* screen = XScreenOfDisplay(display, DefaultScreen(display));
         
-        void reset(T* newPointer = 0)
-        {
-            if (pointer)
-                deleter(pointer);
-            pointer = newPointer;
+        // Xinerama screen information; if available, this info is more accurate.
+        // This is especially important for multi-monitor configurations.
+        int screen_count = 0;
+        XineramaScreenInfo *screen_info = XineramaQueryScreens(display, &screen_count);
+    
+        // If screen_info is not NULL, we got preferred measurements from Xinerama,
+        // otherwise we use the measurements from the X server.
+        if(screen_info != NULL){
+            // screen_info is an array of length screen_count
+            // Index zero should hold the "default" or "primary"
+            // screen as configured by the user.
+            *x_org = screen_info[0].x_org;
+            *y_org = screen_info[0].y_org;
+            *width = screen_info[0].width;
+            *height = screen_info[0].height;
+        }else{
+            // screen is a reference to the default X Server screen
+            // Since we know Xinerama isn't running, this screen
+            // should correspond to exactly one physical display.
+            *x_org = 0;
+            *y_org = 0;
+            *width = screen->width;
+            *height = screen->height;
         }
-        
-        T* get() const
-        {
-            return pointer;
+    
+        // Release the Xinerama screen info, if we have it.
+        if(screen_info != NULL){
+            XFree(screen_info);
         }
         
-        T* operator->() const
-        {
-            return get();
-        }
+        // Release the connection to the X Display
+        XCloseDisplay(display);
         
-        ~scoped_resource()
-        {
-            reset(0);
-        }
-    };
-}
-
-namespace Gosu
-{
-    namespace FPS
-    {
-        void registerFrame();
+        return;
     }
 
     unsigned screenWidth()
     {
-        scoped_resource<Display> display(XOpenDisplay(NULL), XCloseDisplay);
-        return DisplayWidth(display.get(), DefaultScreen(display.get()));
+        int x_org, y_org, width, height;
+        screenMetrics(&x_org, &y_org, &width, &height);
+        return width;
     }
     
     unsigned screenHeight()
     {
-        scoped_resource<Display> display(XOpenDisplay(NULL), XCloseDisplay);
-        return DisplayHeight(display.get(), DefaultScreen(display.get()));
+        int x_org, y_org, width, height;
+        screenMetrics(&x_org, &y_org, &width, &height);
+        return height;
     }
 }
 
@@ -238,63 +244,38 @@ Gosu::Window::Window(unsigned width, unsigned height, bool fullscreen,
     Atom atoms[] = { XInternAtom(pimpl->display, "WM_DELETE_WINDOW", false) };
     XSetWMProtocols(pimpl->display, pimpl->window, atoms, 1);
 
-    // Get xinerama screen info
-    int screen_count = 0;
-    XineramaScreenInfo *screen_info = XineramaQueryScreens(pimpl->display, &screen_count);
 
-    // Holders for screen info
-    int screen_origin_x = 0;
-    int screen_origin_y = 0;
-    int screen_width = 0;
-    int screen_height = 0;
-
-    // Literal X screen, different from Xinerama screens
+    // Get reference to X Screen
     Screen* screen = XScreenOfDisplay(pimpl->display,
-                        DefaultScreen(pimpl->display));
-
-    // Get origin/size from first xinerama screen if it
-    // exists; convention seems to be that the first
-    // screen is always the default screen with xinerama.
-    if(screen_info != NULL){
-        screen_origin_x = screen_info[0].x_org;
-        screen_origin_y = screen_info[0].y_org;
-        screen_width = screen_info[0].width;
-        screen_height = screen_info[0].height;
-    
-    // ... or just use the whole X screen if we don't
-    // seem to have any xinerama information.
-    }else{
-        screen_width = screen->width;
-        screen_height = screen->height;
-    }
-
-    // Free the screen info, cause I guess we don't
-    // need it after this?
-    XFree(screen_info);
+                     DefaultScreen(pimpl->display));
 
-    if (fullscreen)
-    {
+    if (fullscreen){
+        // If we're going fullscreen, replace the window
+        // position and size with our screen metrics.
+        int screen_x_org, screen_y_org, screen_width, screen_height;
+        Gosu::screenMetrics(&screen_x_org, &screen_y_org, &screen_width, &screen_height);
         pimpl->width = screen_width;
         pimpl->height = screen_height;
-        XMoveResizeWindow(pimpl->display, pimpl->window, screen_origin_x, screen_origin_y,
-            screen_width, screen_height);
-            
+        pimpl->x = screen_x_org;
+        pimpl->y = screen_y_org;
+
+        // Override Redirect (JohnColburn says: I don't actually know what this is for.)
         XSetWindowAttributes windowAttributes;
         windowAttributes.override_redirect = true;
         unsigned mask = CWOverrideRedirect;
         XChangeWindowAttributes(pimpl->display, pimpl->window, mask, &windowAttributes);
-        
     }
-    else
-        ; // Window already has requested size
+    
+    // Move and resize the window to its current position and size.
+    XMoveResizeWindow(pimpl->display, pimpl->window, pimpl->x, pimpl->y, pimpl->width, pimpl->height);
 
-    // Set window to be non resizable
-    scoped_resource<XSizeHints> sizeHints(XAllocSizeHints(), XFree);
+    // Set window to be non-resizable
+    XSizeHints *sizeHints = XAllocSizeHints();
     sizeHints->flags = PMinSize | PMaxSize;
     sizeHints->min_width = sizeHints->max_width = pimpl->width;
     sizeHints->min_height = sizeHints->max_height = pimpl->height;
-    XSetWMNormalHints(pimpl->display, pimpl->window, sizeHints.get());
-    sizeHints.reset();
+    XSetWMNormalHints(pimpl->display, pimpl->window, sizeHints);
+    XFree(sizeHints);
 
     // TODO: Window style (_MOTIF_WM_HINTS)?        
 

data/linux/extconf.rb

@@ -96,6 +96,7 @@ else
   have_header('vorbisfile.h') if have_library('vorbisfile', 'ov_open_callbacks')
   have_header('AL/al.h') if have_library('openal')
   have_header('sndfile.h') if have_library('sndfile')
+  have_header('X11/extensions/Xinerama.h') if have_library('Xinerama', 'XineramaQueryScreens')
 end
 
 # Copy all relevant C++ files into the current directory

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: gosu
 version: !ruby/object:Gem::Version 
-  hash: 77
+  hash: 83
   prerelease: 
   segments: 
   - 0
   - 7
-  - 39
-  version: 0.7.39
+  - 40
+  version: 0.7.40
 platform: ruby
 authors: 
 - Julian Raschke
@@ -27,6 +27,7 @@ extensions:
 extra_rdoc_files: []
 
 files: 
+- .yardopts
 - COPYING
 - README.txt
 - Gosu/Async.hpp