/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/

#include "hsTypes.h"
#include "hsGeometry3.h"
#include "plWinAudible.h"
#include "hsMatrix44.h"
#include "hsTimer.h"
#include "../plAudio/plSound.h"
#include "../plAudio/plWin32Sound.h"
#include "../plAudio/plVoiceChat.h"
#include "../plAudio/plAudioSystem.h"
#include "../plAudio/plWin32StreamingSound.h"
#include "../pnMessage/plSoundMsg.h"
#include "../pnMessage/plTimeMsg.h"
#include "../pnMessage/plAudioSysMsg.h"
#include "../plMessage/plLinkToAgeMsg.h"
#include "hsResMgr.h"
#include "../pnKeyedObject/plKey.h"
#include "hsQuat.h"

#include "plgDispatch.h"
#include "../pnMessage/plNodeRefMsg.h"
#include "../pnMessage/plEventCallbackMsg.h"
#include "../pnMessage/plCmdIfaceModMsg.h"
#include "../pnMessage/plProxyDrawMsg.h"
#include "../plMessage/plInputEventMsg.h"
#include "../pnInputCore/plControlEventCodes.h"
#include "../plModifier/plSoundSDLModifier.h"
#include "../pnSceneObject/plSceneObject.h"
#include "../plStatusLog/plStatusLog.h"

#define SND_INDEX_CHECK( index, ret ) 			\
	if( index >= fSoundObjs.GetCount() ) \
	{ \
		hsStatusMessageF( "ERROR: Sound index out of range (index %d, count %d)\n", index,  fSoundObjs.GetCount() ); \
		return ret; \
	} 

#define SND_APPLY_LOOP( index, func, ret ) 		\
	if( index != -1 )							\
	{											\
		SND_INDEX_CHECK( index, ret );			\
		if( fSoundObjs[ index ] != nil )		\
		fSoundObjs[ index ]->func;				\
	}											\
	else										\
	{											\
		for( int i = 0; i < fSoundObjs.Count(); i++ )	\
		{										\
			if( fSoundObjs[ i ] != nil )		\
				fSoundObjs[ i ]->func;			\
		}										\
	}											

// Visualization
#include "plWinAudibleProxy.h"

plWinAudible::plWinAudible()
:	fSceneNode(nil), fSceneObj(nil), fSDLMod(nil)
{
	fProxyGen = TRACKED_NEW plWinAudibleProxy;
	fProxyGen->Init(this);

	fLocalToWorld.Reset();
}

plWinAudible::~plWinAudible()
{
	// delete SDL modifier
	if (fSceneObj)
	{
		plSceneObject* so=plSceneObject::ConvertNoRef(fSceneObj->ObjectIsLoaded());
		if (so)
			so->RemoveModifier(fSDLMod);		
	}
	delete fSDLMod;

	delete fProxyGen;
	for (int i = 0; i < fSoundObjs.Count(); i++)
		delete(fSoundObjs[i]);
	fSoundObjs.SetCountAndZero(0);

}

void plWinAudible::SetSceneObject(plKey obj)
{
	plKey oldKey = nil;
	// remove old SDL mod
	if (fSDLMod && fSceneObj && fSceneObj != obj)
	{
		oldKey = fSceneObj;
		plSceneObject* so=plSceneObject::ConvertNoRef(fSceneObj->ObjectIsLoaded());
		if (so)
			so->RemoveModifier(fSDLMod);
		delete fSDLMod;
		fSDLMod=nil;
	}

	fSceneObj = obj;
	plSceneObject* so=plSceneObject::ConvertNoRef(obj ? obj->ObjectIsLoaded() : nil);
	if (so)
	{
		so->RemoveModifier(fSDLMod);		
		delete fSDLMod;
		fSDLMod=TRACKED_NEW plSoundSDLModifier;
		so->AddModifier(fSDLMod);
	}

	for( int i = 0; i < fSoundObjs.Count(); i++ )
	{									
		if( fSoundObjs[ i ] != nil && fSoundObjs[ i ]->GetKey() != nil )		
		{
			if( obj != nil )
			{
				plGenRefMsg *replaceMsg = TRACKED_NEW plGenRefMsg( fSoundObjs[ i ]->GetKey(), plRefMsg::kOnReplace, 0, plSound::kRefParentSceneObject );
				hsgResMgr::ResMgr()->AddViaNotify( obj, replaceMsg, plRefFlags::kPassiveRef );
			}
			else if( oldKey != nil )
				fSoundObjs[ i ]->GetKey()->Release( oldKey );
		}
	}										
}

