gosu 1.1.1.1 → 1.4.1

data/ext/gosu/extconf.rb

@@ -8,17 +8,17 @@ when /^darwin/
 end
 
 if not windows
-  puts 'The Gosu gem requires some libraries to be installed system-wide.'
-  puts 'See the following site for a list:'
+  puts "The Gosu gem requires some libraries to be installed system-wide."
+  puts "See the following site for a list:"
   if macos
-    puts 'https://github.com/gosu/gosu/wiki/Getting-Started-on-OS-X'
+    puts "https://github.com/gosu/gosu/wiki/Getting-Started-on-OS-X"
   else
-    puts 'https://github.com/gosu/gosu/wiki/Getting-Started-on-Linux'
+    puts "https://github.com/gosu/gosu/wiki/Getting-Started-on-Linux"
   end
 end
 
-require 'mkmf'
-require 'fileutils'
+require "mkmf"
+require "fileutils"
 
 # Silence internal deprecation warnings in Gosu.
 $CFLAGS << " -DGOSU_DEPRECATED="
@@ -33,25 +33,25 @@ $CXXFLAGS ||= ""
 $CXXFLAGS << " -std=gnu++17 -Dregister="
 
 # Make Gosu's own header files and all of its dependencies available to C++ source files.
-$INCFLAGS << " -I../../include -I../../dependencies/stb -I../../dependencies/utf8proc -I../../dependencies/SDL_sound"
+$INCFLAGS << " -I../../include -I../../dependencies/stb -I../../dependencies/utf8proc -I../../dependencies/SDL_sound -I../../dependencies/mojoAL"
 
 if windows
   # We statically compile utf8proc into the Gosu binary.
   # This macro is required to avoid errors about dllexport/dllimport mismatches.
-  $CFLAGS << " -DUTF8PROC_STATIC"
-  $CXXFLAGS << " -DUTF8PROC_STATIC"
+  $CFLAGS << " -DUTF8PROC_STATIC -DAL_LIBTYPE_STATIC"
+  $CXXFLAGS << " -DUTF8PROC_STATIC -DAL_LIBTYPE_STATIC"
 
   # Define UNICODE to use the Unicode-aware variants of all Win32 API functions.
   $CXXFLAGS << " -DUNICODE"
 
   # Use the bundled versions of SDL 2 and open_al.
-  $INCFLAGS << " -I../../dependencies/al_soft -I../../dependencies/SDL/include"
-  if RbConfig::CONFIG['arch'] =~ /x64-/
-    $LDFLAGS << "  -L../../dependencies/al_soft/x64 -L../../dependencies/SDL/lib/x64"
+  $INCFLAGS << " -I../../dependencies/SDL/include"
+  if RbConfig::CONFIG["arch"] =~ /x64-/
+    $LDFLAGS << "  -L../../dependencies/SDL/lib/x64"
   else
-    $LDFLAGS << "  -L../../dependencies/al_soft/x86 -L../../dependencies/SDL/lib/x86"
+    $LDFLAGS << "  -L../../dependencies/SDL/lib/x86"
   end
-  $LDFLAGS << " -lgdi32 -lwinmm -ldwmapi -lOpenGL32 -lOpenAL32 -lSDL2"
+  $LDFLAGS << " -lgdi32 -lwinmm -ldwmapi -lOpenGL32 -lSDL2"
   # Link libstdc++ statically to avoid having another DLL dependency when using Ocra.
   $LDFLAGS << " -static-libstdc++"
 elsif macos
@@ -66,49 +66,48 @@ elsif macos
   # Disable an error that is disabled by default and prevents Gosu from building with universal Ruby:
   # https://trac.macports.org/ticket/58255 / https://github.com/gosu/gosu/issues/424
   $CXXFLAGS << " -Wno-reserved-user-defined-literal"
-  
+
   # Dependencies.
   $CFLAGS << " #{`sdl2-config --cflags`.chomp}"
   $CXXFLAGS << " #{`sdl2-config --cflags`.chomp}"
   # Prefer statically linking SDL 2.
