gosu 0.9.2 → 0.10.0

data/src/Bitmap/BitmapIO.cpp

@@ -0,0 +1,156 @@
+#include <Gosu/Bitmap.hpp>
+#include <Gosu/Platform.hpp>
+#include <Gosu/IO.hpp>
+#include <Gosu/Utility.hpp>
+
+#define STB_IMAGE_IMPLEMENTATION
+#define STBI_NO_STDIO
+#define STBI_NO_LINEAR
+#include "../stb_image.h"
+
+namespace
+{
+    int readCallback(void* user, char* data, int size)
+    {
+        Gosu::Reader* reader = static_cast<Gosu::Reader*>(user);
+        std::size_t remaining = reader->resource().size() - reader->position();
+        std::size_t actualSize = (size < remaining ? size : remaining);
+        reader->read(data, actualSize);
+        return actualSize;
+    }
+
+    void skipCallback(void* user, int n)
+    {
+        Gosu::Reader* reader = static_cast<Gosu::Reader*>(user);
+        reader->setPosition(reader->position() + n);
+    }
+
+    int eofCallback(void* user)
+    {
+        Gosu::Reader* reader = static_cast<Gosu::Reader*>(user);
+        return reader->position() == reader->resource().size();
+    }
+
+    bool isBMP(Gosu::Reader reader)
+    {
+        std::size_t remaining = reader.resource().size() - reader.position();
+        if (remaining < 2)
+            return false;
+        char magicBytes[2];
+        reader.read(magicBytes, sizeof magicBytes);
+        reader.seek(sizeof magicBytes);
+        return magicBytes[0] == 'B' && magicBytes[1] == 'M';
+    }
+}
+
+void Gosu::loadImageFile(Gosu::Bitmap& bitmap, const std::wstring& filename)
+{
+    Buffer buffer;
+    loadFile(buffer, filename);
+    loadImageFile(bitmap, buffer.frontReader());
+}
+
+void Gosu::loadImageFile(Gosu::Bitmap& bitmap, Reader input)
+{
+    bool needsColorKey = isBMP(input);
+    
+    stbi_io_callbacks callbacks;
+    callbacks.read = readCallback;
+    callbacks.skip = skipCallback;
+    callbacks.eof = eofCallback;
+    int x, y, n;
+    stbi_uc* bytes = stbi_load_from_callbacks(&callbacks, &input, &x, &y, &n, STBI_rgb_alpha);
+
+    if (bytes == 0) {
+        // TODO - stbi_failure_reason is not thread safe. Everything here should be wrapped in a mutex.
+        throw std::runtime_error("Cannot load image: " + std::string(stbi_failure_reason()));
+    }
+
+    bitmap.resize(x, y);
+    std::memcpy(bitmap.data(), bytes, x * y * sizeof(Gosu::Color));
+
+    stbi_image_free(bytes);
+    
+    if (needsColorKey)
+        applyColorKey(bitmap, Gosu::Color::FUCHSIA);
+}
+
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include "../stb_image_write.h"
+
+// TODO: Move into proper internal header
+namespace Gosu { bool isExtension(const wchar_t* str, const wchar_t* ext); }
+
+void Gosu::saveImageFile(const Gosu::Bitmap& bitmap, const std::wstring& filename)
+{
+    int ok;
+    std::string utf8 = Gosu::wstringToUTF8(filename);
+    
+    if (isExtension(filename.c_str(), L"bmp"))
+    {
+        ok = stbi_write_bmp(utf8.c_str(), bitmap.width(), bitmap.height(), 4, bitmap.data());
+    }
+    else if (isExtension(filename.c_str(), L"tga"))
+    {
+        ok = stbi_write_tga(utf8.c_str(), bitmap.width(), bitmap.height(), 4, bitmap.data());
+    }
+    else
+    {
+        ok = stbi_write_png(utf8.c_str(), bitmap.width(), bitmap.height(), 4, bitmap.data(), 0);
+    }
+    
+    if (ok == 0)
+        throw std::runtime_error("Could not save image data to file: " + utf8);
+}
+
+void Gosu::saveImageFile(const Gosu::Bitmap& bitmap, Gosu::Writer writer,
+    const std::wstring& formatHint)
+{
+    unsigned char* rgba =
+        const_cast<unsigned char*>(reinterpret_cast<const unsigned char*>(bitmap.data()));
+    
+    int length;
+    unsigned char* png =
+        stbi_write_png_to_mem(rgba, 0, bitmap.width(), bitmap.height(), 4, &length);
+    
+    if (png == 0)
+        throw std::runtime_error("Could not save image data to memory");
+    
+    try
+    {
+        writer.write(png, length);
+    }
+    catch (...)
+    {
+        STBIW_FREE(png);
+        throw;
+    }
+    
+    STBIW_FREE(png);
+}
+
+// Deprecated methods.
+
+Gosu::Reader Gosu::loadFromPNG(Bitmap& bitmap, Reader reader)
+{
+    loadImageFile(bitmap, reader);
+    reader.setPosition(reader.resource().size());
+    return reader;
+}
+
+Gosu::Reader Gosu::loadFromBMP(Bitmap& bitmap, Reader reader)
+{
+    return loadFromPNG(bitmap, reader);
+}
+
+Gosu::Writer Gosu::saveToPNG(const Bitmap& bitmap, Writer writer)
+{
+    saveImageFile(bitmap, writer, L".png");
+    return writer.resource().backWriter();
+}
+
+Gosu::Writer Gosu::saveToBMP(const Bitmap& bitmap, Writer writer)
+{
+    saveImageFile(bitmap, writer, L".bmp");
+    return writer.resource().backWriter();
+}