void plWinAudible::SetSceneNode(plKey newNode)
{
	plKey oldNode = GetSceneNode();
	if( oldNode == newNode )
		return;

	if( !oldNode )
		Activate();

	if( newNode )
	{
		plNodeRefMsg* refMsg = TRACKED_NEW plNodeRefMsg(newNode, plNodeRefMsg::kOnRequest, -1, plNodeRefMsg::kAudible);
		hsgResMgr::ResMgr()->AddViaNotify(GetKey(), refMsg, plRefFlags::kPassiveRef);

	}
	if( oldNode )
	{
		oldNode->Release(GetKey());
	}

	if( !newNode )
	{
		DeActivate();
	}
	fSceneNode = newNode;
}

void plWinAudible::GetStatus(plSoundMsg* pMsg)
{
	if (pMsg->fIndex == -1)
	{
		for (int i = 0; i < fSoundObjs.Count(); i++)
		{
			plSoundMsg* pReply = fSoundObjs[i]->GetStatus(pMsg);
			pReply->fIndex = i;
			plgDispatch::MsgSend(pReply);
		}
	}
	else
	if (pMsg->fIndex < fSoundObjs.Count())
	{
		plSoundMsg* pReply = fSoundObjs[pMsg->fIndex]->GetStatus(pMsg);
		pReply->fIndex = pMsg->fIndex;
		plgDispatch::MsgSend(pReply);
	}
}

hsBool plWinAudible::AddSound( plSound *pSnd, int index, hsBool is3D )
{
	hsAssert(pSnd->GetKey() != nil, "Adding a new sound with no key.");
	if (plgAudioSys::Active())
	{
		hsgResMgr::ResMgr()->AddViaNotify( pSnd->GetKey(), TRACKED_NEW plGenRefMsg( GetKey(), plRefMsg::kOnCreate, index, 0 ), plRefFlags::kActiveRef );
		return true;
	}

	else
	{
		pSnd->SetProperty( plSound::kPropIs3DSound, is3D );
		hsgResMgr::ResMgr()->AddViaNotify( pSnd->GetKey(), TRACKED_NEW plGenRefMsg( GetKey(), plRefMsg::kOnCreate, index, 0 ), plRefFlags::kActiveRef );
		return true;
	}

}

/* Unused
int plWinAudible::AddSoundFromResource(plSound *pSnd, void* addr, Int32 size, hsBool is3D )
{
	//plWin32Sound* pSnd = TRACKED_NEW plWin32Sound;
	//IAssignSoundKey( pSnd, GetKey() ? GetKeyName() : "", fSoundObjs.Count() - 1 );	

	if (plgAudioSys::Active())
	{
		int ret = pSnd->GetSoundFromMemory(addr, size, is3D );
		if (ret)
		{
			fSoundObjs.Append(pSnd);
			return (fSoundObjs.Count() -1 );
		}
	}

	delete pSnd;
	return -1;
}
*/
plAudible& plWinAudible::SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l, int index)
{
	fLocalToWorld = l2w;
	plAudible::SetTransform(l2w, w2l);
	hsVector3 v = l2w.GetAxis(hsMatrix44::kUp);
	v*=-1;
	hsPoint3 pos = l2w.GetTranslate();
	
	if (index != -1)
	{
		SND_INDEX_CHECK( index, (*this) );
		if( fSoundObjs[ index ] != nil )
		{
			fSoundObjs[index]->SetPosition( pos );
			fSoundObjs[index]->SetConeOrientation( v.fX,v.fY,v.fZ );
		}
	}
	else
	{
		for (int i = 0; i < fSoundObjs.Count(); i++)
		{
			if( fSoundObjs[ i ] != nil )
			{
				fSoundObjs[i]->SetConeOrientation( v.fX,v.fY,v.fZ );
				fSoundObjs[i]->SetPosition( pos );
			}
		}
	}
	fProxyGen->SetTransform(l2w, w2l);

	return (*this);

}