-  $LDFLAGS  << " #{`sdl2-config --static-libs`.chomp} -framework OpenGL -framework Metal -framework OpenAL"
+  $LDFLAGS << " #{`sdl2-config --static-libs`.chomp} -framework OpenGL -framework Metal"
   # And yet another hack: `sdl2-config --static-libs` uses `-lSDL2` instead of linking to the static library,
   # even if it exists. -> Manually replace it. (Ugh!)
-  $LDFLAGS.sub! " -lSDL2 ", " /usr/local/lib/libSDL2.a " if File.exist? "/usr/local/lib/libSDL2.a"
-  
+  %w(/usr/local/lib/libSDL2.a /opt/homebrew/opt/sdl2/lib/libSDL2.a).each do |static_lib|
+    $LDFLAGS.sub! " -lSDL2 ", " #{static_lib} " if File.exist? static_lib
+  end
+
   # Disable building of 32-bit slices in Apple's Ruby.
   # (RbConfig::CONFIG['CXXFLAGS'] on 10.11: -arch x86_64 -arch i386 -g -Os -pipe)
   $CFLAGS.gsub! "-arch i386", ""
   $CXXFLAGS.gsub! "-arch i386", ""
   $LDFLAGS.gsub! "-arch i386", ""
   $ARCH_FLAG.gsub! "-arch i386", ""
-  CONFIG['LDSHARED'].gsub! "-arch i386", ""
+  CONFIG["LDSHARED"].gsub! "-arch i386", ""
 else
   if /BCM2708/ =~ `cat /proc/cpuinfo`
     $INCFLAGS << " -I/opt/vc/include/GLES"
     $INCFLAGS << " -I/opt/vc/include"
     $LDFLAGS << " -L/opt/vc/lib"
     $LDFLAGS << " -lGLESv1_CM"
-    $CFLAGS   << " -DGOSU_IS_OPENGLES"
+    $CFLAGS << " -DGOSU_IS_OPENGLES"
     $CXXFLAGS << " -DGOSU_IS_OPENGLES"
   else
-    pkg_config 'gl'
+    pkg_config "gl"
   end
 
-  pkg_config 'sdl2'
-  pkg_config 'vorbisfile'
-  pkg_config 'openal'
-  pkg_config 'sndfile'
-  pkg_config 'libmpg123'
-  pkg_config 'fontconfig'
-  
-  have_header 'AL/al.h' if have_library('openal')
+  pkg_config "sdl2"
+  pkg_config "vorbisfile"
+  pkg_config "sndfile"
+  pkg_config "libmpg123"
+  pkg_config "fontconfig"
 end
 
 # Because Ruby will only compile source file in the src/ folder, but our dependencies are
 # stored in dependencies/, we need to create symlinks for all the .c files. This is terrible,
 # but still seems better than putting everything into the same folder to begin with.
-Dir.glob('../../dependencies/**/*.c').each do |dep|
+Dir.glob("../../dependencies/**/*.c").each do |dep|
   File.open("../../src/#{File.basename dep}", "w") do |shim|
     shim.puts "#include \"#{File.expand_path dep}\""
   end

data/include/Gosu/Audio.hpp

@@ -1,141 +1,126 @@
-//! \file Audio.hpp
-//! Contains all the classes of Gosu's audio system.
-
 #pragma once
 
 #include <Gosu/Fwd.hpp>
 #include <Gosu/IO.hpp>
 #include <Gosu/Platform.hpp>
