Unity3d简便的声音管理方案

本方法是对Ez-Sound-Manager的扩展

https://github.com/JackM36/Eazy-Sound-Manager

参考Audio Toolkit Free Version

http://unity.clockstone.com/

SoundManager

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

namespace ZStudio.SoundManager
{
    public class SoundManager : MonoBehaviour
    {
        private static SoundManager _instance = null;
        private static float vol = 1f;
        private static float musicVol = 1f;
        private static float soundsVol = 1f;
        private static float UISoundsVol = 1f;

        private static Dictionary<int, Audio> musicAudio;
        private static Dictionary<int, Audio> soundsAudio;
        private static Dictionary<int, Audio> UISoundsAudio;

        private static bool initialized = false;

        private static SoundManager instance
        {
            get
            {
                if (_instance == null)
                {
                    _instance = (SoundManager)FindObjectOfType(typeof(SoundManager));
                    if (_instance == null)
                    {
                        // Create gameObject and add component
                        _instance = (new GameObject("ZSoundManager")).AddComponent<SoundManager>();
                    }
                }
                return _instance;
            }
        }

        /// <summary>
        /// The gameobject that the sound manager is attached to
        /// </summary>
        public static GameObject gameobject { get { return instance.gameObject; } }

        /// <summary>
        /// When set to true, new Audios that have the same audio clip as any other Audio, will be ignored
        /// </summary>
        public static bool ignoreDuplicateMusic { get; set; }

        /// <summary>
        /// When set to true, new Audios that have the same audio clip as any other Audio, will be ignored
        /// </summary>
        public static bool ignoreDuplicateSounds { get; set; }

        /// <summary>
        /// When set to true, new Audios that have the same audio clip as any other Audio, will be ignored
        /// </summary>
        public static bool ignoreDuplicateUISounds { get; set; }

        /// <summary>
        /// Global volume
        /// </summary>
        public static float globalVolume
        {
            get
            {
                return vol;
            }
            set
            {
                vol = value;
            }
        }

        /// <summary>
        /// Global music volume
        /// </summary>
        public static float globalMusicVolume
        {
            get
            {
                return musicVol;
            }
            set
            {
                musicVol = value;
            }
        }

        /// <summary>
        /// Global sounds volume
        /// </summary>
        public static float globalSoundsVolume
        {
            get
            {
                return soundsVol;
            }
            set
            {
                soundsVol = value;
            }
        }

        /// <summary>
        /// Global UI sounds volume
        /// </summary>
        public static float globalUISoundsVolume
        {
            get
            {
                return UISoundsVol;
            }
            set
            {
                UISoundsVol = value;
            }
        }

        void Awake()
        {
            instance.Init();
        }

        void Update()
        {
            List<int> keys;

            // Update music
            keys = new List<int>(musicAudio.Keys);
            for (var i = 0; i < keys.Count; i++)
            {
                int key = keys[i];
                Audio _audio = musicAudio[key];
                _audio.Update();

                // Remove all music clips that are not playing
                if (!_audio.playing && !_audio.paused)
                {
                    if (_audio.onComletelyPlayed != null)
                        _audio.onComletelyPlayed.Invoke(_audio);
                    Destroy(_audio.audioSource);
                    musicAudio.Remove(key);
                }
            }

            // Update sound fx
            keys = new List<int>(soundsAudio.Keys);
            for (var i = 0; i < keys.Count; i++)
            {
                int key = keys[i];
                Audio _audio = soundsAudio[key];
                _audio.Update();

                // Remove all sound fx clips that are not playing
                if (!_audio.playing && !_audio.paused)
                {
                    if (_audio.onComletelyPlayed != null)
                        _audio.onComletelyPlayed.Invoke(_audio);
                    Destroy(_audio.audioSource);
                    soundsAudio.Remove(key);
                }
            }

            // Update UI sound fx
            keys = new List<int>(UISoundsAudio.Keys);
            for (var i = 0; i < keys.Count; i++)
            {
                int key = keys[i];
                Audio _audio = UISoundsAudio[key];
                _audio.Update();

                // Remove all UI sound fx clips that are not playing
                if (!_audio.playing && !_audio.paused)
                {
                    if (_audio.onComletelyPlayed != null)
                        _audio.onComletelyPlayed.Invoke(_audio);
                    Destroy(_audio.audioSource);
                    UISoundsAudio.Remove(key);
                }
            }
        }

        void Init()
        {
            if (!initialized)
            {
                musicAudio = new Dictionary<int, Audio>();
                soundsAudio = new Dictionary<int, Audio>();
                UISoundsAudio = new Dictionary<int, Audio>();

                ignoreDuplicateMusic = false;
                ignoreDuplicateSounds = false;
                ignoreDuplicateUISounds = false;

                initialized = true;
                DontDestroyOnLoad(this);
            }
        }

        #region GetAudio Functions

        /// <summary>
        /// Returns the Audio that has as its id the audioID if one is found, returns null if no such Audio is found
        /// </summary>
        /// <param name="audioID">The id of the Audio to be retrieved</param>
        /// <returns>Audio that has as its id the audioID, null if no such Audio is found</returns>
        public static Audio GetAudio(int audioID)
        {
            Audio audio;

            audio = GetMusicAudio(audioID);
            if (audio != null)
            {
                return audio;
            }

            audio = GetSoundAudio(audioID);
            if (audio != null)
            {
                return audio;
            }

            audio = GetUISoundAudio(audioID);
            if (audio != null)
            {
                return audio;
            }

            return null;
        }