data/src/DirectoriesApple.mm

@@ -0,0 +1,76 @@
+#import <Gosu/Directories.hpp>
+#import <Gosu/Utility.hpp>
+#import "AppleUtility.hpp"
+#import <Foundation/Foundation.h>
+#import <unistd.h>
+
+
+static std::wstring stringFromNSString(NSString* string, const std::wstring& def)
+{
+    return string ? Gosu::utf8ToWstring([string UTF8String]) : def;
+}
+
+void Gosu::useResourceDirectory()
+{
+    chdir(Gosu::wstringToUTF8(resourcePrefix()).c_str());
+}
+
+std::wstring Gosu::userSettingsPrefix()
+{
+    static std::wstring result;
+    if (result.empty())
+    {
+        ObjCRef<NSAutoreleasePool> pool([NSAutoreleasePool new]);
+        NSArray *paths = NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES);
+        NSString *libraryDirectory = [paths objectAtIndex:0];
+        NSString *preferencesDirectory = [libraryDirectory stringByAppendingPathComponent:@"Preferences"];
+        
+        result = stringFromNSString(preferencesDirectory, L".") + L"/";
+    }
+    return result;
+}
+
+std::wstring Gosu::userDocsPrefix()
+{
+    static std::wstring result;
+    if (result.empty())
+    {
+        ObjCRef<NSAutoreleasePool> pool([NSAutoreleasePool new]);
+        NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
+        NSString *documentsDirectory = [paths objectAtIndex:0];
+        
+        result = stringFromNSString(documentsDirectory, L".") + L"/";
+    }
+    return result;
+}
+
+std::wstring Gosu::resourcePrefix()
+{
+    static std::wstring result;
+    if (result.empty())
+    {
+        ObjCRef<NSAutoreleasePool> pool([NSAutoreleasePool new]);
+        NSString *resourcePath = [[NSBundle mainBundle] resourcePath];
+        
+        result = stringFromNSString(resourcePath, L".") + L"/";
+    }
+    return result;
+}
+
+std::wstring Gosu::sharedResourcePrefix()
+{
+    #ifdef GOSU_IS_IPHONE
+    return resourcePrefix();
+    #else
+    static std::wstring result;
+    if (result.empty())
+    {
+        ObjCRef<NSAutoreleasePool> pool([NSAutoreleasePool new]);
+        NSString *bundlePath = [[NSBundle mainBundle] bundlePath];
+        NSString *containingPath = [bundlePath stringByDeletingLastPathComponent];
+        
+        result = stringFromNSString(containingPath, L".");
+    }
+    return result;
+    #endif
+}

data/src/DirectoriesUnix.cpp

@@ -1,8 +1,6 @@
 #include <Gosu/Directories.hpp>
-#include <Gosu/Platform.hpp>
 #include <Gosu/Utility.hpp>
 #include <cassert>
-#include <vector>
 #include <sys/types.h>
 #include <unistd.h>
 #include <pwd.h>
@@ -17,7 +15,11 @@ namespace
     }
 }
 
-#ifndef GOSU_IS_MAC
+void Gosu::useResourceDirectory()
+{
+    // Do nothing - the current directory HAS to be correct on Linux.
+}
+
 std::wstring Gosu::resourcePrefix()
 {
     return std::wstring();
@@ -27,22 +29,13 @@ std::wstring Gosu::sharedResourcePrefix()
 {
     return std::wstring();
 }
-#endif
 
 std::wstring Gosu::userSettingsPrefix()
 {
-#ifdef GOSU_IS_MAC
-    return homeDir() + L"/Library/Preferences/";
-#else
     return homeDir() + L"/.";
-#endif
 }
 
 std::wstring Gosu::userDocsPrefix()
 {
-#ifdef GOSU_IS_MAC
-    return homeDir() + L"/Documents/";
-#else
     return homeDir() + L"/";
-#endif
 }

data/src/DirectoriesWin.cpp

@@ -21,6 +21,11 @@ namespace
     }
 }
 
