gosu 1.3.0 → 1.4.0

data/src/Audio.cpp

@@ -1,33 +1,32 @@
-#include "AudioImpl.hpp"
-#include "AudioFile.hpp"
-
 #include <Gosu/Audio.hpp>
-#include <Gosu/Math.hpp>
 #include <Gosu/IO.hpp>
-#include <Gosu/Platform.hpp>
-#include <Gosu/Utility.hpp>
-
-#include <cassert>
-#include <cstdlib>
+#include <Gosu/Math.hpp>
+#include "AudioFile.hpp"
+#include "AudioImpl.hpp"
 #include <algorithm>
-using namespace std;
+#include <cassert>
 
+// These are global variables and not even thread-safe at that, but Gosu::Song is a legacy construct
+// that will be replaced by a unified Sound class anyway in #562.
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 static Gosu::Song* cur_song = nullptr;
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 static bool cur_song_looping;
 
-struct Gosu::Sample::Impl
+struct Gosu::Sample::Impl : Gosu::Noncopyable
 {
     ALuint buffer;
 
-    Impl(AudioFile&& audio_file)
+    explicit Impl(AudioFile&& audio_file)
+    : buffer{}
     {
         al_initialize();
         alGenBuffers(1, &buffer);
         alBufferData(buffer, audio_file.format(), &audio_file.decoded_data().front(),
                      static_cast<ALsizei>(audio_file.decoded_data().size()),
-                     audio_file.sample_rate());
+                     static_cast<ALsizei>(audio_file.sample_rate()));
     }
