gosu 0.7.27.1 → 0.7.28

data/{COPYING.txt → COPYING}

@@ -18,14 +18,17 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 DEALINGS IN THE SOFTWARE.
 
-Julian Raschke julian@raschke.de
+                  Julian Raschke  julian@raschke.de
+                  Jan Lücker     jan.luecker@gmx.de
+                        http://www.libgosu.org/
 
-Jan Lücker jan.luecker@gmx.de
-
-http://www.libgosu.org/
-
-***
+                                  ***
 
 This does NOT apply to audiere.dll shipped with the Windows versions of
 Gosu. Audiere is a separate library licensed under the Lesser General
-Public License. Please consult audiere.sf.net for more details.
+Public License. Please consult http://audiere.sf.net/ for more details.
+
+This does also NOT apply to libogg and libvorbis, which are included in
+all source and binary distributions of Gosu, sometimes via audiere. These
+projects are licensed under a BSD-like license, and their copyright terms
+need to be supplied even with binary redistributions (e.g. Gosu games).

data/Gosu/Bitmap.hpp

@@ -68,18 +68,20 @@ namespace Gosu
     Reader loadFromPNG(Bitmap& bmp, Reader reader);
     //! Saves the contents of the given bitmap into PNG file data, 24 bits.
     Writer saveToPNG(const Bitmap& bmp, Writer writer);
-
+    
     //! Set the alpha value of all pixels which are equal to the color key
     //! to zero. Color values are adjusted so that no borders show up when
     //! the image is stretched or rotated.
     void applyColorKey(Bitmap& bitmap, Color key);
-
+    
     void applyBorderFlags(Bitmap& dest, const Bitmap& source,
         unsigned srcX, unsigned srcY, unsigned srcWidth, unsigned srcHeight,
         unsigned borderFlags);	
-
-	// Still to be moved around & undocumented, beware! (TODO)
-	Bitmap quickLoadBitmap(const std::wstring& filename);
+    
+	//! Loads any supported image into a Bitmap object.
+	Bitmap loadImageFile(const std::wstring& filename);
+	//! Loads any supported image into a Bitmap object.
+	Bitmap loadImageFile(Gosu::Reader input);
 }
 
 #endif

data/Gosu/Image.hpp

@@ -77,7 +77,7 @@ namespace Gosu
             AlphaMode mode = amDefault) const;
 
         //! Provides access to the underlying image data object.
-        const ImageData& getData() const;
+        ImageData& getData() const;
     };
 
 	//! Convenience function that splits a BMP or PNG file into an array
@@ -92,7 +92,7 @@ namespace Gosu
     void imagesFromTiledBitmap(Graphics& graphics, const std::wstring& filename,
         int tileWidth, int tileHeight, bool tileable, Container& appendTo)
     {
-		imagesFromTiledBitmap(graphics, quickLoadBitmap(filename), tileWidth, tileHeight, tileable, appendTo);
+		imagesFromTiledBitmap(graphics, loadImageFile(filename), tileWidth, tileHeight, tileable, appendTo);
     }
 
     //! Convenience function that splits a bitmap into an area of array 

data/Gosu/ImageData.hpp

@@ -43,6 +43,9 @@ namespace Gosu
             
         virtual boost::optional<GLTexInfo> glTexInfo() const = 0;
         virtual Bitmap toBitmap() const = 0;
+        
+        //! Experimental and undocumented for now.
+        virtual void insert(const Bitmap& bitmap, int x, int y) = 0;
     };
 }
 

data/Gosu/Version.hpp

@@ -3,7 +3,7 @@
 
 #define GOSU_MAJOR_VERSION 0
 #define GOSU_MINOR_VERSION 7
-#define GOSU_POINT_VERSION 27
-#define GOSU_VERSION "0.7.27.1"
+#define GOSU_POINT_VERSION 28
+#define GOSU_VERSION "0.7.28"
 
 #endif

data/GosuImpl/Graphics/BitmapApple.mm

