gosu 0.7.40 → 0.7.41

data/Gosu/Image.hpp

@@ -5,9 +5,11 @@
 #define GOSU_IMAGE_HPP
 
 #include <Gosu/Fwd.hpp>
-#include <Gosu/Bitmap.hpp>
+#include <Gosu/Color.hpp>
+#include <Gosu/GraphicsBase.hpp>
 #include <Gosu/TR1.hpp>
 #include <memory>
+#include <vector>
 
 namespace Gosu
 {
@@ -79,7 +81,10 @@ namespace Gosu
         //! Provides access to the underlying image data object.
         ImageData& getData() const;
     };
-
+    
+    std::vector<Gosu::Image> loadTiles(Graphics& graphics, const Bitmap& bmp, int tileWidth, int tileHeight, bool tileable);
+    std::vector<Gosu::Image> loadTiles(Graphics& graphics, const std::wstring& bmp, int tileWidth, int tileHeight, bool tileable);
+    
     //! Convenience function that splits a BMP or PNG file into an array
     //! of small rectangles and creates images from them.
     //! \param tileWidth If positive, specifies the width of one tile in
@@ -89,14 +94,13 @@ namespace Gosu
     //! Must provide a push_back member function; vector<tr1::shared_ptr<Image>>
     //! 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)
+    void imagesFromTiledBitmap(Graphics& graphics, const std::wstring& filename, int tileWidth, int tileHeight, bool tileable, Container& appendTo)
     {
-        Bitmap bmp;
-        loadImageFile(bmp, filename);
-        imagesFromTiledBitmap(graphics, bmp, tileWidth, tileHeight, tileable, appendTo);
+        std::vector<Gosu::Image> tiles = loadTiles(graphics, filename, tileWidth, tileHeight, tileable);
+        for (int i = 0, num = tiles.size(); i < num; ++i)
+            appendTo.push_back(typename Container::value_type(new Gosu::Image(tiles[i])));
     }
-
+    
     //! Convenience function that splits a bitmap into an area of array 
     //! rectangles and creates images from them.
     //! \param tileWidth If positive, specifies the width of one tile in
@@ -109,29 +113,9 @@ namespace Gosu
     void imagesFromTiledBitmap(Graphics& graphics, const Bitmap& bmp,
         int tileWidth, int tileHeight, bool tileable, Container& appendTo)
     {
-        int tilesX, tilesY;
-
-        if (tileWidth > 0)
-            tilesX = bmp.width() / tileWidth;
-        else
-        {
-            tilesX = -tileWidth;
-            tileWidth = bmp.width() / tilesX;
-        }
-        
-        if (tileHeight > 0)
-            tilesY = bmp.height() / tileHeight;
-        else
-        {
-            tilesY = -tileHeight;
-            tileHeight = bmp.height() / tilesY;
-        }
-        
-        for (int y = 0; y < tilesY; ++y)
-            for (int x = 0; x < tilesX; ++x)
-                appendTo.push_back(typename Container::value_type(new Image(graphics, bmp,
-                    x * tileWidth, y * tileHeight, tileWidth, tileHeight,
-                    tileable)));
+        std::vector<Gosu::Image> tiles = loadTiles(graphics, bmp, tileWidth, tileHeight, tileable);
+        for (int i = 0, num = tiles.size(); i < num; ++i)
+            appendTo.push_back(typename Container::value_type(new Gosu::Image(tiles[i])));
     }
 }
 

data/Gosu/TR1.hpp

@@ -1,26 +1,34 @@
 //! \file TR1.hpp
-//! Includes all parts of C++03 (TR1) that are relevant for Gosu.
+//! Includes all parts of C++03 (TR1) that are relevant for Gosu. It makes available the following members of the std::tr1 namespace: array, bind, function, shared_ptr, uint*_t and int*_t.
 
 #ifndef GOSU_TR1_HPP
 #define GOSU_TR1_HPP
 
-#ifdef _MSC_VER
+#include <memory>
+
+#if defined(_MSC_VER) || defined(_LIBCPP_MEMORY)
     #include <array>
