soundmanager.hpp

Go to the documentation of this file.

#ifndef GAME_MWBASE_SOUNDMANAGER_H
#define GAME_MWBASE_SOUNDMANAGER_H

#include <memory>
#include <string>
#include <set>

#include "../mwworld/ptr.hpp"

namespace MWWorld
{
    class CellStore;
}

namespace MWSound
{
    class Sound;
    class Stream;
    struct Sound_Decoder;
    typedef std::shared_ptr<Sound_Decoder> DecoderPtr;

    /* These must all fit together */
    enum class PlayMode {
        Normal  = 0, /* non-looping, affected by environment */
        Loop    = 1<<0, /* Sound will continually loop until explicitly stopped */
        NoEnv   = 1<<1, /* Do not apply environment effects (eg, underwater filters) */
        RemoveAtDistance = 1<<2, /* (3D only) If the listener gets further than 2000 units away
                                  * from the sound source, the sound is removed.
                                  * This is weird stuff but apparently how vanilla works for sounds
                                  * played by the PlayLoopSound family of script functions. Perhaps
                                  * we can make this cut off a more subtle fade later, but have to
                                  * be careful to not change the overall volume of areas by too
                                  * much. */
        NoPlayerLocal = 1<<3, /* (3D only) Don't play the sound local to the listener even if the
                               * player is making it. */
        LoopNoEnv = Loop | NoEnv,
        LoopRemoveAtDistance = Loop | RemoveAtDistance
    };
    enum class Type {
        Sfx   = 1<<4, /* Normal SFX sound */
        Voice = 1<<5, /* Voice sound */
        Foot  = 1<<6, /* Footstep sound */
        Music = 1<<7, /* Music track */
        Movie = 1<<8, /* Movie audio track */
        Mask  = Sfx | Voice | Foot | Music | Movie
    };
    // Used for creating a type mask for SoundManager::pauseSounds and resumeSounds
    inline int operator~(Type a) { return ~static_cast<int>(a); }
    inline int operator&(Type a, Type b) { return static_cast<int>(a) & static_cast<int>(b); }
    inline int operator&(int a, Type b) { return a & static_cast<int>(b); }
    inline int operator|(Type a, Type b) { return static_cast<int>(a) | static_cast<int>(b); }
}

namespace MWBase
{
    using Sound = MWSound::Sound;
    using SoundStream = MWSound::Stream;

    class SoundManager
    {
            SoundManager (const SoundManager&);

            SoundManager& operator= (const SoundManager&);

        protected:
            using PlayMode = MWSound::PlayMode;
            using Type = MWSound::Type;

        public:
            SoundManager() {}
            virtual ~SoundManager() {}

            virtual void processChangedSettings(const std::set< std::pair<std::string, std::string> >& settings) = 0;

            virtual void stopMusic() = 0;

            virtual void streamMusic(const std::string& filename) = 0;

            virtual bool isMusicPlaying() = 0;

            virtual void playPlaylist(const std::string &playlist) = 0;

            virtual void say(const MWWorld::ConstPtr &reference, const std::string& filename) = 0;

            virtual void say(const std::string& filename) = 0;

            virtual bool sayDone(const MWWorld::ConstPtr &reference=MWWorld::ConstPtr()) const = 0;

            virtual void stopSay(const MWWorld::ConstPtr &reference=MWWorld::ConstPtr()) = 0;

            virtual float getSaySoundLoudness(const MWWorld::ConstPtr& reference) const = 0;

            virtual SoundStream *playTrack(const MWSound::DecoderPtr& decoder, Type type) = 0;

            virtual void stopTrack(SoundStream *stream) = 0;

            virtual double getTrackTimeDelay(SoundStream *stream) = 0;

            virtual Sound *playSound(const std::string& soundId, float volume, float pitch,
                                     Type type=Type::Sfx, PlayMode mode=PlayMode::Normal,
                                     float offset=0) = 0;

            virtual Sound *playSound3D(const MWWorld::ConstPtr &reference, const std::string& soundId,
                                       float volume, float pitch, Type type=Type::Sfx,
                                       PlayMode mode=PlayMode::Normal, float offset=0) = 0;

            virtual Sound *playSound3D(const osg::Vec3f& initialPos, const std::string& soundId,
                                       float volume, float pitch, Type type=Type::Sfx,
                                       PlayMode mode=PlayMode::Normal, float offset=0) = 0;

            virtual void stopSound(Sound *sound) = 0;

            virtual void stopSound3D(const MWWorld::ConstPtr &reference, const std::string& soundId) = 0;

            virtual void stopSound3D(const MWWorld::ConstPtr &reference) = 0;

            virtual void stopSound(const MWWorld::CellStore *cell) = 0;

            virtual void stopSound(const std::string& soundId) = 0;

            virtual void fadeOutSound3D(const MWWorld::ConstPtr &reference, const std::string& soundId, float duration) = 0;

            virtual bool getSoundPlaying(const MWWorld::ConstPtr &reference, const std::string& soundId) const = 0;

            virtual void pauseSounds(int types=static_cast<int>(Type::Mask)) = 0;

            virtual void resumeSounds(int types=static_cast<int>(Type::Mask)) = 0;

            virtual void update(float duration) = 0;

            virtual void setListenerPosDir(const osg::Vec3f &pos, const osg::Vec3f &dir, const osg::Vec3f &up, bool underwater) = 0;

            virtual void updatePtr(const MWWorld::ConstPtr& old, const MWWorld::ConstPtr& updated) = 0;

            virtual void clear() = 0;
    };
}

#endif