effectsound.c

Go to the documentation of this file.

 
class EffectSound : Effect
{
 ref ScriptInvoker Event_OnSoundWaveStarted = new ScriptInvoker();
 ref ScriptInvoker Event_OnSoundWaveEnded = new ScriptInvoker();
 ref ScriptInvoker Event_OnSoundFadeInStopped = new ScriptInvoker();
 ref ScriptInvoker Event_OnSoundFadeOutStarted = new ScriptInvoker();
 
 protected ref SoundParams m_SoundParams;
 protected ref SoundObjectBuilder m_SoundObjectBuilder;
 protected ref SoundObject m_SoundObject;
 protected AbstractWave m_SoundWaveObject;
 
 protected WaveKind m_SoundWaveKind;
 protected string m_SoundSetName; 
 protected bool m_SoundLoop;
 protected bool m_SetEnvVariables;
 protected bool m_SoundAutodestroy;
 protected bool m_SoundWaveIsPlaying;
 protected float m_SoundWaveLenght;
 protected float m_SoundWaveVolume;
 protected float m_SoundWaveVolumeMax;
 protected float m_SoundWaveTime;
 protected int m_SoundDoppler;
 
 protected bool m_SoundWaveStarting;
 protected bool m_SoundWaveStopping;
 protected bool m_SoundFadedOut;
 
 protected float m_SoundFadeInDuration;
 
 protected float m_SoundFadeOutStartTime;
 protected float m_SoundFadeOutDuration;
 protected float m_SoundFadeOutInitVolume;
 
 
 
 void EffectSound()
 {
 m_SoundWaveKind = WaveKind.WAVEEFFECTEX;
 m_SoundWaveVolume = 0;
 m_SoundWaveVolumeMax = 1;
 m_SoundAutodestroy = false;
 m_SoundWaveStopping = false;
 m_SoundFadedOut = false;
 m_SoundDoppler = -1;
 }
 
 void ~EffectSound()
 {
 
 }
 
 override void InitEffect()
 {
 super.InitEffect();
 
 // These will be called by the sound events
 Event_OnStarted.Remove(Event_OnEffectStarted);
 Event_OnStopped.Remove(Event_OnEffectEnded);
 }
 
 override string GetDebugName()
 {
 string identifier;
 if (m_SoundSetName != "")
 {
 identifier = m_SoundSetName;
 }
 else
 {
 identifier = "NO_SOUNDSET";
 }
 
 return string.Format("%1:%2", super.GetDebugName(), identifier);
 }
 
 
 
 
 override EffectType GetEffectType()
 {
 return EffectType.SOUND;
 }
 
 override bool IsSound()
 {
 return true;
 }
 
 
 
 
 
 bool SoundPlayEx(out SoundParams params)
 {
 super.Start();
 
 if (m_SoundSetName != "")
 {
 vector position = GetCurrentLocalPosition();
 
 if ( SoundLoadEx(params) )
 {
 if (m_SetEnvVariables && m_SoundParams)
 {
 m_SoundObjectBuilder.AddEnvSoundVariables(GetPosition());
 m_SoundObject = m_SoundObjectBuilder.BuildSoundObject();
 m_SoundObject.SetKind( m_SoundWaveKind );
 m_SoundObject.SetParent( m_ParentObject );
 }
 
 if ( m_SoundObject )
 {
 SetCurrentLocalPosition(position, false);
 m_SoundWaveObject = GetGame().GetSoundScene().Play3D( m_SoundObject, m_SoundObjectBuilder );
 if ( !m_SoundWaveObject )
 return false;
 
 // Wait for header to be loaded before asking for its length, else we block the main thread
 if (m_SoundWaveObject.IsHeaderLoaded())
 ValidateSoundWave();
 else
 m_SoundWaveObject.GetEvents().Event_OnSoundWaveHeaderLoaded.Insert(ValidateSoundWave); 
 
 return true;
 }
 else
 {
 SoundError("m_SoundObject is null.");
 }
 }
 }
 
 return false;
 }
 
 bool SoundPlay()
 {
 SoundParams params;
 return SoundPlayEx(params);
 }
 
