unity 场景管理（Loading界面加载）

最新推荐文章于 2024-10-09 19:08:16 发布
最新推荐文章于 2024-10-09 19:08:16 发布
阅读量1.9k 收藏 11
点赞数 6
分类专栏： Unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Icecoldless/article/details/104078814
版权

很久以前的设计…这是单例的设计，需要挂载在游戏对象上。

/***
*	Title:
*	    场景管理器
*   Description:
*       实现场景的各种加载
* 		公开异步操作数给Loading界面使用
*/

using System.Collections;
using UnityEngine;
using UnityEngine.SceneManagement;

public class LevelManager : SingletonMono<LevelManager>
{

    int SceneIndex = 0;
    public AsyncOperation LoadingProcess;

    // Use this for initialization
    void Start()
    {
        GameObject.DontDestroyOnLoad(this);
    }
    public static void InitLoad()
    {
        new GameObject("LevelMgr").AddComponent<LevelManager>();
    }
    public void LoadNext()
    {
        SceneIndex = SceneManager.GetActiveScene().buildIndex;
        SceneIndex++;
        SceneManager.LoadScene(SceneIndex);
    }
    public void LoadBack()
    {
        SceneIndex = SceneManager.GetActiveScene().buildIndex;
        SceneIndex--;
        if (SceneIndex >= 0)
            SceneManager.LoadScene(SceneIndex);
    }
    public void LoadAgain()
    {
        SceneIndex = SceneManager.GetActiveScene().buildIndex;
        SceneManager.LoadScene(SceneIndex);
    }
    public void LoadScene(int index)
    {
        SceneManager.LoadScene(index);
    }
    public void LoadScene(string sceneName)
    {
        SceneManager.LoadScene(sceneName);
    }
    public IEnumerator LoadSceneAsync(string sceneName)
    {
        LoadingProcess = SceneManager.LoadSceneAsync(sceneName);
        yield return LoadingProcess;
    }
    /// <summary>
    /// 输入一个场景的名称，
    /// 先跳转到Loading场景在跳转进目标场景中
    /// </summary>
    /// <param name="sceneName"></param>
    public void LoadSceneWithLoading(string sceneName)
    {
        Data.NextSceneName = sceneName;
        LoadScene(Data.LoadingScene);
    }
    public IEnumerator LoadNextAsync()
    {
        SceneIndex = SceneManager.GetActiveScene().buildIndex;
        SceneIndex++;
        LoadingProcess = SceneManager.LoadSceneAsync(SceneIndex);
        yield return LoadingProcess;
    }
    public IEnumerator LoadBackAsync()
    {
        SceneIndex = SceneManager.GetActiveScene().buildIndex;
        SceneIndex--;
        LoadingProcess = SceneManager.LoadSceneAsync(SceneIndex);
        yield return LoadingProcess;
    }
    public IEnumerator LoadAgainAsync()
    {
        LoadingProcess = SceneManager.LoadSceneAsync(SceneIndex);
        yield return LoadingProcess;
    }

    private void OnDisable()
    {
        StopAllCoroutines();
    }
    public void QuitGame()
    {
        Application.Quit();
    }
}

这是我现在的设计，状态机设计，我现在的设计是能不挂载游戏物体的脚本死都不挂。

SceneMgr

using System;
using UnityEngine;
using UnityEngine.SceneManagement;

namespace Scene
{
    /// <summary>
    /// 场景管理器
    /// 状态设计模式，因为很多子系统都有可能会设计到场景跳转，例如UI的按钮点击
    /// </summary>
    public class SceneMgr
    {
        public SceneMgr()
        {
            _LoadingScene = CreateSceneState<LoadingSceneState>("LoadingScene",false,false) as LoadingSceneState;
            _CurScene = CreateSceneState<InitSceneState>("InitScene",false,false);
            _CurScene.SceneBegin();
            _CurScene.IsBegin = true;
        }
        /// <summary>
        /// 特殊Loading场景
        /// </summary>
        private LoadingSceneState _LoadingScene;
        /// <summary>
        /// 当前场景状态
        /// </summary>
        private ISceneState _CurScene;
        /// <summary>
        /// 异步操作数
        /// 查看当前场景是否已经加载完成
        /// </summary>
        public AsyncOperation LoadingProcess;