@@ -0,0 +1,132 @@
+#if defined(GOSU_IS_IPHONE) || defined(__LP64__)
+
+#include <Gosu/Graphics.hpp>
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/IO.hpp>
+#include <Gosu/Platform.hpp>
+#include <Gosu/Utility.hpp>
+#include <GosuImpl/MacUtility.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/lexical_cast.hpp>
+#include <stdexcept>
+
+#ifdef GOSU_IS_IPHONE
+#import <UIKit/UIKit.h>
+#else
+#import <AppKit/AppKit.h>
+#endif
+
+namespace Gosu
+{
+    void CGImageToBitmap(CGImageRef imageRef, Bitmap& bitmap)
+    {
+        bitmap.resize(CGImageGetWidth(imageRef), CGImageGetHeight(imageRef));
+        
+        static CFRef<CGColorSpaceRef> colorSpace(CGColorSpaceCreateDeviceRGB());
+        
+        // Use a temporary context to draw the CGImage to the buffer.
+        CFRef<CGContextRef> context(CGBitmapContextCreate(bitmap.data(), bitmap.width(), bitmap.height(),
+                                        8, bitmap.width() * 4, colorSpace.obj(), kCGImageAlphaPremultipliedLast));
+        CGContextDrawImage(context.obj(), CGRectMake(0.0, 0.0, bitmap.width(), bitmap.height()), imageRef);
+    }
+
+    #ifdef GOSU_IS_IPHONE
+    #define APPLE_IMAGE UIImage
+    void appleImageToBitmap(UIImage* image, Bitmap& bitmap)
+    {
+        CGImageToBitmap([image CGImage], bitmap);
+    }
+    #else
+    #define APPLE_IMAGE NSImage
+    void appleImageToBitmap(NSImage* image, Bitmap& bitmap)
+    {
+        //#ifdef __LP64__
+        CGImageToBitmap([image CGImageForProposedRect:NULL context:nil hints:nil], bitmap);
+        //#else
+        
+        // The code below causes colors to be slightly off on my machine (64-bit, 10.6), but should
+        // do the same thing and work on 10.4 & 10.5.
+        // This may be due to http://stackoverflow.com/questions/2239785/nsimage-color-shift-on-snow-leopard
+        // TODO: As soon as I have a 10.4/10.5 machine to verify, use above code on 10.6 and the code
+        // below otherwise. If it works, BitmapBMP and BitmapPNG can be kicked out on OS X.
+        
+        // id anyRep = [image bestRepresentationForDevice:nil];
+        // if (![anyRep isKindOfClass:[NSBitmapImageRep class]])
+        //     throw std::logic_error("Cannot read vector graphics files");
+        // NSBitmapImageRep* rep = (NSBitmapImageRep*)anyRep;
+        // 
+        // bitmap.resize([rep pixelsWide], [rep pixelsHigh]);
+        // 
+        // CFRef<CGColorSpaceRef> colorSpace(CGColorSpaceCreateWithName(kCGColorSpaceGenericRGBLinear));
+        // 
+        // // Use a temporary context to draw the NSImage to the buffer.
+        // CFRef<CGContextRef> context(CGBitmapContextCreate(bitmap.data(), bitmap.width(), bitmap.height(),
+        //                             8, bitmap.width() * 4,
+        //                             colorSpace.obj(), kCGImageAlphaPremultipliedLast)); // kCGBitmapByteOrder32Host?
+        // [NSGraphicsContext saveGraphicsState];
+        // [NSGraphicsContext setCurrentContext:[NSGraphicsContext graphicsContextWithGraphicsPort:context.obj() flipped:NO]];
+        // [image drawInRect:NSMakeRect(0, 0, bitmap.width(), bitmap.height()) fromRect:NSZeroRect operation:NSCompositeCopy fraction:1.0];
+        // [NSGraphicsContext restoreGraphicsState];
+        //#endif
+    }
+    #endif
+}
+
+Gosu::Reader Gosu::loadFromBMP(Bitmap& bitmap, Reader reader)
+{
+    return loadFromPNG(bitmap, reader);
+}
+
+Gosu::Reader Gosu::loadFromPNG(Bitmap& bitmap, Reader reader)
+{
+    ObjRef<NSAutoreleasePool> pool([NSAutoreleasePool new]);
+
+    std::size_t length = reader.resource().size() - reader.position();
+    ObjRef<NSMutableData> buffer([[NSMutableData alloc] initWithLength: length]);
+    reader.read([buffer.get() mutableBytes], length);
+    
+    ObjRef<APPLE_IMAGE> image([[APPLE_IMAGE alloc] initWithData: buffer.get()]);
+    appleImageToBitmap(image.obj(), bitmap);    
+    return reader;
+}
+
+// OS X still completely uses the libpng based saveToPNG.
+#ifdef GOSU_IS_IPHONE
+Gosu::Writer Gosu::saveToPNG(const Bitmap& bmp, Writer writer)
+{
+    ObjRef<NSAutoreleasePool> pool([NSAutoreleasePool new]);
+
+    CGDataProviderRef dataProvider =
+        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,
+                      kCGImageAlphaLast, dataProvider, 0, false, kCGRenderingIntentDefault);
+
+    ObjRef<UIImage> image([[UIImage alloc] initWithCGImage: imageRef]);
+    
+    NSData* pngRef = UIImagePNGRepresentation(image.get());
+    writer.write([pngRef bytes], [pngRef length]);
+    image.reset();
+    
+    CGImageRelease(imageRef);
+
+    CGDataProviderRelease(dataProvider);
+    
+    return writer;
+}
+#endif
+
+Gosu::Bitmap Gosu::loadImageFile(const std::wstring& filename)
+{
+    ObjRef<NSString> filenameRef([[NSString alloc] initWithUTF8String: wstringToUTF8(filename).c_str()]);
+    ObjRef<APPLE_IMAGE> image([[APPLE_IMAGE alloc] initWithContentsOfFile: filenameRef.obj()]);
+    Bitmap bitmap;
+    appleImageToBitmap(image.obj(), bitmap);
+    if (boost::iends_with(filename, L".bmp"))
+        applyColorKey(bitmap, Color::FUCHSIA);
+    return bitmap;
+}
+#endif

data/GosuImpl/Graphics/BitmapBMP.cpp

@@ -5,7 +5,8 @@
 #include <boost/integer.hpp>
 #include <stdexcept>
 
-#ifndef GOSU_IS_IPHONE
+// iOS does not include this file, OS X 64-bit uses NSImage/ImageIO instead.
+#if !defined(GOSU_IS_MAC) || (!defined(GOSU_IS_IPHONE) && !defined(__LP64__))
 
 namespace 
 {

data/GosuImpl/Graphics/BitmapPNG.cpp

@@ -33,6 +33,9 @@ namespace Gosu
     }
 }
 
+// iOS does not include this file, OS X 64-bit uses NSImage/ImageIO instead.
+// OS X does still use saveToPNG though.
+#if !defined(GOSU_IS_MAC) || (!defined(GOSU_IS_IPHONE) && !defined(__LP64__))
 Gosu::Reader Gosu::loadFromPNG(Bitmap& out, Reader reader)
 {    
 #if 0
@@ -83,7 +86,7 @@ Gosu::Reader Gosu::loadFromPNG(Bitmap& out, Reader reader)
         bitDepth = png_get_bit_depth(pngPtr, infoPtr);
 
     png_bytep trans;
-    int numTrans = 0;
+    int numTrans = -1;
     if (png_get_valid(pngPtr, infoPtr, PNG_INFO_tRNS))
         png_get_tRNS(pngPtr, infoPtr, &trans, &numTrans, NULL);
     // This function only understands palette images with a bit depth <= 8 and
@@ -183,11 +186,9 @@ Gosu::Reader Gosu::loadFromPNG(Bitmap& out, Reader reader)
                     }
                     
                     int alpha = 255;