        /// <summary>
        /// Returns the first occurrence of Audio that plays the given audioClip. Returns null if no such Audio is found
        /// </summary>
        /// <param name="audioClip">The audio clip of the Audio to be retrieved</param>
        /// <returns>First occurrence of Audio that has as plays the audioClip, null if no such Audio is found</returns>
        public static Audio GetAudio(AudioClip audioClip)
        {
            Audio audio = GetMusicAudio(audioClip);
            if (audio != null)
            {
                return audio;
            }

            audio = GetSoundAudio(audioClip);
            if (audio != null)
            {
                return audio;
            }

            audio = GetUISoundAudio(audioClip);
            if (audio != null)
            {
                return audio;
            }

            return null;
        }

        /// <summary>
        /// Returns the music Audio that has as its id the audioID if one is found, returns null if no such Audio is found
        /// </summary>
        /// <param name="audioID">The id of the music Audio to be returned</param>
        /// <returns>Music Audio that has as its id the audioID if one is found, null if no such Audio is found</returns>
        public static Audio GetMusicAudio(int audioID)
        {
            List<int> keys = new List<int>(musicAudio.Keys);
            foreach (int key in keys)
            {
                if (audioID == key)
                {
                    return musicAudio[key];
                }
            }

            return null;
        }

        /// <summary>
        /// Returns the first occurrence of music Audio that plays the given audioClip. Returns null if no such Audio is found
        /// </summary>
        /// <param name="audioClip">The audio clip of the music Audio to be retrieved</param>
        /// <returns>First occurrence of music Audio that has as plays the audioClip, null if no such Audio is found</returns>
        public static Audio GetMusicAudio(AudioClip audioClip)
        {
            List<int> keys;
            keys = new List<int>(musicAudio.Keys);
            foreach (int key in keys)
            {
                Audio audio = musicAudio[key];
                if (audio.clip == audioClip)
                {
                    return audio;
                }
            }

            return null;
        }

        /// <summary>
        /// Returns the sound fx Audio that has as its id the audioID if one is found, returns null if no such Audio is found
        /// </summary>
        /// <param name="audioID">The id of the sound fx Audio to be returned</param>
        /// <returns>Sound fx Audio that has as its id the audioID if one is found, null if no such Audio is found</returns>
        public static Audio GetSoundAudio(int audioID)
        {
            List<int> keys = new List<int>(soundsAudio.Keys);
            foreach (int key in keys)
            {
                if (audioID == key)
                {
                    return soundsAudio[key];
                }
            }

            return null;
        }

        /// <summary>
        /// Returns the first occurrence of sound Audio that plays the given audioClip. Returns null if no such Audio is found
        /// </summary>
        /// <param name="audioClip">The audio clip of the sound Audio to be retrieved</param>
        /// <returns>First occurrence of sound Audio that has as plays the audioClip, null if no such Audio is found</returns>
        public static Audio GetSoundAudio(AudioClip audioClip)
        {
            List<int> keys;
            keys = new List<int>(soundsAudio.Keys);
            foreach (int key in keys)
            {
                Audio audio = soundsAudio[key];
                if (audio.clip == audioClip)
                {
                    return audio;
                }
            }

            return null;
        }

        /// <summary>
        /// Returns the UI sound fx Audio that has as its id the audioID if one is found, returns null if no such Audio is found
        /// </summary>
        /// <param name="audioID">The id of the UI sound fx Audio to be returned</param>
        /// <returns>UI sound fx Audio that has as its id the audioID if one is found, null if no such Audio is found</returns>
        public static Audio GetUISoundAudio(int audioID)
        {
            List<int> keys = new List<int>(UISoundsAudio.Keys);
            foreach (int key in keys)
            {
                if (audioID == key)
                {
                    return UISoundsAudio[key];
                }
            }

            return null;
        }

        /// <summary>
        /// Returns the first occurrence of UI sound Audio that plays the given audioClip. Returns null if no such Audio is found
        /// </summary>
        /// <param name="audioClip">The audio clip of the UI sound Audio to be retrieved</param>
        /// <returns>First occurrence of UI sound Audio that has as plays the audioClip, null if no such Audio is found</returns>
        public static Audio GetUISoundAudio(AudioClip audioClip)
        {
            List<int> keys;
            keys = new List<int>(UISoundsAudio.Keys);
            foreach (int key in keys)
            {
                Audio audio = UISoundsAudio[key];
                if (audio.clip == audioClip)
                {
                    return audio;
                }
            }

            return null;
        }

        #endregion

        #region Play Functions

        /// <summary>
        /// Play background music
        /// </summary>
        /// <param name="clip">The audio clip to play</param>
        /// <param name="onCompletelyPlayed">The audio play completed</param>
        /// <returns>The ID of the created Audio object</returns>
        public static int PlayMusic(AudioClip clip, Action<Audio> onCompletelyPlayed)
        {
            return PlayMusic(clip, 1f, false, false, 1f, 1f, -1f, null, onCompletelyPlayed);
        }

        /// <summary>
        /// Play background music
        /// </summary>
        /// <param name="clip">The audio clip to play</param>
        /// <param name="volume"> The volume the music will have</param>
        /// <param name="onCompletelyPlayed">The audio play completed</param>
        /// <returns>The ID of the created Audio object</returns>
        public static int PlayMusic(AudioClip clip, float volume, Action<Audio> onCompletelyPlayed)
        {
            return PlayMusic(clip, volume, false, false, 1f, 1f, -1f, null, onCompletelyPlayed);
        }

        /// <summary>
        /// Play background music
        /// </summary>
        /// <param name="clip">The audio clip to play</param>
        /// <param name="volume"> The volume the music will have</param>
        /// <param name="loop">Wether the music is looped</param>
        /// <param name = "persist" > Whether the audio persists in between scene changes</param>
        /// <param name="onCompletelyPlayed">The audio play completed</param>
        /// <returns>The ID of the created Audio object</returns>
        public static int PlayMusic(AudioClip clip, float volume, bool loop, bool persist, Action<Audio> onCompletelyPlayed)
        {
            return PlayMusic(clip, volume, loop, persist, 1f, 1f, -1f, null, onCompletelyPlayed);
        }