-    #include <memory>
     #include <functional>
     namespace std
     {
         namespace tr1
         {
-            typedef unsigned char        uint8_t;
-            typedef unsigned short       uint16_t;
-            typedef unsigned int         uint32_t;
-            typedef unsigned long long   uint64_t;
-            typedef signed char          int8_t;
-            typedef signed short         int16_t;
-            typedef signed int           int32_t;
-            typedef signed long long     int64_t;
-        }
+            typedef unsigned char uint8_t;
+            typedef unsigned short uint16_t;
+            typedef unsigned int uint32_t;
+            typedef unsigned long long uint64_t;
+            typedef signed char int8_t;
+            typedef signed short int16_t;
+            typedef signed int int32_t;
+            typedef signed long long int64_t;
+            
+            #ifdef _LIBCPP_MEMORY
+            using std::array;
+            using std::bind;
+            using std::function;
+            using std::shared_ptr;
+            #endif
+        }        
     }
 #else
     #include <tr1/array>
@@ -32,7 +40,7 @@
         {
             namespace tr1
             {
-                using ::int8_t;  using ::int16_t;  using ::int32_t;  using ::int64_t;
+                using ::int8_t; using ::int16_t; using ::int32_t; using ::int64_t;
                 using ::uint8_t; using ::uint16_t; using ::uint32_t; using ::uint64_t;
             }
         }

data/Gosu/Version.hpp

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

data/Gosu/Window.hpp

@@ -105,6 +105,7 @@ namespace Gosu
         #endif
         
         #ifdef GOSU_IS_IPHONE
+        void* rootViewController() const;
         // iPhone-only callbacks for touch events.
         // Note that it does not hurt to override them even if you compile
         // for another platform; if you don't specify "virtual" the code
@@ -121,4 +122,8 @@ namespace Gosu
     };
 }
 
+#ifdef GOSU_IS_IPHONE
+Gosu::Window& windowInstance();
+#endif
+
 #endif

data/GosuImpl/Graphics/BitmapFreeImage.cpp

@@ -32,10 +32,23 @@ namespace
         for (int i = bitmap.width() * bitmap.height(); i > 0; --i, ++p)
             *p = (*p & 0xff00ff00) | ((*p << 16) & 0x00ff0000) | ((*p >> 16) & 0x000000ff);
     }