        /// <summary>
        /// 输入一个场景的名称，
        /// 先跳转到Loading场景在跳转进目标场景中
        /// </summary>
        /// <param name="sceneName"></param>
        private void LoadSceneWithLoading(ISceneState scene)
        {
            _LoadingScene.SetNextScene(scene);
            //同步加载到Loading场景
            LoadScene(_LoadingScene);
        }

        /// <summary>
        /// 不通过LoadingScene简单同步加载
        /// </summary>
        /// <param name="sceneName"></param>
        private void LoadScene(ISceneState scene)
        {
            //旧状态离开
            if (_CurScene != null)
                _CurScene.SceneExit();
            //赋值新状态
            _CurScene = scene;
            //先加载对应的AB包
            if (scene.IsABLoad)
            {
                 GameManager.Instance.LoadSceneAB(scene.SceneName);
            }
            SceneManager.LoadScene(scene.SceneName);
        }
        /// <summary>
        /// 异步加载，返回异步操作数，协程操作
        /// </summary>
        /// <param name="scene"></param>
        /// <returns></returns>
        private void LoadSceneAsync(ISceneState scene)
        {
            _CurScene = scene;
            //先加载对应的AB包
            if (scene.IsABLoad)
            {
                GameManager.Instance.LoadSceneAB(scene.SceneName);
            }
            //使用异步操作数直接赋值监控就行了，好像不用迭代
            Debug.Log($"异步加载场景+{scene.SceneName}");
            LoadingProcess = SceneManager.LoadSceneAsync(scene.SceneName);
            LoadingProcess.allowSceneActivation = false; //异步加载
        }
        /// <summary>
        /// 创建一个场景状态
        /// </summary>
        /// <returns></returns>
        public ISceneState CreateSceneState<T>(string sceneName,bool isABLoad,bool isWithLoading) where T:ISceneState,new()
        {
            T t = new T();
            t.Init(isWithLoading, isABLoad, sceneName, this);
            return t;
        }
        /// <summary>
        /// 加载场景
        /// </summary>
        /// <param name="scene">场景状态类</param>
        /// <param name="isLoading">是否已经通过Loading界面加载</param>
        public void SetSceneState(ISceneState scene,bool isLoading)
        {
            if (scene.IsWithLoading)
            {
                if (!isLoading)
                {
                    LoadSceneWithLoading(scene);
                }
                else
                {
                    LoadSceneAsync(scene);
                }
            }
            else
            {
                //加载新场景
                LoadScene(scene);
            }
        }
        /// <summary>
        /// 加载场景
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sceneName">场景名称</param>
        /// <param name="isABLoad">场景是否在AB包中</param>
        /// <param name="isWithLoading">是否属于异步Loading界面加载</param>
        /// <param name="isLoading">是否已经通过Loading界面加载</param>
        public void SetSceneState<T>(string sceneName, bool isABLoad, bool isWithLoading, bool isLoading) where T:ISceneState,new()
        {
            ISceneState scene = CreateSceneState<T>(sceneName,isABLoad,isWithLoading);
            SetSceneState(scene,isLoading);
        }

        public void Update()
        {
            //等待场景加载完成
            if (LoadingProcess != null)
            {
                if(!LoadingProcess.allowSceneActivation)
                {
                    //Loading界面更新
                    _LoadingScene.SceneUpdate();
                    return;
                }
                else
                {
                    //LoadingScene的离开
                    _LoadingScene.SceneExit();
                    LoadingProcess = null;
                }
            }
            //新状态初始化
            if (!_CurScene.IsBegin)
            {
                _CurScene.IsBegin = true;
                _CurScene.SceneBegin();
            }
            //场景状态更新
            _CurScene.SceneUpdate();
        }
    }
}

