VANetClientImpl.cpp

/*
 *  --------------------------------------------------------------------------------------------
 *
 *    VVV        VVV A           Virtual Acoustics (VA) | http://www.virtualacoustics.org
 *     VVV      VVV AAA          Licensed under the Apache License, Version 2.0
 *      VVV    VVV   AAA
 *       VVV  VVV     AAA        Copyright 2015-2019
 *        VVVVVV       AAA       Institute of Technical Acoustics (ITA)
 *         VVVV         AAA      RWTH Aachen University
 *
 *  --------------------------------------------------------------------------------------------
 */

#include "VANetClientImpl.h"
#include "VANetNetworkProtocol.h"
#include "VANetVistaCompatibility.h"

#include <VA.h>

// ViSTA includes
#include <VistaInterProcComm/Connections/VistaConnectionIP.h>
#include <VistaInterProcComm/Concurrency/VistaMutex.h>
#include <VistaInterProcComm/Concurrency/VistaThreadLoop.h>
#include <VistaBase/VistaDefaultTimerImp.h>
#include <VistaBase/VistaExceptionBase.h>
#include <VistaBase/VistaSerializingToolset.h>
#include <VistaBase/VistaTimerImp.h>

#include <algorithm>
#include <cassert>


// Ensures that any possible call to the client
// is executed stricly serial. No two commands may
// be entered at the same time. This ensures that
// multiple client thread can use the client safely.
#define VA_MUTAL_EXCLUDE VistaMutexLock oLock( m_oCommandMutex )

// State checking macro
#define VA_REQUIRE_CONNECTED { if( m_pParent->IsConnected() == false ) VA_EXCEPT2( MODAL_ERROR, "Not connected." ); }


////////////////////////////////////////////////
/////// NetworkedVACore                 ////////
////////////////////////////////////////////////

class CVANetClientImpl::CNetworkedVACore : public IVAInterface
{
public:
	inline CNetworkedVACore( CVANetNetworkProtocol* pProtocol, CVANetClientImpl* pParent, VistaConnectionIP* pCommandChannel, VistaConnectionIP* pHeadChannel )
		: IVAInterface()
		, m_pParent( pParent )
		, m_pCommandChannel( pCommandChannel )
		, m_pHeadChannel( pHeadChannel )
		, m_pProtocol( pProtocol )
	{
		if( m_pHeadChannel )
			m_pHeadMutex = new VistaMutex;
		else
			m_pHeadMutex = &m_oCommandMutex;
	};

	inline ~CNetworkedVACore()
	{
		if( m_pHeadChannel )
			delete m_pHeadMutex;
	};

	inline VistaMutex* GetCommandMutex()
	{
		return &m_oCommandMutex;
	};

	inline VistaMutex* GetHeadMutex()
	{
		return m_pHeadMutex;
	};

	inline void GetVersionInfo( CVAVersionInfo* pVersionInfo ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetVersionInfo( pVersionInfo );
	};

	inline void SetOutputStream( std::ostream* )
	{
		VA_EXCEPT_NOT_IMPLEMENTED;
	};