        /// <summary>
        /// Play background music
        /// </summary>
        /// <param name="clip">The audio clip to play</param>
        /// <param name="volume"> The volume the music will have</param>
        /// <param name="loop">Wether the music is looped</param>
        /// <param name="persist"> Whether the audio persists in between scene changes</param>
        /// <param name="fadeInSeconds">How many seconds it needs for the audio to fade in/ reach target volume (if higher than current)</param>
        /// <param name="fadeOutSeconds"> How many seconds it needs for the audio to fade out/ reach target volume (if lower than current)</param>
        /// <param name="onCompletelyPlayed">The audio play completed</param>
        /// <returns>The ID of the created Audio object</returns>
        public static int PlayMusic(AudioClip clip, float volume, bool loop, bool persist, float fadeInSeconds,
            float fadeOutSeconds, Action<Audio> onCompletelyPlayed)
        {
            return PlayMusic(clip, volume, loop, persist, fadeInSeconds, fadeOutSeconds, -1f, null, onCompletelyPlayed);
        }

        /// <summary>
        /// Play background music
        /// </summary>
        /// <param name="clip">The audio clip to play</param>
        /// <param name="volume"> The volume the music will have</param>
        /// <param name="loop">Wether the music is looped</param>
        /// <param name="persist"> Whether the audio persists in between scene changes</param>
        /// <param name="fadeInSeconds">How many seconds it needs for the audio to fade in/ reach target volume (if higher than current)</param>
        /// <param name="fadeOutSeconds"> How many seconds it needs for the audio to fade out/ reach target volume (if lower than current)</param>
        /// <param name="currentMusicfadeOutSeconds"> How many seconds it needs for current music audio to fade out. It will override its own fade out seconds. If -1 is passed, current music will keep its own fade out seconds</param>
        /// <param name="sourceTransform">The transform that is the source of the music (will become 3D audio). If 3D audio is not wanted, use null</param>
        /// <param name="onCompletelyPlayed">The audio play completed</param>
        /// <returns>The ID of the created Audio object</returns>
        public static int PlayMusic(AudioClip clip, float volume, bool loop, bool persist, float fadeInSeconds,
            float fadeOutSeconds, float currentMusicfadeOutSeconds, Transform sourceTransform, Action<Audio> onCompletelyPlayed)
        {
            if (clip == null)
            {
                Debug.LogError("Sound Manager: Audio clip is null, cannot play music", clip);
            }

            if(ignoreDuplicateMusic)
            {
                List<int> keys = new List<int>(musicAudio.Keys);
                foreach (int key in keys)
                {
                    if (musicAudio[key].audioSource.clip == clip)
                    {
                        return musicAudio[key].audioID;
                    }
                }
            }

            instance.Init();

            // Stop all current music playing
            StopAllMusic(currentMusicfadeOutSeconds);

            // Create the audioSource
            //AudioSource audioSource = instance.gameObject.AddComponent<AudioSource>() as AudioSource;
            Audio audio = new Audio(Audio.AudioType.Music, clip, loop, persist, volume, fadeInSeconds, fadeOutSeconds,
                sourceTransform, onCompletelyPlayed);

            // Add it to music list
            musicAudio.Add(audio.audioID, audio);

            return audio.audioID;
        }

        /// <summary>
        /// Play a sound fx
        /// </summary>
        /// <param name="clip">The audio clip to play</param>
        /// <param name="onCompletelyPlayed">The audio play completed</param>
        /// <returns>The ID of the created Audio object</returns>
        public static int PlaySound(AudioClip clip, Action<Audio> onCompletelyPlayed)
        {
            return PlaySound(clip, 1f, false, null, onCompletelyPlayed);
        }

        /// <summary>
        /// Play a sound fx
        /// </summary>
        /// <param name="clip">The audio clip to play</param>
        /// <param name="volume"> The volume the music will have</param>
        /// <param name="onCompletelyPlayed">The audio play completed</param>
        /// <returns>The ID of the created Audio object</returns>
        public static int PlaySound(AudioClip clip, float volume, Action<Audio> onCompletelyPlayed)
        {
            return PlaySound(clip, volume, false, null, onCompletelyPlayed);
        }

        /// <summary>
        /// Play a sound fx
        /// </summary>
        /// <param name="clip">The audio clip to play</param>
        /// <param name="loop">Wether the sound is looped</param>
        /// <param name="onCompletelyPlayed">The audio play completed</param>
        /// <returns>The ID of the created Audio object</returns>
        public static int PlaySound(AudioClip clip, bool loop, Action<Audio> onCompletelyPlayed)
        {
            return PlaySound(clip, 1f, loop, null, onCompletelyPlayed);
        }

        /// <summary>
        /// Play a sound fx
        /// </summary>
        /// <param name="clip">The audio clip to play</param>
        /// <param name="volume"> The volume the music will have</param>
        /// <param name="loop">Wether the sound is looped</param>
        /// <param name="sourceTransform">The transform that is the source of the sound (will become 3D audio). If 3D audio is not wanted, use null</param>
        /// <param name="onCompletelyPlayed">The audio play completed</param>
        /// <returns>The ID of the created Audio object</returns>
        public static int PlaySound(AudioClip clip, float volume, bool loop, Transform sourceTransform, Action<Audio> onCompletelyPlayed)
        {
            if (clip == null)
            {
                Debug.LogError("Sound Manager: Audio clip is null, cannot play music", clip);
            }

            if (ignoreDuplicateSounds)
            {
                List<int> keys = new List<int>(soundsAudio.Keys);
                foreach (int key in keys)
                {
                    if (soundsAudio[key].audioSource.clip == clip)
                    {
                        return soundsAudio[key].audioID;
                    }
                }
            }

            instance.Init();

            // Create the audioSource
            //AudioSource audioSource = instance.gameObject.AddComponent<AudioSource>() as AudioSource;
            Audio audio = new Audio(Audio.AudioType.Sound, clip, loop, false, volume, 0f, 0f, sourceTransform, onCompletelyPlayed);

            // Add it to music list
            soundsAudio.Add(audio.audioID, audio);

            return audio.audioID;
        }