+#include <Gosu/Utility.hpp>
 #include <memory>
 #include <string>
 
 namespace Gosu
 {
-    //! Sample::play returns a Channel that represents the sound being played.
-    //! This object can be used to stop sounds dynamically, or to check whether playback has
-    //! finished.
+    /// Sample::play returns a Channel that represents the sound being played.
+    /// This object can be used to stop or influence sounds as they are played, or to check whether
+    /// playback has finished.
     class Channel
     {
-        mutable int channel, token;
+        mutable int m_channel, m_token;
 
     public:
-        //! This creates an "empty" Channel which is expired and cannot be resumed.
+        /// This creates an "empty" Channel which is expired and cannot be resumed.
         Channel();
-        //! For internal use only.
+        /// For internal use only.
         Channel(int channel, int token);
-        
-        //! For internal use only.
+
+        /// For internal use only.
         int current_channel() const;
-        
+
         bool playing() const;
         bool paused() const;
-        //! Pauses this instance to be resumed afterwards.
-        //! Avoid leaving samples paused for too long, as they will still occupy one of Gosu's
-        //! limited channels.
+        /// Pauses this instance to be resumed afterwards.
+        /// Avoid leaving samples paused for too long, as they will still occupy one of Gosu's
+        /// limited channels.
         void pause();
         void resume();
-        //! Stops this channel if the sample is still being played.
-        //! If this method is called when playback has finished, it has no effect.
+        /// Stops this m_channel if the sample is still being played.
+        /// If this method is called when playback has finished, it has no effect.
         void stop();
 
-        //! \param volume Can be anything from 0.0 (silence) to 1.0 (full volume).
+        /// @param volume Can be anything from 0.0 (silence) to 1.0 (full volume).
         void set_volume(double volume);
-        //! \param pan Can be anything from -1.0 (left) to 1.0 (right).
+        /// @param pan Can be anything from -1.0 (left) to 1.0 (right).
         void set_pan(double pan);
-        //! \param speed Use 1.0 for normal playback speed.
+        /// @param speed Use 1.0 for normal playback speed.
         void set_speed(double speed);
     };
-    
-    //! A sample is a short sound that is completely loaded in memory, can be
-    //! played multiple times at once and offers very flexible playback
-    //! parameters. Use samples for everything that's not music.
+
+    /// A sample is a short sound that is completely loaded in memory, can be played multiple times
+    /// at once, and offers very flexible playback parameters.
     class Sample
     {
         struct Impl;
-        std::shared_ptr<Impl> pimpl;
+        std::shared_ptr<Impl> m_impl;
 
     public:
-        //! Constructs an empty sample that is inaudible when played.
+        /// Constructs an empty sample that is inaudible when played.
         Sample();
-        
-        //! Constructs a sample that can be played on the specified audio
-        //! system and loads the sample from a file.
+
+        /// Constructs a sample that can be played on the specified audio
+        /// system and loads the sample from a file.
         explicit Sample(const std::string& filename);
-        
-        //! Constructs a sample that can be played on the specified audio
-        //! system and loads the sample data from a stream.
+
+        /// Constructs a sample that can be played on the specified audio
+        /// system and loads the sample data from a stream.
         explicit Sample(Reader reader);
-        
-        //! Plays the sample without panning.
-        //! \param volume Can be anything from 0.0 (silence) to 1.0 (full
-        //! volume).
-        //! \param speed Playback speed is only limited by the underlying audio library,
-        //! and can accept very high or low values. Use 1.0 for
-        //! normal playback speed.
-        Channel play(double volume = 1, double speed = 1, bool looping = false) const;
-
-        //! Plays the sample with panning. Even if pan is 0.0, the sample will
-        //! not be as loud as if it were played by calling play() due to the
-        //! way the panning works.
-        //! \param pan Can be anything from -1.0 (left) to 1.0 (right).
-        //! \param volume Can be anything from 0.0 (silence) to 1.0 (full
-        //! volume).
-        //! \param speed Playback speed is only limited by by the underlying audio library,
-        //! and can accept very high
-        //! or low values. Use 1.0 for normal playback speed.
-        Channel play_pan(double pan, double volume = 1, double speed = 1,
-            bool looping = false) const;
+
+        /// Plays the sample without panning.
+        /// @param volume Can be anything from 0.0 (silence) to 1.0 (full volume).
+        /// @param speed Playback speed is only limited by the underlying audio library,
+        ///              and can accept very high or low values. Use 1.0 for normal playback speed.
+        Channel play(double volume = 1.0, double speed = 1.0, bool looping = false) const;
+
+        /// Plays the sample with panning. Even if pan is 0.0, the sample will
+        /// not be as loud as if it were played by calling play() due to the
+        /// way the panning works.
+        /// @param pan Can be anything from -1.0 (left) to 1.0 (right).
+        /// @param volume Can be anything from 0.0 (silence) to 1.0 (full volume).
+        /// @param speed Playback speed is only limited by by the underlying audio library,
+        ///              and can accept very high or low values. Use 1.0 for normal playback speed.
+        Channel play_pan(double pan, double volume = 1.0, double speed = 1.0,
+                         bool looping = false) const;
     };
 
-    //! Songs are less flexible than samples. Only one Song can be played at any given time,
-    //! and there is no way to control its pan (stereo position) or speed.
-    class Song
+    /// Songs are less flexible than Samples. Only one Song can be played at any given time,
+    /// and there is no way to control its pan (stereo position) or speed.
+    class Song : private Noncopyable
     {
         struct Impl;
-        std::unique_ptr<Impl> pimpl;
-        
-        // Non-movable to avoid dangling internal references.
-        Song(Song&&) = delete;
-        // Non-movable to avoid dangling internal references.
-        Song& operator=(Song&&) = delete;
+        std::unique_ptr<Impl> m_impl;
 
     public:
-        //! Constructs a song that can be played on the provided audio system
-        //! and loads the song from a file.
-        //! The file type is determined by the filename.
+        /// Constructs a song that can be played on the provided audio system and loads the song
+        /// from a file. The file type is determined by the filename.
         explicit Song(const std::string& filename);
-        
-        //! Constructs a song of the specified type that can be played on the
-        //! provided audio system and loads the song data from a stream.
+
+        /// Constructs a song of the specified type that can be played on the
+        /// provided audio system and loads the song data from a stream.
         explicit Song(Reader reader);
-        
+
         ~Song();
-        
-        //! Returns the song currently being played or paused, or 0 if
-        //! no song has been played yet or the last song has finished
-        //! playing.
+
+        /// Returns the song currently being played or paused, or 0 if no song has been played yet
+        /// or the last song has finished playing.
         static Song* current_song();
 
-        //! Starts or resumes playback of the song. This will stop all other
-        //! songs and set the current song to this object.
+        /// Starts or resumes playback of the song. This will stop all other songs and set the
+        /// current song to this object.
         void play(bool looping = false);
-        //! Pauses playback of the song. It is not considered being played.
-        //! current_song will stay the same.
+        /// Pauses playback of the song. Song::current_song() will still refer to this song, but
+        /// playing() will return false.
         void pause();
-        //! Returns true if the song is the current song, but in paused
-        //! mode.
+        /// Returns true if the song is the current song, but in paused mode.
         bool paused() const;
-        //! Stops playback of this song if it is currently played or paused.
-        //! Afterwards, current_song will return nullptr.
+        /// Stops playback of this song if it is currently played or paused.
+        /// Afterwards, current_song will return nullptr.
         void stop();
-        //! Returns true if the song is currently playing.
+        /// Returns true if the song is currently playing.
         bool playing() const;
-        //! Returns the current volume of the song.
+        /// Returns the current volume of the song.
         double volume() const;
-        //! \param volume Can be anything from 0.0 (silence) to 1.0 (full volume).
+        /// @param volume Can be anything from 0.0 (silence) to 1.0 (full volume).
         void set_volume(double volume);
-        
-        //! Called every tick by Window to feed new audio data to OpenAL.
+
+        /// Called every tick by Window to feed new audio data to OpenAL.
         static void update();
     };
 }

