H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-22 22:27:05 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
6920a3bd08
source-engine/soundemittersystem/soundemittersystembase.cpp

1663 lines
43 KiB
C++
Raw Normal View History

1
2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//===========================================================================//
#include <KeyValues.h>
#include "filesystem.h"
#include "utldict.h"
#include "interval.h"
#include "engine/IEngineSound.h"
#include "soundemittersystembase.h"
#include "utlbuffer.h"
#include "soundchars.h"
#include "vstdlib/random.h"
#include "checksum_crc.h"
#include "SoundEmitterSystem/isoundemittersystembase.h"
#include "ifilelist.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#define MANIFEST_FILE "scripts/game_sounds_manifest.txt"
#define GAME_SOUNDS_HEADER_BLOCK "scripts/game_sounds_header.txt"
static IFileSystem* filesystem = 0;
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CSoundEmitterSystemBase::CSoundEmitterSystemBase() :
m_nInitCount( 0 ),
m_uManifestPlusScriptChecksum( 0 )
{
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int CSoundEmitterSystemBase::First() const
{
return m_Sounds.FirstHandle();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : i -
// Output : int
//-----------------------------------------------------------------------------
int CSoundEmitterSystemBase::Next( int i ) const
{
return m_Sounds.NextHandle(i);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CSoundEmitterSystemBase::InvalidIndex() const
{
return m_Sounds.InvalidHandle();
}
//-----------------------------------------------------------------------------
//
// implementation of IUniformRandomStream
//
//-----------------------------------------------------------------------------
class CSoundEmitterUniformRandomStream : public IUniformRandomStream
{
public:
// Sets the seed of the random number generator
void SetSeed( int iSeed )
{
// Never call this from the client or game!
Assert(0);
}
// Generates random numbers
float RandomFloat( float flMinVal = 0.0f, float flMaxVal = 1.0f )
{
return ::RandomFloat( flMinVal, flMaxVal );
}
int RandomInt( int iMinVal, int iMaxVal )
{
return ::RandomInt( iMinVal, iMaxVal );
}
float RandomFloatExp( float flMinVal = 0.0f, float flMaxVal = 1.0f, float flExponent = 1.0f )
{
return ::RandomFloatExp( flMinVal, flMaxVal, flExponent );
}
};
static CSoundEmitterUniformRandomStream g_RandomStream;
IUniformRandomStream *randomStream = &g_RandomStream;
//-----------------------------------------------------------------------------
// Connect, disconnect
//-----------------------------------------------------------------------------
bool CSoundEmitterSystemBase::Connect( CreateInterfaceFn factory )
{
// If someone already connected us up, don't redo the connection
if ( NULL != filesystem )
{
return true;
}
filesystem = (IFileSystem *)factory( FILESYSTEM_INTERFACE_VERSION, NULL );
if( !filesystem )
{
Error( "The soundemittersystem system requires the filesystem to run!\n" );
return false;
}
return true;
}
void CSoundEmitterSystemBase::Disconnect()
{
filesystem = NULL;
}
//-----------------------------------------------------------------------------
// Query interface
//-----------------------------------------------------------------------------
void *CSoundEmitterSystemBase::QueryInterface( const char *pInterfaceName )
{
// Loading the engine DLL mounts *all* soundemitter interfaces
CreateInterfaceFn factory = Sys_GetFactoryThis(); // This silly construction is necessary
return factory( pInterfaceName, NULL ); // to prevent the LTCG compiler from crashing.
}
//-----------------------------------------------------------------------------
// Init, shutdown
//-----------------------------------------------------------------------------
InitReturnVal_t CSoundEmitterSystemBase::Init()
{
return INIT_OK;
}
void CSoundEmitterSystemBase::Shutdown()
{
}
//-----------------------------------------------------------------------------
// Purpose: Helper for checksuming script files and manifest to determine if soundname caches
// need to be blown away.
// Input : *crc -
// *filename -
// Output : static void
//-----------------------------------------------------------------------------
static void AccumulateFileNameAndTimestampIntoChecksum( CRC32_t *crc, char const *filename )
{
if ( IsX360() )
{
// this is an expensive i/o operation due to search path fall through
// 360 doesn't need or use the checksums
return;
}
long ft = filesystem->GetFileTime( filename, "GAME" );
CRC32_ProcessBuffer( crc, &ft, sizeof( ft ) );
CRC32_ProcessBuffer( crc, filename, Q_strlen( filename ) );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CSoundEmitterSystemBase::InternalModInit()
{
/*
if ( m_SoundKeyValues.Count() > 0 )
{
Shutdown();
}
*/
LoadGlobalActors();
m_uManifestPlusScriptChecksum = 0u;
CRC32_t crc;
CRC32_Init( &crc );
KeyValues *manifest = new KeyValues( MANIFEST_FILE );
if ( filesystem->LoadKeyValues( *manifest, IFileSystem::TYPE_SOUNDEMITTER, MANIFEST_FILE, "GAME" ) )
{
AccumulateFileNameAndTimestampIntoChecksum( &crc, MANIFEST_FILE );
for ( KeyValues *sub = manifest->GetFirstSubKey(); sub != NULL; sub = sub->GetNextKey() )
{
if ( !Q_stricmp( sub->GetName(), "precache_file" ) )
{
AccumulateFileNameAndTimestampIntoChecksum( &crc, sub->GetString() );
// Add and always precache
AddSoundsFromFile( sub->GetString(), false );
continue;
}
else if ( !Q_stricmp( sub->GetName(), "preload_file" ) )
{
AccumulateFileNameAndTimestampIntoChecksum( &crc, sub->GetString() );
// Add and always precache
AddSoundsFromFile( sub->GetString(), true );
continue;
}
else if ( !Q_stricmp( sub->GetName(), "faceposer_file" ) )
{
// do nothing for these files; they're only used for faceposer
continue;
}
Warning( "CSoundEmitterSystemBase::BaseInit: Manifest '%s' with bogus file type '%s', expecting 'declare_file' or 'precache_file'\n",
MANIFEST_FILE, sub->GetName() );
}
}
else
{
Error( "Unable to load manifest file '%s'\n", MANIFEST_FILE );
}
manifest->deleteThis();
CRC32_Final( &crc );
m_uManifestPlusScriptChecksum =( unsigned int )crc;
// Only print total once, on server
#if !defined( CLIENT_DLL ) && !defined( FACEPOSER )
DevMsg( 1, "CSoundEmitterSystem: Registered %i sounds\n", m_Sounds.Count() );
#endif
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CSoundEmitterSystemBase::ModInit()
{
++m_nInitCount;
if ( m_nInitCount > 1 )
{
return true;
}
return InternalModInit();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSoundEmitterSystemBase::InternalModShutdown()
{
int i;
m_SoundKeyValues.RemoveAll();
for ( UtlHashHandle_t nIndex = m_Sounds.FirstHandle(); nIndex != m_Sounds.InvalidHandle(); nIndex = m_Sounds.NextHandle( nIndex ) )
{
delete m_Sounds[ nIndex ];
}
m_Sounds.Purge();
for ( i = 0; i < m_SavedOverrides.Count() ; ++i )
{
delete m_SavedOverrides[ i ];
}
m_SavedOverrides.Purge();
m_Waves.RemoveAll();
m_ActorGenders.Purge();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CSoundEmitterSystemBase::ModShutdown()
{
if ( --m_nInitCount > 0 )
return;
InternalModShutdown();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pName -
//-----------------------------------------------------------------------------
int CSoundEmitterSystemBase::GetSoundIndex( const char *pName ) const
{
if ( !pName )
return -1;
CSoundEntry search;
search.m_Name = pName;
UtlHashHandle_t idx = m_Sounds.Find( pName );
if ( idx == m_Sounds.InvalidHandle() )
return -1;
return idx;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : index -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CSoundEmitterSystemBase::IsValidIndex( int index )
{
return m_Sounds.IsValidHandle( index );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : index -
// Output : char const
//-----------------------------------------------------------------------------
const char *CSoundEmitterSystemBase::GetSoundName( int index )
{
if ( !IsValidIndex( index ) )
return "";
return m_Sounds[ index ]->m_Name.Get();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int CSoundEmitterSystemBase::GetSoundCount( void )
{
return m_Sounds.Count();
}
void CSoundEmitterSystemBase::EnsureAvailableSlotsForGender( SoundFile *pSoundnames, int c, gender_t gender )
{
int i;
if ( c <= 0 )
{
return;
}
CUtlVector< int > slots;
bool needsreset = false;
for ( i = 0; i < c; i++ )
{
if ( pSoundnames[ i ].gender != gender )
continue;
// There was at least one match for the gender
needsreset = true;
// This sound is unavailable
if ( !pSoundnames[ i ].available )
continue;
slots.AddToTail( i );
}
if ( slots.Count() == 0 && needsreset )
{
// Reset all slots for the specified gender!!!
for ( i = 0; i < c; i++ )
{
if ( pSoundnames[ i ].gender != gender )
continue;
pSoundnames[ i ].available = true;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : gender -
// soundnames -
//-----------------------------------------------------------------------------
int CSoundEmitterSystemBase::FindBestSoundForGender( SoundFile *pSoundnames, int c, gender_t gender )
{
// Check for recycling of random sounds...
EnsureAvailableSlotsForGender( pSoundnames, c, gender );
if ( c <= 0 )
{
return -1;
}
CUtlVector< int > slots;
for ( int i = 0; i < c; i++ )
{
if ( pSoundnames[ i ].gender == gender &&
pSoundnames[ i ].available )
{
slots.AddToTail( i );
}
}
if ( slots.Count() >= 1 )
{
int idx = slots[ randomStream->RandomInt( 0, slots.Count() - 1 ) ];
return idx;
}
int idx = randomStream->RandomInt( 0, c - 1 );
return idx;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *soundname -
// params -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CSoundEmitterSystemBase::GetParametersForSound( const char *soundname, CSoundParameters& params, gender_t gender, bool isbeingemitted /*= false*/ )
{
HSOUNDSCRIPTHANDLE index = (HSOUNDSCRIPTHANDLE)GetSoundIndex( soundname );
if ( index == SOUNDEMITTER_INVALID_HANDLE )
{
static CUtlSymbolTable soundWarnings;
char key[ 256 ];
Q_snprintf( key, sizeof( key ), "%s:%s", soundname, params.soundname );
if ( UTL_INVAL_SYMBOL == soundWarnings.Find( key ) )
{
soundWarnings.AddString( key );
DevMsg( "CSoundEmitterSystemBase::GetParametersForSound: No such sound %s\n", soundname );
}
return false;
}
return GetParametersForSoundEx( soundname, index, params, gender, isbeingemitted );
}
CSoundParametersInternal *CSoundEmitterSystemBase::InternalGetParametersForSound( int index )
{
if ( !m_Sounds.IsValidHandle( index ) )
{
Assert( !"CSoundEmitterSystemBase::InternalGetParametersForSound: Bogus index" );
return NULL;
}
return &m_Sounds[ index ]->m_SoundParams;
}
static void SplitName( char const *input, int splitchar, int splitlen, char *before, int beforelen, char *after, int afterlen )
{
char const *in = input;
char *out = before;
int c = 0;
int l = 0;
int maxl = beforelen;
while ( *in )
{
if ( c == splitchar )
{
while ( --splitlen >= 0 )
{
in++;
}
*out = 0;
out = after;
maxl = afterlen;
c++;
continue;
}
if ( l >= maxl )
{
in++;
c++;
continue;
}
*out++ = *in++;
l++;
c++;
}
*out = 0;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : params -
// *wavename -
// gender -
//-----------------------------------------------------------------------------
void CSoundEmitterSystemBase::AddSoundName( CSoundParametersInternal& params, char const *wavename, gender_t gender )
{
CUtlSymbol sym = m_Waves.AddString( wavename );
SoundFile e;
e.symbol = sym;
e.gender = gender;
if ( gender != GENDER_NONE )
{
params.SetUsesGenderToken( true );
}
params.AddSoundName( e );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : params -
// *wavename -
//-----------------------------------------------------------------------------
void CSoundEmitterSystemBase::ExpandSoundNameMacros( CSoundParametersInternal& params, char const *wavename )
{
char const *p = Q_stristr( wavename, SOUNDGENDER_MACRO );
if ( !p )
{
AddSoundName( params, wavename, GENDER_NONE );
return;
}
int offset = p - wavename;
Assert( offset >= 0 );
int duration = SOUNDGENDER_MACRO_LENGTH;
// Create a "male" and "female" version of the sound
char before[ 256 ], after[ 256 ];
Q_memset( before, 0, sizeof( before ) );
Q_memset( after, 0, sizeof( after ) );
SplitName( wavename, offset, duration, before, sizeof( before ), after, sizeof( after ) );
char temp[ 256 ];
Q_snprintf( temp, sizeof( temp ), "%s%s%s", before, "male", after );
AddSoundName( params, temp, GENDER_MALE );
Q_snprintf( temp, sizeof( temp ), "%s%s%s", before, "female", after );
AddSoundName( params, temp, GENDER_FEMALE );
// Add the conversion entry with the gender tags still in it
CUtlSymbol sym = m_Waves.AddString( wavename );
SoundFile e;
e.symbol = sym;
e.gender = GENDER_NONE;
params.AddConvertedName( e );
}
void CSoundEmitterSystemBase::GenderExpandString( gender_t gender, char const *in, char *out, int maxlen )
{
// Assume the worst
Q_strncpy( out, in, maxlen );
char const *p = Q_stristr( in, SOUNDGENDER_MACRO );
if ( !p )
{
return;
}
// Look up actor gender
if ( gender == GENDER_NONE )
{
return;
}
int offset = p - in;
Assert( offset >= 0 );
int duration = SOUNDGENDER_MACRO_LENGTH;
// Create a "male" and "female" version of the sound
char before[ 256 ], after[ 256 ];
Q_memset( before, 0, sizeof( before ) );
Q_memset( after, 0, sizeof( after ) );
SplitName( in, offset, duration, before, sizeof( before ), after, sizeof( after ) );
switch ( gender )
{
default:
case GENDER_NONE:
{
Assert( !"CSoundEmitterSystemBase::GenderExpandString: expecting MALE or FEMALE!" );
}
break;
case GENDER_MALE:
{
Q_snprintf( out, maxlen, "%s%s%s", before, "male", after );
}
break;
case GENDER_FEMALE:
{
Q_snprintf( out, maxlen, "%s%s%s", before, "female", after );
}
break;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actorname -
// *in -
// *out -
// maxlen -
//-----------------------------------------------------------------------------
void CSoundEmitterSystemBase::GenderExpandString( char const *actormodel, char const *in, char *out, int maxlen )
{
gender_t gender = GetActorGender( actormodel );
GenderExpandString( gender, in, out, maxlen );
}
void CSoundEmitterSystemBase::LoadGlobalActors()
{
// Now load the global actor list from the scripts/globalactors.txt file
KeyValues *allActors = NULL;
allActors = new KeyValues( "allactors" );
if ( allActors->LoadFromFile( filesystem, "scripts/global_actors.txt", NULL ) )
{
KeyValues *pvkActor;
for ( pvkActor = allActors->GetFirstSubKey(); pvkActor != NULL; pvkActor = pvkActor->GetNextKey() )
{
UtlHashHandle_t idx = m_ActorGenders.Find( pvkActor->GetName() );
if ( idx == m_ActorGenders.InvalidHandle() )
{
if ( m_ActorGenders.Count() > 254 )
{
Warning( "Exceeded max number of actors in scripts/global_actors.txt\n" );
break;
}
gender_t gender = GENDER_NONE;
if ( !Q_stricmp( pvkActor->GetString(), "male" ) )
{
gender = GENDER_MALE;
}
else if (!Q_stricmp( pvkActor->GetString(), "female" ) )
{
gender = GENDER_FEMALE;
}
m_ActorGenders.Insert( pvkActor->GetName(), gender );
}
}
}
allActors->deleteThis();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actorname -
// Output : gender_t
//-----------------------------------------------------------------------------
gender_t CSoundEmitterSystemBase::GetActorGender( char const *actormodel )
{
char actor[ 256 ];
actor[0] = 0;
if ( actormodel )
{
Q_FileBase( actormodel, actor, sizeof( actor ) );
}
UtlHashHandle_t idx = m_ActorGenders.Find( actor );
if ( idx == m_ActorGenders.InvalidHandle() )
return GENDER_NONE;
return m_ActorGenders[ idx ];
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *soundname -
// params -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CSoundEmitterSystemBase::InitSoundInternalParameters( const char *soundname, KeyValues *kv, CSoundParametersInternal& params )
{
KeyValues *pKey = kv->GetFirstSubKey();
while ( pKey )
{
if ( !Q_strcasecmp( pKey->GetName(), "channel" ) )
{
params.ChannelFromString( pKey->GetString() );
}
else if ( !Q_strcasecmp( pKey->GetName(), "volume" ) )
{
params.VolumeFromString( pKey->GetString() );
}
else if ( !Q_strcasecmp( pKey->GetName(), "pitch" ) )
{
params.PitchFromString( pKey->GetString() );
}
else if ( !Q_strcasecmp( pKey->GetName(), "wave" ) )
{
ExpandSoundNameMacros( params, pKey->GetString() );
}
else if ( !Q_strcasecmp( pKey->GetName(), "rndwave" ) )
{
KeyValues *pWaves = pKey->GetFirstSubKey();
while ( pWaves )
{
ExpandSoundNameMacros( params, pWaves->GetString() );
pWaves = pWaves->GetNextKey();
}
}
else if ( !Q_strcasecmp( pKey->GetName(), "attenuation" ) || !Q_strcasecmp( pKey->GetName(), "CompatibilityAttenuation" ) )
{
if ( !Q_strncasecmp( pKey->GetString(), "SNDLVL_", strlen( "SNDLVL_" ) ) )
{
DevMsg( "CSoundEmitterSystemBase::GetParametersForSound: sound %s has \"attenuation\" with %s value!\n",
soundname, pKey->GetString() );
}
if ( !Q_strncasecmp( pKey->GetString(), "ATTN_", strlen( "ATTN_" ) ) )
{
params.SetSoundLevel( ATTN_TO_SNDLVL( TranslateAttenuation( pKey->GetString() ) ) );
}
else
{
interval_t interval;
interval = ReadInterval( pKey->GetString() );
// Translate from attenuation to soundlevel
float start = interval.start;
float end = interval.start + interval.range;
params.SetSoundLevel( ATTN_TO_SNDLVL( start ), ATTN_TO_SNDLVL( end ) - ATTN_TO_SNDLVL( start ) );
}
// Goldsrc compatibility mode.. feed the sndlevel value through the sound engine interface in such a way
// that it can reconstruct the original sndlevel value and flag the sound as using Goldsrc attenuation.
bool bCompatibilityAttenuation = !Q_strcasecmp( pKey->GetName(), "CompatibilityAttenuation" );
if ( bCompatibilityAttenuation )
{
if ( params.GetSoundLevel().range != 0 )
{
Warning( "CompatibilityAttenuation for sound %s must have same start and end values.\n", soundname );
}
params.SetSoundLevel( SNDLEVEL_TO_COMPATIBILITY_MODE( params.GetSoundLevel().start ) );
}
}
else if ( !Q_strcasecmp( pKey->GetName(), "soundlevel" ) )
{
if ( !Q_strncasecmp( pKey->GetString(), "ATTN_", strlen( "ATTN_" ) ) )
{
DevMsg( "CSoundEmitterSystemBase::GetParametersForSound: sound %s has \"soundlevel\" with %s value!\n",
soundname, pKey->GetString() );
}
params.SoundLevelFromString( pKey->GetString() );
}
else if ( !Q_strcasecmp( pKey->GetName(), "play_to_owner_only" ) )
{
params.SetOnlyPlayToOwner( pKey->GetInt() ? true : false );
}
else if ( !Q_strcasecmp( pKey->GetName(), "delay_msec" ) )
{
// Don't allow negative delay
params.SetDelayMsec( max( 0, pKey->GetInt() ) );
}
pKey = pKey->GetNextKey();
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *soundname -
// Output : char const
//-----------------------------------------------------------------------------
const char *CSoundEmitterSystemBase::GetWavFileForSound( const char *soundname, char const *actormodel )
{
gender_t gender = GetActorGender( actormodel );
return GetWavFileForSound( soundname, gender );
}
const char *CSoundEmitterSystemBase::GetWavFileForSound( const char *soundname, gender_t gender )
{
CSoundParameters params;
if ( !GetParametersForSound( soundname, params, gender ) )
{
return soundname;
}
if ( !params.soundname[ 0 ] )
{
return soundname;
}
static char outsound[ 512 ];
Q_strncpy( outsound, params.soundname, sizeof( outsound ) );
return outsound;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *soundname -
// Output : soundlevel_t
//-----------------------------------------------------------------------------
soundlevel_t CSoundEmitterSystemBase::LookupSoundLevel( const char *soundname )
{
CSoundParameters params;
if ( !GetParametersForSound( soundname, params, GENDER_NONE ) )
{
return SNDLVL_NORM;
}
return params.soundlevel;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *filename -
//-----------------------------------------------------------------------------
void CSoundEmitterSystemBase::AddSoundsFromFile( const char *filename, bool bPreload, bool bIsOverride /*=false*/, bool bRefresh /*=false*/ )
{
CSoundScriptFile sf;
sf.hFilename = filesystem->FindOrAddFileName( filename );
sf.dirty = false;
int scriptindex = m_SoundKeyValues.AddToTail( sf );
int replaceCount = 0;
int newOverrideCount = 0;
int duplicatedReplacements = 0;
// Open the soundscape data file, and abort if we can't
KeyValues *kv = new KeyValues( "" );
if ( filesystem->LoadKeyValues( *kv, IFileSystem::TYPE_SOUNDEMITTER, filename, "GAME" ) )
{
// parse out all of the top level sections and save their names
KeyValues *pKeys = kv;
while ( pKeys )
{
if ( pKeys->GetFirstSubKey() )
{
if ( m_Sounds.Count() >= 65534 )
{
Warning( "Exceeded maximum number of sound emitter entries\n" );
break;
}
CSoundEntry *pEntry;
{
MEM_ALLOC_CREDIT();
pEntry = new CSoundEntry;
}
pEntry->m_Name = pKeys->GetName();
pEntry->m_bRemoved = false;
pEntry->m_nScriptFileIndex = scriptindex;
pEntry->m_bIsOverride = bIsOverride;
if ( bIsOverride )
{
++newOverrideCount;
}
UtlHashHandle_t lookup = m_Sounds.Insert( pEntry ); // insert returns existing item if found
if ( m_Sounds[ lookup ] != pEntry )
{
if ( bIsOverride )
{
MEM_ALLOC_CREDIT();
// Store off the old sound if it's not already an "override" from another file!!!
// Otherwise, just whack it again!!!
if ( !m_Sounds[ lookup ]->IsOverride() )
{
m_SavedOverrides.AddToTail( m_Sounds[ lookup ] );
}
else
{
++duplicatedReplacements;
}
InitSoundInternalParameters( pKeys->GetName(), pKeys, pEntry->m_SoundParams );
pEntry->m_SoundParams.SetShouldPreload( bPreload ); // this gets handled by game code after initting.
m_Sounds.ReplaceKey( lookup, pEntry );
++replaceCount;
}
else if ( bRefresh )
{
InitSoundInternalParameters( pKeys->GetName(), pKeys, m_Sounds[ lookup ]->m_SoundParams );
}
#if 0
else
{
DevMsg( "CSoundEmitterSystem::AddSoundsFromFile(%s): Entry %s duplicated, skipping\n", filename, pKeys->GetName() );
}
#endif
}
else
{
MEM_ALLOC_CREDIT();
InitSoundInternalParameters( pKeys->GetName(), pKeys, pEntry->m_SoundParams );
pEntry->m_SoundParams.SetShouldPreload( bPreload ); // this gets handled by game code after initting.
}
}
pKeys = pKeys->GetNextKey();
}
kv->deleteThis();
}
else
{
if ( !bIsOverride )
{
Warning( "CSoundEmitterSystem::AddSoundsFromFile: No such file %s\n", filename );
}
// Discard
m_SoundKeyValues.Remove( scriptindex );
kv->deleteThis();
return;
}
if ( bIsOverride )
{
DevMsg( "SoundEmitter: adding map sound overrides from %s [%i total, %i replacements, %i duplicated replacements]\n",
filename,
newOverrideCount,
replaceCount,
duplicatedReplacements );
}
Assert( scriptindex >= 0 );
}
//-----------------------------------------------------------------------------
// Purpose: Reload a sound emitter file (used to refresh files after sv_pure is turned on)
//-----------------------------------------------------------------------------
void CSoundEmitterSystemBase::ReloadSoundEntriesInList( IFileList *pFilesToReload )
{
int i, c;
c = m_SoundKeyValues.Count();
CUtlVector< const char * > processed;
for ( i = 0; i < c ; i++ )
{
const char *pszFileName = GetSoundScriptName( i );
if ( pszFileName && pszFileName[0] )
{
if ( processed.Find( pszFileName) == processed.InvalidIndex() && pFilesToReload->IsFileInList( pszFileName ) )
{
Msg( "Reloading sound file '%s' due to pure settings.\n", pszFileName );
AddSoundsFromFile( pszFileName, false, false, true );
// Now mark this file name as being reloaded
processed.AddToTail( pszFileName );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Force ModShutdown and ModInit, skips checks for how many systems have
// requested inits (for con commands).
//-----------------------------------------------------------------------------
void CSoundEmitterSystemBase::Flush()
{
InternalModShutdown();
InternalModInit();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CSoundEmitterSystemBase::CheckForMissingWavFiles( bool verbose )
{
int missing = 0;
int c = GetSoundCount();
int i;
char testfile[ 512 ];
for ( i = 0; i < c; i++ )
{
CSoundParametersInternal *internal = InternalGetParametersForSound( i );
if ( !internal )
{
Assert( 0 );
continue;
}
int waveCount = internal->NumSoundNames();
for ( int wave = 0; wave < waveCount; wave++ )
{
CUtlSymbol sym = internal->GetSoundNames()[ wave ].symbol;
const char *name = m_Waves.String( sym );
if ( !name || !name[ 0 ] )
{
Assert( 0 );
continue;
}
// Skip ! sentence stuff
if ( name[0] == CHAR_SENTENCE )
continue;
Q_snprintf( testfile, sizeof( testfile ), "sound/%s", PSkipSoundChars( name ) );
if ( filesystem->FileExists( testfile ) )
continue;
internal->SetHadMissingWaveFiles( true );
++missing;
if ( verbose )
{
DevMsg( "Sound %s references missing file %s\n", GetSoundName( i ), name );
}
}
}
return missing;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *key -
// Output : float
//-----------------------------------------------------------------------------
float CSoundEmitterSystemBase::TranslateAttenuation( const char *key )
{
if ( !key )
{
Assert( 0 );
return ATTN_NORM;
}
if ( !Q_strcasecmp( key, "ATTN_NONE" ) )
return ATTN_NONE;
if ( !Q_strcasecmp( key, "ATTN_NORM" ) )
return ATTN_NORM;
if ( !Q_strcasecmp( key, "ATTN_IDLE" ) )
return ATTN_IDLE;
if ( !Q_strcasecmp( key, "ATTN_STATIC" ) )
return ATTN_STATIC;
if ( !Q_strcasecmp( key, "ATTN_RICOCHET" ) )
return ATTN_RICOCHET;
if ( !Q_strcasecmp( key, "ATTN_GUNFIRE" ) )
return ATTN_GUNFIRE;
DevMsg( "CSoundEmitterSystem: Unknown attenuation key %s\n", key );
return ATTN_NORM;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *key -
// Output : soundlevel_t
//-----------------------------------------------------------------------------
soundlevel_t CSoundEmitterSystemBase::TranslateSoundLevel( const char *key )
{
return TextToSoundLevel( key );
}
//-----------------------------------------------------------------------------
// Purpose: Convert "chan_xxx" into integer value for channel
// Input : *name -
// Output : static int
//-----------------------------------------------------------------------------
int CSoundEmitterSystemBase::TranslateChannel( const char *name )
{
return TextToChannel( name );
}
const char *CSoundEmitterSystemBase::GetSourceFileForSound( int index ) const
{
if ( index < 0 || index >= (int)m_Sounds.Count() )
{
Assert( 0 );
return "";
}
CSoundEntry const *entry = m_Sounds[ index ];
int scriptindex = entry->m_nScriptFileIndex;
if ( scriptindex < 0 || scriptindex >= m_SoundKeyValues.Count() )
{
Assert( 0 );
return "";
}
static char fn[ 512 ];
if ( filesystem->String( m_SoundKeyValues[ scriptindex ].hFilename, fn, sizeof( fn ) ))
{
return fn;
}
Assert( 0 );
return "";
}
const char *CSoundEmitterSystemBase::GetWaveName( CUtlSymbol& sym )
{
return m_Waves.String( sym );
}
int CSoundEmitterSystemBase::FindSoundScript( const char *name ) const
{
int i, c;
FileNameHandle_t hFilename = filesystem->FindFileName( name );
if ( hFilename )
{
// First, make sure it's known
c = m_SoundKeyValues.Count();
for ( i = 0; i < c ; i++ )
{
if ( m_SoundKeyValues[ i ].hFilename == hFilename )
{
return i;
}
}
}
return m_SoundKeyValues.InvalidIndex();
}
bool CSoundEmitterSystemBase::AddSound( const char *soundname, const char *scriptfile, const CSoundParametersInternal& params )
{
int idx = GetSoundIndex( soundname );
int i = FindSoundScript( scriptfile );
if ( i == m_SoundKeyValues.InvalidIndex() )
{
Warning( "CSoundEmitterSystemBase::AddSound( '%s', '%s', ... ), script file not list in manifest '%s'\n",
soundname, scriptfile, MANIFEST_FILE );
return false;
}
MEM_ALLOC_CREDIT();
// More like an update...
if ( IsValidIndex( idx ) )
{
CSoundEntry *entry = m_Sounds[ idx ];
entry->m_bRemoved = false;
entry->m_nScriptFileIndex = i;
entry->m_SoundParams.CopyFrom( params );
m_SoundKeyValues[ i ].dirty = true;
return true;
}
CSoundEntry *pEntry = new CSoundEntry;
pEntry->m_Name = soundname;
pEntry->m_bRemoved = false;
pEntry->m_nScriptFileIndex = i;
pEntry->m_SoundParams.CopyFrom( params );
m_Sounds.Insert( pEntry );
m_SoundKeyValues[ i ].dirty = true;
return true;
}
void CSoundEmitterSystemBase::RemoveSound( const char *soundname )
{
int idx = GetSoundIndex( soundname );
if ( !IsValidIndex( idx ) )
{
Warning( "Can't remove %s, no such sound!\n", soundname );
return;
}
m_Sounds[ idx ]->m_bRemoved = true;
// Mark script as dirty
int scriptindex = m_Sounds[ idx ]->m_nScriptFileIndex;
if ( scriptindex < 0 || scriptindex >= m_SoundKeyValues.Count() )
{
Assert( 0 );
return;
}
m_SoundKeyValues[ scriptindex ].dirty = true;
}
void CSoundEmitterSystemBase::MoveSound( const char *soundname, const char *newscript )
{
int idx = GetSoundIndex( soundname );
if ( !IsValidIndex( idx ) )
{
Warning( "Can't move '%s', no such sound!\n", soundname );
return;
}
int oldscriptindex = m_Sounds[ idx ]->m_nScriptFileIndex;
if ( oldscriptindex < 0 || oldscriptindex >= m_SoundKeyValues.Count() )
{
Assert( 0 );
return;
}
int newscriptindex = FindSoundScript( newscript );
if ( newscriptindex == m_SoundKeyValues.InvalidIndex() )
{
Warning( "CSoundEmitterSystemBase::MoveSound( '%s', '%s' ), script file not list in manifest '%s'\n",
soundname, newscript, MANIFEST_FILE );
return;
}
// No actual change
if ( oldscriptindex == newscriptindex )
{
return;
}
// Move it
m_Sounds[ idx ]->m_nScriptFileIndex = newscriptindex;
// Mark both scripts as dirty
m_SoundKeyValues[ oldscriptindex ].dirty = true;
m_SoundKeyValues[ newscriptindex ].dirty = true;
}
int CSoundEmitterSystemBase::GetNumSoundScripts() const
{
return m_SoundKeyValues.Count();
}
const char *CSoundEmitterSystemBase::GetSoundScriptName( int index ) const
{
if ( index < 0 || index >= m_SoundKeyValues.Count() )
return NULL;
static char fn[ 512 ];
if ( filesystem->String( m_SoundKeyValues[ index ].hFilename, fn, sizeof( fn ) ) )
{
return fn;
}
return "";
}
bool CSoundEmitterSystemBase::IsSoundScriptDirty( int index ) const
{
if ( index < 0 || index >= m_SoundKeyValues.Count() )
return false;
return m_SoundKeyValues[ index ].dirty;
}
void CSoundEmitterSystemBase::SaveChangesToSoundScript( int scriptindex )
{
const char *outfile = GetSoundScriptName( scriptindex );
if ( !outfile )
{
Msg( "CSoundEmitterSystemBase::SaveChangesToSoundScript: No script file for index %i\n", scriptindex );
return;
}
if ( filesystem->FileExists( outfile ) &&
!filesystem->IsFileWritable( outfile ) )
{
Warning( "%s is not writable, can't save data to file\n", outfile );
return;
}
CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );
// FIXME: Write sound script header
if ( filesystem->FileExists( GAME_SOUNDS_HEADER_BLOCK ) )
{
FileHandle_t header = filesystem->Open( GAME_SOUNDS_HEADER_BLOCK, "rb", NULL );
if ( header != FILESYSTEM_INVALID_HANDLE )
{
int len = filesystem->Size( header );
unsigned char *data = new unsigned char[ len + 1 ];
Q_memset( data, 0, len + 1 );
filesystem->Read( data, len, header );
filesystem->Close( header );
data[ len ] = 0;
char *p = (char *)data;
while ( *p )
{
if ( *p != '\r' )
{
buf.PutChar( *p );
}
++p;
}
delete[] data;
}
buf.Printf( "\n" );
}
int c = GetSoundCount();
for ( int i = 0; i < c; i++ )
{
if ( Q_stricmp( outfile, GetSourceFileForSound( i ) ) )
continue;
// It's marked for deletion, just skip it
if ( m_Sounds[ i ]->m_bRemoved )
continue;
CSoundParametersInternal *p = InternalGetParametersForSound( i );
if ( !p )
continue;
buf.Printf( "\"%s\"\n{\n", GetSoundName( i ) );
buf.Printf( "\t\"channel\"\t\t\"%s\"\n", p->ChannelToString() );
buf.Printf( "\t\"volume\"\t\t\"%s\"\n", p->VolumeToString() );
buf.Printf( "\t\"pitch\"\t\t\t\"%s\"\n", p->PitchToString() );
buf.Printf( "\n" );
buf.Printf( "\t\"soundlevel\"\t\"%s\"\n", p->SoundLevelToString() );
if ( p->OnlyPlayToOwner() )
{
buf.Printf( "\t\"play_to_owner_only\"\t\"1\"\n" );
}
if ( p->GetDelayMsec() != 0 )
{
buf.Printf( "\t\"delay_msec\"\t\"%i\"\n", p->GetDelayMsec() );
}
int totalCount = 0;
int waveCount = p->NumSoundNames();
int convertedCount = p->NumConvertedNames();
totalCount = ( waveCount - 2 * convertedCount ) + convertedCount;
if ( totalCount > 0 )
{
buf.Printf( "\n" );
if ( waveCount == 1 )
{
Assert( p->GetSoundNames()[ 0 ].gender == GENDER_NONE );
buf.Printf( "\t\"wave\"\t\t\t\"%s\"\n", GetWaveName( p->GetSoundNames()[ 0 ].symbol ) );
}
else if ( convertedCount == 1 )
{
Assert( p->GetConvertedNames()[ 0 ].gender == GENDER_NONE );
buf.Printf( "\t\"wave\"\t\t\t\"%s\"\n", GetWaveName( p->GetConvertedNames()[ 0 ].symbol ) );
}
else
{
buf.Printf( "\t\"rndwave\"\n" );
buf.Printf( "\t{\n" );
int wave;
for ( wave = 0; wave < waveCount; wave++ )
{
// Skip macro-expanded names
if ( p->GetSoundNames()[ wave ].gender != GENDER_NONE )
continue;
buf.Printf( "\t\t\"wave\"\t\"%s\"\n", GetWaveName( p->GetSoundNames()[ wave ].symbol ) );
}
for ( wave = 0; wave < convertedCount; wave++ )
{
buf.Printf( "\t\t\"wave\"\t\"%s\"\n", GetWaveName( p->GetConvertedNames()[ wave ].symbol ) );
}
buf.Printf( "\t}\n" );
}
}
buf.Printf( "}\n" );
if ( i != c - 1 )
{
buf.Printf( "\n" );
}
}
// Write it out baby
FileHandle_t fh = filesystem->Open( outfile, "wt" );
if (fh)
{
filesystem->Write( buf.Base(), buf.TellPut(), fh );
filesystem->Close(fh);
// Changed saved successfully
m_SoundKeyValues[ scriptindex ].dirty = false;
}
else
{
Warning( "SceneManager_SaveSoundsToScriptFile: Unable to write file %s!!!\n", outfile );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *name -
// Output : CUtlSymbol
//-----------------------------------------------------------------------------
CUtlSymbol CSoundEmitterSystemBase::AddWaveName( const char *name )
{
return m_Waves.AddString( name );
}
void CSoundEmitterSystemBase::RenameSound( const char *soundname, const char *newname )
{
// Same name?
if ( !Q_stricmp( soundname, newname ) )
{
return;
}
int oldindex = GetSoundIndex( soundname );
if ( !IsValidIndex( oldindex ) )
{
Msg( "Can't rename %s, no such sound\n", soundname );
return;
}
int check = GetSoundIndex( newname );
if ( IsValidIndex( check ) )
{
Msg( "Can't rename %s to %s, new name already in list\n", soundname, newname );
return;
}
MEM_ALLOC_CREDIT();
// Copy out old entry
CSoundEntry *pEntry = m_Sounds[ oldindex ];
// Remove it
m_Sounds.Remove( pEntry );
pEntry->m_Name = newname;
// Re-insert in new spot
m_Sounds.Insert( pEntry );
// Mark associated script as dirty
m_SoundKeyValues[ pEntry->m_nScriptFileIndex ].dirty = true;
}
void CSoundEmitterSystemBase::UpdateSoundParameters( const char *soundname, const CSoundParametersInternal& params )
{
int idx = GetSoundIndex( soundname );
if ( !IsValidIndex( idx ) )
{
Msg( "Can't UpdateSoundParameters %s, no such sound\n", soundname );
return;
}
CSoundEntry *entry = m_Sounds[ idx ];
if ( entry->m_SoundParams == params )
{
// No changes
return;
}
// Update parameters
entry->m_SoundParams.CopyFrom( params );
// Set dirty flag
m_SoundKeyValues[ entry->m_nScriptFileIndex ].dirty = true;
}
bool CSoundEmitterSystemBase::IsUsingGenderToken( char const *soundname )
{
int soundindex = GetSoundIndex( soundname );
if ( soundindex < 0 )
return false;
// Look up the sound level from the soundemitter system
CSoundParametersInternal *params = InternalGetParametersForSound( soundindex );
if ( !params )
return false;
return params->UsesGenderToken();
}
unsigned int CSoundEmitterSystemBase::GetManifestFileTimeChecksum()
{
return m_uManifestPlusScriptChecksum;
}
bool CSoundEmitterSystemBase::GetParametersForSoundEx( const char *soundname, HSOUNDSCRIPTHANDLE& handle, CSoundParameters& params, gender_t gender, bool isbeingemitted /*= false*/ )
{
if ( handle == SOUNDEMITTER_INVALID_HANDLE )
{
handle = GetSoundIndex( soundname );
if ( handle == SOUNDEMITTER_INVALID_HANDLE )
return false;
}
CSoundParametersInternal *internal = InternalGetParametersForSound( (int)handle );
if ( !internal )
{
Assert( 0 );
DevMsg( "CSoundEmitterSystemBase::GetParametersForSound: No such sound %s\n", soundname );
return false;
}
params.channel = internal->GetChannel();
params.volume = internal->GetVolume().Random();
params.pitch = internal->GetPitch().Random();
params.pitchlow = internal->GetPitch().start;
params.pitchhigh = params.pitchlow + internal->GetPitch().range;
params.delay_msec = internal->GetDelayMsec();
params.count = internal->NumSoundNames();
params.soundname[ 0 ] = 0;
int bestIndex = FindBestSoundForGender( internal->GetSoundNames(), internal->NumSoundNames(), gender );
if ( bestIndex >= 0 )
{
Q_strncpy( params.soundname, GetWaveName( internal->GetSoundNames()[ bestIndex ].symbol), sizeof( params.soundname ) );
// If we are actually emitting the sound, mark it as not available...
if ( isbeingemitted )
{
internal->GetSoundNames()[ bestIndex ].available = 0;
}
}
params.soundlevel = (soundlevel_t)(int)internal->GetSoundLevel().Random();
params.play_to_owner_only = internal->OnlyPlayToOwner();
if ( !params.soundname[ 0 ] )
{
DevMsg( "CSoundEmitterSystemBase::GetParametersForSound: sound %s has no wave or rndwave key!\n", soundname );
return false;
}
if ( internal->HadMissingWaveFiles() &&
params.soundname[ 0 ] != CHAR_SENTENCE )
{
char testfile[ 256 ];
Q_snprintf( testfile, sizeof( testfile ), "sound/%s", PSkipSoundChars( params.soundname ) );
if ( !filesystem->FileExists( testfile ) )
{
// Prevent repetitive spew...
static CUtlSymbolTable soundWarnings;
char key[ 256 ];
Q_snprintf( key, sizeof( key ), "%s:%s", soundname, params.soundname );
if ( UTL_INVAL_SYMBOL == soundWarnings.Find( key ) )
{
soundWarnings.AddString( key );
DevMsg( "CSoundEmitterSystemBase::GetParametersForSound: sound '%s' references wave '%s' which doesn't exist on disk!\n",
soundname,
params.soundname );
}
return false;
}
}
return true;
}
soundlevel_t CSoundEmitterSystemBase::LookupSoundLevelByHandle( char const *soundname, HSOUNDSCRIPTHANDLE& handle )
{
if ( handle == SOUNDEMITTER_INVALID_HANDLE )
{
handle = (HSOUNDSCRIPTHANDLE)GetSoundIndex( soundname );
if ( handle == SOUNDEMITTER_INVALID_HANDLE )
return SNDLVL_NORM;
}
CSoundParametersInternal *internal = InternalGetParametersForSound( (int)handle );
if ( !internal )
{
return SNDLVL_NORM;
}
return (soundlevel_t)(int)internal->GetSoundLevel().Random();
}
// Called from both client and server (single player) or just one (server only in dedicated server and client only if connected to a remote server)
// Called by LevelInitPreEntity to override sound scripts for the mod with level specific overrides based on custom mapnames, etc.
void CSoundEmitterSystemBase::AddSoundOverrides( char const *scriptfile, bool bPreload /*= false*/ )
{
FileNameHandle_t handle = filesystem->FindOrAddFileName( scriptfile );
if ( m_OverrideFiles.Find( handle ) != m_OverrideFiles.InvalidIndex() )
return;
m_OverrideFiles.AddToTail( handle );
// These are overrides
AddSoundsFromFile( scriptfile, bPreload, true );
}
// Called by either client or server in LevelShutdown to clear out custom overrides
void CSoundEmitterSystemBase::ClearSoundOverrides()
{
int i;
int removed = 0;
for ( UtlHashHandle_t i = m_Sounds.FirstHandle(); i != m_Sounds.InvalidHandle(); )
{
CSoundEntry *entry = m_Sounds[ i ];
if ( entry->IsOverride() )
{
i = m_Sounds.RemoveAndAdvance( i );
++removed;
}
else
{
i = m_Sounds.NextHandle( i );
}
}
if (removed > 0 || m_SavedOverrides.Count() > 0 )
{
Warning( "SoundEmitter: removing map sound overrides [%i to remove, %i to restore]\n",
removed,
m_SavedOverrides.Count() );
}
// Now restore the original entries into the main dictionary.
for ( i = 0; i < m_SavedOverrides.Count(); ++i )
{
CSoundEntry *entry = m_SavedOverrides[ i ];
m_Sounds.Insert( entry );
}
m_SavedOverrides.Purge();
m_OverrideFiles.Purge();
}
CSoundEmitterSystemBase g_SoundEmitterSystemBase;
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CSoundEmitterSystemBase, ISoundEmitterSystemBase,
SOUNDEMITTERSYSTEM_INTERFACE_VERSION, g_SoundEmitterSystemBase );
Reference in New Issue Copy Permalink