gosu 0.7.25 → 0.7.26

data/COPYING.txt

@@ -1,4 +1,4 @@
-Copyright (C) 2004-2010 Julian Raschke, Jan Lücker and all contributors.
+Copyright (C) 2004-2011 Julian Raschke, Jan Lücker and all contributors.
 
 Permission is hereby granted, free of charge, to any person obtaining a
 copy of this software and associated documentation files (the "Software"),

data/Gosu/Color.hpp

@@ -34,7 +34,6 @@ namespace Gosu
         }
         
         //! Conversion constructor for literals of the form 0xaarrggbb.
-        //! (C++ only.)
         Color(boost::uint32_t argb)
         {
             *this = Color((argb >> 24) & 0xff, (argb >> 16) & 0xff,
@@ -52,13 +51,6 @@ namespace Gosu
                   (green << GREEN_OFFSET) | (blue << BLUE_OFFSET);
         }
         
-        static Color fromRGBA(boost::uint32_t rgba)
-        {
-            Color result;
-            result.rep = rgba;
-            return result;
-        }
-        
         //! Constructs a color from the given hue/saturation/value triple.
         //! Ranges of these values are given as 0..360, 0..1 and 0..1,
         //! respectively.

data/Gosu/Graphics.hpp

@@ -8,6 +8,7 @@
 #include <Gosu/Color.hpp>
 #include <Gosu/GraphicsBase.hpp>
 #include <boost/array.hpp>
+#include <boost/function.hpp>
 #include <boost/scoped_ptr.hpp>
 #include <memory>
 
@@ -64,6 +65,16 @@ namespace Gosu
         void beginGL();
         //! Resets Gosu into its default rendering state.
         void endGL();
+        //! (Experimental)
+        //! 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 boost::function<void()>& functor, ZPos z);
+        
         //! Enables clipping to a specified rectangle.
         void beginClipping(double x, double y, double width, double height);
         //! Disables clipping.

data/Gosu/ImageData.hpp

@@ -17,7 +17,7 @@ namespace Gosu
     struct GLTexInfo
     {
         int texName;
-        double left, right, top, bottom;
+        float left, right, top, bottom;
     };
 
     //! The ImageData class is an abstract base class for drawable images.

data/Gosu/Version.hpp

@@ -3,7 +3,7 @@
 
 #define GOSU_MAJOR_VERSION 0
 #define GOSU_MINOR_VERSION 7
-#define GOSU_POINT_VERSION 25
-#define GOSU_VERSION "0.7.25"
+#define GOSU_POINT_VERSION 26
+#define GOSU_VERSION "0.7.26"
 
 #endif

data/GosuImpl/Graphics/BitmapTouch.mm

@@ -50,10 +50,10 @@ Gosu::Writer Gosu::saveToPNG(const Bitmap& bmp, Writer writer)
         CGDataProviderCreateWithData(0, bmp.data(), bmp.width() * bmp.height() * 4, 0);
 
     static CGColorSpaceRef colorspace = CGColorSpaceCreateDeviceRGB();
-
+    
     CGImageRef imageRef =
         CGImageCreate(bmp.width(), bmp.height(), 8, 32, bmp.width() * 4, colorspace,
-                      kCGImageAlphaFirst, dataProvider, 0, false, kCGRenderingIntentDefault);
+                      kCGImageAlphaLast, dataProvider, 0, false, kCGRenderingIntentDefault);
 
     ObjRef<UIImage> image([[UIImage alloc] initWithCGImage: imageRef]);
     

data/GosuImpl/Graphics/DrawOp.hpp

