ge211_audio.hxx

#pragma once
 
#include "ge211_forward.hxx"
#include "ge211_error.hxx"
#include "ge211_time.hxx"
#include "ge211_util.hxx"
 
#include <memory>
#include <vector>
 
namespace ge211 {
 
namespace audio {
 
class Audio_clip
{
    friend Music_track;  // derived class
    friend Sound_effect; // derived class
 
public:
    bool empty() const { return real_empty_(); }
 
    explicit operator bool() const { return !real_empty_(); }
 
    void load(const std::string&, const Mixer&);
 
    bool try_load(const std::string&, const Mixer&);
 
    void clear();
 
    virtual ~Audio_clip() = default;
 
private:
    Audio_clip();
 
    virtual bool real_try_load_(const std::string& filename, const Mixer&) = 0;
 
    virtual void real_clear_() = 0;
 
    virtual bool real_empty_() const = 0;
};
 
class Music_track : public Audio_clip
{
    friend Mixer;
 
public:
    Music_track(const std::string& filename, const Mixer&);
 
    Music_track() { }
 
private:
    bool real_try_load_(const std::string&, const Mixer&) override;
    void real_clear_() override;
    bool real_empty_() const override;
 
    std::shared_ptr<Mix_Music> ptr_;
};
 
class Sound_effect : public Audio_clip
{
    friend Mixer;
 
public:
    Sound_effect(const std::string& filename, const Mixer&);
 
    Sound_effect() { }
 
private:
    bool real_try_load_(const std::string&, const Mixer&) override;
    void real_clear_() override;
    bool real_empty_() const override;
 
    std::shared_ptr<Mix_Chunk> ptr_;
};
 
class Mixer
{
    // This calls default constructor...
    friend Abstract_game;
    // ...via this:
    friend class detail::lazy_ptr<Mixer>;
 
public:
    enum class State
    {
        detached,
        playing,
        fading_out,
        paused,
    };
 
    bool is_enabled() const
    { return enabled_; }
 
 
    void play_music(Music_track, bool forever = false);
 
    void attach_music(Music_track);
 
    void resume_music(Duration fade_in = Duration(0), bool forever = false);
 
    void pause_music(Duration fade_out = Duration(0));
 
    void rewind_music();
 
    const Music_track& get_music() const
    {
        return current_music_;
    }
 
    State get_music_state() const
    {
        return music_state_;
    }
 
    double get_music_volume() const;
 
    void set_music_volume(double unit_value);
 
 
 
    int available_effect_channels() const;
 
    Sound_effect_handle
    play_effect(Sound_effect effect, double volume = 1.0);
 
    Sound_effect_handle
    try_play_effect(Sound_effect effect, double volume = 1.0);
 
    void pause_all_effects();
 
    void resume_all_effects();
 
 
 
    Mixer(const Mixer&) = delete;
    Mixer(const Mixer&&) = delete;
    Mixer& operator=(const Mixer&) = delete;
    Mixer& operator=(const Mixer&&) = delete;
 
    ~Mixer();
 
 
private:
    Mixer();
 
    void poll_channels_();
    friend class detail::Engine; // calls poll_channels_().
 
    int find_empty_channel_() const;
 
    Sound_effect_handle
    register_effect_(int channel, Sound_effect effect);
 
    void unregister_effect_(int channel);
    friend Sound_effect_handle; // calls unregister_effect_(int).
 
private:
    Music_track current_music_;
    State music_state_{State::detached};
    Pausable_timer music_position_{true};
 
    bool enabled_;
    std::vector<Sound_effect_handle> channels_;
    int available_effect_channels_;
};
 
class Sound_effect_handle
{
public:
    Sound_effect_handle() {}
 
    bool empty() const;
 
    explicit operator bool() const;
 
    void pause();
 
    void resume();
 
    void stop();
 
    const Sound_effect& get_effect() const;
 
    Mixer::State get_state() const;
 
    double get_volume() const;
 
    void set_volume(double unit_value);
 
private:
    friend Mixer;
 
    struct Impl_
    {
        Impl_(Mixer& m, Sound_effect e, int c)
                : mixer(m)
                , effect(std::move(e))
                , channel(c)
                , state(Mixer::State::playing)
        { }
 
        Mixer& mixer;
        Sound_effect effect;
        int channel;
        Mixer::State state;
    };
 
    Sound_effect_handle(Mixer&, Sound_effect, int channel);
 
    std::shared_ptr<Impl_> ptr_;
};
 
} // end namespace audio
 
} // end namespace ge211