gosu 0.7.12 → 0.7.13

data/Gosu/Audio.hpp

@@ -11,6 +11,7 @@
 #include <windows.h>
 #endif
 #include <Gosu/Fwd.hpp>
+#include <Gosu/IO.hpp>
 #include <Gosu/Platform.hpp>
 #include <boost/scoped_ptr.hpp>
 #include <boost/utility.hpp>

data/Gosu/Bitmap.hpp

@@ -54,10 +54,10 @@ namespace Gosu
         void insert(const Bitmap& source, int x, int y, unsigned srcX,
             unsigned srcY, unsigned srcWidth, unsigned srcHeight);
 		
-		#ifndef __BIG_ENDIAN__
-		//! Undocumented optimization for Image creation; to be changed.
-        const unsigned* glCompatibleData() const { return reinterpret_cast<const unsigned*>(&pixels[0]); }
-		#endif
+		//! Direct access to the array of color values. May be useful for optimized
+        //! OpenGL operations.
+        const unsigned* data() const { return reinterpret_cast<const unsigned*>(&pixels[0]); }
+        unsigned* data() { return reinterpret_cast<unsigned*>(&pixels[0]); }
     };
 
     //! Loads a Windows or OS/2 BMP file into the given bitmap.

data/Gosu/Graphics.hpp