-                    for (int i = 0; i < numTrans; ++i)
-                    {
-                        if (trans[i] == palIndex)
-                            alpha = 0;
-                    }
+                    if (palIndex <= numTrans)
+                        alpha = trans[palIndex];
+                    
                     c.setAlpha(alpha);
                     c.setRed  (palColors[palIndex].red);
                     c.setGreen(palColors[palIndex].green);
@@ -213,6 +214,7 @@ Gosu::Reader Gosu::loadFromPNG(Bitmap& out, Reader reader)
 
     return reader; // TODO: Does this point to the right location?
 }
+#endif
 
 Gosu::Writer Gosu::saveToPNG(const Bitmap& bmp, Writer writer)
 {

data/GosuImpl/Graphics/BitmapUtils.cpp

@@ -3,21 +3,30 @@
 #include <Gosu/IO.hpp>
 #include <Gosu/Platform.hpp>
 
-Gosu::Bitmap Gosu::quickLoadBitmap(const std::wstring& filename)
+// OS X 64-bit and iOS use Apple APIs.
+#if !defined(GOSU_IS_MAC) || (!defined(GOSU_IS_IPHONE) && !defined(__LP64__))
+Gosu::Bitmap Gosu::loadImageFile(const std::wstring& filename)
+{
+	Buffer buffer;
+	loadFile(buffer, filename);
+    return loadImageFile(buffer.frontReader());
+}
+#endif
+
+Gosu::Bitmap Gosu::loadImageFile(Gosu::Reader reader)
 {
-	Buffer buf;
-	loadFile(buf, filename);
 	Bitmap bmp;
 
     char formatTester[2];
-    buf.frontReader().read(formatTester, sizeof formatTester);
+    reader.read(formatTester, sizeof formatTester);
+    reader.setPosition(0);
     if (formatTester[0] == 'B' && formatTester[1] == 'M')
     {
-        loadFromBMP(bmp, buf.frontReader());
+        loadFromBMP(bmp, reader);
         applyColorKey(bmp, Color::FUCHSIA);
     }
     else
-        loadFromPNG(bmp, buf.frontReader());
+        loadFromPNG(bmp, reader);
 	return bmp;
 }
 

data/GosuImpl/Graphics/DrawOpQueue.hpp

@@ -109,7 +109,11 @@ public:
     {
         // Allows us to make some assumptions.
         if (ops.empty())
+        {
+            BOOST_FOREACH (const CodeMap::value_type& fn, code)
+                fn.second();
             return;
+        }
         
         // Apply Z-Ordering.
         std::stable_sort(ops.begin(), ops.end());

data/GosuImpl/Graphics/Graphics.cpp

@@ -297,7 +297,7 @@ std::auto_ptr<Gosu::ImageData> Gosu::Graphics::endRecording()
     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(pimpl->queues.back()));
+    std::auto_ptr<ImageData> result(new Macro(*this, pimpl->queues.back()));
     pimpl->queues.pop_back();
     return result;
 }
@@ -413,16 +413,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, 0, src.width(), src.height(), 0);
+            data = texture->tryAlloc(*this, pimpl->absoluteTransforms, 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, 0, trimmedSrc.width(), trimmedSrc.height(), 0);
+            data = texture->tryAlloc(*this, pimpl->absoluteTransforms, pimpl->queues, texture, trimmedSrc, 0);
         }
         
         if (!data.get())
@@ -454,7 +452,7 @@ std::auto_ptr<Gosu::ImageData> Gosu::Graphics::createImage(
         boost::shared_ptr<Texture> texture(*i);
         
         std::auto_ptr<ImageData> data;
-        data = texture->tryAlloc(*this, pimpl->absoluteTransforms, pimpl->queues, texture, bmp, 0, 0, bmp.width(), bmp.height(), 1);
+        data = texture->tryAlloc(*this, pimpl->absoluteTransforms, pimpl->queues, texture, bmp, 1);
         if (data.get())
             return data;
     }
@@ -466,7 +464,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, 0, 0, bmp.width(), bmp.height(), 1);
+    data = texture->tryAlloc(*this, pimpl->absoluteTransforms, pimpl->queues, texture, bmp, 1);
     if (!data.get())
         throw std::logic_error("Internal texture block allocation error");
 

data/GosuImpl/Graphics/Image.cpp

@@ -8,7 +8,7 @@
 Gosu::Image::Image(Graphics& graphics, const std::wstring& filename, bool tileable)
 {
 	// Forward.
-	Image(graphics, quickLoadBitmap(filename), tileable).data.swap(data);
+	Image(graphics, loadImageFile(filename), tileable).data.swap(data);
 }
 
 Gosu::Image::Image(Graphics& graphics, const std::wstring& filename,
@@ -16,7 +16,7 @@ Gosu::Image::Image(Graphics& graphics, const std::wstring& filename,
     bool tileable)
 {
 	// Forward.
-	Image(graphics, quickLoadBitmap(filename), srcX, srcY, srcWidth, srcHeight, tileable).data.swap(data);
+	Image(graphics, loadImageFile(filename), srcX, srcY, srcWidth, srcHeight, tileable).data.swap(data);
 }
 
 Gosu::Image::Image(Graphics& graphics, const Bitmap& source, bool tileable)
@@ -26,15 +26,15 @@ Gosu::Image::Image(Graphics& graphics, const Bitmap& source, bool tileable)
 }
 
 Gosu::Image::Image(Graphics& graphics, const Bitmap& source,
-    unsigned srcX, unsigned srcY, unsigned srcWidth, unsigned srcHeight,
-    bool tileable)
-: data(graphics.createImage(source, srcX, srcY, srcWidth, srcHeight,
+        unsigned srcX, unsigned srcY, unsigned srcWidth, unsigned srcHeight,
+        bool tileable)
+:   data(graphics.createImage(source, srcX, srcY, srcWidth, srcHeight,
     tileable ? Gosu::bfTileable : Gosu::bfSmooth))
 {
 }
 
 Gosu::Image::Image(std::auto_ptr<ImageData> data)
-: data(data.release())
+:   data(data.release())
 {
 }
 
@@ -103,7 +103,7 @@ void Gosu::Image::drawRot(double x, double y, ZPos z,
                c, z, mode);
 }
 
