F:/My Projects/LSEngine/Modules/LSSoundLib/Src/SoundComponents/LSSSoundSource.h

#ifndef __LSS_SOUNDSOURCE_H__
#define __LSS_SOUNDSOURCE_H__

#include "../LSSSoundLib.h"
#include "LSSSoundSourceTypes.h"
#include "Vector/LSMVector3.h"
#include <cassert>

namespace lss {

        enum {
                LSS_UNIQUE_ID                                                                   = 0x10000
        };

        class CSoundSource {
                friend class                                                                    CSoundManager;

        public :
                // == Various constructors.
                LSE_INLINE LSE_CALLCTOR                                                 CSoundSource( LSUINT32 _ui32Id );
                virtual LSE_INLINE LSE_CALLCTOR                                 ~CSoundSource();


                // == Enumerations.
                enum LSS_ERROR {
                        LSS_E_INVALID_BUFFER                                            = 0,
                };

                enum LSS_SOUND_STATE {
                        LSS_SS_PLAYING,
                        LSS_SS_PAUSED,
                        LSS_SS_STOPPED,
                };

                enum LSS_LOOP_MODE {
                        LSS_LM_INFINITE                                                         = ~0,
                        LSS_LM_FORCEDWORD                                                       = 0x7FFFFFFFUL,
                };

                // Maximum QWORD value is used to represent a non-expirable sound.
#define LSS_NONEXPIRABLE                                                                static_cast<LSUINT64>(~0ULL)


                // == Functions.
                // 
                virtual LSS_SOUND_SOURCE LSE_CALL                               GetType() const = 0;

                virtual LSBOOL LSE_CALL                                                 Static() const = 0;

                LSUINT32 LSE_CALL                                                               GetId() const;

                LSS_SOUND_STATE LSE_CALL                                                GetState() const;

                virtual LSBOOL LSE_CALL                                                 Play( LSUINT32 _ui32LoopCount = 1 ) = 0;

                virtual LSBOOL LSE_CALL                                                 Pause() = 0;

                virtual LSBOOL LSE_CALL                                                 Stop() = 0;

                const CVector3 & LSE_CALL                                               GetPos() const;

                LSVOID LSE_CALL                                                                 SetPos( const CVector3 &_vPos );

                const CVector3 & LSE_CALL                                               GetVel() const;

                LSVOID LSE_CALL                                                                 SetVel( const CVector3 &_vVel );

                const CVector3 & LSE_CALL                                               GetDir() const;

                LSVOID LSE_CALL                                                                 SetDir( const CVector3 &_vDir );

                LSSREAL LSE_CALL                                                                GetMaxDist() const;

                LSVOID LSE_CALL                                                                 SetMaxDist( LSSREAL _fDist );

                LSSREAL LSE_CALL                                                                GetPitchMultiplier() const;

                LSVOID LSE_CALL                                                                 SetPitchMultiplier( LSSREAL _fPitch );

                LSSREAL LSE_CALL                                                                GetGain() const;

                LSVOID LSE_CALL                                                                 SetGain( LSSREAL _fGain );

                LSSREAL LSE_CALL                                                                GetRolloff() const;

                LSVOID LSE_CALL                                                                 SetRolloff( LSSREAL _fRolloff );

                LSSREAL LSE_CALL                                                                GetMinGain() const;

                LSVOID LSE_CALL                                                                 SetMinGain( LSSREAL _fMinGain );

                LSSREAL LSE_CALL                                                                GetMaxGain() const;

                LSVOID LSE_CALL                                                                 SetMaxGain( LSSREAL _fMaxGain );

                LSSREAL LSE_CALL                                                                GetOuterConeGain() const;

                LSVOID LSE_CALL                                                                 SetOuterConeGain( LSSREAL _fOuterConeGain );

                LSSREAL LSE_CALL                                                                GetInnerConeAngle() const;

                LSVOID LSE_CALL                                                                 SetInnerConeAngle( LSSREAL _fInnerConeGain );

                LSSREAL LSE_CALL                                                                GetConeAngle() const;

