gosu 0.7.33 → 0.7.35

data/GosuImpl/Audio/AudioSDL.cpp

@@ -2,7 +2,6 @@
 #include <Gosu/Math.hpp>
 #include <Gosu/IO.hpp>
 #include <Gosu/Utility.hpp>
-#include <boost/algorithm/string.hpp>
 #include <cassert>
 #include <cstdlib>
 #include <algorithm>
@@ -95,9 +94,10 @@ void Gosu::SampleInstance::changeSpeed(double speed)
    * with SDL_mixer. */
 }
 
-struct Gosu::Sample::SampleData : boost::noncopyable
+struct Gosu::Sample::SampleData
 {
   Mix_Chunk* rep;
+  std::vector<Uint8> buffer;
   
   SampleData(): rep(0) {}
   ~SampleData() {
@@ -121,18 +121,17 @@ Gosu::Sample::Sample(const std::wstring& filename)
 }
 
 Gosu::Sample::Sample(Reader reader)
+: data(new SampleData)
 {
     requireSDLMixer();
 
     if (noSound)
         return;
 
-    std::size_t bufsize = reader.resource().size() - reader.position();
-    Uint8* buffer = static_cast<Uint8*>(malloc(bufsize));
-    reader.read(buffer, bufsize);
+    data->buffer.resize(reader.resource().size() - reader.position());
+    reader.read(&data->buffer[0], data->buffer.size());
 
-    data.reset(new SampleData);
-    data->rep = Mix_LoadWAV_RW(SDL_RWFromMem(buffer, bufsize), 1);
+    data->rep = Mix_LoadWAV_RW(SDL_RWFromMem(&data->buffer[0], data->buffer.size()), 1);
     if (data->rep == NULL)
         throwLastSDLError();
 }
@@ -177,10 +176,10 @@ Gosu::SampleInstance Gosu::Sample::playPan(double pan, double volume,
 }
 
 // No class hierarchy here; SDL_mixer abstracts this away for us.
-class Gosu::Song::BaseData : boost::noncopyable {
+class Gosu::Song::BaseData {
 public:
     Mix_Music* music;
-    //std::vector<Uint8> buffer; - used by constructor that has been commented out
+    // std::vector<Uint8> buffer; - used by constructor that has been commented out
     double volume;
     
     BaseData() : music(0), volume(1.0) {}
@@ -218,9 +217,8 @@ Gosu::Song::Song(Reader reader)
 #if 0
     // This is traditionally broken in SDL_mixer. File bugs :)
     
-    std::size_t bufsize = reader.resource().size() - reader.position();
-    data->buffer.resize(bufsize);
-    reader.read(data->buffer.data(), bufsize);
+    data->buffer.resize(reader.resource().size() - reader.position());
+    reader.read(data->buffer.data(), data->buffer.size());
     data->music = Mix_LoadMUS_RW(SDL_RWFromMem(data->buffer.data(), bufsize));
     if (data->music == NULL)
         throwLastSDLError();
@@ -308,10 +306,10 @@ Gosu::Sample::Sample(Audio& audio, Reader reader)
 
 Gosu::Song::Song(Audio& audio, const std::wstring& filename)
 {
-    Song(filename).data.swap(data);
+    data = Song(filename).data;
 }
 
 Gosu::Song::Song(Audio& audio, Type type, Reader reader)
 {
-    Song(reader).data.swap(data);
+    data = Song(reader).data;
 }

data/GosuImpl/Audio/AudioToolboxFile.hpp

@@ -12,7 +12,6 @@
 #include <Gosu/Platform.hpp>
 #include <algorithm>
 #include <vector>
-#include <boost/lexical_cast.hpp>
 #include <arpa/inet.h>
 #import <Foundation/Foundation.h>
 

data/GosuImpl/Audio/OggFile.hpp

@@ -2,7 +2,9 @@
 #define GOSUIMPL_AUDIO_OGGFILE_HPP
 
 #include <GosuImpl/Audio/AudioFile.hpp>
+#include <Gosu/IO.hpp>
 #include <vorbis/vorbisfile.h>
+#include <cassert>
 #include <algorithm>
 #include <stdexcept>
 

data/GosuImpl/Audio/SndFile.hpp

@@ -0,0 +1,158 @@
+#ifndef GOSUIMPL_AUDIO_SNDFILE_HPP
+#define GOSUIMPL_AUDIO_SNDFILE_HPP
+
+#include <Gosu/Audio.hpp>
+#include <Gosu/Platform.hpp>
+#include <Gosu/Utility.hpp>
+#include <sndfile.h>
+
+namespace Gosu
+{
+    class SndFile : public AudioFile
+    {
+        SNDFILE* file;
+        SF_INFO info;
+        Reader reader;
+        Buffer buffer;
+        
+        // Cannot use /DELAYLOAD with libsndfile-1.dll because it was compiled
+        // using arcane GNU tools of dark magic (or maybe it's the filename).
+        #ifdef GOSU_IS_WIN
+        static HMODULE dll()
+        {
+            static HMODULE dll = LoadLibrary(L"libsndfile.dll");
+            if (!dll)
+                throw std::runtime_error("Cannot find libsndfile.dll");
+            return dll;
+        }
+        
+        #define CREATE_STUB(NAME, RETURN, PARAMS, NAMES)                    \
+        static RETURN NAME PARAMS                                           \
+        {                                                                   \
+            typedef RETURN (__cdecl *NAME##_ptr) PARAMS;                            \
+            static NAME##_ptr f = (NAME##_ptr)GetProcAddress(dll(), #NAME); \
+            if (!f)                                                         \
+                throw std::runtime_error("Cannot find " ## #NAME);          \
+            return f NAMES;                                                 \
+        }
+        CREATE_STUB(sf_open_virtual, SNDFILE*,
+            (SF_VIRTUAL_IO* sfvirtual, int mode, SF_INFO* sfinfo, void* user_data),
+            (sfvirtual, mode, sfinfo, user_data))
+        CREATE_STUB(sf_close, int,
+            (SNDFILE *sndfile),
+            (sndfile))
+        CREATE_STUB(sf_read_short, sf_count_t,
+            (SNDFILE *sndfile, short *ptr, sf_count_t items),
+            (sndfile, ptr, items))
+        CREATE_STUB(sf_seek, sf_count_t,
+            (SNDFILE *sndfile, sf_count_t frames, int whence),
+            (sndfile, frames, whence))
+        CREATE_STUB(sf_strerror, const char*,
+            (SNDFILE* sndfile),
+            (sndfile))
+        #endif
+        
+        static sf_count_t get_filelen(SndFile *self)
+        {
+            return self->buffer.size();
+        }
+        
+        static sf_count_t seek(sf_count_t offset, int whence, SndFile *self)
+        {
+            switch (whence)
+            {
+            case SEEK_SET: self->reader.setPosition(offset); break;
+            case SEEK_CUR: self->reader.seek(offset); break;
+            case SEEK_END: self->reader.setPosition(self->buffer.size() - offset); break;
+            };
+            return 0;
+        }
+        
+        static sf_count_t read(void *ptr, sf_count_t count, SndFile *self)
+        {
+            sf_count_t avail = self->buffer.size() - self->reader.position();
+            count = std::min(avail, count);
+            self->reader.read(ptr, count);
+            return count;
+        }
+        
+        static sf_count_t tell(SndFile *self)
+        {
+            return self->reader.position();
+        }
+        
+        static SF_VIRTUAL_IO* ioInterface()
+        {
+            static SF_VIRTUAL_IO io;
+            io.get_filelen = (sf_vio_get_filelen)&get_filelen;
+            io.seek        = (sf_vio_seek)&seek;
+            io.read        = (sf_vio_read)&read;
+            io.tell        = (sf_vio_tell)&tell;
+            io.write       = NULL;
+            return &io;
+        }
+        
+    public:
+        SndFile(Reader reader)
+        :   file(NULL), reader(buffer.frontReader())
+        {
+            info.format = 0;
+            buffer.resize(reader.resource().size() - reader.position());
+            reader.read(buffer.data(), buffer.size());
+            file = sf_open_virtual(ioInterface(), SFM_READ, &info, this);
+            if (!file)
+                throw std::runtime_error(std::string(sf_strerror(NULL)));
+        }
+        
+        SndFile(const std::wstring& filename)
+        :   file(NULL), reader(buffer.frontReader())
+        {
+            info.format = 0;
+            #ifdef GOSU_IS_WIN
+            loadFile(buffer, filename);
+            file = sf_open_virtual(ioInterface(), SFM_READ, &info, this);
+            #else
+            file = sf_open(wstringToUTF8(filename).c_str(), SFM_READ, &info);
+            #endif
+            if (!file)
+                throw std::runtime_error(std::string(sf_strerror(NULL)));
+        }
+        
+        ~SndFile()
+        {
+            if (file)
+                sf_close(file);
+        }
+        
+        ALenum format() const
+        {
+            switch (info.channels)
+            {
+            case 1:
+                return AL_FORMAT_MONO16;
+            case 2:
+                return AL_FORMAT_STEREO16;
+            default:
+                throw std::runtime_error("Too many channels in audio file");
+            };
+        }
+        
+        ALuint sampleRate() const
+        {
+            return info.samplerate;
+        }
+        
+        std::size_t readData(void* dest, std::size_t length)
+        {
+            int itemSize = 2 * info.channels;
+            return sf_read_short(file, (short*)dest, length / itemSize) * itemSize;
+        }
+        
+        void rewind()
+        {
+            sf_seek(file, 0, SEEK_SET);
+        }
+    };
+}
+
+#endif

data/GosuImpl/DirectoriesWin.cpp

@@ -6,37 +6,37 @@
 
 namespace
 {
-	std::wstring specialFolderPath(int csidl)
-	{
-		WCHAR buf[MAX_PATH + 2];
-		if (!SHGetSpecialFolderPath(0, buf, csidl, TRUE))
-			throw std::runtime_error("Error getting special folder path");
-		std::size_t len = std::wcslen(buf);
-		if (buf[len - 1] != '\\')
-		{
-			buf[len] = L'\\';
-			buf[len + 1] = L'\0';
-		}
-		return buf;
-	}
+    std::wstring specialFolderPath(int csidl)
+    {
+        WCHAR buf[MAX_PATH + 2];
+        if (FAILED(SHGetFolderPath(NULL, csidl | CSIDL_FLAG_CREATE, NULL, 0, buf)))
+            throw std::runtime_error("Error getting special folder path");
+        std::size_t len = std::wcslen(buf);
+        if (buf[len - 1] != L'\\')
+        {
+            buf[len] = L'\\';
+            buf[len + 1] = 0;
+        }
+        return buf;
+    }
 }
 
 std::wstring Gosu::resourcePrefix()
 {
-	return Win::appDirectory();
+    return Win::appDirectory();
 }
 
 std::wstring Gosu::sharedResourcePrefix()
 {
-	return Win::appDirectory();
+    return Win::appDirectory();
 }
 
 std::wstring Gosu::userSettingsPrefix()
 {
-	return specialFolderPath(CSIDL_APPDATA);
+    return specialFolderPath(CSIDL_APPDATA);
 }
 
 std::wstring Gosu::userDocsPrefix()
 {
-	return specialFolderPath(CSIDL_PERSONAL);
-}
+    return specialFolderPath(CSIDL_PERSONAL);
+}

data/GosuImpl/Graphics/BitmapApple.mm

@@ -5,8 +5,6 @@
 #include <Gosu/Utility.hpp>
 
 #include <GosuImpl/MacUtility.hpp>
-#include <boost/algorithm/string.hpp>
-#include <boost/lexical_cast.hpp>
 #include <stdexcept>
 
 #ifdef GOSU_IS_IPHONE
@@ -56,9 +54,10 @@ namespace
         
         bitmap.resize([rep pixelsWide], [rep pixelsHigh]);
         
-        // Use a temporary context to draw the NSImage to the buffer.
+        // Use a temporary context to draw the NSImage to the buffer. For that, construct a color
+        // space that does not alter the colors while drawing from the NSImage to the CGBitmapContext.
         
-        static Gosu::CFRef<CGColorSpaceRef> colorSpace(CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB));
+        static Gosu::CFRef<CGColorSpaceRef> colorSpace(CGColorSpaceCreateDeviceRGB());
         Gosu::CFRef<CGContextRef> context(CGBitmapContextCreate(bitmap.data(), bitmap.width(), bitmap.height(),
                                     8, bitmap.width() * 4,
                                     colorSpace.obj(), kCGImageAlphaPremultipliedLast)); // kCGBitmapByteOrder32Host?
@@ -71,21 +70,22 @@ namespace
     #endif
 }
 
-Gosu::Bitmap Gosu::loadImageFile(const std::wstring& filename)
+// TODO: Move into proper internal header
+namespace Gosu { bool isExtension(const wchar_t* str, const wchar_t* ext); }
+
+void Gosu::loadImageFile(Bitmap& bitmap, const std::wstring& filename)
 {
     ObjRef<NSString> filenameRef([[NSString alloc] initWithUTF8String: wstringToUTF8(filename).c_str()]);
     ObjRef<APPLE_IMAGE> image([[APPLE_IMAGE alloc] initWithContentsOfFile: filenameRef.obj()]);
     if (!image.get())
         throw std::runtime_error("Cannot load image file " + wstringToUTF8(filename));
     
-    Bitmap bitmap;
     appleImageToBitmap(image.obj(), bitmap);
-    if (boost::iends_with(filename, L".bmp"))
+    if (isExtension(filename.c_str(), L".bmp"))
         applyColorKey(bitmap, Color::FUCHSIA);
-    return bitmap;
 }
 
-Gosu::Bitmap Gosu::loadImageFile(Reader reader)
+void Gosu::loadImageFile(Bitmap& bitmap, Reader reader)
 {
     char signature[2];
     reader.read(signature, 2);
@@ -101,11 +101,9 @@ Gosu::Bitmap Gosu::loadImageFile(Reader reader)
     if (!image.get())
         throw std::runtime_error("Cannot load image file from stream");
     
-    Bitmap bitmap;
     appleImageToBitmap(image.obj(), bitmap);
     if (signature[0] == 'B' && signature[1] == 'M')
         applyColorKey(bitmap, Color::FUCHSIA);
-    return bitmap;
 }
 
 #ifndef GOSU_IS_IPHONE
@@ -118,15 +116,15 @@ void Gosu::saveImageFile(const Bitmap& bitmap, const std::wstring& filename)
 void Gosu::saveImageFile(const Bitmap& originalBitmap, Writer writer, const std::wstring& formatHint)
 {
     NSBitmapImageFileType fileType;
-    if (boost::iends_with(formatHint, L"png"))
+    if (isExtension(formatHint.c_str(), L"png"))
         fileType = NSPNGFileType;
-    else if (boost::iends_with(formatHint, L"bmp"))
+    else if (isExtension(formatHint.c_str(), L"bmp"))
         fileType = NSBMPFileType;
-    else if (boost::iends_with(formatHint, L"gif"))
+    else if (isExtension(formatHint.c_str(), L"gif"))
         fileType = NSGIFFileType;
-    else if (boost::iends_with(formatHint, L"jpg") || boost::iends_with(formatHint, L"jpeg"))
+    else if (isExtension(formatHint.c_str(), L"jpg") || isExtension(formatHint.c_str(), L"jpeg"))
         fileType = NSJPEGFileType;
-    else if (boost::iends_with(formatHint, L"tif") || boost::iends_with(formatHint, L"tiff"))
+    else if (isExtension(formatHint.c_str(), L"tif") || isExtension(formatHint.c_str(), L"tiff"))
         fileType = NSTIFFFileType;
     else
         throw std::runtime_error("Unsupported image format for writing: " + wstringToUTF8(formatHint));
@@ -160,7 +158,7 @@ void Gosu::saveImageFile(const Bitmap& bmp, const std::wstring& filename)
 
 void Gosu::saveImageFile(const Bitmap& bmp, Writer writer, const std::wstring& formatHint)
 {    
-    if (boost::iends_with(formatHint, L"bmp"))
+    if (isExtension(formatHint.c_str(), L"bmp"))
     {
         Bitmap bitmap = bmp;
         unapplyColorKey(bitmap, Color::FUCHSIA);
@@ -182,9 +180,9 @@ void Gosu::saveImageFile(const Bitmap& bmp, Writer writer, const std::wstring& f
     ObjRef<UIImage> image([[UIImage alloc] initWithCGImage: imageRef]);
     
     NSData* data;
-    if (boost::iends_with(formatHint, L"jpeg") || boost::iends_with(formatHint, L"jpg"))
+    if (isExtension(formatHint.c_str(), L"jpeg") || isExtension(formatHint.c_str(), L"jpg"))
         data = UIImageJPEGRepresentation(image.get(), 0.0);
-    else if (boost::iends_with(formatHint, L"png"))
+    else if (isExtension(formatHint.c_str(), L"png"))
         data = UIImagePNGRepresentation(image.get());
     else
         throw std::runtime_error("Unsupported image format for writing: " + wstringToUTF8(formatHint));

data/GosuImpl/Graphics/BitmapBMP.cpp

@@ -4,14 +4,19 @@
 #ifdef GOSU_IS_IPHONE
 #include <Gosu/Bitmap.hpp>
 #include <Gosu/IO.hpp>
-#include <boost/integer.hpp>
+#include <Gosu/TR1.hpp>
 
 namespace
 {
+    template<unsigned bits> struct UintSelector;
+    template<> struct UintSelector<8>  { typedef std::tr1::uint8_t  Type; };
+    template<> struct UintSelector<16> { typedef std::tr1::uint16_t Type; };
+    template<> struct UintSelector<32> { typedef std::tr1::uint32_t Type; };
+    
     template<unsigned bits, typename T>
     void writeVal(Gosu::Writer& writer, T value)
     {
-        typename boost::uint_t<bits>::least val = value;
+        typename UintSelector<bits>::Type val = value;
         writer.writePod(val, Gosu::boLittle);
     }
 }

data/GosuImpl/Graphics/BitmapFreeImage.cpp

@@ -1,18 +1,19 @@
 #include <Gosu/Bitmap.hpp>
 #include <Gosu/IO.hpp>
 #include <Gosu/Platform.hpp>
+#include <Gosu/TR1.hpp>
 #include <Gosu/Utility.hpp>
 #include <vector>
-#include <boost/cstdint.hpp>
 #include <FreeImage.h>
 
-// Compatibility with FreeImage < 3.1.3 which is still stuck in many package repositories
+// Compatibility with FreeImage <3.1.3. Subtly changes Gosu's behavior though.
 #ifndef JPEG_EXIFROTATE
 #define JPEG_EXIFROTATE 0
 #endif
 
-// In Windows, add a suffix to all functions so they can be used as a fallback for GDI+.
-#ifdef GOSU_IS_WIN
+// With MSVC, add a suffix so FreeImage can be linked as a fallback for GDI+.
+// With MinGW, Gosu uses FreeImage all the time, so no suffix is needed.
+#ifdef _MSC_VER
 #define FI(x) x##_FreeImage
 #else
 #define FI(x) x
@@ -26,14 +27,13 @@ namespace
     {
         // Since FreeImage gracefully ignores the MASK parameters above, we
         // manually exchange the R and B channels.
-        boost::uint32_t* p = reinterpret_cast<boost::uint32_t*>(bitmap.data());
+        std::tr1::uint32_t* p = reinterpret_cast<std::tr1::uint32_t*>(bitmap.data());
         for (int i = bitmap.width() * bitmap.height(); i > 0; --i, ++p)
             *p = (*p & 0xff00ff00) | ((*p << 16) & 0x00ff0000) | ((*p >> 16) & 0x000000ff);
     }
     
-    Gosu::Bitmap fibToBitmap(FIBITMAP* fib, FREE_IMAGE_FORMAT fif)
+    void fibToBitmap(Gosu::Bitmap& bitmap, FIBITMAP* fib, FREE_IMAGE_FORMAT fif)
     {
-        Gosu::Bitmap bitmap;
         bitmap.resize(FreeImage_GetWidth(fib), FreeImage_GetHeight(fib));
         FreeImage_ConvertToRawBits(reinterpret_cast<BYTE*>(bitmap.data()),
             fib, bitmap.width() * 4, 32,
@@ -42,7 +42,6 @@ namespace
         reshuffleBitmap(bitmap);
         if (fif == FIF_BMP)
             Gosu::applyColorKey(bitmap, Gosu::Color::FUCHSIA);
-        return bitmap;
     }
     
     FIBITMAP* bitmapToFIB(Gosu::Bitmap bitmap, FREE_IMAGE_FORMAT fif)
@@ -82,7 +81,7 @@ namespace
 
 namespace Gosu
 {
-    Bitmap FI(loadImageFile)(const std::wstring& filename)
+    void FI(loadImageFile)(Bitmap& bitmap, const std::wstring& filename)
     {
         #ifdef GOSU_IS_WIN
         FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeU(filename.c_str());
@@ -93,10 +92,10 @@ namespace Gosu
         FIBITMAP* fib = FreeImage_Load(fif, utf8Filename.c_str(), GOSU_FIFLAGS);
         #endif
 
-        return fibToBitmap(fib, fif);
+        fibToBitmap(bitmap, fib, fif);
     }
 
-    Bitmap FI(loadImageFile)(Gosu::Reader input)
+    void FI(loadImageFile)(Bitmap& bitmap, Gosu::Reader input)
     {
         // Read all available input
         std::vector<BYTE> data(input.resource().size() - input.position());
@@ -105,7 +104,7 @@ namespace Gosu
         FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromMemory(fim);
         FIBITMAP* fib = FreeImage_LoadFromMemory(fif, fim, GOSU_FIFLAGS);
 
-        return fibToBitmap(fib, fif);
+        fibToBitmap(bitmap, fib, fif);
     }
 
     void FI(saveImageFile)(const Bitmap& bitmap, const std::wstring& filename)