/// <summary>
/// Stops all sounds on a track
/// </summary>
/// <param name="track"></param>
public virtual void StopTrack(MMSoundManagerTracks track)
{
foreach (MMSoundManagerSound sound in _sounds)
{
if (sound.Track == track)
{
sound.Source.Stop();
}
}
}
/// <summary>
/// Stops all sounds on a track, and returns them to the pool
/// </summary>
/// <param name="track"></param>
public virtual void FreeTrack(MMSoundManagerTracks track)
{
foreach (MMSoundManagerSound sound in _sounds)
{
if (sound.Track == track)
{
sound.Source.Stop();
sound.Source.gameObject.SetActive(false);
}
}
}
/// <summary>
/// Returns true if sounds are currently playing on that track
/// </summary>
/// <param name="track"></param>
public virtual bool HasSoundsPlaying(MMSoundManagerTracks track)
{
foreach (MMSoundManagerSound sound in _sounds)
{
if ((sound.Track == track) && (sound.Source.isPlaying))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Mutes all sounds on the specified track after an optional delay
/// </summary>
/// <param name="track"></param>
/// <param name="mute"></param>
/// <param name="delay"></param>
/// <returns></returns>
protected virtual IEnumerator MuteSoundsOnTrackCoroutine(MMSoundManagerTracks track, bool mute, float delay)
{
if (delay > 0)
{
yield return(MMCoroutine.WaitForUnscaled(delay));
}
foreach (MMSoundManagerSound sound in _sounds)
{
if (sound.Track == track)
{
sound.Source.mute = mute;
}
}
}
/// <summary>
/// Returns the current volume of a track
/// </summary>
/// <param name="track"></param>
/// <param name="volume"></param>
public virtual float GetTrackVolume(MMSoundManagerTracks track, bool mutedVolume)
{
switch (track)
{
case MMSoundManagerTracks.Master:
if (mutedVolume)
{
return(settingsSo.Settings.MutedMasterVolume);
}
else
{
return(settingsSo.Settings.MasterVolume);
}
case MMSoundManagerTracks.Music:
if (mutedVolume)
{
return(settingsSo.Settings.MutedMusicVolume);
}
else
{
return(settingsSo.Settings.MusicVolume);
}
case MMSoundManagerTracks.Sfx:
if (mutedVolume)
{
return(settingsSo.Settings.MutedSfxVolume);
}
else
{
return(settingsSo.Settings.SfxVolume);
}
case MMSoundManagerTracks.UI:
if (mutedVolume)
{
return(settingsSo.Settings.MutedUIVolume);
}
else
{
return(settingsSo.Settings.UIVolume);
}
}
return(1f);
}
/// <summary>
/// Fades an entire track over time
/// </summary>
/// <param name="track"></param>
/// <param name="duration"></param>
/// <param name="initialVolume"></param>
/// <param name="finalVolume"></param>
/// <param name="tweenType"></param>
/// <returns></returns>
protected virtual IEnumerator FadeTrackCoroutine(MMSoundManagerTracks track, float duration, float initialVolume, float finalVolume, MMTweenType tweenType)
{
float startedAt = Time.unscaledTime;
if (tweenType == null)
{
tweenType = new MMTweenType(MMTween.MMTweenCurve.EaseInOutQuartic);
}
while (Time.unscaledTime - startedAt <= duration)
{
float elapsedTime = Time.unscaledTime - startedAt;
float newVolume = MMTween.Tween(elapsedTime, 0f, duration, initialVolume, finalVolume, tweenType);
settingsSo.SetTrackVolume(track, newVolume);
yield return(null);
}
settingsSo.SetTrackVolume(track, finalVolume);
}
/// <summary>
/// Returns true if the specified track is muted, false otherwise
/// </summary>
/// <param name="track"></param>
/// <returns></returns>
public virtual bool IsMuted(MMSoundManagerTracks track)
{
switch (track)
{
case MMSoundManagerTracks.Master:
return(settingsSo.Settings.MasterOn);
case MMSoundManagerTracks.Music:
return(settingsSo.Settings.MusicOn);
case MMSoundManagerTracks.Sfx:
return(settingsSo.Settings.SfxOn);
case MMSoundManagerTracks.UI:
return(settingsSo.Settings.UIOn);
}
return(false);
}
/// <summary>
/// Mutes all sounds playing on a specific track
/// </summary>
/// <param name="track"></param>
/// <param name="mute"></param>
/// <param name="delay"></param>
public virtual void MuteSoundsOnTrack(MMSoundManagerTracks track, bool mute, float delay = 0f)
{
StartCoroutine(MuteSoundsOnTrackCoroutine(track, mute, delay));
}
/// <summary>
/// Fades an entire track over the specified duration towards the desired finalVolume
/// </summary>
/// <param name="track"></param>
/// <param name="duration"></param>
/// <param name="initialVolume"></param>
/// <param name="finalVolume"></param>
/// <param name="tweenType"></param>
public virtual void FadeTrack(MMSoundManagerTracks track, float duration, float initialVolume = 0f, float finalVolume = 1f, MMTweenType tweenType = null)
{
StartCoroutine(FadeTrackCoroutine(track, duration, initialVolume, finalVolume, tweenType));
}
protected virtual void ControlTrack(MMSoundManagerTracks track, ControlTrackModes trackMode, float volume = 0.5f)
{
string target = "";
float savedVolume = 0f;
switch (track)
{
case MMSoundManagerTracks.Master:
target = settingsSo.Settings.MasterVolumeParameter;
if (trackMode == ControlTrackModes.Mute)
{
settingsSo.TargetAudioMixer.GetFloat(target, out settingsSo.Settings.MutedMasterVolume); settingsSo.Settings.MasterOn = false;
}
else if (trackMode == ControlTrackModes.Unmute)
{
savedVolume = settingsSo.Settings.MutedMasterVolume; settingsSo.Settings.MasterOn = true;
}
break;
case MMSoundManagerTracks.Music:
target = settingsSo.Settings.MusicVolumeParameter;
if (trackMode == ControlTrackModes.Mute)
{
settingsSo.TargetAudioMixer.GetFloat(target, out settingsSo.Settings.MutedMusicVolume); settingsSo.Settings.MusicOn = false;
}
else if (trackMode == ControlTrackModes.Unmute)
{
savedVolume = settingsSo.Settings.MutedMusicVolume; settingsSo.Settings.MusicOn = true;
}
break;
case MMSoundManagerTracks.Sfx:
target = settingsSo.Settings.SfxVolumeParameter;
if (trackMode == ControlTrackModes.Mute)
{
settingsSo.TargetAudioMixer.GetFloat(target, out settingsSo.Settings.MutedSfxVolume); settingsSo.Settings.SfxOn = false;
}
else if (trackMode == ControlTrackModes.Unmute)
{
savedVolume = settingsSo.Settings.MutedSfxVolume; settingsSo.Settings.SfxOn = true;
}
break;
case MMSoundManagerTracks.UI:
target = settingsSo.Settings.UIVolumeParameter;
if (trackMode == ControlTrackModes.Mute)
{
settingsSo.TargetAudioMixer.GetFloat(target, out settingsSo.Settings.MutedUIVolume); settingsSo.Settings.UIOn = false;
}
else if (trackMode == ControlTrackModes.Unmute)
{
savedVolume = settingsSo.Settings.MutedUIVolume; settingsSo.Settings.UIOn = true;
}
break;
}
switch (trackMode)
{
case ControlTrackModes.Mute:
settingsSo.SetTrackVolume(track, 0f);
break;
case ControlTrackModes.Unmute:
settingsSo.SetTrackVolume(track, settingsSo.MixerVolumeToNormalized(savedVolume));
break;
case ControlTrackModes.SetVolume:
settingsSo.SetTrackVolume(track, volume);
break;
}
settingsSo.GetTrackVolumes();
if (settingsSo.Settings.AutoSave)
{
settingsSo.SaveSoundSettings();
}
}
/// <summary>
/// Sets the volume of an entire track
/// </summary>
/// <param name="track"></param>
/// <param name="volume"></param>
public virtual void SetTrackVolume(MMSoundManagerTracks track, float volume)
{
ControlTrack(track, ControlTrackModes.SetVolume, volume);
}
/// <summary>
/// Unmutes an entire track
/// </summary>
/// <param name="track"></param>
public virtual void UnmuteTrack(MMSoundManagerTracks track)
{
ControlTrack(track, ControlTrackModes.Unmute, 0f);
}
/// <summary>
/// Plays a sound, signature with all options
/// </summary>
/// <param name="audioClip"></param>
/// <param name="mmSoundManagerTrack"></param>
/// <param name="location"></param>
/// <param name="loop"></param>
/// <param name="volume"></param>
/// <param name="ID"></param>
/// <param name="fade"></param>
/// <param name="fadeInitialVolume"></param>
/// <param name="fadeDuration"></param>
/// <param name="fadeTween"></param>
/// <param name="persistent"></param>
/// <param name="recycleAudioSource"></param>
/// <param name="audioGroup"></param>
/// <param name="pitch"></param>
/// <param name="panStereo"></param>
/// <param name="spatialBlend"></param>
/// <param name="soloSingleTrack"></param>
/// <param name="soloAllTracks"></param>
/// <param name="autoUnSoloOnEnd"></param>
/// <param name="bypassEffects"></param>
/// <param name="bypassListenerEffects"></param>
/// <param name="bypassReverbZones"></param>
/// <param name="priority"></param>
/// <param name="reverbZoneMix"></param>
/// <param name="dopplerLevel"></param>
/// <param name="spread"></param>
/// <param name="rolloffMode"></param>
/// <param name="minDistance"></param>
/// <param name="maxDistance"></param>
/// <returns></returns>
public virtual AudioSource PlaySound(AudioClip audioClip, MMSoundManagerTracks mmSoundManagerTrack, Vector3 location,
bool loop = false, float volume = 1.0f, int ID = 0,
bool fade = false, float fadeInitialVolume = 0f, float fadeDuration = 1f, MMTweenType fadeTween = null,
bool persistent = false,
AudioSource recycleAudioSource = null, AudioMixerGroup audioGroup = null,
float pitch = 1f, float panStereo = 0f, float spatialBlend = 0.0f,
bool soloSingleTrack = false, bool soloAllTracks = false, bool autoUnSoloOnEnd = false,
bool bypassEffects = false, bool bypassListenerEffects = false, bool bypassReverbZones = false, int priority = 128, float reverbZoneMix = 1f,
float dopplerLevel = 1f, int spread = 0, AudioRolloffMode rolloffMode = AudioRolloffMode.Logarithmic, float minDistance = 1f, float maxDistance = 500f
)
{
if (!audioClip)
{
return(null);
}
// audio source setup ---------------------------------------------------------------------------------
// we reuse an audiosource if one is passed in parameters
AudioSource audioSource = recycleAudioSource;
if (audioSource == null)
{
// we pick an idle audio source from the pool if possible
audioSource = _pool.GetAvailableAudioSource(PoolCanExpand, this.transform);
if ((audioSource != null) && (!loop))
{
recycleAudioSource = audioSource;
// we destroy the host after the clip has played (if it not tag for reusability.
StartCoroutine(_pool.AutoDisableAudioSource(audioClip.length, audioSource.gameObject));
}
}
// we create an audio source if needed
if (audioSource == null)
{
_tempAudioSourceGameObject = new GameObject("MMAudio_" + audioClip.name);
audioSource = _tempAudioSourceGameObject.AddComponent <AudioSource>();
}
// audio source settings ---------------------------------------------------------------------------------
audioSource.transform.position = location;
audioSource.time = 0.0f;
audioSource.clip = audioClip;
audioSource.pitch = pitch;
audioSource.spatialBlend = spatialBlend;
audioSource.panStereo = panStereo;
audioSource.loop = loop;
audioSource.bypassEffects = bypassEffects;
audioSource.bypassListenerEffects = bypassListenerEffects;
audioSource.bypassReverbZones = bypassReverbZones;
audioSource.priority = priority;
audioSource.reverbZoneMix = reverbZoneMix;
audioSource.dopplerLevel = dopplerLevel;
audioSource.spread = spread;
audioSource.rolloffMode = rolloffMode;
audioSource.minDistance = minDistance;
audioSource.maxDistance = maxDistance;
// track and volume ---------------------------------------------------------------------------------
if (settingsSo != null)
{
audioSource.outputAudioMixerGroup = settingsSo.MasterAudioMixerGroup;
switch (mmSoundManagerTrack)
{
case MMSoundManagerTracks.Master:
audioSource.outputAudioMixerGroup = settingsSo.MasterAudioMixerGroup;
break;
case MMSoundManagerTracks.Music:
audioSource.outputAudioMixerGroup = settingsSo.MusicAudioMixerGroup;
break;
case MMSoundManagerTracks.Sfx:
audioSource.outputAudioMixerGroup = settingsSo.SfxAudioMixerGroup;
break;
case MMSoundManagerTracks.UI:
audioSource.outputAudioMixerGroup = settingsSo.UIAudioMixerGroup;
break;
}
}
if (audioGroup)
{
audioSource.outputAudioMixerGroup = audioGroup;
}
audioSource.volume = volume;
// we start playing the sound
audioSource.Play();
// we destroy the host after the clip has played if it was a one time AS.
if (!loop && !recycleAudioSource)
{
Destroy(_tempAudioSourceGameObject, audioClip.length);
}
// we fade the sound in if needed
if (fade)
{
FadeSound(audioSource, fadeDuration, fadeInitialVolume, volume, fadeTween);
}
// we handle soloing
if (soloSingleTrack)
{
MuteSoundsOnTrack(mmSoundManagerTrack, true, 0f);
audioSource.mute = false;
if (autoUnSoloOnEnd)
{
MuteSoundsOnTrack(mmSoundManagerTrack, false, audioClip.length);
}
}
else if (soloAllTracks)
{
MuteAllSounds();
audioSource.mute = false;
if (autoUnSoloOnEnd)
{
StartCoroutine(MuteAllSoundsCoroutine(audioClip.length, false));
}
}
// we prepare for storage
_sound.ID = ID;
_sound.Track = mmSoundManagerTrack;
_sound.Source = audioSource;
_sound.Persistent = persistent;
// we check if that audiosource is already being tracked in _sounds
bool alreadyIn = false;
for (int i = 0; i < _sounds.Count; i++)
{
if (_sounds[i].Source == audioSource)
{
_sounds[i] = _sound;
alreadyIn = true;
}
}
if (!alreadyIn)
{
_sounds.Add(_sound);
}
// we return the audiosource reference
return(audioSource);
}