ISceneState

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Scene
{
    public abstract class ISceneState
    {
        /// <summary>
        /// 场景名称
        /// </summary>
        public string SceneName;
        /// <summary>
        /// 是否通过AB加载场景
        /// </summary>
        public bool IsABLoad;
        /// <summary>
        /// 是否初始化完成
        /// </summary>
        public bool IsBegin;
        /// <summary>
        /// 是否要通过Loading方式加载到新场景中
        /// </summary>
        public bool IsWithLoading;
        /// <summary>
        /// 状态上下文
        /// </summary>
        protected SceneMgr _Context;

        public void Init(bool isWithLoading,bool isABLoad,string sceneName,SceneMgr context)
        {
            this.IsBegin = false;
            this.IsWithLoading = isWithLoading;
            this.IsABLoad = isABLoad;
            this.SceneName = sceneName;
            this._Context = context;
        }
        /// <summary>
        /// 场景开始
        /// </summary>
        public virtual void SceneBegin()
        {

        }
        /// <summary>
        /// 场景进入
        /// </summary>
        public virtual void SceneUpdate()
        {
            GameManager.Instance.Update();
        }
        /// <summary>
        /// 场景离开时
        /// </summary>
        public virtual void SceneExit()
        {
            //场景离开释放内存资源
            GameManager.Instance.ReleaseAll();
        }
    }
}

比较特殊的场景Loading异步加载演示

using UIFW;

namespace Scene
{
    public class LoadingSceneState : ISceneState
    {
        /// <summary>
        /// Loading之后的一个场景
        /// </summary>
        private ISceneState _NextScene;
        /// <summary>
        /// 改变Loading场景接下来要跳转的场景
        /// </summary>
        /// <param name="scene"></param>
        public void SetNextScene(ISceneState scene)
        {
            this._NextScene = scene;
        }

        public override void SceneBegin()
        {
            base.SceneBegin();
            //打开LoadingUIFrm，下一个关卡需要异步进入
            GameManager.Instance.UIManager.OpenUIFrm("LoadingUIFrm");
            //加载到下一个关卡，只能使用set   
            GameManager.Instance.SetSceneState(_NextScene, true);
        }
        public override void SceneExit()
        {
            _NextScene = null;
            base.SceneExit();
        }
    }
}

需要配合指定的UI

using UnityEngine;
using UnityEngine.UI;

namespace UIFW
{
    public class LoadingUIFrm : INormalUserInterface
    {
        /// <summary>
        /// 滑动条
        /// </summary>
        Slider slider_Loading;
        /// <sumary>
        /// 加载进度值文本
        /// </summary>
        Text txt_LoadingValue;
        /// <summary>
        /// 进度值 不要随便修改由unity控制的值
        /// </summary>
        float _Progress;

        public override void SetObject()
        {
            //生成父类
            base.TraParent = base._UIManager.TraNormal;
        }
        public void Awake()
        {
            //获得UI组件
            slider_Loading = UITool.GetComponentFromChildNode<Slider>(transform, "sliderLoading");
            txt_LoadingValue = UITool.GetComponentFromChildNode<Text>(transform, "txtLoadingValue");
        }

        public void Update()
        {
            _Progress = GameManager.Instance.SceneMgr.LoadingProcess.progress;
            if (Mathf.Approximately(_Progress, .9f))
            {
                _Progress = 1;
            }
            //更新UI
            UpdateUI(_Progress);
        }

        private void UpdateUI(float value)
        {
            if (slider_Loading.value < value && !Mathf.Approximately(slider_Loading.value, value))
            {
                slider_Loading.value += .01f;
            }
            if (txt_LoadingValue != null)
                txt_LoadingValue.text = Mathf.Round(slider_Loading.value * 100) + "%";
            if (Mathf.Approximately(slider_Loading.value, 1f))
            {
                GameManager.Instance.SceneMgr.LoadingProcess.allowSceneActivation = true;
            }
        }

        public override void Release()
        {
            base.Release();

            //引用置空
            txt_LoadingValue = null;
            slider_Loading = null;
        }
    }
}

实现结果

在这里插入图片描述