                LSVOID LSE_CALL                                                                 SetConeAngle( LSSREAL _fConeAngle );

                virtual LSVOID LSE_CALL                                                 Tick( LSUINT64 _ui64TimeSinceLastUpdate );

                virtual LSVOID LSE_CALL                                                 SynchronousUpdate( LSUINTPTR _uiptrUserPtr );

                LSVOID LSE_CALL                                                                 SetLoopCount( LSUINT32 _ui32Count );

                LSBOOL LSE_CALL                                                                 Loop() const;

                LSUINT32 LSE_CALL                                                               TotalLoops() const;

                LSBOOL LSE_CALL                                                                 Expired() const;

                LSVOID LSE_CALL                                                                 SetExpirationDate( const LSUINT64 &_ui64Micros );

                virtual LSBOOL LSE_CALL                                                 CanSoftReset() const;

                virtual LSVOID LSE_CALL                                                 EventSoundEndedAsync();

                LSBOOL LSE_CALL                                                                 JustStarted() const;

                LSBOOL LSE_CALL                                                                 JustStopped() const;


        protected :
                // == Enumerations.
#ifdef LSS_USEOPENAL
                // An invalid OpenAL buffer ID.  Used internally.
                enum {
                        LSS_INVALID_BUFFER                                                      = 0,
                };
#endif  // #ifdef LSS_USEOPENAL


                // == Members.
                // Live time for this sound.  In microseconds.
                LSUINT64                                                                                m_ui64Time;

                // Dead time for this sound.  In microseconds.  Resets on each play command.
                //      Only accumulates while stopped.
                LSUINT64                                                                                m_ui64DeadTime;

                // Length of the sound we are playing.
                LSUINT64                                                                                m_ui64SoundTime;

                // Expiration time.  If we are dead for this amount of time then we are eligable
                //      for automatic removal.
                LSUINT64                                                                                m_ui64ExpirationDate;

                // Position of the source.
                CVector3                                                                                m_vPos;

                // Velocity of the source.
                CVector3                                                                                m_vVel;

                // Direction of the source.
                CVector3                                                                                m_vDir;

                // Pitch multiplier.
                LSSREAL                                                                                 m_fPitch;

                // Gain.
                LSSREAL                                                                                 m_fGain;

                // Max distance.
                LSSREAL                                                                                 m_fDist;

                // Rolloff.
                LSSREAL                                                                                 m_fRolloff;

                // Minimum gain.
                LSSREAL                                                                                 m_fMinGain;

                // Maximum gain.
                LSSREAL                                                                                 m_fMaxGain;

                // Gain outside of the oriented cone.
                LSSREAL                                                                                 m_fOuterGain;

                // Inner cone angle.
                LSSREAL                                                                                 m_fInnerAngle;

                // Cone angle in degrees.
                LSSREAL                                                                                 m_fConeAngle;

                // Are we dirty?  Update on the next tick if we are.
                LSBOOL                                                                                  m_bDirty;

                // Our unique ID.
                LSUINT32                                                                                m_ui32Id;

                // Our state.
                LSS_SOUND_STATE                                                                 m_ssState;

                // Last state (synchronous with the main game thread).
                LSS_SOUND_STATE                                                                 m_ssLastStateSynchronous;

                // Did we just begin (synchronous with the main game thread)?
                LSBOOL                                                                                  m_bJustBeganSynchronous;

                // Did we just end (synchronous with the main game thread)?
                LSBOOL                                                                                  m_bJustEndedSynchronous;

                // Repeat count.  Use 1 for no looping.  Use LSS_LM_INFINITE
                //      for infinite looping.
                LSUINT32                                                                                m_ui32LoopCount;

                // Last loop mode sent to the sound system.  Sound systems only have loop or not loop.
                LSBOOL                                                                                  m_bSoundSystemLooping;

#ifdef LSS_USEOPENAL
                // The OpenAL ID for this buffer.
                // Created with ::alGenBuffers().
                ALuint                                                                                  m_uiAlSourceId;

#endif  // #ifdef LSS_USEOPENAL

