plugin-library/Assets/04.AudioCore/RunTime/Abstract/IAudio.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading;
using Cysharp.Threading.Tasks;
using UnityEngine;

namespace Stary.Evo.AudioCore
{
    /// <summary>
    /// Audio数据
    /// </summary>
    public struct AudioData
    {
        /// <summary>
        /// 延迟播放时间
        /// </summary>
        public float delayTime;

        /// <summary>
        /// 资源包名
        /// </summary>
        public string packageName;

        /// <summary>
        /// 资源名
        /// </summary>
        public string assetName;

        /// <summary>
        /// 音频
        /// </summary>
        public AudioClip clip;

        /// <summary>
        /// 音量
        /// </summary>
        public float volume;

        /// <summary>
        /// 回调行为
        /// </summary>
        public System.Action onComplete;

        /// <summary>
        /// 延迟回调执行的时间
        /// </summary>
        public float delayOnCompleteTime;

        /// <summary>
        /// 自然过渡时间
        /// </summary>
        public float fadeDuration;

        /// <summary>
        /// 是否不打断上一段对话
        /// </summary>
        public bool isNotOverVoice;

        /// <summary>
        /// 是否是3D音频
        /// </summary>
        public bool is3DAudio;

        /// <summary>
        /// 3D声音位置
        /// </summary>
        public Vector3 audio3DPosition;

        /// <summary>
        /// 3D声音最大距离
        /// </summary>
        public float audio3DMaxDistance;
    }

    public interface IAudio
    {
        IResources Resources { get; set; }
        AudioSourcePool AudioSourcePool { get; set; }
        AudioData Initialize(AudioData audioData);
        void Play(AudioData audioData);

        UniTask PlayAsync(AudioData audioData);
        UniTask FadeInMusic(AudioSource source, float fadeDuration);
        UniTask FadeOutMusic(AudioSource source, float fadeDuration);


        void Stop();
        void StopAll();
    }

    public abstract class AbstractAudio : IAudio
    {
        public IResources Resources { get; set; }

        public AudioSourcePool AudioSourcePool { get; set; }
        public abstract void Play(AudioData audioData);

        public abstract UniTask PlayAsync(AudioData audioData);

        public abstract void StopAll();


        public virtual void Stop()
        {
        }

        protected AbstractAudio(IResources resources)
        {
            Resources = resources;
            if (!GetType().Name.Contains("Music"))
            {
                AudioSourcePool = new AudioSourcePool(GetType().Name, -1);
                AudioSourcePool.Creation();
            }
        }
        /// <summary>
        /// 音频数据初始化
        /// </summary>
        /// <param name="audioData"></param>
        /// <returns></returns>
        public virtual AudioData Initialize(AudioData audioData)
        {
            if (audioData.volume == 0)
            {
                audioData.volume = 1f;
            }

            if (audioData.fadeDuration == 0)
            {
                audioData.fadeDuration = 1f;
            }

            return audioData;
        }

        /// <summary>
        /// 音频淡入
        /// </summary>
        /// <param name="source"></param>
        /// <param name="fadeDuration"></param>
        /// <returns></returns>
        public async UniTask FadeInMusic(AudioSource source, float fadeDuration)
        {
            float targetVolume = source.volume;
            source.volume = 0;

            while (source.volume < targetVolume)
            {
                source.volume += targetVolume * Time.deltaTime / fadeDuration;
                await UniTask.Yield();
            }
        }

        /// <summary>
        /// 音频淡出
        /// </summary>
        /// <param name="source"></param>
        /// <param name="fadeDuration"></param>
        /// <returns></returns>
        public async UniTask FadeOutMusic(AudioSource source, float fadeDuration)
        {
            if (source != null)
            {
                float startVolume = source.volume;

                while (source.volume > 0)
                {
                    source.volume -= startVolume * Time.deltaTime / fadeDuration;
                    await UniTask.Yield();
                }

                source.Stop();
            }
        }

        /// <summary>
        /// 播放音效的协程
        /// </summary>
        /// <param name="source"></param>
        /// <param name="delay"></param>
        /// <param name="onComplete"></param>
        /// <returns></returns>    
        public async UniTask PlayAudioAWait(AudioSourceToken audioSourceToken, float delay, System.Action onComplete)
        {
            await PlayAudioAWait(audioSourceToken, delay);
            onComplete?.Invoke();
        }

        /// <summary>
        /// 播放音效的协程
        /// </summary>
        /// <param name="source"></param>
        /// <param name="delay"></param>
        /// <param name="onComplete"></param>
        /// <returns></returns>    
        public async UniTask PlayAudioAWait(AudioSourceToken audioSourceToken, float delay)
        {
            Debug.Log($"PlayAudioAWait:{GetType().Name}");
            if (!GetType().Name.Contains("Voice"))
            {
                await UniTask.Delay(TimeSpan.FromSeconds(audioSourceToken.source.clip.length - 2f),
                    cancellationToken: audioSourceToken.cancellationToken.Token);
                await FadeOutMusic(audioSourceToken.source, 2f);
                await UniTask.Delay(TimeSpan.FromSeconds(delay),
                    cancellationToken: audioSourceToken.cancellationToken.Token);
            }
            else
            {
                await UniTask.Delay(TimeSpan.FromSeconds(audioSourceToken.source.clip.length + delay),
                    cancellationToken: audioSourceToken.cancellationToken.Token);
            }

            AudioSourcePool.RecycleSpawn(audioSourceToken);
        }
    }
}