gosu 0.9.2 → 0.10.0

data/src/{MacUtility.hpp → AppleUtility.hpp}

@@ -1,75 +1,57 @@
-#ifndef GOSU_MACUTILITY_HPP
-#define GOSU_MACUTILITY_HPP
+#ifndef GOSU_APPLEUTILITY_HPP
+#define GOSU_APPLEUTILITY_HPP
 
 #include <Gosu/Platform.hpp>
 
-#import <CoreFoundation/CoreFoundation.h>
-
-#ifndef GOSU_IS_IPHONE
-#import <ApplicationServices/ApplicationServices.h>
-
-// Not defined on 10.4 Tiger SDK which Gosu uses.
-#if __LP64__ || NS_BUILD_32_LIKE_64
-typedef long NSInteger;
-typedef unsigned long NSUInteger;
-#else
-typedef int NSInteger;
-typedef unsigned int NSUInteger;
-#endif
-#endif
+#ifdef __OBJC__
 
 #include <iostream>
 #include <ostream>
 #include <sstream>
 #include <string>
 #include <stdexcept>
+#include <objc/objc.h>
+#import <CoreFoundation/CoreFoundation.h>
+#import <Foundation/Foundation.h>
 
 namespace Gosu
 {
     inline void throwOSError(OSStatus status, unsigned line)
     {
+        NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+        NSError *error = [NSError errorWithDomain:NSOSStatusErrorDomain code:status userInfo:nil];
         std::ostringstream str;
-        #ifdef GOSU_IS_IPHONE
-        str << "Error on line " << line << " (Code " << status << ")";
-        #else
         str << "Error on line " << line << " (Code " << status << "): "
-            << GetMacOSStatusErrorString(status)
-            << " (" << GetMacOSStatusCommentString(status) << ")";
-        #endif
+        << [[error localizedDescription] UTF8String]
+        << " (" << [[error description] UTF8String] << ")";
+        [pool release];
         throw std::runtime_error(str.str());
     }
     
     #define CHECK_OS(status) if (!(status)) {} else Gosu::throwOSError(status, __LINE__)
-}
 
-#ifdef __OBJC__
-#import <objc/objc.h>
-#import <stdexcept>
-namespace Gosu
-{
     template<typename T>
-    class ObjRef
+    class ObjCRef
     {
-        ObjRef(const ObjRef&);
-        ObjRef& operator=(const ObjRef&);
+        ObjCRef(const ObjCRef&);
+        ObjCRef& operator=(const ObjCRef&);
         
         T* ptr;
+        
     public:
-        ObjRef(T* ptr = nil)
+        ObjCRef(T* ptr = nil)
         : ptr(ptr) 
         {
         }
         
-        ~ObjRef() 
+        ~ObjCRef() 
         {
-            if (ptr)
-                [ptr release];
+            [ptr release];
         }
         
         void reset(T* newPtr = nil)
         { 
-            if (ptr)
-                [ptr release]; 
+            [ptr release]; 
             ptr = newPtr;
         }
         
@@ -81,7 +63,7 @@ namespace Gosu
         T* obj() const
         {
             if (!ptr)
-                throw std::logic_error("Tried dereferencing nil");
+                throw std::logic_error("Objective-C reference is nil");
             return ptr;
         }
     };
@@ -104,21 +86,21 @@ namespace Gosu
         {
         }
         
-        CFRef()
+        ~CFRef()
         {
             if (ref)
                 CFRelease(ref);
         }
         
-        CFRefType get()
+        CFRefType get() const
         {
             return ref;
         }
         
-        CFRefType obj()
+        CFRefType obj() const
         {
             if (!ref)
-                throw std::logic_error("CF reference invalid (null)");
+                throw std::logic_error("CoreFoundation reference is NULL");
             return ref;
         }
     };

data/src/Audio/ALChannelManagement.hpp

@@ -2,7 +2,7 @@
 #ifdef GOSU_IS_MAC
 #include <OpenAL/al.h>
 #include <OpenAL/alc.h>