        /// <summary>
        /// Play a UI sound fx
        /// </summary>
        /// <param name="clip">The audio clip to play</param>
        /// <param name="onCompletelyPlayed">The audio play completed</param>
        /// <returns>The ID of the created Audio object</returns>
        public static int PlayUISound(AudioClip clip, Action<Audio> onCompletelyPlayed)
        {
            return PlayUISound(clip, 1f, onCompletelyPlayed);
        }

        /// <summary>
        /// Play a UI sound fx
        /// </summary>
        /// <param name="clip">The audio clip to play</param>
        /// <param name="volume"> The volume the music will have</param>
        /// <param name="onCompletelyPlayed">The audio play completed</param>
        /// <returns>The ID of the created Audio object</returns>
        public static int PlayUISound(AudioClip clip, float volume, Action<Audio> onCompletelyPlayed)
        {
            if (clip == null)
            {
                Debug.LogError("Sound Manager: Audio clip is null, cannot play music", clip);
            }

            if (ignoreDuplicateUISounds)
            {
                List<int> keys = new List<int>(UISoundsAudio.Keys);
                foreach (int key in keys)
                {
                    if (UISoundsAudio[key].audioSource.clip == clip)
                    {
                        return UISoundsAudio[key].audioID;
                    }
                }
            }

            instance.Init();

            // Create the audioSource
            //AudioSource audioSource = instance.gameObject.AddComponent<AudioSource>() as AudioSource;
            Audio audio = new Audio(Audio.AudioType.UISound, clip, false, false, volume, 0f, 0f, null, onCompletelyPlayed);

            // Add it to music list
            UISoundsAudio.Add(audio.audioID, audio);

            return audio.audioID;
        }

        #endregion

        #region Stop Functions

        /// <summary>
        /// Stop all audio playing
        /// </summary>
        public static void StopAll()
        {
            StopAll(-1f);
        }

        /// <summary>
        /// Stop all audio playing
        /// </summary>
        /// <param name="fadeOutSeconds"> How many seconds it needs for all music audio to fade out. It will override  their own fade out seconds. If -1 is passed, all music will keep their own fade out seconds</param>
        public static void StopAll(float fadeOutSeconds)
        {
            StopAllMusic(fadeOutSeconds);
            StopAllSounds();
            StopAllUISounds();
        }

        /// <summary>
        /// Stop all music playing
        /// </summary>
        public static void StopAllMusic()
        {
            StopAllMusic(-1f);
        }

        /// <summary>
        /// Stop all music playing
        /// </summary>
        /// <param name="fadeOutSeconds"> How many seconds it needs for all music audio to fade out. It will override  their own fade out seconds. If -1 is passed, all music will keep their own fade out seconds</param>
        public static void StopAllMusic(float fadeOutSeconds)
        {
            List<int> keys = new List<int>(musicAudio.Keys);
            foreach (int key in keys)
            {
                Audio audio = musicAudio[key];
                if (fadeOutSeconds > 0)
                {
                    audio.fadeOutSeconds = fadeOutSeconds;
                }
                audio.Stop();
            }
        }

        /// <summary>
        /// Stop all sound fx playing
        /// </summary>
        public static void StopAllSounds()
        {
            List<int> keys = new List<int>(soundsAudio.Keys);
            foreach (int key in keys)
            {
                Audio audio = soundsAudio[key];
                audio.Stop();
            }
        }

        /// <summary>
        /// Stop all UI sound fx playing
        /// </summary>
        public static void StopAllUISounds()
        {
            List<int> keys = new List<int>(UISoundsAudio.Keys);
            foreach (int key in keys)
            {
                Audio audio = UISoundsAudio[key];
                audio.Stop();
            }
        }

        #endregion

        #region Pause Functions

        /// <summary>
        /// Pause all audio playing
        /// </summary>
        public static void PauseAll()
        {
            PauseAllMusic();
            PauseAllSounds();
            PauseAllUISounds();
        }

        /// <summary>
        /// Pause all music playing
        /// </summary>
        public static void PauseAllMusic()
        {
            List<int> keys = new List<int>(musicAudio.Keys);
            foreach (int key in keys)
            {
                Audio audio = musicAudio[key];
                audio.Pause();
            }
        }

        /// <summary>
        /// Pause all sound fx playing
        /// </summary>
        public static void PauseAllSounds()
        {
            List<int> keys = new List<int>(soundsAudio.Keys);
            foreach (int key in keys)
            {
                Audio audio = soundsAudio[key];
                audio.Pause();
            }
        }

        /// <summary>
        /// Pause all UI sound fx playing
        /// </summary>
        public static void PauseAllUISounds()
        {
            List<int> keys = new List<int>(UISoundsAudio.Keys);
            foreach (int key in keys)
            {
                Audio audio = UISoundsAudio[key];
                audio.Pause();
            }
        }

        #endregion

        #region Resume Functions

        /// <summary>
        /// Resume all audio playing
        /// </summary>
        public static void ResumeAll()
        {
            ResumeAllMusic();
            ResumeAllSounds();
            ResumeAllUISounds();
        }

        /// <summary>
        /// Resume all music playing
        /// </summary>
        public static void ResumeAllMusic()
        {
            List<int> keys = new List<int>(musicAudio.Keys);
            foreach (int key in keys)
            {
                Audio audio = musicAudio[key];
                audio.Resume();
            }
        }