@@ -12,6 +12,9 @@
 
 namespace Gosu
 {
+    unsigned screenWidth();
+    unsigned screenHeight();
+
     //! Flags that affect the softness of a border.
     enum BorderFlags
     {

data/Gosu/Input.hpp

@@ -27,6 +27,7 @@
 #include <Gosu/Fwd.hpp>
 #include <boost/function.hpp>
 #include <boost/scoped_ptr.hpp>
+#include <vector>
 
 namespace Gosu
 {
@@ -48,6 +49,11 @@ namespace Gosu
 		Button(ButtonName name) : id(name) {}
 	};
 	
+	// Available even on non-iPhone platforms to make it easier to compile the
+	// same source for multiple platforms. To be moved to Input.hpp, though.
+    struct Touch { void* id; double x, y; };
+    typedef std::vector<Touch> Touches;
+
 	//! Tests whether two Buttons identify the same physical button.
 	inline bool operator==(Button lhs, Button rhs)
 	{
@@ -71,9 +77,13 @@ namespace Gosu
         #endif
         
         #ifdef GOSU_IS_MAC
+        #ifdef GOSU_IS_IPHONE
+        Input();
+        #else
         Input(void* nswindow);
         bool feedNSEvent(void* event);
         #endif
+        #endif
         
         #ifdef GOSU_IS_X
         Input(::Display* display, ::Window window);

data/Gosu/Text.hpp

@@ -5,6 +5,7 @@
 #define GOSU_TEXT_HPP
 
 #include <Gosu/Fwd.hpp>
+#include <Gosu/Color.hpp>
 #include <Gosu/GraphicsBase.hpp>
 #include <string>
 

data/Gosu/Window.hpp

@@ -11,7 +11,6 @@
 #include <boost/shared_ptr.hpp>
 #include <boost/function.hpp>
 #include <string>
-#include <vector>
 
 #ifdef GOSU_IS_WIN
 #include <windows.h>
@@ -19,11 +18,6 @@
 
 namespace Gosu
 {
-    #ifdef GOSU_IS_IPHONE
-    struct Touch { double x, y; };
-    typedef std::vector<Touch> Touches;
-    #endif
-
     //! Convenient all-in-one class that serves as the foundation of a standard
 	//! Gosu application. Manages initialization of all of Gosu's core components
     //! and provides timing functionality.
@@ -42,6 +36,8 @@ namespace Gosu
 
         std::wstring caption() const;
         void setCaption(const std::wstring& caption);
+        
+        double updateInterval() const;
 
         //! Starts the main event loop.
         void show();
@@ -54,7 +50,12 @@ namespace Gosu
         //! Called after every update and when the OS wants the window to
         //! repaint itself. Your application's rendering code goes here.
         virtual void draw() {}
-
+        
+        //! Gives the game a chance to say no to being redrawn.
+        //! This is not a definitive answer. The operating system can still cause
+        //! redraws for one reason or another.
+        virtual bool needsRedraw() const { return true; }
+        
         //! Called before update when the user pressed a button while the
         //! window had the focus.
         virtual void buttonDown(Gosu::Button) {}
@@ -73,19 +74,29 @@ namespace Gosu
         Input& input();
 
         #ifdef GOSU_IS_WIN
-        // Only on Windows.
+        // Only on Windows, used for integrating with GUI toolkits.
         HWND handle() const;
         virtual LRESULT handleMessage(UINT message, WPARAM wparam,
             LPARAM lparam);
-        #else
+        #endif
+        
+        #ifdef GOSU_IS_UNIX
+        // Context for creating shared contexts.
         // Only on Unices (so far).
         typedef boost::shared_ptr<boost::function<void()> > SharedContext;
         SharedContext createSharedContext();
         #endif
+        
         #ifdef GOSU_IS_IPHONE
+        // iPhone-only callbacks for touch events.
+        // Note that it does not hurt to override them even if you compile
+        // for another platform; if you don't specify "virtual" the code
+        // should even be stripped away cleanly.
         virtual void touchesBegan(const Touches& touches) {}
         virtual void touchesMoved(const Touches& touches) {}
         virtual void touchesEnded(const Touches& touches) {}
+        // Currently known touches.
+        const Touches& currentTouches() const;
         #endif        
 
         #endif

data/GosuImpl/Audio/ALChannelManagement.hpp

@@ -0,0 +1,72 @@
+#import <OpenAL/al.h>
+#import <OpenAL/alc.h>
+#include <GosuImpl/MacUtility.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <algorithm>
+
+namespace Gosu
+{
+    class ALChannelManagement : boost::noncopyable
+    {
+        static ALCdevice* alDevice;
+        static ALCcontext* alContext;
+
+        enum { NUM_SOURCES = 32 }; // This is what the iPhone supports, I hear.
+        NSUInteger alSources[NUM_SOURCES];
+        NSUInteger currentToken;
+        NSUInteger currentTokens[NUM_SOURCES];
+        
+    public:
+        enum { NO_TOKEN = -1, NO_SOURCE = -1, NO_FREE_CHANNEL = -1 };
+    
+        ALChannelManagement()
+        {
+            // Open preferred device
+            alDevice = alcOpenDevice(0);
+            alContext = alcCreateContext(alDevice, 0);
+            alcMakeContextCurrent(alContext);
+            alGenSources(NUM_SOURCES, alSources);
+            currentToken = 0;
+            std::fill(currentTokens, currentTokens + NUM_SOURCES,
+                static_cast<NSUInteger>(NO_TOKEN));
+        }
+        
+        ~ALChannelManagement()
+        {
+            alDeleteSources(NUM_SOURCES, alSources);
+            alcMakeContextCurrent(0);
+            alcDestroyContext(alContext);
+            alcCloseDevice(alDevice);
+        }
+        
+        std::pair<int, int> reserveChannel()
+        {
+            int i;
+            for (i = 0; i <= NUM_SOURCES; ++i)
+            {
+                if (i == NUM_SOURCES)
+                    return std::make_pair<int, int>(NO_FREE_CHANNEL, NO_TOKEN);
+                if (currentTokens[i] == NO_TOKEN)
+                    break;
+                ALint state;
+                alGetSourcei(alSources[i], AL_SOURCE_STATE, &state);
+                if (state != AL_PLAYING && state != AL_PAUSED)
+                    break;
+            }
+            ++currentToken;
+            currentTokens[i] = currentToken;
+            return std::make_pair<int, int>(i, currentToken);
+        }
+        
+        int sourceIfStillPlaying(int channel, int token) const
+        {
+            if (currentTokens[channel] == token)
+                return alSources[channel];
+            return NO_SOURCE;
+        }
+    };
+    ALCdevice* ALChannelManagement::alDevice = 0;
+    ALCcontext* ALChannelManagement::alContext = 0;
+    
+    boost::scoped_ptr<ALChannelManagement> alChannelManagement;
+}

data/GosuImpl/Audio/AudioFileMac.hpp

@@ -0,0 +1,105 @@
+#ifndef GOSU_AUDIO_AUDIOFILE_MAC_HPP
+#define GOSU_AUDIO_AUDIOFILE_MAC_HPP
+
+#include <AudioToolbox/AudioToolbox.h>
+#include <OpenAL/al.h>
+#include <Gosu/IO.hpp>
+#include <GosuImpl/MacUtility.hpp>
+#include <Gosu/Utility.hpp>
+#include <boost/utility.hpp>
+#include <algorithm>
+#include <vector>
+#import <Foundation/Foundation.h>
+
+namespace Gosu
+{
+    class AudioFile : boost::noncopyable
+    {
+        AudioFileID fileID;
+        mutable std::vector<char> decodedData;
+        
+        static OSStatus AudioFile_ReadProc(void* inClientData, SInt64 inPosition, UInt32 requestCount,
+                                           void* buffer, UInt32* actualCount)
+        {
+            const Resource& res = *static_cast<Resource*>(inClientData);
+            *actualCount = std::min<UInt32>(requestCount, res.size() - inPosition);
+            res.read(inPosition, *actualCount, buffer);
+            return noErr;
+        }
+        
+        static SInt64 AudioFile_GetSizeProc(void* inClientData)
+        {
+            const Resource& res = *static_cast<Resource*>(inClientData);
+            return res.size();
+        }
+        
+    public:
+        AudioFile(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
+            CHECK_OS(AudioFileOpenURL((CFURLRef)url.get(), kAudioFileReadPermission, 0, &fileID));
+            #else
+            // Use FSRef for compatibility with 10.4 Tiger.
+            FSRef fsRef;
+            CFURLGetFSRef(reinterpret_cast<CFURLRef>(url.get()), &fsRef);
+            CHECK_OS(AudioFileOpen(&fsRef, fsRdPerm, 0, &fileID));
+            #endif
+        }
+        
+        AudioFile(const Gosu::Resource& resource)
+        {
+            void* clientData = const_cast<Resource*>(&resource);
+            CHECK_OS(AudioFileOpenWithCallbacks(clientData, AudioFile_ReadProc, 0,
+                                                AudioFile_GetSizeProc, 0, 0, &fileID));
+        }
+        
+        ~AudioFile()
+        {
+            AudioFileClose(fileID);
+        }
+        
+        UInt32 getSizeOfData() const
+        {
+            UInt64 sizeOfData = 0;
+            UInt32 sizeOfProperty = sizeof sizeOfData;
+            CHECK_OS(AudioFileGetProperty(fileID, kAudioFilePropertyAudioDataByteCount, &sizeOfProperty, &sizeOfData));
+            return sizeOfData;
+        }
+        
+        std::pair<ALuint, ALuint> getFormatAndSampleRate() const
+        {
+            AudioStreamBasicDescription desc;
+            UInt32 sizeOfProperty = sizeof desc;
+            CHECK_OS(AudioFileGetProperty(fileID, kAudioFilePropertyDataFormat, &sizeOfProperty, &desc));
+            std::pair<ALuint, ALuint> formatAndSampleRate = std::make_pair(0, desc.mSampleRate);
+            if (desc.mChannelsPerFrame == 1)
+                if (desc.mBitsPerChannel == 8)
+                    formatAndSampleRate.first = AL_FORMAT_MONO8;
+                else if (desc.mBitsPerChannel == 16)
+                    formatAndSampleRate.first = AL_FORMAT_MONO16;
+            else if (desc.mChannelsPerFrame == 2)
+                if (desc.mBitsPerChannel == 8)
+                    formatAndSampleRate.first = AL_FORMAT_STEREO8;
+                else if (desc.mBitsPerChannel == 16)
+                    formatAndSampleRate.first = AL_FORMAT_STEREO16;
+            if (formatAndSampleRate.first == 0)
+                throw std::runtime_error("Invalid sample format");
+            return formatAndSampleRate;
+        }
+        
+        const std::vector<char>& getDecodedData() const
+        {
+            if (decodedData.empty())
+            {
+                UInt32 sizeOfData = getSizeOfData();
+                decodedData.resize(sizeOfData);
+                CHECK_OS(AudioFileReadBytes(fileID, false, 0, &sizeOfData, &decodedData[0]));
+            }
+            return decodedData;
+        }
+    };
+}
+
+#endif

data/GosuImpl/AudioOpenAL.mm

@@ -0,0 +1,486 @@
+#include <GosuImpl/MacUtility.hpp>
+#include <GosuImpl/Audio/AudioFileMac.hpp>
+#include <GosuImpl/Audio/ALChannelManagement.hpp>
+
+#include <Gosu/Audio.hpp>
+#include <Gosu/Math.hpp>
+#include <Gosu/IO.hpp>
+#include <Gosu/Utility.hpp>
+#include <Gosu/Platform.hpp>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/lexical_cast.hpp>
+
+#include <cassert>
+#include <cstdlib>
+#include <algorithm>
+#include <stdexcept>
+#include <vector>
+
+#include <OpenAL/al.h>
+#include <OpenAL/alc.h>
+
+#if __LP64__ || NS_BUILD_32_LIKE_64
+typedef long NSInteger;
+typedef unsigned long NSUInteger;
+#else
+typedef int NSInteger;
+typedef unsigned int NSUInteger;
+#endif
+
+using namespace std;
+
+namespace
+{
+    using namespace Gosu;
+    
+    /*GOSU_NORETURN void throwLastALError(const char* action)
+    {
+        string message = "OpenAL error " +
+                         boost::lexical_cast<string>(alcGetError(alDevice));
+        if (action)
+            message += " while ", message += action;
+        throw runtime_error(message);
+    }
+
+    inline void alCheck(const char* action = 0)
+    {
+        if (alcGetError(alDevice) != ALC_NO_ERROR)
+            throwLastALError(action);
+    }*/
+
+    Song* curSong = 0;
+}
+
+Gosu::Audio::Audio()
+{
+    if (alChannelManagement)
+        throw std::logic_error("Multiple Gosu::Audio instances not supported");
+    alChannelManagement.reset(new ALChannelManagement);
+}
+
+Gosu::Audio::~Audio()
+{
+    alChannelManagement.reset();
+}
+
+Gosu::SampleInstance::SampleInstance(int handle, int extra)
+: handle(handle), extra(extra)
+{
+}
+
+bool Gosu::SampleInstance::playing() const
+{
+    NSUInteger source = alChannelManagement->sourceIfStillPlaying(handle, extra);
+    if (source == ALChannelManagement::NO_SOURCE)
+        return false;
+    ALint state;
+    alGetSourcei(source, AL_SOURCE_STATE, &state);
+    return state == AL_PLAYING;
+}
+
+bool Gosu::SampleInstance::paused() const
+{
+    NSUInteger source = alChannelManagement->sourceIfStillPlaying(handle, extra);
+    if (source == ALChannelManagement::NO_SOURCE)
+        return false;
+    ALint state;
+    alGetSourcei(source, AL_SOURCE_STATE, &state);
+    return state == AL_PAUSED;
+}
+
+void Gosu::SampleInstance::pause()
+{
+    NSUInteger source = alChannelManagement->sourceIfStillPlaying(handle, extra);
+    if (source == ALChannelManagement::NO_SOURCE)
+        return;
+    alSourcePause(source);
+}
+
+void Gosu::SampleInstance::resume()
+{
+    NSUInteger source = alChannelManagement->sourceIfStillPlaying(handle, extra);
+    if (source == ALChannelManagement::NO_SOURCE)
+        return;
+    ALint state;
+    alGetSourcei(source, AL_SOURCE_STATE, &state);
+    if (state == AL_PAUSED)
+        alSourcePlay(source);
+}
+
+void Gosu::SampleInstance::stop()
+{
+    NSUInteger source = alChannelManagement->sourceIfStillPlaying(handle, extra);
+    if (source == ALChannelManagement::NO_SOURCE)
+        return;
+    alSourceStop(source);
+}
+
+void Gosu::SampleInstance::changeVolume(double volume)
+{
+    NSUInteger source = alChannelManagement->sourceIfStillPlaying(handle, extra);
+    if (source == ALChannelManagement::NO_SOURCE)
+        return;
+    alSourcef(source, AL_GAIN, volume);
+}
+
+void Gosu::SampleInstance::changePan(double pan)
+{
+    NSUInteger 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);
+}
+
+void Gosu::SampleInstance::changeSpeed(double speed)
+{
+    NSUInteger source = alChannelManagement->sourceIfStillPlaying(handle, extra);
+    if (source == ALChannelManagement::NO_SOURCE)
+        return;
+    alSourcef(source, AL_PITCH, speed);
+}
+
+struct Gosu::Sample::SampleData : boost::noncopyable
+{
+    NSUInteger buffer, source;
+
+    SampleData(const AudioFile& audioFile)
+    {
+        alGenBuffers(1, &buffer);
+        alBufferData(buffer,
+                     audioFile.getFormatAndSampleRate().first,
+                     &audioFile.getDecodedData().front(),
+                     audioFile.getDecodedData().size(),
+                     audioFile.getFormatAndSampleRate().second);
+    }
+
+    ~SampleData()
+    {
+        // It's hard to free things in the right order in Ruby/Gosu.
+        // Make sure buffer isn't deleted after the context/device are shut down.
+        
+        if (!alChannelManagement)
+            return;
+            
+        alDeleteBuffers(1, &buffer);
+    }
+};
+
+Gosu::Sample::Sample(Audio& audio, const std::wstring& filename)
+{
+    AudioFile audioFile(filename);
+    data.reset(new SampleData(audioFile));
+}
+
+Gosu::Sample::Sample(Audio& audio, Reader reader)
+{
+    AudioFile audioFile(reader.resource());
+    data.reset(new SampleData(audioFile));
+}
+
+Gosu::Sample::~Sample()
+{
+}
+
+Gosu::SampleInstance Gosu::Sample::play(double volume, double speed,
+    bool looping) const
+{
+    return playPan(0, volume, speed, looping);
+}
+
+Gosu::SampleInstance Gosu::Sample::playPan(double pan, double volume,
+    double speed, bool looping) const
+{
+    std::pair<int, int> channelAndToken = alChannelManagement->reserveChannel();
+    if (channelAndToken.first == ALChannelManagement::NO_FREE_CHANNEL)
+        return Gosu::SampleInstance(channelAndToken.first, channelAndToken.second);
+        
+    NSUInteger source = alChannelManagement->sourceIfStillPlaying(channelAndToken.first,
+                                                                  channelAndToken.second);
+    assert(source != ALChannelManagement::NO_SOURCE);
+    alSourcei(source, AL_BUFFER, data->buffer);
+    // TODO: This is not the old panning behavior!
+    alSource3f(source, AL_POSITION, pan * 10, 0, 0);
+    alSourcef(source, AL_GAIN, volume);
+    alSourcef(source, AL_PITCH, speed);
+    alSourcei(source, AL_LOOPING, looping ? AL_TRUE : AL_FALSE);
+    alSourcePlay(source);
+
+    return Gosu::SampleInstance(channelAndToken.first, channelAndToken.second);
+}
+
+class Gosu::Song::BaseData : boost::noncopyable
+{
+//    double volume_;
+//
+//protected:
+//    BaseData() : volume_(1) {}
+//    virtual void applyVolume() = 0;
+//
+//public:
+//    virtual ~BaseData() {}
+//
+//    virtual void play(bool looping) = 0;
+//    virtual void pause() = 0;
+//    virtual bool paused() const = 0;
+//    virtual void stop() = 0;
+//    
+//    double volume() const
+//    {
+//        return volume_;
+//    }
+//    
+//    void changeVolume(double volume)
+//    {
+//        volume_ = clamp(volume, 0.0, 1.0);
+//        applyVolume();
+//    }
+};
+
+//class Gosu::Song::StreamData : public BaseData
+//{
+//    FSOUND_STREAM* stream;
+//    int handle;
+//    std::vector<char> buffer;
+//
+//    static signed char F_CALLBACKAPI endSongCallback(FSOUND_STREAM*, void*,
+//        int, void* self)
+//    {
+//        curSong = 0;
+//        static_cast<StreamData*>(self)->handle = -1;
+//        return 0;
+//    }
+//
+//public:
+//    StreamData(Gosu::Reader reader)
+//    : stream(0), handle(-1)
+//    {
+//        buffer.resize(reader.resource().size() - reader.position());
+//        reader.read(&buffer[0], buffer.size());
+//
+//// Disabled for licensing reasons.
+//// If you have a license to play MP3 files, compile with GOSU_ALLOW_MP3.
+//#ifndef GOSU_ALLOW_MP3
+//        if (buffer.size() > 2 &&
+//            ((buffer[0] == '\xff' && (buffer[1] & 0xfe) == '\xfa') ||
+//            (buffer[0] == 'I' && buffer[1] == 'D' && buffer[2] == '3')))
+//        {
+//            throw std::runtime_error("MP3 file playback not allowed");
+//        }
+//#endif
+//
+//        stream = FSOUND_Stream_Open(&buffer[0], FSOUND_LOADMEMORY | FSOUND_LOOP_NORMAL,
+//            0, buffer.size());
+//        if (stream == 0)
+//            throwLastFMODError();
+//        
+//        FSOUND_Stream_SetEndCallback(stream, endSongCallback, this);
+//    }
+//    
+//    ~StreamData()
+//    {
+//        // TODO: Should be checked for earlier, as play would crash too.
+//        // This is just because Ruby's GC will free objects in a weird
+//        // order.
+//        if (!fmodInitialized)
+//            return;
+//
+//        if (stream != 0)
+//            FSOUND_Stream_Close(stream);
+//    }
+//    
+//    void play(bool looping)
+//    {
+//        if (handle == -1)
+//        {
+//            handle = FSOUND_Stream_Play(FSOUND_FREE, stream);
+//                FSOUND_Stream_SetLoopCount(stream, looping ? -1 : 0);
+//        }
+//        else if (paused())
+//            FSOUND_SetPaused(handle, 0);
+//        applyVolume();
+//    }
+//    
+//    void pause()
+//    {
+//        if (handle != -1)
+//            FSOUND_SetPaused(handle, 1);
+//    }
+//    
+//    bool paused() const
+//    {
+//        return handle != -1 && FSOUND_GetPaused(handle);
+//    }
+//    
+//    void stop()
+//    {
+//        fmodCheck(FSOUND_Stream_Stop(stream));
+//        handle = -1; // The end callback is NOT being called!
+//    }
+//    
+//    void applyVolume()
+//    {
+//        if (handle != -1)
+//            FSOUND_SetVolume(handle, static_cast<int>(volume() * 255));
+//    }
+//};
+//
+//class Gosu::Song::ModuleData : public Gosu::Song::BaseData
+//{
+//    FMUSIC_MODULE* module_;
+//
+//public:
+//    ModuleData(Reader reader)
+//    : module_(0)
+//    {
+//        std::vector<char> buffer(reader.resource().size() - reader.position());
+//        reader.read(&buffer[0], buffer.size());
+//
+//        module_ = FMUSIC_LoadSongEx(&buffer[0], 0, buffer.size(),
+//            FSOUND_LOADMEMORY | FSOUND_LOOP_OFF, 0, 0);
+//        if (module_ == 0)
+//            throwLastFMODError();
+//    }
+//
+//    ~ModuleData()
+//    {
+//        // TODO: Should be checked for earlier, as play would crash too.
+//        // This is just because Ruby's GC will free objects in a weird
+//        // order.
+//        if (!fmodInitialized)
+//            return;
+//
+//        if (module_ != 0)
+//            FMUSIC_FreeSong(module_);
+//    }
+//
+//    void play(bool looping)
+//    {
+//        if (paused())
+//            FMUSIC_SetPaused(module_, 0);
+//        else
+//            FMUSIC_PlaySong(module_);
+//        FMUSIC_SetLooping(module_, looping);
+//        applyVolume();
+//    }
+//    
+//    void pause()
+//    {
+//        FMUSIC_SetPaused(module_, 1);
+//    }
+//    
+//    bool paused() const
+//    {
+//        return FMUSIC_GetPaused(module_);
+//    }
+//
+//    void stop()
+//    {
+//        fmodCheck(FMUSIC_StopSong(module_));
+//        FMUSIC_SetPaused(module_, false);
+//    }
+//    
+//    void applyVolume()
+//    {
+//        // Weird as it may seem, the FMOD doc really says volume can
+//        // be 0 to 256, *inclusive*, for this function.
+//        FMUSIC_SetMasterVolume(module_, static_cast<int>(volume() * 256.0));
+//    }
+//};
+//
+Gosu::Song::Song(Audio& audio, const std::wstring& filename)
+{
+//    Buffer buf;
+//	loadFile(buf, filename);
+//	Type type = stStream;
+//    
+//	using boost::iends_with;
+//	if (iends_with(filename, ".mod") || iends_with(filename, ".mid") ||
+//	    iends_with(filename, ".s3m") || iends_with(filename, ".it") ||
+//	    iends_with(filename, ".xm"))
+//	{
+//	      type = stModule;
+//	}
+//	
+//    // Forward.
+//	Song(audio, type, buf.frontReader()).data.swap(data);
+}
+
+Gosu::Song::Song(Audio& audio, Type type, Reader reader)
+{
+//    switch (type)
+//    {
+//    case stStream:
+//        data.reset(new StreamData(reader));
+//        break;
+//
+//    case stModule:
+//        data.reset(new ModuleData(reader));
+//        break;
+//
+//    default:
+//        throw std::logic_error("Invalid song type");
+//    }
+}
+
+Gosu::Song::~Song()
+{
+    if (alChannelManagement)
+        stop();
+}
+
+Gosu::Song* Gosu::Song::currentSong()
+{
+    return curSong;
+}
+
+void Gosu::Song::play(bool looping)
+{
+//    if (curSong && curSong != this)
+//    {
+//        curSong->stop();
+//        assert(curSong == 0);
+//    }
+//
+//    data->play(looping);
+//    curSong = this; // may be redundant
+}
+
+void Gosu::Song::pause()
+{
+//    if (curSong == this)
+//        data->pause(); // may be redundant
+}
+
+bool Gosu::Song::paused() const
+{
+//    return curSong == this && data->paused();
+return false;
+}
+
+void Gosu::Song::stop()
+{
+//    if (curSong == this)
+//    {
+//        data->stop();
+//        curSong = 0;
+//    }
+}
+
+bool Gosu::Song::playing() const
+{
+//    return curSong == this && !data->paused();
+return false;
+}
+
+double Gosu::Song::volume() const
+{
+//    return data->volume();
+return 0;
+}
+
+void Gosu::Song::changeVolume(double volume)
+{
+//    data->changeVolume(volume);
+}