soundmanager.hpp

Go to the documentation of this file.

#ifndef GAME_MWBASE_SOUNDMANAGER_H
#define GAME_MWBASE_SOUNDMANAGER_H

#include <string>
#include <set>
#include <boost/shared_ptr.hpp>

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

namespace MWWorld
{
    class CellStore;
}

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

namespace MWBase
{
    typedef boost::shared_ptr<MWSound::Sound> SoundPtr;
    typedef boost::shared_ptr<MWSound::Stream> SoundStreamPtr;

    class SoundManager
    {
        public:
            /* These must all fit together */
            enum PlayMode {
                Play_Normal  = 0, /* non-looping, affected by environment */
                Play_Loop    = 1<<0, /* Sound will continually loop until explicitly stopped */
                Play_NoEnv   = 1<<1, /* Do not apply environment effects (eg, underwater filters) */
                Play_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. */
                Play_NoPlayerLocal = 1<<3, /* (3D only) Don't play the sound local to the listener even if the
                                              player is making it. */
                Play_LoopNoEnv = Play_Loop | Play_NoEnv,
                Play_LoopRemoveAtDistance = Play_Loop | Play_RemoveAtDistance
            };
            enum PlayType {
                Play_TypeSfx   = 1<<4, /* Normal SFX sound */
                Play_TypeVoice = 1<<5, /* Voice sound */
                Play_TypeFoot  = 1<<6, /* Footstep sound */
                Play_TypeMusic = 1<<7, /* Music track */
                Play_TypeMovie = 1<<8, /* Movie audio track */
                Play_TypeMask  = Play_TypeSfx|Play_TypeVoice|Play_TypeFoot|Play_TypeMusic|Play_TypeMovie
            };

        private:

            SoundManager (const SoundManager&);

            SoundManager& operator= (const SoundManager&);

        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 void startRandomTitle() = 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 SoundStreamPtr playTrack(const MWSound::DecoderPtr& decoder, PlayType type) = 0;

            virtual void stopTrack(SoundStreamPtr stream) = 0;

            virtual double getTrackTimeDelay(SoundStreamPtr stream) = 0;

            virtual SoundPtr playSound(const std::string& soundId, float volume, float pitch,
                                       PlayType type=Play_TypeSfx, PlayMode mode=Play_Normal,
                                       float offset=0) = 0;

            virtual MWBase::SoundPtr playSound3D(const MWWorld::ConstPtr &reference, const std::string& soundId,
                                                 float volume, float pitch, PlayType type=Play_TypeSfx,
                                                 PlayMode mode=Play_Normal, float offset=0) = 0;

            virtual MWBase::SoundPtr playSound3D(const osg::Vec3f& initialPos, const std::string& soundId,
                                                 float volume, float pitch, PlayType type=Play_TypeSfx, PlayMode mode=Play_Normal, float offset=0) = 0;

            virtual void stopSound(SoundPtr 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=Play_TypeMask) = 0;

            virtual void resumeSounds(int types=Play_TypeMask) = 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