+
+    FIBITMAP* ensure32bits(FIBITMAP* fib)
+    {
+        int bpp = FreeImage_GetBPP(fib);
+        FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(fib);
+        if (bpp != 32 && (image_type == FIT_BITMAP || image_type == FIT_RGBA16)) {
+            FIBITMAP* fib32 = FreeImage_ConvertTo32Bits(fib);
+            FreeImage_Unload(fib);
+            fib = fib32;
+        }
+        return fib;
+    }
     
     void fibToBitmap(Gosu::Bitmap& bitmap, FIBITMAP* fib, FREE_IMAGE_FORMAT fif)
     {
         bitmap.resize(FreeImage_GetWidth(fib), FreeImage_GetHeight(fib));
+        fib = ensure32bits(fib);
         FreeImage_ConvertToRawBits(reinterpret_cast<BYTE*>(bitmap.data()),
             fib, bitmap.width() * 4, 32,
             FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK, TRUE);

data/GosuImpl/Graphics/ClipRectStack.hpp

@@ -76,13 +76,6 @@ public:
         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;

data/GosuImpl/Graphics/Common.hpp

@@ -58,7 +58,7 @@ namespace Gosu
     struct DrawOp;
     class DrawOpQueue;
     typedef std::list<Transform> Transforms;
-    typedef std::vector<DrawOpQueue> DrawOpQueueStack;
+    typedef std::list<DrawOpQueue> DrawOpQueueStack;
     class Macro;
     struct ArrayVertex
     {

data/GosuImpl/Graphics/DrawOpQueue.hpp

@@ -3,6 +3,7 @@
 
 #include <Gosu/TR1.hpp>
 #include <GosuImpl/Graphics/Common.hpp>
+#include <GosuImpl/Graphics/TransformStack.hpp>
 #include <GosuImpl/Graphics/ClipRectStack.hpp>
 #include <GosuImpl/Graphics/DrawOp.hpp>
 #include <cassert>
@@ -12,8 +13,7 @@
 
 class Gosu::DrawOpQueue
 {
-    Transforms individualTransforms;
-    Transforms absoluteTransforms;
+    TransformStack transformStack;
     ClipRectStack clipRectStack;
     
     typedef std::vector<DrawOp> DrawOps;
@@ -21,31 +21,7 @@ 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:
-    DrawOpQueue()
-    {
-        // 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)
     {
         if (clipRectStack.clippedWorldAway())
@@ -56,7 +32,7 @@ public:
         assert (op.verticesOrBlockIndex == 4);
         #endif
         
-        op.renderState.transform = &currentTransform();
+        op.renderState.transform = &transformStack.current();
         if (const ClipRect* cr = clipRectStack.maybeEffectiveRect())
             op.renderState.clipRect = *cr;
         ops.push_back(op);
@@ -73,7 +49,7 @@ public:
         
         DrawOp op;
         op.verticesOrBlockIndex = complementOfBlockIndex;
-        op.renderState.transform = &currentTransform();
+        op.renderState.transform = &transformStack.current();
         if (const ClipRect* cr = clipRectStack.maybeEffectiveRect())
             op.renderState.clipRect = *cr;
         op.z = z;
@@ -87,8 +63,8 @@ public:
         double left = x, right = x + width;
         double top = y, bottom = y + height;
         
-        applyTransform(currentTransform(), left, top);
-        applyTransform(currentTransform(), right, bottom);
+        applyTransform(transformStack.current(), left, top);
+        applyTransform(transformStack.current(), right, bottom);
         
         int physX = std::min(left, right);
         int physY = std::min(top, bottom);
@@ -110,31 +86,17 @@ public:
     
     void setBaseTransform(const Transform& baseTransform)
     {
-        assert (individualTransforms.size() == 1);
-        assert (absoluteTransforms.size() == 1);
-        
-        individualTransforms.front() = absoluteTransforms.front() = baseTransform;
+        transformStack.setBaseTransform(baseTransform);
     }
     
     void pushTransform(const Transform& transform)
     {
-        individualTransforms.push_back(transform);
-        Transform result = multiply(transform, currentTransform());
-        makeCurrentTransform(result);
+        transformStack.push(transform);
     }
     
     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);
+        transformStack.pop();
     }
     
     void performDrawOpsAndCode()
@@ -185,17 +147,21 @@ public:
             op->compileTo(vas);
     }
     
-    void clear()
+    // This retains the current stack of transforms and clippings.
+    void clearQueue()
     {
-        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();
     }
+    
+    // This clears the queue and starts with new stacks. This must not be called
+    // when endClipping/popTransform calls might still be pending.
+    void reset()
+    {
+        transformStack.reset();
+        clipRectStack.clear();
+        clearQueue();
+    }
 };
 
 #endif

data/GosuImpl/Graphics/GosuView.mm

@@ -36,7 +36,7 @@ int Gosu::clipRectBaseFactor()
 }
 
 - (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation {
-    return NO;//UIInterfaceOrientationIsLandscape(interfaceOrientation);
+    return NO;
 }
 
 - (void)didReceiveMemoryWarning {

data/GosuImpl/Graphics/Graphics.cpp

@@ -52,20 +52,9 @@ struct Gosu::Graphics::Impl
         }
     }
     
-    Orientation orientation;
-    
-    Impl()
-    : orientation(currentOrientation())
-    {
-    }
-    
     void updateBaseTransform()
     {
-        if (orientation != currentOrientation())
-        {
-            orientation = currentOrientation();
-            queues.front().setBaseTransform(transformForOrientation(orientation));
-        }
+        queues.front().setBaseTransform(transformForOrientation(currentOrientation()));
     }
 #endif
 };
@@ -127,9 +116,8 @@ void Gosu::Graphics::setResolution(unsigned virtualWidth, unsigned virtualHeight
         throw std::invalid_argument("Invalid virtual resolution.");
     
     pimpl->virtWidth = virtualWidth, pimpl->virtHeight = virtualHeight;
-    #ifdef GOSU_IS_IPHONE
-    pimpl->orientation = static_cast<Orientation>(-1);
-    #else
+    #ifndef GOSU_IS_IPHONE
+    // on the iPhone, updateCurrentTransform will handle this (yuck)
     Transform baseTransform;
     baseTransform = scale(1.0 / virtualWidth  * pimpl->physWidth,
                           1.0 / virtualHeight * pimpl->physHeight);
@@ -142,8 +130,8 @@ bool Gosu::Graphics::begin(Gosu::Color clearWithColor)
     // If recording is in process, cancel it.
     assert (pimpl->queues.size() == 1);
     pimpl->queues.resize(1);
-    // Clear leftover clippings.
-    pimpl->queues.front().clear();
+    // Clear leftover transforms, clip rects etc.
+    pimpl->queues.front().reset();
     
     #ifdef GOSU_IS_IPHONE
     pimpl->updateBaseTransform();
@@ -172,7 +160,7 @@ void Gosu::Graphics::flush()
         throw std::logic_error("Flushing to screen is not allowed while creating a macro");
     
     pimpl->queues.front().performDrawOpsAndCode();
-    pimpl->queues.front().clear();
+    pimpl->queues.front().clearQueue();
 }
 
 void Gosu::Graphics::beginGL()