        /// <summary>
        /// Resume all sound fx playing
        /// </summary>
        public static void ResumeAllSounds()
        {
            List<int> keys = new List<int>(soundsAudio.Keys);
            foreach (int key in keys)
            {
                Audio audio = soundsAudio[key];
                audio.Resume();
            }
        }

        /// <summary>
        /// Resume all UI sound fx playing
        /// </summary>
        public static void ResumeAllUISounds()
        {
            List<int> keys = new List<int>(UISoundsAudio.Keys);
            foreach (int key in keys)
            {
                Audio audio = UISoundsAudio[key];
                audio.Resume();
            }
        }

        #endregion
    }

    public class Audio
    {
        private static int audioCounter = 0;
        private float volume;
        private float targetVolume;
        private float initTargetVolume;
        private float tempFadeSeconds;
        private float fadeInterpolater;
        private float onFadeStartVolume;
        private AudioType audioType;
        private AudioClip initClip;
        private Transform sourceTransform;

        /// <summary>
        /// The ID of the Audio
        /// </summary>
        public int audioID { get; private set; }

        /// <summary>
        /// The audio source that is responsible for this audio
        /// </summary>
        public AudioSource audioSource { get; private set; }

        /// <summary>
        /// Audio clip to play/is playing
        /// </summary>
        public AudioClip clip
        {
            get
            {
                return audioSource == null ? initClip : audioSource.clip;
            }
        }

        /// <summary>
        /// Whether the audio will be lopped
        /// </summary>
        public bool loop { get; set; }

        /// <summary>
        /// Whether the audio persists in between scene changes
        /// </summary>
        public bool persist { get; set; }

        /// <summary>
        /// How many seconds it needs for the audio to fade in/ reach target volume (if higher than current)
        /// </summary>
        public float fadeInSeconds { get; set; }

        /// <summary>
        /// How many seconds it needs for the audio to fade out/ reach target volume (if lower than current)
        /// </summary>
        public float fadeOutSeconds { get; set; }

        /// <summary>
        /// Whether the audio is currently playing
        /// </summary>
        public bool playing { get; set; }

        /// <summary>
        /// Whether the audio is paused
        /// </summary>
        public bool paused { get; private set; }

        /// <summary>
        /// Whether the audio is stopping
        /// </summary>
        public bool stopping { get; private set; }        

        /// <summary>
        /// Whether the audio is created and updated at least once. 
        /// </summary>
        public bool activated { get; private set; }

        /// <summary>
        /// The audio played completed.
        /// </summary>
        public Action<Audio> onComletelyPlayed;

        public enum AudioType
        {
            Music,
            Sound,
            UISound
        }

        public Audio(AudioType audioType, AudioClip clip, bool loop, bool persist, float volume, float fadeInValue,
            float fadeOutValue, Transform sourceTransform, Action<Audio> onComletelyPlayed)
        {
            if (sourceTransform == null)
            {
                this.sourceTransform = SoundManager.gameobject.transform;
            }
            else
            {
                this.sourceTransform = sourceTransform;
            }

            this.audioID = audioCounter;
            audioCounter++;

            this.audioType = audioType;
            this.initClip = clip;
            this.loop = loop;
            this.persist = persist;
            this.targetVolume = volume;
            this.initTargetVolume = volume;
            this.tempFadeSeconds = -1;
            this.volume = 0f;
            this.fadeInSeconds = fadeInValue;
            this.fadeOutSeconds = fadeOutValue;
            this.onComletelyPlayed = onComletelyPlayed;

            this.playing = false;
            this.paused = false;
            this.activated = false;

            CreateAudiosource(clip, loop);
            Play();
        }

        void CreateAudiosource(AudioClip clip, bool loop)
        {
            audioSource = sourceTransform.gameObject.AddComponent<AudioSource>() as AudioSource;

            audioSource.clip = clip;
            audioSource.loop = loop;
            audioSource.volume = 0f;
            if (sourceTransform != SoundManager.gameobject.transform)
            {
                audioSource.spatialBlend = 1;
            }
        }

        /// <summary>
        /// Start playing audio clip from the beggining
        /// </summary>
        public void Play()
        {
            Play(initTargetVolume);
        }

        /// <summary>
        /// Start playing audio clip from the beggining
        /// </summary>
        /// <param name="volume">The target volume</param>
        public void Play(float volume)
        {
            if(audioSource == null)
            {
                CreateAudiosource(initClip, loop);
            }

            audioSource.Play();
            playing = true;

            fadeInterpolater = 0f;
            onFadeStartVolume = this.volume;
            targetVolume = volume;
        }

        /// <summary>
        /// Stop playing audio clip
        /// </summary>
        public void Stop()
        {
            fadeInterpolater = 0f;
            onFadeStartVolume = volume;
            targetVolume = 0f;

            stopping = true;
        }

        /// <summary>
        /// Pause playing audio clip
        /// </summary>
        public void Pause()
        {
            audioSource.Pause();
            paused = true;
        }

        /// <summary>
        /// Resume playing audio clip
        /// </summary>
        public void Resume()
        {
            audioSource.UnPause();
            paused = false;
        }

        /// <summary>
        /// Sets the audio volume
        /// </summary>
        /// <param name="volume">The target volume</param>
        public void SetVolume(float volume)
        {
            if(volume > targetVolume)
            {
                SetVolume(volume, fadeOutSeconds);
            }
            else
            {
                SetVolume(volume, fadeInSeconds);
            }
        }

        /// <summary>
        /// Sets the audio volume
        /// </summary>
        /// <param name="volume">The target volume</param>
        /// <param name="fadeSeconds">How many seconds it needs for the audio to fade in/out to reach target volume. If passed, it will override the Audio's fade in/out seconds, but only for this transition</param>
        public void SetVolume(float volume, float fadeSeconds)
        {
            SetVolume(volume, fadeSeconds, this.volume);
        }