-    
+
     ~Impl()
     {
         // It's hard to free things in the right order in Ruby/Gosu.
@@ -42,103 +41,104 @@ Gosu::Sample::Sample()
 {
 }
 
-Gosu::Sample::Sample(const string& filename)
+Gosu::Sample::Sample(const std::string& filename)
+: m_impl{new Impl(AudioFile(filename))}
 {
-    pimpl.reset(new Impl(AudioFile(filename)));
 }
 
 Gosu::Sample::Sample(Gosu::Reader reader)
+: m_impl{new Impl(AudioFile(reader))}
 {
-    pimpl.reset(new Impl(AudioFile(reader)));
 }
 
 Gosu::Channel Gosu::Sample::play(double volume, double speed, bool looping) const
 {
-    return play_pan(0, volume, speed, looping);
+    return play_pan(0.0, volume, speed, looping);
 }
 
 Gosu::Channel Gosu::Sample::play_pan(double pan, double volume, double speed, bool looping) const
 {
-    if (!pimpl) return Channel();
+    if (!m_impl) return Channel{};
 
     Channel channel = allocate_channel();
-    
+
     // Couldn't allocate a free channel.
     if (channel.current_channel() == NO_CHANNEL) return channel;
-    
+
     ALuint source = al_source_for_channel(channel.current_channel());
-    alSourcei(source, AL_BUFFER, pimpl->buffer);
-    alSource3f(source, AL_POSITION, pan * 10, 0, 0);
-    alSourcef(source, AL_GAIN, max(volume, 0.0));
-    alSourcef(source, AL_PITCH, speed);
+    alSourcei(source, AL_BUFFER, static_cast<ALint>(m_impl->buffer));
+    alSource3f(source, AL_POSITION, static_cast<ALfloat>(pan * 10), 0, 0);
+    alSourcef(source, AL_GAIN, static_cast<ALfloat>(std::max(volume, 0.0)));
+    alSourcef(source, AL_PITCH, static_cast<ALfloat>(speed));
     alSourcei(source, AL_LOOPING, looping ? AL_TRUE : AL_FALSE);
     alSourcePlay(source);
     return channel;
 }
 
 // AudioFile impl
-struct Gosu::Song::Impl
+struct Gosu::Song::Impl : Gosu::Noncopyable
 {
-    double volume_ = 1.0;
-    unique_ptr<AudioFile> file;
-    ALuint buffers[2];
-    
+private:
+    double m_volume = 1.0;
+    std::unique_ptr<AudioFile> m_file;
+    ALuint m_buffers[2];
+
     void apply_volume()
     {
-        alSourcef(al_source_for_songs(), AL_GAIN, max(volume(), 0.0));
+        alSourcef(al_source_for_songs(), AL_GAIN, static_cast<ALfloat>(std::max(volume(), 0.0)));
     }
-    
+
     bool stream_to_buffer(ALuint buffer)
     {
         char audio_data[4096 * 8];
-        size_t read_bytes = file->read_data(audio_data, sizeof audio_data);
+        size_t read_bytes = m_file->read_data(audio_data, sizeof audio_data);
         if (read_bytes > 0) {
-            alBufferData(buffer, file->format(), audio_data,
-                         static_cast<ALsizei>(read_bytes), file->sample_rate());
+            alBufferData(buffer, m_file->format(), audio_data, static_cast<ALsizei>(read_bytes),
+                         static_cast<ALsizei>(m_file->sample_rate()));
         }
         return read_bytes > 0;
     }
-    
+
 public:
-    explicit Impl(const string& filename)
+    explicit Impl(const std::string& filename)
+    : m_buffers{},
+      m_file{new AudioFile{filename}}
     {
-        file.reset(new AudioFile(filename));
-
         al_initialize();
-        alGenBuffers(2, buffers);
+        alGenBuffers(2, m_buffers);
     }
 
     explicit Impl(Reader reader)
+    : m_buffers{},
+      m_file{new AudioFile{reader}}
     {
-        file.reset(new AudioFile(reader));
-
         al_initialize();
-        alGenBuffers(2, buffers);
+        alGenBuffers(2, m_buffers);
     }
-    
+
     ~Impl()
     {
         // It's hard to free things in the right order in Ruby/Gosu.
         // Make sure buffers aren't deleted after the context/device are shut down.
         if (!al_initialized()) return;
-        
-        alDeleteBuffers(2, buffers);
+
+        alDeleteBuffers(2, m_buffers);
     }
-    
-    void play(bool looping)
+
+    void play()
     {
         ALuint source = al_source_for_songs();
 
         alSource3f(source, AL_POSITION, 0, 0, 0);
-        alSourcef(source, AL_GAIN, max(volume(), 0.0));
+        alSourcef(source, AL_GAIN, static_cast<ALfloat>(std::max(volume(), 0.0)));
         alSourcef(source, AL_PITCH, 1);
         alSourcei(source, AL_LOOPING, AL_FALSE); // need to implement this manually...
 
-        stream_to_buffer(buffers[0]);
-        stream_to_buffer(buffers[1]);
-        
+        stream_to_buffer(m_buffers[0]);
+        stream_to_buffer(m_buffers[1]);
+
         // TODO: Not good for songs with less than two buffers full of data.
-        alSourceQueueBuffers(source, 2, buffers);
+        alSourceQueueBuffers(source, 2, m_buffers);
         alSourcePlay(source);
     }
 
@@ -148,7 +148,7 @@ public:
 
         alSourceStop(source);
 
-        // Unqueue all buffers for this source.
+        // Dequeue all buffers for this source.
         // The number of QUEUED buffers apparently includes the number of PROCESSED ones,
         // so getting rid of the QUEUED ones is enough.
         ALuint buffer;
@@ -157,27 +157,27 @@ public:
         while (queued--) {
             alSourceUnqueueBuffers(source, 1, &buffer);
         }
-        
-        file->rewind();
+
+        m_file->rewind();
     }
-    
-    void pause()
+
+    static void pause() //
     {
         alSourcePause(al_source_for_songs());
     }
-    
-    void resume()
+
+    static void resume() //
     {
         alSourcePlay(al_source_for_songs());
     }
-    
-    bool paused() const
+
+    static bool paused()
     {
         ALint state;
         alGetSourcei(al_source_for_songs(), AL_SOURCE_STATE, &state);
         return state == AL_PAUSED;
     }
-    
+
     void update()
     {
         ALuint source = al_source_for_songs();
@@ -185,14 +185,14 @@ public:
         ALuint buffer;
         int processed;
         bool active = true;
-        
+
         alGetSourcei(source, AL_BUFFERS_PROCESSED, &processed);
         for (int i = 0; i < processed; ++i) {
             alSourceUnqueueBuffers(source, 1, &buffer);
             active = stream_to_buffer(buffer);
             if (active) alSourceQueueBuffers(source, 1, &buffer);
         }
-        
+
         ALint state;
         alGetSourcei(source, AL_SOURCE_STATE, &state);
         if (active && state != AL_PLAYING && state != AL_PAUSED) {
@@ -205,7 +205,7 @@ public:
 
             if (cur_song_looping) {
                 // Start anew.
-                play(true);
+                play();
             }
             else {
                 // Let the world know we're finished.
@@ -213,27 +213,27 @@ public:
             }
         }
     }
-    
+
     double volume() const
     {
-        return volume_;
+        return m_volume;
     }
-    
+
     void set_volume(double volume)
     {
-        volume_ = clamp(volume, 0.0, 1.0);
+        m_volume = std::clamp(volume, 0.0, 1.0);
         apply_volume();
     }
 };
 