void plWinAudible::SetTime(double t, int index)
{
	SND_APPLY_LOOP( index, SetTime( t ), ; );
}

void plWinAudible::SynchedPlay(int index)
{
	for(int i = 0; i < fSoundObjs.Count(); ++i)
	{
		if(fSoundObjs[i]->IsPlaying())
		{
			fSoundObjs[index]->SynchedPlay(fSoundObjs[i]->GetByteOffset());
			return;
		}
	}
}

void plWinAudible::Play(int index )
{	
	// hsStatusMessageF( "Playing sound %s, index %d, time=%f\n", GetKeyName(), index, hsTimer::GetSeconds());
	SND_APPLY_LOOP( index, Play(), ; );
}

void plWinAudible::FastForwardPlay(int index /* = -1 */)
{
	SND_APPLY_LOOP(index, FastForwardPlay(), ; );
}

void plWinAudible::FastForwardToggle(int index /* = -1 */)
{
	SND_APPLY_LOOP(index, FastForwardToggle(), ; );
}

void plWinAudible::SetOuterVol(const int v, int index)
{
	SND_APPLY_LOOP( index, SetOuterVolume( v ), ; );
}

void plWinAudible::SetConeAngles(int inner, int outer, int index)
{
	SND_APPLY_LOOP( index, SetConeAngles( inner, outer ), ; );
}

void plWinAudible::Stop(int index)
{
	SND_APPLY_LOOP( index, Stop(), ; );
}

void plWinAudible::SetMin(const hsScalar m,int index)
{
	SND_APPLY_LOOP( index, SetMin( (int)m ), ; );
}

void plWinAudible::SetMax(const hsScalar m,int index)
{
	SND_APPLY_LOOP( index, SetMax( (int)m ), ; );
}

// Takes a 0-1.f as the volume (platform independent)
void	plWinAudible::SetVolume(const float volume,int index )
{
	SND_APPLY_LOOP( index, SetVolume( volume ), ; );
}

void	plWinAudible::SetMuted( hsBool muted, int index )
{
	SND_APPLY_LOOP( index, SetMuted( muted ), ; );
}

void	plWinAudible::ToggleMuted( int index )
{
	if( index != -1 )
	{
		SND_INDEX_CHECK( index, ; );
		if( fSoundObjs[ index ] != nil )
			fSoundObjs[ index ]->SetMuted( !fSoundObjs[ index ]->IsMuted() );
	}
	else
	{
		for( int i = 0; i < fSoundObjs.Count(); i++ )
		{
			if( fSoundObjs[ i ] != nil )
				fSoundObjs[ i ]->SetMuted( !fSoundObjs[ i ]->IsMuted() );
		}
	}
}

hsScalar plWinAudible::GetMin(int index) const
{
	return (hsScalar)(fSoundObjs[index]->GetMin());
}

hsScalar plWinAudible::GetMax(int index) const
{
	return (hsScalar)(fSoundObjs[index]->GetMax());
}

void plWinAudible::SetVelocity(const hsVector3 vel,int index)
{
	SND_APPLY_LOOP( index, SetVelocity( vel ), ; );
}

hsVector3 plWinAudible::GetVelocity(int index) const
{
	return(fSoundObjs[index]->GetVelocity());
}

hsPoint3 plWinAudible::GetPosition(int index)
{
	return( fSoundObjs[index]->GetPosition() );
}

void plWinAudible::SetLooping(hsBool loop,int index)
{
	SND_APPLY_LOOP( index, SetProperty( plSound::kPropLooping, loop ), ; );
}

void	plWinAudible::SetFadeIn( const int type, const float length, int index )
{
	SND_APPLY_LOOP( index, SetFadeInEffect( (plSound::plFadeParams::Type)type, length ), ; );
}

void	plWinAudible::SetFadeOut( const int type, const float length, int index ) 
{
	SND_APPLY_LOOP( index, SetFadeOutEffect( (plSound::plFadeParams::Type)type, length ), ; );
}