-const Gosu::ImageData& Gosu::Image::getData() const
+Gosu::ImageData& Gosu::Image::getData() const
 {
     return *data;
 }

data/GosuImpl/Graphics/LargeImageData.cpp

@@ -126,3 +126,10 @@ Gosu::Bitmap Gosu::LargeImageData::toBitmap() const
             bitmap.insert(parts[y * partsX + x]->toBitmap(), x * partWidth, y * partHeight);
     return bitmap;
 }
+
+void Gosu::LargeImageData::insert(const Bitmap& bitmap, int atX, int atY)
+{
+    for (int x = 0; x < partsX; ++x)
+        for (int y = 0; y < partsY; ++y)
+            parts[y * partsX + x]->insert(bitmap, atX - x * partWidth, atY - y * partHeight);
+}

data/GosuImpl/Graphics/LargeImageData.hpp

@@ -33,6 +33,7 @@ namespace Gosu
         }
         
         Bitmap toBitmap() const;
+        void insert(const Bitmap& bitmap, int x, int y);
     };
 }
 

data/GosuImpl/Graphics/Macro.hpp

@@ -5,6 +5,7 @@
 #include <Gosu/ImageData.hpp>
 #include <GosuImpl/Graphics/Common.hpp>
 #include <GosuImpl/Graphics/DrawOpQueue.hpp>
+#include <boost/bind.hpp>
 #include <boost/foreach.hpp>
 #include <boost/scoped_ptr.hpp>
 #include <cmath>
@@ -15,12 +16,14 @@ class Gosu::Macro : public Gosu::ImageData
     VertexArray vertexArray;
     unsigned w, h;
     
+    Graphics& graphics;
 public:
-    Macro(DrawOpQueue& queue)
+    Macro(Graphics& graphics, DrawOpQueue& queue)
+    : graphics(graphics)
     {
         queue.compileTo(vertexArray);
         double left = 0, right = 0, top = 0, bottom = 0;
-        BOOST_FOREACH(const ArrayVertex& av, vertexArray)
+        BOOST_FOREACH (const ArrayVertex& av, vertexArray)
         {
             left = std::min<double>(left, av.vertices[0]);
             right = std::max<double>(right, av.vertices[0]);
@@ -47,27 +50,37 @@ public:
               double x4, double y4, Color c4,
               ZPos z, AlphaMode mode) const
     {
-#ifndef GOSU_IS_IPHONE
-        // Commented out for now on the iPhone.
+        boost::function<void()> f = boost::bind(&Macro::realDraw, this, x1, y1, x2, y2, x3, y3);
+        graphics.scheduleGL(f, z);
+    }
+    
+    void realDraw(double x1, double y1,
+              double x2, double y2,
+              double x3, double y3) const
+    {
+        // 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();
+        //glPushMatrix();
         glTranslated(x1, y1, 0);
         glScaled((x2 - x1) / width(), (y3 - y1) / height(), 1);
         
-        glEnable(GL_TEXTURE_2D);
-        glBindTexture(GL_TEXTURE_2D, 1);
-        
         glInterleavedArrays(GL_T2F_C4UB_V3F, 0, &vertexArray[0]);
 
         glDrawArrays(GL_QUADS, 0, vertexArray.size());
         glFlush();
 
-        glDisable(GL_TEXTURE_2D);
-        
-        glPopMatrix();
-#endif
+        //glPopMatrix();
+    #endif
     }
     
     boost::optional<Gosu::GLTexInfo> glTexInfo() const
@@ -77,7 +90,12 @@ public:
     
     Gosu::Bitmap toBitmap() const
     {
-        throw std::logic_error("Gosu::Macro cannot be rendered to Gosu::Bitmap");
+        throw std::logic_error("Gosu::Macro cannot be rendered as Gosu::Bitmap");
+    }
+    
+    void insert(const Bitmap& bitmap, int x, int y)
+    {
+        throw std::logic_error("Gosu::Macro cannot be updated with a Gosu::Bitmap");
     }
 };
 

data/GosuImpl/Graphics/TexChunk.cpp

@@ -57,3 +57,34 @@ Gosu::Bitmap Gosu::TexChunk::toBitmap() const
 {
     return texture->toBitmap(x, y, w, h);
 }
+
+void Gosu::TexChunk::insert(const Bitmap& original, int x, int y)
+{
+    // TODO: Should respect borderFlags.
+    
+    Bitmap alternate;
+    const Bitmap* bitmap = &original;
+    if (x < 0 || y < 0 || x + original.width() > w || y + original.height() > h)
+    {
+        int offsetX = 0, offsetY = 0, trimmedWidth = original.width(), trimmedHeight = original.height();
+        if (x < 0)
+            offsetX = x, trimmedWidth  += x, x = 0;
+        if (y < 0)
+            offsetY = y, trimmedHeight += y, y = 0;
+        if (x + trimmedWidth > w)
+            trimmedWidth  -= (w - x - trimmedWidth);
+        if (y + trimmedHeight > h)
+            trimmedHeight -= (h - y - trimmedHeight);
+            
+        if (trimmedWidth <= 0 || trimmedHeight <= 0)
+            return;
+        
+        alternate.resize(trimmedWidth, trimmedHeight);
+        alternate.insert(original, offsetX, offsetY);
+        bitmap = &alternate;
+    }
+    
+    glBindTexture(GL_TEXTURE_2D, texture->texName());
+    glTexSubImage2D(GL_TEXTURE_2D, 0, this->x + x, this->y + y, bitmap->width(), bitmap->height(),
+        Color::GL_FORMAT, GL_UNSIGNED_BYTE, bitmap->data());
+}

