ResourceComponent.cs 57 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459
  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.Download;
  9. using GameFramework.FileSystem;
  10. using GameFramework.ObjectPool;
  11. using GameFramework.Resource;
  12. using System;
  13. using System.Collections.Generic;
  14. using UnityEngine;
  15. namespace UnityGameFramework.Runtime
  16. {
  17. /// <summary>
  18. /// 资源组件。
  19. /// </summary>
  20. [DisallowMultipleComponent]
  21. [AddComponentMenu("Game Framework/Resource")]
  22. public sealed class ResourceComponent : GameFrameworkComponent
  23. {
  24. private const int DefaultPriority = 0;
  25. private const int OneMegaBytes = 1024 * 1024;
  26. private IResourceManager m_ResourceManager = null;
  27. private EventComponent m_EventComponent = null;
  28. private bool m_EditorResourceMode = false;
  29. private bool m_ForceUnloadUnusedAssets = false;
  30. private bool m_PreorderUnloadUnusedAssets = false;
  31. private bool m_PerformGCCollect = false;
  32. private AsyncOperation m_AsyncOperation = null;
  33. private float m_LastUnloadUnusedAssetsOperationElapseSeconds = 0f;
  34. private ResourceHelperBase m_ResourceHelper = null;
  35. [SerializeField]
  36. private ResourceMode m_ResourceMode = ResourceMode.Package;
  37. [SerializeField]
  38. private ReadWritePathType m_ReadWritePathType = ReadWritePathType.Unspecified;
  39. [SerializeField]
  40. private float m_MinUnloadUnusedAssetsInterval = 60f;
  41. [SerializeField]
  42. private float m_MaxUnloadUnusedAssetsInterval = 300f;
  43. [SerializeField]
  44. private float m_AssetAutoReleaseInterval = 60f;
  45. [SerializeField]
  46. private int m_AssetCapacity = 64;
  47. [SerializeField]
  48. private float m_AssetExpireTime = 60f;
  49. [SerializeField]
  50. private int m_AssetPriority = 0;
  51. [SerializeField]
  52. private float m_ResourceAutoReleaseInterval = 60f;
  53. [SerializeField]
  54. private int m_ResourceCapacity = 16;
  55. [SerializeField]
  56. private float m_ResourceExpireTime = 60f;
  57. [SerializeField]
  58. private int m_ResourcePriority = 0;
  59. [SerializeField]
  60. private string m_UpdatePrefixUri = null;
  61. [SerializeField]
  62. private int m_GenerateReadWriteVersionListLength = OneMegaBytes;
  63. [SerializeField]
  64. private int m_UpdateRetryCount = 3;
  65. [SerializeField]
  66. private Transform m_InstanceRoot = null;
  67. [SerializeField]
  68. private string m_ResourceHelperTypeName = "UnityGameFramework.Runtime.DefaultResourceHelper";
  69. [SerializeField]
  70. private ResourceHelperBase m_CustomResourceHelper = null;
  71. [SerializeField]
  72. private string m_LoadResourceAgentHelperTypeName = "UnityGameFramework.Runtime.DefaultLoadResourceAgentHelper";
  73. [SerializeField]
  74. private LoadResourceAgentHelperBase m_CustomLoadResourceAgentHelper = null;
  75. [SerializeField]
  76. private int m_LoadResourceAgentHelperCount = 3;
  77. /// <summary>
  78. /// 获取资源只读路径。
  79. /// </summary>
  80. public string ReadOnlyPath
  81. {
  82. get
  83. {
  84. return m_ResourceManager.ReadOnlyPath;
  85. }
  86. }
  87. /// <summary>
  88. /// 获取资源读写路径。
  89. /// </summary>
  90. public string ReadWritePath
  91. {
  92. get
  93. {
  94. return m_ResourceManager.ReadWritePath;
  95. }
  96. }
  97. /// <summary>
  98. /// 获取资源模式。
  99. /// </summary>
  100. public ResourceMode ResourceMode
  101. {
  102. get
  103. {
  104. return m_ResourceManager.ResourceMode;
  105. }
  106. }
  107. /// <summary>
  108. /// 获取资源读写路径类型。
  109. /// </summary>
  110. public ReadWritePathType ReadWritePathType
  111. {
  112. get
  113. {
  114. return m_ReadWritePathType;
  115. }
  116. }
  117. /// <summary>
  118. /// 设置当前变体。
  119. /// </summary>
  120. public string CurrentVariant
  121. {
  122. get
  123. {
  124. return m_ResourceManager.CurrentVariant;
  125. }
  126. }
  127. /// <summary>
  128. /// 获取单机模式版本资源列表序列化器。
  129. /// </summary>
  130. public PackageVersionListSerializer PackageVersionListSerializer
  131. {
  132. get
  133. {
  134. return m_ResourceManager.PackageVersionListSerializer;
  135. }
  136. }
  137. /// <summary>
  138. /// 获取可更新模式版本资源列表序列化器。
  139. /// </summary>
  140. public UpdatableVersionListSerializer UpdatableVersionListSerializer
  141. {
  142. get
  143. {
  144. return m_ResourceManager.UpdatableVersionListSerializer;
  145. }
  146. }
  147. /// <summary>
  148. /// 获取本地只读区版本资源列表序列化器。
  149. /// </summary>
  150. public ReadOnlyVersionListSerializer ReadOnlyVersionListSerializer
  151. {
  152. get
  153. {
  154. return m_ResourceManager.ReadOnlyVersionListSerializer;
  155. }
  156. }
  157. /// <summary>
  158. /// 获取本地读写区版本资源列表序列化器。
  159. /// </summary>
  160. public ReadWriteVersionListSerializer ReadWriteVersionListSerializer
  161. {
  162. get
  163. {
  164. return m_ResourceManager.ReadWriteVersionListSerializer;
  165. }
  166. }
  167. /// <summary>
  168. /// 获取资源包版本资源列表序列化器。
  169. /// </summary>
  170. public ResourcePackVersionListSerializer ResourcePackVersionListSerializer
  171. {
  172. get
  173. {
  174. return m_ResourceManager.ResourcePackVersionListSerializer;
  175. }
  176. }
  177. /// <summary>
  178. /// 获取无用资源释放的等待时长,以秒为单位。
  179. /// </summary>
  180. public float LastUnloadUnusedAssetsOperationElapseSeconds
  181. {
  182. get
  183. {
  184. return m_LastUnloadUnusedAssetsOperationElapseSeconds;
  185. }
  186. }
  187. /// <summary>
  188. /// 获取或设置无用资源释放的最小间隔时间,以秒为单位。
  189. /// </summary>
  190. public float MinUnloadUnusedAssetsInterval
  191. {
  192. get
  193. {
  194. return m_MinUnloadUnusedAssetsInterval;
  195. }
  196. set
  197. {
  198. m_MinUnloadUnusedAssetsInterval = value;
  199. }
  200. }
  201. /// <summary>
  202. /// 获取或设置无用资源释放的最大间隔时间,以秒为单位。
  203. /// </summary>
  204. public float MaxUnloadUnusedAssetsInterval
  205. {
  206. get
  207. {
  208. return m_MaxUnloadUnusedAssetsInterval;
  209. }
  210. set
  211. {
  212. m_MaxUnloadUnusedAssetsInterval = value;
  213. }
  214. }
  215. /// <summary>
  216. /// 获取当前资源适用的游戏版本号。
  217. /// </summary>
  218. public string ApplicableGameVersion
  219. {
  220. get
  221. {
  222. return m_ResourceManager.ApplicableGameVersion;
  223. }
  224. }
  225. /// <summary>
  226. /// 获取当前内部资源版本号。
  227. /// </summary>
  228. public int InternalResourceVersion
  229. {
  230. get
  231. {
  232. return m_ResourceManager.InternalResourceVersion;
  233. }
  234. }
  235. /// <summary>
  236. /// 获取资源数量。
  237. /// </summary>
  238. public int AssetCount
  239. {
  240. get
  241. {
  242. return m_ResourceManager.AssetCount;
  243. }
  244. }
  245. /// <summary>
  246. /// 获取资源数量。
  247. /// </summary>
  248. public int ResourceCount
  249. {
  250. get
  251. {
  252. return m_ResourceManager.ResourceCount;
  253. }
  254. }
  255. /// <summary>
  256. /// 获取资源组数量。
  257. /// </summary>
  258. public int ResourceGroupCount
  259. {
  260. get
  261. {
  262. return m_ResourceManager.ResourceGroupCount;
  263. }
  264. }
  265. /// <summary>
  266. /// 获取或设置资源更新下载地址。
  267. /// </summary>
  268. public string UpdatePrefixUri
  269. {
  270. get
  271. {
  272. return m_ResourceManager.UpdatePrefixUri;
  273. }
  274. set
  275. {
  276. m_ResourceManager.UpdatePrefixUri = m_UpdatePrefixUri = value;
  277. }
  278. }
  279. /// <summary>
  280. /// 获取或设置每更新多少字节的资源,重新生成一次版本资源列表。
  281. /// </summary>
  282. public int GenerateReadWriteVersionListLength
  283. {
  284. get
  285. {
  286. return m_ResourceManager.GenerateReadWriteVersionListLength;
  287. }
  288. set
  289. {
  290. m_ResourceManager.GenerateReadWriteVersionListLength = m_GenerateReadWriteVersionListLength = value;
  291. }
  292. }
  293. /// <summary>
  294. /// 获取正在应用的资源包路径。
  295. /// </summary>
  296. public string ApplyingResourcePackPath
  297. {
  298. get
  299. {
  300. return m_ResourceManager.ApplyingResourcePackPath;
  301. }
  302. }
  303. /// <summary>
  304. /// 获取等待应用资源数量。
  305. /// </summary>
  306. public int ApplyWaitingCount
  307. {
  308. get
  309. {
  310. return m_ResourceManager.ApplyWaitingCount;
  311. }
  312. }
  313. /// <summary>
  314. /// 获取或设置资源更新重试次数。
  315. /// </summary>
  316. public int UpdateRetryCount
  317. {
  318. get
  319. {
  320. return m_ResourceManager.UpdateRetryCount;
  321. }
  322. set
  323. {
  324. m_ResourceManager.UpdateRetryCount = m_UpdateRetryCount = value;
  325. }
  326. }
  327. /// <summary>
  328. /// 获取正在更新的资源组。
  329. /// </summary>
  330. public IResourceGroup UpdatingResourceGroup
  331. {
  332. get
  333. {
  334. return m_ResourceManager.UpdatingResourceGroup;
  335. }
  336. }
  337. /// <summary>
  338. /// 获取等待更新资源数量。
  339. /// </summary>
  340. public int UpdateWaitingCount
  341. {
  342. get
  343. {
  344. return m_ResourceManager.UpdateWaitingCount;
  345. }
  346. }
  347. /// <summary>
  348. /// 获取使用时下载的等待更新资源数量。
  349. /// </summary>
  350. public int UpdateWaitingWhilePlayingCount
  351. {
  352. get
  353. {
  354. return m_ResourceManager.UpdateWaitingWhilePlayingCount;
  355. }
  356. }
  357. /// <summary>
  358. /// 获取候选更新资源数量。
  359. /// </summary>
  360. public int UpdateCandidateCount
  361. {
  362. get
  363. {
  364. return m_ResourceManager.UpdateCandidateCount;
  365. }
  366. }
  367. /// <summary>
  368. /// 获取加载资源代理总数量。
  369. /// </summary>
  370. public int LoadTotalAgentCount
  371. {
  372. get
  373. {
  374. return m_ResourceManager.LoadTotalAgentCount;
  375. }
  376. }
  377. /// <summary>
  378. /// 获取可用加载资源代理数量。
  379. /// </summary>
  380. public int LoadFreeAgentCount
  381. {
  382. get
  383. {
  384. return m_ResourceManager.LoadFreeAgentCount;
  385. }
  386. }
  387. /// <summary>
  388. /// 获取工作中加载资源代理数量。
  389. /// </summary>
  390. public int LoadWorkingAgentCount
  391. {
  392. get
  393. {
  394. return m_ResourceManager.LoadWorkingAgentCount;
  395. }
  396. }
  397. /// <summary>
  398. /// 获取等待加载资源任务数量。
  399. /// </summary>
  400. public int LoadWaitingTaskCount
  401. {
  402. get
  403. {
  404. return m_ResourceManager.LoadWaitingTaskCount;
  405. }
  406. }
  407. /// <summary>
  408. /// 获取或设置资源对象池自动释放可释放对象的间隔秒数。
  409. /// </summary>
  410. public float AssetAutoReleaseInterval
  411. {
  412. get
  413. {
  414. return m_ResourceManager.AssetAutoReleaseInterval;
  415. }
  416. set
  417. {
  418. m_ResourceManager.AssetAutoReleaseInterval = m_AssetAutoReleaseInterval = value;
  419. }
  420. }
  421. /// <summary>
  422. /// 获取或设置资源对象池的容量。
  423. /// </summary>
  424. public int AssetCapacity
  425. {
  426. get
  427. {
  428. return m_ResourceManager.AssetCapacity;
  429. }
  430. set
  431. {
  432. m_ResourceManager.AssetCapacity = m_AssetCapacity = value;
  433. }
  434. }
  435. /// <summary>
  436. /// 获取或设置资源对象池对象过期秒数。
  437. /// </summary>
  438. public float AssetExpireTime
  439. {
  440. get
  441. {
  442. return m_ResourceManager.AssetExpireTime;
  443. }
  444. set
  445. {
  446. m_ResourceManager.AssetExpireTime = m_AssetExpireTime = value;
  447. }
  448. }
  449. /// <summary>
  450. /// 获取或设置资源对象池的优先级。
  451. /// </summary>
  452. public int AssetPriority
  453. {
  454. get
  455. {
  456. return m_ResourceManager.AssetPriority;
  457. }
  458. set
  459. {
  460. m_ResourceManager.AssetPriority = m_AssetPriority = value;
  461. }
  462. }
  463. /// <summary>
  464. /// 获取或设置资源对象池自动释放可释放对象的间隔秒数。
  465. /// </summary>
  466. public float ResourceAutoReleaseInterval
  467. {
  468. get
  469. {
  470. return m_ResourceManager.ResourceAutoReleaseInterval;
  471. }
  472. set
  473. {
  474. m_ResourceManager.ResourceAutoReleaseInterval = m_ResourceAutoReleaseInterval = value;
  475. }
  476. }
  477. /// <summary>
  478. /// 获取或设置资源对象池的容量。
  479. /// </summary>
  480. public int ResourceCapacity
  481. {
  482. get
  483. {
  484. return m_ResourceManager.ResourceCapacity;
  485. }
  486. set
  487. {
  488. m_ResourceManager.ResourceCapacity = m_ResourceCapacity = value;
  489. }
  490. }
  491. /// <summary>
  492. /// 获取或设置资源对象池对象过期秒数。
  493. /// </summary>
  494. public float ResourceExpireTime
  495. {
  496. get
  497. {
  498. return m_ResourceManager.ResourceExpireTime;
  499. }
  500. set
  501. {
  502. m_ResourceManager.ResourceExpireTime = m_ResourceExpireTime = value;
  503. }
  504. }
  505. /// <summary>
  506. /// 获取或设置资源对象池的优先级。
  507. /// </summary>
  508. public int ResourcePriority
  509. {
  510. get
  511. {
  512. return m_ResourceManager.ResourcePriority;
  513. }
  514. set
  515. {
  516. m_ResourceManager.ResourcePriority = m_ResourcePriority = value;
  517. }
  518. }
  519. /// <summary>
  520. /// 游戏框架组件初始化。
  521. /// </summary>
  522. protected override void Awake()
  523. {
  524. base.Awake();
  525. }
  526. private void Start()
  527. {
  528. return;
  529. BaseComponent baseComponent = GameEntry.GetComponent<BaseComponent>();
  530. if (baseComponent == null)
  531. {
  532. Log.Fatal("Base component is invalid.");
  533. return;
  534. }
  535. m_EventComponent = GameEntry.GetComponent<EventComponent>();
  536. if (m_EventComponent == null)
  537. {
  538. Log.Fatal("Event component is invalid.");
  539. return;
  540. }
  541. m_EditorResourceMode = baseComponent.EditorResourceMode;
  542. m_ResourceManager = m_EditorResourceMode ? baseComponent.EditorResourceHelper : GameFrameworkEntry.GetModule<IResourceManager>();
  543. if (m_ResourceManager == null)
  544. {
  545. Log.Fatal("Resource manager is invalid.");
  546. return;
  547. }
  548. m_ResourceManager.ResourceApplySuccess += OnResourceApplySuccess;
  549. m_ResourceManager.ResourceApplyFailure += OnResourceApplyFailure;
  550. m_ResourceManager.ResourceUpdateStart += OnResourceUpdateStart;
  551. m_ResourceManager.ResourceUpdateChanged += OnResourceUpdateChanged;
  552. m_ResourceManager.ResourceUpdateSuccess += OnResourceUpdateSuccess;
  553. m_ResourceManager.ResourceUpdateFailure += OnResourceUpdateFailure;
  554. m_ResourceManager.ResourceUpdateAllComplete += OnResourceUpdateAllComplete;
  555. m_ResourceManager.SetReadOnlyPath(Application.streamingAssetsPath);
  556. if (m_ReadWritePathType == ReadWritePathType.TemporaryCache)
  557. {
  558. m_ResourceManager.SetReadWritePath(Application.temporaryCachePath);
  559. }
  560. else
  561. {
  562. if (m_ReadWritePathType == ReadWritePathType.Unspecified)
  563. {
  564. m_ReadWritePathType = ReadWritePathType.PersistentData;
  565. }
  566. m_ResourceManager.SetReadWritePath(Application.persistentDataPath);
  567. }
  568. if (m_EditorResourceMode)
  569. {
  570. return;
  571. }
  572. SetResourceMode(m_ResourceMode);
  573. m_ResourceManager.SetObjectPoolManager(GameFrameworkEntry.GetModule<IObjectPoolManager>());
  574. m_ResourceManager.SetFileSystemManager(GameFrameworkEntry.GetModule<IFileSystemManager>());
  575. m_ResourceManager.SetDownloadManager(GameFrameworkEntry.GetModule<IDownloadManager>());
  576. m_ResourceManager.AssetAutoReleaseInterval = m_AssetAutoReleaseInterval;
  577. m_ResourceManager.AssetCapacity = m_AssetCapacity;
  578. m_ResourceManager.AssetExpireTime = m_AssetExpireTime;
  579. m_ResourceManager.AssetPriority = m_AssetPriority;
  580. m_ResourceManager.ResourceAutoReleaseInterval = m_ResourceAutoReleaseInterval;
  581. m_ResourceManager.ResourceCapacity = m_ResourceCapacity;
  582. m_ResourceManager.ResourceExpireTime = m_ResourceExpireTime;
  583. m_ResourceManager.ResourcePriority = m_ResourcePriority;
  584. if (m_ResourceMode == ResourceMode.Updatable || m_ResourceMode == ResourceMode.UpdatableWhilePlaying)
  585. {
  586. m_ResourceManager.UpdatePrefixUri = m_UpdatePrefixUri;
  587. m_ResourceManager.GenerateReadWriteVersionListLength = m_GenerateReadWriteVersionListLength;
  588. m_ResourceManager.UpdateRetryCount = m_UpdateRetryCount;
  589. }
  590. m_ResourceHelper = Helper.CreateHelper(m_ResourceHelperTypeName, m_CustomResourceHelper);
  591. if (m_ResourceHelper == null)
  592. {
  593. Log.Error("Can not create resource helper.");
  594. return;
  595. }
  596. m_ResourceHelper.name = "Resource Helper";
  597. Transform transform = m_ResourceHelper.transform;
  598. transform.SetParent(this.transform);
  599. transform.localScale = Vector3.one;
  600. m_ResourceManager.SetResourceHelper(m_ResourceHelper);
  601. if (m_InstanceRoot == null)
  602. {
  603. m_InstanceRoot = new GameObject("Load Resource Agent Instances").transform;
  604. m_InstanceRoot.SetParent(gameObject.transform);
  605. m_InstanceRoot.localScale = Vector3.one;
  606. }
  607. for (int i = 0; i < m_LoadResourceAgentHelperCount; i++)
  608. {
  609. AddLoadResourceAgentHelper(i);
  610. }
  611. }
  612. private void Update()
  613. {
  614. m_LastUnloadUnusedAssetsOperationElapseSeconds += Time.unscaledDeltaTime;
  615. if (m_AsyncOperation == null && (m_ForceUnloadUnusedAssets || m_LastUnloadUnusedAssetsOperationElapseSeconds >= m_MaxUnloadUnusedAssetsInterval || m_PreorderUnloadUnusedAssets && m_LastUnloadUnusedAssetsOperationElapseSeconds >= m_MinUnloadUnusedAssetsInterval))
  616. {
  617. Log.Info("Unload unused assets...");
  618. m_ForceUnloadUnusedAssets = false;
  619. m_PreorderUnloadUnusedAssets = false;
  620. m_LastUnloadUnusedAssetsOperationElapseSeconds = 0f;
  621. m_AsyncOperation = Resources.UnloadUnusedAssets();
  622. }
  623. if (m_AsyncOperation != null && m_AsyncOperation.isDone)
  624. {
  625. m_AsyncOperation = null;
  626. if (m_PerformGCCollect)
  627. {
  628. Log.Info("GC.Collect...");
  629. m_PerformGCCollect = false;
  630. GC.Collect();
  631. }
  632. }
  633. }
  634. /// <summary>
  635. /// 设置资源模式。
  636. /// </summary>
  637. /// <param name="resourceMode">资源模式。</param>
  638. public void SetResourceMode(ResourceMode resourceMode)
  639. {
  640. m_ResourceManager.SetResourceMode(resourceMode);
  641. switch (resourceMode)
  642. {
  643. case ResourceMode.Package:
  644. m_ResourceManager.PackageVersionListSerializer.RegisterDeserializeCallback(0, BuiltinVersionListSerializer.PackageVersionListDeserializeCallback_V0);
  645. m_ResourceManager.PackageVersionListSerializer.RegisterDeserializeCallback(1, BuiltinVersionListSerializer.PackageVersionListDeserializeCallback_V1);
  646. m_ResourceManager.PackageVersionListSerializer.RegisterDeserializeCallback(2, BuiltinVersionListSerializer.PackageVersionListDeserializeCallback_V2);
  647. break;
  648. case ResourceMode.Updatable:
  649. case ResourceMode.UpdatableWhilePlaying:
  650. m_ResourceManager.UpdatableVersionListSerializer.RegisterDeserializeCallback(0, BuiltinVersionListSerializer.UpdatableVersionListDeserializeCallback_V0);
  651. m_ResourceManager.UpdatableVersionListSerializer.RegisterDeserializeCallback(1, BuiltinVersionListSerializer.UpdatableVersionListDeserializeCallback_V1);
  652. m_ResourceManager.UpdatableVersionListSerializer.RegisterDeserializeCallback(2, BuiltinVersionListSerializer.UpdatableVersionListDeserializeCallback_V2);
  653. m_ResourceManager.UpdatableVersionListSerializer.RegisterTryGetValueCallback(0, BuiltinVersionListSerializer.UpdatableVersionListTryGetValueCallback_V0);
  654. m_ResourceManager.UpdatableVersionListSerializer.RegisterTryGetValueCallback(1, BuiltinVersionListSerializer.UpdatableVersionListTryGetValueCallback_V1_V2);
  655. m_ResourceManager.UpdatableVersionListSerializer.RegisterTryGetValueCallback(2, BuiltinVersionListSerializer.UpdatableVersionListTryGetValueCallback_V1_V2);
  656. m_ResourceManager.ReadOnlyVersionListSerializer.RegisterDeserializeCallback(0, BuiltinVersionListSerializer.LocalVersionListDeserializeCallback_V0);
  657. m_ResourceManager.ReadOnlyVersionListSerializer.RegisterDeserializeCallback(1, BuiltinVersionListSerializer.LocalVersionListDeserializeCallback_V1);
  658. m_ResourceManager.ReadOnlyVersionListSerializer.RegisterDeserializeCallback(2, BuiltinVersionListSerializer.LocalVersionListDeserializeCallback_V2);
  659. m_ResourceManager.ReadWriteVersionListSerializer.RegisterSerializeCallback(0, BuiltinVersionListSerializer.LocalVersionListSerializeCallback_V0);
  660. m_ResourceManager.ReadWriteVersionListSerializer.RegisterSerializeCallback(1, BuiltinVersionListSerializer.LocalVersionListSerializeCallback_V1);
  661. m_ResourceManager.ReadWriteVersionListSerializer.RegisterSerializeCallback(2, BuiltinVersionListSerializer.LocalVersionListSerializeCallback_V2);
  662. m_ResourceManager.ReadWriteVersionListSerializer.RegisterDeserializeCallback(0, BuiltinVersionListSerializer.LocalVersionListDeserializeCallback_V0);
  663. m_ResourceManager.ReadWriteVersionListSerializer.RegisterDeserializeCallback(1, BuiltinVersionListSerializer.LocalVersionListDeserializeCallback_V1);
  664. m_ResourceManager.ReadWriteVersionListSerializer.RegisterDeserializeCallback(2, BuiltinVersionListSerializer.LocalVersionListDeserializeCallback_V2);
  665. m_ResourceManager.ResourcePackVersionListSerializer.RegisterDeserializeCallback(0, BuiltinVersionListSerializer.ResourcePackVersionListDeserializeCallback_V0);
  666. break;
  667. }
  668. }
  669. /// <summary>
  670. /// 设置当前变体。
  671. /// </summary>
  672. /// <param name="currentVariant">当前变体。</param>
  673. public void SetCurrentVariant(string currentVariant)
  674. {
  675. m_ResourceManager.SetCurrentVariant(!string.IsNullOrEmpty(currentVariant) ? currentVariant : null);
  676. }
  677. /// <summary>
  678. /// 设置解密资源回调函数。
  679. /// </summary>
  680. /// <param name="decryptResourceCallback">要设置的解密资源回调函数。</param>
  681. /// <remarks>如果不设置,将使用默认的解密资源回调函数。</remarks>
  682. public void SetDecryptResourceCallback(DecryptResourceCallback decryptResourceCallback)
  683. {
  684. m_ResourceManager.SetDecryptResourceCallback(decryptResourceCallback);
  685. }
  686. /// <summary>
  687. /// 预订执行释放未被使用的资源。
  688. /// </summary>
  689. /// <param name="performGCCollect">是否使用垃圾回收。</param>
  690. public void UnloadUnusedAssets(bool performGCCollect)
  691. {
  692. m_PreorderUnloadUnusedAssets = true;
  693. if (performGCCollect)
  694. {
  695. m_PerformGCCollect = performGCCollect;
  696. }
  697. }
  698. /// <summary>
  699. /// 强制执行释放未被使用的资源。
  700. /// </summary>
  701. /// <param name="performGCCollect">是否使用垃圾回收。</param>
  702. public void ForceUnloadUnusedAssets(bool performGCCollect)
  703. {
  704. m_ForceUnloadUnusedAssets = true;
  705. if (performGCCollect)
  706. {
  707. m_PerformGCCollect = performGCCollect;
  708. }
  709. }
  710. /// <summary>
  711. /// 使用单机模式并初始化资源。
  712. /// </summary>
  713. /// <param name="initResourcesCompleteCallback">使用单机模式并初始化资源完成时的回调函数。</param>
  714. public void InitResources(InitResourcesCompleteCallback initResourcesCompleteCallback)
  715. {
  716. m_ResourceManager.InitResources(initResourcesCompleteCallback);
  717. }
  718. /// <summary>
  719. /// 使用可更新模式并检查版本资源列表。
  720. /// </summary>
  721. /// <param name="latestInternalResourceVersion">最新的内部资源版本号。</param>
  722. /// <returns>检查版本资源列表结果。</returns>
  723. public CheckVersionListResult CheckVersionList(int latestInternalResourceVersion)
  724. {
  725. return m_ResourceManager.CheckVersionList(latestInternalResourceVersion);
  726. }
  727. /// <summary>
  728. /// 使用可更新模式并更新版本资源列表。
  729. /// </summary>
  730. /// <param name="versionListLength">版本资源列表大小。</param>
  731. /// <param name="versionListHashCode">版本资源列表哈希值。</param>
  732. /// <param name="versionListCompressedLength">版本资源列表压缩后大小。</param>
  733. /// <param name="versionListCompressedHashCode">版本资源列表压缩后哈希值。</param>
  734. /// <param name="updateVersionListCallbacks">版本资源列表更新回调函数集。</param>
  735. public void UpdateVersionList(int versionListLength, int versionListHashCode, int versionListCompressedLength, int versionListCompressedHashCode, UpdateVersionListCallbacks updateVersionListCallbacks)
  736. {
  737. m_ResourceManager.UpdateVersionList(versionListLength, versionListHashCode, versionListCompressedLength, versionListCompressedHashCode, updateVersionListCallbacks);
  738. }
  739. /// <summary>
  740. /// 使用可更新模式并检查资源。
  741. /// </summary>
  742. /// <param name="checkResourcesCompleteCallback">使用可更新模式并检查资源完成时的回调函数。</param>
  743. public void CheckResources(CheckResourcesCompleteCallback checkResourcesCompleteCallback)
  744. {
  745. m_ResourceManager.CheckResources(false, checkResourcesCompleteCallback);
  746. }
  747. /// <summary>
  748. /// 使用可更新模式并检查资源。
  749. /// </summary>
  750. /// <param name="ignoreOtherVariant">是否忽略处理其它变体的资源,若不忽略,将会移除其它变体的资源。</param>
  751. /// <param name="checkResourcesCompleteCallback">使用可更新模式并检查资源完成时的回调函数。</param>
  752. public void CheckResources(bool ignoreOtherVariant, CheckResourcesCompleteCallback checkResourcesCompleteCallback)
  753. {
  754. m_ResourceManager.CheckResources(ignoreOtherVariant, checkResourcesCompleteCallback);
  755. }
  756. /// <summary>
  757. /// 使用可更新模式并应用资源包资源。
  758. /// </summary>
  759. /// <param name="resourcePackPath">要应用的资源包路径。</param>
  760. /// <param name="applyResourcesCompleteCallback">使用可更新模式并应用资源包资源完成时的回调函数。</param>
  761. public void ApplyResources(string resourcePackPath, ApplyResourcesCompleteCallback applyResourcesCompleteCallback)
  762. {
  763. m_ResourceManager.ApplyResources(resourcePackPath, applyResourcesCompleteCallback);
  764. }
  765. /// <summary>
  766. /// 使用可更新模式并更新所有资源。
  767. /// </summary>
  768. /// <param name="updateResourcesCompleteCallback">使用可更新模式并更新默认资源组完成时的回调函数。</param>
  769. public void UpdateResources(UpdateResourcesCompleteCallback updateResourcesCompleteCallback)
  770. {
  771. m_ResourceManager.UpdateResources(updateResourcesCompleteCallback);
  772. }
  773. /// <summary>
  774. /// 使用可更新模式并更新指定资源组的资源。
  775. /// </summary>
  776. /// <param name="resourceGroupName">要更新的资源组名称。</param>
  777. /// <param name="updateResourcesCompleteCallback">使用可更新模式并更新指定资源组完成时的回调函数。</param>
  778. public void UpdateResources(string resourceGroupName, UpdateResourcesCompleteCallback updateResourcesCompleteCallback)
  779. {
  780. m_ResourceManager.UpdateResources(resourceGroupName, updateResourcesCompleteCallback);
  781. }
  782. /// <summary>
  783. /// 停止更新资源。
  784. /// </summary>
  785. public void StopUpdateResources()
  786. {
  787. m_ResourceManager.StopUpdateResources();
  788. }
  789. /// <summary>
  790. /// 校验资源包。
  791. /// </summary>
  792. /// <param name="resourcePackPath">要校验的资源包路径。</param>
  793. /// <returns>是否校验资源包成功。</returns>
  794. public bool VerifyResourcePack(string resourcePackPath)
  795. {
  796. return m_ResourceManager.VerifyResourcePack(resourcePackPath);
  797. }
  798. /// <summary>
  799. /// 获取所有加载资源任务的信息。
  800. /// </summary>
  801. /// <returns>所有加载资源任务的信息。</returns>
  802. public GameFramework.TaskInfo[] GetAllLoadAssetInfos()
  803. {
  804. return m_ResourceManager.GetAllLoadAssetInfos();
  805. }
  806. /// <summary>
  807. /// 获取所有加载资源任务的信息。
  808. /// </summary>
  809. /// <param name="results">所有加载资源任务的信息。</param>
  810. public void GetAllLoadAssetInfos(List<GameFramework.TaskInfo> results)
  811. {
  812. m_ResourceManager.GetAllLoadAssetInfos(results);
  813. }
  814. /// <summary>
  815. /// 检查资源是否存在。
  816. /// </summary>
  817. /// <param name="assetName">要检查资源的名称。</param>
  818. /// <returns>检查资源是否存在的结果。</returns>
  819. public HasAssetResult HasAsset(string assetName)
  820. {
  821. return m_ResourceManager.HasAsset(assetName);
  822. }
  823. /// <summary>
  824. /// 异步加载资源。
  825. /// </summary>
  826. /// <param name="assetName">要加载资源的名称。</param>
  827. /// <param name="loadAssetCallbacks">加载资源回调函数集。</param>
  828. public void LoadAsset(string assetName, LoadAssetCallbacks loadAssetCallbacks)
  829. {
  830. LoadAsset(assetName, null, DefaultPriority, loadAssetCallbacks, null);
  831. }
  832. /// <summary>
  833. /// 异步加载资源。
  834. /// </summary>
  835. /// <param name="assetName">要加载资源的名称。</param>
  836. /// <param name="assetType">要加载资源的类型。</param>
  837. /// <param name="loadAssetCallbacks">加载资源回调函数集。</param>
  838. public void LoadAsset(string assetName, Type assetType, LoadAssetCallbacks loadAssetCallbacks)
  839. {
  840. LoadAsset(assetName, assetType, DefaultPriority, loadAssetCallbacks, null);
  841. }
  842. /// <summary>
  843. /// 异步加载资源。
  844. /// </summary>
  845. /// <param name="assetName">要加载资源的名称。</param>
  846. /// <param name="priority">加载资源的优先级。</param>
  847. /// <param name="loadAssetCallbacks">加载资源回调函数集。</param>
  848. public void LoadAsset(string assetName, int priority, LoadAssetCallbacks loadAssetCallbacks)
  849. {
  850. LoadAsset(assetName, null, priority, loadAssetCallbacks, null);
  851. }
  852. /// <summary>
  853. /// 异步加载资源。
  854. /// </summary>
  855. /// <param name="assetName">要加载资源的名称。</param>
  856. /// <param name="loadAssetCallbacks">加载资源回调函数集。</param>
  857. /// <param name="userData">用户自定义数据。</param>
  858. public void LoadAsset(string assetName, LoadAssetCallbacks loadAssetCallbacks, object userData)
  859. {
  860. LoadAsset(assetName, null, DefaultPriority, loadAssetCallbacks, userData);
  861. }
  862. /// <summary>
  863. /// 异步加载资源。
  864. /// </summary>
  865. /// <param name="assetName">要加载资源的名称。</param>
  866. /// <param name="assetType">要加载资源的类型。</param>
  867. /// <param name="priority">加载资源的优先级。</param>
  868. /// <param name="loadAssetCallbacks">加载资源回调函数集。</param>
  869. public void LoadAsset(string assetName, Type assetType, int priority, LoadAssetCallbacks loadAssetCallbacks)
  870. {
  871. LoadAsset(assetName, assetType, priority, loadAssetCallbacks, null);
  872. }
  873. /// <summary>
  874. /// 异步加载资源。
  875. /// </summary>
  876. /// <param name="assetName">要加载资源的名称。</param>
  877. /// <param name="assetType">要加载资源的类型。</param>
  878. /// <param name="loadAssetCallbacks">加载资源回调函数集。</param>
  879. /// <param name="userData">用户自定义数据。</param>
  880. public void LoadAsset(string assetName, Type assetType, LoadAssetCallbacks loadAssetCallbacks, object userData)
  881. {
  882. LoadAsset(assetName, assetType, DefaultPriority, loadAssetCallbacks, userData);
  883. }
  884. /// <summary>
  885. /// 异步加载资源。
  886. /// </summary>
  887. /// <param name="assetName">要加载资源的名称。</param>
  888. /// <param name="priority">加载资源的优先级。</param>
  889. /// <param name="loadAssetCallbacks">加载资源回调函数集。</param>
  890. /// <param name="userData">用户自定义数据。</param>
  891. public void LoadAsset(string assetName, int priority, LoadAssetCallbacks loadAssetCallbacks, object userData)
  892. {
  893. LoadAsset(assetName, null, priority, loadAssetCallbacks, userData);
  894. }
  895. /// <summary>
  896. /// 异步加载资源。
  897. /// </summary>
  898. /// <param name="assetName">要加载资源的名称。</param>
  899. /// <param name="assetType">要加载资源的类型。</param>
  900. /// <param name="priority">加载资源的优先级。</param>
  901. /// <param name="loadAssetCallbacks">加载资源回调函数集。</param>
  902. /// <param name="userData">用户自定义数据。</param>
  903. public void LoadAsset(string assetName, Type assetType, int priority, LoadAssetCallbacks loadAssetCallbacks, object userData)
  904. {
  905. if (string.IsNullOrEmpty(assetName))
  906. {
  907. Log.Error("Asset name is invalid.");
  908. return;
  909. }
  910. if (!assetName.StartsWith("Assets/", StringComparison.Ordinal))
  911. {
  912. Log.Error("Asset name '{0}' is invalid.", assetName);
  913. return;
  914. }
  915. m_ResourceManager.LoadAsset(assetName, assetType, priority, loadAssetCallbacks, userData);
  916. }
  917. /// <summary>
  918. /// 卸载资源。
  919. /// </summary>
  920. /// <param name="asset">要卸载的资源。</param>
  921. public void UnloadAsset(object asset)
  922. {
  923. m_ResourceManager.UnloadAsset(asset);
  924. }
  925. /// <summary>
  926. /// 获取二进制资源的实际路径。
  927. /// </summary>
  928. /// <param name="binaryAssetName">要获取实际路径的二进制资源的名称。</param>
  929. /// <returns>二进制资源的实际路径。</returns>
  930. /// <remarks>此方法仅适用于二进制资源存储在磁盘(而非文件系统)中的情况。若二进制资源存储在文件系统中时,返回值将始终为空。</remarks>
  931. public string GetBinaryPath(string binaryAssetName)
  932. {
  933. return m_ResourceManager.GetBinaryPath(binaryAssetName);
  934. }
  935. /// <summary>
  936. /// 获取二进制资源的实际路径。
  937. /// </summary>
  938. /// <param name="binaryAssetName">要获取实际路径的二进制资源的名称。</param>
  939. /// <param name="storageInReadOnly">二进制资源是否存储在只读区中。</param>
  940. /// <param name="storageInFileSystem">二进制资源是否存储在文件系统中。</param>
  941. /// <param name="relativePath">二进制资源或存储二进制资源的文件系统,相对于只读区或者读写区的相对路径。</param>
  942. /// <param name="fileName">若二进制资源存储在文件系统中,则指示二进制资源在文件系统中的名称,否则此参数返回空。</param>
  943. /// <returns>是否获取二进制资源的实际路径成功。</returns>
  944. public bool GetBinaryPath(string binaryAssetName, out bool storageInReadOnly, out bool storageInFileSystem, out string relativePath, out string fileName)
  945. {
  946. return m_ResourceManager.GetBinaryPath(binaryAssetName, out storageInReadOnly, out storageInFileSystem, out relativePath, out fileName);
  947. }
  948. /// <summary>
  949. /// 获取二进制资源的长度。
  950. /// </summary>
  951. /// <param name="binaryAssetName">要获取长度的二进制资源的名称。</param>
  952. /// <returns>二进制资源的长度。</returns>
  953. public int GetBinaryLength(string binaryAssetName)
  954. {
  955. return m_ResourceManager.GetBinaryLength(binaryAssetName);
  956. }
  957. /// <summary>
  958. /// 异步加载二进制资源。
  959. /// </summary>
  960. /// <param name="binaryAssetName">要加载二进制资源的名称。</param>
  961. /// <param name="loadBinaryCallbacks">加载二进制资源回调函数集。</param>
  962. public void LoadBinary(string binaryAssetName, LoadBinaryCallbacks loadBinaryCallbacks)
  963. {
  964. LoadBinary(binaryAssetName, loadBinaryCallbacks, null);
  965. }
  966. /// <summary>
  967. /// 异步加载二进制资源。
  968. /// </summary>
  969. /// <param name="binaryAssetName">要加载二进制资源的名称。</param>
  970. /// <param name="loadBinaryCallbacks">加载二进制资源回调函数集。</param>
  971. /// <param name="userData">用户自定义数据。</param>
  972. public void LoadBinary(string binaryAssetName, LoadBinaryCallbacks loadBinaryCallbacks, object userData)
  973. {
  974. if (string.IsNullOrEmpty(binaryAssetName))
  975. {
  976. Log.Error("Binary asset name is invalid.");
  977. return;
  978. }
  979. if (!binaryAssetName.StartsWith("Assets/", StringComparison.Ordinal))
  980. {
  981. Log.Error("Binary asset name '{0}' is invalid.", binaryAssetName);
  982. return;
  983. }
  984. m_ResourceManager.LoadBinary(binaryAssetName, loadBinaryCallbacks, userData);
  985. }
  986. /// <summary>
  987. /// 从文件系统中加载二进制资源。
  988. /// </summary>
  989. /// <param name="binaryAssetName">要加载二进制资源的名称。</param>
  990. /// <returns>存储加载二进制资源的二进制流。</returns>
  991. public byte[] LoadBinaryFromFileSystem(string binaryAssetName)
  992. {
  993. if (string.IsNullOrEmpty(binaryAssetName))
  994. {
  995. Log.Error("Binary asset name is invalid.");
  996. return null;
  997. }
  998. if (!binaryAssetName.StartsWith("Assets/", StringComparison.Ordinal))
  999. {
  1000. Log.Error("Binary asset name '{0}' is invalid.", binaryAssetName);
  1001. return null;
  1002. }
  1003. return m_ResourceManager.LoadBinaryFromFileSystem(binaryAssetName);
  1004. }
  1005. /// <summary>
  1006. /// 从文件系统中加载二进制资源。
  1007. /// </summary>
  1008. /// <param name="binaryAssetName">要加载二进制资源的名称。</param>
  1009. /// <param name="buffer">存储加载二进制资源的二进制流。</param>
  1010. /// <returns>实际加载了多少字节。</returns>
  1011. public int LoadBinaryFromFileSystem(string binaryAssetName, byte[] buffer)
  1012. {
  1013. if (buffer == null)
  1014. {
  1015. Log.Error("Buffer is invalid.");
  1016. return 0;
  1017. }
  1018. return LoadBinaryFromFileSystem(binaryAssetName, buffer, 0, buffer.Length);
  1019. }
  1020. /// <summary>
  1021. /// 从文件系统中加载二进制资源。
  1022. /// </summary>
  1023. /// <param name="binaryAssetName">要加载二进制资源的名称。</param>
  1024. /// <param name="buffer">存储加载二进制资源的二进制流。</param>
  1025. /// <param name="startIndex">存储加载二进制资源的二进制流的起始位置。</param>
  1026. /// <returns>实际加载了多少字节。</returns>
  1027. public int LoadBinaryFromFileSystem(string binaryAssetName, byte[] buffer, int startIndex)
  1028. {
  1029. if (buffer == null)
  1030. {
  1031. Log.Error("Buffer is invalid.");
  1032. return 0;
  1033. }
  1034. return LoadBinaryFromFileSystem(binaryAssetName, buffer, startIndex, buffer.Length - startIndex);
  1035. }
  1036. /// <summary>
  1037. /// 从文件系统中加载二进制资源。
  1038. /// </summary>
  1039. /// <param name="binaryAssetName">要加载二进制资源的名称。</param>
  1040. /// <param name="buffer">存储加载二进制资源的二进制流。</param>
  1041. /// <param name="startIndex">存储加载二进制资源的二进制流的起始位置。</param>
  1042. /// <param name="length">存储加载二进制资源的二进制流的长度。</param>
  1043. /// <returns>实际加载了多少字节。</returns>
  1044. public int LoadBinaryFromFileSystem(string binaryAssetName, byte[] buffer, int startIndex, int length)
  1045. {
  1046. if (string.IsNullOrEmpty(binaryAssetName))
  1047. {
  1048. Log.Error("Binary asset name is invalid.");
  1049. return 0;
  1050. }
  1051. if (!binaryAssetName.StartsWith("Assets/", StringComparison.Ordinal))
  1052. {
  1053. Log.Error("Binary asset name '{0}' is invalid.", binaryAssetName);
  1054. return 0;
  1055. }
  1056. if (buffer == null)
  1057. {
  1058. Log.Error("Buffer is invalid.");
  1059. return 0;
  1060. }
  1061. return m_ResourceManager.LoadBinaryFromFileSystem(binaryAssetName, buffer, startIndex, length);
  1062. }
  1063. /// <summary>
  1064. /// 从文件系统中加载二进制资源的片段。
  1065. /// </summary>
  1066. /// <param name="binaryAssetName">要加载片段的二进制资源的名称。</param>
  1067. /// <param name="length">要加载片段的长度。</param>
  1068. /// <returns>存储加载二进制资源片段内容的二进制流。</returns>
  1069. public byte[] LoadBinarySegmentFromFileSystem(string binaryAssetName, int length)
  1070. {
  1071. return LoadBinarySegmentFromFileSystem(binaryAssetName, 0, length);
  1072. }
  1073. /// <summary>
  1074. /// 从文件系统中加载二进制资源的片段。
  1075. /// </summary>
  1076. /// <param name="binaryAssetName">要加载片段的二进制资源的名称。</param>
  1077. /// <param name="offset">要加载片段的偏移。</param>
  1078. /// <param name="length">要加载片段的长度。</param>
  1079. /// <returns>存储加载二进制资源片段内容的二进制流。</returns>
  1080. public byte[] LoadBinarySegmentFromFileSystem(string binaryAssetName, int offset, int length)
  1081. {
  1082. if (string.IsNullOrEmpty(binaryAssetName))
  1083. {
  1084. Log.Error("Binary asset name is invalid.");
  1085. return null;
  1086. }
  1087. if (!binaryAssetName.StartsWith("Assets/", StringComparison.Ordinal))
  1088. {
  1089. Log.Error("Binary asset name '{0}' is invalid.", binaryAssetName);
  1090. return null;
  1091. }
  1092. return m_ResourceManager.LoadBinarySegmentFromFileSystem(binaryAssetName, offset, length);
  1093. }
  1094. /// <summary>
  1095. /// 从文件系统中加载二进制资源的片段。
  1096. /// </summary>
  1097. /// <param name="binaryAssetName">要加载片段的二进制资源的名称。</param>
  1098. /// <param name="buffer">存储加载二进制资源片段内容的二进制流。</param>
  1099. /// <returns>实际加载了多少字节。</returns>
  1100. public int LoadBinarySegmentFromFileSystem(string binaryAssetName, byte[] buffer)
  1101. {
  1102. if (buffer == null)
  1103. {
  1104. Log.Error("Buffer is invalid.");
  1105. return 0;
  1106. }
  1107. return LoadBinarySegmentFromFileSystem(binaryAssetName, 0, buffer, 0, buffer.Length);
  1108. }
  1109. /// <summary>
  1110. /// 从文件系统中加载二进制资源的片段。
  1111. /// </summary>
  1112. /// <param name="binaryAssetName">要加载片段的二进制资源的名称。</param>
  1113. /// <param name="buffer">存储加载二进制资源片段内容的二进制流。</param>
  1114. /// <param name="length">要加载片段的长度。</param>
  1115. /// <returns>实际加载了多少字节。</returns>
  1116. public int LoadBinarySegmentFromFileSystem(string binaryAssetName, byte[] buffer, int length)
  1117. {
  1118. return LoadBinarySegmentFromFileSystem(binaryAssetName, 0, buffer, 0, length);
  1119. }
  1120. /// <summary>
  1121. /// 从文件系统中加载二进制资源的片段。
  1122. /// </summary>
  1123. /// <param name="binaryAssetName">要加载片段的二进制资源的名称。</param>
  1124. /// <param name="buffer">存储加载二进制资源片段内容的二进制流。</param>
  1125. /// <param name="startIndex">存储加载二进制资源片段内容的二进制流的起始位置。</param>
  1126. /// <param name="length">要加载片段的长度。</param>
  1127. /// <returns>实际加载了多少字节。</returns>
  1128. public int LoadBinarySegmentFromFileSystem(string binaryAssetName, byte[] buffer, int startIndex, int length)
  1129. {
  1130. return LoadBinarySegmentFromFileSystem(binaryAssetName, 0, buffer, startIndex, length);
  1131. }
  1132. /// <summary>
  1133. /// 从文件系统中加载二进制资源的片段。
  1134. /// </summary>
  1135. /// <param name="binaryAssetName">要加载片段的二进制资源的名称。</param>
  1136. /// <param name="offset">要加载片段的偏移。</param>
  1137. /// <param name="buffer">存储加载二进制资源片段内容的二进制流。</param>
  1138. /// <returns>实际加载了多少字节。</returns>
  1139. public int LoadBinarySegmentFromFileSystem(string binaryAssetName, int offset, byte[] buffer)
  1140. {
  1141. if (buffer == null)
  1142. {
  1143. Log.Error("Buffer is invalid.");
  1144. return 0;
  1145. }
  1146. return LoadBinarySegmentFromFileSystem(binaryAssetName, offset, buffer, 0, buffer.Length);
  1147. }
  1148. /// <summary>
  1149. /// 从文件系统中加载二进制资源的片段。
  1150. /// </summary>
  1151. /// <param name="binaryAssetName">要加载片段的二进制资源的名称。</param>
  1152. /// <param name="offset">要加载片段的偏移。</param>
  1153. /// <param name="buffer">存储加载二进制资源片段内容的二进制流。</param>
  1154. /// <param name="length">要加载片段的长度。</param>
  1155. /// <returns>实际加载了多少字节。</returns>
  1156. public int LoadBinarySegmentFromFileSystem(string binaryAssetName, int offset, byte[] buffer, int length)
  1157. {
  1158. return LoadBinarySegmentFromFileSystem(binaryAssetName, offset, buffer, 0, length);
  1159. }
  1160. /// <summary>
  1161. /// 从文件系统中加载二进制资源的片段。
  1162. /// </summary>
  1163. /// <param name="binaryAssetName">要加载片段的二进制资源的名称。</param>
  1164. /// <param name="offset">要加载片段的偏移。</param>
  1165. /// <param name="buffer">存储加载二进制资源片段内容的二进制流。</param>
  1166. /// <param name="startIndex">存储加载二进制资源片段内容的二进制流的起始位置。</param>
  1167. /// <param name="length">要加载片段的长度。</param>
  1168. /// <returns>实际加载了多少字节。</returns>
  1169. public int LoadBinarySegmentFromFileSystem(string binaryAssetName, int offset, byte[] buffer, int startIndex, int length)
  1170. {
  1171. if (string.IsNullOrEmpty(binaryAssetName))
  1172. {
  1173. Log.Error("Binary asset name is invalid.");
  1174. return 0;
  1175. }
  1176. if (!binaryAssetName.StartsWith("Assets/", StringComparison.Ordinal))
  1177. {
  1178. Log.Error("Binary asset name '{0}' is invalid.", binaryAssetName);
  1179. return 0;
  1180. }
  1181. if (buffer == null)
  1182. {
  1183. Log.Error("Buffer is invalid.");
  1184. return 0;
  1185. }
  1186. return m_ResourceManager.LoadBinarySegmentFromFileSystem(binaryAssetName, offset, buffer, startIndex, length);
  1187. }
  1188. /// <summary>
  1189. /// 检查资源组是否存在。
  1190. /// </summary>
  1191. /// <param name="resourceGroupName">要检查资源组的名称。</param>
  1192. /// <returns>资源组是否存在。</returns>
  1193. public bool HasResourceGroup(string resourceGroupName)
  1194. {
  1195. return m_ResourceManager.HasResourceGroup(resourceGroupName);
  1196. }
  1197. /// <summary>
  1198. /// 获取默认资源组。
  1199. /// </summary>
  1200. /// <returns>默认资源组。</returns>
  1201. public IResourceGroup GetResourceGroup()
  1202. {
  1203. return m_ResourceManager.GetResourceGroup();
  1204. }
  1205. /// <summary>
  1206. /// 获取资源组。
  1207. /// </summary>
  1208. /// <param name="resourceGroupName">要获取的资源组名称。</param>
  1209. /// <returns>要获取的资源组。</returns>
  1210. public IResourceGroup GetResourceGroup(string resourceGroupName)
  1211. {
  1212. return m_ResourceManager.GetResourceGroup(resourceGroupName);
  1213. }
  1214. /// <summary>
  1215. /// 获取所有资源组。
  1216. /// </summary>
  1217. /// <returns>所有资源组。</returns>
  1218. public IResourceGroup[] GetAllResourceGroups()
  1219. {
  1220. return m_ResourceManager.GetAllResourceGroups();
  1221. }
  1222. /// <summary>
  1223. /// 获取所有资源组。
  1224. /// </summary>
  1225. /// <param name="results">所有资源组。</param>
  1226. public void GetAllResourceGroups(List<IResourceGroup> results)
  1227. {
  1228. m_ResourceManager.GetAllResourceGroups(results);
  1229. }
  1230. /// <summary>
  1231. /// 获取资源组集合。
  1232. /// </summary>
  1233. /// <param name="resourceGroupNames">要获取的资源组名称的集合。</param>
  1234. /// <returns>要获取的资源组集合。</returns>
  1235. public IResourceGroupCollection GetResourceGroupCollection(params string[] resourceGroupNames)
  1236. {
  1237. return m_ResourceManager.GetResourceGroupCollection(resourceGroupNames);
  1238. }
  1239. /// <summary>
  1240. /// 获取资源组集合。
  1241. /// </summary>
  1242. /// <param name="resourceGroupNames">要获取的资源组名称的集合。</param>
  1243. /// <returns>要获取的资源组集合。</returns>
  1244. public IResourceGroupCollection GetResourceGroupCollection(List<string> resourceGroupNames)
  1245. {
  1246. return m_ResourceManager.GetResourceGroupCollection(resourceGroupNames);
  1247. }
  1248. /// <summary>
  1249. /// 增加加载资源代理辅助器。
  1250. /// </summary>
  1251. /// <param name="index">加载资源代理辅助器索引。</param>
  1252. private void AddLoadResourceAgentHelper(int index)
  1253. {
  1254. LoadResourceAgentHelperBase loadResourceAgentHelper = Helper.CreateHelper(m_LoadResourceAgentHelperTypeName, m_CustomLoadResourceAgentHelper, index);
  1255. if (loadResourceAgentHelper == null)
  1256. {
  1257. Log.Error("Can not create load resource agent helper.");
  1258. return;
  1259. }
  1260. loadResourceAgentHelper.name = Utility.Text.Format("Load Resource Agent Helper - {0}", index.ToString());
  1261. Transform transform = loadResourceAgentHelper.transform;
  1262. transform.SetParent(m_InstanceRoot);
  1263. transform.localScale = Vector3.one;
  1264. m_ResourceManager.AddLoadResourceAgentHelper(loadResourceAgentHelper);
  1265. }
  1266. private void OnResourceApplySuccess(object sender, GameFramework.Resource.ResourceApplySuccessEventArgs e)
  1267. {
  1268. m_EventComponent.Fire(this, ResourceApplySuccessEventArgs.Create(e));
  1269. }
  1270. private void OnResourceApplyFailure(object sender, GameFramework.Resource.ResourceApplyFailureEventArgs e)
  1271. {
  1272. m_EventComponent.Fire(this, ResourceApplyFailureEventArgs.Create(e));
  1273. }
  1274. private void OnResourceUpdateStart(object sender, GameFramework.Resource.ResourceUpdateStartEventArgs e)
  1275. {
  1276. m_EventComponent.Fire(this, ResourceUpdateStartEventArgs.Create(e));
  1277. }
  1278. private void OnResourceUpdateChanged(object sender, GameFramework.Resource.ResourceUpdateChangedEventArgs e)
  1279. {
  1280. m_EventComponent.Fire(this, ResourceUpdateChangedEventArgs.Create(e));
  1281. }
  1282. private void OnResourceUpdateSuccess(object sender, GameFramework.Resource.ResourceUpdateSuccessEventArgs e)
  1283. {
  1284. m_EventComponent.Fire(this, ResourceUpdateSuccessEventArgs.Create(e));
  1285. }
  1286. private void OnResourceUpdateFailure(object sender, GameFramework.Resource.ResourceUpdateFailureEventArgs e)
  1287. {
  1288. m_EventComponent.Fire(this, ResourceUpdateFailureEventArgs.Create(e));
  1289. }
  1290. private void OnResourceUpdateAllComplete(object sender, GameFramework.Resource.ResourceUpdateAllCompleteEventArgs e)
  1291. {
  1292. m_EventComponent.Fire(this, ResourceUpdateAllCompleteEventArgs.Create(e));
  1293. }
  1294. }
  1295. }