data/GosuImpl/Graphics/Image.cpp

@@ -111,3 +111,38 @@ Gosu::ImageData& Gosu::Image::getData() const
 {
     return *data;
 }
+
+std::vector<Gosu::Image> Gosu::loadTiles(Graphics& graphics, const Bitmap& bmp, int tileWidth, int tileHeight, bool tileable)
+{
+    int tilesX, tilesY;
+    std::vector<Image> images;
+    
+    if (tileWidth > 0)
+        tilesX = bmp.width() / tileWidth;
+    else
+    {
+        tilesX = -tileWidth;
+        tileWidth = bmp.width() / tilesX;
+    }
+    
+    if (tileHeight > 0)
+        tilesY = bmp.height() / tileHeight;
+    else
+    {
+        tilesY = -tileHeight;
+        tileHeight = bmp.height() / tilesY;
+    }
+    
+    for (int y = 0; y < tilesY; ++y)
+        for (int x = 0; x < tilesX; ++x)
+            images.push_back(Image(graphics, bmp, x * tileWidth, y * tileHeight, tileWidth, tileHeight, tileable));
+    
+    return images;
+}
+
+std::vector<Gosu::Image> Gosu::loadTiles(Graphics& graphics, const std::wstring& filename, int tileWidth, int tileHeight, bool tileable)
+{
+    Bitmap bmp;
+    loadImageFile(bmp, filename);
+    return loadTiles(graphics, bmp, tileWidth, tileHeight, tileable);
+}

data/GosuImpl/Graphics/RenderState.hpp

@@ -8,7 +8,7 @@
 struct Gosu::RenderState
 {
     GLuint texName;
-    Transform* transform;
+    const Transform* transform;
     ClipRect clipRect;
     AlphaMode mode;
     
@@ -126,16 +126,19 @@ public:
     
         if (newTexName != NO_TEXTURE)
         {
+            // New texture *is* really a texture - change to it.
+            
             if (texName == NO_TEXTURE)
                 glEnable(GL_TEXTURE_2D);
             glBindTexture(GL_TEXTURE_2D, newTexName);
         }
-        else if (texName != NO_TEXTURE)
+        else
+            // New texture is NO_TEXTURE, disable texturing.
             glDisable(GL_TEXTURE_2D);
         texName = newTexName;
     }
     
