CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plAudio/plSound.h

/*==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/>.

Additional permissions under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.

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==*/
//////////////////////////////////////////////////////////////////////////////
//																			//
//	plSound.h - Base sound class header										//
//																			//
//// History /////////////////////////////////////////////////////////////////
//																			//
//	10.12.01 mcn	- Added preliminary soft region (volume) support.		//
//	7.12.02 mcn		- Added EAX support										//
//	7.15.02 mcn		- Added support for animated volumes					//
//																			//
//////////////////////////////////////////////////////////////////////////////

#ifndef plSound_h
#define plSound_h

#include "hsTemplates.h"
#include "hsGeometry3.h"
#include "plEAXEffects.h"
#include "../pnNetCommon/plSynchedObject.h"
#include "../plAvatar/plAGChannel.h"
#include "../plAvatar/plAGApplicator.h"
#include "../plAudioCore/plSoundBuffer.h"

class hsResMgr;
class hsStream;
class plSoundProxy;
class plDrawableSpans;
class hsGMaterial;
class plSoundMsg;
class plSoftVolume;
class plGraphPlate;
struct hsMatrix44;
class plSoundBuffer;
class plSceneObject;
class plSoundVolumeApplicator;

// Set this to 1 to do our own distance attenuation (model doesn't work yet tho)
#define MCN_HACK_OUR_ATTEN	0
#define MAX_INCIDENTALS 4

class plSound : public plSynchedObject
{
	friend class plSoundSDLModifier;
	friend class plSoundVolumeApplicator;

public:
	plSound();
	virtual ~plSound();

	CLASSNAME_REGISTER( plSound );
	GETINTERFACE_ANY( plSound, plSynchedObject );

	enum Property
	{
		kPropIs3DSound		= 0x00000001,
		kPropDisableLOD		= 0x00000002,
		kPropLooping		= 0x00000004,
		kPropAutoStart		= 0x00000008,
		kPropLocalOnly		= 0x00000010,	// Disables network synching and triggering
		kPropLoadOnlyOnCall	= 0x00000020,	// Only load and unload when we're told to
		kPropFullyDisabled  = 0x00000040,	// This sound should never play while this is set
											// Only plWin32LinkSound uses it. Placed here as a TODO though...
		kPropDontFade		= 0x00000080,
		kPropIncidental		= 0x00000100	// Incidental sound, will be played thru the incidental manager
	};

	enum Type
	{
		kStartType,
		kSoundFX = kStartType,				// For now, 3D sounds are always marked as this
		kAmbience,
		kBackgroundMusic,
		kGUISound,
		kNPCVoices,
		kNumTypes
	};

	enum Refs
	{
		kRefSoftVolume = 0,
		kRefDataBuffer,		// plugins only
		kRefParentSceneObject,
		kRefSoftOcclusionRegion
	};

	enum 
	{
		kSoftRegion = 0
	};

	enum StreamType
	{ 
		kNoStream, 
		kStreamFromRAM, 
		kStreamFromDisk, 
		kStreamCompressed 
	};

	class plFadeParams
	{
		friend class plSound;

		public:
			enum Type
			{
				kLinear,
				kLogarithmic,
				kExponential
			};

			hsScalar	fLengthInSecs;		// Time to take to fade
			hsScalar	fVolStart;			// Set one of these two for fade in/out,
			hsScalar	fVolEnd;			// the other becomes the current volume
			UInt8		fType;
			hsBool		fStopWhenDone;		// Actually stop the sound once the fade is complete
			hsBool		fFadeSoftVol;		// Fade the soft volume instead of fCurrVolume

			plFadeParams() { fLengthInSecs = 0.f; fCurrTime = -1.f; fStopWhenDone = false; fFadeSoftVol = false; fVolStart = fVolEnd = 0.f; fType = kLinear; }

			plFadeParams( Type type, hsScalar len, hsScalar start, hsScalar end )
			{
				fLengthInSecs = len; fVolStart = start; fVolEnd = end; fType = type;
				fStopWhenDone = false;
				fFadeSoftVol = false;
			}

			void	Read( hsStream *s );
			void	Write( hsStream *s );

			hsScalar	InterpValue( void );

		protected:
			hsScalar	fCurrTime;			// -1 if we aren't active, else it's how far we're into the animation
	};

	virtual hsBool		LoadSound( hsBool is3D ) = 0;
	hsScalar			GetVirtualStartTime( void ) const { return (hsScalar)fVirtualStartTime; }