 override void Start()
 { 
 SoundPlay();
 }
 
 void SoundStop()
 {
 super.Stop();
 
 if ( IsSoundPlaying() )
 {
 if ( m_SoundFadeOutDuration > 0 && !m_SoundWaveStopping )
 {
 m_SoundWaveStopping = true;
 m_SoundFadedOut = false;
 m_SoundWaveStarting = false;
 m_SoundFadeOutStartTime = m_SoundWaveTime;
 }
 else
 {
 m_SoundWaveObject.Stop();
 }
 }
 else
 {
 SoundReset();
 } 
 }
 
 override void Stop()
 {
 SoundStop(); 
 }
 
 protected void SoundReset()
 {
 m_IsPlaying = false;
 m_SoundWaveIsPlaying = false;
 m_SoundWaveStopping = false;
 m_SoundFadedOut = false;
 m_SoundWaveVolume = m_SoundWaveVolumeMax;
 m_SoundWaveTime = 0;
 m_SoundFadeOutInitVolume = 0;
 m_SoundFadeOutStartTime = 0;
 
 if ( m_SoundWaveObject )
 {
 m_SoundWaveObject.Stop();
 m_SoundWaveObject.SetVolumeRelative( m_SoundWaveVolumeMax );
 }
 }
 
 bool IsSoundPlaying()
 {
 return m_SoundWaveIsPlaying;
 }
 
 override bool IsPlaying()
 {
 return IsSoundPlaying(); // Just in case, as that's what used to be the actual way to check
 }
 
 
 
 
 
 bool SoundLoadEx(out SoundParams params)
 { 
 if ( !m_SoundParams || !m_SoundParams.IsValid() )
 {
 if (!params)
 {
 params = new SoundParams( m_SoundSetName );
 }
 
 //Print("SoundLoad is loading..");
 m_SoundParams = params;
 if ( !m_SoundParams.IsValid() )
 {
 SoundError("Invalid sound set.");
 return false;
 }
 
 m_SoundObjectBuilder = new SoundObjectBuilder( m_SoundParams );
 if (m_SetEnvVariables)
 {
 m_SoundObjectBuilder.AddEnvSoundVariables(GetPosition());
 }
 
 m_SoundObject = m_SoundObjectBuilder.BuildSoundObject();
 
 if ( m_SoundObject )
 {
 m_SoundObject.SetKind( m_SoundWaveKind );
 m_SoundObject.SetParent( m_ParentObject );
 }
 else
 {
 SoundError("m_SoundObject is null.");
 }
 }
 else
 {
 //Print("SoundLoad is loaded.");
 }
 
 return true;
 }
 
 bool SoundLoad()
 {
 SoundParams params;
 return SoundLoadEx(params);
 }
 
 bool IsSoundValid()
 {
 return m_SoundParams.IsValid();
 }
 
 protected void ValidateSoundWave()
 {
 m_SoundWaveLenght = m_SoundWaveObject.GetLength();
 
 if ( SoundWaveValidation() )
 {
 if ( m_SoundFadeInDuration > 0 )
 {
 m_SoundWaveObject.SetVolumeRelative( 0 );
 m_SoundFadeOutStartTime = m_SoundWaveLenght - m_SoundFadeInDuration;
 }
 
 SetSoundLoop( m_SoundLoop );
 
 m_SoundWaveStarting = true;
 
 AbstractWaveEvents events = m_SoundWaveObject.GetEvents();
 events.Event_OnSoundWaveStarted.Insert( Event_OnSoundWaveStarted );
 events.Event_OnSoundWaveEnded.Insert( Event_OnSoundWaveEnded );
 
 UpdateEvents();
 }
 else
 {
 m_SoundWaveObject.Stop();
 }
 }
 
 protected bool SoundWaveValidation()
 {
 bool valid = true;
 
 if ( m_SoundFadeInDuration > GetSoundWaveLength() )
 {
 SoundError("FadeIn is longer than sound wave length.");
 valid = false;
 }
 
 if ( m_SoundFadeOutDuration > GetSoundWaveLength() )
 {
 SoundError("FadeOut is longer than sound wave length.");
 valid = false;
 }
 
 if ( m_SoundFadeOutDuration + m_SoundFadeInDuration > GetSoundWaveLength() )
 {
 SoundError("FadeIn & FadeOut are longer than sound wave length.");
 valid = false;
 }
 
 return valid;
 }
 