void plWinAudible::SetFilename(int index, const char *filename, hsBool isCompressed)
{
	if(index < 0 || index >= fSoundObjs.Count())
	{
		hsStatusMessageF( "ERROR: Sound index out of range (index %d, count %d)\n", index,  fSoundObjs.GetCount() );
		return;
	}
	plWin32StreamingSound *pStreamingSound = plWin32StreamingSound::ConvertNoRef(fSoundObjs[ index ]);
	if(pStreamingSound)
	{
		pStreamingSound->SetFilename(filename, isCompressed);
	}
	else
	{
		plStatusLog::AddLineS("audio.log", "Cannot set filename of non-streaming sound. %s", fSoundObjs[ index ]->GetKeyName());
	}
}

hsBool plWinAudible::IsPlaying(int index)
{
	int count = fSoundObjs.Count();

	if(index < count)
	{
		if (index == -1)
		{
			for (int i = 0; i < fSoundObjs.Count(); i++)
			{
				if( fSoundObjs[ i ] != nil && fSoundObjs[i]->IsPlaying() )
					return true;
			}
			return false;
		}

		if( fSoundObjs[ index ] == nil )
			return false;

		return(fSoundObjs[index]->IsPlaying());
	} else {
		return false;
	}
}

void plWinAudible::Read(hsStream* s, hsResMgr* mgr)
{
	plAudible::Read(s, mgr);
	int n = s->ReadSwap32();
	fSoundObjs.SetCountAndZero(n);
	for(int i = 0; i < n; i++ )
	{	
		plGenRefMsg* msg = TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, i, 0);
		mgr->ReadKeyNotifyMe(s, msg, plRefFlags::kActiveRef);
		//plSound* pSnd =  plSound::ConvertNoRef(mgr->ReadCreatable(s));
		//IAssignSoundKey( pSnd, GetKey() ? GetKeyName() : "", i );
		//if (plWin32LinkSound::ConvertNoRef(pSnd))
		//	plgDispatch::Dispatch()->RegisterForExactType(plLinkEffectBCMsg::Index(), pSnd->GetKey());
		//fSoundObjs[i] = pSnd;
	}	
		
	plKey pSceneKey = mgr->ReadKey(s);
	plNodeRefMsg* refMsg = TRACKED_NEW plNodeRefMsg(pSceneKey, plRefMsg::kOnCreate, -1, plNodeRefMsg::kAudible); 
	mgr->AddViaNotify(GetKey(), refMsg, plRefFlags::kPassiveRef);
}

void plWinAudible::IAssignSoundKey( plSound *sound, const char *name, UInt32 i )
{
	char	keyName[ 256 ];

	sprintf( keyName, "%s_%d", name, i );
	hsgResMgr::ResMgr()->NewKey( keyName, sound, GetKey() ? GetKey()->GetUoid().GetLocation() : plLocation::kGlobalFixedLoc );
}

void plWinAudible::Write(hsStream* s, hsResMgr* mgr)
{
	plAudible::Write(s, mgr);
	s->WriteSwap32(fSoundObjs.GetCount());
	for(int i = 0; i < fSoundObjs.GetCount(); i++ )
//		mgr->WriteCreatable( s, fSoundObjs[i] );
		mgr->WriteKey(s, fSoundObjs[i]);

	mgr->WriteKey(s, fSceneNode);
}

void plWinAudible::Activate()
{
	for (int i = 0; i < fSoundObjs.Count(); i++)
		if (fSoundObjs[i] != nil)
			fSoundObjs[i]->Activate();
}


void plWinAudible::DeActivate()
{
	for (int i = 0; i < fSoundObjs.Count(); i++)
	{
		if (fSoundObjs[i] != nil)
		{
			fSoundObjs[i]->DeActivate();
		}
	}
}

