AudioService.cs

Go to the documentation of this file.

using Hellmade.Sound;
using System;
using System.Collections;
using UnityEngine;
 
namespace PixoVR.Audio
{
    public class AudioService : MonoBehaviour
    {
        [SerializeField] private VoiceOverData voices;
        [SerializeField] private VoiceOverData soundsFx;
        [SerializeField] private SpatialSoundSettings defaultSpatialSoundSettings;
 
        public RepeatableAudio LastPlayedRepeatableAudio { get; private set; }
        public RepeatableAudio PlayOnceAudio { get; private set; }
 
        private const float _soundRepeatDelay = 30;
        private const float _mutedVolume = 0.001f;
        private bool _isSoundMuted = false;
 
        private Coroutine _playRepeatableCoroutine;
 
        public event Action RepeatableAudioStopped;
        public event Action<string> OnceTimeAudioStopped;
 
        private Hellmade.Sound.Audio _lastStartedVO;
 
        private void Start()
        {
            EazySoundManager.AudioStopped += OnAudioStopped;
        }
 
        private void OnDestroy()
        {
            EazySoundManager.AudioStopped -= OnAudioStopped;
        }
 
        public void InitCurrentVoiceOverdata(VoiceOverData voData)
        {
            voices = voData;
        }
 
        public VoiceOverInfo GetOverOverData(string voiceOverName)
        {
            var voiceOverData = voices.GetDataVO(voiceOverName);
 
            if (voiceOverData == null)
            {
                Debug.LogError("Voice over data is not exist");
            }
 
            return voiceOverData;
        }
 
        public bool IsPlaying(string fxName)
        {
            var clip = soundsFx.GetAudioClipVO(fxName);
 
            if (clip == null)
            {
                Debug.LogError("audio clip not found " + fxName);
                return false;
            }
 
            var audio = EazySoundManager.GetAudio(clip);
            return audio != null ? audio.IsPlaying : false;
        }
 
        public int PlayFX(string fxName)
        {
            var clip = soundsFx.GetAudioClipVO(fxName);
 
            if (clip == null)
            {
                Debug.LogError("audio clip not found " + fxName);
                return -1;
            }
 
            return EazySoundManager.PlaySound(clip, fxName);
        }
 
        public void PlayFX(string fxName, bool loop)
        {
            var clip = soundsFx.GetAudioClipVO(fxName);
 
            if (clip == null)
            {
                Debug.LogError("audio clip not found " + fxName);
                return;
            }
 
            EazySoundManager.PlaySound(clip, fxName, loop);
        }
 
        public void PlayFX(string fxName, float volume, bool loop)
        {
            var clip = soundsFx.GetAudioClipVO(fxName);
 
            if (clip == null)
            {
                Debug.LogError("audio clip not found " + fxName);
                return;
            }
 
            EazySoundManager.PlaySound(clip, fxName, volume, loop);
        }
 
 
        public int PlaySpatiallyFX(string fxName, float volume, bool loop, Transform sourceTransform)
        {
            Debug.Log($"TestAudio PlaySpatiallyFX {fxName}");
            var fxInfo = soundsFx.GetDataVO(fxName);
 
            if (fxInfo == null)
            {
                Debug.LogError("voice over info not found " + fxName);
                return -1;
            }
 
            var audioId = EazySoundManager.PlaySound(fxInfo.voiceOver, fxName, volume, loop, sourceTransform);
 
            var spatialSoundSettings = GetSpatialSoundSettings(fxInfo);
 
            if (spatialSoundSettings == null) return -1;
 
            ConfigureAudioSource(EazySoundManager.GetAudio(audioId), spatialSoundSettings);
 
            return audioId;
        }
 
        private void ConfigureAudioSource(Hellmade.Sound.Audio audio, SpatialSoundSettings spatialSoundSettings)
        {
            audio.RolloffMode = spatialSoundSettings.audioRolloffMode;
            audio.Max3DDistance = spatialSoundSettings.maxDistance;
            audio.Min3DDistance = spatialSoundSettings.minDistance;
            audio.SpatialBlend = 1f;
        }
 
        private SpatialSoundSettings GetSpatialSoundSettings(VoiceOverInfo voiceOverInfo)
        {
            if (voiceOverInfo.UseSpatialSoundSettings)
            {
                if (voiceOverInfo.spatialSoundSettings != null)
                    return voiceOverInfo.spatialSoundSettings;
                else
                {
                    Debug.LogError("Can't use SpatialSoundSettings because it is null");
                    return null;
                }
            }
            else
            {
                if (defaultSpatialSoundSettings != null)
                    return defaultSpatialSoundSettings;
                else
                {
                    Debug.LogError("defaultSpatialSoundSettings is null");
                    return null;
                }
            }
        }
 