	virtual void 		Play();
	void				SynchedPlay( unsigned bytes );
	void				SynchedPlay( hsScalar virtualStartTime );
	virtual void 		Stop();
	virtual void 		FastForwardPlay();
	virtual void 		FastForwardToggle();
	virtual void 		SetMin(const int m); // sets minimum falloff distance
	virtual void 		SetMax(const int m); // sets maximum falloff distance
	virtual int			GetMin() const;
	virtual int			GetMax() const;
	virtual void		SetVolume(const float volume);
	virtual float		GetVolume(void) const { return fCurrVolume; }
	hsScalar			GetMaxVolume() { return fMaxVolume; }
	virtual hsBool		IsPlaying() { return fPlaying; }
	void				SetTime(double t);
	virtual double		GetTime( void ) { return 0.f; }
	virtual void		Activate(hsBool forcePlay = false);
	virtual void		DeActivate();
	virtual void		SetLength(double l) { fLength = l; }
	virtual void		SetMuted( hsBool muted );
	virtual hsBool		IsMuted( void ) { return fMuted; }
	void				Disable() { fDistAttenuation = 0; }
	virtual plSoundMsg* GetStatus(plSoundMsg* pMsg){return NULL;}
	virtual void		SetConeOrientation(hsScalar x, hsScalar y, hsScalar z);
	virtual void		SetOuterVolume( const int v ); // volume for the outer cone (if applicable)
	virtual void		SetConeAngles( int inner, int outer );
	virtual void		SetPosition(const hsPoint3 pos);
	virtual void		SetVelocity(const hsVector3 vel);
	virtual hsPoint3	GetPosition() const;
	virtual hsVector3	GetVelocity() const;

	virtual void		Update();
	
	plSoundBuffer *		GetDataBuffer( void ) const { return (plSoundBuffer *)fDataBufferKey->ObjectIsLoaded(); }
	hsScalar			QueryCurrVolume( void ) const;	// Returns the current volume, attenuated

	const char *		GetFileName( void ) const;
	virtual double		GetLength();

	void				SetProperty( Property prop, hsBool on ) { if( on ) fProperties |= prop; else fProperties &= ~prop; }
	hsBool				IsPropertySet( Property prop ) const { return ( fProperties & prop ) ? true : false; }

	virtual void		RefreshVolume( void );

	virtual void		SetStartPos(unsigned bytes) = 0;
	virtual unsigned	GetByteOffset(){return 0;}
	virtual float		GetActualTimeSec() = 0;

	virtual	void		AddCallbacks(plSoundMsg* pMsg) = 0;
	virtual void		RemoveCallbacks(plSoundMsg* pMsg) = 0;

	virtual UInt8		GetChannelSelect( void ) const { return 0; }	// Only defined on Win32Sound right now, should be here tho

	virtual void		Read(hsStream* s, hsResMgr* mgr);
	virtual void		Write(hsStream* s, hsResMgr* mgr);
	
	virtual void		SetFadeInEffect( plFadeParams::Type type, hsScalar length );
	virtual void		SetFadeOutEffect( plFadeParams::Type type, hsScalar length );
	virtual hsScalar	CalcSoftVolume( hsBool enable, hsScalar distToListenerSquared );
	virtual void		UpdateSoftVolume( hsBool enable, hsBool firstTime = false );

	virtual hsBool		MsgReceive( plMessage* pMsg );
	virtual hsBool		DirtySynchState( const char *sdlName = nil, UInt32 sendFlags = 0 );	// call when state has changed

	// Tests whether this sound is within range of the given position, not counting soft regions
	hsBool				IsWithinRange( const hsPoint3 &listenerPos, hsScalar *distSquared );

	// Type setting and getting, from the Types enum
	void				SetType( UInt8 type ) { fType = type; }
	UInt8				GetType( void ) const { return fType; }

	// Priority stuff
	void				SetPriority( UInt8 pri ) { fPriority = pri; }
	UInt8				GetPriority( void ) const { return fPriority; }

	// Visualization
	virtual plDrawableSpans*	CreateProxy(const hsMatrix44& l2w, hsGMaterial* mat, hsTArray<UInt32>& idx, plDrawableSpans* addTo);

	// Forced loading/unloading (for when the audio system's LOD just doesn't cut it)
	virtual void		ForceLoad(  );
	virtual void		ForceUnload( void );

	// Note: ONLY THE AUDIOSYS SHOULD CALL THIS. If you're not the audioSys, get lost.
	static void			SetCurrDebugPlate( const plKey soundKey );

	void				RegisterOnAudioSys( void );
	void				UnregisterOnAudioSys( void );

	// Also only for the audio system
	hsScalar			GetVolumeRank( void );
	void				ForceUnregisterFromAudioSys( void );

	static void			SetLoadOnDemand( hsBool activate ) { fLoadOnDemandFlag = activate; }
	static void			SetLoadFromDiskOnDemand( hsBool activate ) { fLoadFromDiskOnDemand = activate; }

	const plEAXSourceSettings	&GetEAXSettings( void ) const { return fEAXSettings; }
	plEAXSourceSettings			&GetEAXSettings( void ) { return fEAXSettings; }
	virtual StreamType			GetStreamType() const { return kNoStream; }
	virtual void	FreeSoundData();


protected:
	hsBool		fPlaying;
	hsBool		fActive;
	double		fTime;
	int			fMaxFalloff;
	int			fMinFalloff;
	hsScalar	fCurrVolume;
	hsScalar	fDesiredVol;		// Equal to fCurrVolume except when we're fading or muted
	hsScalar	fFadedVolume;
	hsScalar	fMaxVolume;