JustEasyCode
关注
专栏目录
unity引擎场景管理
听老罗娓娓道来
09-15 1021
Unity的场景管理系统提供了丰富的API和功能，支持同步和异步加载、卸载场景，以及多场景管理。通过合理使用这些功能，可以有效地组织和管理游戏内容，提高游戏的性能和用户体验。在实际项目中，建议根据具体需求选择合适的场景管理策略，并结合异步加载、过渡效果、依赖管理等高级功能，构建高效、稳定的场景管理系统。希望这些示例和最佳实践能帮助你更好地理解和使用Unity的场景管理系统。在一些特殊情况下，可能需要实现自定义的场景管理系统，以满足特定的需求。
Unity --- 场景/场景管理类 与 异步场景加载法
qq_51947882的博客
08-23 4415
1.一个游戏是由很多的场景组成的，比如游戏的开始页面，战斗场景，商店页面...等等，这些都是一个个游戏场景或者比如说：一进入游戏，你一开始来到的是新手村这个场景，出了新手村后来到的就是荒野场景，过来荒野场景后来到的就是大城市场景.....一个游戏是由很多的场景组成的，而每个场景又由很多的游戏物体组成，而每个游戏物体又由很多的脚本组件组成之前我们一直是在默认的场景中添加游戏物体，其实我们也可以添加新的游戏场景，并通过游戏代码加载新的场景这个就是一开始Unity自动为我们创建的示例场景（默认场景）
Unity 场景管理
weixin_44806700的博客
06-12 1149
通过序列化、AssetBundle加载、AOI和LOD的结合应用，我们能够实现高效的场景管理，动态加载和卸载场景物体，以及根据玩家位置和视野调整显示细节。通过只加载玩家所关注的物体，可以减少不必要的资源加载和渲染，提高游戏性能。通过结合这些技术，开发者可以实现高效的场景管理，动态加载和卸载场景物体，并根据玩家的位置和视野调整显示细节，提供优化的游戏性能和更好的用户体验。对于较大的场景，动态卸载可以帮助减少内存占用，而对于相对较小的场景，仅隐藏物体可能更合适，以避免频繁的加载和卸载操作。
场景管理器（SceneManager）
最新发布
听老罗娓娓道来
10-09 1418
SceneManager依赖于Unity引擎的多个核心模块来实现场景的管理和切换。这些模块共同协作，确保场景的加载、激活、停用和卸载过程顺利进行。理解这些依赖关系有助于更好地优化和管理Unity项目的性能。希望这些信息对你有所帮助！如果你有任何疑问或需要进一步的指导，请随时提问。
Unity场景问题，以及老程序DontDestory问题
Paris_chenxin的博客
06-30 2692
Unity 5.3中新增加了多场景编辑功能，允许用户将一个大场景以某种逻辑分割成多个小场景并方便的编辑和管理。这在某些情况下会比较有用，是对Unity编辑器对场景编辑能力的一个重要提升。本文将由Unity官方工程师张为，为大家介绍一些多场景编辑的基本功能以及一些实例。什么是多场景编辑 多场景编辑就是允许用户在Unity编辑器中同时打开多个场景，并对它们进行编辑。Unity提供了一系列的UI和
Unity 3D开发--SceneManager场景管理(异步使用同一个过渡场景)
一江之水
12-22 1960
在U3D开发过程中经常使用到多场景的切换，有同步SceneManager.LoadScene()和异步SceneManager.LoadSceneAsync()两种方法，同步的话一般就会卡住界面直到加载完成，使用异步的话一般都做一个加载的进度条，每次切换的时候都需要一个加载动画，所以需要建一个专门的过渡加载场景来进行统一加载，也可以避免场景直接切换出现的黑屏。一、建立一个单例进行切换，在项目代码的任何位置都可以调用。要做个进度条然后进行管理，代码很简单就不说了。
Unity 场景异步加载（加载界面的实现）
热门推荐
xinzhilinger的博客
12-07 1万+
前言： 玩游戏最讨厌的是什么呢？当然是游戏加载界面啦 但是你知道吗，加载界面在游戏制作中是不可或缺的，它可以使我们的场景完全加载完毕后再进入游戏，确保用户不会出现加载卡顿的情况。 如何实现一个简易的加载界面呢？来跟我学习一下吧 效果图 UI创建： 首先创建一个开始界面，为Button按钮添加事件来完成场景的转换： 然后创建一个加载界面的UI，首先需要的呢就是一个游戏进度条，可以直接使用Slider来完成创建，其UI层级关系为： 其元素作用为： Background:即整个进度条的背景为棕色 .
Unity3D多个异步加载场景资源 简洁漂亮的加载画面
04-24
在Unity3D游戏开发中，异步加载（Asynchronous Loading）是提高用户体验的关键技术之一，尤其是在处理大型场景或大量资源时。本项目提供了一个简洁且漂亮的加载画面，旨在帮助Unity3D学者理解和实现游戏资源的高效...
Unity游戏场景加载Loading详解
weixin_30508309的博客
01-03 1095
游戏中的Loading现在都做得很漂亮，但是归根究底就两种类型，静态Loading和动态Loading。静态Loading可能就是一张背景图。而动态的Loading就是在读取的同时有一个东西在“转圈”。 1.静态Loading：优点：读取场景使用同步的方法就可以，因为是同步方法所以读取的速度是最快的，也不用更新界面，因为同步执行方法的时候程序在等待读取结束。执行Application.LoadL...
Unity可自定义loading页的异步加载工具，免费下载，使用说明
09-23
总的来说，这个工具为Unity开发者提供了一个便捷的方式来实现异步加载场景并自定义加载界面，从而提高游戏的加载体验。通过深入学习和应用这些知识点，开发者可以打造出更加流畅、用户体验更佳的游戏产品。在使用前...
unity2D笔记-场景管理器和场景加载界面
qq_43008645的博客
05-22 1121
1.场景管理器 using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.SceneManagement; public class SceneController : MonoBehaviour { public static SceneController _instance; public static SceneController Instanc
Unity引擎中的场景管理系统
听老罗娓娓道来
06-20 491
好的，模仿Unity引擎中的场景管理系统，我们将创建一个简单但功能强大的场景管理器。
Unity 工具类 之 简单的异步场景加载（包含加载进度和同步加载方法）类 LoadSceneManager 实现
仙魁XAN
01-12 1217
Unity 工具类 之 简单的异步场景加载（包含加载进度和同步加载方法）类 LoadSceneManager 实现 目录 Unity 工具类 之 简单的异步场景加载（包含加载进度和同步加载方法）类 LoadSceneManager 实现 一、简单介绍 二、实现原理 三、注意事项 四、效果预览 五、实现步骤 六、关键代码 七、参考工程 一、简单介绍 U...
Unity加载场景
qq_42883222的博客
04-02 1869
Unity官方提供了4种加载场景（scene）的方法，分别是： Application.LoadLevel()：同步加载 Application.LoadLevelAsync():异步加载 Application.LoadLevelAddictive():同步附加式加载 Application.LoadLevelAddictiveAsync():异步附加式加载 下面对这四种方法进行简要的介绍和分析： 1.同步加载：假设当前场景为A，我们要切换到场景B，unity会在切换场景的时候将场景B中的所有内容（场
unity加载场景
zhliu1991的专栏
10-11 608
一、添加场景 菜单栏->build settings->add cun
Unity进度条loading页加载的实现
qq_38008632的博客
01-16 1274
1.首先创建一个Global.cs  using UnityEngine; using System.Collections; public class Global  {         public string loadName ; } 2.创建一个场景A   新建一个button组件 OnPress.cs 脚本很简单，只用于实现场景的切换 using U
Unity 场景加载
heaventianjianke的博客
10-04 1854
使用异步加载的方式加载场景
unity3d场景管理插件
11-18
unity3d 多场景管理插件 需要的拿去吧
Unity3D LoadingScene
wjb0108的专栏
11-22 744
Unity3D LoadingScene     大家都知道，在我们玩游戏的时候，在进入游戏的时候，都会看到会有一个进度条画面，这样做是因为场景加载的需要一定时间，尤其是场景资源很大的时候，都是通过引入一个过渡画面，显示游戏加载进度，这样提高了游戏的体验度。     using UnityEngine; using System.Collections;   public clas
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

JustEasyCode

谢谢您

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值