-    void setTransform(Transform* newTransform)
+    void setTransform(const Transform* newTransform)
     {
         if (newTransform == transform)
             return;

data/GosuImpl/Graphics/TransformStack.hpp

@@ -0,0 +1,100 @@
+#ifndef GOSUIMPL_GRAPHICS_TRANSFORMSTACK_HPP
+#define GOSUIMPL_GRAPHICS_TRANSFORMSTACK_HPP
+
+#include <GosuImpl/Graphics/Common.hpp>
+#include <cassert>
+#include <algorithm>
+
+namespace Gosu
+{
+    class TransformStack
+    {
+        // All the matrices that are pushed right now.
+        Transforms individual;
+        // All the absolute matrices that have been created since last reset.
+        Transforms absolute;
+        // Points to one absolute transform.
+        Transforms::const_iterator currentIterator;
+        
+        void makeCurrent(const Transform& transform)
+        {
+            currentIterator =
+                std::find(absolute.begin(), absolute.end(), transform);
+            if (currentIterator == absolute.end())
+                currentIterator = absolute.insert(absolute.end(), transform);
+        }
+        
+    public:
+        TransformStack()
+        {
+            reset();
+            individual.front() = absolute.front() = scale(1);
+        }
+                
+        void reset()
+        {
+            // 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.
+            individual.resize(1);
+            absolute.resize(1);
+            currentIterator = absolute.begin();
+        }
+        
+        TransformStack(const TransformStack& other)
+        {
+            *this = other;
+        }
+        
+        // Custom assignment to ensure valid currentIterator
+        TransformStack& operator=(const TransformStack &other)
+        {
+            individual = other.individual;
+            absolute = other.absolute;
+            
+            // Reset our currentIterator to point to the respective element
+            // in our own 'absolute' transforms by iterating both lists up to
+            // the other lists' current iterator
+            currentIterator = absolute.begin();
+            Transforms::const_iterator otherIterator = other.absolute.begin();
+            while (otherIterator != other.currentIterator)
+                ++currentIterator, ++otherIterator;
+            
+            return *this;
+        }
+        
+        void setBaseTransform(const Transform& baseTransform)
+        {
+            assert (individual.size() == 1);
+            assert (absolute.size() == 1);
+            
+            individual.front() = absolute.front() = baseTransform;
+        }
+        
+        const Transform& current()
+        {
+            return *currentIterator;
+        }
+        
+        void push(const Transform& transform)
+        {
+            individual.push_back(transform);
+            Transform result = multiply(transform, current());
+            makeCurrent(result);
+        }
+        
+        void pop()
+        {
+            assert (individual.size() > 1);
+            
+            individual.pop_back();
+            Transform result = scale(1);
+            for (Transforms::reverse_iterator it = individual.rbegin(),
+                    end = individual.rend(); it != end; ++it)
+                result = multiply(result, *it);
+            makeCurrent(result);
+        }
+    };
+}
+
+#endif

data/GosuImpl/InputTouch.mm

@@ -1,10 +1,10 @@
 #include <Gosu/Input.hpp>
 #include <Gosu/TextInput.hpp>
 
-#import <GosuImpl/MacUtility.hpp>
-#import <GosuImpl/Orientation.hpp>
-#import <GosuImpl/Graphics/GosuView.hpp>
-#import <GosuImpl/Input/AccelerometerReader.hpp>
+#include <GosuImpl/MacUtility.hpp>
+#include <GosuImpl/Orientation.hpp>
+#include <GosuImpl/Input/AccelerometerReader.hpp>
+#import <UIKit/UIKit.h>
 
 struct Gosu::TextInput::Impl {};
 Gosu::TextInput::TextInput() {}
@@ -14,8 +14,10 @@ void Gosu::TextInput::setText(const std::wstring& text) {}
 unsigned Gosu::TextInput::caretPos() const { return 0; }
 unsigned Gosu::TextInput::selectionStart() const { return 0; }
 
-struct Gosu::Input::Impl {
-    GosuView* view;
+struct Gosu::Input::Impl
+{
+    UIView* view;
+    float mouseX, mouseY;
     float factorX, factorY;
     float updateInterval;
     
@@ -52,13 +54,15 @@ struct Gosu::Input::Impl {
 Gosu::Input::Input(void* view, float updateInterval)
 : pimpl(new Impl)
 {
-    pimpl->view = (GosuView*)view;
+    pimpl->view = (UIView*)view;
     pimpl->updateInterval = updateInterval;
     pimpl->currentTouchesSet.reset([[NSMutableSet alloc] init]);
+    pimpl->mouseX = pimpl->mouseY = -1000;
     setMouseFactors(1, 1);
 }
 
-Gosu::Input::~Input() {
+Gosu::Input::~Input()
+{
 }
 
 void Gosu::Input::feedTouchEvent(int type, void* touches)
@@ -76,27 +80,34 @@ void Gosu::Input::feedTouchEvent(int type, void* touches)
             (*f)(pimpl->translateTouch(uiTouch));        
 }
 
-wchar_t Gosu::Input::idToChar(Button btn) {
+wchar_t Gosu::Input::idToChar(Button btn)
+{
     return 0;
 }
 
-Gosu::Button Gosu::Input::charToId(wchar_t ch) {
+Gosu::Button Gosu::Input::charToId(wchar_t ch)
+{
     return noButton;
 }
         
-bool Gosu::Input::down(Button btn) const {
+bool Gosu::Input::down(Button btn) const
+{
     return false;
 }
 
-double Gosu::Input::mouseX() const {
-    return -1000;
+double Gosu::Input::mouseX() const
+{
+    return pimpl->mouseX;
 }
 
-double Gosu::Input::mouseY() const {
-    return -1000;
+double Gosu::Input::mouseY() const
+{
+    return pimpl->mouseY;
 }
 
 void Gosu::Input::setMousePosition(double x, double y) {
+    pimpl->mouseX = x;
+    pimpl->mouseY = y;
 }
 
 void Gosu::Input::setMouseFactors(double factorX, double factorY) {
@@ -115,19 +126,23 @@ const Gosu::Touches& Gosu::Input::currentTouches() const
     return *pimpl->currentTouchesVector;
 }
 
-double Gosu::Input::accelerometerX() const {
+double Gosu::Input::accelerometerX() const
+{
     return pimpl->acceleration(0);
 }
 
-double Gosu::Input::accelerometerY() const {
+double Gosu::Input::accelerometerY() const
+{
     return pimpl->acceleration(1);
 }
 
-double Gosu::Input::accelerometerZ() const {
+double Gosu::Input::accelerometerZ() const
+{
     return pimpl->acceleration(2);
 }
 
-void Gosu::Input::update() {
+void Gosu::Input::update()
+{
     // Check for dead touches and remove from vector if
     // necessary
 
@@ -140,7 +155,7 @@ void Gosu::Input::update() {
             phase == UITouchPhaseMoved ||
             phase == UITouchPhaseStationary)
             continue;
-            
+        
         // Something was deleted, we will need the set.
         if (!deadTouches.get())
             deadTouches.reset([[NSMutableSet alloc] init]);
@@ -158,10 +173,12 @@ void Gosu::Input::update() {
     }
 }
 
-Gosu::TextInput* Gosu::Input::textInput() const {
+Gosu::TextInput* Gosu::Input::textInput() const
+{
     return 0;
 }
 
-void Gosu::Input::setTextInput(TextInput* input) {
+void Gosu::Input::setTextInput(TextInput* input)
+{
     throw "NYI";
 }

data/GosuImpl/Orientation.mm

@@ -19,8 +19,8 @@ Gosu::Orientation Gosu::currentOrientation()
     
     static Orientation orientation = Gosu::Orientation(-1);
     static unsigned waitingForChangeSince = now;
-
-    if (!UIDeviceOrientationIsLandscape(newOrientation) || orientationToGosu(newOrientation) == orientation)
+    
+    if (not UIDeviceOrientationIsLandscape(newOrientation) or orientationToGosu(newOrientation) == orientation)
         waitingForChangeSince = now;
     
     if (now - waitingForChangeSince >= CHANGE_AFTER_MS or orientation == Gosu::Orientation(-1))

data/GosuImpl/RubyGosu.swg

@@ -158,6 +158,7 @@
 #undef close
 #undef read
 #undef bind
+#undef send
 #undef sleep
 #undef Sleep
 #undef int8_t
@@ -173,23 +174,7 @@
 //#include <Gosu/Async.hpp>
 //#endif
 
-#include <Gosu/Audio.hpp>
-#include <Gosu/Color.hpp>
-#include <Gosu/Font.hpp>
-#include <Gosu/GraphicsBase.hpp>
-#include <Gosu/Graphics.hpp>
-#include <Gosu/Image.hpp>
-#include <Gosu/ImageData.hpp>
-#include <Gosu/Inspection.hpp>
-#include <Gosu/Input.hpp>
-#include <Gosu/IO.hpp>
-#include <Gosu/Math.hpp>
-#include <Gosu/Text.hpp>
-#include <Gosu/TextInput.hpp>
-#include <Gosu/Timing.hpp>
-#include <Gosu/Utility.hpp>
-#include <Gosu/Version.hpp>
-#include <Gosu/Window.hpp>
+#include <Gosu/Gosu.hpp>
 #ifdef GOSU_IS_WIN
 #include <FreeImage.h>
 #endif
@@ -521,6 +506,7 @@ namespace Gosu {
 %ignore Gosu::Image::Image(Graphics& graphics, const Bitmap& source, bool tileable = false);
 %ignore Gosu::Image::Image(Graphics& graphics, const Bitmap& source, unsigned srcX, unsigned srcY, unsigned srcWidth, unsigned srcHeight, bool tileable = false);
 %ignore Gosu::Image::Image(std::auto_ptr<ImageData> data);
+%ignore Gosu::loadTiles;
 %include "../Gosu/Image.hpp"
 %extend Gosu::Image {
     Image(Gosu::Window& window, VALUE source, bool tileable = false) {

data/GosuImpl/RubyGosu_wrap.cxx

@@ -2208,6 +2208,7 @@ static VALUE mGosu;
 #undef close
 #undef read
 #undef bind
+#undef send
 #undef sleep
 #undef Sleep
 #undef int8_t
@@ -2223,23 +2224,7 @@ static VALUE mGosu;
 //#include <Gosu/Async.hpp>
 //#endif
 
-#include <Gosu/Audio.hpp>
-#include <Gosu/Color.hpp>
-#include <Gosu/Font.hpp>
-#include <Gosu/GraphicsBase.hpp>
-#include <Gosu/Graphics.hpp>
-#include <Gosu/Image.hpp>
-#include <Gosu/ImageData.hpp>
-#include <Gosu/Inspection.hpp>
-#include <Gosu/Input.hpp>
-#include <Gosu/IO.hpp>
-#include <Gosu/Math.hpp>
-#include <Gosu/Text.hpp>
-#include <Gosu/TextInput.hpp>
-#include <Gosu/Timing.hpp>
-#include <Gosu/Utility.hpp>
-#include <Gosu/Version.hpp>
-#include <Gosu/Window.hpp>
+#include <Gosu/Gosu.hpp>
 #ifdef GOSU_IS_WIN
 #include <FreeImage.h>
 #endif
@@ -11243,8 +11228,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 >(40)));
-  rb_define_const(mGosu, "VERSION", SWIG_FromCharPtr("0.7.40"));
+  rb_define_const(mGosu, "POINT_VERSION", SWIG_From_int(static_cast< int >(41)));
+  rb_define_const(mGosu, "VERSION", SWIG_FromCharPtr("0.7.41"));
   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/WindowTouch.mm

@@ -13,27 +13,41 @@ using namespace std::tr1::placeholders;
 
 namespace Gosu
 {
-    CGRect screenRect = [[UIScreen mainScreen] bounds];
+    static CGRect &screenRect()
+    {
+        static CGRect screenRect = [[UIScreen mainScreen] bounds];
+        return screenRect;
+    }
     
     unsigned screenWidth()
     {
-        return screenRect.size.width;
+        return screenRect().size.width;
     }
     
     unsigned screenHeight()
     {
-        return screenRect.size.height;
+        return screenRect().size.height;
     }
 }
 
-int main(int argc, char *argv[]) {
-    [[NSAutoreleasePool alloc] init];
-	return UIApplicationMain(argc, argv, nil, @"GosuAppDelegate");
+int main(int argc, char *argv[])
+{
+    try
+    {
+        [[NSAutoreleasePool alloc] init];
+        return UIApplicationMain(argc, argv, nil, @"GosuAppDelegate");
+    }
+    catch (const std::exception& e)
+    {
+        NSLog(@"Terminating due to C++ exception: %s", e.what());
+        throw;
+    }
 }
 
 class Gosu::Audio {};
 
-struct Gosu::Window::Impl {
+struct Gosu::Window::Impl
+{
     ObjRef<UIWindow> window;
     ObjRef<GosuViewController> controller;
     std::auto_ptr<Graphics> graphics;
@@ -57,27 +71,22 @@ namespace
 
 @implementation GosuAppDelegate
 // Required according to docs...
-- (void)applicationProtectedDataWillBecomeUnavailable:(UIApplication *)application
-{
+- (void)applicationProtectedDataWillBecomeUnavailable:(UIApplication *)application {
 }
 
 // Required according to docs...
-- (void)applicationProtectedDataDidBecomeAvailable:(UIApplication *)application
-{
+- (void)applicationProtectedDataDidBecomeAvailable:(UIApplication *)application {
 }
 
 // Required according to docs...
-- (void)application:(UIApplication *)application didReceiveLocalNotification:(UILocalNotification *)notification
-{
+- (void)application:(UIApplication *)application didReceiveLocalNotification:(UILocalNotification *)notification {
 }
 
 - (void)applicationDidFinishLaunching:(UIApplication *)application {
     [UIDevice.currentDevice beginGeneratingDeviceOrientationNotifications];
-    UIApplication.sharedApplication.idleTimerDisabled = YES;
+    //UIApplication.sharedApplication.idleTimerDisabled = YES;
     UIApplication.sharedApplication.statusBarOrientation = UIInterfaceOrientationLandscapeRight;
-    
-    windowInstance();
-    
+        
     [[NSTimer scheduledTimerWithTimeInterval: windowInstance().updateInterval() / 1000.0
               target: self
               selector: @selector(doTick:)
@@ -139,11 +148,13 @@ Gosu::Window::~Window()
 {
 }
 
-std::wstring Gosu::Window::caption() const {
+std::wstring Gosu::Window::caption() const
+{
     return L"";
 }
 
-void Gosu::Window::setCaption(const std::wstring& caption) {
+void Gosu::Window::setCaption(const std::wstring& caption)
+{
 }
 
 double Gosu::Window::updateInterval() const
@@ -151,27 +162,33 @@ double Gosu::Window::updateInterval() const
     return pimpl->interval;
 }
 
-const Gosu::Graphics& Gosu::Window::graphics() const {
+const Gosu::Graphics& Gosu::Window::graphics() const
+{
     return *pimpl->graphics;
 }
 
-Gosu::Graphics& Gosu::Window::graphics() {
+Gosu::Graphics& Gosu::Window::graphics()
+{
     return *pimpl->graphics;
 }
 
-const Gosu::Audio& Gosu::Window::audio() const {
+const Gosu::Audio& Gosu::Window::audio() const
+{
     return *pimpl->audio;
 }
 
-Gosu::Audio& Gosu::Window::audio() {
+Gosu::Audio& Gosu::Window::audio()
+{
     return *pimpl->audio;
 }
 
-const Gosu::Input& Gosu::Window::input() const {
+const Gosu::Input& Gosu::Window::input() const
+{
     return *pimpl->input;
 }
 
-Gosu::Input& Gosu::Window::input() {
+Gosu::Input& Gosu::Window::input()
+{
     return *pimpl->input;
 }
 
@@ -183,3 +200,8 @@ void Gosu::Window::close()
 {
     throw std::logic_error("Cannot close windows manually on iOS");
 }
+
+void* Gosu::Window::rootViewController() const
+{
+    return pimpl->controller.get();
+}

data/linux/extconf.rb

@@ -68,7 +68,7 @@ if `uname`.chomp == 'Darwin' then
   # Apple curiously distributes libpng only inside X11
   $INCFLAGS << " -I/usr/X11/include"
   # To make everything work with the Objective C runtime
-  $CFLAGS   << " -x objective-c++ -fobjc-gc"
+  $CFLAGS   << " -x objective-c++ -fobjc-gc -DNDEBUG"
   $LDFLAGS  << " -L/usr/X11/lib -logg -lvorbis -lvorbisfile -liconv"
   %w(AudioToolbox IOKit OpenAL OpenGL AppKit ApplicationServices Foundation Carbon).each do |f|
     #$INCFLAGS << " -framework #{f}" <- not necessary? I only get lots of warnings

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: gosu
 version: !ruby/object:Gem::Version 
-  hash: 83
+  hash: 81
   prerelease: 
   segments: 
   - 0
   - 7
-  - 40
-  version: 0.7.40
+  - 41
+  version: 0.7.41
 platform: ruby
 authors: 
 - Julian Raschke
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-19 00:00:00 Z
+date: 2011-12-17 00:00:00 Z
 dependencies: []
 
 description: "  2D game development library.\n\n  Gosu features easy to use and game-friendly interfaces to 2D graphics\n  and text (accelerated by 3D hardware), sound samples and music as well as\n  keyboard, mouse and gamepad/joystick input.\n\n  Also includes demos for integration with RMagick, Chipmunk and OpenGL.\n"
@@ -138,6 +138,7 @@ files:
 - GosuImpl/Graphics/Texture.hpp
 - GosuImpl/Graphics/TextWin.cpp
 - GosuImpl/Graphics/Transform.cpp
+- GosuImpl/Graphics/TransformStack.hpp
 - GosuImpl/Iconv.hpp
 - GosuImpl/Input/AccelerometerReader.hpp
 - GosuImpl/Input/AccelerometerReader.mm