UAudioManager.cs

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

using System;
using System.Collections.Generic;
using UnityEngine;

namespace HoloToolkit.Unity
{
    public partial class UAudioManager : UAudioManagerBase<AudioEvent, AudioEventBank>
    {
        [Tooltip("The maximum number of AudioEvents that can be played at once. Zero (0) indicates there is no limit.")]
        [SerializeField]
        private int globalEventInstanceLimit = 0;

        [Tooltip("The desired behavior when the instance limit is reached.")]
        [SerializeField]
        private AudioEventInstanceBehavior globalInstanceBehavior = AudioEventInstanceBehavior.KillOldest;

        public Func<GameObject, GameObject> AudioEmitterTransform { get; set; }

        private Dictionary<string, AudioEvent> eventsDictionary;

        private static UAudioManager instance;
        public static UAudioManager Instance
        {
            get { return instance ?? (instance = FindObjectOfType<UAudioManager>()); }
        }

        protected new void Awake()
        {
            base.Awake();

            CreateEventsDictionary();
        }

        public void PlayEvent(string eventName)
        {
            PlayEvent(eventName, gameObject);
        }

        public void PlayEvent(string eventName, GameObject emitter, string messageOnAudioEnd = null)
        {
            PlayEvent(eventName, emitter, null, null, messageOnAudioEnd);
        }

        public void PlayEvent(string eventName, AudioSource primarySource, AudioSource secondarySource = null)
        {
            PlayEvent(eventName, primarySource.gameObject, primarySource, secondarySource);
        }

        private void PlayEvent(string eventName, GameObject emitter, AudioSource primarySource, AudioSource secondarySource, string messageOnAudioEnd = null)
        {
            if (!CanPlayNewEvent())
            {
                return;
            }

            emitter = ApplyAudioEmitterTransform(emitter);

            if (emitter == null)
            {
                //if emitter is null, use the uAudioManager GameObject(2dSound)
                emitter = gameObject;
            }

            if (string.IsNullOrEmpty(eventName))
            {
                Debug.LogWarning("Audio Event string is null or empty!");
                return;
            }

            AudioEvent currentEvent;

            if (!eventsDictionary.TryGetValue(eventName, out currentEvent))
            {
                Debug.LogFormat("Could not find event \"{0}\"", eventName);
                return;
            }

            // If the instance limit has been reached...
            if (currentEvent.InstanceLimit != 0 && GetInstances(eventName) >= currentEvent.InstanceLimit)
            {
                if (currentEvent.AudioEventInstanceBehavior == AudioEventInstanceBehavior.KillNewest)
                {
                    // Do not play the event.
                    Debug.LogFormat(this, "Instance limit reached, not playing event \"{0}\"", eventName);
                    return;
                }
                else
                {
                    // Top the oldest instance of this event.
                    KillOldestInstance(eventName);
                }
            }

            if (primarySource == null)
            {
                primarySource = GetUnusedAudioSource(emitter);
            }

            if (currentEvent.IsContinuous() && secondarySource == null)
            {
                secondarySource = GetUnusedAudioSource(emitter);
            }

            PlayEvent(currentEvent, emitter, primarySource, secondarySource, messageOnAudioEnd);
        }

        private void PlayEvent(AudioEvent audioEvent,
                            GameObject emitter,
                            AudioSource primarySource,
                            AudioSource secondarySource,
                            string messageOnAudioEnd = null)
        {
            ActiveEvent tempEvent = new ActiveEvent(audioEvent, emitter, primarySource, secondarySource, messageOnAudioEnd);

            // The base class owns this event once we pass it to PlayContainer, and may dispose it if it cannot be played.
            PlayContainer(tempEvent);
        }

        public void StopEventsOnGameObject(string eventName, GameObject gameObjectToStop, float fadeOutTime = 0f)
        {
            for (int i = ActiveEvents.Count - 1; i >= 0; i--)
            {
                ActiveEvent activeEvent = ActiveEvents[i];

                if (activeEvent.AudioEmitter == gameObjectToStop)
                {
                    StopEvent(activeEvent.AudioEvent.Name, gameObjectToStop, fadeOutTime);
                }
            }
        }


        public void StopAllEvents(string eventName, GameObject emitter = null, float fadeOutTime = 0f)
        {

            for (int i = ActiveEvents.Count - 1; i >= 0; i--)
            {
                ActiveEvent activeEvent = ActiveEvents[i];

                if (activeEvent.AudioEvent.Name == eventName)
                {
                    if (fadeOutTime > 0)
                    {
                        StartCoroutine(StopEventWithFadeCoroutine(activeEvent, fadeOutTime));
                    }
                    else
                    {
                        StartCoroutine(StopEventWithFadeCoroutine(activeEvent, activeEvent.AudioEvent.FadeOutTime));
                    }
                }
            }
        }

        public void StopAll(GameObject emitter = null, float fadeOutTime = 0f)
        {
            foreach (ActiveEvent activeEvent in ActiveEvents)
            {
                if (fadeOutTime > 0)
                {
                    StartCoroutine(StopEventWithFadeCoroutine(activeEvent, fadeOutTime));
                }
                else
                {
                    StartCoroutine(StopEventWithFadeCoroutine(activeEvent, activeEvent.AudioEvent.FadeOutTime));
                }
            }
        }



