gosu 0.7.13.3 → 0.7.14

data/Gosu/Audio.hpp

@@ -26,12 +26,14 @@ namespace Gosu
     class Audio : boost::noncopyable
     {
     public:
-#ifdef GOSU_IS_WIN
+        #ifdef GOSU_IS_WIN
         explicit Audio(HWND window);
-#else
+        #else
         Audio();
-#endif
+        #endif
         ~Audio();
+        
+        void update();
     };
 
     //! An instance of a Sample playing. Can be used to stop sounds dynamically,
@@ -117,7 +119,11 @@ namespace Gosu
         class ModuleData;
         class StreamData;
         boost::scoped_ptr<BaseData> data;
-
+        
+        #ifdef GOSU_IS_MAC
+        void update();
+        friend class Audio;
+        #endif
     public:
         //! There are two types of songs that can be loaded as a Song: Streamed
         //! songs (like OGG) and modules (like MOD or XM).

data/Gosu/Math.hpp

@@ -8,14 +8,14 @@ namespace Gosu
 {
     //! Pi.
     const double pi = 3.1415926536;
-
+    
     //! Truncates the fractional part of a real value. Equivalent to
     //! static_cast<long>.
     inline long trunc(double value)
     {
         return static_cast<long>(value);
     }
-
+    
     //! Rounds a real value towards the next integer.
     inline long round(double value)
     {
@@ -24,11 +24,11 @@ namespace Gosu
         else
             return static_cast<long>(value - 0.5);
     }
-
-    //! Returns a real value between min and max. Uses std::rand (so you have
-    //! to call std::srand before using it).
+    
+    //! Returns a real value between min (inclusive) and max (exclusive).
+    //! Uses std::rand, so you should call std::srand before using it.
     double random(double min, double max);
-
+    
     //! Translates between Gosu's angle system and radians.
     inline double gosuToRadians(double angle)
     {
@@ -40,6 +40,19 @@ namespace Gosu
         return angle * 180 / pi + 90;
     }
 
+    //! Translates between Gosu's angle scaling and radians, i.e. it
+    //! does not change the 'origin' of the angle system.
+    inline double gosuToRadianScale(double angle)
+    {
+        return angle * pi / 180;
+    }
+    //! Translates between Gosu's angle scaling and radians, i.e. it
+    //! does not change the 'origin' of the angle system.
+    inline double radiansScaleToGosu(double angle)
+    {
+        return angle * 180 / pi;
+    }
+    
     //! Returns the horizontal distance between the origin and the point to
     //! which you would get if you moved radius pixels in the direction
     //! specified by angle.
@@ -59,14 +72,14 @@ namespace Gosu
     double angleDiff(double angle1, double angle2);
     //! Normalizes an angle to fit into the range [0; 360[.
     double normalizeAngle(double angle);
-
+    
     //! Returns value * value.
     template<typename T>
     T square(T value)
     {
         return value * value;
     }
-
+    
     //! Returns min if value is smaller than min, max if value is larger than
     //! max and value otherwise.
     template<typename T>
@@ -85,13 +98,13 @@ namespace Gosu
     {
         return clamp(value, min, max);
     }
-
+    
     //! Returns the square of the distance between two points.
     inline double distanceSqr(double x1, double y1, double x2, double y2)
     {
         return square(x1 - x2) + square(y1 - y2);
     }
-
+    
     //! Returns the distance between two points.
     double distance(double x1, double y1, double x2, double y2);
     

data/Gosu/Platform.hpp

@@ -5,11 +5,13 @@
 #define GOSU_PLATFORM_HPP
 
 #ifdef __BIG_ENDIAN__
+#define GOSU_IS_BIG_ENDIAN
 #define IDENTITY_FUN bigToNative
 #define IDENTITY_FUN2 nativeToBig
 #define CONV_FUN littleToNative
 #define CONV_FUN2 nativeToLittle
 #else
+#define GOSU_IS_LITTLE_ENDIAN
 #define IDENTITY_FUN littleToNative
 #define IDENTITY_FUN2 nativeToLittle
 #define CONV_FUN bigToNative

data/Gosu/Version.hpp

@@ -0,0 +1,9 @@
+#ifndef GOSU_VERSION_HPP
+#define GOSU_VERSION_HPP
+
+#define GOSU_MAJOR_VERSION 0
+#define GOSU_MINOR_VERSION 7
+#define GOSU_POINT_VERSION 14
+#define GOSU_VERSION "0.7.14"
+
+#endif

data/GosuImpl/Audio/ALChannelManagement.hpp

@@ -18,7 +18,12 @@ namespace Gosu
         
     public:
         enum { NO_TOKEN = -1, NO_SOURCE = -1, NO_FREE_CHANNEL = -1 };
-    
+        
+        static ALCdevice* device()
+        {
+            return alDevice;
+        }
+        
         ALChannelManagement()
         {
             // Open preferred device
@@ -42,7 +47,7 @@ namespace Gosu
         std::pair<int, int> reserveChannel()
         {
             int i;
-            for (i = 0; i <= NUM_SOURCES; ++i)
+            for (i = 1; i <= NUM_SOURCES; ++i)
             {
                 if (i == NUM_SOURCES)
                     return std::make_pair<int, int>(NO_FREE_CHANNEL, NO_TOKEN);
@@ -60,10 +65,15 @@ namespace Gosu
         
         int sourceIfStillPlaying(int channel, int token) const
         {
-            if (currentTokens[channel] == token)
+            if (channel != NO_FREE_CHANNEL && currentTokens[channel] == token)
                 return alSources[channel];
             return NO_SOURCE;
         }
+        
+        int sourceForSongs() const
+        {
+            return alSources[0];
+        }
     };
     ALCdevice* ALChannelManagement::alDevice = 0;
     ALCcontext* ALChannelManagement::alContext = 0;

data/GosuImpl/Audio/AudioFile.hpp

@@ -0,0 +1,45 @@
+#ifndef GOSUIMPL_AUDIO_AUDIOFILE_HPP
+#define GOSUIMPL_AUDIO_AUDIOFILE_HPP
+
+#include <boost/noncopyable.hpp>
+#include <vector>
+#import <OpenAL/al.h>
+
+namespace Gosu
+{
+    class AudioFile : boost::noncopyable
+    {
+        std::vector<char> decodedData_;
+        
+    public:
+        virtual ~AudioFile() {}
+        virtual ALenum format() const = 0;
+        virtual ALuint sampleRate() const = 0;
+        virtual std::size_t readData(void* dest, std::size_t length) = 0;
+        virtual void rewind() = 0;
+        
+        const std::vector<char>& decodedData()
+        {
+            static const unsigned INCREMENT = 512*1024;
+            
+            if (!decodedData_.empty())
+                return decodedData_;
+            
+            for (;;)
+            {
+                decodedData_.resize(decodedData_.size() + INCREMENT);
+                int readBytes = readData(&decodedData_[decodedData_.size() - INCREMENT],
+                                    INCREMENT);
+                if (readBytes < INCREMENT)
+                {
+                    decodedData_.resize(decodedData_.size() - INCREMENT + readBytes);
+                    break;
+                }
+            }
+            
+            return decodedData_;
+        }
+    };
+}
+
+#endif

data/GosuImpl/Audio/AudioOpenAL.mm

@@ -0,0 +1,533 @@
+#include <GosuImpl/MacUtility.hpp>
+#include <GosuImpl/Audio/AudioToolboxFile.hpp>
+#include <GosuImpl/Audio/ALChannelManagement.hpp>
+#include <GosuImpl/Audio/OggFile.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 <boost/optional.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(ALChannelManagement::device()));
+        if (action)
+            message += " while ", message += action;
+        throw runtime_error(message);
+    }
+
+    inline void alCheck(const char* action = 0)
+    {
+        if (alcGetError(ALChannelManagement::device()) != ALC_NO_ERROR)
+            throwLastALError(action);
+    }
+    
+    bool isOggFile(Gosu::Reader reader)
+    {
+        char magicBytes[4];
+        reader.read(magicBytes, 4);
+        return magicBytes[0] == 'O' && magicBytes[1] == 'g' &&
+               magicBytes[2] == 'g' && magicBytes[3] == 'S';
+    }
+
+    bool isOggFile(const std::wstring& filename)
+    {
+        Gosu::File file(filename);
+        return isOggFile(file.frontReader());
+    }
+    
+    Song* curSong = 0;
+    bool curSongLooping;
+}
+
+Gosu::Audio::Audio()
+{
+    if (alChannelManagement)
+        throw std::logic_error("Multiple Gosu::Audio instances not supported");
+    alChannelManagement.reset(new ALChannelManagement);
+}
+
+Gosu::Audio::~Audio()
+{
+    alChannelManagement.reset();
+}
+
+void Gosu::Audio::update()
+{
+    if (Song::currentSong())
+        Song::currentSong()->update();
+}
+
+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(AudioFile& audioFile)
+    {
+        alGenBuffers(1, &buffer);
+        alBufferData(buffer,
+                     audioFile.format(),
+                     &audioFile.decodedData().front(),
+                     audioFile.decodedData().size(),
+                     audioFile.sampleRate());
+    }
+    
+    ~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)
+{
+    if (isOggFile(filename))
+    {
+        Gosu::Buffer buffer;
+        Gosu::loadFile(buffer, filename);
+        OggFile oggFile(buffer.frontReader());
+        data.reset(new SampleData(oggFile));
+    }
+    else
+    {
+        AudioToolboxFile audioFile(filename);
+        data.reset(new SampleData(audioFile));
+    }
+}
+
+Gosu::Sample::Sample(Audio& audio, Reader reader)
+{
+    if (isOggFile(reader))
+    {
+        OggFile oggFile(reader);
+        data.reset(new SampleData(oggFile));
+    }
+    else
+    {
+        AudioToolboxFile audioFile(reader);
+        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() = 0;
+    virtual void pause() = 0;
+    virtual void resume() = 0;
+    virtual bool paused() const = 0;
+    virtual void stop() = 0;
+    
+    virtual void update() = 0;
+    
+    double volume() const
+    {
+        return volume_;
+    }
+    
+    void changeVolume(double volume)
+    {
+        volume_ = clamp(volume, 0.0, 1.0);
+        applyVolume();
+    }
+};
+
+class Gosu::Song::StreamData : public BaseData
+{
+    boost::scoped_ptr<AudioFile> file;
+    NSUInteger buffers[2];
+    
+    void applyVolume()
+    {
+        int source = lookupSource();
+        if (source != ALChannelManagement::NO_SOURCE)
+            alSourcef(source, AL_GAIN, volume());
+    }
+    
+    int lookupSource() const
+    {
+        return alChannelManagement->sourceForSongs();
+    }
+    
+    bool streamToBuffer(NSUInteger buffer)
+    {
+        #ifdef GOSU_IS_IPHONE
+        static const unsigned BUFFER_SIZE = 4096 * 4;
+        #else
+        static const unsigned BUFFER_SIZE = 4096 * 8;
+        #endif
+        char audioData[BUFFER_SIZE];
+        std::size_t readBytes = file->readData(audioData, BUFFER_SIZE);
+        if (readBytes > 0)
+            alBufferData(buffer, file->format(), audioData, readBytes, file->sampleRate());
+        return readBytes > 0;
+    }
+    
+public:
+    StreamData(const std::wstring& filename)
+    {
+        if (isOggFile(filename))
+        {
+            Gosu::File sourceFile(filename);
+            file.reset(new OggFile(sourceFile.frontReader()));
+        }
+        else
+            file.reset(new AudioToolboxFile(filename));
+        alGenBuffers(2, buffers);
+    }
+
+    StreamData(Reader reader)
+    {
+        if (isOggFile(reader))
+            file.reset(new OggFile(reader));
+        else
+            file.reset(new AudioToolboxFile(reader));
+        alGenBuffers(2, buffers);
+    }
+    
+    ~StreamData()
+    {
+        if (alChannelManagement)
+        {
+            stop();
+            alDeleteBuffers(2, buffers);
+        }
+    }
+    
+    void play()
+    {
+        int source = lookupSource();
+        if (source != ALChannelManagement::NO_SOURCE)
+        {
+            alSource3f(source, AL_POSITION, 0, 0, 0);
+            alSourcef(source, AL_GAIN, volume());
+            alSourcef(source, AL_PITCH, 1);
+            alSourcei(source, AL_LOOPING, AL_FALSE); // need to implement this manually...
+
+            streamToBuffer(buffers[0]);
+            streamToBuffer(buffers[1]);
+            
+            // TODO: Not good for songs with less than two buffers full of data.
+            
+            alSourceQueueBuffers(source, 2, buffers);
+            alSourcePlay(source);
+        }
+    }
+
+    void stop()
+    {
+        int source = lookupSource();
+        if (source != ALChannelManagement::NO_SOURCE)
+        {
+            alSourceStop(source);
+
+            NSUInteger buffer;
+            
+            // The number of QUEUED buffers apparently includes the number of
+            // PROCESSED ones, so getting rid of the QUEUED ones is enough.
+            
+            int queued;
+            alGetSourcei(source, AL_BUFFERS_QUEUED, &queued);
+            while (queued--)
+                alSourceUnqueueBuffers(source, 1, &buffer);
+
+            //int processed;
+            //alGetSourcei(source, AL_BUFFERS_PROCESSED, &processed);
+            //while (processed--)
+            //    alSourceUnqueueBuffers(source, 1, &buffer);
+        }
+        file->rewind();
+    }
+    
+    void pause()
+    {
+        int source = lookupSource();
+        if (source != ALChannelManagement::NO_SOURCE)
+            alSourcePause(source);
+    }
+    
+    void resume()
+    {
+        int source = lookupSource();
+        if (source != ALChannelManagement::NO_SOURCE)
+            alSourcePlay(source);
+    }
+    
+    bool paused() const
+    {
+        int source = lookupSource();
+        if (source == ALChannelManagement::NO_SOURCE)
+            return false;
+        ALint state;
+        alGetSourcei(source, AL_SOURCE_STATE, &state);
+        return state == AL_PAUSED;
+    }
+    
+    void update()
+    {
+        int source = lookupSource();
+
+        NSUInteger buffer;
+        int queued, processed;
+        bool active = true;
+        
+        alGetSourcei(source, AL_BUFFERS_PROCESSED, &processed);
+        for (int i = 0; i < processed; ++i)
+        {
+            alSourceUnqueueBuffers(source, 1, &buffer);
+            active = streamToBuffer(buffer);
+            if (active)
+                alSourceQueueBuffers(source, 1, &buffer);
+        }
+        
+        ALint state;
+        alGetSourcei(source, AL_SOURCE_STATE, &state);
+        if (active && state != AL_PLAYING && state != AL_PAUSED)
+        {
+            // We seemingly got starved.
+            alSourcePlay(source);
+        }
+        else if (!active)
+        {
+            // We got starved and there is nothing to play left.
+            // In any case, shut down the playback logic for a moment.
+            stop();
+
+            if (curSongLooping)
+                // Start anew.
+                play();
+            else
+                // Let the world know we're finished.
+                curSong = 0;
+        }
+    }
+};
+
+void Gosu::Song::update()
+{
+    data->update();
+}
+
+Gosu::Song::Song(Audio& audio, const std::wstring& filename)
+: data(new StreamData(filename))
+{
+}
+
+Gosu::Song::Song(Audio& audio, Type type, Reader reader)
+: data(new StreamData(reader))
+{
+}
+
+Gosu::Song::~Song()
+{
+    if (alChannelManagement)
+        stop();
+}
+
+Gosu::Song* Gosu::Song::currentSong()
+{
+    return curSong;
+}
+
+void Gosu::Song::play(bool looping)
+{
+    if (paused())
+        data->resume();
+    
+    if (curSong && curSong != this)
+    {
+        curSong->stop();
+        assert(curSong == 0);
+    }
+    
+    if (curSong == 0)
+        data->play();
+    
+    curSong = this;
+    curSongLooping = looping;
+}
+
+void Gosu::Song::pause()
+{
+    if (curSong == this)
+        data->pause(); // may be redundant
+}
+
+bool Gosu::Song::paused() const
+{
+    return curSong == this && data->paused();
+}
+
+void Gosu::Song::stop()
+{
+    if (curSong == this)
+    {
+        data->stop();
+        curSong = 0;
+    }
+}
+
+bool Gosu::Song::playing() const
+{
+    return curSong == this && !data->paused();
+}
+
+double Gosu::Song::volume() const
+{
+    return data->volume();
+}
+
+void Gosu::Song::changeVolume(double volume)
+{
+    data->changeVolume(volume);
+}