UnityAudioManager声音管理器怎么用

本篇内容主要讲解“Unity AudioManager声音管理器怎么用”,感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷,实用性强。下面就让小编来带大家学习“Unity AudioManager声音管理器怎么用”吧!

10多年的聂荣网站建设经验,针对设计、前端、开发、售后、文案、推广等六对一服务,响应快,48小时及时工作处理。网络营销推广的优势是能够根据用户设备显示端的尺寸不同,自动调整聂荣建站的显示方式,使网站能够适用不同显示终端,在浏览器中调整网站的宽度,无论在任何一种浏览器上浏览网站,都能展现优雅布局与设计,从而大程度地提升浏览体验。创新互联公司从事“聂荣网站设计”,“聂荣网站推广”以来,每个客户项目都认真落实执行。

我们一般会把音频分为四类:以农场类项目为例

1.背景音乐:全局只有一个,不同的场景不同的时间不同的天气都会有不同的背景音乐,其主要作用是为了烘托氛围。所以大部分的背景音乐都是2d的且音量是所有音效中最低的,目的为不突兀不刺激为主。

// 播放背景音乐
public void PlayBackgroundMusic(AudioClip clip, bool isLoop = true, float speed = 1)
// 暂停播放背景音乐
public void PauseBackgroundMusic(bool isGradual = true)

2.人声配音:全局只有一个,经常会用在人物对话,npc讲话等人声场景下。当播放新的声音时会把当前的声音覆盖掉。

/// 播放单通道音效
public void PlaySingleSound(AudioClip clip, bool isLoop = false, float speed = 1)
/// 暂停播放单通道音效
public void PauseSingleSound(bool isGradual = true)

3.技能ui音效:全局可以多个,在触发ui的时候或者释放技能的时候我们的配音是可以多个可重叠的。

/// 播放多通道音效
 public void PlayMultipleSound(AudioClip clip, bool isLoop = false, float speed = 1)
 /// 停止播放指定的多通道音效
  public void StopMultipleSound(AudioClip clip)

4.世界3d音效:全局可以多个,世界音效其实就是3d音,我们一般用在固定位置范围内的音效,通过设置触发距离听到音量不一样的空间声音,比如cf的敌人脚步声。

/// 播放世界音效
public void PlayWorldSound(GameObject attachTarget, AudioClip clip, bool isLoop = false, float speed = 1)
/// 暂停播放指定的世界音效
  public void PauseWorldSound(GameObject attachTarget, bool isGradual = true)

源代码:

using DG.Tweening;
using System.Collections.Generic;
using UnityEngine;

public delegate void AudAction();
/// <summary>
/// 音频管理者
/// </summary>
[DisallowMultipleComponent]
public sealed class AudioManager : MonoBehaviour
{
    /// <summary>
    /// 是否静音初始值【请勿在代码中修改】
    /// </summary>
    public bool MuteDefault = false;
    /// <summary>
    /// 背景音乐优先级初始值【请勿在代码中修改】
    /// </summary>
    public int BackgroundPriorityDefault = 0;
    /// <summary>
    /// 单通道音效优先级初始值【请勿在代码中修改】
    /// </summary>
    public int SinglePriorityDefault = 10;
    /// <summary>
    /// 多通道音效优先级初始值【请勿在代码中修改】
    /// </summary>
    public int MultiplePriorityDefault = 20;
    /// <summary>
    /// 世界音效优先级初始值【请勿在代码中修改】
    /// </summary>
    public int WorldPriorityDefault = 30;
    /// <summary>
    /// 背景音乐音量初始值【请勿在代码中修改】
    /// </summary>
    public float BackgroundVolumeDefault = 0.6f;
    /// <summary>
    /// 单通道音效音量初始值【请勿在代码中修改】
    /// </summary>
    public float SingleVolumeDefault = 1;
    /// <summary>
    /// 多通道音效音量初始值【请勿在代码中修改】
    /// </summary>
    public float MultipleVolumeDefault = 1;
    /// <summary>
    /// 世界音效音量初始值【请勿在代码中修改】
    /// </summary>
    public float WorldVolumeDefault = 1;
    /// <summary>
    /// 单通道音效播放结束事件
    /// </summary>
    public event AudAction SingleSoundEndOfPlayEvent;