                // The unique ID counter.
                static LSUINT32                                                                 m_ui32IdCounter;


                // == Functions.
                virtual LSVOID LSE_CALL                                                 ApplyStates();

                LSVOID LSE_CALL                                                                 UpdateLoop();

        
                // == Functions.
                virtual LSBOOL LSE_CALL                                                 DeviceActivated();

                virtual LSVOID LSE_CALL                                                 DeviceWillClose();

                virtual LSVOID LSE_CALL                                                 EnterDeletableState() const;
        };


        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // DEFINITIONS
        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // == Various constructors.
        LSE_INLINE LSE_CALLCTOR CSoundSource::CSoundSource( LSUINT32 _ui32Id ) :
                m_fPitch( static_cast<LSSREAL>(1.0) ),
                m_fGain( static_cast<LSSREAL>(0.0) ),
                m_fDist( static_cast<LSSREAL>(100.0) ),
                m_fRolloff( static_cast<LSSREAL>(1.0) ),
                m_fMinGain( static_cast<LSSREAL>(0.0) ),
                m_fMaxGain( static_cast<LSSREAL>(1.0) ),
                m_fOuterGain( static_cast<LSSREAL>(0.0) ),
                m_fInnerAngle( static_cast<LSSREAL>(360.0) ),
                m_fConeAngle( static_cast<LSSREAL>(360.0) ),
                m_bDirty( true ),
                m_ui32Id( LSS_E_INVALID_BUFFER ),
                m_ui64Time( 0ULL ),
                m_ui64DeadTime( 0ULL ),
                m_ui64SoundTime( 0ULL ),
                m_ui64ExpirationDate( LSS_NONEXPIRABLE ),
                m_ssState( LSS_SS_STOPPED ),
                m_bJustBeganSynchronous( false ),
                m_bJustEndedSynchronous( false ),
                m_ui32LoopCount( 1UL ),
                m_bSoundSystemLooping( false ),
#ifdef LSS_USEOPENAL
                m_uiAlSourceId( LSS_INVALID_BUFFER )
#endif  // #ifdef LSS_USEOPENAL
                {
                m_vPos[0] = m_vPos[1] = m_vPos[2] = LSM_ZERO;
                m_vVel[0] = m_vVel[1] = m_vVel[2] = LSM_ZERO;
                m_vDir[0] = m_vDir[1] = LSM_ZERO;
                m_vDir[2] = -LSM_ONE;

                if ( _ui32Id != 0ULL ) {
                        m_ui32IdCounter = _ui32Id;
                        if ( _ui32Id < LSS_UNIQUE_ID ) {
                                CStd::DebugPrintA( "CSoundSource::CSoundSource(): The unique ID given must be equal to or above LSS_UNIQUE_ID.\r\n" );
                                assert( 0 );
                        }
                }
                else {
                        m_ui32IdCounter = ((m_ui32IdCounter + 1UL) % (LSS_UNIQUE_ID - 1)) + 1UL;
                        m_ui32Id = m_ui32IdCounter;
                }
        }
        LSE_INLINE LSE_CALLCTOR CSoundSource::~CSoundSource() {
                EnterDeletableState();
#ifdef LSS_USEOPENAL
                // Delete existing source.
                if ( m_uiAlSourceId != LSS_INVALID_BUFFER ) {
                        ::alDeleteSources( 1, &m_uiAlSourceId );
                        assert( ::alIsSource( m_uiAlSourceId ) == AL_FALSE );
                        m_uiAlSourceId = LSS_INVALID_BUFFER;
                }
#endif  // #ifdef LSS_USEOPENAL
        }

        // == Functions.
        LSE_INLINE LSBOOL LSE_CALL CSoundSource::JustStarted() const {
                return m_bJustBeganSynchronous;
        }

        LSE_INLINE LSBOOL LSE_CALL CSoundSource::JustStopped() const {
                return m_bJustEndedSynchronous;
        }

}       // namespace lss

#endif  // __LSS_SOUNDSOURCE_H__