@@ -12,35 +12,35 @@ namespace Gosu
 {
     struct ArrayVertex
     {
-        GLfloat texCoords[2];
+        float texCoords[2];
         boost::uint32_t color;
-        GLfloat vertices[3];
+        float vertices[3];
     };
     typedef std::vector<ArrayVertex> VertexArray;
     
     struct DrawOp
     {
+        ZPos z;
+                
         Gosu::Transform* transform;
         int clipX, clipY;
         unsigned clipWidth, clipHeight;
-            
+        
         struct Vertex
         {
-            double x, y;
+            float x, y;
             Color c;
             Vertex() {}
-            Vertex(double x, double y, Color c) : x(x), y(y), c(c) {}
+            Vertex(float x, float y, Color c) : x(x), y(y), c(c) {}
         };
-
-        ZPos z;
+        
         Vertex vertices[4];
         unsigned usedVertices;
         const TexChunk* chunk;
         AlphaMode mode;
-
+        
         DrawOp(Gosu::Transform& transform)
-        :   transform(&transform), clipWidth(NO_CLIPPING),
-            usedVertices(0), chunk(0)
+        :   transform(&transform), clipWidth(NO_CLIPPING), chunk(0)
         {
         }
         
@@ -50,8 +50,8 @@ namespace Gosu
             static const unsigned MAX_AUTOGROUP = 24;
             
             static int spriteCounter = 0;
-            static GLfloat spriteVertices[12 * MAX_AUTOGROUP];
-            static GLfloat spriteTexcoords[12 * MAX_AUTOGROUP];
+            static float spriteVertices[12 * MAX_AUTOGROUP];
+            static float spriteTexcoords[12 * MAX_AUTOGROUP];
             static boost::uint32_t spriteColors[6 * MAX_AUTOGROUP];
             
             // iPhone specific setup
@@ -79,7 +79,7 @@ namespace Gosu
                 current.setTexName(chunk->texName());
                 
                 #ifdef GOSU_IS_IPHONE
-                double left, top, right, bottom;
+                float left, top, right, bottom;
                 chunk->getCoords(left, top, right, bottom);
                 spriteTexcoords[spriteCounter*12 + 0] = left;
                 spriteTexcoords[spriteCounter*12 + 1] = top;
@@ -107,31 +107,30 @@ namespace Gosu
             else if (usedVertices == 4)
                 glBegin(GL_QUADS);
 
-            double left, top, right, bottom;
+            float 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);
+                glColor4ubv(reinterpret_cast<const GLubyte*>(&vertices[i].c));
                 if (chunk)
                     switch (i)
                     {
                     case 0:
-                        glTexCoord2d(left, top);
+                        glTexCoord2f(left, top);
                         break;
                     case 1:
-                        glTexCoord2d(right, top);
+                        glTexCoord2f(right, top);
                         break;
                     case 2:
-                        glTexCoord2d(right, bottom);
+                        glTexCoord2f(right, bottom);
                         break;
                     case 3:
-                        glTexCoord2d(left, bottom);
+                        glTexCoord2f(left, bottom);
                         break;
                     }
-                glVertex2d(vertices[i].x, vertices[i].y);
+                glVertex2f(vertices[i].x, vertices[i].y);
             }
             
             glEnd();
@@ -175,7 +174,7 @@ namespace Gosu
                 result[i].color = vertices[i].c.abgr();
             }
 
-            double left, top, right, bottom;
+            float left, top, right, bottom;
             chunk->getCoords(left, top, right, bottom);
             result[0].texCoords[0] = left,  result[0].texCoords[1] = top;
             result[1].texCoords[0] = right, result[1].texCoords[1] = top;

data/GosuImpl/Graphics/DrawOpQueue.hpp

@@ -4,14 +4,18 @@
 #include <GosuImpl/Graphics/Common.hpp>
 #include <GosuImpl/Graphics/DrawOp.hpp>
 #include <boost/foreach.hpp>
+#include <boost/function.hpp>
 #include <boost/optional.hpp>
 #include <algorithm>