        public void SetSfxVolume(int audioID, float volume)
        {
            EazySoundManager.GetAudio(audioID)?.SetVolume(volume);
        }
 
        public void SetSfxVolume(string name, float volume)
        {
            var fx = EazySoundManager.GetAudio(name);
 
            if (fx == null)
            {
                Debug.LogWarning("Fx not found");
 
                return;
            }
 
            fx.SetVolume(volume);
        }
 
 
        public void SetSfxPitch(int audioID, float pitch)
        {
            Hellmade.Sound.Audio audioInstance = EazySoundManager.GetAudio(audioID);
            if (audioInstance != null)
            {
                audioInstance.Pitch = pitch;
            }
        }
 
        public void StopFx(string fxName)
        {
            var clip = soundsFx.GetAudioClipVO(fxName);
 
            if (clip == null)
            {
                Debug.LogError("audio clip not found " + fxName);
                return;
            }
 
            var audio = EazySoundManager.GetAudio(clip);
 
            if (audio != null)
            {
                audio.Stop();
            }
        }
 
        public void StopFxById(int fxId)
        {
            var audio = EazySoundManager.GetSoundAudio(fxId);
 
            if (audio == null)
            {
                Debug.LogWarning($"Fx id - {fxId} is not exist");
 
                return;
            }
 
            audio.Stop();
        }
 
        public void PlayOnlyOneFX(string fxName)
        {
            StopAllFx();
 
            var clip = soundsFx.GetAudioClipVO(fxName);
 
            if (clip == null)
            {
                Debug.LogError("audio clip not found " + fxName);
                return;
            }
 
            EazySoundManager.PlaySound(clip, fxName);
        }
 
        public void StopPlaying()
        {
            StopAllFx();
        }
 
        public void PlayVoice(string voiceOver)
        {
            var clip = voices.GetAudioClipVO(voiceOver);
 
            if (clip == null)
            {
                Debug.LogError("audio clip not found " + voiceOver);
 
                return;
            }
 
            PlayVoice(clip);
        }
 
        public void PlayVoice(AudioClip clip)
        {
            var soundId = PlayMusicWithParams(clip);
 
            _lastStartedVO = EazySoundManager.GetAudio(soundId);
        }
 
        public void PlayRepeatable(string voiceOverName)
        {
            if (LastPlayedRepeatableAudio != null)
            {
                if (LastPlayedRepeatableAudio.Name == voiceOverName)
                {
                    return;
                }
            }
 
            var voiceOverAudioClip = voices.GetAudioClipVO(voiceOverName);
 
            StopRepeatable();
            PlayRepeatable(voiceOverAudioClip, voiceOverName);
        }
 
        public void PlayOnceTime(string voiceOverName)
        {
            var voiceOverAudioClip = voices.GetAudioClipVO(voiceOverName);
 
            PlayOnceTime(voiceOverAudioClip, voiceOverName);
        }
 
        public void UpdateLastRepeatable(string voiceOverName)
        {
            var voiceOverAudioClip = voices.GetAudioClipVO(voiceOverName);
            var soundId = EazySoundManager.PlayMusic(voiceOverAudioClip, 0.001f, false, false, 0f, 0f);
            var audio = EazySoundManager.GetAudio(soundId);
 
            LastPlayedRepeatableAudio = new RepeatableAudio()
            {
                Name = voiceOverName,
                Volume = 1f,
                Audio = audio
            };
        }
 
        public void PlayRepeatable(AudioClip clip, string voiceOverName)
        {
            if (clip == null)
            {
                Debug.LogError("No Audio File");
                RepeatableAudioStopped?.Invoke();
                return;
            }
 
            LastPlayedRepeatableAudio = new RepeatableAudio()
            {
                Name = voiceOverName,
                Volume = 1f
            };
 
            var soundId = PlayMusicWithParams(clip);
 
            LastPlayedRepeatableAudio.Audio = EazySoundManager.GetAudio(soundId);
        }
 
        public void PlayOnceTime(AudioClip clip, string voiceOverName)
        {
            if (clip == null)
            {
                Debug.LogError("No Audio File");
                string idVO = LastPlayedRepeatableAudio.Name;
                LastPlayedRepeatableAudio = null;
                OnceTimeAudioStopped?.Invoke(idVO);
                return;
            }
 
            PlayOnceAudio = new RepeatableAudio()
            {
                Name = voiceOverName,
                Volume = 1f
            };
 
            var soundId = PlayMusicWithParams(clip);
 
            PlayOnceAudio.Audio = EazySoundManager.GetAudio(soundId);
        }
 