        /// <summary>
        /// Sets the audio volume
        /// </summary>
        /// <param name="volume">The target volume</param>
        /// <param name="fadeSeconds">How many seconds it needs for the audio to fade in/out to reach target volume. If passed, it will override the Audio's fade in/out seconds, but only for this transition</param>
        /// <param name="startVolume">Immediately set the volume to this value before beginning the fade. If not passed, the Audio will start fading from the current volume towards the target volume</param>
        public void SetVolume(float volume, float fadeSeconds, float startVolume) 
        {
            targetVolume = Mathf.Clamp01(volume);
            fadeInterpolater = 0;
            onFadeStartVolume = startVolume;
            tempFadeSeconds = fadeSeconds;
        }

        /// <summary>
        /// Sets the Audio 3D max distance
        /// </summary>
        /// <param name="max">the max distance</param>
        public void Set3DMaxDistance(float max)
        {
            audioSource.maxDistance = max;
        }

        /// <summary>
        /// Sets the Audio 3D min distance
        /// </summary>
        /// <param name="max">the min distance</param>
        public void Set3DMinDistance(float min)
        {
            audioSource.minDistance = min;
        }

        /// <summary>
        /// Sets the Audio 3D distances
        /// </summary>
        /// <param name="min">the min distance</param>
        /// <param name="max">the max distance</param>
        public void Set3DDistances(float min, float max)
        {
            Set3DMinDistance(min);
            Set3DMaxDistance(max);
        }

        public void Update()
        {
            if(audioSource == null)
            {
                return;
            }

            activated = true;

            if (volume != targetVolume)
            {
                float fadeValue;
                fadeInterpolater += Time.deltaTime;
                if (volume > targetVolume)
                {
                    fadeValue = tempFadeSeconds != -1? tempFadeSeconds: fadeOutSeconds;
                }
                else
                {
                    fadeValue = tempFadeSeconds != -1 ? tempFadeSeconds : fadeInSeconds;
                }

                volume = Mathf.Lerp(onFadeStartVolume, targetVolume, fadeInterpolater / fadeValue);
            }
            else if(tempFadeSeconds != -1)
            {
                tempFadeSeconds = -1;
            }

            switch (audioType)
            {
                case AudioType.Music:
                    {
                        audioSource.volume = volume * SoundManager.globalMusicVolume * SoundManager.globalVolume;
                        break;
                    }
                case AudioType.Sound:
                    {
                        audioSource.volume = volume * SoundManager.globalSoundsVolume * SoundManager.globalVolume;
                        break;
                    }
                case AudioType.UISound:
                    {
                        audioSource.volume = volume * SoundManager.globalUISoundsVolume * SoundManager.globalVolume;
                        break;
                    }
            }

            if (volume == 0f && stopping)
            {
                audioSource.Stop();
                stopping = false;
                playing = false;
                paused = false;
            }

            // Update playing status
            if (audioSource.isPlaying != playing)
            {
                playing = audioSource.isPlaying;
            }
        }
    }
}

ZSAudioController

using System;
using System.Collections.Generic;
using UnityEngine;
using ZStudio.SoundManager;
using Object = UnityEngine.Object;

public class ZSAudioControllerStub : MonoBehaviour
{
    public List<AudioSett> audioSetts;
    public AudioGlobalSett audioGlobalSett = new AudioGlobalSett();

    public AudioSett GetAudio(string an)
    {
        return audioSetts.Find(aud => aud.name == an);
    }
}

[Serializable]
public class AudioGlobalSett
{
    public float uiVolome;
    public float fxVolume;
    public float soundVolume;

    public bool ignoreDuplicateMusic;
    public bool ignoreDuplicateSounds;
    public bool ignoreDuplicateUISounds;

    public AudioGlobalSett()
    {
        uiVolome = 1;
        fxVolume = 1;
        soundVolume = 1;

        ignoreDuplicateMusic = false;
        ignoreDuplicateSounds = false;
        ignoreDuplicateUISounds = false;
    }
}

[Serializable]
public class AudioSett
{
    public Audio.AudioType type;

    public string name;
    public AudioClip clip;
    public float volume;
    public bool loop;
    public bool persist;
    public float fadeInSec;
    public float fadeOutSec;

    public AudioSett()
    {
        volume = 1;
        loop = false;
        persist = false;
        fadeInSec = 0;
        fadeOutSec = 0;
    }
}

public class ZSAudioController : Singleton<ZSAudioController>
{
    private static ZSAudioControllerStub stub;

    public enum RangeType
    {
        Music,
        Sound,
        UISound,
        All
    }

    private static void  InitStub()
    {
        var stubs = Object.FindObjectsOfType<ZSAudioControllerStub>();
        if (stubs.Length > 1)
        {
            Debug.LogWarning("More than one ZSAudioControllerStub in scene.");
            foreach (var st in stubs)
            {
                Object.DestroyObject(st.gameObject);
            }
        }
        else if (stubs.Length == 1) stub = stubs[0];

        if (stub == null)
            stub = Object.Instantiate(Resources.Load<ZSAudioControllerStub>("AudioController"));
        Object.DontDestroyOnLoad(stub.gameObject);
    }