+void Gosu::useResourceDirectory()
+{
+    SetCurrentDirectory(resourcePrefix().c_str());
+}
+
 std::wstring Gosu::resourcePrefix()
 {
     return Win::appDirectory();

data/src/Graphics/BlockAllocator.hpp

@@ -1,5 +1,5 @@
-#ifndef GOSUIMPL_BLOCKALLOCATOR_HPP
-#define GOSUIMPL_BLOCKALLOCATOR_HPP
+#ifndef GOSU_SRC_BLOCKALLOCATOR_HPP
+#define GOSU_SRC_BLOCKALLOCATOR_HPP
 
 #include <memory>
 #include <Gosu/Platform.hpp>

data/src/Graphics/ClipRectStack.hpp

@@ -1,5 +1,5 @@
-#ifndef GOSUIMPL_GRAPHICS_CLIPRECTSTACK_HPP
-#define GOSUIMPL_GRAPHICS_CLIPRECTSTACK_HPP
+#ifndef GOSU_SRC_GRAPHICS_CLIPRECTSTACK_HPP
+#define GOSU_SRC_GRAPHICS_CLIPRECTSTACK_HPP
 
 #include "Common.hpp"
 #include <cassert>

data/src/Graphics/Common.hpp

@@ -1,5 +1,5 @@
-#ifndef GOSUIMPL_GRAPHICS_COMMON_HPP
-#define GOSUIMPL_GRAPHICS_COMMON_HPP
+#ifndef GOSU_SRC_GRAPHICS_COMMON_HPP
+#define GOSU_SRC_GRAPHICS_COMMON_HPP
 
 #include <Gosu/Bitmap.hpp>
 #include <Gosu/Graphics.hpp>

data/src/Graphics/DrawOp.hpp

@@ -1,5 +1,5 @@
-#ifndef GOSUIMPL_DRAWOP_HPP
-#define GOSUIMPL_DRAWOP_HPP
+#ifndef GOSU_SRC_DRAWOP_HPP
+#define GOSU_SRC_DRAWOP_HPP
 
 #include <Gosu/GraphicsBase.hpp>
 #include <Gosu/Color.hpp>

data/src/Graphics/DrawOpQueue.hpp

@@ -1,5 +1,5 @@
-#ifndef GOSUIMPL_GRAPHICS_DRAWOPQUEUE_HPP
-#define GOSUIMPL_GRAPHICS_DRAWOPQUEUE_HPP
+#ifndef GOSU_SRC_GRAPHICS_DRAWOPQUEUE_HPP
+#define GOSU_SRC_GRAPHICS_DRAWOPQUEUE_HPP
 
 #include <Gosu/TR1.hpp>
 #include "Common.hpp"

data/src/Graphics/Graphics.cpp

@@ -392,6 +392,8 @@ GOSU_UNIQUE_PTR<Gosu::ImageData> Gosu::Graphics::createImage(
     if (flags == 1)
         flags = ifTileable;
 
+    bool wantsRetro = (flags & ifRetro);
+    
     // Special case: If the texture is supposed to have hard borders, is
     // quadratic, has a size that is at least 64 pixels but no more than maxSize
     // pixels and a power of two, create a single texture just for this image.
@@ -400,7 +402,7 @@ GOSU_UNIQUE_PTR<Gosu::ImageData> Gosu::Graphics::createImage(
         (srcWidth & (srcWidth - 1)) == 0 &&
         srcWidth >= 64 && srcWidth <= maxSize)
     {
-        std::tr1::shared_ptr<Texture> texture(new Texture(srcWidth));
+        std::tr1::shared_ptr<Texture> texture(new Texture(srcWidth, wantsRetro));
         GOSU_UNIQUE_PTR<ImageData> data;
         
         // Use the source bitmap directly if the source area completely covers
@@ -440,6 +442,9 @@ GOSU_UNIQUE_PTR<Gosu::ImageData> Gosu::Graphics::createImage(
     {
         std::tr1::shared_ptr<Texture> texture(*i);
         
+        if (texture->retro() != wantsRetro)
+            continue;
+        
         GOSU_UNIQUE_PTR<ImageData> data;
         data = texture->tryAlloc(texture, bmp, 1);
         if (data.get())
@@ -449,7 +454,7 @@ GOSU_UNIQUE_PTR<Gosu::ImageData> Gosu::Graphics::createImage(
     // All textures are full: Create a new one.
     
     std::tr1::shared_ptr<Texture> texture;
-    texture.reset(new Texture(maxSize));
+    texture.reset(new Texture(maxSize, wantsRetro));
     textures.push_back(texture);
     
     GOSU_UNIQUE_PTR<ImageData> data;

data/src/Graphics/LargeImageData.cpp

@@ -7,7 +7,7 @@
 using namespace std;
 
 Gosu::LargeImageData::LargeImageData(const Bitmap& source,
-    unsigned partWidth, unsigned partHeight, unsigned flags)
+    unsigned partWidth, unsigned partHeight, unsigned imageFlags)
 {
     fullWidth = source.width();
     fullHeight = source.height();
@@ -31,15 +31,15 @@ Gosu::LargeImageData::LargeImageData(const Bitmap& source,
             if (y == partsY - 1 && source.height() % partHeight != 0)
                 srcHeight = source.height() % partHeight;
 
-            unsigned localFlags = ifTileable;
+            unsigned localFlags = ifTileable | imageFlags;
             if (x == 0)
-                localFlags = (localFlags & ~ifTileableLeft) | (flags & ifTileableLeft);
+                localFlags = (localFlags & ~ifTileableLeft) | (imageFlags & ifTileableLeft);
             if (x == partsX - 1)
-                localFlags = (localFlags & ~ifTileableRight) | (flags & ifTileableRight);
+                localFlags = (localFlags & ~ifTileableRight) | (imageFlags & ifTileableRight);
             if (y == 0)
-                localFlags = (localFlags & ~ifTileableTop) | (flags & ifTileableTop);
+                localFlags = (localFlags & ~ifTileableTop) | (imageFlags & ifTileableTop);
             if (y == partsY - 1)
-                localFlags = (localFlags & ~ifTileableBottom) | (flags & ifTileableBottom);
+                localFlags = (localFlags & ~ifTileableBottom) | (imageFlags & ifTileableBottom);
             
             parts[y * partsX + x].reset(Graphics::createImage(source,
                 x * partWidth, y * partHeight, srcWidth, srcHeight,

data/src/Graphics/LargeImageData.hpp

@@ -1,5 +1,5 @@
-#ifndef GOSUIMPL_LARGEIMAGEDATA_HPP
-#define GOSUIMPL_LARGEIMAGEDATA_HPP
+#ifndef GOSU_SRC_LARGEIMAGEDATA_HPP
+#define GOSU_SRC_LARGEIMAGEDATA_HPP
 
 #include <Gosu/Fwd.hpp>
 #include <Gosu/ImageData.hpp>
@@ -17,7 +17,7 @@ namespace Gosu
 
     public:
         LargeImageData(const Bitmap& source,
-            unsigned partWidth, unsigned partHeight, unsigned borderFlags);
+            unsigned partWidth, unsigned partHeight, unsigned imageFlags);
 
         int width() const;
         int height() const;

data/src/Graphics/Macro.hpp

@@ -1,5 +1,5 @@
-#ifndef GOSUIMPL_GRAPHICS_MACRO_HPP
-#define GOSUIMPL_GRAPHICS_MACRO_HPP
+#ifndef GOSU_SRC_GRAPHICS_MACRO_HPP
+#define GOSU_SRC_GRAPHICS_MACRO_HPP
 
 #include <Gosu/Fwd.hpp>
 #include <Gosu/ImageData.hpp>

data/src/Graphics/RenderState.hpp

@@ -1,5 +1,5 @@
-#ifndef GOSUIMPL_GRAPHICS_RENDERSTATE_HPP
-#define GOSUIMPL_GRAPHICS_RENDERSTATE_HPP
+#ifndef GOSU_SRC_GRAPHICS_RENDERSTATE_HPP
+#define GOSU_SRC_GRAPHICS_RENDERSTATE_HPP
 
 #include "Common.hpp"
 #include "Texture.hpp"

data/src/Graphics/Resolution.cpp

@@ -46,7 +46,7 @@ unsigned Gosu::availableHeight()
     return availableSize.cy;
 }
 #else
-#include <SDL2/SDL.h>
+#include <SDL.h>
 
 namespace
 {

data/src/Graphics/TexChunk.hpp

@@ -1,5 +1,5 @@
-#ifndef GOSUIMPL_GRAPHICS_TEXCHUNK_HPP
-#define GOSUIMPL_GRAPHICS_TEXCHUNK_HPP
+#ifndef GOSU_SRC_GRAPHICS_TEXCHUNK_HPP
+#define GOSU_SRC_GRAPHICS_TEXCHUNK_HPP
 
 #include <Gosu/Fwd.hpp>
 #include <Gosu/ImageData.hpp>