data/GosuImpl/Graphics/TexChunk.hpp

@@ -56,6 +56,7 @@ public:
         
     boost::optional<GLTexInfo> glTexInfo() const;
     Gosu::Bitmap toBitmap() const;
+    void insert(const Bitmap& bitmap, int x, int y);
 };
 
 #endif

data/GosuImpl/Graphics/Texture.cpp

@@ -62,14 +62,11 @@ GLuint Gosu::Texture::texName() const
 
 std::auto_ptr<Gosu::TexChunk>
     Gosu::Texture::tryAlloc(Graphics& graphics, Transforms& transforms,
-        DrawOpQueueStack& queues, boost::shared_ptr<Texture> ptr,
-        const Bitmap& bmp, unsigned srcX,
-        unsigned srcY, unsigned srcWidth,
-        unsigned srcHeight, unsigned padding)
+        DrawOpQueueStack& queues, boost::shared_ptr<Texture> ptr, const Bitmap& bmp, unsigned padding)
 {
     std::auto_ptr<Gosu::TexChunk> result;
     
-    boost::optional<BlockAllocator::Block> block = allocator.alloc(srcWidth, srcHeight);
+    boost::optional<BlockAllocator::Block> block = allocator.alloc(bmp.width(), bmp.height());
     if (!block)
         return result;
     

data/GosuImpl/Graphics/Texture.hpp

@@ -25,8 +25,7 @@ namespace Gosu
         GLuint texName() const;
         std::auto_ptr<TexChunk> 
             tryAlloc(Graphics& graphics, Transforms& transforms, DrawOpQueueStack& queues, boost::shared_ptr<Texture> ptr,
-                const Bitmap& bmp, unsigned srcX, unsigned srcY, unsigned srcWidth, unsigned srcHeight,
-                unsigned padding);
+                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/MacUtility.hpp

@@ -94,7 +94,7 @@ namespace Gosu
         CFRefType ref;
 
     public:
-        explicit CFRef(CFRefType ref)
+        CFRef(CFRefType ref)
         :   ref(ref)
         {
         }

data/GosuImpl/RubyGosu.swg

@@ -127,6 +127,18 @@
         $1 = *reinterpret_cast<Gosu::Color*>(ptr);
 }
 