 protected void UpdateEvents()
 {
 if ( m_SoundWaveObject )
 {
 SetEnableEventFrame(true);
 }
 else
 {
 SetEnableEventFrame(false);
 }
 }
 
 
 
 
 
 override void Event_OnFrameUpdate(float time_delta)
 {
 if ( IsSoundPlaying() )
 {
 if (m_SoundDoppler != -1)
 {
 m_SoundWaveObject.SetDoppler(m_SoundDoppler);
 } 
 // FadeIn
 if ( m_SoundWaveStarting )
 {
 if ( m_SoundFadeInDuration > 0 )
 {
 SetSoundVolume( GetSoundVolume() + (time_delta / m_SoundFadeInDuration) );
 
 if ( GetSoundVolume() >= m_SoundWaveVolumeMax )
 {
 Event_OnSoundFadeInStopped();
 SetSoundVolume( m_SoundWaveVolumeMax );
 m_SoundWaveStarting = false;
 }
 }
 else
 {
 SetSoundVolume( m_SoundWaveVolumeMax );
 m_SoundWaveStarting = false;
 }
 }
 
 // FadeOut
 if ( m_SoundWaveStopping )
 {
 if ( m_SoundFadeOutDuration > 0 )
 {
 if ( m_SoundFadeOutInitVolume == 0 )
 {
 m_SoundFadeOutInitVolume = GetSoundVolume();
 Event_OnSoundFadeOutStarted();
 }
 SetSoundVolume( GetSoundVolume() - (m_SoundFadeOutInitVolume / m_SoundFadeOutDuration * time_delta) );
 }
 else
 {
 SetSoundVolume( 0 );
 }
 
 if ( GetSoundVolume() <= 0 )
 { 
 if ( m_SoundWaveObject )
 {
 m_SoundWaveObject.Stop();
 m_SoundWaveStopping = false;
 m_SoundFadedOut = true;
 }
 }
 }
 
 // Counting timer here because loop play
 m_SoundWaveTime += time_delta;
 }
 }
 
 override void Event_OnRegistered(int id)
 {
 super.Event_OnRegistered(id);
 
 Event_OnSoundWaveEnded.Insert( SEffectManager.Event_OnSoundWaveEnded );
 }
 
 override void Event_OnUnregistered()
 {
 super.Event_OnUnregistered();
 
 Event_OnSoundWaveEnded.Remove( SEffectManager.Event_OnSoundWaveEnded );
 }
 
 void Event_OnSoundWaveStarted()
 {
 m_SoundWaveIsPlaying = true;
 
 Event_OnSoundWaveStarted.Invoke(this);
 
 Event_OnEffectStarted();
 }
 
 void Event_OnSoundWaveEnded()
 {
 m_SoundWaveIsPlaying = false;
 
 Event_OnSoundWaveEnded.Invoke(this);
 
 Event_OnEffectEnded();
 }
 
 void Event_OnSoundFadeInStopped()
 {
 Event_OnSoundFadeInStopped.Invoke(this);
 }
 
 void Event_OnSoundFadeOutStarted()
 {
 Event_OnSoundFadeOutStarted.Invoke(this);
 }
 
 
 
 
 
 override void SetAutodestroy(bool auto_destroy)
 {
 super.SetAutodestroy(auto_destroy);
 m_SoundAutodestroy = auto_destroy; 
 }
 
 override bool IsAutodestroy()
 {
 return IsSoundAutodestroy();
 }
 
 void SetSoundAutodestroy(bool auto_destroy)
 {
 SetAutodestroy(auto_destroy);
 }
 
 bool IsSoundAutodestroy()
 {
 return m_SoundAutodestroy;
 }
 
 override bool CanDestroy()
 {
 return m_SoundFadeOutDuration <= 0 || m_SoundFadedOut;
 }
 
 
 
 
 
