浅谈unity淡入淡出的效果的实现

 1         //设置静态的字段来模拟全局的变量(开始为空)
 2         private static SceneFadeInAndOut _instance = null;
 3         /// <summary>
 4         /// 只读属性的设置(得到实例)
 5         /// </summary>
 6         public static SceneFadeInAndOut Instance
 7         {
 8             get
 9             {
10                 //如果一开始的为空的话
11                 if (_instance == null)
12                 {
13                     //进行类的实例化的操作
14                     _instance = new SceneFadeInAndOut();
15                 }
16                 //下一个访问的话_instance就不为空直接返回字段
17                 return _instance;
18             }
19         }
20         //构造函数的私有化
21         private SceneFadeInAndOut() { }

 1         //RawImage对象
 2         public GameObject goRawImage;
 3         //RawImage组件
 4         private RawImage _rawImage;
 5         void Awake()
 6         {
 7             //如果goRawImage不为空的话
 8             if (goRawImage)
 9             {
10                 //得到RawImage组件
11                 _rawImage = goRawImage.GetComponent<RawImage>();
12             }
13         }

 1         //渐变的速率
 2         public float floatColorChangeSpeed = 1f;
 3         /// <summary>
 4         /// 屏幕逐渐清晰(淡入)
 5         /// </summary>
 6         private void FadeToClear()
 7         {
 8             //插值运算
 9             _rawImage.color = Color.Lerp(_rawImage.color, Color.clear, floatColorChangeSpeed * Time.deltaTime);
10         }
11 
12         /// <summary>
13         /// 屏幕逐渐暗淡(淡出)
14         /// </summary>
15         private void FadeToBlack()
16         {
17             //插值运算
18             _rawImage.color = Color.Lerp(_rawImage.color, Color.black, floatColorChangeSpeed * Time.deltaTime);
19         }
20 
21         /// <summary>
22         /// 屏幕的淡入
23         /// </summary>
24         private void SceneToClear()
25         {
26             FadeToClear();
27             //当我们的a值小于等于0.05f的时候 就相当于完全透明了
28             if (_rawImage.color.a <= 0.05f)
29             {
30                 //设置为完全透明
31                 _rawImage.color = Color.clear;
32                 //组件的开关设置为关闭的状态
33                 _rawImage.enabled = false;
34                 //布尔条件设置为false
35                 _isSceneToClear = false;
36             }
37         }
38 
39         /// <summary>
40         /// 屏幕的淡出
41         /// </summary>
42         private void SceneToBlack()
43         {
44             //组件的打开
45             _rawImage.enabled = true;
46             FadeToBlack();
47             //当前的阿尔法值大于0.95f的时候 表示已经接近于完全不透明的状态
48             if (_rawImage.color.a >= 0.95f)
49             {
50                 //设置为完全不透明的状态 
51                 _rawImage.color = Color.black;
52                 //布尔条件当到达指定的阿尔法值得时候设置为false
53                 _isSceneToBlack = false;
54             }
55         }

 1         //屏幕是否要逐渐清晰(默认是需要的)
 2         private bool _isSceneToClear = true;
 3         //屏幕是否需要逐渐变暗(默认是不需要的)
 4         private bool _isSceneToBlack = false;
 5         void Update()
 6         {
 7             if (_isSceneToClear)
 8             {
 9                 SceneToClear();
10             }
11             else if (_isSceneToBlack)
12             {
13                 SceneToBlack();
14             }
15         }
16         /// <summary>
17         /// 设置场景的淡入
18         /// </summary>
19         public void SetSceneToClear()
20         {
21             _isSceneToClear = true;
22             _isSceneToBlack = false;
23         }
24 
25         /// <summary>
26         /// 设置场景的淡出
27         /// </summary>
28         public void SetSceneToBlack()
29         {
30             _isSceneToClear = false;
31             _isSceneToBlack = true;
32         }

/**
*    Title:"":项目
*          主题 :
*    Description:
*          功能：场景的淡入淡出的效果
*    Date:2017.10.12
*    Version:Unity5.5.4
*    Modify Recoder:
*    Operator:
*
**/
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

namespace Gnome
{
    public class SceneFadeInAndOut : MonoBehaviour
    {

        #region 单例模式

        //设置静态的字段来模拟全局的变量(开始为空)
        private static SceneFadeInAndOut _instance = null;
        /// <summary>
        /// 只读属性的设置
        /// </summary>
        public static SceneFadeInAndOut Instance
        {
            get
            {
                //如果一开始的为空的话
                if (_instance == null)
                {
                    //进行类的实例化的操作
                    _instance = new SceneFadeInAndOut();
                }
                //下一个访问的话_instance就不为空直接返回字段
                return _instance;
            }
        }
        private SceneFadeInAndOut() { }

        #endregion

        #region 字段和属性的定义

        //渐变的速率
        public float floatColorChangeSpeed = 1f;
        //RawImage对象
        public GameObject goRawImage;
        //RawImage组件
        private RawImage _rawImage;
        //屏幕是否要逐渐清晰(默认是需要的)
        private bool _isSceneToClear = true;
        //屏幕是否需要逐渐变暗(默认是不需要的)
        private bool _isSceneToBlack = false;

        #endregion

        void Awake()
        {
            //如果goRawImage不为空的话
            if (goRawImage)
            {
                //得到RawImage组件
                _rawImage = goRawImage.GetComponent<RawImage>();
            }
        }
        void Update()
        {
            if (_isSceneToClear)
            {
                SceneToClear();
            }
            else if (_isSceneToBlack)
            {
                SceneToBlack();
            }
        }

        #region 公共方法的定义

        /// <summary>
        /// 设置场景的淡入
        /// </summary>
        public void SetSceneToClear()
        {
            _isSceneToClear = true;
            _isSceneToBlack = false;
        }

        /// <summary>
        /// 设置场景的淡出
        /// </summary>
        public void SetSceneToBlack()
        {
            _isSceneToClear = false;
            _isSceneToBlack = true;
        }

        #endregion

        #region 私有方法的定义

        /// <summary>
        /// 屏幕逐渐清晰(淡入)
        /// </summary>
        private void FadeToClear()
        {
            //插值运算
            _rawImage.color = Color.Lerp(_rawImage.color, Color.clear, floatColorChangeSpeed * Time.deltaTime);
        }

        /// <summary>
        /// 屏幕逐渐暗淡(淡出)
        /// </summary>
        private void FadeToBlack()
        {
            //插值运算
            _rawImage.color = Color.Lerp(_rawImage.color, Color.black, floatColorChangeSpeed * Time.deltaTime);
        }

        /// <summary>
        /// 屏幕的淡入
        /// </summary>
        private void SceneToClear()
        {
            FadeToClear();
            //当我们的a值小于等于0.05f的时候 就相当于完全透明了
            if (_rawImage.color.a <= 0.05f)
            {
                //设置为完全透明
                _rawImage.color = Color.clear;
                //组件的开关设置为关闭的状态
                _rawImage.enabled = false;
                //布尔条件设置为false
                _isSceneToClear = false;
            }
        }

        /// <summary>
        /// 屏幕的淡出
        /// </summary>
        private void SceneToBlack()
        {
            //组件的打开
            _rawImage.enabled = true;
            FadeToBlack();
            //当前的阿尔法值大于0.95f的时候 表示已经接近于完全不透明的状态
            if (_rawImage.color.a >= 0.95f)
            {
                //设置为完全不透明的状态 
                _rawImage.color = Color.black;
                //布尔条件当到达指定的阿尔法值得时候设置为false
                _isSceneToBlack = false;
            }
        }

        #endregion

    }//class_end
}