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

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