	int			fOuterVol;
	int			fInnerCone;
	int			fOuterCone;
	double		fLength;
	
	int			fProperties;
	UInt8		fType;
	UInt8		fPriority;

	hsBool		fMuted, fFading, fRegisteredForTime, fPlayOnReactivate, fFreeData;
	hsBool		fNotHighEnoughPriority;		// Set whenever the audioSys calls UpdateSoftVolume() with enable=false,
											// thus indicating that we slipped off the top 16 most wanted list. 

	// Do these need to be synched values? They weren't before...
	hsVector3	fConeOrientation;
	hsPoint3	f3DPosition;
	hsVector3	f3DVelocity;
	hsBool		fPlayWhenLoaded;

	double		fSynchedStartTimeSec;
	
	// Just around for reference and sending messages upward (synched state)
	plSceneObject		*fOwningSceneObject;

	// EAX Settings storage here
	plEAXSourceSettings	fEAXSettings;
	hsBool fQueued;

	plFadeParams	fFadeInParams, fFadeOutParams;
	plFadeParams	fCoolSoftVolumeTrickParams;
	plFadeParams	*fCurrFadeParams;

	plSoftVolume	*fSoftRegion;
	hsScalar		fSoftVolume;
	hsScalar		fDistAttenuation, fDistToListenerSquared;
	double			fVirtualStartTime;
	hsBool			fRegistered;
	static unsigned	fIncidentalsPlaying;

	plSoftVolume	*fSoftOcclusionRegion;

	plSoundBuffer	*fDataBuffer;			// Not always around
	hsBool			fDataBufferLoaded;
	plKey			fDataBufferKey;		// Always around

	static plGraphPlate	*fDebugPlate;
	static plSound		*fCurrDebugPlateSound;

	static hsBool		fLoadOnDemandFlag, fLoadFromDiskOnDemand;
	hsBool				fLoading;

	void			IUpdateDebugPlate( void );
	void			IPrintDbgMessage( const char *msg, hsBool isErr = false );

	virtual void	ISetActualVolume(const float v) = 0;
	virtual void	IActuallyStop( void );
	virtual hsBool	IActuallyPlaying( void ) = 0;
	virtual void	IActuallyPlay( void ) = 0;
	virtual void	IFreeBuffers( void ) = 0;

	//NOTE: if isIncidental is true the entire sound will be loaded. 
	virtual plSoundBuffer::ELoadReturnVal	IPreLoadBuffer( hsBool playWhenLoaded, hsBool isIncidental = false );	
	virtual void		ISetActualTime( double t ) = 0;
	
	virtual hsBool		IActuallyLoaded( void ) = 0;
	virtual void		IRefreshEAXSettings( hsBool force = false ) = 0;

	virtual hsScalar	IGetChannelVolume( void ) const;

	void	ISynchToStartTime( void );
	void	ISynchedPlay( double virtualStartTime );
	void	IStartFade( plFadeParams *params, hsScalar offsetIntoFade = 0.f );
	void	IStopFade( hsBool shuttingDown = false, hsBool SetVolEnd = true);
	
	hsBool	IWillBeAbleToPlay( void );

	void		ISetSoftRegion( plSoftVolume *region );
	hsScalar	IAttenuateActualVolume( hsScalar volume ) const;
	void		ISetSoftOcclusionRegion( plSoftVolume *region );

	// Override to make sure the buffer is available before the base class is called
	virtual void	IRefreshParams( void );

	virtual bool	ILoadDataBuffer( void );
	virtual void	IUnloadDataBuffer( void );

	//virtual void	ISetMinDistance( const int m ) = 0;
	//virtual void	ISetMaxDistance( const int m ) = 0;
	//virtual void	ISetOuterVolume( const int v ) = 0;
	//virtual void	ISetConeAngles( int inner, int outer ) = 0;
	//virtual void	ISetActualConeOrient( hsVector3 &vector ) = 0;
	//virtual void	ISetVelocity( const hsVector3 vel ) = 0;
	//virtual void	ISetPosition( const hsPoint3 pos ) = 0;

	virtual void	IRead( hsStream *s, hsResMgr *mgr );
	virtual void	IWrite( hsStream *s, hsResMgr *mgr );
};


//// plSoundVolumeApplicator /////////////////////////////////////////////////
//	Tiny helper for handling animated volumes

class plSoundVolumeApplicator : public plAGApplicator
{
public:
	plSoundVolumeApplicator() { }
	plSoundVolumeApplicator( UInt32 index ) { fIndex = index; }

	CLASSNAME_REGISTER( plSoundVolumeApplicator );
	GETINTERFACE_ANY( plSoundVolumeApplicator, plAGApplicator );

	virtual plAGApplicator *CloneWithChannel( plAGChannel *channel );
	virtual void			Write( hsStream *stream, hsResMgr *mgr );
	virtual void			Read( hsStream *s, hsResMgr *mgr );

protected:
	UInt32		fIndex;
	virtual void IApply( const plAGModifier *mod, double time );
};

#endif //plWin32Sound_h