hsBool plWinAudible::MsgReceive(plMessage* msg)
{
	plGenRefMsg *refMsg;
	if (refMsg = plGenRefMsg::ConvertNoRef(msg))
	{
		plSound *snd;
		if (snd = plSound::ConvertNoRef(refMsg->GetRef()))
		{
			int index = refMsg->fWhich;
			if( refMsg->GetContext() & (plRefMsg::kOnCreate | plRefMsg::kOnRequest) )
			{
				int i = fSoundObjs.Count();
				if (index >= i)
				{
					fSoundObjs.ExpandAndZero(index + 1);
				}
				fSoundObjs[index] = plSound::ConvertNoRef(refMsg->GetRef());
				if (plgAudioSys::Active())
					fSoundObjs[index]->Activate();
			}
			else if( refMsg->GetContext() & (plRefMsg::kOnRemove | plRefMsg::kOnDestroy) )
			{
				int i = fSoundObjs.Count();
				if (index < i)
				{
					fSoundObjs[index] = nil;
				}
			}
			return true;
		}
	}

	plAudioSysMsg *sysMsg = plAudioSysMsg::ConvertNoRef( msg );
	if( sysMsg )
	{
		if( sysMsg->GetAudFlag() == plAudioSysMsg::kChannelVolChanged )
		{
			SND_APPLY_LOOP( -1, RefreshVolume(), false; );
		}
	}

	// proxyDrawMsg handling--just pass it on to the proxy object
	plProxyDrawMsg *pdMsg = plProxyDrawMsg::ConvertNoRef( msg );
	if( pdMsg != nil )
	{
		if( fProxyGen )
			return fProxyGen->MsgReceive( pdMsg );

		return true;
	}

	return plAudible::MsgReceive(msg);
}

void plWinAudible::RemoveCallbacks(plSoundMsg* pMsg)
{
	// sanity check
	if (pMsg->fIndex >= fSoundObjs.Count())
		return;
	if( pMsg->fIndex < 0 )
	{
		int i;
		for( i = 0; i < fSoundObjs.Count(); i++ )
			fSoundObjs[i]->RemoveCallbacks(pMsg);
	}
	else
	{
		fSoundObjs[pMsg->fIndex]->RemoveCallbacks(pMsg);
	}
}

void plWinAudible::AddCallbacks(plSoundMsg* pMsg)
{
	// sanity check
	if (pMsg->fIndex >= fSoundObjs.Count())
		return;
	int i;
	for( i = 0; i < pMsg->GetNumCallbacks(); i++ )
	{
		pMsg->GetEventCallback(i)->fIndex = pMsg->fIndex;
		pMsg->GetEventCallback(i)->SetSender(GetKey());
	}
	if( pMsg->fIndex < 0 )
	{
		for( i = 0; i < fSoundObjs.Count(); i++ )
			fSoundObjs[i]->AddCallbacks(pMsg);
	}
	else
	{
		fSoundObjs[pMsg->fIndex]->AddCallbacks(pMsg);
	}
}

int plWinAudible::GetSoundIndex(const char *keyname) const
{
	for( int i = 0; i < fSoundObjs.Count(); i++)
	{
		if(!fSoundObjs[i]) continue;
		if(!strcmp(fSoundObjs[i]->GetKeyName(), keyname ))
		{
			return i;
		}
	}
	return -1;
}

plSound* plWinAudible::GetSound(int i) const 
{ 
	return fSoundObjs[i]; 
}

// Visualization
plDrawableSpans* plWinAudible::CreateProxy(hsGMaterial* mat, hsTArray<UInt32>& idx, plDrawableSpans* addTo)
{
	plDrawableSpans* myDraw = addTo;
	int i;
	for( i = 0; i < fSoundObjs.Count(); i++ )
		myDraw = fSoundObjs[i]->CreateProxy(fLocalToWorld, mat, idx, myDraw);
	return myDraw;
}


//
// 2-way win audible (for local players)
//

pl2WayWinAudible::pl2WayWinAudible() :
fVoicePlayer(nil),
fVoiceRecorder(nil),
fActive(false)
{
}

pl2WayWinAudible::~pl2WayWinAudible()
{
	DeActivate();
	if (fVoicePlayer)
		delete fVoicePlayer;
	if(fVoiceRecorder)
		delete fVoiceRecorder;
}