+// Allow integral constants to be passed in place of Color values.
+%typemap(in) boost::optional<Gosu::Color> {    
+    if (TYPE($input) == T_FIXNUM || TYPE($input) == T_BIGNUM)
+        $1 = Gosu::Color(NUM2UINT($input));
+    else {
+        void* ptr;
+        int res = SWIG_ConvertPtr($input, &ptr, SWIGTYPE_p_Gosu__Color, 0);
+        if (SWIG_IsOK(res) && ptr)
+            $1 = *reinterpret_cast<Gosu::Color*>(ptr);
+    }
+}
+
 // Header inclusion (order irrelevant)
 %module(directors="1") gosu
 %{
@@ -220,7 +232,7 @@ namespace Gosu
         {
             VALUE to_str = rb_funcall(val, rb_intern("to_str"), 0);
             const char* filename = StringValuePtr(to_str);
-            return quickLoadBitmap(Gosu::utf8ToWstring(filename));
+            return loadImageFile(Gosu::utf8ToWstring(filename));
         }
 
         // Otherwise, try to call .to_blob on it.
@@ -368,8 +380,8 @@ namespace Gosu {
         return stream.str();
     }
     
-    bool operator==(Gosu::Color other) {
-        return *$self == other;
+    bool operator==(boost::optional<Gosu::Color> other) {
+        return other && *$self == *other;
     }
 }
 
@@ -425,8 +437,7 @@ namespace Gosu {
 %include "../Gosu/Image.hpp"
 %extend Gosu::Image {
     Image(Gosu::Window& window, VALUE source, bool tileable = false) {
-        return new Gosu::Image(window.graphics(),
-            Gosu::loadBitmap(source), tileable);
+        return new Gosu::Image(window.graphics(), Gosu::loadBitmap(source), tileable);
     }
     Image(Gosu::Window& window, VALUE source, bool tileable,
           unsigned srcX, unsigned srcY, unsigned srcWidth, unsigned srcHeight) {
@@ -456,23 +467,26 @@ namespace Gosu {
     }
     %newobject fromText4;
     static Gosu::Image* fromText4(Gosu::Window& window, const std::wstring& text,
-                                 const std::wstring& fontName, unsigned fontHeight) {
+                                 const std::wstring& fontName, unsigned fontHeight)
+    {
         Gosu::Bitmap bmp = Gosu::createText(text, fontName, fontHeight);
         return new Gosu::Image(window.graphics(), bmp);
     }
     %newobject fromText7;
     static Gosu::Image* fromText7(Gosu::Window& window, const std::wstring& text,
-                                 const std::wstring& fontName, unsigned fontHeight,
-                                 int lineSpacing, unsigned maxWidth, TextAlign align) {
+            const std::wstring& fontName, unsigned fontHeight,
+            int lineSpacing, unsigned maxWidth, TextAlign align)
+    {
         Gosu::Bitmap bmp = Gosu::createText(text, fontName, fontHeight, lineSpacing, maxWidth, align);
         return new Gosu::Image(window.graphics(), bmp);
     }
-    static std::vector<Gosu::Image*> loadTiles(Gosu::Window& window, VALUE source,
-                                               int tileWidth, int tileHeight, bool tileable) {
+    static std::vector<Gosu::Image*> loadTiles(Gosu::Window& window,
+            VALUE source, int tileWidth, int tileHeight, bool tileable)
+    {
         std::vector<Gosu::Image*> vec;
         // TODO: const correctness (<- did I mean exception safety?)
         Gosu::imagesFromTiledBitmap(window.graphics(), Gosu::loadBitmap(source),
-                                    tileWidth, tileHeight, tileable, vec);
+            tileWidth, tileHeight, tileable, vec);
         return vec;        
     }
     std::string toBlob() const
@@ -500,6 +514,10 @@ namespace Gosu {
             Gosu::saveToPNG(bmp, buf.backWriter());
         Gosu::saveFile(buf, filename);
     }
+    void insert(VALUE source, int x, int y)
+    {
+        $self->getData().insert(Gosu::loadBitmap(source), x, y);
+    }
 }
 
 // Inspection:

data/GosuImpl/RubyGosu_wrap.cxx

@@ -2172,11 +2172,12 @@ namespace Swig {
 #define SWIGTYPE_p_Gosu__TextInput swig_types[10]
 #define SWIGTYPE_p_Gosu__Window swig_types[11]
 #define SWIGTYPE_p_boost__arrayT_double_16_t swig_types[12]
-#define SWIGTYPE_p_char swig_types[13]
-#define SWIGTYPE_p_double swig_types[14]
-#define SWIGTYPE_p_std__wstring swig_types[15]
-static swig_type_info *swig_types[17];
-static swig_module_info swig_module = {swig_types, 16, 0, 0, 0, 0};
+#define SWIGTYPE_p_boost__optionalT_Gosu__Color_t swig_types[13]
+#define SWIGTYPE_p_char swig_types[14]
+#define SWIGTYPE_p_double swig_types[15]
+#define SWIGTYPE_p_std__wstring swig_types[16]
+static swig_type_info *swig_types[18];
+static swig_module_info swig_module = {swig_types, 17, 0, 0, 0, 0};
 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
 
@@ -2292,7 +2293,7 @@ namespace Gosu
         {
             VALUE to_str = rb_funcall(val, rb_intern("to_str"), 0);
             const char* filename = StringValuePtr(to_str);
-            return quickLoadBitmap(Gosu::utf8ToWstring(filename));
+            return loadImageFile(Gosu::utf8ToWstring(filename));
         }
 
         // Otherwise, try to call .to_blob on it.
@@ -2516,8 +2517,8 @@ SWIG_From_std_string  (const std::string& s)
   }
 }
 
-SWIGINTERN bool Gosu_Color_operator_Se__Se_(Gosu::Color *self,Gosu::Color other){
-        return *self == other;
+SWIGINTERN bool Gosu_Color_operator_Se__Se_(Gosu::Color *self,boost::optional< Gosu::Color > other){
+        return other && *self == *other;
     }
 
 SWIGINTERNINLINE VALUE
@@ -2637,8 +2638,7 @@ SWIG_AsVal_bool (VALUE obj, bool *val)
 }
 
 SWIGINTERN Gosu::Image *new_Gosu_Image__SWIG_0(Gosu::Window &window,VALUE source,bool tileable=false){
-        return new Gosu::Image(window.graphics(),
-            Gosu::loadBitmap(source), tileable);
+        return new Gosu::Image(window.graphics(), Gosu::loadBitmap(source), tileable);
     }
 SWIGINTERN Gosu::Image *new_Gosu_Image__SWIG_1(Gosu::Window &window,VALUE source,bool tileable,unsigned int srcX,unsigned int srcY,unsigned int srcWidth,unsigned int srcHeight){
         return new Gosu::Image(window.graphics(), Gosu::loadBitmap(source),
@@ -2666,7 +2666,7 @@ SWIGINTERN std::vector< Gosu::Image * > Gosu_Image_loadTiles(Gosu::Window &windo
         std::vector<Gosu::Image*> vec;
         // TODO: const correctness (<- did I mean exception safety?)
         Gosu::imagesFromTiledBitmap(window.graphics(), Gosu::loadBitmap(source),
-                                    tileWidth, tileHeight, tileable, vec);
+            tileWidth, tileHeight, tileable, vec);
         return vec;        
     }
 SWIGINTERN std::string Gosu_Image_toBlob(Gosu::Image const *self){
@@ -2690,6 +2690,9 @@ SWIGINTERN void Gosu_Image_save(Gosu::Image const *self,std::wstring const &file
             Gosu::saveToPNG(bmp, buf.backWriter());
         Gosu::saveFile(buf, filename);
     }
+SWIGINTERN void Gosu_Image_insert(Gosu::Image *self,VALUE source,int x,int y){
+        self->getData().insert(Gosu::loadBitmap(source), x, y);
+    }
 SWIGINTERN unsigned int Gosu_TextInput_caret_pos(Gosu::TextInput const *self){
         return RUBY_18_19(Gosu::wstringToUTF8(self->text().substr(0, self->caretPos())).size(),
             self->caretPos());
@@ -5023,7 +5026,7 @@ Equality comparison operator.
 SWIGINTERN VALUE
 _wrap_Color___eq__(int argc, VALUE *argv, VALUE self) {
   Gosu::Color *arg1 = (Gosu::Color *) 0 ;
-  Gosu::Color arg2 ;
+  boost::optional< Gosu::Color > arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   bool result;
@@ -5038,15 +5041,14 @@ _wrap_Color___eq__(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = reinterpret_cast< Gosu::Color * >(argp1);
   {
-    void* ptr;
-    int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Gosu__Color, 0);
-    if (!SWIG_IsOK(res))
-    // TODO: error checking
+    if (TYPE(argv[0]) == T_FIXNUM || TYPE(argv[0]) == T_BIGNUM)
     arg2 = Gosu::Color(NUM2UINT(argv[0]));
-    else if (!ptr)
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
-    else
-    arg2 = *reinterpret_cast<Gosu::Color*>(ptr);
+    else {
+      void* ptr;
+      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Gosu__Color, 0);
+      if (SWIG_IsOK(res) && ptr)
+      arg2 = *reinterpret_cast<Gosu::Color*>(ptr);
+    }
   }
   {
     try {
@@ -7327,6 +7329,60 @@ fail:
 }
 
 
+
+/*
+  Document-method: Gosu::Image.insert
+
+  call-seq:
+    insert(source, x, y)
+
+Insert one or more new elements in the Image.
+*/
+SWIGINTERN VALUE
+_wrap_Image_insert(int argc, VALUE *argv, VALUE self) {
+  Gosu::Image *arg1 = (Gosu::Image *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  int arg3 ;
+  int arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  int val4 ;
+  int ecode4 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Image, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Image *","insert", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::Image * >(argp1);
+  arg2 = argv[0];
+  ecode3 = SWIG_AsVal_int(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","insert", 3, argv[1] ));
+  } 
+  arg3 = static_cast< int >(val3);
+  ecode4 = SWIG_AsVal_int(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","insert", 4, argv[2] ));
+  } 
+  arg4 = static_cast< int >(val4);
+  {
+    try {
+      Gosu_Image_insert(arg1,arg2,arg3,arg4);
+    } catch(const std::runtime_error& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN void
 free_Gosu_Image(Gosu::Image *arg1) {
     SWIG_RubyRemoveTracking(arg1);
@@ -10662,6 +10718,7 @@ static swig_type_info _swigt__p_Gosu__Song = {"_p_Gosu__Song", "Gosu::Song *", 0
 static swig_type_info _swigt__p_Gosu__TextInput = {"_p_Gosu__TextInput", "Gosu::TextInput *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_Gosu__Window = {"_p_Gosu__Window", "Gosu::Window *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_boost__arrayT_double_16_t = {"_p_boost__arrayT_double_16_t", "boost::array< double,16 > *|Gosu::Transform *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_boost__optionalT_Gosu__Color_t = {"_p_boost__optionalT_Gosu__Color_t", "boost::optional< Gosu::Color > *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_double = {"_p_double", "Gosu::ZPos *|double *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_std__wstring = {"_p_std__wstring", "std::wstring *", 0, 0, (void*)0, 0};
@@ -10680,6 +10737,7 @@ static swig_type_info *swig_type_initial[] = {
   &_swigt__p_Gosu__TextInput,
   &_swigt__p_Gosu__Window,
   &_swigt__p_boost__arrayT_double_16_t,
+  &_swigt__p_boost__optionalT_Gosu__Color_t,
   &_swigt__p_char,
   &_swigt__p_double,
   &_swigt__p_std__wstring,
@@ -10698,6 +10756,7 @@ static swig_cast_info _swigc__p_Gosu__Song[] = {  {&_swigt__p_Gosu__Song, 0, 0,
 static swig_cast_info _swigc__p_Gosu__TextInput[] = {  {&_swigt__p_Gosu__TextInput, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_Gosu__Window[] = {  {&_swigt__p_Gosu__Window, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_boost__arrayT_double_16_t[] = {  {&_swigt__p_boost__arrayT_double_16_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_boost__optionalT_Gosu__Color_t[] = {  {&_swigt__p_boost__optionalT_Gosu__Color_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_std__wstring[] = {  {&_swigt__p_std__wstring, 0, 0, 0},{0, 0, 0, 0}};
@@ -10716,6 +10775,7 @@ static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_Gosu__TextInput,
   _swigc__p_Gosu__Window,
   _swigc__p_boost__arrayT_double_16_t,
+  _swigc__p_boost__optionalT_Gosu__Color_t,
   _swigc__p_char,
   _swigc__p_double,
   _swigc__p_std__wstring,
@@ -10981,8 +11041,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 >(27)));
-  rb_define_const(mGosu, "VERSION", SWIG_FromCharPtr("0.7.27.1"));
+  rb_define_const(mGosu, "POINT_VERSION", SWIG_From_int(static_cast< int >(28)));
+  rb_define_const(mGosu, "VERSION", SWIG_FromCharPtr("0.7.28"));
   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);
@@ -11102,6 +11162,7 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_method(SwigClassImage.klass, "columns", VALUEFUNC(_wrap_Image_columns), -1);
   rb_define_method(SwigClassImage.klass, "rows", VALUEFUNC(_wrap_Image_rows), -1);
   rb_define_method(SwigClassImage.klass, "save", VALUEFUNC(_wrap_Image_save), -1);
+  rb_define_method(SwigClassImage.klass, "insert", VALUEFUNC(_wrap_Image_insert), -1);
   SwigClassImage.mark = 0;
   SwigClassImage.destroy = (void (*)(void *)) free_Gosu_Image;
   SwigClassImage.trackObjects = 1;

data/README.txt

@@ -1,17 +1,26 @@
-Moin moin, dear Gosu user!
+ Moin and welcome to Gosu!
 
-* All resources concerning Gosu are linked from http://libgosu.org/.
+ Gosu's main website is http://www.libgosu.org/ which always has the latest
+links to all relevant information.
 
-* The latest documentation on how to install/set up Gosu can be found at:
+ The actual source code, wiki, issue tracker etc. are currently moving away
+from Gosu's old Google Code project to GitHub:
 
-    http://code.google.com/p/gosu/wiki/DocsOverview
+    http://code.google.com/p/gosu/ -> http://github.com/jlnr/gosu/
+
+ The best entry point into Gosu's documentation is still this wiki page:
 
-* Try doing the tutorial there if you don't know how to start out! Or look
-  at one of the games in the Gosu Users board.
+    http://code.google.com/p/gosu/wiki/DocsOverview
 
-* If you have any questions or feedback,
-  -  visit the boards at http://libgosu.org/,
-  -  try your luck in irc://irc.freenode.org/gosu,
-  -  or mail me at julian@raschke.de!
+ Try doing the tutorial there if you don't know how to start out. Or look at
+one of the games in the Gosu Users board.
 
-Hope you'll enjoy using Gosu!
+ Remember that Gosu is licensed under the MIT license and feel invited to fork,
+port and transmogrify all parts of it. The only license that may affect you by
+indirection is libogg's (BSD-style). If you release a Gosu game in any common
+binary form, you will need to mention use of libogg and libvorbis somewhere.
+ 
+ Complaints, questions, feedback?
+* Visit the boards,                         http://www.libgosu.org/
+* try your luck in the chat,              irc://irc.freenode.org/gosu
+* or e-mail me. Have fun, write games!         julian@raschke.de

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: gosu
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 59
   prerelease: 
   segments: 
   - 0
   - 7
-  - 27
-  - 1
-  version: 0.7.27.1
+  - 28
+  version: 0.7.28
 platform: ruby
 authors: 
 - Julian Raschke
@@ -17,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-07 00:00:00 +08:00
+date: 2011-03-24 00:00:00 +08:00
 default_executable: 
 dependencies: []
 
@@ -30,7 +29,7 @@ extensions:
 extra_rdoc_files: []
 
 files: 
-- COPYING.txt
+- COPYING
 - README.txt
 - Gosu/Async.hpp
 - Gosu/Audio.hpp
@@ -101,10 +100,10 @@ files:
 - GosuImpl/FileUnix.cpp
 - GosuImpl/FileWin.cpp
 - GosuImpl/Graphics/Bitmap.cpp
+- GosuImpl/Graphics/BitmapApple.mm
 - GosuImpl/Graphics/BitmapBMP.cpp
 - GosuImpl/Graphics/BitmapColorKey.cpp
 - GosuImpl/Graphics/BitmapPNG.cpp
-- GosuImpl/Graphics/BitmapTouch.mm
 - GosuImpl/Graphics/BitmapUtils.cpp
 - GosuImpl/Graphics/BlockAllocator.cpp
 - GosuImpl/Graphics/BlockAllocator.hpp
@@ -205,7 +204,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: 
 - See http://code.google.com/p/gosu/wiki/GettingStartedOnLinux
 rubyforge_project: 
-rubygems_version: 1.4.2
+rubygems_version: 1.6.0
 signing_key: 
 specification_version: 3
 summary: 2D game development library.

data/GosuImpl/Graphics/BitmapTouch.mm

@@ -1,69 +0,0 @@
-#include <Gosu/Graphics.hpp>
-#include <Gosu/Bitmap.hpp>
-#include <Gosu/IO.hpp>
-#include <Gosu/Utility.hpp>
-#include <GosuImpl/MacUtility.hpp>
-#include <boost/algorithm/string.hpp>
-#include <boost/lexical_cast.hpp>
-#include <stdexcept>
-#import <UIKit/UIKit.h>
-
-Gosu::Reader Gosu::loadFromBMP(Bitmap& bmp, Reader reader)
-{
-    ObjRef<NSAutoreleasePool> pool([NSAutoreleasePool new]);
-
-    std::size_t length = reader.resource().size() - reader.position();
-    ObjRef<NSMutableData> buffer([[NSMutableData alloc] initWithLength: length]);
-    reader.read([buffer.get() mutableBytes], length);
-    
-    ObjRef<UIImage> image([[UIImage alloc] initWithData: buffer.get()]);
-    if (!image.get())
-        throw std::runtime_error("Could not load image from resource of length " +
-                                 boost::lexical_cast<std::string>(length));
-    
-    CGImageRef imageRef = [image.obj() CGImage];
-    
-    bmp.resize(CGImageGetWidth(imageRef), CGImageGetHeight(imageRef));
-    
-    // Use a temporary context to draw the CGImage to the buffer.
-    CGContextRef context =
-        CGBitmapContextCreate(bmp.data(),
-                              bmp.width(), bmp.height(), 8, bmp.width() * 4,
-                              CGImageGetColorSpace(imageRef),
-                              kCGImageAlphaPremultipliedLast);
-    CGContextDrawImage(context, CGRectMake(0.0, 0.0, bmp.width(), bmp.height()), imageRef);
-    CGContextRelease(context);
-    
-    return reader;
-}
-
-Gosu::Reader Gosu::loadFromPNG(Bitmap& bmp, Reader reader)
-{
-    return loadFromBMP(bmp, reader);
-}
-
-Gosu::Writer Gosu::saveToPNG(const Bitmap& bmp, Writer writer)
-{
-    ObjRef<NSAutoreleasePool> pool([NSAutoreleasePool new]);
-
-    CGDataProviderRef dataProvider =
-        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,
-                      kCGImageAlphaLast, dataProvider, 0, false, kCGRenderingIntentDefault);
-
-    ObjRef<UIImage> image([[UIImage alloc] initWithCGImage: imageRef]);
-    
-    NSData* pngRef = UIImagePNGRepresentation(image.get());
-    writer.write([pngRef bytes], [pngRef length]);
-    image.reset();
-    
-    CGImageRelease(imageRef);
-
-    CGDataProviderRelease(dataProvider);
-    
-    return writer;
-}