-#include "../MacUtility.hpp"
+#include "../AppleUtility.hpp"
 #else
 #include <AL/al.h>
 #include <AL/alc.h>

data/src/Audio/{AudioOpenAL.cpp → Audio.cpp}

@@ -57,9 +57,9 @@ namespace
 
 // TODO: What is this NSAutoreleasePool good for?
 #ifdef GOSU_IS_MAC
-#include "../MacUtility.hpp"
+#include "../AppleUtility.hpp"
     #define CONSTRUCTOR_COMMON \
-        ObjRef<NSAutoreleasePool> pool([[NSAutoreleasePool alloc] init]); \
+        ObjCRef<NSAutoreleasePool> pool([NSAutoreleasePool new]); \
         if (!alChannelManagement.get()) \
             alChannelManagement.reset(new ALChannelManagement)
 #else
@@ -133,7 +133,6 @@ void Gosu::SampleInstance::changePan(double pan)
     ALuint source = alChannelManagement->sourceIfStillPlaying(handle, extra);
     if (source == ALChannelManagement::NO_SOURCE)
         return;
-    // TODO: This is not the old panning behavior!
     alSource3f(source, AL_POSITION, pan * 10, 0, 0);
 }
 
@@ -273,7 +272,7 @@ public:
 // AVAudioPlayer impl
 class Gosu::Song::ModuleData : public BaseData
 {
-    ObjRef<AVAudioPlayer> player;
+    ObjCRef<AVAudioPlayer> player;
     
     void applyVolume()
     {
@@ -284,9 +283,9 @@ public:
     ModuleData(const std::wstring& filename)
     {
         std::string utf8Filename = Gosu::wstringToUTF8(filename);
-        ObjRef<NSString> nsFilename([[NSString alloc] initWithUTF8String: utf8Filename.c_str()]);
-        ObjRef<NSURL> url([[NSURL alloc] initFileURLWithPath: nsFilename.obj()]);
-        player.reset([[AVAudioPlayer alloc] initWithContentsOfURL: url.obj() error: NULL]);
+        ObjCRef<NSString> nsFilename([[NSString alloc] initWithUTF8String:utf8Filename.c_str()]);
+        ObjCRef<NSURL> url([[NSURL alloc] initFileURLWithPath:nsFilename.obj()]);
+        player.reset([[AVAudioPlayer alloc] initWithContentsOfURL:url.obj() error:NULL]);
     }
     
     void play(bool looping)

data/src/Audio/Audio.mm

@@ -0,0 +1 @@
+#include "Audio.cpp"

data/src/Audio/AudioFile.hpp

@@ -1,5 +1,5 @@
-#ifndef GOSUIMPL_AUDIO_AUDIOFILE_HPP
-#define GOSUIMPL_AUDIO_AUDIOFILE_HPP
+#ifndef GOSU_SRC_AUDIO_AUDIOFILE_HPP
+#define GOSU_SRC_AUDIO_AUDIOFILE_HPP
 
 #include <vector>
 #include <Gosu/Platform.hpp>

data/src/Audio/AudioToolboxFile.hpp

@@ -1,5 +1,5 @@
-#ifndef GOSU_AUDIO_AUDIOFILE_MAC_HPP
-#define GOSU_AUDIO_AUDIOFILE_MAC_HPP
+#ifndef GOSU_SRC_AUDIO_AUDIOFILE_MAC_HPP
+#define GOSU_SRC_AUDIO_AUDIOFILE_MAC_HPP
 
 #include "AudioFile.hpp"
 #include <AudioToolbox/AudioToolbox.h>
@@ -9,7 +9,7 @@
 #include <Gosu/IO.hpp>
 #include <Gosu/Utility.hpp>
 #include <Gosu/Platform.hpp>
-#include "../MacUtility.hpp"
+#include "../AppleUtility.hpp"
 #include <algorithm>
 #include <vector>
 #include <arpa/inet.h>
@@ -141,24 +141,9 @@ namespace Gosu
     public:
         AudioToolboxFile(const std::wstring& filename)
         {
-            ObjRef<NSString> utf8Filename([[NSString alloc] initWithUTF8String: wstringToUTF8(filename).c_str()]);
-            ObjRef<NSURL> url([[NSURL alloc] initFileURLWithPath: utf8Filename.get()]);
-            #ifdef GOSU_IS_IPHONE
+            ObjCRef<NSString> utf8Filename([[NSString alloc] initWithUTF8String:wstringToUTF8(filename).c_str()]);
+            ObjCRef<NSURL> url([[NSURL alloc] initFileURLWithPath:utf8Filename.get()]);
             CHECK_OS(ExtAudioFileOpenURL((CFURLRef)url.get(), &file_));
-            #else
-            // Use FSRef for compatibility with 10.4 Tiger.
-            FSRef fsRef;
-            CFURLGetFSRef(reinterpret_cast<CFURLRef>(url.get()), &fsRef);
-            try
-            {
-                CHECK_OS(ExtAudioFileOpen(&fsRef, &file_));
-            }
-            catch (const std::runtime_error&)
-            {
-                throw std::runtime_error("Unsupported audio file type (" +
-                    Gosu::wstringToUTF8(filename) + ")");
-            }
-            #endif
             
             fileID_ = 0;
             

data/src/Audio/OggFile.hpp

@@ -1,11 +1,14 @@
-#ifndef GOSUIMPL_AUDIO_OGGFILE_HPP
-#define GOSUIMPL_AUDIO_OGGFILE_HPP
+#ifndef GOSU_SRC_AUDIO_OGGFILE_HPP
+#define GOSU_SRC_AUDIO_OGGFILE_HPP
 
 #include "AudioFile.hpp"
 #include <Gosu/IO.hpp>
-#include <vorbis/vorbisfile.h>
 #include <algorithm>
 #include <stdexcept>
+#include <sstream>
+
+#define STB_VORBIS_HEADER_ONLY
+#include "../stb_vorbis.c"
 
 // Based on the Drama Sound Engine for D
 
@@ -13,58 +16,55 @@ namespace Gosu
 {
     class OggFile : public AudioFile
     {
+        Gosu::Buffer contents_;
         Gosu::Buffer buffer_;
-        Gosu::Reader reader_;
-        ALenum format_;
+        int channels_;
         ALenum sampleRate_;
-        OggVorbis_File file_;
+        stb_vorbis* stream_;
 
-        // extern "C"
-        static std::size_t readCallback(void* ptr, std::size_t size, std::size_t nmemb, void* datasource)
-        {
-            OggFile* oggFile = static_cast<OggFile*>(datasource);
-            size = std::min(size * nmemb,
-                oggFile->buffer_.size() - oggFile->reader_.position());
-            oggFile->reader_.read(ptr, size);
-            return size;
-        }
-        
-        void setup()
+        void open()
         {
-            static const ov_callbacks cbs = { readCallback, 0, 0, 0 };
-            ov_open_callbacks(this, &file_, 0, 0, cbs);
+            int error = 0;
             
-            vorbis_info* info = ov_info(&file_, -1); // -1 is current bitstream
-            if (ov_streams(&file_) != 1)
-                throw std::runtime_error("multi-stream vorbis files not supported");
+            const unsigned char *mem = static_cast<const unsigned char*>(contents_.data());
+            stream_ = stb_vorbis_open_memory(mem, contents_.size(), &error, 0);
             
-            format_ = info->channels == 1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16;
-            sampleRate_ = info->rate;
+            if (stream_ == 0)
+            {
+                std::ostringstream message;
+                message << "Cannot open Ogg Vorbis file, error code: " << error;
+                throw std::runtime_error(message.str());
+            }
+            
+            stb_vorbis_info info = stb_vorbis_get_info(stream_);
+            channels_ = info.channels;
+            sampleRate_ = info.sample_rate;
+            buffer_.resize(info.temp_memory_required);
         }
         
-        void teardown()
+        void close()
         {
-            ov_clear(&file_);
+            stb_vorbis_close(stream_);
+            stream_ = 0;
         }
         
     public:
         OggFile(Gosu::Reader reader)
-        : reader_(buffer_.frontReader())
         {
-            buffer_.resize(reader.resource().size() - reader.position());
-            reader.read(buffer_.data(), buffer_.size());
+            contents_.resize(reader.resource().size() - reader.position());
+            reader.read(contents_.data(), contents_.size());
             
-            setup();
+            open();
         }
         
         ~OggFile()
         {
-            teardown();
+            close();
         }
         
         ALenum format() const
         {
-            return format_;
+            return (channels_ == 1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16);
         }
         
         ALuint sampleRate() const
@@ -74,38 +74,26 @@ namespace Gosu
         
         std::size_t readData(void* dest, std::size_t length)
         {
-            static const unsigned OGG_ENDIANNESS =
-            #ifdef GOSU_IS_BIG_ENDIAN
-                1;
-            #else
-                0;
-            #endif
+            int samples = 0;
+            int maxSamples = length / sizeof(short);
             
-            char* ptr = static_cast<char*>(dest);
-            std::size_t size = 0;
-            int result;
-            int section;
-            while (size < length)
-            {
-                result = ov_read(&file_, ptr + size, length - size,
-                                 OGG_ENDIANNESS, 2 /* 16-bit */,
-                                 1 /* signed */, &section);
-                if (result > 0)
-                    size += result;
-                else if (result < 0)
-                    throw std::runtime_error("error reading vorbis stream");
-                else
+            while (samples < maxSamples) {
+                int samplesPerChannel =
+                    stb_vorbis_get_samples_short_interleaved(stream_, channels_,
+                        static_cast<short*>(dest) + samples, maxSamples - samples);
+                
+                if (samplesPerChannel == 0)
                     break;
+                
+                samples += samplesPerChannel * channels_;
             }
             
-            return size;
+            return samples * sizeof(short);
         }
         
         void rewind()
         {
-            teardown();
-            reader_ = buffer_.frontReader();
-            setup();
+            stb_vorbis_seek_start(stream_);
         }
     };
 }

data/src/Audio/SndFile.hpp

@@ -1,5 +1,5 @@
-#ifndef GOSUIMPL_AUDIO_SNDFILE_HPP
-#define GOSUIMPL_AUDIO_SNDFILE_HPP
+#ifndef GOSU_SRC_AUDIO_SNDFILE_HPP
+#define GOSU_SRC_AUDIO_SNDFILE_HPP
 
 #include <Gosu/Audio.hpp>
 #include <Gosu/Platform.hpp>

data/src/Bitmap/Bitmap.cpp

@@ -14,7 +14,7 @@ void Gosu::Bitmap::resize(unsigned width, unsigned height, Color c)
 {
     if (width == w && height == h)
         return;
-    
+
     Bitmap temp(width, height, c);
     temp.insert(*this, 0, 0);
     swap(temp);
@@ -39,7 +39,7 @@ void Gosu::Bitmap::insert(const Bitmap& source, int x, int y, unsigned srcX,
     unsigned srcY, unsigned srcWidth, unsigned srcHeight)
 {
     // TODO: This should use memcpy if possible (x == 0 && srcWidth == this->width())
-    
+
     if (x < 0)
     {
         unsigned clipLeft = -x;
@@ -85,3 +85,99 @@ void Gosu::Bitmap::insert(const Bitmap& source, int x, int y, unsigned srcX,
             setPixel(x + relX, y + relY,
                 source.getPixel(srcX + relX, srcY + relY));
 }
+
+void Gosu::applyColorKey(Bitmap& bitmap, Color key)
+{
+    std::vector<Color> surroundingColors;
+    surroundingColors.reserve(4);
+
+    for (unsigned y = 0; y < bitmap.height(); ++y)
+        for (unsigned x = 0; x < bitmap.width(); ++x)
+            if (bitmap.getPixel(x, y) == key)
+            {
+                surroundingColors.clear();
+                if (x > 0 && bitmap.getPixel(x - 1, y) != key)
+                    surroundingColors.push_back(bitmap.getPixel(x - 1, y));
+                if (x < bitmap.width() - 1 && bitmap.getPixel(x + 1, y) != key)
+                    surroundingColors.push_back(bitmap.getPixel(x + 1, y));
+                if (y > 0 && bitmap.getPixel(x, y - 1) != key)
+                    surroundingColors.push_back(bitmap.getPixel(x, y - 1));
+                if (y < bitmap.height() - 1 && bitmap.getPixel(x, y + 1) != key)
+                    surroundingColors.push_back(bitmap.getPixel(x, y + 1));
+
+                if (surroundingColors.empty())
+                {
+                    bitmap.setPixel(x, y, Color::NONE);
+                    continue;
+                }
+
+                unsigned red = 0, green = 0, blue = 0;
+                for (unsigned i = 0; i < surroundingColors.size(); ++i)
+                {
+                    red += surroundingColors[i].red();
+                    green += surroundingColors[i].green();
+                    blue += surroundingColors[i].blue();
+                }
+                bitmap.setPixel(x, y, Color(0, red / surroundingColors.size(),
+                    green / surroundingColors.size(), blue / surroundingColors.size()));
+            }
+}
+
+void Gosu::unapplyColorKey(Bitmap& bitmap, Color color)
+{
+    Color* p = bitmap.data();
+    for (int i = bitmap.width() * bitmap.height(); i > 0; --i, ++p)
+        if (p->alpha() == 0)
+            *p = color;
+        else
+            p->setAlpha(255);
+}
+
+void Gosu::applyBorderFlags(Bitmap& dest, const Bitmap& source,
+    unsigned srcX, unsigned srcY, unsigned srcWidth, unsigned srcHeight,
+    unsigned imageFlags)
+{
+    // Backwards compatibility: This used to be 'bool tileable'.
+    if (imageFlags == 1)
+        imageFlags = ifTileable;
+
+    dest.resize(srcWidth + 2, srcHeight + 2);
+
+    // The borders are made "harder" by duplicating the original bitmap's
+    // borders.
+
+    // Top.
+    if (imageFlags & ifTileableTop)
+        dest.insert(source, 1, 0, srcX, srcY, srcWidth, 1);
+    // Bottom.
+    if (imageFlags & ifTileableBottom)
+        dest.insert(source, 1, dest.height() - 1,
+            srcX, srcY + srcHeight - 1, srcWidth, 1);
+    // Left.
+    if (imageFlags & ifTileableLeft)
+        dest.insert(source, 0, 1, srcX, srcY, 1, srcHeight);
+    // Right.
+    if (imageFlags & ifTileableRight)
+        dest.insert(source, dest.width() - 1, 1,
+            srcX + srcWidth - 1, srcY, 1, srcHeight);
+
+    // Top left.
+    if ((imageFlags & ifTileableTop) && (imageFlags & ifTileableLeft))
+        dest.setPixel(0, 0,
+            source.getPixel(srcX, srcY));
+    // Top right.
+    if ((imageFlags & ifTileableTop) && (imageFlags & ifTileableRight))
+        dest.setPixel(dest.width() - 1, 0,
+            source.getPixel(srcX + srcWidth - 1, srcY));
+    // Bottom left.
+    if ((imageFlags & ifTileableBottom) && (imageFlags & ifTileableLeft))
+        dest.setPixel(0, dest.height() - 1,
+            source.getPixel(srcX, srcY + srcHeight - 1));
+    // Bottom right.
+    if ((imageFlags & ifTileableBottom) && (imageFlags & ifTileableRight))
+        dest.setPixel(dest.width() - 1, dest.height() - 1,
+            source.getPixel(srcX + srcWidth - 1, srcY + srcHeight - 1));
+
+    // Now put the final image into the prepared borders.
+    dest.insert(source, 1, 1, srcX, srcY, srcWidth, srcHeight);
+}