hsBool pl2WayWinAudible::MsgReceive(plMessage* msg)
{
	plEvalMsg* pMsg = plEvalMsg::ConvertNoRef(msg);
	if (pMsg && fVoiceRecorder)
	{
		fVoiceRecorder->Update(pMsg->GetTimeStamp());
//		fVoxIO->Update();
		return true;
	}

	plControlEventMsg* pCtrlMsg = plControlEventMsg::ConvertNoRef(msg);
	if (pCtrlMsg)
	{
		if (pCtrlMsg->GetControlCode() == S_PUSH_TO_TALK && fVoiceRecorder)
			fVoiceRecorder->SetMikeOpen(pCtrlMsg->ControlActivated());
		return true;
	}

	return plWinAudible::MsgReceive(msg);
}

void pl2WayWinAudible::Init(hsBool isLocal)
{
	if (!fVoicePlayer)
	{
		if(!isLocal)
			fVoicePlayer = TRACKED_NEW plVoicePlayer;
	}
	if(!fVoiceRecorder)
	{
		if(isLocal)
		{
			fVoiceRecorder = TRACKED_NEW plVoiceRecorder;
		}
	}
	Activate();
}

void pl2WayWinAudible::Activate()
{
	if(fActive)
		return;

	plWinAudible::Activate();
	if(fVoicePlayer)
	{
		fVoicePlayer->GetSoundPtr()->Activate();
		fActive = true;
	}
	if (fVoiceRecorder)
	{
		plCmdIfaceModMsg* pModMsg = TRACKED_NEW plCmdIfaceModMsg;
		pModMsg->SetBCastFlag(plMessage::kBCastByExactType);
		pModMsg->SetSender(GetKey());
		pModMsg->SetCmd(plCmdIfaceModMsg::kAdd);
		plgDispatch::MsgSend(pModMsg);
		fActive = true;
	}
}

void pl2WayWinAudible::DeActivate()
{
	if(!fActive)
		return;

	plWinAudible::DeActivate();
	if(fVoicePlayer)
	{
		fVoicePlayer->GetSoundPtr()->DeActivate();
		fActive = false;
	}
	if (fVoiceRecorder)
	{			
		plCmdIfaceModMsg* pModMsg = TRACKED_NEW plCmdIfaceModMsg;
		pModMsg->SetBCastFlag(plMessage::kBCastByExactType);
		pModMsg->SetSender(GetKey());
		pModMsg->SetCmd(plCmdIfaceModMsg::kRemove);
		plgDispatch::MsgSend(pModMsg);
		fActive = false;
	}
}

void pl2WayWinAudible::Read(hsStream* s, hsResMgr* mgr)
{
	plWinAudible::Read(s, mgr);
	plgDispatch::Dispatch()->RegisterForExactType(plEvalMsg::Index(), GetKey());
}

void pl2WayWinAudible::PlayNetworkedSpeech(const char* addr, Int32 size, int numFrames, BYTE flags)
{
	if (fVoicePlayer)
	{
		if (!(flags & VOICE_ENCODED))
			fVoicePlayer->PlaybackUncompressedVoiceMessage((BYTE*)addr, size);
		else
			fVoicePlayer->PlaybackVoiceMessage((BYTE*)addr, size, numFrames);
	}
}

plAudible& pl2WayWinAudible::SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l, int index)
{
	plWinAudible::SetTransform(l2w, w2l, index);
	if (fVoicePlayer)
	{
		hsPoint3 pt = l2w.GetTranslate();

		// adjust to head level
		pt.fZ += 6.33f;
		fVoicePlayer->SetPosition( pt );
		hsPoint3 v(l2w.GetAxis(hsMatrix44::kView));
		fVoicePlayer->SetOrientation(v);
	}
	return (*this);
}

void pl2WayWinAudible::SetVelocity(const hsVector3 vel,int index)
{
	plWinAudible::SetVelocity(vel, index);
	if (fVoicePlayer)
		fVoicePlayer->SetVelocity( vel );
}

void pl2WayWinAudible::SetTalkIcon(int index, UInt32 str)
{
	if (fVoicePlayer)
		fVoicePlayer->SetTalkIcon(index,str);
}

void pl2WayWinAudible::ClearTalkIcon()
{
	if (fVoicePlayer)
		fVoicePlayer->ClearTalkIcon();
}