        public void StopEvent(string eventName, GameObject emitter = null, float fadeOutTime = 0f)
        {
            emitter = ApplyAudioEmitterTransform(emitter);
            if (emitter == null)
            {
                //if emitter is null, use the uaudiomanager GameObject (2dsound)
                emitter = gameObject;
            }

            for (int i = ActiveEvents.Count - 1; i >= 0; i--)
            {
                ActiveEvent activeEvent = ActiveEvents[i];

                if (activeEvent.AudioEvent.Name == eventName && activeEvent.AudioEmitter == emitter)
                {
                    //if there's no fade specified, use the fade stored in the event
                    if (fadeOutTime > 0f)
                    {
                        StartCoroutine(StopEventWithFadeCoroutine(activeEvent, fadeOutTime));
                    }
                    else
                    {
                        StartCoroutine(StopEventWithFadeCoroutine(activeEvent, ActiveEvents[i].AudioEvent.FadeOutTime));

                    }
                }
            }
        }

        public void SetPitch(string eventName, float newPitch)
        {
            if (newPitch <= 0 || newPitch > 3)
            {
                Debug.LogErrorFormat(this, "Invalid pitch {0} set for event \"{1}\"", newPitch, eventName);
                return;
            }

            for (int i = ActiveEvents.Count - 1; i >= 0; i--)
            {
                ActiveEvent activeEvent = ActiveEvents[i];
                if (activeEvent.AudioEvent.Name == eventName)
                {
                    activeEvent.SetPitch(newPitch);
                }
            }
        }

        public void SetLoopingContainerFrequency(string eventName, float newLoopTime)
        {
            AudioEvent currentEvent;

            if (!eventsDictionary.TryGetValue(eventName, out currentEvent))
            {
                Debug.LogErrorFormat(this, "Could not find event \"{0}\"", eventName);
                return;
            }

            if (newLoopTime <= 0)
            {
                Debug.LogErrorFormat(this, "Invalid loop time set for event \"{0}\"", eventName);
                return;
            }

            currentEvent.Container.LoopTime = newLoopTime;
        }

        public void ModulateVolume(string eventName, GameObject emitter, float volume)
        {
            emitter = ApplyAudioEmitterTransform(emitter);

            if (emitter == null)
            {
                return;
            }

            for (int i = 0; i < ActiveEvents.Count; i++)
            {
                ActiveEvent activeEvent = ActiveEvents[i];

                if (ActiveEvents[i].AudioEvent.Name == eventName && ActiveEvents[i].AudioEmitter == emitter)
                {
                    activeEvent.VolDest = volume;
                    activeEvent.AltVolDest = volume;
                    activeEvent.CurrentFade = 0;
                }
            }
        }

        private AudioSource GetUnusedAudioSource(GameObject emitter, ActiveEvent currentEvent = null)
        {
            // Get or create valid AudioSource.
            AudioSourcesReference sourcesReference = emitter.GetComponent<AudioSourcesReference>();
            if (sourcesReference != null)
            {
                List<AudioSource> sources = sourcesReference.AudioSources;
                for (int s = 0; s < sources.Count; s++)
                {
                    if (!sources[s].isPlaying && !sources[s].enabled)
                    {
                        if (currentEvent == null)
                        {
                            return sources[s];
                        }
                        else if (sources[s] != currentEvent.PrimarySource)
                        {
                            return sources[s];
                        }
                    }
                }
            }
            else
            {
                sourcesReference = emitter.AddComponent<AudioSourcesReference>();
            }

            return sourcesReference.AddNewAudioSource();
        }

        private bool CanPlayNewEvent()
        {
            if (globalEventInstanceLimit == 0 || ActiveEvents.Count < globalEventInstanceLimit)
            {
                return true;
            }
            else
            {
                if (globalInstanceBehavior == AudioEventInstanceBehavior.KillOldest)
                {
                    StopEvent(ActiveEvents[0]);
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }

        private void KillOldestInstance(string eventName)
        {
            for (int i = 0; i < ActiveEvents.Count; i++)
            {
                ActiveEvent tempEvent = ActiveEvents[i];

                if (tempEvent.AudioEvent.Name == eventName)
                {
                    StopEvent(tempEvent);
                    return;
                }
            }
        }

        private GameObject ApplyAudioEmitterTransform(GameObject emitter)
        {
            if (AudioEmitterTransform != null)
            {
                emitter = AudioEmitterTransform(emitter);
            }

            return emitter;
        }

        protected override void BanksChanged()
        {
            CreateEventsDictionary();
        }

        private void CreateEventsDictionary()
        {
            int numEvents = 0;
            for(int i=0; i<LoadedBanks.Count; i++)
            {
                numEvents += LoadedBanks[i].Events.Length;
            }

            eventsDictionary = new Dictionary<string, AudioEvent>(numEvents);

            for (int b = 0; b < LoadedBanks.Count; b++)
            {
                for (int i = 0; i < LoadedBanks[b].Events.Length; i++)
                {
                    AudioEvent tempEvent = LoadedBanks[b].Events[i];
                    try
                    {
                        eventsDictionary.Add(tempEvent.Name, tempEvent);
                    }
                    catch (ArgumentException)
                    {
                        Debug.LogErrorFormat("Name {0} already exists in Event dictionary", tempEvent.Name);
                    }
                }
            }
        }
    }
}