SceneComponent.cs 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477
  1. //------------------------------------------------------------
  2. // Game Framework
  3. // Copyright © 2013-2021 loyalsoft. All rights reserved.
  4. // Homepage: http://www.game7000.com/
  5. // Feedback: http://www.game7000.com/
  6. //------------------------------------------------------------
  7. using GameFramework;
  8. using GameFramework.Resource;
  9. using GameFramework.Scene;
  10. using System;
  11. using System.Collections.Generic;
  12. using UnityEngine;
  13. using UnityEngine.SceneManagement;
  14. namespace UnityGameFramework.Runtime
  15. {
  16. /// <summary>
  17. /// 场景组件。
  18. /// </summary>
  19. [DisallowMultipleComponent]
  20. [AddComponentMenu("Game Framework/Scene")]
  21. public sealed class SceneComponent : GameFrameworkComponent
  22. {
  23. private const int DefaultPriority = 0;
  24. private ISceneManager m_SceneManager = null;
  25. private EventComponent m_EventComponent = null;
  26. private readonly SortedDictionary<string, int> m_SceneOrder = new SortedDictionary<string, int>(StringComparer.Ordinal);
  27. private Camera m_MainCamera = null;
  28. private Scene m_GameFrameworkScene = default(Scene);
  29. [SerializeField]
  30. private bool m_EnableLoadSceneUpdateEvent = true;
  31. [SerializeField]
  32. private bool m_EnableLoadSceneDependencyAssetEvent = true;
  33. /// <summary>
  34. /// 获取当前场景主摄像机。
  35. /// </summary>
  36. public Camera MainCamera
  37. {
  38. get
  39. {
  40. return m_MainCamera;
  41. }
  42. }
  43. /// <summary>
  44. /// 游戏框架组件初始化。
  45. /// </summary>
  46. protected override void Awake()
  47. {
  48. base.Awake();
  49. m_SceneManager = GameFrameworkEntry.GetModule<ISceneManager>();
  50. if (m_SceneManager == null)
  51. {
  52. Log.Fatal("Scene manager is invalid.");
  53. return;
  54. }
  55. m_SceneManager.LoadSceneSuccess += OnLoadSceneSuccess;
  56. m_SceneManager.LoadSceneFailure += OnLoadSceneFailure;
  57. if (m_EnableLoadSceneUpdateEvent)
  58. {
  59. m_SceneManager.LoadSceneUpdate += OnLoadSceneUpdate;
  60. }
  61. if (m_EnableLoadSceneDependencyAssetEvent)
  62. {
  63. m_SceneManager.LoadSceneDependencyAsset += OnLoadSceneDependencyAsset;
  64. }
  65. m_SceneManager.UnloadSceneSuccess += OnUnloadSceneSuccess;
  66. m_SceneManager.UnloadSceneFailure += OnUnloadSceneFailure;
  67. m_GameFrameworkScene = UnityEngine.SceneManagement.SceneManager.GetSceneAt(GameEntry.GameFrameworkSceneId);
  68. if (!m_GameFrameworkScene.IsValid())
  69. {
  70. Log.Fatal("Game Framework scene is invalid.");
  71. return;
  72. }
  73. }
  74. private void Start()
  75. {
  76. BaseComponent baseComponent = GameEntry.GetComponent<BaseComponent>();
  77. if (baseComponent == null)
  78. {
  79. Log.Fatal("Base component is invalid.");
  80. return;
  81. }
  82. m_EventComponent = GameEntry.GetComponent<EventComponent>();
  83. if (m_EventComponent == null)
  84. {
  85. Log.Fatal("Event component is invalid.");
  86. return;
  87. }
  88. if (baseComponent.EditorResourceMode)
  89. {
  90. m_SceneManager.SetResourceManager(baseComponent.EditorResourceHelper);
  91. }
  92. else
  93. {
  94. m_SceneManager.SetResourceManager(GameFrameworkEntry.GetModule<IResourceManager>());
  95. }
  96. }
  97. /// <summary>
  98. /// 获取场景名称。
  99. /// </summary>
  100. /// <param name="sceneAssetName">场景资源名称。</param>
  101. /// <returns>场景名称。</returns>
  102. public static string GetSceneName(string sceneAssetName)
  103. {
  104. if (string.IsNullOrEmpty(sceneAssetName))
  105. {
  106. Log.Error("Scene asset name is invalid.");
  107. return null;
  108. }
  109. int sceneNamePosition = sceneAssetName.LastIndexOf('/');
  110. if (sceneNamePosition + 1 >= sceneAssetName.Length)
  111. {
  112. Log.Error("Scene asset name '{0}' is invalid.", sceneAssetName);
  113. return null;
  114. }
  115. string sceneName = sceneAssetName.Substring(sceneNamePosition + 1);
  116. sceneNamePosition = sceneName.LastIndexOf(".unity");
  117. if (sceneNamePosition > 0)
  118. {
  119. sceneName = sceneName.Substring(0, sceneNamePosition);
  120. }
  121. return sceneName;
  122. }
  123. /// <summary>
  124. /// 获取场景是否已加载。
  125. /// </summary>
  126. /// <param name="sceneAssetName">场景资源名称。</param>
  127. /// <returns>场景是否已加载。</returns>
  128. public bool SceneIsLoaded(string sceneAssetName)
  129. {
  130. return m_SceneManager.SceneIsLoaded(sceneAssetName);
  131. }
  132. /// <summary>
  133. /// 获取已加载场景的资源名称。
  134. /// </summary>
  135. /// <returns>已加载场景的资源名称。</returns>
  136. public string[] GetLoadedSceneAssetNames()
  137. {
  138. return m_SceneManager.GetLoadedSceneAssetNames();
  139. }
  140. /// <summary>
  141. /// 获取已加载场景的资源名称。
  142. /// </summary>
  143. /// <param name="results">已加载场景的资源名称。</param>
  144. public void GetLoadedSceneAssetNames(List<string> results)
  145. {
  146. m_SceneManager.GetLoadedSceneAssetNames(results);
  147. }
  148. /// <summary>
  149. /// 获取场景是否正在加载。
  150. /// </summary>
  151. /// <param name="sceneAssetName">场景资源名称。</param>
  152. /// <returns>场景是否正在加载。</returns>
  153. public bool SceneIsLoading(string sceneAssetName)
  154. {
  155. return m_SceneManager.SceneIsLoading(sceneAssetName);
  156. }
  157. /// <summary>
  158. /// 获取正在加载场景的资源名称。
  159. /// </summary>
  160. /// <returns>正在加载场景的资源名称。</returns>
  161. public string[] GetLoadingSceneAssetNames()
  162. {
  163. return m_SceneManager.GetLoadingSceneAssetNames();
  164. }
  165. /// <summary>
  166. /// 获取正在加载场景的资源名称。
  167. /// </summary>
  168. /// <param name="results">正在加载场景的资源名称。</param>
  169. public void GetLoadingSceneAssetNames(List<string> results)
  170. {
  171. m_SceneManager.GetLoadingSceneAssetNames(results);
  172. }
  173. /// <summary>
  174. /// 获取场景是否正在卸载。
  175. /// </summary>
  176. /// <param name="sceneAssetName">场景资源名称。</param>
  177. /// <returns>场景是否正在卸载。</returns>
  178. public bool SceneIsUnloading(string sceneAssetName)
  179. {
  180. return m_SceneManager.SceneIsUnloading(sceneAssetName);
  181. }
  182. /// <summary>
  183. /// 获取正在卸载场景的资源名称。
  184. /// </summary>
  185. /// <returns>正在卸载场景的资源名称。</returns>
  186. public string[] GetUnloadingSceneAssetNames()
  187. {
  188. return m_SceneManager.GetUnloadingSceneAssetNames();
  189. }
  190. /// <summary>
  191. /// 获取正在卸载场景的资源名称。
  192. /// </summary>
  193. /// <param name="results">正在卸载场景的资源名称。</param>
  194. public void GetUnloadingSceneAssetNames(List<string> results)
  195. {
  196. m_SceneManager.GetUnloadingSceneAssetNames(results);
  197. }
  198. /// <summary>
  199. /// 检查场景资源是否存在。
  200. /// </summary>
  201. /// <param name="sceneAssetName">要检查场景资源的名称。</param>
  202. /// <returns>场景资源是否存在。</returns>
  203. public bool HasScene(string sceneAssetName)
  204. {
  205. if (string.IsNullOrEmpty(sceneAssetName))
  206. {
  207. Log.Error("Scene asset name is invalid.");
  208. return false;
  209. }
  210. if (!sceneAssetName.StartsWith("Assets/", StringComparison.Ordinal) || !sceneAssetName.EndsWith(".unity", StringComparison.Ordinal))
  211. {
  212. Log.Error("Scene asset name '{0}' is invalid.", sceneAssetName);
  213. return false;
  214. }
  215. return m_SceneManager.HasScene(sceneAssetName);
  216. }
  217. /// <summary>
  218. /// 加载场景。
  219. /// </summary>
  220. /// <param name="sceneAssetName">场景资源名称。</param>
  221. public void LoadScene(string sceneAssetName)
  222. {
  223. LoadScene(sceneAssetName, DefaultPriority, null);
  224. }
  225. /// <summary>
  226. /// 加载场景。
  227. /// </summary>
  228. /// <param name="sceneAssetName">场景资源名称。</param>
  229. /// <param name="priority">加载场景资源的优先级。</param>
  230. public void LoadScene(string sceneAssetName, int priority)
  231. {
  232. LoadScene(sceneAssetName, priority, null);
  233. }
  234. /// <summary>
  235. /// 加载场景。
  236. /// </summary>
  237. /// <param name="sceneAssetName">场景资源名称。</param>
  238. /// <param name="userData">用户自定义数据。</param>
  239. public void LoadScene(string sceneAssetName, object userData)
  240. {
  241. LoadScene(sceneAssetName, DefaultPriority, userData);
  242. }
  243. /// <summary>
  244. /// 加载场景。
  245. /// </summary>
  246. /// <param name="sceneAssetName">场景资源名称。</param>
  247. /// <param name="priority">加载场景资源的优先级。</param>
  248. /// <param name="userData">用户自定义数据。</param>
  249. public void LoadScene(string sceneAssetName, int priority, object userData)
  250. {
  251. if (string.IsNullOrEmpty(sceneAssetName))
  252. {
  253. Log.Error("Scene asset name is invalid.");
  254. return;
  255. }
  256. if (!sceneAssetName.StartsWith("Assets/", StringComparison.Ordinal) || !sceneAssetName.EndsWith(".unity", StringComparison.Ordinal))
  257. {
  258. Log.Error("Scene asset name '{0}' is invalid.", sceneAssetName);
  259. return;
  260. }
  261. m_SceneManager.LoadScene(sceneAssetName, priority, userData);
  262. }
  263. /// <summary>
  264. /// 卸载场景。
  265. /// </summary>
  266. /// <param name="sceneAssetName">场景资源名称。</param>
  267. public void UnloadScene(string sceneAssetName)
  268. {
  269. UnloadScene(sceneAssetName, null);
  270. }
  271. /// <summary>
  272. /// 卸载场景。
  273. /// </summary>
  274. /// <param name="sceneAssetName">场景资源名称。</param>
  275. /// <param name="userData">用户自定义数据。</param>
  276. public void UnloadScene(string sceneAssetName, object userData)
  277. {
  278. if (string.IsNullOrEmpty(sceneAssetName))
  279. {
  280. Log.Error("Scene asset name is invalid.");
  281. return;
  282. }
  283. if (!sceneAssetName.StartsWith("Assets/", StringComparison.Ordinal) || !sceneAssetName.EndsWith(".unity", StringComparison.Ordinal))
  284. {
  285. Log.Error("Scene asset name '{0}' is invalid.", sceneAssetName);
  286. return;
  287. }
  288. m_SceneManager.UnloadScene(sceneAssetName, userData);
  289. m_SceneOrder.Remove(sceneAssetName);
  290. }
  291. /// <summary>
  292. /// 设置场景顺序。
  293. /// </summary>
  294. /// <param name="sceneAssetName">场景资源名称。</param>
  295. /// <param name="sceneOrder">要设置的场景顺序。</param>
  296. public void SetSceneOrder(string sceneAssetName, int sceneOrder)
  297. {
  298. if (string.IsNullOrEmpty(sceneAssetName))
  299. {
  300. Log.Error("Scene asset name is invalid.");
  301. return;
  302. }
  303. if (!sceneAssetName.StartsWith("Assets/", StringComparison.Ordinal) || !sceneAssetName.EndsWith(".unity", StringComparison.Ordinal))
  304. {
  305. Log.Error("Scene asset name '{0}' is invalid.", sceneAssetName);
  306. return;
  307. }
  308. if (SceneIsLoading(sceneAssetName))
  309. {
  310. m_SceneOrder[sceneAssetName] = sceneOrder;
  311. return;
  312. }
  313. if (SceneIsLoaded(sceneAssetName))
  314. {
  315. m_SceneOrder[sceneAssetName] = sceneOrder;
  316. RefreshSceneOrder();
  317. return;
  318. }
  319. Log.Error("Scene '{0}' is not loaded or loading.", sceneAssetName);
  320. }
  321. /// <summary>
  322. /// 刷新当前场景主摄像机。
  323. /// </summary>
  324. public void RefreshMainCamera()
  325. {
  326. m_MainCamera = Camera.main;
  327. }
  328. private void RefreshSceneOrder()
  329. {
  330. if (m_SceneOrder.Count > 0)
  331. {
  332. string maxSceneName = null;
  333. int maxSceneOrder = 0;
  334. foreach (KeyValuePair<string, int> sceneOrder in m_SceneOrder)
  335. {
  336. if (SceneIsLoading(sceneOrder.Key))
  337. {
  338. continue;
  339. }
  340. if (maxSceneName == null)
  341. {
  342. maxSceneName = sceneOrder.Key;
  343. maxSceneOrder = sceneOrder.Value;
  344. continue;
  345. }
  346. if (sceneOrder.Value > maxSceneOrder)
  347. {
  348. maxSceneName = sceneOrder.Key;
  349. maxSceneOrder = sceneOrder.Value;
  350. }
  351. }
  352. if (maxSceneName == null)
  353. {
  354. SetActiveScene(m_GameFrameworkScene);
  355. return;
  356. }
  357. Scene scene = UnityEngine.SceneManagement.SceneManager.GetSceneByName(GetSceneName(maxSceneName));
  358. if (!scene.IsValid())
  359. {
  360. Log.Error("Active scene '{0}' is invalid.", maxSceneName);
  361. return;
  362. }
  363. SetActiveScene(scene);
  364. }
  365. else
  366. {
  367. SetActiveScene(m_GameFrameworkScene);
  368. }
  369. }
  370. private void SetActiveScene(Scene activeScene)
  371. {
  372. Scene lastActiveScene = UnityEngine.SceneManagement.SceneManager.GetActiveScene();
  373. if (lastActiveScene != activeScene)
  374. {
  375. UnityEngine.SceneManagement.SceneManager.SetActiveScene(activeScene);
  376. m_EventComponent.Fire(this, ActiveSceneChangedEventArgs.Create(lastActiveScene, activeScene));
  377. }
  378. RefreshMainCamera();
  379. }
  380. private void OnLoadSceneSuccess(object sender, GameFramework.Scene.LoadSceneSuccessEventArgs e)
  381. {
  382. if (!m_SceneOrder.ContainsKey(e.SceneAssetName))
  383. {
  384. m_SceneOrder.Add(e.SceneAssetName, 0);
  385. }
  386. m_EventComponent.Fire(this, LoadSceneSuccessEventArgs.Create(e));
  387. RefreshSceneOrder();
  388. }
  389. private void OnLoadSceneFailure(object sender, GameFramework.Scene.LoadSceneFailureEventArgs e)
  390. {
  391. Log.Warning("Load scene failure, scene asset name '{0}', error message '{1}'.", e.SceneAssetName, e.ErrorMessage);
  392. m_EventComponent.Fire(this, LoadSceneFailureEventArgs.Create(e));
  393. }
  394. private void OnLoadSceneUpdate(object sender, GameFramework.Scene.LoadSceneUpdateEventArgs e)
  395. {
  396. m_EventComponent.Fire(this, LoadSceneUpdateEventArgs.Create(e));
  397. }
  398. private void OnLoadSceneDependencyAsset(object sender, GameFramework.Scene.LoadSceneDependencyAssetEventArgs e)
  399. {
  400. m_EventComponent.Fire(this, LoadSceneDependencyAssetEventArgs.Create(e));
  401. }
  402. private void OnUnloadSceneSuccess(object sender, GameFramework.Scene.UnloadSceneSuccessEventArgs e)
  403. {
  404. m_EventComponent.Fire(this, UnloadSceneSuccessEventArgs.Create(e));
  405. m_SceneOrder.Remove(e.SceneAssetName);
  406. RefreshSceneOrder();
  407. }
  408. private void OnUnloadSceneFailure(object sender, GameFramework.Scene.UnloadSceneFailureEventArgs e)
  409. {
  410. Log.Warning("Unload scene failure, scene asset name '{0}'.", e.SceneAssetName);
  411. m_EventComponent.Fire(this, UnloadSceneFailureEventArgs.Create(e));
  412. }
  413. }
  414. }