ResourceManager.ResourceLoader.cs 42 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943
  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.FileSystem;
  8. using GameFramework.ObjectPool;
  9. using System;
  10. using System.Collections.Generic;
  11. using System.IO;
  12. namespace GameFramework.Resource
  13. {
  14. internal sealed partial class ResourceManager : GameFrameworkModule, IResourceManager
  15. {
  16. /// <summary>
  17. /// 加载资源器。
  18. /// </summary>
  19. private sealed partial class ResourceLoader
  20. {
  21. private const int CachedHashBytesLength = 4;
  22. private readonly ResourceManager m_ResourceManager;
  23. private readonly TaskPool<LoadResourceTaskBase> m_TaskPool;
  24. private readonly Dictionary<object, int> m_AssetDependencyCount;
  25. private readonly Dictionary<object, int> m_ResourceDependencyCount;
  26. private readonly Dictionary<object, object> m_AssetToResourceMap;
  27. private readonly Dictionary<string, object> m_SceneToAssetMap;
  28. private readonly LoadBytesCallbacks m_LoadBytesCallbacks;
  29. private readonly byte[] m_CachedHashBytes;
  30. private IObjectPool<AssetObject> m_AssetPool;
  31. private IObjectPool<ResourceObject> m_ResourcePool;
  32. /// <summary>
  33. /// 初始化加载资源器的新实例。
  34. /// </summary>
  35. /// <param name="resourceManager">资源管理器。</param>
  36. public ResourceLoader(ResourceManager resourceManager)
  37. {
  38. m_ResourceManager = resourceManager;
  39. m_TaskPool = new TaskPool<LoadResourceTaskBase>();
  40. m_AssetDependencyCount = new Dictionary<object, int>();
  41. m_ResourceDependencyCount = new Dictionary<object, int>();
  42. m_AssetToResourceMap = new Dictionary<object, object>();
  43. m_SceneToAssetMap = new Dictionary<string, object>(StringComparer.Ordinal);
  44. m_LoadBytesCallbacks = new LoadBytesCallbacks(OnLoadBinarySuccess, OnLoadBinaryFailure);
  45. m_CachedHashBytes = new byte[CachedHashBytesLength];
  46. m_AssetPool = null;
  47. m_ResourcePool = null;
  48. }
  49. /// <summary>
  50. /// 获取加载资源代理总数量。
  51. /// </summary>
  52. public int TotalAgentCount
  53. {
  54. get
  55. {
  56. return m_TaskPool.TotalAgentCount;
  57. }
  58. }
  59. /// <summary>
  60. /// 获取可用加载资源代理数量。
  61. /// </summary>
  62. public int FreeAgentCount
  63. {
  64. get
  65. {
  66. return m_TaskPool.FreeAgentCount;
  67. }
  68. }
  69. /// <summary>
  70. /// 获取工作中加载资源代理数量。
  71. /// </summary>
  72. public int WorkingAgentCount
  73. {
  74. get
  75. {
  76. return m_TaskPool.WorkingAgentCount;
  77. }
  78. }
  79. /// <summary>
  80. /// 获取等待加载资源任务数量。
  81. /// </summary>
  82. public int WaitingTaskCount
  83. {
  84. get
  85. {
  86. return m_TaskPool.WaitingTaskCount;
  87. }
  88. }
  89. /// <summary>
  90. /// 获取或设置资源对象池自动释放可释放对象的间隔秒数。
  91. /// </summary>
  92. public float AssetAutoReleaseInterval
  93. {
  94. get
  95. {
  96. return m_AssetPool.AutoReleaseInterval;
  97. }
  98. set
  99. {
  100. m_AssetPool.AutoReleaseInterval = value;
  101. }
  102. }
  103. /// <summary>
  104. /// 获取或设置资源对象池的容量。
  105. /// </summary>
  106. public int AssetCapacity
  107. {
  108. get
  109. {
  110. return m_AssetPool.Capacity;
  111. }
  112. set
  113. {
  114. m_AssetPool.Capacity = value;
  115. }
  116. }
  117. /// <summary>
  118. /// 获取或设置资源对象池对象过期秒数。
  119. /// </summary>
  120. public float AssetExpireTime
  121. {
  122. get
  123. {
  124. return m_AssetPool.ExpireTime;
  125. }
  126. set
  127. {
  128. m_AssetPool.ExpireTime = value;
  129. }
  130. }
  131. /// <summary>
  132. /// 获取或设置资源对象池的优先级。
  133. /// </summary>
  134. public int AssetPriority
  135. {
  136. get
  137. {
  138. return m_AssetPool.Priority;
  139. }
  140. set
  141. {
  142. m_AssetPool.Priority = value;
  143. }
  144. }
  145. /// <summary>
  146. /// 获取或设置资源对象池自动释放可释放对象的间隔秒数。
  147. /// </summary>
  148. public float ResourceAutoReleaseInterval
  149. {
  150. get
  151. {
  152. return m_ResourcePool.AutoReleaseInterval;
  153. }
  154. set
  155. {
  156. m_ResourcePool.AutoReleaseInterval = value;
  157. }
  158. }
  159. /// <summary>
  160. /// 获取或设置资源对象池的容量。
  161. /// </summary>
  162. public int ResourceCapacity
  163. {
  164. get
  165. {
  166. return m_ResourcePool.Capacity;
  167. }
  168. set
  169. {
  170. m_ResourcePool.Capacity = value;
  171. }
  172. }
  173. /// <summary>
  174. /// 获取或设置资源对象池对象过期秒数。
  175. /// </summary>
  176. public float ResourceExpireTime
  177. {
  178. get
  179. {
  180. return m_ResourcePool.ExpireTime;
  181. }
  182. set
  183. {
  184. m_ResourcePool.ExpireTime = value;
  185. }
  186. }
  187. /// <summary>
  188. /// 获取或设置资源对象池的优先级。
  189. /// </summary>
  190. public int ResourcePriority
  191. {
  192. get
  193. {
  194. return m_ResourcePool.Priority;
  195. }
  196. set
  197. {
  198. m_ResourcePool.Priority = value;
  199. }
  200. }
  201. /// <summary>
  202. /// 加载资源器轮询。
  203. /// </summary>
  204. /// <param name="elapseSeconds">逻辑流逝时间,以秒为单位。</param>
  205. /// <param name="realElapseSeconds">真实流逝时间,以秒为单位。</param>
  206. public void Update(float elapseSeconds, float realElapseSeconds)
  207. {
  208. m_TaskPool.Update(elapseSeconds, realElapseSeconds);
  209. }
  210. /// <summary>
  211. /// 关闭并清理加载资源器。
  212. /// </summary>
  213. public void Shutdown()
  214. {
  215. m_TaskPool.Shutdown();
  216. m_AssetDependencyCount.Clear();
  217. m_ResourceDependencyCount.Clear();
  218. m_AssetToResourceMap.Clear();
  219. m_SceneToAssetMap.Clear();
  220. LoadResourceAgent.Clear();
  221. }
  222. /// <summary>
  223. /// 设置对象池管理器。
  224. /// </summary>
  225. /// <param name="objectPoolManager">对象池管理器。</param>
  226. public void SetObjectPoolManager(IObjectPoolManager objectPoolManager)
  227. {
  228. m_AssetPool = objectPoolManager.CreateMultiSpawnObjectPool<AssetObject>("Asset Pool");
  229. m_ResourcePool = objectPoolManager.CreateMultiSpawnObjectPool<ResourceObject>("Resource Pool");
  230. }
  231. /// <summary>
  232. /// 增加加载资源代理辅助器。
  233. /// </summary>
  234. /// <param name="loadResourceAgentHelper">要增加的加载资源代理辅助器。</param>
  235. /// <param name="resourceHelper">资源辅助器。</param>
  236. /// <param name="readOnlyPath">资源只读区路径。</param>
  237. /// <param name="readWritePath">资源读写区路径。</param>
  238. /// <param name="decryptResourceCallback">要设置的解密资源回调函数。</param>
  239. public void AddLoadResourceAgentHelper(ILoadResourceAgentHelper loadResourceAgentHelper, IResourceHelper resourceHelper, string readOnlyPath, string readWritePath, DecryptResourceCallback decryptResourceCallback)
  240. {
  241. if (m_AssetPool == null || m_ResourcePool == null)
  242. {
  243. throw new GameFrameworkException("You must set object pool manager first.");
  244. }
  245. LoadResourceAgent agent = new LoadResourceAgent(loadResourceAgentHelper, resourceHelper, this, readOnlyPath, readWritePath, decryptResourceCallback ?? DefaultDecryptResourceCallback);
  246. m_TaskPool.AddAgent(agent);
  247. }
  248. /// <summary>
  249. /// 检查资源是否存在。
  250. /// </summary>
  251. /// <param name="assetName">要检查资源的名称。</param>
  252. /// <returns>检查资源是否存在的结果。</returns>
  253. public HasAssetResult HasAsset(string assetName)
  254. {
  255. ResourceInfo resourceInfo = GetResourceInfo(assetName);
  256. if (resourceInfo == null)
  257. {
  258. return HasAssetResult.NotExist;
  259. }
  260. if (!resourceInfo.Ready && m_ResourceManager.m_ResourceMode != ResourceMode.UpdatableWhilePlaying)
  261. {
  262. return HasAssetResult.NotReady;
  263. }
  264. if (resourceInfo.UseFileSystem)
  265. {
  266. return resourceInfo.IsLoadFromBinary ? HasAssetResult.BinaryOnFileSystem : HasAssetResult.AssetOnFileSystem;
  267. }
  268. else
  269. {
  270. return resourceInfo.IsLoadFromBinary ? HasAssetResult.BinaryOnDisk : HasAssetResult.AssetOnDisk;
  271. }
  272. }
  273. /// <summary>
  274. /// 异步加载资源。
  275. /// </summary>
  276. /// <param name="assetName">要加载资源的名称。</param>
  277. /// <param name="assetType">要加载资源的类型。</param>
  278. /// <param name="priority">加载资源的优先级。</param>
  279. /// <param name="loadAssetCallbacks">加载资源回调函数集。</param>
  280. /// <param name="userData">用户自定义数据。</param>
  281. public void LoadAsset(string assetName, Type assetType, int priority, LoadAssetCallbacks loadAssetCallbacks, object userData)
  282. {
  283. ResourceInfo resourceInfo = null;
  284. string[] dependencyAssetNames = null;
  285. if (!CheckAsset(assetName, out resourceInfo, out dependencyAssetNames))
  286. {
  287. string errorMessage = Utility.Text.Format("Can not load asset '{0}'.", assetName);
  288. if (loadAssetCallbacks.LoadAssetFailureCallback != null)
  289. {
  290. loadAssetCallbacks.LoadAssetFailureCallback(assetName, resourceInfo != null && !resourceInfo.Ready ? LoadResourceStatus.NotReady : LoadResourceStatus.NotExist, errorMessage, userData);
  291. return;
  292. }
  293. throw new GameFrameworkException(errorMessage);
  294. }
  295. if (resourceInfo.IsLoadFromBinary)
  296. {
  297. string errorMessage = Utility.Text.Format("Can not load asset '{0}' which is a binary asset.", assetName);
  298. if (loadAssetCallbacks.LoadAssetFailureCallback != null)
  299. {
  300. loadAssetCallbacks.LoadAssetFailureCallback(assetName, LoadResourceStatus.TypeError, errorMessage, userData);
  301. return;
  302. }
  303. throw new GameFrameworkException(errorMessage);
  304. }
  305. LoadAssetTask mainTask = LoadAssetTask.Create(assetName, assetType, priority, resourceInfo, dependencyAssetNames, loadAssetCallbacks, userData);
  306. foreach (string dependencyAssetName in dependencyAssetNames)
  307. {
  308. if (!LoadDependencyAsset(dependencyAssetName, priority, mainTask, userData))
  309. {
  310. string errorMessage = Utility.Text.Format("Can not load dependency asset '{0}' when load asset '{1}'.", dependencyAssetName, assetName);
  311. if (loadAssetCallbacks.LoadAssetFailureCallback != null)
  312. {
  313. loadAssetCallbacks.LoadAssetFailureCallback(assetName, LoadResourceStatus.DependencyError, errorMessage, userData);
  314. return;
  315. }
  316. throw new GameFrameworkException(errorMessage);
  317. }
  318. }
  319. m_TaskPool.AddTask(mainTask);
  320. if (!resourceInfo.Ready)
  321. {
  322. m_ResourceManager.UpdateResource(resourceInfo.ResourceName);
  323. }
  324. }
  325. /// <summary>
  326. /// 卸载资源。
  327. /// </summary>
  328. /// <param name="asset">要卸载的资源。</param>
  329. public void UnloadAsset(object asset)
  330. {
  331. m_AssetPool.Unspawn(asset);
  332. }
  333. /// <summary>
  334. /// 异步加载场景。
  335. /// </summary>
  336. /// <param name="sceneAssetName">要加载场景资源的名称。</param>
  337. /// <param name="priority">加载场景资源的优先级。</param>
  338. /// <param name="loadSceneCallbacks">加载场景回调函数集。</param>
  339. /// <param name="userData">用户自定义数据。</param>
  340. public void LoadScene(string sceneAssetName, int priority, LoadSceneCallbacks loadSceneCallbacks, object userData)
  341. {
  342. ResourceInfo resourceInfo = null;
  343. string[] dependencyAssetNames = null;
  344. if (!CheckAsset(sceneAssetName, out resourceInfo, out dependencyAssetNames))
  345. {
  346. string errorMessage = Utility.Text.Format("Can not load scene '{0}'.", sceneAssetName);
  347. if (loadSceneCallbacks.LoadSceneFailureCallback != null)
  348. {
  349. loadSceneCallbacks.LoadSceneFailureCallback(sceneAssetName, resourceInfo != null && !resourceInfo.Ready ? LoadResourceStatus.NotReady : LoadResourceStatus.NotExist, errorMessage, userData);
  350. return;
  351. }
  352. throw new GameFrameworkException(errorMessage);
  353. }
  354. if (resourceInfo.IsLoadFromBinary)
  355. {
  356. string errorMessage = Utility.Text.Format("Can not load scene asset '{0}' which is a binary asset.", sceneAssetName);
  357. if (loadSceneCallbacks.LoadSceneFailureCallback != null)
  358. {
  359. loadSceneCallbacks.LoadSceneFailureCallback(sceneAssetName, LoadResourceStatus.TypeError, errorMessage, userData);
  360. return;
  361. }
  362. throw new GameFrameworkException(errorMessage);
  363. }
  364. LoadSceneTask mainTask = LoadSceneTask.Create(sceneAssetName, priority, resourceInfo, dependencyAssetNames, loadSceneCallbacks, userData);
  365. foreach (string dependencyAssetName in dependencyAssetNames)
  366. {
  367. if (!LoadDependencyAsset(dependencyAssetName, priority, mainTask, userData))
  368. {
  369. string errorMessage = Utility.Text.Format("Can not load dependency asset '{0}' when load scene '{1}'.", dependencyAssetName, sceneAssetName);
  370. if (loadSceneCallbacks.LoadSceneFailureCallback != null)
  371. {
  372. loadSceneCallbacks.LoadSceneFailureCallback(sceneAssetName, LoadResourceStatus.DependencyError, errorMessage, userData);
  373. return;
  374. }
  375. throw new GameFrameworkException(errorMessage);
  376. }
  377. }
  378. m_TaskPool.AddTask(mainTask);
  379. if (!resourceInfo.Ready)
  380. {
  381. m_ResourceManager.UpdateResource(resourceInfo.ResourceName);
  382. }
  383. }
  384. /// <summary>
  385. /// 异步卸载场景。
  386. /// </summary>
  387. /// <param name="sceneAssetName">要卸载场景资源的名称。</param>
  388. /// <param name="unloadSceneCallbacks">卸载场景回调函数集。</param>
  389. /// <param name="userData">用户自定义数据。</param>
  390. public void UnloadScene(string sceneAssetName, UnloadSceneCallbacks unloadSceneCallbacks, object userData)
  391. {
  392. if (m_ResourceManager.m_ResourceHelper == null)
  393. {
  394. throw new GameFrameworkException("You must set resource helper first.");
  395. }
  396. object asset = null;
  397. if (m_SceneToAssetMap.TryGetValue(sceneAssetName, out asset))
  398. {
  399. m_SceneToAssetMap.Remove(sceneAssetName);
  400. m_AssetPool.Unspawn(asset);
  401. m_AssetPool.ReleaseObject(asset);
  402. }
  403. else
  404. {
  405. throw new GameFrameworkException(Utility.Text.Format("Can not find asset of scene '{0}'.", sceneAssetName));
  406. }
  407. m_ResourceManager.m_ResourceHelper.UnloadScene(sceneAssetName, unloadSceneCallbacks, userData);
  408. }
  409. /// <summary>
  410. /// 获取二进制资源的实际路径。
  411. /// </summary>
  412. /// <param name="binaryAssetName">要获取实际路径的二进制资源的名称。</param>
  413. /// <returns>二进制资源的实际路径。</returns>
  414. /// <remarks>此方法仅适用于二进制资源存储在磁盘(而非文件系统)中的情况。若二进制资源存储在文件系统中时,返回值将始终为空。</remarks>
  415. public string GetBinaryPath(string binaryAssetName)
  416. {
  417. ResourceInfo resourceInfo = GetResourceInfo(binaryAssetName);
  418. if (resourceInfo == null)
  419. {
  420. return null;
  421. }
  422. if (!resourceInfo.Ready)
  423. {
  424. return null;
  425. }
  426. if (!resourceInfo.IsLoadFromBinary)
  427. {
  428. return null;
  429. }
  430. if (resourceInfo.UseFileSystem)
  431. {
  432. return null;
  433. }
  434. return Utility.Path.GetRegularPath(Path.Combine(resourceInfo.StorageInReadOnly ? m_ResourceManager.m_ReadOnlyPath : m_ResourceManager.m_ReadWritePath, resourceInfo.ResourceName.FullName));
  435. }
  436. /// <summary>
  437. /// 获取二进制资源的实际路径。
  438. /// </summary>
  439. /// <param name="binaryAssetName">要获取实际路径的二进制资源的名称。</param>
  440. /// <param name="storageInReadOnly">二进制资源是否存储在只读区中。</param>
  441. /// <param name="storageInFileSystem">二进制资源是否存储在文件系统中。</param>
  442. /// <param name="relativePath">二进制资源或存储二进制资源的文件系统,相对于只读区或者读写区的相对路径。</param>
  443. /// <param name="fileName">若二进制资源存储在文件系统中,则指示二进制资源在文件系统中的名称,否则此参数返回空。</param>
  444. /// <returns>是否获取二进制资源的实际路径成功。</returns>
  445. public bool GetBinaryPath(string binaryAssetName, out bool storageInReadOnly, out bool storageInFileSystem, out string relativePath, out string fileName)
  446. {
  447. storageInReadOnly = false;
  448. storageInFileSystem = false;
  449. relativePath = null;
  450. fileName = null;
  451. ResourceInfo resourceInfo = GetResourceInfo(binaryAssetName);
  452. if (resourceInfo == null)
  453. {
  454. return false;
  455. }
  456. if (!resourceInfo.Ready)
  457. {
  458. return false;
  459. }
  460. if (!resourceInfo.IsLoadFromBinary)
  461. {
  462. return false;
  463. }
  464. storageInReadOnly = resourceInfo.StorageInReadOnly;
  465. if (resourceInfo.UseFileSystem)
  466. {
  467. storageInFileSystem = true;
  468. relativePath = Utility.Text.Format("{0}.{1}", resourceInfo.FileSystemName, DefaultExtension);
  469. fileName = resourceInfo.ResourceName.FullName;
  470. }
  471. else
  472. {
  473. relativePath = resourceInfo.ResourceName.FullName;
  474. }
  475. return true;
  476. }
  477. /// <summary>
  478. /// 获取二进制资源的长度。
  479. /// </summary>
  480. /// <param name="binaryAssetName">要获取长度的二进制资源的名称。</param>
  481. /// <returns>二进制资源的长度。</returns>
  482. public int GetBinaryLength(string binaryAssetName)
  483. {
  484. ResourceInfo resourceInfo = GetResourceInfo(binaryAssetName);
  485. if (resourceInfo == null)
  486. {
  487. return -1;
  488. }
  489. if (!resourceInfo.Ready)
  490. {
  491. return -1;
  492. }
  493. if (!resourceInfo.IsLoadFromBinary)
  494. {
  495. return -1;
  496. }
  497. return resourceInfo.Length;
  498. }
  499. /// <summary>
  500. /// 异步加载二进制资源。
  501. /// </summary>
  502. /// <param name="binaryAssetName">要加载二进制资源的名称。</param>
  503. /// <param name="loadBinaryCallbacks">加载二进制资源回调函数集。</param>
  504. /// <param name="userData">用户自定义数据。</param>
  505. public void LoadBinary(string binaryAssetName, LoadBinaryCallbacks loadBinaryCallbacks, object userData)
  506. {
  507. ResourceInfo resourceInfo = GetResourceInfo(binaryAssetName);
  508. if (resourceInfo == null)
  509. {
  510. string errorMessage = Utility.Text.Format("Can not load binary '{0}' which is not exist.", binaryAssetName);
  511. if (loadBinaryCallbacks.LoadBinaryFailureCallback != null)
  512. {
  513. loadBinaryCallbacks.LoadBinaryFailureCallback(binaryAssetName, LoadResourceStatus.NotExist, errorMessage, userData);
  514. return;
  515. }
  516. throw new GameFrameworkException(errorMessage);
  517. }
  518. if (!resourceInfo.Ready)
  519. {
  520. string errorMessage = Utility.Text.Format("Can not load binary '{0}' which is not ready.", binaryAssetName);
  521. if (loadBinaryCallbacks.LoadBinaryFailureCallback != null)
  522. {
  523. loadBinaryCallbacks.LoadBinaryFailureCallback(binaryAssetName, LoadResourceStatus.NotReady, errorMessage, userData);
  524. return;
  525. }
  526. throw new GameFrameworkException(errorMessage);
  527. }
  528. if (!resourceInfo.IsLoadFromBinary)
  529. {
  530. string errorMessage = Utility.Text.Format("Can not load binary '{0}' which is not a binary asset.", binaryAssetName);
  531. if (loadBinaryCallbacks.LoadBinaryFailureCallback != null)
  532. {
  533. loadBinaryCallbacks.LoadBinaryFailureCallback(binaryAssetName, LoadResourceStatus.TypeError, errorMessage, userData);
  534. return;
  535. }
  536. throw new GameFrameworkException(errorMessage);
  537. }
  538. if (resourceInfo.UseFileSystem)
  539. {
  540. loadBinaryCallbacks.LoadBinarySuccessCallback(binaryAssetName, LoadBinaryFromFileSystem(binaryAssetName), 0f, userData);
  541. }
  542. else
  543. {
  544. string path = Utility.Path.GetRemotePath(Path.Combine(resourceInfo.StorageInReadOnly ? m_ResourceManager.m_ReadOnlyPath : m_ResourceManager.m_ReadWritePath, resourceInfo.ResourceName.FullName));
  545. m_ResourceManager.m_ResourceHelper.LoadBytes(path, m_LoadBytesCallbacks, LoadBinaryInfo.Create(binaryAssetName, resourceInfo, loadBinaryCallbacks, userData));
  546. }
  547. }
  548. /// <summary>
  549. /// 从文件系统中加载二进制资源。
  550. /// </summary>
  551. /// <param name="binaryAssetName">要加载二进制资源的名称。</param>
  552. /// <returns>存储加载二进制资源的二进制流。</returns>
  553. public byte[] LoadBinaryFromFileSystem(string binaryAssetName)
  554. {
  555. ResourceInfo resourceInfo = GetResourceInfo(binaryAssetName);
  556. if (resourceInfo == null)
  557. {
  558. throw new GameFrameworkException(Utility.Text.Format("Can not load binary '{0}' from file system which is not exist.", binaryAssetName));
  559. }
  560. if (!resourceInfo.Ready)
  561. {
  562. throw new GameFrameworkException(Utility.Text.Format("Can not load binary '{0}' from file system which is not ready.", binaryAssetName));
  563. }
  564. if (!resourceInfo.IsLoadFromBinary)
  565. {
  566. throw new GameFrameworkException(Utility.Text.Format("Can not load binary '{0}' from file system which is not a binary asset.", binaryAssetName));
  567. }
  568. if (!resourceInfo.UseFileSystem)
  569. {
  570. throw new GameFrameworkException(Utility.Text.Format("Can not load binary '{0}' from file system which is not use file system.", binaryAssetName));
  571. }
  572. IFileSystem fileSystem = m_ResourceManager.GetFileSystem(resourceInfo.FileSystemName, resourceInfo.StorageInReadOnly);
  573. byte[] bytes = fileSystem.ReadFile(resourceInfo.ResourceName.FullName);
  574. if (bytes == null)
  575. {
  576. return null;
  577. }
  578. if (resourceInfo.LoadType == LoadType.LoadFromBinaryAndQuickDecrypt || resourceInfo.LoadType == LoadType.LoadFromBinaryAndDecrypt)
  579. {
  580. DecryptResourceCallback decryptResourceCallback = m_ResourceManager.m_DecryptResourceCallback ?? DefaultDecryptResourceCallback;
  581. decryptResourceCallback(bytes, 0, bytes.Length, resourceInfo.ResourceName.Name, resourceInfo.ResourceName.Variant, resourceInfo.ResourceName.Extension, resourceInfo.StorageInReadOnly, resourceInfo.FileSystemName, (byte)resourceInfo.LoadType, resourceInfo.Length, resourceInfo.HashCode);
  582. }
  583. return bytes;
  584. }
  585. /// <summary>
  586. /// 从文件系统中加载二进制资源。
  587. /// </summary>
  588. /// <param name="binaryAssetName">要加载二进制资源的名称。</param>
  589. /// <param name="buffer">存储加载二进制资源的二进制流。</param>
  590. /// <param name="startIndex">存储加载二进制资源的二进制流的起始位置。</param>
  591. /// <param name="length">存储加载二进制资源的二进制流的长度。</param>
  592. /// <returns>实际加载了多少字节。</returns>
  593. public int LoadBinaryFromFileSystem(string binaryAssetName, byte[] buffer, int startIndex, int length)
  594. {
  595. ResourceInfo resourceInfo = GetResourceInfo(binaryAssetName);
  596. if (resourceInfo == null)
  597. {
  598. throw new GameFrameworkException(Utility.Text.Format("Can not load binary '{0}' from file system which is not exist.", binaryAssetName));
  599. }
  600. if (!resourceInfo.Ready)
  601. {
  602. throw new GameFrameworkException(Utility.Text.Format("Can not load binary '{0}' from file system which is not ready.", binaryAssetName));
  603. }
  604. if (!resourceInfo.IsLoadFromBinary)
  605. {
  606. throw new GameFrameworkException(Utility.Text.Format("Can not load binary '{0}' from file system which is not a binary asset.", binaryAssetName));
  607. }
  608. if (!resourceInfo.UseFileSystem)
  609. {
  610. throw new GameFrameworkException(Utility.Text.Format("Can not load binary '{0}' from file system which is not use file system.", binaryAssetName));
  611. }
  612. IFileSystem fileSystem = m_ResourceManager.GetFileSystem(resourceInfo.FileSystemName, resourceInfo.StorageInReadOnly);
  613. int bytesRead = fileSystem.ReadFile(resourceInfo.ResourceName.FullName, buffer, startIndex, length);
  614. if (resourceInfo.LoadType == LoadType.LoadFromBinaryAndQuickDecrypt || resourceInfo.LoadType == LoadType.LoadFromBinaryAndDecrypt)
  615. {
  616. DecryptResourceCallback decryptResourceCallback = m_ResourceManager.m_DecryptResourceCallback ?? DefaultDecryptResourceCallback;
  617. decryptResourceCallback(buffer, startIndex, bytesRead, resourceInfo.ResourceName.Name, resourceInfo.ResourceName.Variant, resourceInfo.ResourceName.Extension, resourceInfo.StorageInReadOnly, resourceInfo.FileSystemName, (byte)resourceInfo.LoadType, resourceInfo.Length, resourceInfo.HashCode);
  618. }
  619. return bytesRead;
  620. }
  621. /// <summary>
  622. /// 从文件系统中加载二进制资源的片段。
  623. /// </summary>
  624. /// <param name="binaryAssetName">要加载片段的二进制资源的名称。</param>
  625. /// <param name="offset">要加载片段的偏移。</param>
  626. /// <param name="length">要加载片段的长度。</param>
  627. /// <returns>存储加载二进制资源片段内容的二进制流。</returns>
  628. public byte[] LoadBinarySegmentFromFileSystem(string binaryAssetName, int offset, int length)
  629. {
  630. ResourceInfo resourceInfo = GetResourceInfo(binaryAssetName);
  631. if (resourceInfo == null)
  632. {
  633. throw new GameFrameworkException(Utility.Text.Format("Can not load binary '{0}' from file system which is not exist.", binaryAssetName));
  634. }
  635. if (!resourceInfo.Ready)
  636. {
  637. throw new GameFrameworkException(Utility.Text.Format("Can not load binary '{0}' from file system which is not ready.", binaryAssetName));
  638. }
  639. if (!resourceInfo.IsLoadFromBinary)
  640. {
  641. throw new GameFrameworkException(Utility.Text.Format("Can not load binary '{0}' from file system which is not a binary asset.", binaryAssetName));
  642. }
  643. if (!resourceInfo.UseFileSystem)
  644. {
  645. throw new GameFrameworkException(Utility.Text.Format("Can not load binary '{0}' from file system which is not use file system.", binaryAssetName));
  646. }
  647. IFileSystem fileSystem = m_ResourceManager.GetFileSystem(resourceInfo.FileSystemName, resourceInfo.StorageInReadOnly);
  648. byte[] bytes = fileSystem.ReadFileSegment(resourceInfo.ResourceName.FullName, offset, length);
  649. if (bytes == null)
  650. {
  651. return null;
  652. }
  653. if (resourceInfo.LoadType == LoadType.LoadFromBinaryAndQuickDecrypt || resourceInfo.LoadType == LoadType.LoadFromBinaryAndDecrypt)
  654. {
  655. DecryptResourceCallback decryptResourceCallback = m_ResourceManager.m_DecryptResourceCallback ?? DefaultDecryptResourceCallback;
  656. decryptResourceCallback(bytes, 0, bytes.Length, resourceInfo.ResourceName.Name, resourceInfo.ResourceName.Variant, resourceInfo.ResourceName.Extension, resourceInfo.StorageInReadOnly, resourceInfo.FileSystemName, (byte)resourceInfo.LoadType, resourceInfo.Length, resourceInfo.HashCode);
  657. }
  658. return bytes;
  659. }
  660. /// <summary>
  661. /// 从文件系统中加载二进制资源的片段。
  662. /// </summary>
  663. /// <param name="binaryAssetName">要加载片段的二进制资源的名称。</param>
  664. /// <param name="offset">要加载片段的偏移。</param>
  665. /// <param name="buffer">存储加载二进制资源片段内容的二进制流。</param>
  666. /// <param name="startIndex">存储加载二进制资源片段内容的二进制流的起始位置。</param>
  667. /// <param name="length">要加载片段的长度。</param>
  668. /// <returns>实际加载了多少字节。</returns>
  669. public int LoadBinarySegmentFromFileSystem(string binaryAssetName, int offset, byte[] buffer, int startIndex, int length)
  670. {
  671. ResourceInfo resourceInfo = GetResourceInfo(binaryAssetName);
  672. if (resourceInfo == null)
  673. {
  674. throw new GameFrameworkException(Utility.Text.Format("Can not load binary '{0}' from file system which is not exist.", binaryAssetName));
  675. }
  676. if (!resourceInfo.Ready)
  677. {
  678. throw new GameFrameworkException(Utility.Text.Format("Can not load binary '{0}' from file system which is not ready.", binaryAssetName));
  679. }
  680. if (!resourceInfo.IsLoadFromBinary)
  681. {
  682. throw new GameFrameworkException(Utility.Text.Format("Can not load binary '{0}' from file system which is not a binary asset.", binaryAssetName));
  683. }
  684. if (!resourceInfo.UseFileSystem)
  685. {
  686. throw new GameFrameworkException(Utility.Text.Format("Can not load binary '{0}' from file system which is not use file system.", binaryAssetName));
  687. }
  688. IFileSystem fileSystem = m_ResourceManager.GetFileSystem(resourceInfo.FileSystemName, resourceInfo.StorageInReadOnly);
  689. int bytesRead = fileSystem.ReadFileSegment(resourceInfo.ResourceName.FullName, offset, buffer, startIndex, length);
  690. if (resourceInfo.LoadType == LoadType.LoadFromBinaryAndQuickDecrypt || resourceInfo.LoadType == LoadType.LoadFromBinaryAndDecrypt)
  691. {
  692. DecryptResourceCallback decryptResourceCallback = m_ResourceManager.m_DecryptResourceCallback ?? DefaultDecryptResourceCallback;
  693. decryptResourceCallback(buffer, startIndex, bytesRead, resourceInfo.ResourceName.Name, resourceInfo.ResourceName.Variant, resourceInfo.ResourceName.Extension, resourceInfo.StorageInReadOnly, resourceInfo.FileSystemName, (byte)resourceInfo.LoadType, resourceInfo.Length, resourceInfo.HashCode);
  694. }
  695. return bytesRead;
  696. }
  697. /// <summary>
  698. /// 获取所有加载资源任务的信息。
  699. /// </summary>
  700. /// <returns>所有加载资源任务的信息。</returns>
  701. public TaskInfo[] GetAllLoadAssetInfos()
  702. {
  703. return m_TaskPool.GetAllTaskInfos();
  704. }
  705. /// <summary>
  706. /// 获取所有加载资源任务的信息。
  707. /// </summary>
  708. /// <param name="results">所有加载资源任务的信息。</param>
  709. public void GetAllLoadAssetInfos(List<TaskInfo> results)
  710. {
  711. m_TaskPool.GetAllTaskInfos(results);
  712. }
  713. private bool LoadDependencyAsset(string assetName, int priority, LoadResourceTaskBase mainTask, object userData)
  714. {
  715. if (mainTask == null)
  716. {
  717. throw new GameFrameworkException("Main task is invalid.");
  718. }
  719. ResourceInfo resourceInfo = null;
  720. string[] dependencyAssetNames = null;
  721. if (!CheckAsset(assetName, out resourceInfo, out dependencyAssetNames))
  722. {
  723. return false;
  724. }
  725. if (resourceInfo.IsLoadFromBinary)
  726. {
  727. return false;
  728. }
  729. LoadDependencyAssetTask dependencyTask = LoadDependencyAssetTask.Create(assetName, priority, resourceInfo, dependencyAssetNames, mainTask, userData);
  730. foreach (string dependencyAssetName in dependencyAssetNames)
  731. {
  732. if (!LoadDependencyAsset(dependencyAssetName, priority, dependencyTask, userData))
  733. {
  734. return false;
  735. }
  736. }
  737. m_TaskPool.AddTask(dependencyTask);
  738. if (!resourceInfo.Ready)
  739. {
  740. m_ResourceManager.UpdateResource(resourceInfo.ResourceName);
  741. }
  742. return true;
  743. }
  744. private ResourceInfo GetResourceInfo(string assetName)
  745. {
  746. if (string.IsNullOrEmpty(assetName))
  747. {
  748. return null;
  749. }
  750. AssetInfo assetInfo = m_ResourceManager.GetAssetInfo(assetName);
  751. if (assetInfo == null)
  752. {
  753. return null;
  754. }
  755. return m_ResourceManager.GetResourceInfo(assetInfo.ResourceName);
  756. }
  757. private bool CheckAsset(string assetName, out ResourceInfo resourceInfo, out string[] dependencyAssetNames)
  758. {
  759. resourceInfo = null;
  760. dependencyAssetNames = null;
  761. if (string.IsNullOrEmpty(assetName))
  762. {
  763. return false;
  764. }
  765. AssetInfo assetInfo = m_ResourceManager.GetAssetInfo(assetName);
  766. if (assetInfo == null)
  767. {
  768. return false;
  769. }
  770. resourceInfo = m_ResourceManager.GetResourceInfo(assetInfo.ResourceName);
  771. if (resourceInfo == null)
  772. {
  773. return false;
  774. }
  775. dependencyAssetNames = assetInfo.GetDependencyAssetNames();
  776. return m_ResourceManager.m_ResourceMode == ResourceMode.UpdatableWhilePlaying ? true : resourceInfo.Ready;
  777. }
  778. private void DefaultDecryptResourceCallback(byte[] bytes, int startIndex, int count, string name, string variant, string extension, bool storageInReadOnly, string fileSystem, byte loadType, int length, int hashCode)
  779. {
  780. Utility.Converter.GetBytes(hashCode, m_CachedHashBytes);
  781. switch ((LoadType)loadType)
  782. {
  783. case LoadType.LoadFromMemoryAndQuickDecrypt:
  784. case LoadType.LoadFromBinaryAndQuickDecrypt:
  785. Utility.Encryption.GetQuickSelfXorBytes(bytes, m_CachedHashBytes);
  786. break;
  787. case LoadType.LoadFromMemoryAndDecrypt:
  788. case LoadType.LoadFromBinaryAndDecrypt:
  789. Utility.Encryption.GetSelfXorBytes(bytes, m_CachedHashBytes);
  790. break;
  791. default:
  792. throw new GameFrameworkException("Not supported load type when decrypt resource.");
  793. }
  794. Array.Clear(m_CachedHashBytes, 0, CachedHashBytesLength);
  795. }
  796. private void OnLoadBinarySuccess(string fileUri, byte[] bytes, float duration, object userData)
  797. {
  798. LoadBinaryInfo loadBinaryInfo = (LoadBinaryInfo)userData;
  799. if (loadBinaryInfo == null)
  800. {
  801. throw new GameFrameworkException("Load binary info is invalid.");
  802. }
  803. ResourceInfo resourceInfo = loadBinaryInfo.ResourceInfo;
  804. if (resourceInfo.LoadType == LoadType.LoadFromBinaryAndQuickDecrypt || resourceInfo.LoadType == LoadType.LoadFromBinaryAndDecrypt)
  805. {
  806. DecryptResourceCallback decryptResourceCallback = m_ResourceManager.m_DecryptResourceCallback ?? DefaultDecryptResourceCallback;
  807. decryptResourceCallback(bytes, 0, bytes.Length, resourceInfo.ResourceName.Name, resourceInfo.ResourceName.Variant, resourceInfo.ResourceName.Extension, resourceInfo.StorageInReadOnly, resourceInfo.FileSystemName, (byte)resourceInfo.LoadType, resourceInfo.Length, resourceInfo.HashCode);
  808. }
  809. loadBinaryInfo.LoadBinaryCallbacks.LoadBinarySuccessCallback(loadBinaryInfo.BinaryAssetName, bytes, duration, loadBinaryInfo.UserData);
  810. ReferencePool.Release(loadBinaryInfo);
  811. }
  812. private void OnLoadBinaryFailure(string fileUri, string errorMessage, object userData)
  813. {
  814. LoadBinaryInfo loadBinaryInfo = (LoadBinaryInfo)userData;
  815. if (loadBinaryInfo == null)
  816. {
  817. throw new GameFrameworkException("Load binary info is invalid.");
  818. }
  819. if (loadBinaryInfo.LoadBinaryCallbacks.LoadBinaryFailureCallback != null)
  820. {
  821. loadBinaryInfo.LoadBinaryCallbacks.LoadBinaryFailureCallback(loadBinaryInfo.BinaryAssetName, LoadResourceStatus.AssetError, errorMessage, loadBinaryInfo.UserData);
  822. }
  823. ReferencePool.Release(loadBinaryInfo);
  824. }
  825. }
  826. }
  827. }