    private AudioSource _backgroundAudio;
    private AudioSource _singleAudio;
    private List<AudioSource> _multipleAudios = new List<AudioSource>();
    private Dictionary<GameObject, AudioSource> _worldAudios = new Dictionary<GameObject, AudioSource>();
    private bool _singleSoundPlayDetector = false;
    private bool _isMute = false;
    private int _backgroundPriority = 0;
    private int _singlePriority = 10;
    private int _multiplePriority = 20;
    private int _worldPriority = 30;
    private float _backgroundVolume = 0.6f;
    private float _singleVolume = 1;
    private float _multipleVolume = 1;
    private float _worldVolume = 1;

    public void Awake()
    {
        _backgroundAudio = CreateAudioSource("BackgroundAudio", BackgroundPriorityDefault, BackgroundVolumeDefault, 1, 0);
        _singleAudio = CreateAudioSource("SingleAudio", SinglePriorityDefault, SingleVolumeDefault, 1, 0);

        Mute = MuteDefault;
        BackgroundPriority = BackgroundPriorityDefault;
        SinglePriority = SinglePriorityDefault;
        MultiplePriority = MultiplePriorityDefault;
        WorldPriority = WorldPriorityDefault;
        BackgroundVolume = BackgroundVolumeDefault;
        SingleVolume = SingleVolumeDefault;
        MultipleVolume = MultipleVolumeDefault;
        WorldVolume = WorldVolumeDefault;
    }

    public void Start()
    {
        StopBackgroundMusic();
        StopSingleSound();
        StopAllMultipleSound();
        StopAllWorldSound();
    }

    public void Update()
    {
        if (_singleSoundPlayDetector)
        {
            if (!_singleAudio.isPlaying)
            {
                _singleSoundPlayDetector = false;
                SingleSoundEndOfPlayEvent?.Invoke();
            }
        }
    }

    /// <summary>
    /// 静音
    /// </summary>
    public bool Mute
    {
        get
        {
            return _isMute;
        }
        set
        {
            if (_isMute != value)
            {
                _isMute = value;
                _backgroundAudio.mute = _isMute;
                _singleAudio.mute = _isMute;
                for (int i = 0; i < _multipleAudios.Count; i++)
                {
                    _multipleAudios[i].mute = _isMute;
                }
                foreach (var audio in _worldAudios)
                {
                    audio.Value.mute = _isMute;
                }
            }
        }
    }
    /// <summary>
    /// 背景音乐优先级
    /// </summary>
    public int BackgroundPriority
    {
        get
        {
            return _backgroundPriority;
        }
        set
        {
            if (_backgroundPriority != value)
            {
                _backgroundPriority = value;
                _backgroundAudio.priority = _backgroundPriority;
            }
        }
    }
    /// <summary>
    /// 单通道音效优先级
    /// </summary>
    public int SinglePriority
    {
        get
        {
            return _singlePriority;
        }
        set
        {
            if (_singlePriority != value)
            {
                _singlePriority = value;
                _singleAudio.priority = _singlePriority;
            }
        }
    }
    /// <summary>
    /// 多通道音效优先级
    /// </summary>
    public int MultiplePriority
    {
        get
        {
            return _multiplePriority;
        }
        set
        {
            if (_multiplePriority != value)
            {
                _multiplePriority = value;
                for (int i = 0; i < _multipleAudios.Count; i++)
                {
                    _multipleAudios[i].priority = _multiplePriority;
                }
            }
        }
    }
    /// <summary>
    /// 世界音效优先级
    /// </summary>
    public int WorldPriority
    {
        get
        {
            return _worldPriority;
        }
        set
        {
            if (_worldPriority != value)
            {
                _worldPriority = value;
                foreach (var audio in _worldAudios)
                {
                    audio.Value.priority = _worldPriority;
                }
            }
        }
    }
    /// <summary>
    /// 背景音乐音量
    /// </summary>
    public float BackgroundVolume
    {
        get
        {
            return _backgroundVolume;
        }
        set
        {
            if (!Mathf.Approximately(_backgroundVolume, value))
            {
                _backgroundVolume = value;
                _backgroundAudio.volume = _backgroundVolume;
            }
        }
    }
    /// <summary>
    /// 单通道音效音量
    /// </summary>
    public float SingleVolume
    {
        get
        {
            return _singleVolume;
        }
        set
        {
            if (!Mathf.Approximately(_singleVolume, value))
            {
                _singleVolume = value;
                _singleAudio.volume = _singleVolume;
            }
        }
    }
    /// <summary>
    /// 多通道音效音量
    /// </summary>
    public float MultipleVolume
    {
        get
        {
            return _multipleVolume;
        }
        set
        {

            if (!Mathf.Approximately(_multipleVolume, value))
            {
                _multipleVolume = value;
                for (int i = 0; i < _multipleAudios.Count; i++)
                {
                    _multipleAudios[i].volume = _multipleVolume;
                }
            }
        }
    }
    /// <summary>
    /// 世界音效音量
    /// </summary>
    public float WorldVolume
    {
        get
        {
            return _worldVolume;
        }
        set
        {
            if (!Mathf.Approximately(_worldVolume, value))
            {
                _worldVolume = value;
                foreach (var audio in _worldAudios)
                {
                    audio.Value.volume = _worldVolume;
                }
            }
        }
    }