	inline int GetState() const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetState();
	};

	inline void Initialize()
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientInitialize();
	};

	inline void Finalize()
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientFinalize();
	};

	inline void Reset()
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientReset();
	};

	inline void AttachEventHandler( IVAEventHandler* pEventHandler )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pParent->AttachEventHandler( pEventHandler );
	};

	inline void DetachEventHandler( IVAEventHandler* pEventHandler )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pParent->DetachEventHandler( pEventHandler );
	};

	inline CVAStruct GetSearchPaths() const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSearchPaths();
	};

	inline std::string FindFilePath( const std::string& sFilePath ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientFindFilePath( sFilePath );
	};

	inline CVAStruct GetCoreConfiguration( const bool bFilterEnabled = true ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetCoreConfiguration( bFilterEnabled );
	};

	inline CVAStruct GetHardwareConfiguration() const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetHardwareConfiguration();
	};

	inline CVAStruct GetFileList( const bool bRecursive = true, const std::string& sFileSuffixMask = "*" ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetFileList( bRecursive, sFileSuffixMask );
	};

	inline void GetModules( std::vector< CVAModuleInfo >& viModuleInfos ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientGetModules( viModuleInfos );
	};

	inline CVAStruct CallModule( const std::string& sModuleName, const CVAStruct& oArgs )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientCallModule( sModuleName, oArgs );
	};


	inline int CreateDirectivityFromParameters( const CVAStruct& oParams, const std::string& sName /* = "" */ )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientCreateDirectivityFromParameters( oParams, sName );
	};

	inline bool DeleteDirectivity( const int iID )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientDeleteDirectivity( iID );
	};

	inline CVADirectivityInfo GetDirectivityInfo( const int iDirID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetDirectivityInfo( iDirID );
	};

	inline void GetDirectivityInfos( std::vector< CVADirectivityInfo >& vdiDest ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientGetDirectivityInfos( vdiDest );
	};

	inline void SetDirectivityName( const int iID, const std::string& sName )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetDirectivityName( iID, sName );
	};

	inline std::string GetDirectivityName( const int iID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetDirectivityName( iID );
	};

	inline void SetDirectivityParameters( const int iID, const CVAStruct& oParams )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetDirectivityParameters( iID, oParams );
	};

	inline CVAStruct GetDirectivityParameters( const int iID, const CVAStruct& oArgs ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetDirectivityParameters( iID, oArgs );
	};


	inline std::string CreateSignalSourceBufferFromParameters( const CVAStruct& oParams, const std::string& sName = "" )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientCreateSignalSourceBufferFromParameters( oParams, sName );
	};

	inline std::string CreateSignalSourcePrototypeFromParameters( const CVAStruct& oParams, const std::string& sName = "" )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientCreateSignalSourcePrototypeFromParameters( oParams, sName );
	};

	inline std::string CreateSignalSourceTextToSpeech( const std::string& sName = "" )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientCreateTextToSpeechSignalSource( sName );
	};

	inline std::string CreateSignalSourceSequencer( const std::string& sName = "" )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientCreateSequencerSignalSource( sName );
	};

	inline std::string CreateSignalSourceNetworkStream( const std::string& sInterface, const int iPort, const std::string& sName = "" )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientCreateNetworkStreamSignalSource( sInterface, iPort, sName );
	};

	inline std::string CreateSignalSourceEngine( const CVAStruct& oParams, const std::string& sName = "" )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientCreateEngineSignalSource( oParams, sName );
	};

	inline std::string CreateSignalSourceMachine( const CVAStruct& oParams, const std::string& sName = "" )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientCreateSignalSourceMachine( oParams, sName );
	};

	inline bool DeleteSignalSource( const std::string& sID )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientDeleteSignalSource( sID );
	};

	inline std::string RegisterSignalSource( IVAAudioSignalSource*, const std::string& )
	{
		VA_EXCEPT2( NOT_IMPLEMENTED, "This function is not available when operating on a remote server" );
	};

	inline bool UnregisterSignalSource( IVAAudioSignalSource* )
	{
		VA_EXCEPT2( NOT_IMPLEMENTED, "This function is not available when operating on a remote server" );
	};

	inline CVASignalSourceInfo GetSignalSourceInfo( const std::string& sSignalSourceID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSignalSourceInfo( sSignalSourceID );
	};

	inline void GetSignalSourceInfos( std::vector<CVASignalSourceInfo>& vssiDest ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSignalSourceInfos( vssiDest );
	};

	inline int GetSignalSourceBufferPlaybackState( const std::string& sSignalSourceID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSignalSourceBufferPlaybackState( sSignalSourceID );
	};

	inline void SetSignalSourceBufferPlaybackAction( const std::string& sSignalSourceID, const int iPlayState )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSignalSourceBufferPlaybackAction( sSignalSourceID, iPlayState );
	};

	inline void SetSignalSourceBufferPlaybackPosition( const std::string& sSignalSourceID, const double dPlaybackPosition )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSignalSourceBufferPlaybackPosition( sSignalSourceID, dPlaybackPosition );
	};

	inline bool GetSignalSourceBufferLooping( const std::string& sSignalSourceID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSignalSourceBufferLooping( sSignalSourceID );
	};

	inline void SetSignalSourceBufferLooping( const std::string& sSignalSourceID, const bool bLooping )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSignalSourceBufferLooping( sSignalSourceID, bLooping );
	};

	inline void SetSignalSourceParameters( const std::string& sSignalSourceID, const CVAStruct& oParams )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSignalSourceParameters( sSignalSourceID, oParams );
	};

	inline CVAStruct GetSignalSourceParameters( const std::string& sSignalSourceID, const CVAStruct& oParams ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSignalSourceParameters( sSignalSourceID, oParams );
	};

	inline int AddSignalSourceSequencerSample( const std::string& sSignalSourceID, const CVAStruct& oArgs )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientAddSignalSourceSequencerSample( sSignalSourceID, oArgs );
	};

	inline int AddSignalSourceSequencerPlayback( const std::string& sSignalSourceID, const int iSoundID, const int iFlags, const double dTimeCode )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientAddSignalSourceSequencerPlayback( sSignalSourceID, iSoundID, iFlags, dTimeCode );
	};

	inline void RemoveSignalSourceSequencerSample( const std::string& sSignalSourceID, const int iSoundID )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientRemoveSignalSourceSequencerSample( sSignalSourceID, iSoundID );
	};


	inline bool GetUpdateLocked() const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetUpdateLocked();
	};

	inline void LockUpdate()
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientLockUpdate();
	};

	inline int UnlockUpdate()
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientUnlockUpdate();
	};


	inline void GetSoundSourceIDs( std::vector< int >& vSoundSourceIDs )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundSourceIDs( vSoundSourceIDs );
	};

	inline int CreateSoundSource( const std::string& sName = "" )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientCreateSoundSource( sName );
	};

	inline int CreateSoundSourceExplicitRenderer( const std::string& sRendererID, const std::string& sName = "" )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientCreateSoundSourceExplicitRenderer( sRendererID, sName );
	};

	inline int DeleteSoundSource( const int iID )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientDeleteSoundSource( iID );
	};

	inline void SetSoundSourceEnabled( const int iSoundSourceID, const bool bEnabled = true )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientSetSoundSourceEnabled( iSoundSourceID, bEnabled );
	};

	inline bool GetSoundSourceEnabled( const int iSoundSourceID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundSourceEnabled( iSoundSourceID );
	};

	inline CVASoundSourceInfo GetSoundSourceInfo( const int iSoundSourceID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundSourceInfo( iSoundSourceID );
	};

	inline std::string GetSoundSourceName( const int iSoundSourceID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundSourceName( iSoundSourceID );
	};

	inline void SetSoundSourceName( const int iSoundSourceID, const std::string& sName )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundSourceName( iSoundSourceID, sName );
	};

	inline std::string GetSoundSourceSignalSource( const int iSoundSourceID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundSourceSignalSource( iSoundSourceID );
	};

	inline void SetSoundSourceSignalSource( const int iSoundSourceID, const std::string& sSignalSourceID )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundSourceSignalSource( iSoundSourceID, sSignalSourceID );
	};

	inline int GetSoundSourceAuralizationMode( const int iSoundSourceID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundSourceAuralizationMode( iSoundSourceID );
	};

	inline void SetSoundSourceAuralizationMode( const int iSoundSourceID, const int iAuralizationMode )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundSourceAuralizationMode( iSoundSourceID, iAuralizationMode );
	};

	inline CVAStruct GetSoundSourceParameters( const int iID, const CVAStruct& oArgs ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundSourceParameters( iID, oArgs );
	};

	inline void SetSoundSourceParameters( const int iID, const CVAStruct& oParams )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundSourceParameters( iID, oParams );
	};

	inline int GetSoundSourceDirectivity( const int iSoundSourceID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundSourceDirectivity( iSoundSourceID );
	};

	inline void SetSoundSourceDirectivity( const int iSoundSourceID, const int iDirectivityID )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientSetSoundSourceDirectivity( iSoundSourceID, iDirectivityID );
	};

	inline double GetSoundSourceSoundPower( const int iSoundSourceID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundSourceSoundPower( iSoundSourceID );
	};

	inline void SetSoundSourceSoundPower( const int iSoundSourceID, const double dPower )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundSourceSoundPower( iSoundSourceID, dPower );
	};

	inline bool GetSoundSourceMuted( const int iSoundSourceID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundSourceMuted( iSoundSourceID );
	};

	inline void SetSoundSourceMuted( const int iSoundSourceID, const bool bMuted = true )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundSourceMuted( iSoundSourceID, bMuted );
	};

	inline void GetSoundSourcePose( const int iID, VAVec3& v3Pos, VAQuat& qOrient ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientGetSoundSourcePose( iID, v3Pos, qOrient );
	};

	inline void SetSoundSourcePose( const int iID, const VAVec3& v3Pos, const VAQuat& qOrient )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundSourcePose( iID, v3Pos, qOrient );
	};

	inline void SetSoundSourcePosition( const int iID, const VAVec3& v3Pos )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundSourcePosition( iID, v3Pos );
	};

	inline void SetSoundSourceOrientation( const int iID, const VAQuat& qOrient )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundSourceOrientation( iID, qOrient );
	};

	inline void SetSoundSourceOrientationVU( const int iID, const VAVec3& v3View, const VAVec3& v3Up )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundSourceOrientationVU( iID, v3View, v3Up );
	};

	inline VAVec3 GetSoundSourcePosition( const int iID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundSourcePosition( iID );
	};

	inline VAQuat GetSoundSourceOrientation( const int iSoundSourceID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundSourceOrientation( iSoundSourceID );
	};

	inline void GetSoundSourceOrientationVU( const int iSoundSourceID, VAVec3& v3View, VAVec3& v3Up ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientGetSoundSourceOrientationVU( iSoundSourceID, v3View, v3Up );
	};


	inline int GetSoundSourceGeometryMesh( const int iID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundSourceGeometryMesh( iID );
	};

	inline void SetSoundSourceGeometryMesh( const int iSoundSourceID, const int iGeometryMeshID )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundSourceGeometryMesh( iSoundSourceID, iGeometryMeshID );
	};


	inline void GetSoundReceiverIDs( std::vector< int >& vSoundReceiverIDs ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientGetSoundReceiverIDs( vSoundReceiverIDs );
	};

	inline int CreateSoundReceiver( const std::string& sName = "" )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientCreateSoundReceiver( sName );
	};

	inline int CreateSoundReceiverExplicitRenderer( const std::string& sRendererID, const std::string& sName )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientCreateSoundReceiverExplicitRenderer( sRendererID, sName );
	};

	inline void SetActiveSoundReceiverExplicitRenderer( const int iSoundReceiverID, const std::string& sRendererID )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientSetActiveSoundReceiverExplicitRenderer( iSoundReceiverID, sRendererID );
	};

	inline int GetActiveSoundReceiverExplicitRenderer( const std::string& sRendererID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetActiveSoundReceiverExplicitRenderer( sRendererID );
	};

	inline int DeleteSoundReceiver( const int iSoundReceiverID )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientDeleteSoundReceiver( iSoundReceiverID );
	};

	inline CVASoundReceiverInfo GetSoundReceiverInfo( const int iID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundReceiverInfo( iID );
	};

	inline void SetSoundReceiverEnabled( const int iSoundReceiverID, const bool bEnabled = true )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientSetSoundReceiverEnabled( iSoundReceiverID, bEnabled );
	};

	inline bool GetSoundReceiverEnabled( const int iSoundReceiverID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundReceiverEnabled( iSoundReceiverID );
	};

	inline std::string GetSoundReceiverName( const int iSoundReceiverID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundReceiverName( iSoundReceiverID );
	};

	inline void SetSoundReceiverName( const int iSoundReceiverID, const std::string& sName )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundReceiverName( iSoundReceiverID, sName );
	};

	inline int GetSoundReceiverAuralizationMode( const int iSoundReceiverID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundReceiverAuralizationMode( iSoundReceiverID );
	}

	inline void SetSoundReceiverAuralizationMode( const int iSoundReceiverID, const int iAuralizationMode )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundReceiverAuralizationMode( iSoundReceiverID, iAuralizationMode );
	};

	inline CVAStruct GetSoundReceiverParameters( const int iID, const CVAStruct& oArgs ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundReceiverParameters( iID, oArgs );
	};

	inline void SetSoundReceiverParameters( const int iID, const CVAStruct& oParams )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundReceiverParameters( iID, oParams );
	};

	inline int GetSoundReceiverDirectivity( const int iSoundReceiverID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundReceiverDirectivity( iSoundReceiverID );
	};

	inline void SetSoundReceiverDirectivity( const int iSoundReceiverID, const int iDirectivityID )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundReceiverDirectivity( iSoundReceiverID, iDirectivityID );
	};

	inline void GetSoundReceiverPose( const int iID, VAVec3& v3Pos, VAQuat& qOrient ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientGetSoundReceiverPose( iID, v3Pos, qOrient );
	};

	inline void SetSoundReceiverPose( const int iID, const VAVec3& v3Pos, const VAQuat& qOrient )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundReceiverPose( iID, v3Pos, qOrient );
	};

	inline VAVec3 GetSoundReceiverPosition( const int iID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundReceiverPosition( iID );
	};

	inline void SetSoundReceiverPosition( const int iID, const VAVec3& v3Pos )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundReceiverPosition( iID, v3Pos );
	};

	inline VAQuat GetSoundReceiverOrientation( const int iSoundReceiverID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundReceiverOrientation( iSoundReceiverID );
	};

	inline void SetSoundReceiverOrientation( const int iID, const VAQuat& qOrient )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundReceiverOrientation( iID, qOrient );
	};


	inline void GetSoundReceiverOrientationVU( const int iSoundReceiverID, VAVec3& v3View, VAVec3& v3Up ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientGetSoundReceiverOrientationVU( iSoundReceiverID, v3View, v3Up );
	};

	inline void SetSoundReceiverOrientationVU( const int iID, const VAVec3& v3View, const VAVec3& v3Up )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundReceiverOrientationVU( iID, v3View, v3Up );
	};

	inline VAQuat GetSoundReceiverHeadAboveTorsoOrientation( const int iID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundReceiverHeadAboveTorsoOrientation( iID );
	};

	inline void SetSoundReceiverHeadAboveTorsoOrientation( const int iID, const VAQuat& qOrient )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundReceiverHeadAboveTorsoOrientation( iID, qOrient );
	};

	inline int GetSoundReceiverGeometryMesh( const int iID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundReceiverGeometryMesh( iID );
	};

	inline void SetSoundReceiverGeometryMesh( const int iSoundReceiverID, const int iGeometryMeshID )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundReceiverGeometryMesh( iSoundReceiverID, iGeometryMeshID );
	};

	inline void GetSoundReceiverRealWorldPose( const int iID, VAVec3& v3Pos, VAQuat& qOrient ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientGetSoundReceiverRealWorldPose( iID, v3Pos, qOrient );
	};

	inline void SetSoundReceiverRealWorldPose( const int iID, const VAVec3& v3Pos, const VAQuat& qOrient )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundReceiverRealWorldPose( iID, v3Pos, qOrient );
	};

	inline VAQuat GetSoundReceiverRealWorldHeadAboveTorsoOrientation( const int iID ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetSoundReceiverRealWorldTorsoOrientation( iID );
	};

	inline void SetSoundReceiverRealWorldHeadAboveTorsoOrientation( const int iID, const VAQuat& qOrient )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundReceiverRealWorldTorsoOrientation( iID, qOrient );
	};

	inline void GetSoundReceiverRealWorldPositionOrientationVU( const int iID, VAVec3& v3Pos, VAVec3& v3View, VAVec3& v3Up ) const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientGetSoundReceiverRealWorldPositionOrientationVU( iID, v3Pos, v3View, v3Up );
	};

	inline void SetSoundReceiverRealWorldPositionOrientationVU( const int iID, const VAVec3& v3Pos, const VAVec3& v3View, const VAVec3& v3Up )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetSoundReceiverRealWorldPositionOrientationVU( iID, v3Pos, v3View, v3Up );
	};


	inline void SetHomogeneousMediumSoundSpeed( const double dSoundSpeed )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetHomogeneousMediumSoundSpeed( dSoundSpeed );
	};

	inline double GetHomogeneousMediumSoundSpeed() const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetHomogeneousMediumSoundSpeed();
	};

	inline void SetHomogeneousMediumTemperature( const double dDegreesCentigrade )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetHomogeneousMediumTemperature( dDegreesCentigrade );
	};

	inline double GetHomogeneousMediumTemperature() const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetHomogeneousMediumTemperature();
	};

	inline void SetHomogeneousMediumStaticPressure( const double dPressurePascal )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetHomogeneousMediumStaticPressure( dPressurePascal );
	};

	inline double GetHomogeneousMediumStaticPressure() const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetHomogeneousMediumStaticPressure();
	};

	inline void SetHomogeneousMediumRelativeHumidity( const double dRelativeHumidityPercent )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetHomogeneousMediumRelativeHumidity( dRelativeHumidityPercent );
	};

	inline double GetHomogeneousMediumRelativeHumidity()
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetHomogeneousMediumRelativeHumidity();
	};

	inline void SetHomogeneousMediumShiftSpeed( const VAVec3& v3TranslationSpeed )
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		m_pProtocol->ClientSetHomogeneousMediumShiftSpeed( v3TranslationSpeed );
	};

	inline VAVec3 GetHomogeneousMediumShiftSpeed() const
	{
		VA_REQUIRE_CONNECTED;
		VA_MUTAL_EXCLUDE;
		return m_pProtocol->ClientGetHomogeneousMediumShiftSpeed();
	};

	inline void SetHomogeneousMediumParameters( const CVAStruct& oParams )
	{