        private void OnAudioStopped(Hellmade.Sound.Audio audio)
        {
            if (LastPlayedRepeatableAudio == null) return;
            if (PlayOnceAudio?.Audio == audio)
            {
                string idVO = LastPlayedRepeatableAudio.Name;
                LastPlayedRepeatableAudio = null;
                OnceTimeAudioStopped?.Invoke(idVO);
                PlayOnceAudio.Name = null;
                PlayOnceAudio = null;
                return;
            }
 
            if (LastPlayedRepeatableAudio.Audio != audio) return;
 
            RepeatableAudioStopped?.Invoke();
 
            if (_playRepeatableCoroutine != null)
            {
                StopCoroutine(_playRepeatableCoroutine);
            }
 
            _playRepeatableCoroutine = StartCoroutine(PlayRepeatableCoroutine());
        }
 
        public void PlayLastRepeatable()
        {
            if (_lastStartedVO != null && _lastStartedVO.IsPlaying)
            {
                _lastStartedVO.Stop();
            }
 
            LastPlayedRepeatableAudio.Audio.Play();
            LastPlayedRepeatableAudio.Audio.SetVolume(LastPlayedRepeatableAudio.Volume);
        }
 
 
        public void StopRepeatable()
        {
            if (LastPlayedRepeatableAudio == null) return;
 
            LastPlayedRepeatableAudio.Audio.Stop();
 
            if (_playRepeatableCoroutine != null)
            {
                StopCoroutine(_playRepeatableCoroutine);
            }
 
            LastPlayedRepeatableAudio = null;
            _playRepeatableCoroutine = null;
        }
 
        public void PauseRepeatable()
        {
            if (LastPlayedRepeatableAudio == null) return;
 
            LastPlayedRepeatableAudio.Audio.Stop();
 
            if (_playRepeatableCoroutine != null)
            {
                StopCoroutine(_playRepeatableCoroutine);
            }
 
            _playRepeatableCoroutine = null;
        }
 
        public void StopRepeatableTemporarily()
        {
            if (LastPlayedRepeatableAudio == null)
            {
                Debug.LogWarning("Repeatable sound is not exist");
                return;
            }
 
            LastPlayedRepeatableAudio.Audio.Stop();
 
            if (_playRepeatableCoroutine != null)
            {
                StopCoroutine(_playRepeatableCoroutine);
            }
 
            RepeatableAudioStopped?.Invoke();
        }
 
        public void StopOnceTimeTemporarily()
        {
            if (PlayOnceAudio == null)
            {
                Debug.LogWarning("PlayOnceAudio sound is not exist");
                return;
            }
 
            PlayOnceAudio.Audio.Stop();
            PlayOnceAudio = null;
        }
 
        public void CleanOnceTimeVO()
        {
            if (PlayOnceAudio == null)
            {
                Debug.LogWarning("PlayOnceAudio sound is not exist");
                return;
            }
 
            PlayOnceAudio = null;
        }
 
        public void StopAllVoiceOvers()
        {
            Debug.Log("TestAudio StopAllVoiceOvers");
            EazySoundManager.StopAllMusic();
        }
 
        public void StopAllFx()
        {
            Debug.Log("TestAudio StopAllFx");
            EazySoundManager.StopAllSounds();
        }
 
        public void SetRepeatableSoundVolume(float volume)
        {
            if (volume != _mutedVolume)
            {
                _isSoundMuted = false;
            }
 
            LastPlayedRepeatableAudio.Volume = volume;
            if (PlayOnceAudio != null)
                PlayOnceAudio.Volume = volume;
 
            LastPlayedRepeatableAudio.Audio.SetVolume(LastPlayedRepeatableAudio.Volume, 0, 0);
            PlayOnceAudio?.Audio.SetVolume(PlayOnceAudio.Volume, 0, 0);
        }
 
        public void MuteRepeatableSound()
        {
            _isSoundMuted = true;
            LastPlayedRepeatableAudio.Audio.SetVolume(_mutedVolume, 0, 0);
            PlayOnceAudio?.Audio.SetVolume(_mutedVolume, 0, 0);
        }
 
        private IEnumerator PlayRepeatableCoroutine()
        {
            while (true)
            {
                yield return new WaitForSeconds(_soundRepeatDelay);
 
                if (_lastStartedVO is { IsPlaying: true })
                {
                    if (_playRepeatableCoroutine != null)
                    {
                        StopCoroutine(_playRepeatableCoroutine);
                        _playRepeatableCoroutine = StartCoroutine(PlayRepeatableCoroutine());
                    }
                }
                else
                {
                    _lastStartedVO = null;
                }
 
                LastPlayedRepeatableAudio.Audio.Play();
                if (_isSoundMuted)
                {
                    MuteRepeatableSound();
                }
            }
        }
 
        private int PlayMusicWithParams(AudioClip clip)
        {
            return EazySoundManager.PlayMusic(clip, 1f, false, false, 0f, 0f);
        }
    }
 
    public class RepeatableAudio
    {
        public string Name { get; set; }
        public float Volume { get; set; }
        public Hellmade.Sound.Audio Audio { get; set; }
    }
}