AudioEngine2.h

#pragma once
#include "IParaAudioEngine.h"
#include "util/intrusive_ptr.h"
using namespace std;

namespace ParaEngine
{
    class CAudioSource2 : public ParaEngine::intrusive_ptr_single_thread_base, public IAudioSourceEventHandler
    {
    public:
        CAudioSource2(const char* sName, IParaAudioSource* pSource=NULL):m_name(sName), m_pSource(pSource), m_nLoopCount(0), m_status(AUDIO_FLAG_Uninitialized), m_bReleaseOnStop(false), m_bIsAsyncLoadingWhileLoopPlaying(false){}
        ~CAudioSource2(){};
        HRESULT Stop(ParaAudioFlagsEnum dwFlags);

        void SetSource(IParaAudioSource* pSource)
        {
            m_pSource = pSource;
        };
        IParaAudioSource* GetSource()
        {
            return m_pSource;
        };

        void SetName(const char* sName) {m_name = sName;}

        const std::string& GetName() const {return m_name;}

        void EnableCallback(bool bEnable = true)
        {
            if(m_pSource!=0)
            {
                if(bEnable)
                    m_pSource->registerEventHandler(this);
                else
                    m_pSource->unRegisterAllEventHandlers();
            }
        }
    public:
        bool play();

        bool play2d(const bool& toLoop = false, bool bIgnoreIfPlaying = true);

        bool play3d(const PARAVECTOR3& position, const float& soundstr = 1.0 , const bool& toLoop = false);
        
        void pause();

        void stop();


        void loop(const bool& toLoop);

        bool IsAsyncLoadingWhileLoopPlaying();

        bool IsWaveFileLoopPlaying();

        bool IsPlaying();
    public:
        //
        // audio event callback, invoked on the update thread (so need lock to feedback to main thread)
        //

        virtual void onUpdate();

        virtual void onRelease();

        virtual void onPlay();

        virtual void onStop();

        virtual void onPause();

    public:

        IParaAudioSource* m_pSource;
        int m_nLoopCount;
        bool m_bReleaseOnStop;
        std::string m_name;
        ParaAudioFlagsEnum m_status;
        bool m_bIsAsyncLoadingWhileLoopPlaying;
    };
    typedef ParaIntrusivePtr<CAudioSource2> CAudioSource2_ptr;

    class CAudioEngine2
    {
    public:
        typedef std::map<std::string, CAudioSource2_ptr> AudioFileMap_type;

        CAudioEngine2();
        ~CAudioEngine2();

        static CAudioEngine2* GetInstance();

        IParaAudioEngine* GetInterface();

        HRESULT InitAudioEngine(IParaAudioEngine* pInteface = NULL);

        void CleanupAudioEngine();

        bool IsValid();

        inline bool IsValidAndEnabled(){return IsValid() && IsAudioEngineEnabled();};

        bool IsAudioEngineEnabled() {return m_bEnableAudioEngine;};

        void EnableAudioEngine(bool bEnable);

        float GetGlobalVolume(){return m_fGlobalVolume;};

        void SetGlobalVolume(const float& volume);

        void OnSwitch(bool bOn);

        CAudioSource2_ptr Create(const char* sName, const char* sWavePath=NULL, bool bStream=false);

        CAudioSource2_ptr Get(const char* sName);

        CAudioSource2_ptr CreateGet(const char* sName, const char* sWavePath=NULL, bool bStream=false);

        void release(CAudioSource2_ptr& audio_src);

        void Update();

        void SetAutoMoveListener(bool bAuto) { m_bAutoMoveListener = bAuto; };

        bool GetAutoMoveListener() {return m_bAutoMoveListener; };
    public:
        // handy functions for playback
        
        HRESULT PlayWaveFile(const char* sWavePath, bool bLoop=false, bool bStream=false, int dwPlayOffset=0);
        
        HRESULT PrepareWaveFile(CAudioSource2_ptr& pWave, const char* sWavePath, bool bStream = false);

        HRESULT StopWaveFile(const char* sWavePath, ParaAudioFlagsEnum dwFlags);
        
        HRESULT ReleaseWaveFile(const std::string& szWavePath);

        bool IsWaveFileInQueue(const std::string& filename);
        bool IsWaveFileLoopPlaying(const std::string& filename);

        void SetDistanceModel(ParaAudioDistanceModelEnum eDistModel);

        //
        // the audio listener
        //

        void setPosition(const PARAVECTOR3& pos);

        void setDirection(const PARAVECTOR3& dir);

        void setUpVector(const PARAVECTOR3& up);

        void setVelocity(const PARAVECTOR3& vel);

        void move(const PARAVECTOR3& pos);

        PARAVECTOR3 getPosition() const;

        PARAVECTOR3 getDirection() const;

        PARAVECTOR3 getUpVector() const;

        PARAVECTOR3 getVelocity() const;

        void PauseAll();
        void ResumeAll();
    private:
        IParaAudioEngine* m_pAudioEngine;
        bool m_bEnableAudioEngine;
        AudioFileMap_type m_audio_file_map;
        std::vector<CAudioSource2_ptr> m_paused_audios;
        float m_fGlobalVolume;
        float m_fGlobalVolumeBeforeSwitch;
        bool m_bAutoMoveListener;
    };
}