You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1312 lines
38 KiB
1312 lines
38 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: |
|
// |
|
// $Workfile: $ |
|
// $Date: $ |
|
// $NoKeywords: $ |
|
//=============================================================================// |
|
#include "cbase.h" |
|
#include "sharedInterface.h" |
|
#include "soundenvelope.h" |
|
#include "engine/IEngineSound.h" |
|
#include "IEffects.h" |
|
#include "isaverestore.h" |
|
#include "saverestore_utlvector.h" |
|
#include "gamestringpool.h" |
|
#include "igamesystem.h" |
|
#include "utlpriorityqueue.h" |
|
#include "mempool.h" |
|
#include "SoundEmitterSystem/isoundemittersystembase.h" |
|
#include "tier0/vprof.h" |
|
#include "gamerules.h" |
|
|
|
// memdbgon must be the last include file in a .cpp file!!! |
|
#include "tier0/memdbgon.h" |
|
|
|
static ConVar soundpatch_captionlength( "soundpatch_captionlength", "2.0", FCVAR_REPLICATED, "How long looping soundpatch captions should display for." ); |
|
|
|
// Envelope |
|
// This is a class that controls a ramp for a sound (pitch / volume / etc) |
|
class CSoundEnvelope |
|
{ |
|
public: |
|
DECLARE_SIMPLE_DATADESC(); |
|
|
|
CSoundEnvelope() |
|
{ |
|
m_current = 0.0f; |
|
m_target = 0.0f; |
|
m_rate = 0.0f; |
|
m_forceupdate = false; |
|
} |
|
|
|
void SetTarget( float target, float deltaTime ); |
|
void SetValue( float value ); |
|
bool ShouldUpdate( void ); |
|
void Update( float time ); |
|
inline float Value( void ) { return m_current; } |
|
|
|
private: |
|
float m_current; |
|
float m_target; |
|
float m_rate; |
|
bool m_forceupdate; |
|
}; |
|
|
|
|
|
BEGIN_SIMPLE_DATADESC( CSoundEnvelope ) |
|
DEFINE_FIELD( m_current, FIELD_FLOAT ), |
|
DEFINE_FIELD( m_target, FIELD_FLOAT ), |
|
DEFINE_FIELD( m_rate, FIELD_FLOAT ), |
|
DEFINE_FIELD( m_forceupdate, FIELD_BOOLEAN ), |
|
END_DATADESC() |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Set the new target value for this ramp. Reach this target in deltaTime |
|
// seconds from now |
|
// Input : target - new target value |
|
// deltaTime - time to reach target |
|
//----------------------------------------------------------------------------- |
|
void CSoundEnvelope::SetTarget( float target, float deltaTime ) |
|
{ |
|
float deltaValue = target - m_current; |
|
|
|
if ( deltaValue && deltaTime > 0 ) |
|
{ |
|
m_target = target; |
|
m_rate = MAX( 0.1, fabs(deltaValue / deltaTime) ); |
|
} |
|
else |
|
{ |
|
if ( target != m_current ) |
|
{ |
|
m_forceupdate = true; |
|
} |
|
|
|
SetValue( target ); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Instantaneously set the value of this ramp |
|
// Input : value - new value |
|
//----------------------------------------------------------------------------- |
|
void CSoundEnvelope::SetValue( float value ) |
|
{ |
|
if ( m_target != value ) |
|
{ |
|
m_forceupdate = true; |
|
} |
|
|
|
m_current = m_target = value; |
|
m_rate = 0; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Check to see if I need to update this envelope |
|
// Output : Returns true if this envelope is changing |
|
//----------------------------------------------------------------------------- |
|
bool CSoundEnvelope::ShouldUpdate( void ) |
|
{ |
|
if ( m_forceupdate ) |
|
{ |
|
m_forceupdate = false; |
|
return true; |
|
} |
|
|
|
if ( m_current != m_target ) |
|
{ |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Update the envelope for the current frame time |
|
// Input : time - amount of time that has passed |
|
//----------------------------------------------------------------------------- |
|
void CSoundEnvelope::Update( float deltaTime ) |
|
{ |
|
m_current = Approach( m_target, m_current, m_rate * deltaTime ); |
|
} |
|
|
|
class CCopyRecipientFilter : public IRecipientFilter |
|
{ |
|
public: |
|
DECLARE_SIMPLE_DATADESC(); |
|
|
|
CCopyRecipientFilter() : m_Flags(0) {} |
|
|
|
void Init( IRecipientFilter *pSrc ) |
|
{ |
|
m_Flags = FLAG_ACTIVE; |
|
if ( pSrc->IsReliable() ) |
|
{ |
|
m_Flags |= FLAG_RELIABLE; |
|
} |
|
|
|
if ( pSrc->IsInitMessage() ) |
|
{ |
|
m_Flags |= FLAG_INIT_MESSAGE; |
|
} |
|
|
|
for ( int i = 0; i < pSrc->GetRecipientCount(); i++ ) |
|
{ |
|
int index = pSrc->GetRecipientIndex( i ); |
|
|
|
if ( index >= 0 ) |
|
m_Recipients.AddToTail( index ); |
|
} |
|
} |
|
|
|
bool IsActive() const |
|
{ |
|
return (m_Flags & FLAG_ACTIVE) != 0; |
|
} |
|
|
|
virtual bool IsReliable( void ) const |
|
{ |
|
return (m_Flags & FLAG_RELIABLE) != 0; |
|
} |
|
|
|
virtual int GetRecipientCount( void ) const |
|
{ |
|
return m_Recipients.Count(); |
|
} |
|
|
|
virtual int GetRecipientIndex( int slot ) const |
|
{ |
|
return m_Recipients[ slot ]; |
|
} |
|
|
|
virtual bool IsInitMessage( void ) const |
|
{ |
|
return (m_Flags & FLAG_INIT_MESSAGE) != 0; |
|
} |
|
|
|
virtual bool AddRecipient( CBasePlayer *player ) |
|
{ |
|
Assert( player ); |
|
|
|
int index = player->entindex(); |
|
|
|
if ( index < 0 ) |
|
return false; |
|
|
|
// Already in list |
|
if ( m_Recipients.Find( index ) != m_Recipients.InvalidIndex() ) |
|
return false; |
|
|
|
m_Recipients.AddToTail( index ); |
|
return true; |
|
} |
|
|
|
private: |
|
enum |
|
{ |
|
FLAG_ACTIVE = 0x1, |
|
FLAG_RELIABLE = 0x2, |
|
FLAG_INIT_MESSAGE = 0x4, |
|
}; |
|
|
|
int m_Flags; |
|
CUtlVector< int > m_Recipients; |
|
}; |
|
|
|
BEGIN_SIMPLE_DATADESC( CCopyRecipientFilter ) |
|
|
|
DEFINE_FIELD( m_Flags, FIELD_INTEGER ), |
|
DEFINE_UTLVECTOR( m_Recipients, FIELD_INTEGER ), |
|
|
|
END_DATADESC() |
|
|
|
|
|
#include "tier0/memdbgoff.h" |
|
// This is the a basic sound controller, a "patch" |
|
// It has envelopes for pitch and volume and can manage state changes to those |
|
class CSoundPatch |
|
{ |
|
public: |
|
DECLARE_SIMPLE_DATADESC(); |
|
|
|
static int g_SoundPatchCount; |
|
CSoundPatch() |
|
{ |
|
g_SoundPatchCount++; |
|
m_iszSoundName = NULL_STRING; |
|
m_iszSoundScriptName = NULL_STRING; |
|
m_flCloseCaptionDuration = soundpatch_captionlength.GetFloat(); |
|
} |
|
~CSoundPatch() |
|
{ |
|
g_SoundPatchCount--; |
|
} |
|
|
|
void Init( IRecipientFilter *pFilter, CBaseEntity *pEnt, int channel, const char *pSoundName, |
|
soundlevel_t iSoundLevel ); |
|
void ChangePitch( float pitchTarget, float deltaTime ); |
|
void ChangeVolume( float volumeTarget, float deltaTime ); |
|
void FadeOut( float deltaTime, bool destroyOnFadeout ); |
|
float GetPitch( void ); |
|
float GetVolume( void ); |
|
string_t GetName() { return m_iszSoundName; }; |
|
string_t GetScriptName() { return m_iszSoundScriptName; } |
|
// UNDONE: Don't call this, use the controller to shut down |
|
void Shutdown( void ); |
|
bool Update( float time, float deltaTime ); |
|
void Reset( void ); |
|
void StartSound( float flStartTime = 0 ); |
|
void ResumeSound( void ); |
|
int IsPlaying( void ) { return m_isPlaying; } |
|
void AddPlayerPost( CBasePlayer *pPlayer ); |
|
void SetCloseCaptionDuration( float flDuration ) { m_flCloseCaptionDuration = flDuration; } |
|
|
|
void SetBaseFlags( int iFlags ) { m_baseFlags = iFlags; } |
|
|
|
// Returns the ent index |
|
int EntIndex() const; |
|
|
|
private: |
|
// SoundPatches take volumes between 0 & 1, and use that to multiply the sounds.txt specified volume. |
|
// This function is an internal method of accessing the real volume passed into the engine (i.e. post multiply) |
|
float GetVolumeForEngine( void ); |
|
|
|
private: |
|
CSoundEnvelope m_pitch; |
|
CSoundEnvelope m_volume; |
|
|
|
soundlevel_t m_soundlevel; |
|
float m_shutdownTime; |
|
float m_flLastTime; |
|
string_t m_iszSoundName; |
|
string_t m_iszSoundScriptName; |
|
EHANDLE m_hEnt; |
|
int m_entityChannel; |
|
int m_flags; |
|
int m_baseFlags; |
|
int m_isPlaying; |
|
float m_flScriptVolume; // Volume for this sound in sounds.txt |
|
CCopyRecipientFilter m_Filter; |
|
|
|
float m_flCloseCaptionDuration; |
|
|
|
#ifdef _DEBUG |
|
// Used to get the classname of the entity associated with the sound |
|
string_t m_iszClassName; |
|
#endif |
|
|
|
DECLARE_FIXEDSIZE_ALLOCATOR(CSoundPatch); |
|
}; |
|
#include "tier0/memdbgon.h" |
|
|
|
int CSoundPatch::g_SoundPatchCount = 0; |
|
|
|
CON_COMMAND( report_soundpatch, "reports sound patch count" ) |
|
{ |
|
#ifndef CLIENT_DLL |
|
if ( !UTIL_IsCommandIssuedByServerAdmin() ) |
|
return; |
|
#endif |
|
|
|
Msg("Current sound patches: %d\n", CSoundPatch::g_SoundPatchCount ); |
|
} |
|
DEFINE_FIXEDSIZE_ALLOCATOR( CSoundPatch, 64, CUtlMemoryPool::GROW_FAST ); |
|
|
|
BEGIN_SIMPLE_DATADESC( CSoundPatch ) |
|
|
|
DEFINE_EMBEDDED( m_pitch ), |
|
DEFINE_EMBEDDED( m_volume ), |
|
DEFINE_FIELD( m_soundlevel, FIELD_INTEGER ), |
|
DEFINE_FIELD( m_shutdownTime, FIELD_TIME ), |
|
DEFINE_FIELD( m_flLastTime, FIELD_TIME ), |
|
DEFINE_FIELD( m_iszSoundName, FIELD_STRING ), |
|
DEFINE_FIELD( m_iszSoundScriptName, FIELD_STRING ), |
|
DEFINE_FIELD( m_hEnt, FIELD_EHANDLE ), |
|
DEFINE_FIELD( m_entityChannel, FIELD_INTEGER ), |
|
DEFINE_FIELD( m_flags, FIELD_INTEGER ), |
|
DEFINE_FIELD( m_baseFlags, FIELD_INTEGER ), |
|
DEFINE_FIELD( m_isPlaying, FIELD_INTEGER ), |
|
DEFINE_FIELD( m_flScriptVolume, FIELD_FLOAT ), |
|
DEFINE_EMBEDDED( m_Filter ), |
|
DEFINE_FIELD( m_flCloseCaptionDuration, FIELD_FLOAT ), |
|
|
|
// Not saved, it's debug only |
|
// DEFINE_FIELD( m_iszClassName, FIELD_STRING ), |
|
|
|
END_DATADESC() |
|
|
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Setup the patch |
|
// Input : nEntIndex - index of the edict that owns the sound channel |
|
// channel - This is a sound channel (CHAN_ITEM, CHAN_STATIC) |
|
// *pSoundName - sound script string name |
|
// attenuation - attenuation of this sound (not animated) |
|
//----------------------------------------------------------------------------- |
|
void CSoundPatch::Init( IRecipientFilter *pFilter, CBaseEntity *pEnt, int channel, const char *pSoundName, |
|
soundlevel_t soundlevel ) |
|
{ |
|
m_hEnt = pEnt; |
|
m_entityChannel = channel; |
|
// Get the volume from the script |
|
CSoundParameters params; |
|
if ( !Q_stristr( pSoundName, ".wav" ) && !Q_stristr( pSoundName, ".mp3" ) && |
|
CBaseEntity::GetParametersForSound( pSoundName, params, NULL ) ) |
|
{ |
|
m_flScriptVolume = params.volume; |
|
// This has to be the actual .wav because rndwave would cause a bunch of new .wavs to play... bad... |
|
// e.g., when you pitch shift it would start a different wav instead. |
|
|
|
m_iszSoundScriptName = AllocPooledString( pSoundName ); |
|
|
|
pSoundName = params.soundname; |
|
m_soundlevel = params.soundlevel; |
|
|
|
m_entityChannel = params.channel; |
|
} |
|
else |
|
{ |
|
|
|
m_iszSoundScriptName = AllocPooledString( pSoundName ); |
|
|
|
m_flScriptVolume = 1.0; |
|
m_soundlevel = soundlevel; |
|
} |
|
|
|
m_iszSoundName = AllocPooledString( pSoundName ); |
|
m_volume.SetValue( 0 ); |
|
m_pitch.SetValue( 0 ); |
|
m_isPlaying = false; |
|
m_shutdownTime = 0; |
|
m_flLastTime = 0; |
|
m_Filter.Init( pFilter ); |
|
m_baseFlags = 0; |
|
|
|
#ifdef _DEBUG |
|
if ( pEnt ) |
|
{ |
|
m_iszClassName = AllocPooledString( pEnt->GetClassname() ); |
|
} |
|
#endif |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Ramps the pitch to a new value |
|
// Input : pitchTarget - new value |
|
// deltaTime - seconds to reach the value |
|
//----------------------------------------------------------------------------- |
|
void CSoundPatch::ChangePitch( float pitchTarget, float deltaTime ) |
|
{ |
|
m_flags |= SND_CHANGE_PITCH; |
|
m_pitch.SetTarget( pitchTarget, deltaTime ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Ramps the volume to a new value |
|
// Input : volumeTarget - new volume |
|
// deltaTime - seconds to reach the new volume |
|
//----------------------------------------------------------------------------- |
|
void CSoundPatch::ChangeVolume( float volumeTarget, float deltaTime ) |
|
{ |
|
m_flags |= SND_CHANGE_VOL; |
|
if ( volumeTarget > 1.0 ) |
|
volumeTarget = 1.0; |
|
m_volume.SetTarget( volumeTarget, deltaTime ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Fade volume to zero AND SHUT DOWN THIS SOUND |
|
// Input : deltaTime - seconds before done/shutdown |
|
//----------------------------------------------------------------------------- |
|
void CSoundPatch::FadeOut( float deltaTime, bool destroyOnFadeout ) |
|
{ |
|
ChangeVolume( 0, deltaTime ); |
|
if ( !destroyOnFadeout ) |
|
{ |
|
m_shutdownTime = g_pEffects->Time() + deltaTime; |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Get the sound's current pitch |
|
//----------------------------------------------------------------------------- |
|
float CSoundPatch::GetPitch( void ) |
|
{ |
|
return m_pitch.Value(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Get the sound's current volume |
|
//----------------------------------------------------------------------------- |
|
float CSoundPatch::GetVolume( void ) |
|
{ |
|
return m_volume.Value(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Returns the ent index |
|
//----------------------------------------------------------------------------- |
|
inline int CSoundPatch::EntIndex() const |
|
{ |
|
Assert( !m_hEnt.IsValid() || m_hEnt.Get() ); |
|
return m_hEnt.Get() ? m_hEnt->entindex() : -1; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: SoundPatches take volumes between 0 & 1, and use that to multiply the sounds.txt specified volume. |
|
// This function is an internal method of accessing the real volume passed into the engine (i.e. post multiply) |
|
// Output : float |
|
//----------------------------------------------------------------------------- |
|
float CSoundPatch::GetVolumeForEngine( void ) |
|
{ |
|
return ( m_flScriptVolume * m_volume.Value() ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Stop the sound |
|
//----------------------------------------------------------------------------- |
|
void CSoundPatch::Shutdown( void ) |
|
{ |
|
// Msg( "Removing sound %s\n", m_pszSoundName ); |
|
if ( m_isPlaying ) |
|
{ |
|
int entIndex = EntIndex(); |
|
Assert( entIndex >= 0 ); |
|
// BUGBUG: Don't crash in release mode |
|
if ( entIndex >= 0 ) |
|
{ |
|
CBaseEntity::StopSound( entIndex, m_entityChannel, STRING( m_iszSoundName ) ); |
|
} |
|
m_isPlaying = false; |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Update all envelopes and send appropriate data to the client |
|
// Input : time - new global clock |
|
// deltaTime - amount of time that has passed |
|
// Output : Returns true on success, false on failure. |
|
//----------------------------------------------------------------------------- |
|
bool CSoundPatch::Update( float time, float deltaTime ) |
|
{ |
|
VPROF( "CSoundPatch::Update" ); |
|
if ( m_shutdownTime && time > m_shutdownTime ) |
|
{ |
|
Shutdown(); |
|
return false; |
|
} |
|
|
|
if ( EntIndex() < 0 ) |
|
{ |
|
// FIXME: The pointer to this soundpatch is probably leaked since no entity is around to clean it up (ywb) |
|
DevWarning( "CSoundPatch::Update: Removing CSoundPatch (%s) with NULL EHandle\n", STRING(m_iszSoundName) ); |
|
return false; |
|
} |
|
|
|
if ( m_pitch.ShouldUpdate() ) |
|
{ |
|
m_pitch.Update( deltaTime ); |
|
m_flags |= SND_CHANGE_PITCH; |
|
} |
|
else |
|
{ |
|
m_flags &= ~SND_CHANGE_PITCH; |
|
} |
|
|
|
if ( m_volume.ShouldUpdate() ) |
|
{ |
|
m_volume.Update( deltaTime ); |
|
m_flags |= SND_CHANGE_VOL; |
|
} |
|
else |
|
{ |
|
m_flags &= ~SND_CHANGE_VOL; |
|
} |
|
|
|
if ( m_flags && m_Filter.IsActive() ) |
|
{ |
|
// SoundPatches take volumes between 0 & 1, and use that to multiply the sounds.txt specified volume. |
|
// Because of this, we need to always set the SND_CHANGE_VOL flag when we emit sound, or it'll use the scriptfile's instead. |
|
m_flags |= SND_CHANGE_VOL; |
|
|
|
EmitSound_t ep; |
|
ep.m_nChannel = m_entityChannel; |
|
ep.m_pSoundName = STRING(m_iszSoundName); |
|
ep.m_flVolume = GetVolumeForEngine(); |
|
ep.m_SoundLevel = m_soundlevel; |
|
ep.m_nFlags = m_flags; |
|
ep.m_nPitch = (int)m_pitch.Value(); |
|
|
|
CBaseEntity::EmitSound( m_Filter, EntIndex(), ep ); |
|
|
|
m_flags = 0; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Sound is going to start playing again, clear any shutdown time |
|
//----------------------------------------------------------------------------- |
|
void CSoundPatch::Reset( void ) |
|
{ |
|
m_shutdownTime = 0; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Start playing the sound - send updates to the client |
|
//----------------------------------------------------------------------------- |
|
void CSoundPatch::StartSound( float flStartTime ) |
|
{ |
|
// Msg( "Start sound %s\n", m_pszSoundName ); |
|
m_flags = 0; |
|
if ( m_Filter.IsActive() ) |
|
{ |
|
EmitSound_t ep; |
|
ep.m_nChannel = m_entityChannel; |
|
ep.m_pSoundName = STRING(m_iszSoundName); |
|
ep.m_flVolume = GetVolumeForEngine(); |
|
ep.m_SoundLevel = m_soundlevel; |
|
ep.m_nFlags = (SND_CHANGE_VOL | m_baseFlags); |
|
ep.m_nPitch = (int)m_pitch.Value(); |
|
ep.m_bEmitCloseCaption = false; |
|
|
|
if ( flStartTime ) |
|
{ |
|
ep.m_flSoundTime = flStartTime; |
|
} |
|
|
|
CBaseEntity::EmitSound( m_Filter, EntIndex(), ep ); |
|
CBaseEntity::EmitCloseCaption( m_Filter, EntIndex(), STRING( m_iszSoundScriptName ), ep.m_UtlVecSoundOrigin, m_flCloseCaptionDuration, true ); |
|
} |
|
m_isPlaying = true; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: resumes playing the sound on restore |
|
//----------------------------------------------------------------------------- |
|
void CSoundPatch::ResumeSound( void ) |
|
{ |
|
if ( IsPlaying() && m_Filter.IsActive() ) |
|
{ |
|
if ( EntIndex() >= 0 ) |
|
{ |
|
EmitSound_t ep; |
|
ep.m_nChannel = m_entityChannel; |
|
ep.m_pSoundName = STRING(m_iszSoundName); |
|
ep.m_flVolume = GetVolumeForEngine(); |
|
ep.m_SoundLevel = m_soundlevel; |
|
ep.m_nFlags = (SND_CHANGE_VOL | SND_CHANGE_PITCH | m_baseFlags); |
|
ep.m_nPitch = (int)m_pitch.Value(); |
|
|
|
CBaseEntity::EmitSound( m_Filter, EntIndex(), ep ); |
|
} |
|
else |
|
{ |
|
// FIXME: Lost the entity on restore. It might have been suppressed by the save/restore system. |
|
// This will probably leak the sound patch since there's no one to delete it, but the next |
|
// call to CSoundPatch::Update should at least remove it from the list of sound patches. |
|
DevWarning( "CSoundPatch::ResumeSound: Lost EHAndle on restore - destroy the sound patch in your entity's StopLoopingSounds! (%s)\n", STRING( m_iszSoundName ) ); |
|
} |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: A new player's entered the game. See if we need to restart our sound. |
|
//----------------------------------------------------------------------------- |
|
void CSoundPatch::AddPlayerPost( CBasePlayer *pPlayer ) |
|
{ |
|
if ( m_Filter.IsActive() && m_Filter.AddRecipient(pPlayer) ) |
|
{ |
|
// Alrighty, he's new. We need to restart our sound just to him. |
|
// Create a new filter just to him. |
|
CSingleUserRecipientFilter filter( pPlayer ); |
|
|
|
EmitSound_t ep; |
|
ep.m_nChannel = m_entityChannel; |
|
ep.m_pSoundName = STRING(m_iszSoundName); |
|
ep.m_flVolume = GetVolumeForEngine(); |
|
ep.m_SoundLevel = m_soundlevel; |
|
ep.m_nFlags = (SND_CHANGE_VOL | m_baseFlags); |
|
ep.m_nPitch = (int)m_pitch.Value(); |
|
|
|
CBaseEntity::EmitSound( filter, EntIndex(), ep ); |
|
} |
|
} |
|
|
|
// This is an entry in the command queue. It's used to queue up various pitch and volume changes |
|
// so you can define an envelope without writing timing code in an entity. Existing queued commands |
|
// can be deleted later if the envelope changes dynamically. |
|
#include "tier0/memdbgoff.h" |
|
struct SoundCommand_t |
|
{ |
|
SoundCommand_t( void ) { memset( this, 0, sizeof(*this) ); } |
|
SoundCommand_t( CSoundPatch *pSound, float executeTime, soundcommands_t command, float deltaTime, float value ) : m_pPatch(pSound), m_time(executeTime), m_deltaTime(deltaTime), m_command(command), m_value(value) {} |
|
|
|
CSoundPatch *m_pPatch; |
|
float m_time; |
|
float m_deltaTime; |
|
soundcommands_t m_command; |
|
float m_value; |
|
|
|
SoundCommand_t *m_pNext; |
|
|
|
DECLARE_SIMPLE_DATADESC(); |
|
DECLARE_FIXEDSIZE_ALLOCATOR(SoundCommand_t); |
|
}; |
|
#include "tier0/memdbgon.h" |
|
|
|
DEFINE_FIXEDSIZE_ALLOCATOR( SoundCommand_t, 32, CUtlMemoryPool::GROW_FAST ); |
|
|
|
|
|
BEGIN_SIMPLE_DATADESC( SoundCommand_t ) |
|
|
|
// NOTE: This doesn't need to be saved, sound commands are saved right after the patch |
|
// they are associated with |
|
// DEFINE_FIELD( m_pPatch, FIELD_????? ) |
|
DEFINE_FIELD( m_time, FIELD_TIME ), |
|
DEFINE_FIELD( m_deltaTime, FIELD_FLOAT ), |
|
DEFINE_FIELD( m_command, FIELD_INTEGER ), |
|
DEFINE_FIELD( m_value, FIELD_FLOAT ), |
|
// DEFINE_FIELD( m_pNext, FIELD_????? ) |
|
|
|
END_DATADESC() |
|
|
|
typedef SoundCommand_t *SOUNDCOMMANDPTR; |
|
|
|
bool SoundCommandLessFunc( const SOUNDCOMMANDPTR &lhs, const SOUNDCOMMANDPTR &rhs ) |
|
{ |
|
// NOTE: A greater time means "less" priority |
|
return ( lhs->m_time > rhs->m_time ); |
|
} |
|
|
|
|
|
// This implements the sound controller |
|
class CSoundControllerImp : public CSoundEnvelopeController, public CAutoGameSystemPerFrame |
|
{ |
|
//----------------------------------------------------------------------------- |
|
// internal functions, private to this file |
|
//----------------------------------------------------------------------------- |
|
public: |
|
CSoundControllerImp( void ) : CAutoGameSystemPerFrame( "CSoundControllerImp" ) |
|
{ |
|
m_commandList.SetLessFunc( SoundCommandLessFunc ); |
|
} |
|
|
|
void ProcessCommand( SoundCommand_t *pCmd ); |
|
void RemoveFromList( CSoundPatch *pSound ); |
|
void SaveSoundPatch( CSoundPatch *pSound, ISave *pSave ); |
|
void RestoreSoundPatch( CSoundPatch **ppSound, IRestore *pRestore ); |
|
|
|
virtual void OnRestore(); |
|
|
|
//----------------------------------------------------------------------------- |
|
// external interface functions (from CSoundEnvelopeController) |
|
//----------------------------------------------------------------------------- |
|
public: |
|
|
|
// Start this sound playing, or reset if already playing with new volume/pitch |
|
void Play( CSoundPatch *pSound, float volume, float pitch, float flStartTime = 0 ); |
|
void CommandAdd( CSoundPatch *pSound, float executeDeltaTime, soundcommands_t command, float commandTime, float commandValue ); |
|
|
|
void SystemReset( void ); |
|
void SystemUpdate( void ); |
|
void CommandClear( CSoundPatch *pSound ); |
|
void Shutdown( CSoundPatch *pSound ); |
|
|
|
CSoundPatch *SoundCreate( IRecipientFilter& filter, int nEntIndex, const char *pSoundName ); |
|
CSoundPatch *SoundCreate( IRecipientFilter& filter, int nEntIndex, int channel, const char *pSoundName, |
|
float attenuation ); |
|
CSoundPatch *SoundCreate( IRecipientFilter& filter, int nEntIndex, int channel, const char *pSoundName, |
|
soundlevel_t soundlevel ); |
|
CSoundPatch *SoundCreate( IRecipientFilter& filter, int nEntIndex, const EmitSound_t &es ); |
|
void SoundDestroy( CSoundPatch *pSound ); |
|
void SoundChangePitch( CSoundPatch *pSound, float pitchTarget, float deltaTime ); |
|
void SoundChangeVolume( CSoundPatch *pSound, float volumeTarget, float deltaTime ); |
|
void SoundFadeOut( CSoundPatch *pSound, float deltaTime, bool destroyOnFadeout ); |
|
float SoundGetPitch( CSoundPatch *pSound ); |
|
float SoundGetVolume( CSoundPatch *pSound ); |
|
string_t SoundGetName( CSoundPatch *pSound ) { return pSound->GetName(); } |
|
void SoundSetCloseCaptionDuration( CSoundPatch *pSound, float flDuration ) { pSound->SetCloseCaptionDuration(flDuration); } |
|
|
|
float SoundPlayEnvelope( CSoundPatch *pSound, soundcommands_t soundCommand, envelopePoint_t *points, int numPoints ); |
|
float SoundPlayEnvelope( CSoundPatch *pSound, soundcommands_t soundCommand, envelopeDescription_t *envelope ); |
|
|
|
void CheckLoopingSoundsForPlayer( CBasePlayer *pPlayer ); |
|
|
|
// Inserts the command into the list, sorted by time |
|
void CommandInsert( SoundCommand_t *pCommand ); |
|
|
|
#ifdef CLIENT_DLL |
|
// CAutoClientSystem |
|
virtual void Update( float frametime ) |
|
{ |
|
SystemUpdate(); |
|
} |
|
#else |
|
virtual void PreClientUpdate() |
|
{ |
|
SystemUpdate(); |
|
} |
|
#endif |
|
|
|
virtual void LevelShutdownPreEntity() |
|
{ |
|
SystemReset(); |
|
} |
|
|
|
private: |
|
CUtlVector<CSoundPatch *> m_soundList; |
|
CUtlPriorityQueue<SoundCommand_t *> m_commandList; |
|
float m_flLastTime; |
|
}; |
|
|
|
// Execute a command from the list |
|
// currently only 3 commands |
|
// UNDONE: Add start command? |
|
void CSoundControllerImp::ProcessCommand( SoundCommand_t *pCmd ) |
|
{ |
|
switch( pCmd->m_command ) |
|
{ |
|
case SOUNDCTRL_CHANGE_VOLUME: |
|
pCmd->m_pPatch->ChangeVolume( pCmd->m_value, pCmd->m_deltaTime ); |
|
break; |
|
|
|
case SOUNDCTRL_CHANGE_PITCH: |
|
pCmd->m_pPatch->ChangePitch( pCmd->m_value, pCmd->m_deltaTime ); |
|
break; |
|
|
|
case SOUNDCTRL_STOP: |
|
pCmd->m_pPatch->Shutdown(); |
|
break; |
|
|
|
case SOUNDCTRL_DESTROY: |
|
RemoveFromList( pCmd->m_pPatch ); |
|
delete pCmd->m_pPatch; |
|
pCmd->m_pPatch = NULL; |
|
break; |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Remove this sound from the sound list & shutdown (not in external interface) |
|
// Input : *pSound - patch to remove |
|
//----------------------------------------------------------------------------- |
|
void CSoundControllerImp::RemoveFromList( CSoundPatch *pSound ) |
|
{ |
|
m_soundList.FindAndRemove( pSound ); |
|
pSound->Shutdown(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Start this sound playing, or reset if already playing with new volume/pitch |
|
//----------------------------------------------------------------------------- |
|
void CSoundControllerImp::Play( CSoundPatch *pSound, float volume, float pitch, float flStartTime ) |
|
{ |
|
// reset the vars |
|
pSound->Reset(); |
|
|
|
pSound->ChangeVolume( volume, 0 ); |
|
pSound->ChangePitch( pitch, 0 ); |
|
|
|
if ( pSound->IsPlaying() ) |
|
{ |
|
// remove any previous commands in the queue |
|
CommandClear( pSound ); |
|
} |
|
else |
|
{ |
|
m_soundList.AddToTail( pSound ); |
|
pSound->StartSound( flStartTime ); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Inserts the command into the list, sorted by time |
|
//----------------------------------------------------------------------------- |
|
void CSoundControllerImp::CommandInsert( SoundCommand_t *pCommand ) |
|
{ |
|
m_commandList.Insert( pCommand ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: puts a command into the queue |
|
// Input : *pSound - patch this command affects |
|
// executeDeltaTime - relative time to execute this command |
|
// command - command to execute (SOUNDCTRL_*) |
|
// commandTime - commands have 2 parameters, a time and a value |
|
// value - |
|
// Output : void |
|
//----------------------------------------------------------------------------- |
|
void CSoundControllerImp::CommandAdd( CSoundPatch *pSound, float executeDeltaTime, soundcommands_t command, float commandTime, float commandValue ) |
|
{ |
|
SoundCommand_t *pCommand = new SoundCommand_t( pSound, g_pEffects->Time() + executeDeltaTime, command, commandTime, commandValue ); |
|
CommandInsert( pCommand ); |
|
} |
|
|
|
// Reset the whole system (level change, etc.) |
|
void CSoundControllerImp::SystemReset( void ) |
|
{ |
|
for ( int i = m_soundList.Count()-1; i >=0; i-- ) |
|
{ |
|
CSoundPatch *pNode = m_soundList[i]; |
|
|
|
// shutdown all active sounds |
|
pNode->Shutdown(); |
|
} |
|
|
|
// clear the list |
|
m_soundList.Purge(); |
|
|
|
// clear the command queue |
|
m_commandList.RemoveAll(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Update the active sounds, dequeue any events and move the ramps |
|
//----------------------------------------------------------------------------- |
|
void CSoundControllerImp::SystemUpdate( void ) |
|
{ |
|
VPROF( "CSoundControllerImp::SystemUpdate" ); |
|
float time = g_pEffects->Time(); |
|
float deltaTime = time - m_flLastTime; |
|
|
|
// handle clock resets |
|
if ( deltaTime < 0 ) |
|
deltaTime = 0; |
|
|
|
m_flLastTime = time; |
|
|
|
{ |
|
VPROF( "CSoundControllerImp::SystemUpdate:processcommandlist" ); |
|
while ( m_commandList.Count() ) |
|
{ |
|
SoundCommand_t *pCmd = m_commandList.ElementAtHead(); |
|
// Commands are sorted by time. |
|
// process any that should occur by the current time |
|
if ( time >= pCmd->m_time ) |
|
{ |
|
m_commandList.RemoveAtHead(); |
|
ProcessCommand( pCmd ); |
|
delete pCmd; |
|
} |
|
else |
|
{ |
|
break; |
|
} |
|
} |
|
} |
|
|
|
// NOTE: Because this loop goes from the end to the beginning |
|
// we can fast remove inside it without breaking the indexing |
|
{ |
|
VPROF( "CSoundControllerImp::SystemUpdate:removesounds" ); |
|
for ( int i = m_soundList.Count()-1; i >=0; i-- ) |
|
{ |
|
CSoundPatch *pNode = m_soundList[i]; |
|
if ( !pNode->Update( time, deltaTime ) ) |
|
{ |
|
pNode->Reset(); |
|
m_soundList.FastRemove( i ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
// Remove any envelope commands from the list (dynamically changing envelope) |
|
void CSoundControllerImp::CommandClear( CSoundPatch *pSound ) |
|
{ |
|
for ( int i = m_commandList.Count()-1; i >= 0; i-- ) |
|
{ |
|
SoundCommand_t *pCmd = m_commandList.Element( i ); |
|
if ( pCmd->m_pPatch == pSound ) |
|
{ |
|
m_commandList.RemoveAt(i); |
|
delete pCmd; |
|
} |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Saves the sound patch + associated commands |
|
//----------------------------------------------------------------------------- |
|
void CSoundControllerImp::SaveSoundPatch( CSoundPatch *pSoundPatch, ISave *pSave ) |
|
{ |
|
int i; |
|
|
|
// Write out the sound patch |
|
pSave->StartBlock(); |
|
pSave->WriteAll( pSoundPatch ); |
|
pSave->EndBlock(); |
|
|
|
// Count the number of commands that refer to the sound patch |
|
int nCount = 0; |
|
for ( i = m_commandList.Count()-1; i >= 0; i-- ) |
|
{ |
|
SoundCommand_t *pCmd = m_commandList.Element( i ); |
|
if ( pCmd->m_pPatch == pSoundPatch ) |
|
{ |
|
nCount++; |
|
} |
|
} |
|
|
|
// Write out the number of commands, followed by each command itself |
|
pSave->StartBlock(); |
|
pSave->WriteInt( &nCount ); |
|
|
|
for ( i = m_commandList.Count()-1; i >= 0; i-- ) |
|
{ |
|
SoundCommand_t *pCmd = m_commandList.Element( i ); |
|
if ( pCmd->m_pPatch == pSoundPatch ) |
|
{ |
|
pSave->StartBlock(); |
|
pSave->WriteAll( pCmd ); |
|
pSave->EndBlock(); |
|
} |
|
} |
|
|
|
pSave->EndBlock(); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Restores the sound patch + associated commands |
|
//----------------------------------------------------------------------------- |
|
void CSoundControllerImp::RestoreSoundPatch( CSoundPatch **ppSoundPatch, IRestore *pRestore ) |
|
{ |
|
CSoundPatch *pPatch = new CSoundPatch; |
|
|
|
// read the sound patch data from the memory block |
|
pRestore->StartBlock(); |
|
bool bOk = ( pRestore->ReadAll( pPatch ) != 0 ); |
|
pRestore->EndBlock(); |
|
bOk = (bOk && pPatch->IsPlaying()) ? true : false; |
|
|
|
if (bOk) |
|
{ |
|
m_soundList.AddToTail( pPatch ); |
|
} |
|
|
|
// Count the number of commands that refer to the sound patch |
|
pRestore->StartBlock(); |
|
|
|
if ( bOk ) |
|
{ |
|
int nCount; |
|
pRestore->ReadInt( &nCount ); |
|
while ( --nCount >= 0 ) |
|
{ |
|
SoundCommand_t *pCommand = new SoundCommand_t; |
|
|
|
pRestore->StartBlock(); |
|
if ( pRestore->ReadAll( pCommand ) ) |
|
{ |
|
pCommand->m_pPatch = pPatch; |
|
CommandInsert( pCommand ); |
|
} |
|
|
|
pRestore->EndBlock(); |
|
} |
|
} |
|
|
|
pRestore->EndBlock(); |
|
*ppSoundPatch = pPatch; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: immediately stop playing this sound |
|
// Input : *pSound - Patch to shut down |
|
//----------------------------------------------------------------------------- |
|
void CSoundControllerImp::Shutdown( CSoundPatch *pSound ) |
|
{ |
|
if ( !pSound ) |
|
return; |
|
|
|
pSound->Shutdown(); |
|
CommandClear( pSound ); |
|
RemoveFromList( pSound ); |
|
} |
|
|
|
CSoundPatch *CSoundControllerImp::SoundCreate( IRecipientFilter& filter, int nEntIndex, const char *pSoundName ) |
|
{ |
|
#ifdef CLIENT_DLL |
|
if ( GameRules() ) |
|
{ |
|
pSoundName = GameRules()->TranslateEffectForVisionFilter( "sounds", pSoundName ); |
|
} |
|
#endif |
|
|
|
CSoundPatch *pSound = new CSoundPatch; |
|
|
|
// FIXME: This is done so we don't have to futz with the public interface |
|
EHANDLE hEnt = (nEntIndex != -1) ? g_pEntityList->GetNetworkableHandle( nEntIndex ) : NULL; |
|
pSound->Init( &filter, hEnt.Get(), CHAN_AUTO, pSoundName, SNDLVL_NORM ); |
|
|
|
return pSound; |
|
} |
|
|
|
CSoundPatch *CSoundControllerImp::SoundCreate( IRecipientFilter& filter, int nEntIndex, int channel, |
|
const char *pSoundName, float attenuation ) |
|
{ |
|
#ifdef CLIENT_DLL |
|
if ( GameRules() ) |
|
{ |
|
pSoundName = GameRules()->TranslateEffectForVisionFilter( "sounds", pSoundName ); |
|
} |
|
#endif |
|
|
|
CSoundPatch *pSound = new CSoundPatch; |
|
EHANDLE hEnt = (nEntIndex != -1) ? g_pEntityList->GetNetworkableHandle( nEntIndex ) : NULL; |
|
pSound->Init( &filter, hEnt.Get(), channel, pSoundName, ATTN_TO_SNDLVL( attenuation ) ); |
|
|
|
return pSound; |
|
} |
|
|
|
CSoundPatch *CSoundControllerImp::SoundCreate( IRecipientFilter& filter, int nEntIndex, int channel, |
|
const char *pSoundName, soundlevel_t soundlevel ) |
|
{ |
|
#ifdef CLIENT_DLL |
|
if ( GameRules() ) |
|
{ |
|
pSoundName = GameRules()->TranslateEffectForVisionFilter( "sounds", pSoundName ); |
|
} |
|
#endif |
|
|
|
CSoundPatch *pSound = new CSoundPatch; |
|
EHANDLE hEnt = (nEntIndex != -1) ? g_pEntityList->GetNetworkableHandle( nEntIndex ) : NULL; |
|
pSound->Init( &filter, hEnt.Get(), channel, pSoundName, soundlevel ); |
|
|
|
return pSound; |
|
} |
|
|
|
CSoundPatch *CSoundControllerImp::SoundCreate( IRecipientFilter& filter, int nEntIndex, const EmitSound_t &es ) |
|
{ |
|
CSoundPatch *pSound = new CSoundPatch; |
|
|
|
// FIXME: This is done so we don't have to futz with the public interface |
|
EHANDLE hEnt = (nEntIndex != -1) ? g_pEntityList->GetNetworkableHandle( nEntIndex ) : NULL; |
|
pSound->Init( &filter, hEnt.Get(), es.m_nChannel, es.m_pSoundName, es.m_SoundLevel ); |
|
pSound->ChangeVolume( es.m_flVolume, 0 ); |
|
pSound->ChangePitch( es.m_nPitch, 0 ); |
|
|
|
if ( es.m_nFlags & SND_SHOULDPAUSE ) |
|
{ |
|
pSound->SetBaseFlags( SND_SHOULDPAUSE ); |
|
} |
|
|
|
return pSound; |
|
} |
|
|
|
void CSoundControllerImp::SoundDestroy( CSoundPatch *pSound ) |
|
{ |
|
if ( !pSound ) |
|
return; |
|
|
|
Shutdown( pSound ); |
|
delete pSound; |
|
} |
|
|
|
void CSoundControllerImp::SoundChangePitch( CSoundPatch *pSound, float pitchTarget, float deltaTime ) |
|
{ |
|
pSound->ChangePitch( pitchTarget, deltaTime ); |
|
} |
|
|
|
|
|
void CSoundControllerImp::SoundChangeVolume( CSoundPatch *pSound, float volumeTarget, float deltaTime ) |
|
{ |
|
pSound->ChangeVolume( volumeTarget, deltaTime ); |
|
} |
|
|
|
float CSoundControllerImp::SoundGetPitch( CSoundPatch *pSound ) |
|
{ |
|
return pSound->GetPitch(); |
|
} |
|
|
|
float CSoundControllerImp::SoundGetVolume( CSoundPatch *pSound ) |
|
{ |
|
return pSound->GetVolume(); |
|
} |
|
|
|
void CSoundControllerImp::SoundFadeOut( CSoundPatch *pSound, float deltaTime, bool destroyOnFadeout ) |
|
{ |
|
if ( destroyOnFadeout && (deltaTime == 0.0f) ) |
|
{ |
|
SoundDestroy( pSound ); |
|
return; |
|
} |
|
|
|
pSound->FadeOut( deltaTime, destroyOnFadeout ); |
|
if ( destroyOnFadeout ) |
|
{ |
|
CommandAdd( pSound, deltaTime, SOUNDCTRL_DESTROY, 0.0f, 0.0f ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Queue a list of envelope points into a sound patch's event list |
|
// Input : *pSound - The sound patch to be operated on |
|
// soundCommand - Type of operation the envelope describes |
|
// *points - List of enevelope points |
|
// numPoints - Number of points provided |
|
// Output : float - Returns the total duration of the envelope |
|
//----------------------------------------------------------------------------- |
|
float CSoundControllerImp::SoundPlayEnvelope( CSoundPatch *pSound, soundcommands_t soundCommand, envelopePoint_t *points, int numPoints ) |
|
{ |
|
float amplitude = 0.0f; |
|
float duration = 0.0f; |
|
float totalDuration = 0.0f; |
|
|
|
Assert( points ); |
|
|
|
// Clear out all previously acting commands |
|
CommandClear( pSound ); |
|
|
|
// Evaluate and queue all points |
|
for ( int i = 0; i < numPoints; i++ ) |
|
{ |
|
// See if we're keeping our last amplitude for this new point |
|
if ( ( points[i].amplitudeMin != -1.0f ) || ( points[i].amplitudeMax != -1.0f ) ) |
|
{ |
|
amplitude = random->RandomFloat( points[i].amplitudeMin, points[i].amplitudeMax ); |
|
} |
|
else if ( i == 0 ) |
|
{ |
|
// Can't do this on the first entry |
|
Msg( "Invalid starting amplitude value in envelope! (Cannot be -1)\n" ); |
|
} |
|
|
|
// See if we're keeping our last duration for this new point |
|
if ( ( points[i].durationMin != -1.0f ) || ( points[i].durationMax != -1.0f ) ) |
|
{ |
|
duration = random->RandomFloat( points[i].durationMin, points[i].durationMax ); |
|
//duration = points[i].durationMin; |
|
} |
|
else if ( i == 0 ) |
|
{ |
|
// Can't do this on the first entry |
|
Msg( "Invalid starting duration value in envelope! (Cannot be -1)\n" ); |
|
} |
|
|
|
// Queue the command |
|
CommandAdd( pSound, totalDuration, soundCommand, duration, amplitude ); |
|
|
|
// Tack this command's duration onto the running duration |
|
totalDuration += duration; |
|
} |
|
|
|
return totalDuration; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Queue a list of envelope points into a sound patch's event list |
|
// Input : *pSound - The sound patch to be operated on |
|
// soundCommand - Type of operation the envelope describes |
|
// *envelope - The envelope description to be queued |
|
// Output : float - Returns the total duration of the envelope |
|
//----------------------------------------------------------------------------- |
|
float CSoundControllerImp::SoundPlayEnvelope( CSoundPatch *pSound, soundcommands_t soundCommand, envelopeDescription_t *envelope ) |
|
{ |
|
return SoundPlayEnvelope( pSound, soundCommand, envelope->pPoints, envelope->nNumPoints ); |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Looping sounds are often started in entity spawn/activate functions. |
|
// In singleplayer, the player's not ready to receive sounds then, so restart |
|
// and SoundPatches that are active and have no receivers. |
|
//----------------------------------------------------------------------------- |
|
void CSoundControllerImp::CheckLoopingSoundsForPlayer( CBasePlayer *pPlayer ) |
|
{ |
|
for ( int i = m_soundList.Count()-1; i >=0; i-- ) |
|
{ |
|
CSoundPatch *pNode = m_soundList[i]; |
|
pNode->AddPlayerPost( pPlayer ); |
|
} |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Resumes saved soundpatches |
|
//----------------------------------------------------------------------------- |
|
void CSoundControllerImp::OnRestore() |
|
{ |
|
for ( int i = m_soundList.Count()-1; i >=0; i-- ) |
|
{ |
|
CSoundPatch *pNode = m_soundList[i]; |
|
if ( pNode && pNode->IsPlaying() ) |
|
{ |
|
pNode->ResumeSound(); |
|
} |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Singleton accessors |
|
//----------------------------------------------------------------------------- |
|
static CSoundControllerImp g_Controller; |
|
CSoundEnvelopeController &CSoundEnvelopeController::GetController( void ) |
|
{ |
|
return g_Controller; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Queues up sound patches to save/load |
|
//----------------------------------------------------------------------------- |
|
class CSoundPatchSaveRestoreOps : public CClassPtrSaveRestoreOps |
|
{ |
|
public: |
|
virtual void Save( const SaveRestoreFieldInfo_t &fieldInfo, ISave *pSave ) |
|
{ |
|
pSave->StartBlock(); |
|
|
|
int nSoundPatchCount = fieldInfo.pTypeDesc->fieldSize; |
|
CSoundPatch **ppSoundPatch = (CSoundPatch**)fieldInfo.pField; |
|
while ( --nSoundPatchCount >= 0 ) |
|
{ |
|
// Write out commands associated with this sound patch |
|
g_Controller.SaveSoundPatch( *ppSoundPatch, pSave ); |
|
++ppSoundPatch; |
|
} |
|
|
|
pSave->EndBlock(); |
|
} |
|
|
|
virtual void Restore( const SaveRestoreFieldInfo_t &fieldInfo, IRestore *pRestore ) |
|
{ |
|
pRestore->StartBlock(); |
|
|
|
int nSoundPatchCount = fieldInfo.pTypeDesc->fieldSize; |
|
CSoundPatch **ppSoundPatch = (CSoundPatch**)fieldInfo.pField; |
|
while ( --nSoundPatchCount >= 0 ) |
|
{ |
|
// Write out commands associated with this sound patch |
|
g_Controller.RestoreSoundPatch( ppSoundPatch, pRestore ); |
|
++ppSoundPatch; |
|
} |
|
|
|
pRestore->EndBlock(); |
|
} |
|
}; |
|
|
|
static CSoundPatchSaveRestoreOps s_SoundPatchSaveRestoreOps; |
|
ISaveRestoreOps *GetSoundSaveRestoreOps( ) |
|
{ |
|
return &s_SoundPatchSaveRestoreOps; |
|
}
|
|
|