    public static void Play(string audid, Action<Audio> onPlayed = null)
    {
        if (stub == null) InitStub();

        AudioSett _ass = stub.GetAudio(audid);
        if (_ass != null)
        {
            if (_ass.type == Audio.AudioType.Music)
            {
                SoundManager.PlayMusic(_ass.clip, _ass.volume, _ass.loop, _ass.persist, _ass.fadeInSec,
                    _ass.fadeOutSec, onPlayed);
            }
            else if (_ass.type == Audio.AudioType.Sound)
            {
                SoundManager.PlaySound(_ass.clip, _ass.volume, _ass.loop, null, onPlayed);
            }
            else if (_ass.type == Audio.AudioType.UISound)
            {
                SoundManager.PlayUISound(_ass.clip, _ass.volume, onPlayed);
            }          
        }
    }

    public static void Stop(string audid)
    {
        if (stub == null) InitStub();

        AudioSett _ass = stub.GetAudio(audid);
        if (_ass != null)
        {
            Audio _audio = SoundManager.GetAudio(_ass.clip);
            if (_audio != null) _audio.Stop();
        }
    }

    public static void Pause(string audid)
    {
        if (stub == null) InitStub();

        AudioSett _ass = stub.GetAudio(audid);
        if (_ass != null)
        {
            Audio _audio = SoundManager.GetAudio(_ass.clip);
            if (_audio != null) _audio.Pause();
        }
    }

    public static void Resume(string audid)
    {
        if (stub == null) InitStub();

        AudioSett _ass = stub.GetAudio(audid);
        if (_ass != null)
        {
            Audio _audio = SoundManager.GetAudio(_ass.clip);
            if (_audio != null) _audio.Resume();
        }
    }

    public static void Stop(RangeType range)
    {
        if (range == RangeType.Music) SoundManager.StopAllMusic();
        if (range == RangeType.Sound) SoundManager.StopAllSounds();
        if (range == RangeType.UISound) SoundManager.StopAllUISounds();
        if (range == RangeType.All) SoundManager.StopAll();
    }

    public static void Pause(RangeType range)
    {
        if (range == RangeType.Music) SoundManager.PauseAllMusic();
        if (range == RangeType.Sound) SoundManager.PauseAllSounds();
        if (range == RangeType.UISound) SoundManager.PauseAllUISounds();
        if (range == RangeType.All) SoundManager.PauseAll();
    }

    public static void Resume(RangeType range)
    {
        if (range == RangeType.Music) SoundManager.ResumeAllMusic();
        if (range == RangeType.Sound) SoundManager.ResumeAllSounds();
        if (range == RangeType.UISound) SoundManager.ResumeAllUISounds();
        if (range == RangeType.All) SoundManager.ResumeAll();
    }
}

ZSAudioControllerEditor

using UnityEditor;
using UnityEngine;
using ZStudio.SoundManager;

[CustomEditor(typeof(ZSAudioControllerStub))]
[CanEditMultipleObjects]
public class ZSAudioControllerEditor : Editor
{
    private SerializedProperty ass;
    private SerializedProperty ags;
    private Audio.AudioType audioType;

    private bool showAudio = true;
    private bool showGlobal = true;
    private int deleteIndex = -1;
    private int selectedIndex = 0;

    private GUIStyle labelStyle;
    private GUIStyle foldoutStyle;

    // 当对象已启用并处于活动状态时调用此函数
    private void OnEnable()
    {
        ass = serializedObject.FindProperty("audioSetts");
        ags = serializedObject.FindProperty("audioGlobalSett");
    }

    private void SetStyles()
    {
        foldoutStyle = new GUIStyle(EditorStyles.foldout);
        Color color = new Color(0, 0, 0.2f);
        foldoutStyle.onNormal.background = EditorStyles.boldLabel.onNormal.background;
        foldoutStyle.onFocused.background = EditorStyles.boldLabel.onNormal.background;
        foldoutStyle.onActive.background = EditorStyles.boldLabel.onNormal.background;
        foldoutStyle.onHover.background = EditorStyles.boldLabel.onNormal.background;
        foldoutStyle.normal.textColor = color;
        foldoutStyle.focused.textColor = color;
        foldoutStyle.active.textColor = color;
        foldoutStyle.hover.textColor = color;
        foldoutStyle.fixedWidth = 1000f;

        labelStyle = new GUIStyle(EditorStyles.foldout);
        color = new Color(0, 0, 0.5f);
        labelStyle.onNormal.background = EditorStyles.boldLabel.onNormal.background;
        labelStyle.onFocused.background = EditorStyles.boldLabel.onNormal.background;
        labelStyle.onActive.background = EditorStyles.boldLabel.onNormal.background;
        labelStyle.onHover.background = EditorStyles.boldLabel.onNormal.background;
        labelStyle.font = EditorStyles.boldFont;
        labelStyle.normal.textColor = color;
        labelStyle.focused.textColor = color;
        labelStyle.active.textColor = color;
        labelStyle.hover.textColor = color;
        labelStyle.fixedWidth = 1000f;
    }

    public override void OnInspectorGUI()
    {
        SetStyles();
        serializedObject.Update();

        // 全局设定
        GlobalSetting();

        //GUILayout.Label("添加/删除音乐", foldoutStyle);
        EditorGUILayout.Foldout(true, "添加音乐", foldoutStyle);
        GUILayout.BeginVertical("Box");
        GUILayout.BeginHorizontal("Box");
        audioType = (Audio.AudioType) EditorGUILayout.EnumPopup(audioType, GUILayout.MinWidth(65));
        GUILayout.Label("", GUILayout.MaxWidth(1000));
        GUILayout.EndHorizontal();
        GUILayout.BeginHorizontal("box");
        if (GUILayout.Button("Add", GUILayout.Width(50)))
        {
            AddAudio(audioType);
        }
        GUILayout.Label("", GUILayout.MaxWidth(1000));
        if (GUILayout.Button("ClearAll", GUILayout.MinWidth(80)))
        {
            ass.ClearArray();
        }
        GUILayout.EndHorizontal();
        GUILayout.EndVertical();
        GUILayout.Space(10);

        // 移除项
        if (deleteIndex > -1)
        {
            RemoveAudio(deleteIndex);
            deleteIndex = -1;
        }

        showAudio = EditorGUILayout.Foldout(showAudio, new GUIContent("音乐列表"), foldoutStyle);
        if (showAudio)
        {   
            PopupAudio();
            if (ass.arraySize > selectedIndex)
            {
                var audio = ass.GetArrayElementAtIndex(selectedIndex);
                DrawAudio(audio, selectedIndex);
            }
        }

        serializedObject.ApplyModifiedProperties();
    }

