OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
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.
357 Commits
80 Branches
23 Tags
172 MiB
Tree: eb2767a5f7
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'eb2767a5f7'
${ noResults }
CWE-ou-minkata/Sources/Plasma/PubUtilLib/plAudio/plSound.cpp

1545 lines
46 KiB
Raw Normal View History Unescape

Fix line endings and tabs
14 years ago
/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Open source re-licensing
13 years ago
Additional permissions under GNU GPL version 3 section 7
If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.
Fix line endings and tabs
14 years ago
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
#include "hsTypes.h"
#include "hsUtils.h"
#include "hsResMgr.h"
#include "hsTimer.h"
#include "hsGeometry3.h"
#include "hsColorRGBA.h"
#include "plProfile.h"
#include "plgDispatch.h"
#include "plAudioSystem.h"
#include "plSound.h"
#include "plWin32Sound.h"
#include "plAudioCore/plSoundBuffer.h"
#include "plDrawable/plDrawableGenerator.h"
#include "pnMessage/plRefMsg.h"
#include "pnMessage/plTimeMsg.h"
#include "pnMessage/plAudioSysMsg.h"
#include "pnMessage/plSoundMsg.h"
#include "plMessage/plListenerMsg.h"
#include "plIntersect/plSoftVolume.h"
#include "plStatusLog/plStatusLog.h"
#include "plPipeline/plPlates.h"
#include "pnKeyedObject/plKey.h"
#include "pnNetCommon/plSDLTypes.h"
#include "plAvatar/plScalarChannel.h"
#include "plAvatar/plAGModifier.h"
#include "pnSceneObject/plSceneObject.h"
#include "pnSceneObject/plAudioInterface.h"
plProfile_CreateCounterNoReset( "Loaded", "Sound", SoundNumLoaded );
plProfile_CreateCounterNoReset( "Waiting to Die", "Sound", WaitingToDie );
plProfile_CreateAsynchTimer( "Sound Load Time", "Sound", SoundLoadTime );
plGraphPlate *plSound::fDebugPlate = nil;
plSound *plSound::fCurrDebugPlateSound = nil;
hsBool plSound::fLoadOnDemandFlag = true;
hsBool plSound::fLoadFromDiskOnDemand = true;
unsigned plSound::fIncidentalsPlaying = 0;
plSound::plSound() :
fPlaying(false),
fActive(false),
fTime(0),
fMaxFalloff(0),
fMinFalloff(0),
fCurrVolume(0.f),
fOuterVol(0),
fOuterCone(360),
fInnerCone(360),
fLength(0.0f),
fDesiredVol(0.f),
fFading(false),
fRegisteredForTime(false),
fMuted(true),
fFadedVolume(0.f),
fSoftRegion(nil),
fSoftOcclusionRegion(nil),
fSoftVolume(0.f),
fCurrFadeParams(nil),
fRegistered(false),
fDistAttenuation(0.f),
fProperties(0),
fNotHighEnoughPriority(false),
fVirtualStartTime(0),
fOwningSceneObject(nil),
fPriority(0),
fType(plSound::kSoundFX),
fQueued(false),
fLoading(false),
fSynchedStartTimeSec(0),
fMaxVolume(0),
fFreeData(false)
{
plProfile_Inc( SoundNumLoaded );
f3DPosition.Set( 0.f, 0.f, 0.f );
f3DVelocity.Set( 0.f, 0.f, 0.f );
fDataBuffer = nil;
fDataBufferKey = nil;
fPlayOnReactivate = false;
fDataBufferLoaded = false;
}
plSound::~plSound()
{
IStopFade( true );
plProfile_Dec( SoundNumLoaded );
}
void plSound::IPrintDbgMessage( const char *msg, hsBool isError )
{
static plStatusLog *ourLog = nil;
// Print to our log file (create it if necessary)
if( ourLog == nil )
{
// ourLog = plStatusLogMgr::GetInstance().CreateStatusLog( 15,
// "audio.log", plStatusLog::kFilledBackground | plStatusLog::kDeleteForMe | plStatusLog::kAlignToTop );
}
if( isError )
// ourLog->AddLineF( plStatusLog::kRed, "ERROR: %s (%s)", msg, GetKey() ? GetKeyName() : "unkeyed" );
ourLog->AddLineS( "audio.log", plStatusLog::kRed, "ERROR: %s (%s)", msg, GetKey() ? GetKeyName() : "unkeyed" );
else
// ourLog->AddLineF( "%s (%s)", msg, GetKey() ? GetKeyName() : "unkeyed" );
ourLog->AddLineS( "audio.log", "%s (%s)", msg, GetKey() ? GetKeyName() : "unkeyed" );
}
///////////////////////////////////////////////////////////
// Called to send more values to the debug plate, assuming this is the right
// sound. Should be called every time any of the values change, which means
// the best place is inside ISetActualVolume(). Since that's a pure virtual,
// it makes the placement of the call a bit annoying, but oh well.
void plSound::IUpdateDebugPlate( void )
{
if( this == fCurrDebugPlateSound )
{
if( fDebugPlate == nil )
{
plPlateManager::Instance().CreateGraphPlate( &fDebugPlate );
fDebugPlate->SetSize( 0.50, 0.25 );
fDebugPlate->SetPosition( -0.5, 0 );
fDebugPlate->SetDataRange( 0, 100, 100 );
fDebugPlate->SetColors( 0x80202000 );
fDebugPlate->SetTitle( (char *)GetKeyName() ); // Bleah
fDebugPlate->SetLabelText( "Desired", "Curr", "Soft", "Dist" );
}
fDebugPlate->SetVisible( true );
fDebugPlate->AddData( (Int32)( fDesiredVol * 100.f ),
(Int32)( fCurrVolume * 100.f ),
(Int32)( fSoftVolume * 100.f ),
(Int32)( fDistAttenuation * 100.f ) );
}
}
void plSound::SetCurrDebugPlate( const plKey soundKey )
{
if( soundKey == nil )
{
fCurrDebugPlateSound = nil;
if( fDebugPlate != nil )
fDebugPlate->SetVisible( false );
}
else
{
fCurrDebugPlateSound = plSound::ConvertNoRef( soundKey->GetObjectPtr() );
if( fDebugPlate != nil )
{
fDebugPlate->ClearData();
fDebugPlate->SetVisible( true );
fDebugPlate->SetTitle( (char *)fCurrDebugPlateSound->GetKeyName() ); // Bleah
}
}
}
/////////////////////////////////////////////////////////////////////
// We don't keep track of the current time we should be at, but rather the
// time we started at. Since we're calling SetTime(), we should adjust the
// start time to be accurate for the time we want to be at now. Note: we
// don't actually move the buffer position unless it's loaded, since we
// don't want to force a load on a buffer just from a SetTime() call.
void plSound::SetTime( double t )
{
fVirtualStartTime = hsTimer::GetSysSeconds() - t;
if( IActuallyLoaded() )
ISetActualTime( t );
}
// Support for Fast forward responder
void plSound::FastForwardPlay()
{
if(fProperties & kPropLooping)
{
Play();
}
}
void plSound::FastForwardToggle()
{
if(fPlaying == true)
{
Stop();
return;
}
FastForwardPlay();
}
////////////////////////////////////////////////////////////////////////
// Our basic play function. Marks the sound as playing, and if we're actually
// allowed to play, will actually start the sound playing as well.
void plSound::Play()
{
if(fLoading) // if we are loading there is no reason to do this. Play will be called, by Update(), once the data is loaded and this floag is set to false
return;
if( !fActive )
{
// We're not active, so we can't play, but mark to make sure we'll play once we do get activated
fPlayOnReactivate = true;
return;
}
fPlaying = true;
if(IPreLoadBuffer(true) == plSoundBuffer::kPending)
{
return;
}
fVirtualStartTime = hsTimer::GetSysSeconds(); // When we "started", even if we really don't start
// if the sound system is not active do a fake play so callbacks get sent
if(!plgAudioSys::Active())
{
// Do the (fake) actual play
IActuallyPlay();
}
if( IWillBeAbleToPlay() )
{
IRefreshParams();
if( fFadeInParams.fLengthInSecs > 0 )
{
IStartFade( &fFadeInParams);
}
else
{
// we're NOT fading!!!!
if( fFading )
IStopFade();
SetVolume( fDesiredVol );
}
// Do the actual play
IActuallyPlay();
}
}
void plSound::SynchedPlay(unsigned bytes )
{
if( fFading )
IStopFade();
if(fLoading) // the sound is loading, it will be played when loading is finished
return;
if( !fActive )
{
// We're not active, so we can't play, but mark to make sure we'll play once we do get activated
fPlayOnReactivate = true;
return;
}
// Mark as playing, since we'll be calling ITryPlay() directly
fPlaying = true;
fPlayOnReactivate = false;
if( IWillBeAbleToPlay() )
{
SetStartPos(bytes);
Play();
}
}
/////////////////////////////////////////////////////////////////
// Used for synching play state. The state only knows that we're playing
// and what time we started at, so we use that to compute what time we should
// be at and update. Note that we also set our virtual start time to what
// we're given, NOT the current time, 'cause, well, duh, that should be our
// start time!
// So think of it as "Play() but act as if you started at *this* time"...
void plSound::SynchedPlay( hsScalar virtualStartTime )
{
if( fFading )
IStopFade();
ISynchedPlay( virtualStartTime );
}
////////////////////////////////////////////////////////////////
// Only want to do the fade hack when somebody outside synch()s us.
void plSound::ISynchedPlay( double virtualStartTime )
{
if(fLoading) // the sound is loading, it will be played when loading is finished
return;
// Store our start time
fVirtualStartTime = virtualStartTime;
if( !fActive )
{
// We're not active, so we can't play, but mark to make sure we'll play once we do get activated
fPlayOnReactivate = true;
return;
}
// Mark as playing, since we'll be calling ITryPlay() directly
fPlaying = true;
fPlayOnReactivate = false;
// Do da synch, which will start us playing
if( IWillBeAbleToPlay() )
{
ISynchToStartTime();
}
}
///////////////////////////////////////////////////////////
// Takes the virtual start time and sets us to the real time we should be at,
// then starts us playing via ITryPlay().
void plSound::ISynchToStartTime( void )
{
if( !plgAudioSys::Active() )
return;
// We don't want to do this until we're actually loaded, since that's when we'll know our
// REAL length (thanks to the inaccuracies of WMA compression)
// LoadSound( IsPropertySet( kPropIs3DSound ) );
// Haha, the GetLength() call will do this for us
// Calculate what time we should be at
double deltaTime = hsTimer::GetSysSeconds() - fVirtualStartTime;
double length = GetLength();
if( deltaTime > length || deltaTime < 0 )
{
// Hmm, our time went past the length of sound, so handle that
if( IsPropertySet( kPropLooping ) )
{
if( length <= 0 )
deltaTime = 0; // Error, attempt to recover
else if( deltaTime < 0 )
{
int numWholeParts = (int)( -deltaTime / length );
deltaTime += length * ( numWholeParts + 1 );
}
else
{
int numWholeParts = (int)( deltaTime / length );
deltaTime -= length * (double)numWholeParts;
}
//ISetActualTime( deltaTime );
Play();
}
else
// We already played and stopped virtually, so really mark us as stopped
Stop();
}
else
{
// Easy 'nuf...
//ISetActualTime( deltaTime );
Play();
}
}
void plSound::SetPosition(const hsPoint3 pos)
{
f3DPosition = pos;
}
void plSound::SetVelocity(const hsVector3 vel)
{
f3DVelocity = vel;
}
hsPoint3 plSound::GetPosition( void ) const
{
return f3DPosition;
}
hsVector3 plSound::GetVelocity( void ) const
{
return f3DVelocity;
}
void plSound::SetMin(const int m)
{
fMinFalloff = m;
}
void plSound::SetMax(const int m)
{
fMaxFalloff = m;
}
void plSound::SetOuterVolume(const int v)
{
fOuterVol = v;
}
void plSound::SetConeOrientation( hsScalar x, hsScalar y, hsScalar z )
{
fConeOrientation.Set( x, y, z );
}
void plSound::SetConeAngles( int inner, int outer )
{
fOuterCone = outer;
fInnerCone = inner;
}
int plSound::GetMin() const
{
return fMinFalloff;
}
int plSound::GetMax() const
{
return fMaxFalloff;
}
void plSound::SetVolume(const float v)
{
fDesiredVol = v;
if( !fMuted && !fFading )
fCurrVolume = fDesiredVol;
RefreshVolume();
}
void plSound::RefreshVolume( void )
{
this->ISetActualVolume( fCurrVolume );
}
void plSound::SetMuted( hsBool muted )
{
if( muted != fMuted )
{
fMuted = muted;
if( fMuted )
fCurrVolume = 0.f;
else if( !fFading )
fCurrVolume = fDesiredVol;
RefreshVolume();
}
}
void plSound::IRefreshParams( void )
{
SetMax( fMaxFalloff );
SetMin( fMinFalloff );
SetOuterVolume( fOuterVol );
SetConeAngles( fInnerCone, fOuterCone );
SetConeOrientation( fConeOrientation.fX, fConeOrientation.fY, fConeOrientation.fZ);
SetPosition( f3DPosition );
SetVelocity( f3DVelocity );
}
////////////////////////////////////////////////////////////////////////
// The public interface to stopping, which also synchs the state with the
// server.
void plSound::Stop( void )
{
fPlaying = false;
// if the audio data is loading while stop is called we need to make sure the sounds doesn't play, and the data is unloaded.
fPlayOnReactivate = false;
fFreeData = true;
// Do we have an ending fade?
if( fFadeOutParams.fLengthInSecs > 0 && !plgAudioSys::IsRestarting() )
{
IStartFade( &fFadeOutParams );
}
else
{
if( fFading )
IStopFade();
fCurrVolume = 0.f;
ISetActualVolume( fCurrVolume );
IActuallyStop();
}
if(fPlayWhenLoaded)
{
fPlayWhenLoaded = false;
}
}
void plSound::IActuallyStop( void )
{
if( fLoadOnDemandFlag && !IsPropertySet( kPropDisableLOD ) && !IsPropertySet( kPropLoadOnlyOnCall ) )
{
// If we're loading on demand, we want to unload on stop
IFreeBuffers();
}
}
void plSound::Update()
{
if(fLoading)
{
plSoundBuffer::ELoadReturnVal retVal = IPreLoadBuffer(fPlayWhenLoaded);
if(retVal == plSoundBuffer::kError)
{
fLoading = false;
fPlayWhenLoaded = false;
}
if(retVal == plSoundBuffer::kSuccess)
{
fLoading = false;
if(fPlayWhenLoaded)
Play();
fPlayWhenLoaded = false;
// ensure the sound data is released if the sound object was stopped while the audio data was being loaded.
if(fFreeData)
{
fFreeData = false;
FreeSoundData();
}
}
}
}
hsScalar plSound::IGetChannelVolume( void ) const
{
hsScalar channelVol = plgAudioSys::GetChannelVolume( (plgAudioSys::ASChannel)fType );
// if not using hardware acceleration then apply 2D/3D bias to non 3D sounds
if( !plgAudioSys::Hardware() && !IsPropertySet( kPropIs3DSound ) )
channelVol *= plgAudioSys::Get2D3Dbias();
if( IsPropertySet( kPropDontFade ) )
return channelVol;
return channelVol * plgAudioSys::GetGlobalFadeVolume();
}
void plSound::IStartFade( plFadeParams *params, hsScalar offsetIntoFade )
{
fFading = true;
if( params == &fFadeOutParams )
{
fFadeOutParams.fVolStart = fCurrVolume;
fFadeOutParams.fVolEnd = fFadedVolume;
fCurrFadeParams = &fFadeOutParams;
}
else if( params == &fFadeInParams )
{
fFadeInParams.fVolStart = fCurrVolume; // Hopefully, we got to fFadedVolume, but maybe not
fFadeInParams.fVolEnd = fDesiredVol;
fCurrFadeParams = &fFadeInParams;
plStatusLog::AddLineS("audio.log", "Fading in %s", GetKeyName());
}
else
fCurrFadeParams = params;
fCurrFadeParams->fCurrTime = offsetIntoFade;
ISetActualVolume( fCurrFadeParams->InterpValue() );
if( !fRegisteredForTime )
{
plgDispatch::Dispatch()->RegisterForExactType( plTimeMsg::Index(), GetKey() );
fRegisteredForTime = true;
}
}
void plSound::IStopFade( hsBool shuttingDown, hsBool SetVolEnd)
{
if( fCurrFadeParams != nil )
{
if( fCurrFadeParams == &fCoolSoftVolumeTrickParams )
{
plProfile_Dec( WaitingToDie );
}
// This can cause problems if we've exited a soft region and are doing a soft volume fade.
// If the camera pops back into the region of this particular sound this will cause the soft volume to be zero,
// therefore not allowing the sound to play until the listener moves again(triggering another softsound update).
// So if this function is called from UpdateSoftSounds this will not be performed
if(SetVolEnd)
{
if( fCurrFadeParams->fFadeSoftVol )
fSoftVolume = fCurrFadeParams->fVolEnd;
else
fCurrVolume = fCurrFadeParams->fVolEnd;
}
if( !shuttingDown )
ISetActualVolume( fCurrVolume );
fCurrFadeParams->fCurrTime = -1.f;
}
fFading = false;
fCurrFadeParams = nil;
// Fade done, unregister for time message
if( fRegisteredForTime )
{
plgDispatch::Dispatch()->UnRegisterForExactType( plTimeMsg::Index(), GetKey() );
fRegisteredForTime = false;
}
}
hsBool plSound::MsgReceive( plMessage* pMsg )
{
plTimeMsg *time = plTimeMsg::ConvertNoRef( pMsg );
if( time != nil )
{
/// Time message for handling fade ins/outs
if( fCurrFadeParams == nil )
return true;
fCurrFadeParams->fCurrTime += time->DelSeconds();
if( fCurrFadeParams->fCurrTime >= fCurrFadeParams->fLengthInSecs )
{
if( fCurrFadeParams->fFadeSoftVol )
fSoftVolume = fCurrFadeParams->fVolEnd;
else
fCurrVolume = fCurrFadeParams->fVolEnd;
ISetActualVolume( fCurrVolume );
fCurrFadeParams->fCurrTime = -1.f;
// Fade done, unregister for time message
if( fRegisteredForTime )
{
plgDispatch::Dispatch()->UnRegisterForExactType( plTimeMsg::Index(), GetKey() );
fRegisteredForTime = false;
}
// Note: if we're done, and we were fading out, we need to STOP
if( fCurrFadeParams->fStopWhenDone )
{
// REALLY STOP
IActuallyStop();
}
if( fCurrFadeParams == &fCoolSoftVolumeTrickParams )
{
plProfile_Dec( WaitingToDie );
}
// Done with this one!
fCurrFadeParams = nil;
fFading = false;
}
else
{
// Gotta interp
if( fCurrFadeParams->fFadeSoftVol )
fSoftVolume = fCurrFadeParams->InterpValue();
else
fCurrVolume = fCurrFadeParams->InterpValue();
ISetActualVolume( fCurrVolume );
}
return true;
}
plGenRefMsg* refMsg = plGenRefMsg::ConvertNoRef( pMsg );
if( refMsg )
{
if( refMsg->fType == kRefSoftVolume )
{
if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
{
ISetSoftRegion( plSoftVolume::ConvertNoRef(refMsg->GetRef()) );
return true;
}
else if( refMsg->GetContext() & (plRefMsg::kOnRemove | plRefMsg::kOnDestroy) )
{
ISetSoftRegion( nil );
return true;
}
}
else if( refMsg->fType == kRefSoftOcclusionRegion )
{
if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
{
ISetSoftOcclusionRegion( plSoftVolume::ConvertNoRef( refMsg->GetRef() ) );
return true;
}
else if( refMsg->GetContext() & (plRefMsg::kOnRemove | plRefMsg::kOnDestroy) )
{
ISetSoftOcclusionRegion( nil );
return true;
}
}
else if( refMsg->fType == kRefDataBuffer )
{
if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
{
fDataBuffer = plSoundBuffer::ConvertNoRef( refMsg->GetRef() );
SetLength( fDataBuffer->GetDataLengthInSecs() );
}
else
fDataBuffer = nil;
return true;
}
else if( refMsg->fType == kRefParentSceneObject )
{
if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
fOwningSceneObject = plSceneObject::ConvertNoRef( refMsg->GetRef() );
else
fOwningSceneObject = nil;
return true;
}
}
plSoundMsg *pSoundMsg = plSoundMsg::ConvertNoRef( pMsg );
if( pSoundMsg != nil )
{
if( pSoundMsg->Cmd( plSoundMsg::kAddCallbacks ) )
{
AddCallbacks( pSoundMsg );
return true;
}
else if( pSoundMsg->Cmd( plSoundMsg::kRemoveCallbacks ) )
{
RemoveCallbacks( pSoundMsg );
return true;
}
return false;
}
plListenerMsg *listenMsg = plListenerMsg::ConvertNoRef( pMsg );
if( listenMsg != nil )
{
if( fSoftOcclusionRegion != nil )
{
// The EAX settings have 0 as the start value and 1 as the end, and since start
// translates to "inside the soft region", it's reversed of what the region gives us
fEAXSettings.SetOcclusionSoftValue( 1.f - fSoftOcclusionRegion->GetListenerStrength() );
IRefreshEAXSettings();
}
return true;
}
return plSynchedObject::MsgReceive( pMsg );
}
void plSound::ForceLoad()
{
if( !IsPropertySet( kPropLoadOnlyOnCall ) )
return;
LoadSound( IsPropertySet( kPropIs3DSound ) );
}
void plSound::ForceUnload( void )
{
if( !IsPropertySet( kPropLoadOnlyOnCall ) )
return;
Stop();
IFreeBuffers();
}
bool plSound::ILoadDataBuffer( void )
{
if(!fDataBufferLoaded)
{
plSoundBuffer *buffer = (plSoundBuffer *)fDataBufferKey->RefObject();
if(!buffer)
{
hsAssert(false, "unable to load sound buffer");
plStatusLog::AddLineS("audio.log", "Unable to load sound buffer: %s", GetKeyName());
return false;
}
SetLength( buffer->GetDataLengthInSecs() );
fDataBufferLoaded = true;
}
return true;
}
void plSound::FreeSoundData()
{
if(!fDataBufferKey) return; // for plugins
plSoundBuffer *buffer = (plSoundBuffer *) fDataBufferKey->ObjectIsLoaded();
if(buffer)
{
buffer->UnLoad();
}
}
void plSound::IUnloadDataBuffer( void )
{
if(fDataBufferLoaded)
{
fDataBufferLoaded = false;
fDataBufferKey->UnRefObject();
}
}
/////////////////////////////////////////////////////////////////////////
// calling preload will cause the sound to play once loaded
plSoundBuffer::ELoadReturnVal plSound::IPreLoadBuffer( hsBool playWhenLoaded, hsBool isIncidental /* = false */ )
{
if(!ILoadDataBuffer())
{
return plSoundBuffer::kError;
}
plSoundBuffer *buffer = (plSoundBuffer *)fDataBufferKey->ObjectIsLoaded();
if(buffer && buffer->IsValid() )
{
plProfile_BeginTiming( SoundLoadTime );
plSoundBuffer::ELoadReturnVal retVal = buffer->AsyncLoad(buffer->HasFlag(plSoundBuffer::kStreamCompressed) ? plAudioFileReader::kStreamNative : plAudioFileReader::kStreamWAV);
if(retVal == plSoundBuffer::kPending)
{
fPlayWhenLoaded = playWhenLoaded;
fLoading = true;
}
plProfile_EndTiming( SoundLoadTime );
return retVal;
}
else
{
return plSoundBuffer::kError;
}
}
const char *plSound::GetFileName( void ) const
{
if(fDataBufferKey->ObjectIsLoaded())
{
return ((plSoundBuffer *)fDataBufferKey->ObjectIsLoaded())->GetFileName();
}
return nil;
}
/////////////////////////////////////////////////////////////////////////
// WARNING: to do this right, we have to load the data buffer in, which could
// force an early load of the sound if you're just calling this on a whim. So
// it's best to call this right before you're going to load it anyway (or
// when it's already loaded).
// Note that if we already set the length (like at export time), we never need
// to load the sound, so the optimization at export time is all ready to plug-
// and-play...
double plSound::GetLength( void )
{
if( ( (double)fLength == 0.f ) )
ILoadDataBuffer();
return fLength;
}
void plSound::ISetSoftRegion( plSoftVolume *region )
{
/// We're either registering or unregistering
if( fSoftRegion == nil && region != nil )
RegisterOnAudioSys();
else if( fSoftRegion != nil && region == nil )
UnregisterOnAudioSys();
fSoftRegion = region;
fSoftVolume = 0.f; // Set to zero until we can get our processing call
}
void plSound::ISetSoftOcclusionRegion( plSoftVolume *region )
{
/// We're either registering or unregistering for listener messages
if( fSoftOcclusionRegion == nil && region != nil )
{
plgDispatch::Dispatch()->RegisterForExactType( plListenerMsg::Index(), GetKey() );
}
else if( fSoftOcclusionRegion != nil && region == nil )
{
plgDispatch::Dispatch()->UnRegisterForExactType( plListenerMsg::Index(), GetKey() );
}
fSoftOcclusionRegion = region;
}
/////////////////////////////////////////////////////////////////////////
// This function calculates our new softVolume value. Used both to update the
// said value and so the audio system can rank us in importance.
hsScalar plSound::CalcSoftVolume( hsBool enable, hsScalar distToListenerSquared )
{
// Do distance-based attenuation ourselves
#if MCN_HACK_OUR_ATTEN
if( IsPropertySet( kPropIs3DSound ) )
{
hsScalar minDist = (hsScalar)GetMin();
if( distToListenerSquared <= minDist * minDist )
{
fDistAttenuation = 1.f;
}
else
{
hsScalar maxDist = (hsScalar)GetMax();
if( distToListenerSquared >= maxDist * maxDist )
{
fDistAttenuation = 0.f;
}
else
{
hsScalar d = (hsScalar)sqrt( distToListenerSquared );
fDistAttenuation = minDist / d;
// The following line ramps it to 0 at the maxDistance. Kinda klunky, but good for now I guess...
// fDistAttenuation *= 1.f - ( 1.f / ( maxDist - minDist ) ) * ( d - minDist );
}
}
}
else
fDistAttenuation = 1.f;
#endif
// At the last 50% of our distance attenuation (squared, so it really is farther than that),
// ramp down to 0 so we don't get annoying popping when we stop stuff
if( IsPropertySet( kPropIs3DSound ) )
{
hsScalar maxDistSquared = (hsScalar)( GetMax() * GetMax() );
hsScalar distToStartSquared = (hsScalar)(maxDistSquared * 0.50);
if( maxDistSquared < 0.f ) // Happens when the max distance is REALLY big
{
maxDistSquared = distToListenerSquared + 1.f; // :)
distToStartSquared = maxDistSquared;
}
if( distToListenerSquared > maxDistSquared )
fDistAttenuation = 0.f;
else if( distToListenerSquared > distToStartSquared )
fDistAttenuation = ( maxDistSquared - distToListenerSquared ) / ( maxDistSquared - distToStartSquared );
else
fDistAttenuation = 1.f;
fDistToListenerSquared = distToListenerSquared;
}
else
{
fDistAttenuation = 1.f;
fDistToListenerSquared = 0.f;
}
// Attenuate based on our soft region, if we have one
if( !enable )
// We apparently don't know jack. Let the audioSystem's decision rule
fSoftVolume = 0.f;
else if( fSoftRegion != nil )
fSoftVolume = fSoftRegion->GetListenerStrength();
else
fSoftVolume = 1.f;
return fSoftVolume;
}
/////////////////////////////////////////////////////////////////////////
// Wee function for the audio system. This basically returns the effective
// current volume of this sound. Useful for doing things like ranking all
// sounds based on volume.
hsScalar plSound::GetVolumeRank( void )
{
if( !IsPlaying() && !this->IActuallyPlaying() )
return 0.f;
hsScalar rank = fSoftVolume * fDesiredVol;
if( IsPropertySet( kPropIs3DSound ) )
{
hsScalar minDistSquared = (hsScalar)( GetMin() * GetMin() );
hsScalar maxDistSquared = (hsScalar) (GetMax() * GetMax());
hsPoint3 listenerPos = plgAudioSys::Sys()->GetCurrListenerPos();
if( fDistToListenerSquared > minDistSquared )
{
hsScalar diff = maxDistSquared - minDistSquared;
rank *= fabs((fDistToListenerSquared - maxDistSquared)) / diff;
}
}
return rank;
}
/////////////////////////////////////////////////////////////////////////
// Tests to see whether, if we try to play this sound now, it'll actually
// be able to play. Takes into account whether the sound is within range
// of the listener and the current soft region value.
hsBool plSound::IWillBeAbleToPlay( void )
{
if( fSoftVolume == 0.f )
return false;
return IsWithinRange( plgAudioSys::Sys()->GetCurrListenerPos(), nil );
}
/////////////////////////////////////////////////////////////////////////
// Tests to see whether this sound is within range of the position given,
// ignoring soft volumes.
hsBool plSound::IsWithinRange( const hsPoint3 &listenerPos, hsScalar *distSquared )
{
if( !IsPropertySet( plSound::kPropIs3DSound ) )
{
if( distSquared != nil )
*distSquared = 1.f;
return true;
}
hsVector3 distance;
hsPoint3 soundPos = GetPosition();
distance.Set( &listenerPos, &soundPos );
if( distSquared != nil )
*distSquared = distance.MagnitudeSquared();
if( GetMax() == 1000000000 )
return true;
hsScalar soundRadius = (hsScalar)( GetMax() * GetMax() );
return ( distance.MagnitudeSquared() <= soundRadius ) ? true : false;
}
//// ////////////////////////////////////////////////////////
// Once the soft volume is calculated and our rank is computed, we can
// decide whether to actually enable or not.
// Note: we might have been "enabled" by our Calc call, but the ranking
// still could have disabled us, so we have to specify again whether
// we're enabled.
// Note: if we KNOW we're disabling this sound (out of range), Calc() doesn't
// have to be called at all, and we can simply call this function with
// enable = false.
void plSound::UpdateSoftVolume( hsBool enable, hsBool firstTime )
{
fNotHighEnoughPriority = !enable;
// Don't do any of this special stuff that follows if we're not supposed to be playing
if( IsPlaying() )
{
if( fSoftVolume * fDistAttenuation > 0.f && !fNotHighEnoughPriority )
{
if( fCurrFadeParams == &fCoolSoftVolumeTrickParams )
{
// Stop the fade, but since we are updating the softvolume with the intention of being audible
// tell StopFade not to set the soft volume to zero.
IStopFade(false, false);
}
if( !IActuallyPlaying() )
{
// Must've been stopped from being out of range. Start up again...
// Synch up to our start time.
// If this sound is auto starting and is background music, get the current time so we don't start
// with the play cursor already into the piece.
if(IsPropertySet(kPropAutoStart) && fType == kBackgroundMusic) fVirtualStartTime = hsTimer::GetSysSeconds();
ISynchedPlay( fVirtualStartTime );
}
}
else if( fCurrFadeParams != &fCoolSoftVolumeTrickParams && IActuallyPlaying() )
{
// Start our special trick, courtesy of Brice. Basically, we don't
// stop the sound immediately, but rather let it get to the end of
// the sound and loop once more. This way, if we go away and come back soon
// enough, it will be continuing as we expect it to, but if we wait long enough,
// it'll stop, saving processing time.
// Note: we just do it as a fade because it makes it easier on us that way!
fCoolSoftVolumeTrickParams.fCurrTime = 0.f;
fCoolSoftVolumeTrickParams.fLengthInSecs = firstTime ? 0.f : (hsScalar)fLength + ( (hsScalar)fLength - (hsScalar)GetTime() );
fCoolSoftVolumeTrickParams.fStopWhenDone = true;
fCoolSoftVolumeTrickParams.fFadeSoftVol = true;
fCoolSoftVolumeTrickParams.fType = plFadeParams::kLinear;
fCoolSoftVolumeTrickParams.fVolStart = fSoftVolume; // Don't actually change the volume this way
fCoolSoftVolumeTrickParams.fVolEnd = 0.f;
IStartFade( &fCoolSoftVolumeTrickParams );
plProfile_Inc( WaitingToDie );
}
}
RefreshVolume();
}
/////////////////////////////////////////////////////////////////////////
// Returns the current volume, attenuated
hsScalar plSound::QueryCurrVolume( void ) const
{
return IAttenuateActualVolume( fCurrVolume ) * IGetChannelVolume();
}
/////////////////////////////////////////////////////////////////////////
// Used by ISetActualVolume(). Does the final attenuation on a volume before
// sending it to the sound processing. Only does soft regions for now.
hsScalar plSound::IAttenuateActualVolume( hsScalar volume ) const
{
if( fNotHighEnoughPriority )
return 0.f;
volume *= fSoftVolume;
if( IsPropertySet( kPropIs3DSound ) )
volume *= fDistAttenuation;
return volume;
}
void plSound::Activate(hsBool forcePlay)
{
// Our actual state...
fActive = true;
// re-create the sound state here:
if( forcePlay || fPlayOnReactivate )
{
ISynchedPlay( hsTimer::GetSysSeconds() );
fPlayOnReactivate = false;
}
RegisterOnAudioSys();
SetMuted(plgAudioSys::IsMuted());
}
void plSound::DeActivate( void )
{
UnregisterOnAudioSys();
if( fActive )
{
if( IsPlaying() )
{
Stop();
fPlayOnReactivate = true;
}
else
fPlayOnReactivate = false;
}
fActive = false;
}
/////////////////////////////////////////////////////////////////////////
// Tell the audio system about ourselves.
void plSound::RegisterOnAudioSys( void )
{
if( !fRegistered )
{
plgAudioSys::RegisterSoftSound(GetKey());
fRegistered = true;
}
}
/////////////////////////////////////////////////////////////////////////
// Tell the audio system to stop caring about us
void plSound::UnregisterOnAudioSys( void )
{
if( fRegistered )
{
plgAudioSys::UnregisterSoftSound(GetKey());
fRegistered = false;
}
}
/////////////////////////////////////////////////////////////////////////
// Called by the audio system when we've been booted off (audio system is
// shutting down). Normally, we should already be shut down, but in case
// we're not, this function makes sure everything is cleaned up before
// the audio system itself shuts down.
void plSound::ForceUnregisterFromAudioSys( void )
{
DeActivate();
fRegistered = false;
}
void plSound::Read(hsStream* s, hsResMgr* mgr)
{
plSynchedObject::Read(s, mgr);
IRead( s, mgr );
// If we're autostart, start playing
if( IsPropertySet( kPropAutoStart ) )
Play();
// Make sure we synch or don't synch
if( IsPropertySet( kPropLocalOnly ) )
SetLocalOnly(true);
// If we're not playing, but we're going to, and we're going to fade in,
// then our current state is faded out, so set fFading
if( fFadeInParams.fLengthInSecs > 0 && !fPlaying )
fFading = true;
else if( fFadeInParams.fLengthInSecs <= 0 && !fPlaying )
fFading = false;
ILoadDataBuffer(); // make sure our sound buffer is loaded
// Force load on read
if( !fLoadOnDemandFlag || IsPropertySet( kPropDisableLOD ) )
{
LoadSound( IsPropertySet( kPropIs3DSound ) );
}
else
{
// Loading on demand, but we still need the length. But that's ok, we'll get it when we get the fDataBuffer ref.
// But we want to preload the data, so go ahead and do that
if( !fLoadFromDiskOnDemand && !IsPropertySet( kPropLoadOnlyOnCall ) && fPriority <= plgAudioSys::GetPriorityCutoff())
{
IPreLoadBuffer(false);
}
}
}
void plSound::Write(hsStream* s, hsResMgr* mgr)
{
plSynchedObject::Write(s, mgr);
IWrite( s, mgr );
}
void plSound::IRead( hsStream *s, hsResMgr *mgr )
{
fPlaying = s->ReadBool();
fVirtualStartTime = hsTimer::GetSysSeconds(); // Need if we're autostart
fTime = s->ReadSwapDouble();
fMaxFalloff = s->ReadSwap32();
fMinFalloff = s->ReadSwap32();
s->ReadSwap( &fCurrVolume );
s->ReadSwap( &fDesiredVol );
/// mcn debugging - Thanks to some of my older sound code, it's possible that a few volumes
/// will come in too large. This will only happen with scenes that were exported with that intermediate
/// code, which should be limited to my test scenes locally. Otherwise, things should be fine. This
/// is to compensate for those bogus files. (The fix is to reset the volume in MAX, since the bogusness
/// is in the range of the volume slider itself).
if( fDesiredVol > 1.f )
fDesiredVol = 1.f;
if( fCurrVolume > 1.f )
fCurrVolume = 1.f;
fMaxVolume = fDesiredVol;
fOuterVol = s->ReadSwap32();
fInnerCone = s->ReadSwap32();
fOuterCone = s->ReadSwap32();
s->ReadSwap( &fFadedVolume );
s->ReadSwap( &fProperties );
fType = s->ReadByte();
fPriority = s->ReadByte();
// HACK FOR OLDER EXPORTERS that thought Auto-start meant set fPlaying true
if( fPlaying )
SetProperty( kPropAutoStart, true );
// Read in fade params
fFadeInParams.Read( s );
fFadeOutParams.Read( s );
// Read in soft volume key
mgr->ReadKeyNotifyMe( s, TRACKED_NEW plGenRefMsg( GetKey(), plRefMsg::kOnCreate, 0, kRefSoftVolume ), plRefFlags::kActiveRef );
// Read in the data buffer key
fDataBufferKey = mgr->ReadKey( s );
// EAX params
fEAXSettings.Read( s );
// EAX soft keys
mgr->ReadKeyNotifyMe( s, TRACKED_NEW plGenRefMsg( GetKey(), plRefMsg::kOnCreate, 0, kRefSoftOcclusionRegion ), plRefFlags::kActiveRef );
}
void plSound::IWrite( hsStream *s, hsResMgr *mgr )
{
s->WriteBool(fPlaying);
s->WriteSwapDouble(fTime);
s->WriteSwap32(fMaxFalloff);
s->WriteSwap32(fMinFalloff);
s->WriteSwap( fCurrVolume );
s->WriteSwap( fDesiredVol );
s->WriteSwap32(fOuterVol);
s->WriteSwap32(fInnerCone);
s->WriteSwap32(fOuterCone);
s->WriteSwap( fFadedVolume );
s->WriteSwap( fProperties );
s->WriteByte( fType );
s->WriteByte( fPriority );
// Write out fade params
fFadeInParams.Write( s );
fFadeOutParams.Write( s );
// Write out soft volume key
mgr->WriteKey( s, fSoftRegion );
// Write out data buffer key
if(fDataBuffer)
mgr->WriteKey( s, fDataBuffer->GetKey() );
else
mgr->WriteKey( s, fDataBufferKey );
// EAX params
fEAXSettings.Write( s );
// EAX Soft keys
mgr->WriteKey( s, fSoftOcclusionRegion );
}
void plSound::plFadeParams::Read( hsStream *s )
{
s->ReadSwap( &fLengthInSecs );
s->ReadSwap( &fVolStart );
s->ReadSwap( &fVolEnd );
s->ReadSwap( &fType );
s->ReadSwap( &fCurrTime );
s->ReadSwap( &fStopWhenDone );
s->ReadSwap( &fFadeSoftVol );
}
void plSound::plFadeParams::Write( hsStream *s )
{
s->WriteSwap( fLengthInSecs );
s->WriteSwap( fVolStart );
s->WriteSwap( fVolEnd );
s->WriteSwap( fType );
s->WriteSwap( fCurrTime );
s->WriteSwap( fStopWhenDone );
s->WriteSwap( fFadeSoftVol );
}
hsScalar plSound::plFadeParams::InterpValue( void )
{
hsScalar val;
switch( fType )
{
case kLinear:
val = ( ( fCurrTime / fLengthInSecs ) * ( fVolEnd - fVolStart ) ) + fVolStart;
break;
case kLogarithmic:
val = fCurrTime / fLengthInSecs;
val = ( ( val * val ) * ( fVolEnd - fVolStart ) ) + fVolStart;
break;
case kExponential:
val = fCurrTime / fLengthInSecs;
val = ( (hsScalar)sqrt( val ) * ( fVolEnd - fVolStart ) ) + fVolStart;
break;
default:
val = 0.f;
}
return val;
}
void plSound::SetFadeInEffect( plSound::plFadeParams::Type type, hsScalar length )
{
fFadeInParams.fLengthInSecs = length;
fFadeInParams.fType = type;
fFadeInParams.fVolStart = 0.f; // Will be set when activated
fFadeInParams.fVolEnd = 1.f; // Will be set when activated
fFadeInParams.fCurrTime = -1.f;
// If we're not playing, but we're going to, and we're going to fade in,
// then our current state is faded out, so set fFading
if( fFadeInParams.fLengthInSecs > 0 && !fPlaying )
fFading = true;
else if( fFadeInParams.fLengthInSecs <= 0 && !fPlaying )
fFading = false;
}
void plSound::SetFadeOutEffect( plSound::plFadeParams::Type type, hsScalar length )
{
fFadeOutParams.fLengthInSecs = length;
fFadeOutParams.fType = type;
fFadeOutParams.fVolStart = 1.f; // Will be set when activated
fFadeOutParams.fVolEnd = 0.f; // Will be set when activated
fFadeOutParams.fCurrTime = -1.f;
fFadeOutParams.fStopWhenDone = true;
}
plDrawableSpans* plSound::CreateProxy(const hsMatrix44& l2w, hsGMaterial* mat, hsTArray<UInt32>& idx, plDrawableSpans* addTo)
{
plDrawableSpans* myDraw = addTo;
if( fOuterCone < 360 )
{
hsScalar len = (hsScalar)GetMax();
hsScalar halfAng = hsScalarDegToRad(hsScalar(fInnerCone) * 0.5f);
hsScalar radius = len * tanf(halfAng);
if( fInnerCone < 180 )
len = -len;
myDraw = plDrawableGenerator::GenerateConicalDrawable(
radius,
len,
mat,
l2w,
true,
&hsColorRGBA().Set(1.f, 0.5f, 0.5f, 1.f),
&idx,
myDraw);
len = (hsScalar)GetMin();
halfAng = hsScalarDegToRad(hsScalar(fOuterCone) * 0.5f);
radius = len * tanf(halfAng);
if( fOuterCone < 180 )
len = -len;
myDraw = plDrawableGenerator::GenerateConicalDrawable(
radius,
len,
mat,
l2w,
true,
&hsColorRGBA().Set(0.25f, 0.25f, 0.5f, 1.f),
&idx,
myDraw);
}
else
{
myDraw = plDrawableGenerator::GenerateSphericalDrawable(
hsPoint3(0,0,0),
(hsScalar)GetMin(),
mat,
l2w,
true,
&hsColorRGBA().Set(1.f, 0.5f, 0.5f, 1.f),
&idx,
myDraw);
myDraw = plDrawableGenerator::GenerateSphericalDrawable(
hsPoint3(0,0,0),
(hsScalar)GetMax(),
mat,
l2w,
true,
&hsColorRGBA().Set(0.25f, 0.25f, 0.5f, 1.f),
&idx,
myDraw);
}
return myDraw;
}
// call when state has changed
hsBool plSound::DirtySynchState(const char* sdlName /* kSDLSound */, UInt32 sendFlags)
{
/*
if( sdlName == nil )
sdlName = kSDLSound;
if( fOwningSceneObject != nil )
return fOwningSceneObject->DirtySynchState(sdlName, sendFlags);
*/
return false;
}
//////////////////////////////////////////////////////////////////////////////
//// plSoundVolumeApplicator /////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
void plSoundVolumeApplicator::IApply( const plAGModifier *mod, double time )
{
plScalarChannel *chan = plScalarChannel::ConvertNoRef( fChannel );
if(chan)
{
hsScalar volume = chan->Value( time );
hsScalar digitalVolume = (float)pow( 10.f, volume / 20.f );
// Find the audio interface and thus the plSound from it
plSceneObject *so = mod->GetTarget( 0 );
if( so != nil )
{
const plAudioInterface *ai = so->GetAudioInterface();
if( ai != nil && fIndex < ai->GetNumSounds() )
{
plSound *sound = ai->GetSound( fIndex );
if( sound != nil )
{
sound->SetVolume( digitalVolume );
return;
}
}
}
}
}
plAGApplicator *plSoundVolumeApplicator::CloneWithChannel( plAGChannel *channel )
{
plSoundVolumeApplicator *clone = (plSoundVolumeApplicator *)plAGApplicator::CloneWithChannel( channel );
clone->fIndex = fIndex;
return clone;
}
void plSoundVolumeApplicator::Write( hsStream *stream, hsResMgr *mgr )
{
plAGApplicator::Write( stream, mgr );
stream->WriteSwap32( fIndex );
}
void plSoundVolumeApplicator::Read( hsStream *s, hsResMgr *mgr )
{
plAGApplicator::Read( s, mgr );
fIndex = s->ReadSwap32();
}