-Gosu::Song::Song(const string& filename)
+Gosu::Song::Song(const std::string& filename)
+: m_impl{new Impl(filename)}
 {
-    pimpl.reset(new Impl(filename));
 }
 
 Gosu::Song::Song(Reader reader)
+: m_impl{new Impl(reader)}
 {
-    pimpl.reset(new Impl(reader));
 }
 
 Gosu::Song::~Song()
@@ -249,18 +249,18 @@ Gosu::Song* Gosu::Song::current_song()
 void Gosu::Song::play(bool looping)
 {
     if (paused()) {
-        pimpl->resume();
+        m_impl->resume();
     }
-    
+
     if (cur_song && cur_song != this) {
         cur_song->stop();
-        assert (cur_song == nullptr);
+        assert(cur_song == nullptr);
     }
-    
+
     if (cur_song == nullptr) {
-        pimpl->play(looping);
+        m_impl->play();
     }
-    
+
     cur_song = this;
     cur_song_looping = looping;
 }
@@ -268,41 +268,41 @@ void Gosu::Song::play(bool looping)
 void Gosu::Song::pause()
 {
     if (cur_song == this) {
-        pimpl->pause();
+        m_impl->pause();
     }
 }
 
 bool Gosu::Song::paused() const
 {
-    return cur_song == this && pimpl->paused();
+    return cur_song == this && m_impl->paused();
 }
 
 void Gosu::Song::stop()
 {
     if (cur_song == this) {
-        pimpl->stop();
+        m_impl->stop();
         cur_song = nullptr;
     }
 }
 
 bool Gosu::Song::playing() const
 {
-    return cur_song == this && !pimpl->paused();
+    return cur_song == this && !m_impl->paused();
 }
 
 double Gosu::Song::volume() const
 {
-    return pimpl->volume();
+    return m_impl->volume();
 }
 
 void Gosu::Song::set_volume(double volume)
 {
-    pimpl->set_volume(volume);
+    m_impl->set_volume(volume);
 }
 
 void Gosu::Song::update()
 {
     if (current_song()) {
-        current_song()->pimpl->update();
+        current_song()->m_impl->update();
     }
 }

data/src/AudioFile.hpp

@@ -2,7 +2,7 @@
 
 #include <Gosu/IO.hpp>
 
-#ifdef GOSU_IS_MAC
+#ifdef GOSU_IS_IPHONE
 // Ignore OpenAL deprecation warnings. If macOS stops shipping OpenAL, it's more likely that we bundle our own version
 // of it than that we switch to another audio API.
 #define OPENAL_DEPRECATED
@@ -21,20 +21,20 @@ namespace Gosu
     {
         struct Impl;
         std::unique_ptr<Impl> pimpl;
-        
+
     public:
         explicit AudioFile(const std::string& filename);
         explicit AudioFile(Reader reader);
         ~AudioFile();
 
         ALenum format() const;
-        
+
         ALuint sample_rate() const;
-        
+
         std::size_t read_data(void* dest, std::size_t length);
-        
+
         void rewind();
-        
+
         const std::vector<char>& decoded_data();
     };
 }