    private void GlobalSetting()
    {
        GUILayout.BeginVertical();
        showGlobal = EditorGUILayout.Foldout(showGlobal, "Global Settings", foldoutStyle);
        if (showGlobal)
        {
            var uiv = ags.FindPropertyRelative("uiVolome");
            EditorGUILayout.Slider(uiv, 0, 1, "UI Volume:");
            var fxv = ags.FindPropertyRelative("fxVolume");
            EditorGUILayout.Slider(fxv, 0, 1, "Fx Volume:");
            var sdv = ags.FindPropertyRelative("soundVolume");
            EditorGUILayout.Slider(sdv, 0, 1, "Sound Volume:");
            GUILayout.EndVertical();
        }
    }

    private void PopupAudio()
    {
        string[] names = new string[ass.arraySize];
        for (int i = 0; i < ass.arraySize; i++)
        {
            SerializedProperty _ass = ass.GetArrayElementAtIndex(i);
            string _name = _ass.FindPropertyRelative("name").stringValue;
            names[i] = _name;
        }

        GUILayout.BeginHorizontal(new GUIStyle(EditorStyles.whiteBoldLabel));
        selectedIndex = EditorGUILayout.Popup("Audio:", selectedIndex, names);
        GUILayout.EndHorizontal();
    }

    private void DrawAudio(SerializedProperty audio, int index)
    {
        GUILayout.BeginVertical("Box");

        GUILayout.BeginHorizontal();
        EditorGUILayout.LabelField("Type:", GUILayout.MaxWidth(40));
        SerializedProperty _type = audio.FindPropertyRelative("type");
        EditorGUILayout.PropertyField(_type, new GUIContent(""), GUILayout.MaxWidth(200));
        GUILayout.Label("", GUILayout.MaxWidth(1000));
        if (GUILayout.Button("-", GUILayout.MaxWidth(25)))
        {
            deleteIndex = index;
        }
        GUILayout.EndHorizontal();

        SerializedProperty _clip = audio.FindPropertyRelative("clip");
        EditorGUILayout.PropertyField(_clip, new GUIContent("Audio Clip:"));
        SerializedProperty _name = audio.FindPropertyRelative("name");
        EditorGUILayout.PropertyField(_name, new GUIContent("Audio Name:"));
        SerializedProperty _volume = audio.FindPropertyRelative("volume");
        EditorGUILayout.Slider(_volume, 0, 1, "Volume:");
        SerializedProperty _loop = audio.FindPropertyRelative("loop");
        EditorGUILayout.PropertyField(_loop, new GUIContent("Loop:"));
        SerializedProperty _persist = audio.FindPropertyRelative("persist");
        EditorGUILayout.PropertyField(_persist, new GUIContent("Persist:"));
        GUILayout.BeginHorizontal();
        SerializedProperty _fadeInSec = audio.FindPropertyRelative("fadeInSec");
        EditorGUILayout.PropertyField(_fadeInSec, new GUIContent("Fade-In:"));
        GUILayout.Label("Sec");
        GUILayout.EndHorizontal();
        GUILayout.BeginHorizontal();
        SerializedProperty _fadeOutSec = audio.FindPropertyRelative("fadeOutSec");
        EditorGUILayout.PropertyField(_fadeOutSec, new GUIContent("Fade-Out:"));
        GUILayout.Label("Sec");
        GUILayout.EndHorizontal();

        GUILayout.EndVertical();       
    }

    private void AddAudio(Audio.AudioType type)
    {
        AudioClip[] clips = GetSelectedAudioClips();
        for (int i = 0; i < clips.Length; i++)
        {
            ass.arraySize += 1;
            var _audio = ass.GetArrayElementAtIndex(ass.arraySize - 1);
            _audio.FindPropertyRelative("clip").objectReferenceValue = clips[i];
            _audio.FindPropertyRelative("name").stringValue = clips[i].name;
            _audio.FindPropertyRelative("type").enumValueIndex = (int)type;
            _audio.FindPropertyRelative("volume").floatValue = 1;
            _audio.FindPropertyRelative("loop").boolValue = false;
            _audio.FindPropertyRelative("persist").boolValue = false;
            _audio.FindPropertyRelative("fadeInSec").floatValue = 0;
            _audio.FindPropertyRelative("fadeOutSec").floatValue = 0;
        }
        serializedObject.ApplyModifiedProperties();
    }

    private void RemoveAudio(int index)
    {
        if (index >= ass.arraySize || index < 0)
        {
            Debug.LogWarning("invalid index in DeleteArrayElement: " + index);
        }
        else
        {
            ass.DeleteArrayElementAtIndex(index);
            // 最后一个元素被删除
            if (selectedIndex >= ass.arraySize - 1)
            {
                selectedIndex -= 1;
                if (selectedIndex < 0) selectedIndex = 0;
            }
        }
    }

    // 获取选中的音乐或者文件夹下面的音乐
    private AudioClip[] GetSelectedAudioClips()
    {
        var filtered = Selection.GetFiltered<AudioClip>(SelectionMode.DeepAssets);
        return filtered;
    }
}

• 测试播放

---

// TODEBUG 测试声音播放
ZSAudioController.Play("0");

添加音乐只需要在资源视图中选中音乐或者音乐文件夹，点击Add.