-#include <set>
+#include <map>
 #include <vector>
 
 class Gosu::DrawOpQueue
 {
-    std::multiset<DrawOp> set;
+    typedef std::vector<DrawOp> DrawOps;
+    DrawOps ops;
+    typedef std::multimap<ZPos, boost::function<void()> > CodeMap;
+    CodeMap code;
 
     struct ClipRect
     {
@@ -55,14 +59,15 @@ public:
     {
         clipRectStack.swap(other.clipRectStack);
         std::swap(effectiveRect, other.effectiveRect);
-        set.swap(other.set);
+        ops.swap(other.ops);
+        code.swap(other.code);
     }
     
-    void addDrawOp(DrawOp op, ZPos z)
+    void scheduleDrawOp(DrawOp op, ZPos z)
     {
         #ifdef GOSU_IS_IPHONE
         // No triangles, no lines supported
-        assert(op.usedVertices == 4);
+        assert (op.usedVertices == 4);
         #endif
         
         if (effectiveRect)
@@ -79,7 +84,12 @@ public:
             return;
         
         op.z = z;
-        set.insert(op);
+        ops.push_back(op);
+    }
+    
+    void scheduleGL(boost::function<void()> customCode, ZPos z)
+    {
+        code.insert(std::make_pair(z, customCode));
     }
     
     void beginClipping(int x, int y, unsigned width, unsigned height)
@@ -95,16 +105,57 @@ public:
         updateEffectiveRect();
     }
 
-    void performDrawOps() const
+    void performDrawOpsAndCode()
     {
-        RenderState current;
+        // Allows us to make some assumptions.
+        if (ops.empty())
+            return;
         
-        std::multiset<DrawOp>::const_iterator last, cur = set.begin(), end = set.end();
-        while (cur != end)
+        // 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();
+        
+        while (true)
         {
-            last = cur;
-            ++cur;
-            last->perform(current, cur == end ? 0 : &*cur);
+            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)
+            {
+                // 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;
+            }
+            
+            // Draw next code, or break if there is none
+            if (it == code.end())
+                break;
+            else
+            {
+                it->second();
+                ++it;
+            }
         }
     }
     
@@ -113,13 +164,18 @@ public:
         // Not sure if Graphics::begin() should implicitly do that.
         //clipRectStack.clear();
         //effectiveRect.reset();
-        set.clear();
+        code.clear();
+        ops.clear();
     }
     
-    void compileTo(VertexArray& va) const
+    void compileTo(VertexArray& va)
     {
-        va.reserve(set.size());
-        BOOST_FOREACH (const DrawOp& op, set)
+        if (!code.empty())
+            throw std::logic_error("Custom code cannot be recorded into a macro");
+        
+        va.reserve(ops.size());
+        std::stable_sort(ops.begin(), ops.end());
+        BOOST_FOREACH (const DrawOp& op, ops)
             op.compileTo(va);
     }
 };

data/GosuImpl/Graphics/Graphics.cpp

@@ -179,7 +179,7 @@ void Gosu::Graphics::flush()
     // If there is a recording in process, cancel it.
     pimpl->queues.resize(1);
     
-    pimpl->queues.at(0).performDrawOps();
+    pimpl->queues.at(0).performDrawOpsAndCode();
     pimpl->queues.at(0).clear();
 }
 
@@ -217,6 +217,44 @@ void Gosu::Graphics::endGL()
 #endif
 }
 