    /// <summary>
    /// 播放背景音乐
    /// </summary>
    /// <param name="clip">音乐剪辑</param>
    /// <param name="isLoop">是否循环</param>
    /// <param name="speed">播放速度</param>
    public void PlayBackgroundMusic(AudioClip clip, bool isLoop = true, float speed = 1)
    {
        if (_backgroundAudio.isPlaying)
        {
            _backgroundAudio.Stop();
        }

        _backgroundAudio.clip = clip;
        _backgroundAudio.loop = isLoop;
        _backgroundAudio.pitch = speed;
        _backgroundAudio.Play();
    }
    /// <summary>
    /// 暂停播放背景音乐
    /// </summary>
    /// <param name="isGradual">是否渐进式</param>
    public void PauseBackgroundMusic(bool isGradual = true)
    {
        if (isGradual)
        {
            _backgroundAudio.DOFade(0, 2).OnComplete(() =>
            {
                _backgroundAudio.volume = BackgroundVolume;
                _backgroundAudio.Pause();
            });
        }
        else
        {
            _backgroundAudio.Pause();
        }
    }
    /// <summary>
    /// 恢复播放背景音乐
    /// </summary>
    /// <param name="isGradual">是否渐进式</param>
    public void UnPauseBackgroundMusic(bool isGradual = true)
    {
        if (isGradual)
        {
            _backgroundAudio.UnPause();
            _backgroundAudio.volume = 0;
            _backgroundAudio.DOFade(BackgroundVolume, 2);
        }
        else
        {
            _backgroundAudio.UnPause();
        }
    }
    /// <summary>
    /// 停止播放背景音乐
    /// </summary>
    public void StopBackgroundMusic()
    {
        if (_backgroundAudio.isPlaying)
        {
            _backgroundAudio.Stop();
        }
    }

