mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2024-11-22 04:12:09 +00:00
977 lines
27 KiB
C++
977 lines
27 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 BFG Edition GPL Source Code
|
|
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
|
|
|
|
Doom 3 BFG Edition Source Code 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.
|
|
|
|
Doom 3 BFG Edition Source Code 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 Doom 3 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#pragma hdrstop
|
|
#include "../idlib/precompiled.h"
|
|
|
|
#include "snd_local.h"
|
|
|
|
idCVar s_singleEmitter( "s_singleEmitter", "0", CVAR_INTEGER, "mute all sounds but this emitter" );
|
|
idCVar s_showStartSound( "s_showStartSound", "0", CVAR_BOOL, "print a message every time a sound starts/stops" );
|
|
idCVar s_useOcclusion( "s_useOcclusion", "1", CVAR_BOOL, "Attenuate sounds based on walls" );
|
|
idCVar s_centerFractionVO( "s_centerFractionVO", "0.75", CVAR_FLOAT, "Portion of VO sounds routed to the center channel" );
|
|
|
|
extern idCVar s_playDefaultSound;
|
|
extern idCVar s_noSound;
|
|
|
|
/*
|
|
================================================================================================
|
|
|
|
idSoundFade
|
|
|
|
================================================================================================
|
|
*/
|
|
|
|
/*
|
|
========================
|
|
idSoundFade::Clear
|
|
========================
|
|
*/
|
|
void idSoundFade::Clear() {
|
|
fadeStartTime = 0;
|
|
fadeEndTime = 0;
|
|
fadeStartVolume = 0.0f;
|
|
fadeEndVolume = 0.0f;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundFade::SetVolume
|
|
========================
|
|
*/
|
|
void idSoundFade::SetVolume( float to ) {
|
|
fadeStartVolume = to;
|
|
fadeEndVolume = to;
|
|
fadeStartTime = 0;
|
|
fadeEndTime = 0;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundFade::Fade
|
|
========================
|
|
*/
|
|
void idSoundFade::Fade( float to, int length, int soundTime ) {
|
|
int startTime = soundTime;
|
|
// if it is already fading to this volume at this rate, don't change it
|
|
if ( fadeEndTime == startTime + length && fadeEndVolume == to ) {
|
|
return;
|
|
}
|
|
fadeStartVolume = GetVolume( soundTime );
|
|
fadeEndVolume = to;
|
|
fadeStartTime = startTime;
|
|
fadeEndTime = startTime + length;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundFade::GetVolume
|
|
========================
|
|
*/
|
|
float idSoundFade::GetVolume( const int soundTime ) const {
|
|
const float fadeDuration = ( fadeEndTime - fadeStartTime );
|
|
const int currentTime = soundTime;
|
|
const float playTime = ( currentTime - fadeStartTime );
|
|
if ( fadeDuration <= 0.0f ) {
|
|
return fadeEndVolume;
|
|
} else if ( currentTime >= fadeEndTime ) {
|
|
return fadeEndVolume;
|
|
} else if ( currentTime > fadeStartTime ) {
|
|
return fadeStartVolume + ( fadeEndVolume - fadeStartVolume ) * playTime / fadeDuration;
|
|
} else {
|
|
return fadeStartVolume;
|
|
}
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundChannel::idSoundChannel
|
|
========================
|
|
*/
|
|
idSoundChannel::idSoundChannel() {
|
|
emitter = NULL;
|
|
hardwareVoice = NULL;
|
|
|
|
startTime = 0;
|
|
endTime = 0;
|
|
leadinSample = NULL;
|
|
loopingSample = NULL;
|
|
logicalChannel = SCHANNEL_ANY;
|
|
allowSlow = false;
|
|
soundShader = NULL;
|
|
|
|
volumeFade.Clear();
|
|
|
|
volumeDB = DB_SILENCE;
|
|
currentAmplitude = 0.0f;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundChannel::~idSoundChannel
|
|
========================
|
|
*/
|
|
idSoundChannel::~idSoundChannel() {
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundChannel::CanMute
|
|
Never actually mute VO because we can't restart them precisely enough for lip syncing to not fuck up
|
|
========================
|
|
*/
|
|
bool idSoundChannel::CanMute() const {
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundChannel::Mute
|
|
|
|
A muted sound is considered still running, and can restart when a listener
|
|
gets close enough.
|
|
========================
|
|
*/
|
|
void idSoundChannel::Mute() {
|
|
if ( hardwareVoice != NULL ) {
|
|
soundSystemLocal.FreeVoice( hardwareVoice );
|
|
hardwareVoice = NULL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundChannel::IsLooping
|
|
========================
|
|
*/
|
|
bool idSoundChannel::IsLooping() const {
|
|
return ( parms.soundShaderFlags & SSF_LOOPING ) != 0;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundChannel::CheckForCompletion
|
|
========================
|
|
*/
|
|
bool idSoundChannel::CheckForCompletion( int currentTime ) {
|
|
if ( leadinSample == NULL ) {
|
|
return true;
|
|
}
|
|
// endTime of 0 indicates a sound should loop forever
|
|
if ( endTime > 0 && endTime < currentTime ) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundChannel::UpdateVolume
|
|
========================
|
|
*/
|
|
void idSoundChannel::UpdateVolume( int currentTime ) {
|
|
idSoundWorldLocal * soundWorld = emitter->soundWorld;
|
|
|
|
volumeDB = DB_SILENCE;
|
|
currentAmplitude = 0.0f;
|
|
|
|
if ( leadinSample == NULL ) {
|
|
return;
|
|
}
|
|
if ( startTime > currentTime ) {
|
|
return;
|
|
}
|
|
if ( endTime > 0 && endTime < currentTime ) {
|
|
return;
|
|
}
|
|
|
|
// if you don't want to hear all the beeps from missing sounds
|
|
if ( leadinSample->IsDefault() && !s_playDefaultSound.GetBool() ) {
|
|
return;
|
|
}
|
|
|
|
bool emitterIsListener = ( emitter->emitterId == soundWorld->listener.id );
|
|
|
|
// if it is a private sound, set the volume to zero unless we match the listener.id
|
|
if ( parms.soundShaderFlags & SSF_PRIVATE_SOUND ) {
|
|
if ( !emitterIsListener ) {
|
|
return;
|
|
}
|
|
}
|
|
if ( parms.soundShaderFlags & SSF_ANTI_PRIVATE_SOUND ) {
|
|
if ( emitterIsListener ) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
// volume fading
|
|
float newVolumeDB = parms.volume;
|
|
newVolumeDB += volumeFade.GetVolume( currentTime );
|
|
newVolumeDB += soundWorld->volumeFade.GetVolume( currentTime );
|
|
newVolumeDB += soundWorld->pauseFade.GetVolume( currentTime );
|
|
if ( parms.soundClass >= 0 && parms.soundClass < SOUND_MAX_CLASSES ) {
|
|
newVolumeDB += soundWorld->soundClassFade[parms.soundClass].GetVolume( currentTime );
|
|
}
|
|
|
|
bool global = ( parms.soundShaderFlags & SSF_GLOBAL ) != 0;
|
|
|
|
// attenuation
|
|
if ( !global && !emitterIsListener ) {
|
|
float distance = ( parms.soundShaderFlags & SSF_NO_OCCLUSION ) == 0 ? emitter->spatializedDistance : emitter->directDistance;
|
|
float mindist = parms.minDistance;
|
|
float maxdist = parms.maxDistance;
|
|
if ( distance >= maxdist ) {
|
|
newVolumeDB = DB_SILENCE;
|
|
} else if ( ( distance > mindist ) && ( maxdist > mindist ) ) {
|
|
float f = ( distance - mindist ) / ( maxdist - mindist );
|
|
newVolumeDB += LinearToDB( Square( 1.0f - f ) );
|
|
}
|
|
}
|
|
|
|
if ( soundSystemLocal.musicMuted && ( parms.soundShaderFlags & SSF_MUSIC ) != 0 ) {
|
|
newVolumeDB = DB_SILENCE;
|
|
}
|
|
|
|
// store the new volume on the channel
|
|
volumeDB = newVolumeDB;
|
|
|
|
// keep track of the maximum volume
|
|
float currentVolumeDB = newVolumeDB;
|
|
if ( hardwareVoice != NULL ) {
|
|
float amplitude = hardwareVoice->GetAmplitude();
|
|
if ( amplitude <= 0.0f ) {
|
|
currentVolumeDB = DB_SILENCE;
|
|
} else {
|
|
currentVolumeDB += LinearToDB( amplitude );
|
|
}
|
|
currentAmplitude = amplitude;
|
|
}
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundChannel::UpdateHardware
|
|
========================
|
|
*/
|
|
void idSoundChannel::UpdateHardware( float volumeAdd, int currentTime ) {
|
|
idSoundWorldLocal * soundWorld = emitter->soundWorld;
|
|
|
|
if ( soundWorld == NULL ) {
|
|
return;
|
|
}
|
|
if ( leadinSample == NULL ) {
|
|
return;
|
|
}
|
|
if ( startTime > currentTime ) {
|
|
return;
|
|
}
|
|
if ( endTime > 0 && endTime < currentTime ) {
|
|
return;
|
|
}
|
|
|
|
// convert volumes from decibels to linear
|
|
float volume = Max( 0.0f, DBtoLinear( volumeDB + volumeAdd ) );
|
|
|
|
if ( ( parms.soundShaderFlags & SSF_UNCLAMPED ) == 0 ) {
|
|
volume = Min( 1.0f, volume );
|
|
}
|
|
|
|
bool global = ( parms.soundShaderFlags & SSF_GLOBAL ) != 0;
|
|
bool omni = ( parms.soundShaderFlags & SSF_OMNIDIRECTIONAL ) != 0;
|
|
bool emitterIsListener = ( emitter->emitterId == soundWorld->listener.id );
|
|
|
|
int startOffset = 0;
|
|
bool issueStart = false;
|
|
|
|
if ( hardwareVoice == NULL ) {
|
|
if ( volume <= 0.00001f ) {
|
|
return;
|
|
}
|
|
|
|
hardwareVoice = soundSystemLocal.AllocateVoice( leadinSample, loopingSample );
|
|
|
|
if ( hardwareVoice == NULL ) {
|
|
return;
|
|
}
|
|
|
|
issueStart = true;
|
|
startOffset = currentTime - startTime;
|
|
}
|
|
|
|
if ( omni || global || emitterIsListener ) {
|
|
hardwareVoice->SetPosition( vec3_zero );
|
|
} else {
|
|
hardwareVoice->SetPosition( ( emitter->spatializedOrigin - soundWorld->listener.pos ) * soundWorld->listener.axis.Transpose() );
|
|
}
|
|
if ( parms.soundShaderFlags & SSF_VO ) {
|
|
hardwareVoice->SetCenterChannel( s_centerFractionVO.GetFloat() );
|
|
} else {
|
|
hardwareVoice->SetCenterChannel( 0.0f );
|
|
}
|
|
|
|
extern idCVar timescale;
|
|
|
|
hardwareVoice->SetGain( volume );
|
|
hardwareVoice->SetInnerRadius( parms.minDistance * METERS_TO_DOOM );
|
|
hardwareVoice->SetPitch( soundWorld->slowmoSpeed * idMath::ClampFloat( 0.2f, 5.0f, timescale.GetFloat() ) );
|
|
|
|
if ( soundWorld->enviroSuitActive ) {
|
|
hardwareVoice->SetOcclusion( 0.5f );
|
|
} else {
|
|
hardwareVoice->SetOcclusion( 0.0f );
|
|
}
|
|
|
|
if ( issueStart ) {
|
|
hardwareVoice->Start( startOffset, parms.soundShaderFlags | ( parms.shakes == 0.0f ? SSF_NO_FLICKER : 0 ) );
|
|
} else {
|
|
hardwareVoice->Update();
|
|
}
|
|
}
|
|
|
|
/*
|
|
================================================================================================
|
|
|
|
idSoundEmitterLocal
|
|
|
|
================================================================================================
|
|
*/
|
|
|
|
/*
|
|
========================
|
|
idSoundEmitterLocal::idSoundEmitterLocal
|
|
========================
|
|
*/
|
|
idSoundEmitterLocal::idSoundEmitterLocal() {
|
|
Init( 0, NULL );
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundEmitterLocal::~idSoundEmitterLocal
|
|
========================
|
|
*/
|
|
idSoundEmitterLocal::~idSoundEmitterLocal() {
|
|
assert( channels.Num() == 0 );
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundEmitterLocal::Clear
|
|
========================
|
|
*/
|
|
void idSoundEmitterLocal::Init( int i, idSoundWorldLocal * sw ) {
|
|
index = i;
|
|
soundWorld = sw;
|
|
|
|
// Init should only be called on a freshly constructed sound emitter or in a Reset()
|
|
assert( channels.Num() == 0 );
|
|
|
|
canFree = false;
|
|
origin.Zero();
|
|
emitterId = 0;
|
|
|
|
directDistance = 0.0f;
|
|
lastValidPortalArea = -1;
|
|
spatializedDistance = 0.0f;
|
|
spatializedOrigin.Zero();
|
|
|
|
memset( &parms, 0, sizeof( parms ) );
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundEmitterLocal::Reset
|
|
========================
|
|
*/
|
|
void idSoundEmitterLocal::Reset() {
|
|
for ( int i = 0; i < channels.Num(); i++ ) {
|
|
soundWorld->FreeSoundChannel( channels[i] );
|
|
}
|
|
channels.Clear();
|
|
Init( index, soundWorld );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idSoundEmitterLocal::OverrideParms
|
|
==================
|
|
*/
|
|
void idSoundEmitterLocal::OverrideParms( const soundShaderParms_t * base, const soundShaderParms_t * over, soundShaderParms_t * out ) {
|
|
if ( !over ) {
|
|
*out = *base;
|
|
return;
|
|
}
|
|
if ( over->minDistance ) {
|
|
out->minDistance = over->minDistance;
|
|
} else {
|
|
out->minDistance = base->minDistance;
|
|
}
|
|
if ( over->maxDistance ) {
|
|
out->maxDistance = over->maxDistance;
|
|
} else {
|
|
out->maxDistance = base->maxDistance;
|
|
}
|
|
if ( over->shakes ) {
|
|
out->shakes = over->shakes;
|
|
} else {
|
|
out->shakes = base->shakes;
|
|
}
|
|
if ( over->volume ) {
|
|
out->volume = over->volume;
|
|
} else {
|
|
out->volume = base->volume;
|
|
}
|
|
if ( over->soundClass ) {
|
|
out->soundClass = over->soundClass;
|
|
} else {
|
|
out->soundClass = base->soundClass;
|
|
}
|
|
out->soundShaderFlags = base->soundShaderFlags | over->soundShaderFlags;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundEmitterLocal::CheckForCompletion
|
|
|
|
Checks to see if any of the channels have completed, removing them as they do
|
|
|
|
This will also play any postSounds on the same channel as their owner.
|
|
|
|
Returns true if the emitter should be freed.
|
|
========================
|
|
*/
|
|
bool idSoundEmitterLocal::CheckForCompletion( int currentTime ) {
|
|
for ( int i = channels.Num() - 1; i >= 0 ; i-- ) {
|
|
idSoundChannel * chan = channels[i];
|
|
|
|
if ( chan->CheckForCompletion( currentTime ) ) {
|
|
channels.RemoveIndex( i );
|
|
soundWorld->FreeSoundChannel( chan );
|
|
}
|
|
}
|
|
return ( canFree && channels.Num() == 0 );
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundEmitterLocal::Update
|
|
========================
|
|
*/
|
|
void idSoundEmitterLocal::Update( int currentTime ) {
|
|
if ( channels.Num() == 0 ) {
|
|
return;
|
|
}
|
|
|
|
directDistance = ( soundWorld->listener.pos - origin ).LengthFast() * DOOM_TO_METERS;
|
|
|
|
spatializedDistance = directDistance;
|
|
spatializedOrigin = origin;
|
|
|
|
// Initialize all channels to silence
|
|
for ( int i = 0; i < channels.Num(); i++ ) {
|
|
channels[i]->volumeDB = DB_SILENCE;
|
|
}
|
|
|
|
if ( s_singleEmitter.GetInteger() > 0 && s_singleEmitter.GetInteger() != index ) {
|
|
return;
|
|
}
|
|
if ( soundWorld->listener.area == -1 ) {
|
|
// listener is outside the world
|
|
return;
|
|
}
|
|
if ( soundSystemLocal.muted || soundWorld != soundSystemLocal.currentSoundWorld ) {
|
|
return;
|
|
}
|
|
float maxDistance = 0.0f;
|
|
bool maxDistanceValid = false;
|
|
bool useOcclusion = false;
|
|
if ( emitterId != soundWorld->listener.id ) {
|
|
for ( int i = 0; i < channels.Num(); i++ ) {
|
|
idSoundChannel * chan = channels[i];
|
|
if ( ( chan->parms.soundShaderFlags & SSF_GLOBAL ) != 0 ) {
|
|
continue;
|
|
}
|
|
useOcclusion = useOcclusion || ( ( chan->parms.soundShaderFlags & SSF_NO_OCCLUSION ) == 0 );
|
|
maxDistanceValid = true;
|
|
if ( maxDistance < channels[i]->parms.maxDistance ) {
|
|
maxDistance = channels[i]->parms.maxDistance;
|
|
}
|
|
}
|
|
}
|
|
if ( maxDistanceValid && directDistance >= maxDistance ) {
|
|
// too far away to possibly hear it
|
|
return;
|
|
}
|
|
if ( useOcclusion && s_useOcclusion.GetBool() ) {
|
|
// work out virtual origin and distance, which may be from a portal instead of the actual origin
|
|
if ( soundWorld->renderWorld != NULL ) {
|
|
// we have a valid renderWorld
|
|
int soundInArea = soundWorld->renderWorld->PointInArea( origin );
|
|
if ( soundInArea == -1 ) {
|
|
soundInArea = lastValidPortalArea;
|
|
} else {
|
|
lastValidPortalArea = soundInArea;
|
|
}
|
|
if ( soundInArea != -1 && soundInArea != soundWorld->listener.area ) {
|
|
spatializedDistance = maxDistance * METERS_TO_DOOM;
|
|
soundWorld->ResolveOrigin( 0, NULL, soundInArea, 0.0f, origin, this );
|
|
spatializedDistance *= DOOM_TO_METERS;
|
|
}
|
|
}
|
|
}
|
|
|
|
for ( int j = 0; j < channels.Num(); j++ ) {
|
|
channels[j]->UpdateVolume( currentTime );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundEmitterLocal::Index
|
|
========================
|
|
*/
|
|
int idSoundEmitterLocal::Index() const {
|
|
assert( soundWorld );
|
|
assert( soundWorld->emitters[this->index] == this );
|
|
|
|
return index;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundEmitterLocal::Free
|
|
|
|
Doesn't free it until the next update.
|
|
========================
|
|
*/
|
|
void idSoundEmitterLocal::Free( bool immediate ) {
|
|
assert( soundWorld );
|
|
assert( soundWorld->emitters[this->index] == this );
|
|
|
|
if ( canFree ) {
|
|
// Double free
|
|
return;
|
|
}
|
|
if ( soundWorld && soundWorld->writeDemo ) {
|
|
soundWorld->writeDemo->WriteInt( DS_SOUND );
|
|
soundWorld->writeDemo->WriteInt( SCMD_FREE );
|
|
soundWorld->writeDemo->WriteInt( index );
|
|
soundWorld->writeDemo->WriteInt( immediate );
|
|
}
|
|
|
|
if ( immediate ) {
|
|
Reset();
|
|
}
|
|
|
|
canFree = true;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundEmitterLocal::UpdateEmitter
|
|
========================
|
|
*/
|
|
void idSoundEmitterLocal::UpdateEmitter( const idVec3 &origin, int listenerId, const soundShaderParms_t *parms ) {
|
|
assert( soundWorld != NULL );
|
|
assert( soundWorld->emitters[this->index] == this );
|
|
|
|
if ( soundWorld && soundWorld->writeDemo ) {
|
|
soundWorld->writeDemo->WriteInt( DS_SOUND );
|
|
soundWorld->writeDemo->WriteInt( SCMD_UPDATE );
|
|
soundWorld->writeDemo->WriteInt( index );
|
|
soundWorld->writeDemo->WriteVec3( origin );
|
|
soundWorld->writeDemo->WriteInt( listenerId );
|
|
soundWorld->writeDemo->WriteFloat( parms->minDistance );
|
|
soundWorld->writeDemo->WriteFloat( parms->maxDistance );
|
|
soundWorld->writeDemo->WriteFloat( parms->volume );
|
|
soundWorld->writeDemo->WriteFloat( parms->shakes );
|
|
soundWorld->writeDemo->WriteInt( parms->soundShaderFlags );
|
|
soundWorld->writeDemo->WriteInt( parms->soundClass );
|
|
}
|
|
|
|
this->origin = origin;
|
|
this->emitterId = listenerId;
|
|
this->parms = *parms;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundEmitterLocal::StartSound
|
|
|
|
in most cases play sounds immediately, however
|
|
intercept sounds using SSF_FINITE_SPEED_OF_SOUND
|
|
and schedule them for playback later
|
|
|
|
return: int - the length of the started sound in msec.
|
|
========================
|
|
*/
|
|
int idSoundEmitterLocal::StartSound( const idSoundShader * shader, const s_channelType channel, float diversity, int shaderFlags, bool allowSlow ) {
|
|
assert( soundWorld != NULL );
|
|
assert( soundWorld->emitters[this->index] == this );
|
|
|
|
if ( shader == NULL ) {
|
|
return 0;
|
|
}
|
|
|
|
if ( soundWorld && soundWorld->writeDemo ) {
|
|
soundWorld->writeDemo->WriteInt( DS_SOUND );
|
|
soundWorld->writeDemo->WriteInt( SCMD_START );
|
|
soundWorld->writeDemo->WriteInt( index );
|
|
|
|
soundWorld->writeDemo->WriteHashString( shader->GetName() );
|
|
|
|
soundWorld->writeDemo->WriteInt( channel );
|
|
soundWorld->writeDemo->WriteFloat( diversity );
|
|
soundWorld->writeDemo->WriteInt( shaderFlags );
|
|
}
|
|
|
|
if ( s_noSound.GetBool() ) {
|
|
return 0;
|
|
}
|
|
|
|
int currentTime = soundWorld->GetSoundTime();
|
|
|
|
bool showStartSound = s_showStartSound.GetBool();
|
|
if ( showStartSound ) {
|
|
idLib::Printf( "%dms: StartSound(%d:%d): %s: ", currentTime, index, channel, shader->GetName() );
|
|
}
|
|
|
|
// build the channel parameters by taking the shader parms and optionally overriding
|
|
soundShaderParms_t chanParms;
|
|
chanParms = shader->parms;
|
|
OverrideParms( &chanParms, &parms, &chanParms );
|
|
chanParms.soundShaderFlags |= shaderFlags;
|
|
|
|
if ( shader->entries.Num() == 0 ) {
|
|
if ( showStartSound ) {
|
|
idLib::Printf( S_COLOR_RED "No Entries\n" );
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// PLAY_ONCE sounds will never be restarted while they are running
|
|
if ( chanParms.soundShaderFlags & SSF_PLAY_ONCE ) {
|
|
for ( int i = 0; i < channels.Num(); i++ ) {
|
|
idSoundChannel * chan = channels[i];
|
|
if ( chan->soundShader == shader && !chan->CheckForCompletion( currentTime ) ) {
|
|
if ( showStartSound ) {
|
|
idLib::Printf( S_COLOR_YELLOW "Not started because of playOnce\n" );
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// never play the same sound twice with the same starting time, even
|
|
// if they are on different channels
|
|
for ( int i = 0; i < channels.Num(); i++ ) {
|
|
idSoundChannel * chan = channels[i];
|
|
if ( chan->soundShader == shader && chan->startTime == currentTime && chan->endTime != 1 ) {
|
|
if ( showStartSound ) {
|
|
idLib::Printf( S_COLOR_RED "Already started this frame\n" );
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// kill any sound that is currently playing on this channel
|
|
if ( channel != SCHANNEL_ANY ) {
|
|
for ( int i = 0; i < channels.Num(); i++ ) {
|
|
idSoundChannel * chan = channels[i];
|
|
if ( chan->soundShader && chan->logicalChannel == channel ) {
|
|
if ( showStartSound ) {
|
|
idLib::Printf( S_COLOR_YELLOW "OVERRIDE %s: ", chan->soundShader->GetName() );
|
|
}
|
|
channels.RemoveIndex( i );
|
|
soundWorld->FreeSoundChannel( chan );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
idSoundSample * leadinSample = NULL;
|
|
idSoundSample * loopingSample = NULL;
|
|
|
|
if ( shader->leadin && ( chanParms.soundShaderFlags & SSF_LOOPING ) ) {
|
|
leadinSample = shader->entries[0];
|
|
loopingSample = shader->entries.Num() > 1 ? shader->entries[1] : NULL;
|
|
} else {
|
|
if ( shader->entries.Num() == 1 ) {
|
|
leadinSample = shader->entries[0];
|
|
} else {
|
|
int choice;
|
|
if ( chanParms.soundShaderFlags & SSF_NO_DUPS ) {
|
|
// Don't select the most recently played entry
|
|
int mostRecentTime = 0;
|
|
int mostRecent = 0;
|
|
for ( int i = 0; i < shader->entries.Num(); i++ ) {
|
|
int entryTime = shader->entries[i]->GetLastPlayedTime();
|
|
if ( entryTime > mostRecentTime ) {
|
|
mostRecentTime = entryTime;
|
|
mostRecent = i;
|
|
}
|
|
}
|
|
choice = (int)( diversity * ( shader->entries.Num() - 1 ) );
|
|
if ( choice >= mostRecent ) {
|
|
choice++;
|
|
}
|
|
} else {
|
|
// pick a sound from the list based on the passed diversity
|
|
choice = (int)( diversity * shader->entries.Num() );
|
|
}
|
|
choice = idMath::ClampInt( 0, shader->entries.Num() - 1, choice );
|
|
leadinSample = shader->entries[choice];
|
|
leadinSample->SetLastPlayedTime( soundWorld->GetSoundTime() );
|
|
}
|
|
if ( chanParms.soundShaderFlags & SSF_LOOPING ) {
|
|
loopingSample = leadinSample;
|
|
}
|
|
}
|
|
|
|
// set all the channel parameters here,
|
|
// a hardware voice will be allocated next update if the volume is high enough to be audible
|
|
if ( channels.Num() == channels.Max() ) {
|
|
CheckForCompletion( currentTime ); // as a last chance try to release finished sounds here
|
|
if ( channels.Num() == channels.Max() ) {
|
|
if ( showStartSound ) {
|
|
idLib::Printf( S_COLOR_RED "No free emitter channels!\n" );
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
idSoundChannel * chan = soundWorld->AllocSoundChannel();
|
|
if ( chan == NULL ) {
|
|
if ( showStartSound ) {
|
|
idLib::Printf( S_COLOR_RED "No free global channels!\n" );
|
|
}
|
|
return 0;
|
|
}
|
|
channels.Append( chan );
|
|
chan->emitter = this;
|
|
chan->parms = chanParms;
|
|
chan->soundShader = shader;
|
|
chan->logicalChannel = channel;
|
|
chan->leadinSample = leadinSample;
|
|
chan->loopingSample = loopingSample;
|
|
chan->allowSlow = allowSlow;
|
|
|
|
// return length of sound in milliseconds
|
|
int length = chan->leadinSample->LengthInMsec();
|
|
|
|
// adjust the start time based on diversity for looping sounds, so they don't all start at the same point
|
|
int startOffset = 0;
|
|
|
|
if ( chan->IsLooping() && !shader->leadin ) {
|
|
// looping sounds start at a random point...
|
|
startOffset = soundSystemLocal.random.RandomInt( length );
|
|
}
|
|
|
|
chan->startTime = currentTime - startOffset;
|
|
|
|
if ( ( chanParms.soundShaderFlags & SSF_LOOPING ) != 0 ) {
|
|
// This channel will never end!
|
|
chan->endTime = 0;
|
|
} else {
|
|
// This channel will automatically end at this time
|
|
chan->endTime = chan->startTime + length + 100;
|
|
}
|
|
if ( showStartSound ) {
|
|
if ( loopingSample == NULL || leadinSample == loopingSample ) {
|
|
idLib::Printf( "Playing %s @ %d\n", leadinSample->GetName(), startOffset );
|
|
} else {
|
|
idLib::Printf( "Playing %s then looping %s\n", leadinSample->GetName(), loopingSample->GetName() );
|
|
}
|
|
}
|
|
|
|
return length;
|
|
}
|
|
|
|
|
|
/*
|
|
========================
|
|
idSoundEmitterLocal::OnReloadSound
|
|
|
|
This is a shortened version of StartSound, called whenever a sound shader is reloaded.
|
|
If the emitter is currently playing the given sound shader, restart it so
|
|
a change in the sound sample used for a given sound shader will be picked up.
|
|
========================
|
|
*/
|
|
void idSoundEmitterLocal::OnReloadSound( const idDecl *decl ) {
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundEmitterLocal::StopSound
|
|
|
|
Can pass SCHANNEL_ANY.
|
|
========================
|
|
*/
|
|
void idSoundEmitterLocal::StopSound( const s_channelType channel ) {
|
|
assert( soundWorld != NULL );
|
|
assert( soundWorld->emitters[this->index] == this );
|
|
|
|
if ( soundWorld && soundWorld->writeDemo ) {
|
|
soundWorld->writeDemo->WriteInt( DS_SOUND );
|
|
soundWorld->writeDemo->WriteInt( SCMD_STOP );
|
|
soundWorld->writeDemo->WriteInt( index );
|
|
soundWorld->writeDemo->WriteInt( channel );
|
|
}
|
|
|
|
for( int i = 0; i < channels.Num(); i++ ) {
|
|
idSoundChannel * chan = channels[i];
|
|
|
|
if ( channel != SCHANNEL_ANY && chan->logicalChannel != channel ) {
|
|
continue;
|
|
}
|
|
if ( s_showStartSound.GetBool() ) {
|
|
idLib::Printf( "%dms: StopSound(%d:%d): %s\n", soundWorld->GetSoundTime(), index, channel, chan->soundShader->GetName() );
|
|
}
|
|
|
|
// This forces CheckForCompletion to return true
|
|
chan->endTime = 1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundEmitterLocal::ModifySound
|
|
========================
|
|
*/
|
|
void idSoundEmitterLocal::ModifySound( const s_channelType channel, const soundShaderParms_t *parms ) {
|
|
assert( soundWorld != NULL );
|
|
assert( soundWorld->emitters[this->index] == this );
|
|
|
|
if ( soundWorld && soundWorld->writeDemo ) {
|
|
soundWorld->writeDemo->WriteInt( DS_SOUND );
|
|
soundWorld->writeDemo->WriteInt( SCMD_MODIFY );
|
|
soundWorld->writeDemo->WriteInt( index );
|
|
soundWorld->writeDemo->WriteInt( channel );
|
|
soundWorld->writeDemo->WriteFloat( parms->minDistance );
|
|
soundWorld->writeDemo->WriteFloat( parms->maxDistance );
|
|
soundWorld->writeDemo->WriteFloat( parms->volume );
|
|
soundWorld->writeDemo->WriteFloat( parms->shakes );
|
|
soundWorld->writeDemo->WriteInt( parms->soundShaderFlags );
|
|
soundWorld->writeDemo->WriteInt( parms->soundClass );
|
|
}
|
|
|
|
for ( int i = channels.Num() - 1; i >= 0; i-- ) {
|
|
idSoundChannel * chan = channels[i];
|
|
if ( channel != SCHANNEL_ANY && chan->logicalChannel != channel ) {
|
|
continue;
|
|
}
|
|
if ( s_showStartSound.GetBool() ) {
|
|
idLib::Printf( "%dms: ModifySound(%d:%d): %s\n", soundWorld->GetSoundTime(), index, channel, chan->soundShader->GetName() );
|
|
}
|
|
OverrideParms( &chan->parms, parms, &chan->parms );
|
|
}
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundEmitterLocal::FadeSound
|
|
========================
|
|
*/
|
|
void idSoundEmitterLocal::FadeSound( const s_channelType channel, float to, float over ) {
|
|
assert( soundWorld != NULL );
|
|
assert( soundWorld->emitters[this->index] == this );
|
|
|
|
if ( soundWorld->writeDemo ) {
|
|
soundWorld->writeDemo->WriteInt( DS_SOUND );
|
|
soundWorld->writeDemo->WriteInt( SCMD_FADE );
|
|
soundWorld->writeDemo->WriteInt( index );
|
|
soundWorld->writeDemo->WriteInt( channel );
|
|
soundWorld->writeDemo->WriteFloat( to );
|
|
soundWorld->writeDemo->WriteFloat( over );
|
|
}
|
|
|
|
int overMSec = SEC2MS( over );
|
|
|
|
for ( int i = 0; i < channels.Num(); i++ ) {
|
|
idSoundChannel * chan = channels[i];
|
|
|
|
if ( channel != SCHANNEL_ANY && chan->logicalChannel != channel ) {
|
|
continue;
|
|
}
|
|
if ( s_showStartSound.GetBool() ) {
|
|
idLib::Printf( "%dms: FadeSound(%d:%d): %s to %.2fdb over %.2f seconds\n", soundWorld->GetSoundTime(), index, channel, chan->soundShader->GetName(), to, over );
|
|
}
|
|
|
|
// fade it
|
|
chan->volumeFade.Fade( to - chan->parms.volume, overMSec, soundWorld->GetSoundTime() );
|
|
}
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundEmitterLocal::CurrentlyPlaying
|
|
========================
|
|
*/
|
|
bool idSoundEmitterLocal::CurrentlyPlaying( const s_channelType channel ) const {
|
|
|
|
if ( channel == SCHANNEL_ANY ) {
|
|
return ( channels.Num() > 0 );
|
|
}
|
|
|
|
for ( int i = 0; i < channels.Num(); ++i ) {
|
|
if ( channels[i] != NULL && channels[i]->logicalChannel == channel ) {
|
|
if ( channels[i]->endTime == 1 ) {
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSoundEmitterLocal::CurrentAmplitude
|
|
========================
|
|
*/
|
|
float idSoundEmitterLocal::CurrentAmplitude() {
|
|
float amplitude = 0.0f;
|
|
int currentTime = soundWorld->GetSoundTime();
|
|
for ( int i = 0; i < channels.Num(); i++ ) {
|
|
idSoundChannel * chan = channels[i];
|
|
if ( chan == NULL || currentTime < chan->startTime || ( chan->endTime > 0 && currentTime >= chan->endTime ) ) {
|
|
continue;
|
|
}
|
|
int relativeTime = currentTime - chan->startTime;
|
|
int leadinLength = chan->leadinSample->LengthInMsec();
|
|
if ( relativeTime < leadinLength ) {
|
|
amplitude = Max( amplitude, chan->leadinSample->GetAmplitude( relativeTime ) );
|
|
} else if ( chan->loopingSample != NULL ) {
|
|
amplitude = Max( amplitude, chan->loopingSample->GetAmplitude( ( relativeTime - leadinLength ) % chan->loopingSample->LengthInMsec() ) );
|
|
}
|
|
}
|
|
return amplitude;
|
|
}
|