+#ifdef GOSU_IS_IPHONE
+void Gosu::Graphics::scheduleGL(const boost::function<void()>& functor, Gosu::ZPos z)
+{
+    throw std::logic_error("Custom OpenGL is unsupported on the iPhone");
+}
+#else
+namespace
+{
+    struct RunGLFunctor
+    {
+        Gosu::Graphics& graphics;
+        boost::function<void()> functor;
+        
+        RunGLFunctor(Gosu::Graphics& graphics, const boost::function<void()>& functor)
+        : graphics(graphics), functor(functor)
+        {
+        }
+        
+        void operator()() const
+        {
+            // Inlined beginGL() to avoid flushing.
+            glPushAttrib(GL_ALL_ATTRIB_BITS);
+            glDisable(GL_BLEND);
+
+            functor();
+            
+            // Does not have to be inlined.
+            graphics.endGL();            
+        }
+    };
+}
+
+void Gosu::Graphics::scheduleGL(const boost::function<void()>& functor, Gosu::ZPos 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)
@@ -304,7 +342,7 @@ void Gosu::Graphics::drawLine(double x1, double y1, Color c1,
     op.vertices[0] = DrawOp::Vertex(x1, y1, c1);
     op.vertices[1] = DrawOp::Vertex(x2, y2, c2);
 
-    pimpl->queues.back().addDrawOp(op, z);
+    pimpl->queues.back().scheduleDrawOp(op, z);
 }
 
 void Gosu::Graphics::drawTriangle(double x1, double y1, Color c1,
@@ -324,7 +362,7 @@ void Gosu::Graphics::drawTriangle(double x1, double y1, Color c1,
     op.vertices[3] = op.vertices[2];
 #endif
     
-    pimpl->queues.back().addDrawOp(op, z);
+    pimpl->queues.back().scheduleDrawOp(op, z);
 }
 
 void Gosu::Graphics::drawQuad(double x1, double y1, Color c1,
@@ -350,7 +388,7 @@ void Gosu::Graphics::drawQuad(double x1, double y1, Color c1,
     op.vertices[2] = DrawOp::Vertex(x4, y4, c4);
 #endif
 
-    pimpl->queues.back().addDrawOp(op, z);
+    pimpl->queues.back().scheduleDrawOp(op, z);
 }
 
 std::auto_ptr<Gosu::ImageData> Gosu::Graphics::createImage(

data/GosuImpl/Graphics/Macro.hpp

@@ -16,7 +16,7 @@ class Gosu::Macro : public Gosu::ImageData
     unsigned w, h;
     
 public:
-    Macro(const DrawOpQueue& queue)
+    Macro(DrawOpQueue& queue)
     {
         queue.compileTo(vertexArray);
         double left = 0, right = 0, top = 0, bottom = 0;

data/GosuImpl/Graphics/TexChunk.cpp

@@ -9,6 +9,11 @@ Gosu::TexChunk::TexChunk(Graphics& graphics, Transforms& transforms, DrawOpQueue
 :   graphics(&graphics), transforms(&transforms), queues(&queues),
     texture(texture), x(x), y(y), w(w), h(h), padding(padding)
 {
+    info.texName = texture->texName();
+    info.left    = float(x) / texture->size();
+    info.top     = float(y) / texture->size();
+    info.right   = float(x + w) / texture->size();
+    info.bottom  = float(y + h) / texture->size();
 }
 
 Gosu::TexChunk::~TexChunk()
@@ -16,29 +21,6 @@ Gosu::TexChunk::~TexChunk()
     texture->free(x - padding, y - padding);
 }
 
-unsigned int Gosu::TexChunk::width() const
-{
-    return w;
-}
-
-unsigned int Gosu::TexChunk::height() const
-{
-    return h;
-}
-
-GLuint Gosu::TexChunk::texName() const
-{
-    return texture->texName();
-}
-
-void Gosu::TexChunk::getCoords(double& left, double& top, double& right, double& bottom) const
-{
-    left = double(x) / texture->size();
-    top = double(y) / texture->size();
-    right = double(x + w) / texture->size();
-    bottom = double(y + h) / texture->size();
-}
-
 void Gosu::TexChunk::draw(double x1, double y1, Color c1,
     double x2, double y2, Color c2,
     double x3, double y3, Color c3,
@@ -63,14 +45,11 @@ void Gosu::TexChunk::draw(double x1, double y1, Color c1,
     newDrawOp.chunk = this;
     newDrawOp.mode = mode;
     
-    queues->back().addDrawOp(newDrawOp, z);
+    queues->back().scheduleDrawOp(newDrawOp, z);
 }
 
 boost::optional<Gosu::GLTexInfo> Gosu::TexChunk::glTexInfo() const
 {
-    Gosu::GLTexInfo info;
-    info.texName = texName();
-    getCoords(info.left, info.top, info.right, info.bottom);
     return info;
 }