data/src/AudioFileAudioToolbox.cpp

@@ -35,7 +35,7 @@ static void throw_os_error(OSStatus status, unsigned line)
 
 #define CHECK_OS(status) do { if (status) throw_os_error(status, __LINE__); } while (0)
 
-struct Gosu::AudioFile::Impl
+struct Gosu::AudioFile::Impl : Gosu::Noncopyable
 {
     Buffer buffer;
     AudioFileID file_id;

data/src/AudioFileSDLSound.cpp

@@ -14,7 +14,7 @@
 #include <mutex>
 #include <vector>
 
-struct Gosu::AudioFile::Impl
+struct Gosu::AudioFile::Impl : Gosu::Noncopyable
 {
     Buffer buffer;
 

data/src/AudioImpl.hpp

@@ -2,7 +2,7 @@
 
 #include <Gosu/Audio.hpp>
 #include <Gosu/Platform.hpp>
-#ifdef GOSU_IS_MAC
+#ifdef GOSU_IS_IPHONE
 // Ignore OpenAL deprecation warnings. If macOS stops shipping OpenAL, it's more likely that we bundle our own version
 // of it than that we switch to another audio API.
 #define OPENAL_DEPRECATED
@@ -17,18 +17,18 @@ namespace Gosu
 {
     void al_initialize();
     bool al_initialized();
-    
+
     // Will initialize OpenAL if necessary.
     ALCdevice* al_device();
     // Will initialize OpenAL if necessary.
     ALCcontext* al_context();
-    
+
     const int NO_CHANNEL = -1;
-    
+
     // Returns an expired Channel if no channel is free.
     // Will initialize OpenAL if necessary.
     Channel allocate_channel();
-    
+
     bool channel_expired(int channel, int token);
     ALuint al_source_for_channel(int channel);
     ALuint al_source_for_songs();

data/src/BitmapIO.cpp

@@ -7,18 +7,8 @@
 #define STBI_NO_STDIO
 #define STBI_NO_LINEAR
 
-// Disable comma warnings in stb headers.
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wcomma"
-#endif
-
 #include <stb_image.h>
 
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-
 static int read_callback(void* user, char* data, int size)
 {
     Gosu::Reader* reader = static_cast<Gosu::Reader*>(user);
@@ -82,19 +72,9 @@ Gosu::Bitmap Gosu::load_image_file(Reader input)
     return bitmap;
 }
 
-// Disable comma warnings in stb headers.
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wcomma"
-#endif
-
 #define STB_IMAGE_WRITE_IMPLEMENTATION
 #include <stb_image_write.h>
 
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-
 void Gosu::save_image_file(const Gosu::Bitmap& bitmap, const std::string& filename)
 {
     int ok;

data/src/BlockAllocator.cpp

@@ -1,9 +1,10 @@
+#include <Gosu/Utility.hpp>
 #include "BlockAllocator.hpp"
 #include <stdexcept>
 #include <vector>
 using namespace std;
 
-struct Gosu::BlockAllocator::Impl
+struct Gosu::BlockAllocator::Impl : Gosu::Noncopyable
 {
     unsigned width, height;
 

data/src/Channel.cpp

@@ -1,8 +1,8 @@
 #include <Gosu/Audio.hpp>
 #include "AudioImpl.hpp"
-using namespace std;
+#include <algorithm>
 
-// Returns the current state of a source
+/// Returns the current state of a source.
 static ALint state(int& channel)
 {
     ALint state;
@@ -14,41 +14,43 @@ static ALint state(int& channel)
 }
 
 Gosu::Channel::Channel()
-: channel(NO_CHANNEL), token(0)
+: m_channel{NO_CHANNEL},
+  m_token{0}
 {
 }
 
 Gosu::Channel::Channel(int channel, int token)
-: channel(channel), token(token)
+: m_channel{channel},
+  m_token{token}
 {
 }
 
 int Gosu::Channel::current_channel() const
 {
-    if (channel != NO_CHANNEL && channel_expired(channel, token)) {
-        channel = NO_CHANNEL;
+    if (m_channel != NO_CHANNEL && channel_expired(m_channel, m_token)) {
+        m_channel = NO_CHANNEL;
     }
-    return channel;
+    return m_channel;
 }
 
 bool Gosu::Channel::playing() const
 {
     if (current_channel() == NO_CHANNEL) return false;
-    
-    return state(channel) == AL_PLAYING;
+
+    return state(m_channel) == AL_PLAYING;
 }
 
 bool Gosu::Channel::paused() const
 {
     if (current_channel() == NO_CHANNEL) return false;
 
-    return state(channel) == AL_PAUSED;
+    return state(m_channel) == AL_PAUSED;
 }
 
 void Gosu::Channel::pause()
 {
     if (playing()) {
-        ALuint source = al_source_for_channel(channel);
+        ALuint source = al_source_for_channel(m_channel);
         alSourcePause(source);
     }
 }
@@ -56,7 +58,7 @@ void Gosu::Channel::pause()
 void Gosu::Channel::resume()
 {
     if (paused()) {
-        ALuint source = al_source_for_channel(channel);
+        ALuint source = al_source_for_channel(m_channel);
         alSourcePlay(source);
     }
 }
@@ -65,31 +67,31 @@ void Gosu::Channel::stop()
 {
     if (current_channel() == NO_CHANNEL) return;
 
-    ALuint source = al_source_for_channel(channel);
+    ALuint source = al_source_for_channel(m_channel);
     alSourceStop(source);
-    channel = NO_CHANNEL;
+    m_channel = NO_CHANNEL;
 }
 
 void Gosu::Channel::set_volume(double volume)
 {
     if (current_channel() == NO_CHANNEL) return;
 
-    ALuint source = al_source_for_channel(channel);
-    alSourcef(source, AL_GAIN, max(volume, 0.0));
+    ALuint source = al_source_for_channel(m_channel);
+    alSourcef(source, AL_GAIN, static_cast<ALfloat>(std::max(volume, 0.0)));
 }
 
 void Gosu::Channel::set_pan(double pan)
 {
     if (current_channel() == NO_CHANNEL) return;
 
-    ALuint source = al_source_for_channel(channel);
-    alSource3f(source, AL_POSITION, pan * 10, 0, 0);
+    ALuint source = al_source_for_channel(m_channel);
+    alSource3f(source, AL_POSITION, static_cast<ALfloat>(pan * 10), 0, 0);
 }
 
 void Gosu::Channel::set_speed(double speed)
 {
     if (current_channel() == NO_CHANNEL) return;
 
-    ALuint source = al_source_for_channel(channel);
-    alSourcef(source, AL_PITCH, speed);
+    ALuint source = al_source_for_channel(m_channel);
+    alSourcef(source, AL_PITCH, static_cast<ALfloat>(speed));
 }

data/src/Color.cpp

@@ -1,35 +1,38 @@
 #include <Gosu/Color.hpp>
 #include <Gosu/Math.hpp>
-#include <cmath>
 #include <algorithm>
+#include <cmath>
 
 namespace
 {
-    struct HSV { double h, s, v; };
-    
+    struct HSV
+    {
+        double h, s, v;
+    };
+
     HSV color_to_hsv(const Gosu::Color& c)
     {
         double r = c.red / 255.0;
         double g = c.green / 255.0;
         double b = c.blue / 255.0;
-        
+
         double min = std::min(std::min(r, g), b);
         double max = std::max(std::max(r, g), b);
         double delta = max - min;
 
         if (max == 0) {
-            HSV hsv = { 0, 0, 0 };
+            HSV hsv = {0, 0, 0};
             return hsv;
         }
-        
+
         HSV hsv{};
 
         // Value.
         hsv.v = max;
-        
+
         // Saturation.
         hsv.s = delta / max;
-        
+
         // Hue.
         if (delta == 0) {
             hsv.h = 0;
@@ -44,7 +47,7 @@ namespace
             hsv.h = (r - g) / delta + 4;
         }
         hsv.h *= 60;
-        
+
         return hsv;
     }
 }