    /// <summary>
    /// 播放单通道音效
    /// </summary>
    /// <param name="clip">音乐剪辑</param>
    /// <param name="isLoop">是否循环</param>
    /// <param name="speed">播放速度</param>
    public void PlaySingleSound(AudioClip clip, bool isLoop = false, float speed = 1)
    {
        if (_singleAudio.isPlaying)
        {
            _singleAudio.Stop();
        }

        _singleAudio.clip = clip;
        _singleAudio.loop = isLoop;
        _singleAudio.pitch = speed;
        _singleAudio.Play();
        _singleSoundPlayDetector = true;
    }
    /// <summary>
    /// 暂停播放单通道音效
    /// </summary>
    /// <param name="isGradual">是否渐进式</param>
    public void PauseSingleSound(bool isGradual = true)
    {
        if (isGradual)
        {
            _singleAudio.DOFade(0, 2).OnComplete(() =>
            {
                _singleAudio.volume = SingleVolume;
                _singleAudio.Pause();
            });
        }
        else
        {
            _singleAudio.Pause();
        }
    }
    /// <summary>
    /// 恢复播放单通道音效
    /// </summary>
    /// <param name="isGradual">是否渐进式</param>
    public void UnPauseSingleSound(bool isGradual = true)
    {
        if (isGradual)
        {
            _singleAudio.UnPause();
            _singleAudio.volume = 0;
            _singleAudio.DOFade(SingleVolume, 2);
        }
        else
        {
            _singleAudio.UnPause();
        }
    }
    /// <summary>
    /// 停止播放单通道音效
    /// </summary>
    public void StopSingleSound()
    {
        if (_singleAudio.isPlaying)
        {
            _singleAudio.Stop();
        }
    }

    /// <summary>
    /// 播放多通道音效
    /// </summary>
    /// <param name="clip">音乐剪辑</param>
    /// <param name="isLoop">是否循环</param>
    /// <param name="speed">播放速度</param>
    public void PlayMultipleSound(AudioClip clip, bool isLoop = false, float speed = 1)
    {
        AudioSource audio = ExtractIdleMultipleAudioSource();
        audio.clip = clip;
        audio.loop = isLoop;
        audio.pitch = speed;
        audio.Play();
    }
    /// <summary>
    /// 停止播放指定的多通道音效
    /// </summary>
    /// <param name="clip">音乐剪辑</param>
    public void StopMultipleSound(AudioClip clip)
    {
        for (int i = 0; i < _multipleAudios.Count; i++)
        {
            if (_multipleAudios[i].isPlaying)
            {
                if (_multipleAudios[i].clip == clip)
                {
                    _multipleAudios[i].Stop();
                }
            }
        }
    }
    /// <summary>
    /// 停止播放所有多通道音效
    /// </summary>
    public void StopAllMultipleSound()
    {
        for (int i = 0; i < _multipleAudios.Count; i++)
        {
            if (_multipleAudios[i].isPlaying)
            {
                _multipleAudios[i].Stop();
            }
        }
    }
    /// <summary>
    /// 销毁所有闲置中的多通道音效的音源
    /// </summary>
    public void ClearIdleMultipleAudioSource()
    {
        for (int i = 0; i < _multipleAudios.Count; i++)
        {
            if (!_multipleAudios[i].isPlaying)
            {
                AudioSource audio = _multipleAudios[i];
                _multipleAudios.RemoveAt(i);
                i -= 1;
                Destroy(audio.gameObject);
            }
        }
    }