 override void SetParent(Object parent_obj)
 {
 super.SetParent(parent_obj); // ...
 
 if (m_SoundObject)
 {
 m_SoundObject.SetParent(parent_obj);
 }
 }
 
 override Object GetParent()
 {
 if (m_SoundObject)
 return Object.Cast(m_SoundObject.GetParent());
 else
 return super.GetParent();
 }
 
 override Object GetCurrentParent()
 {
 if (m_SoundObject)
 return Object.Cast(m_SoundObject.GetParent());
 else
 return super.GetParent(); // Yes, intentionally this one
 }
 
 override void SetCurrentPosition( vector pos, bool updateCached = true )
 {
 super.SetCurrentPosition(pos, updateCached);
 
 if (m_SoundObject)
 {
 Object parent = GetParent();
 
 if (parent)
 pos = parent.WorldToModel(pos);
 
 m_SoundObject.SetPosition(pos);
 }
 }
 
 override vector GetCurrentPosition()
 {
 if (m_SoundObject)
 return m_SoundObject.GetPosition();
 
 if (m_ParentObject)
 return m_ParentObject.ModelToWorld(GetPosition());
 
 return GetPosition();
 }
 
 override void SetCurrentLocalPosition( vector pos, bool updateCached = true )
 {
 super.SetCurrentLocalPosition(pos, updateCached);
 
 if (m_SoundObject)
 {
 m_SoundObject.SetPosition(pos);
 }
 }
 
 override vector GetCurrentLocalPosition()
 {
 Object parent = GetParent();
 
 if (m_SoundObject)
 {
 //TODO(kumarjac): Create and expose 'SoundObject.GetLocalPosition'
 if (parent)
 return parent.WorldToModel(m_SoundObject.GetPosition());
 else
 return m_SoundObject.GetPosition();
 }
 else
 {
 if (parent)
 return GetLocalPosition();
 else
 return GetPosition();
 }
 
 return vector.Zero;
 }
 
 void SetSoundWaveKind(WaveKind wave_kind)
 {
 m_SoundWaveKind = wave_kind;
 }
 
 void SetSoundSet(string snd)
 {
 m_SoundSetName = snd;
 }
 
 string GetSoundSet()
 {
 return m_SoundSetName;
 }
 
 void SetSoundLoop(bool loop)
 {
 m_SoundLoop = loop;
 
 if ( m_SoundWaveObject )
 m_SoundWaveObject.Loop( loop );
 }
 
 void SetEnviromentVariables(bool setEnvVariables)
 {
 m_SetEnvVariables = setEnvVariables;
 } 
 
 float GetSoundWaveLenght()
 {
 return GetSoundWaveLength();
 }
 
 float GetSoundWaveLength()
 {
 return m_SoundWaveLenght;
 }
 
 void SetSoundVolume(float volume)
 {
 m_SoundWaveVolume = volume;
 if ( m_SoundWaveObject )
 m_SoundWaveObject.SetVolumeRelative( volume );
 }
 
 float GetSoundVolume()
 {
 return m_SoundWaveVolume;
 }
 
 void SetSoundMaxVolume(float volume)
 {
 m_SoundWaveVolumeMax = volume;
 if ( m_SoundWaveObject )
 m_SoundWaveObject.SetVolumeRelative( m_SoundWaveVolume );
 }
 
 float GetSoundWaveTime()
 {
 return m_SoundWaveTime;
 }
 
 void SetSoundFadeIn(float fade_in)
 {
 m_SoundFadeInDuration = fade_in;
 }
 
 void SetSoundFadeOut(float fade_out)
 {
 m_SoundFadeOutDuration = fade_out;
 }
 
 void SetDoppler(bool setDoppler)
 {
 m_SoundDoppler = 0;
 if (setDoppler)
 {
 m_SoundDoppler = 1;
 }
 }
 
 
 
 
 protected void SoundError(string err_msg)
 {
 ErrorEx(string.Format("%1: SoundSetName: '%2' :: %3", this, m_SoundSetName, err_msg));
 }
}