data/include/Gosu/Color.hpp

@@ -1,6 +1,3 @@
-//! \file Color.hpp
-//! Interface of the Color class.
-
 #pragma once
 
 #include <Gosu/Platform.hpp>
@@ -8,154 +5,113 @@
 
 namespace Gosu
 {
-    //! Represents an RGBA color value with 8 bits for each channel.
-    //! Can be implicitly constructed from literals of the form 0xaarrggbb.
-    //! Has fast value semantics.
-    //! The four-byte layout in memory is RGBA. On Big-Endian machines the unsigned int will look
-    //! like 0xrrggbbaa, on Little-Endian machines it is 0xaabbggrr.
-    class Color
+    /// Represents an RGBA color value with 8 bit for each channel.
+    /// Can be implicitly constructed from literals of the form 0xaarrggbb.
+    struct Color
     {
-        std::uint32_t rep;
-        #ifdef GOSU_IS_LITTLE_ENDIAN
-        enum { RED_OFFSET = 0, GREEN_OFFSET = 8, BLUE_OFFSET = 16, ALPHA_OFFSET = 24 };
-        #else
-        enum { RED_OFFSET = 24, GREEN_OFFSET = 16, BLUE_OFFSET = 8, ALPHA_OFFSET = 0 };
-        #endif
-        
-    public:
-        typedef std::uint8_t Channel;
         static const unsigned GL_FORMAT = 0x1908; // GL_RGBA
-        
-        //! The default constructor does not initialize the color to any value.
-        Color()
-        {
-        }
-        
-        //! Conversion constructor for literals of the form 0xaarrggbb.
-        Color(unsigned argb)
-        : Color((argb >> 24) & 0xff, (argb >> 16) & 0xff, (argb >> 8) & 0xff, (argb >> 0) & 0xff)
-        {
-        }
-        
-        Color(Channel red, Channel green, Channel blue)
-        : Color(0xff, red, green, blue)
-        {
-        }
-        
-        Color(Channel alpha, Channel red, Channel green, Channel blue)
-        {
-            rep = (alpha << ALPHA_OFFSET) | (red << RED_OFFSET) |
-                  (green << GREEN_OFFSET) | (blue << BLUE_OFFSET);
-        }
-        
-        //! Constructs a color from the given hue/saturation/value triple.
-        //! Ranges of these values are given as 0..360, 0..1, and 0..1, respectively.
-        static Color from_hsv(double h, double s, double v);
-        
-        //! Constructs a color from the given hue/saturation/value triple.
-        //! Ranges of these values are given as 0..360, 0..1, and 0..1, respectively.
-        static Color from_ahsv(Channel alpha, double h, double s, double v);
 
-        Channel red() const
-        {
-            return static_cast<Channel>(rep >> RED_OFFSET);
-        }
+        typedef std::uint8_t Channel;
 
-        Channel green() const
-        {
-            return static_cast<Channel>(rep >> GREEN_OFFSET);
-        }
+        Channel red, green, blue, alpha;
 
-        Channel blue() const
+        constexpr Color()
+        : red{0},
+          green{0},
+          blue{0},
+          alpha{0}
         {
-            return static_cast<Channel>(rep >> BLUE_OFFSET);
         }
 
-        Channel alpha() const
+        /// Conversion constructor for literals of the form 0xaarrggbb.
+        // NOLINTNEXTLINE: We want to allow implicit conversions.
+        constexpr Color(std::uint32_t argb)
+        : red{static_cast<Channel>(argb >> 16)},
+          green{static_cast<Channel>(argb >> 8)},
+          blue{static_cast<Channel>(argb >> 0)},
+          alpha{static_cast<Channel>(argb >> 24)}
         {
-            return static_cast<Channel>(rep >> ALPHA_OFFSET);
         }
 
-        void set_red(Channel value)
+        constexpr Color(Channel red, Channel green, Channel blue)
+        : red{red},
+          green{green},
+          blue{blue},
+          alpha{255}
         {
-            rep &= ~(0xff << RED_OFFSET);
-            rep |= value << RED_OFFSET;
         }
 
-        void set_green(Channel value)
+        Color with_alpha(Channel new_alpha)
         {
-            rep &= ~(0xff << GREEN_OFFSET);
-            rep |= value << GREEN_OFFSET;
+            Color result = *this;
+            result.alpha = new_alpha;
+            return result;
         }
 
-        void set_blue(Channel value)
-        {
-            rep &= ~(0xff << BLUE_OFFSET);
-            rep |= value << BLUE_OFFSET;
-        }
-
-        void set_alpha(Channel value)
-        {
-            rep &= ~(0xff << ALPHA_OFFSET);
-            rep |= value << ALPHA_OFFSET;
-        }
+        /// Constructs a color from the given hue/saturation/value triple.
+        /// Ranges of these values are given as 0..360, 0..1, and 0..1, respectively.
+        static Color from_hsv(double h, double s, double v);
 
-        //! Returns the hue of the color, in the usual range of 0..360.
+        /// Returns the hue of the color, in the usual range of 0..360.
         double hue() const;
-        
-        //! Changes the current color so hue() will return h.
+
+        /// Changes the current color so hue() will return h.
         void set_hue(double h);
-        
-        //! Returns the saturation of the color, in the range of 0..1.
+
+        /// Returns the saturation of the color, in the range of 0..1.
         double saturation() const;
-        
-        //! Changes the current color so saturation() will return s.
+
+        /// Changes the current color so saturation() will return s.
         void set_saturation(double s);
-        
-        //! Returns the value (brightness) of the color, in the range of 0..1.
+
+        /// Returns the value (brightness) of the color, in the range of 0..1.
         double value() const;
-        
-        //! Changes the current color so value() will return v.
+
+        /// Changes the current color so value() will return v.
         void set_value(double v);
 
-        //! Returns the color in 0xaarrggbb representation.
-        std::uint32_t argb() const { return alpha() << 24 | red() << 16 | green() << 8 | blue(); }
+        /// Returns the color in 0xaarrggbb representation.
+        std::uint32_t argb() const { return alpha << 24 | red << 16 | green << 8 | blue; }
+
+        /// Returns the color in 0x00bbggrr representation. Useful for Win32 programming.
+        std::uint32_t bgr() const { return blue << 16 | green << 8 | red; }
+
+        /// Returns the color in 0xaabbggrr representation.
+        std::uint32_t abgr() const { return alpha << 24 | blue << 16 | green << 8 | red; }
 
-        //! Returns the color in 0x00bbggrr representation. Useful for Win32 programming.
-        std::uint32_t bgr() const { return blue() << 16 | green() << 8 | red(); }
+        /// Returns the internal representation of the color (RGBA in memory).
+        std::uint32_t gl() const { return *reinterpret_cast<const std::uint32_t*>(this); }
 
-        //! Returns the color in 0xaabbggrr representation.
-        std::uint32_t abgr() const { return alpha() << 24 | blue() << 16 | green() << 8 | red(); }
-        
-        //! Returns the internal representation of the color (RGBA in memory).
-        std::uint32_t gl() const { return rep; }
-        
         static const Color NONE;
         static const Color BLACK;
         static const Color GRAY;
         static const Color WHITE;
-        
+
+        /// Same as Color::CYAN.
         static const Color AQUA;
         static const Color RED;
         static const Color GREEN;
         static const Color BLUE;
         static const Color YELLOW;
         static const Color FUCHSIA;
+        /// Same as Color::AQUA.
         static const Color CYAN;
     };
-    
+
+    // Ensure that we can pass vectors of Gosu::Color straight to OpenGL and back.
+    static_assert(sizeof(Color) == sizeof(std::uint32_t));
+
 #ifndef SWIG
     inline bool operator<(Color a, Color b) { return a.gl() < b.gl(); }
     inline bool operator==(Color a, Color b) { return a.gl() == b.gl(); }
     inline bool operator!=(Color a, Color b) { return a.gl() != b.gl(); }
 
-    //! Interpolates linearly between two colors, with a given weight towards
-    //! the second color.
-    //! Specialization of the general function in Gosu/Math.hpp.
-    Color interpolate(Color a, Color b, double weight = 0.5);
-    
-    //! Combines two colors as if their channels were mapped to the 0..1 range
-    //! and then multiplied with each other.
+    /// Interpolates linearly between two colors, with a given weight towards
+    /// the second color.
+    Color lerp(Color a, Color b, double t = 0.5);
+
+    /// Combines two colors as if their channels were mapped to the 0..1 range
+    /// and then multiplied with each other.
     Color multiply(Color a, Color b);
 #endif
 }