    /// <summary>
    /// 播放世界音效
    /// </summary>
    /// <param name="attachTarget">附加目标</param>
    /// <param name="clip">音乐剪辑</param>
    /// <param name="isLoop">是否循环</param>
    /// <param name="speed">播放速度</param>
    public void PlayWorldSound(GameObject attachTarget, AudioClip clip, bool isLoop = false, float speed = 1)
    {
        if (_worldAudios.ContainsKey(attachTarget))
        {
            AudioSource audio = _worldAudios[attachTarget];
            if (audio.isPlaying)
            {
                audio.Stop();
            }
            audio.clip = clip;
            audio.loop = isLoop;
            audio.pitch = speed;
            audio.Play();
        }
        else
        {
            AudioSource audio = AttachAudioSource(attachTarget, WorldPriority, WorldVolume, 1, 1);
            _worldAudios.Add(attachTarget, audio);
            audio.clip = clip;
            audio.loop = isLoop;
            audio.pitch = speed;
            audio.Play();
        }
    }
    /// <summary>
    /// 暂停播放指定的世界音效
    /// </summary>
    /// <param name="attachTarget">附加目标</param>
    /// <param name="isGradual">是否渐进式</param>
    public void PauseWorldSound(GameObject attachTarget, bool isGradual = true)
    {
        if (_worldAudios.ContainsKey(attachTarget))
        {
            AudioSource audio = _worldAudios[attachTarget];
            if (isGradual)
            {
                audio.DOFade(0, 2).OnComplete(() =>
                {
                    audio.volume = WorldVolume;
                    audio.Pause();
                });
            }
            else
            {
                audio.Pause();
            }
        }
    }
    /// <summary>
    /// 恢复播放指定的世界音效
    /// </summary>
    /// <param name="attachTarget">附加目标</param>
    /// <param name="isGradual">是否渐进式</param>
    public void UnPauseWorldSound(GameObject attachTarget, bool isGradual = true)
    {
        if (_worldAudios.ContainsKey(attachTarget))
        {
            AudioSource audio = _worldAudios[attachTarget];
            if (isGradual)
            {
                audio.UnPause();
                audio.volume = 0;
                audio.DOFade(WorldVolume, 2);
            }
            else
            {
                audio.UnPause();
            }
        }
    }
    /// <summary>
    /// 停止播放所有的世界音效
    /// </summary>
    public void StopAllWorldSound()
    {
        foreach (var audio in _worldAudios)
        {
            if (audio.Value.isPlaying)
            {
                audio.Value.Stop();
            }
        }
    }
    /// <summary>
    /// 销毁所有闲置中的世界音效的音源
    /// </summary>
    public void ClearIdleWorldAudioSource()
    {
        HashSet<GameObject> removeSet = new HashSet<GameObject>();
        foreach (var audio in _worldAudios)
        {
            if (!audio.Value.isPlaying)
            {
                removeSet.Add(audio.Key);
                Destroy(audio.Value);
            }
        }
        foreach (var item in removeSet)
        {
            _worldAudios.Remove(item);
        }
    }

    //创建一个音源
    private AudioSource CreateAudioSource(string name, int priority, float volume, float speed, float spatialBlend)
    {
        GameObject audioObj = new GameObject(name);
        audioObj.transform.SetParent(transform);
        audioObj.transform.localPosition = Vector3.zero;
        audioObj.transform.localRotation = Quaternion.identity;
        audioObj.transform.localScale = Vector3.one;
        AudioSource audio = audioObj.AddComponent<AudioSource>();
        audio.playOnAwake = false;
        audio.priority = priority;
        audio.volume = volume;
        audio.pitch = speed;
        audio.spatialBlend = spatialBlend;
        audio.mute = _isMute;
        return audio;
    }
    //附加一个音源
    private AudioSource AttachAudioSource(GameObject target, int priority, float volume, float speed, float spatialBlend)
    {
        AudioSource audio = target.AddComponent<AudioSource>();
        audio.playOnAwake = false;
        audio.priority = priority;
        audio.volume = volume;
        audio.pitch = speed;
        audio.spatialBlend = spatialBlend;
        audio.mute = _isMute;
        return audio;
    }
    //提取闲置中的多通道音源
    private AudioSource ExtractIdleMultipleAudioSource()
    {
        for (int i = 0; i < _multipleAudios.Count; i++)
        {
            if (!_multipleAudios[i].isPlaying)
            {
                return _multipleAudios[i];
            }
        }

        AudioSource audio = CreateAudioSource("MultipleAudio", MultiplePriority, MultipleVolume, 1, 0);
        _multipleAudios.Add(audio);
        return audio;
    }
}

到此,相信大家对“Unity AudioManager声音管理器怎么用”有了更深的了解,不妨来实际操作一番吧!这里是创新互联网站,更多相关内容可以进入相关频道进行查询,关注我们,继续学习!

本文名称:UnityAudioManager声音管理器怎么用
分享路径:https://www.cdcxhl.com/article24/ipdije.html

成都网站建设公司_创新互联,为您提供移动网站建设关键词优化网站策划网站导航微信公众号服务器托管

广告

声明:本网站发布的内容(图片、视频和文字)以用户投稿、用户转载内容为主,如果涉及侵权请尽快告知,我们将会在第一时间删除。文章观点不代表本网站立场,如需处理请联系客服。电话:028-86922220;邮箱:631063699@qq.com。内容未经允许不得转载,或转载时需注明来源: 创新互联

搜索引擎优化