public AssetModel get_assets(AssetRequest request)
{
return new AssetModel()
{
};
}
protected override AssetBase GetAsset(AssetRequest req)
{
#if DEBUG
//m_log.DebugFormat("[GRID ASSET CLIENT]: Querying for {0}", req.AssetID.ToString());
#endif
RestClient rc = new RestClient(_assetServerUrl);
rc.AddResourcePath("assets");
rc.AddResourcePath(req.AssetID.ToString());
rc.RequestMethod = "GET";
Stream s = rc.Request();
if (s == null)
return null;
if (s.Length > 0)
{
XmlSerializer xs = new XmlSerializer(typeof (AssetBase));
return (AssetBase) xs.Deserialize(s);
}
return null;
}
private IEnumerator loadPlayerHeldExperience(PlayerHeldItem playerHeldItem)
{
AssetRequest <GameObject> assetRequest = Content.LoadAsync(getPropExperiencePathFromPropId(playerHeldItem.Type));
yield return(assetRequest);
GameObject experience = UnityEngine.Object.Instantiate(assetRequest.Asset);
PropExperience spawnedExperience = experience.GetComponent <PropExperience>();
if (spawnedExperience != null)
{
spawnedExperience.InstanceId = playerHeldItem.CreatorId.ToString();
spawnedExperience.OwnerId = playerHeldItem.CreatorId;
spawnedExperience.IsOwnerLocalPlayer = dataEntityCollection.LocalPlayerSessionId == playerHeldItem.CreatorId;
spawnedExperience.PropDef = Props[playerHeldItem.Type];
GameObject playerObject = getPlayerObject(playerHeldItem.CreatorId);
if (!(playerObject == null))
{
spawnedExperience.transform.SetParent(playerObject.transform, worldPositionStays: false);
spawnedExperience.StartExperience();
}
}
}
// post: Materialize
public IHttpActionResult PostMaterializePo(int AssetRequestId)
{
string AssetStatus = "Materialized";
var dbAssetStatusId = db.AssetStatus.Where(c => c.Name.ToUpper() == AssetStatus.ToUpper()).Select(x => x.Id).FirstOrDefault();
AssetRequest assetRequest = (from x in db.AssetRequests
where x.Id == AssetRequestId
select x).Single();
if (assetRequest != null)
{
assetRequest.AssetStatusId = dbAssetStatusId;
assetRequest.LastModifiedOn = System.DateTime.Now;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
}
return(Ok());
}
public static AssetRequestUnit FindEquivelent(AssetRequest targetRq, AssetRequestUnit refReq)
{
var result = targetRq.units.Find((request) => {
foreach (var newAttribute in refReq.attributes)
{
if (!request.attributes.Contains(newAttribute))
{
return(false);
}
}
if (!AGDev.StdUtil.Utilities.CompareNullableString(refReq.assettype, request.assettype))
{
return(false);
}
if (!AGDev.StdUtil.Utilities.CompareNullableString(refReq.sname, request.sname))
{
return(false);
}
return(true);
});
return(result);
}
public override IEnumerator PerformFirstPass()
{
string dailyChallengesScheduleManifestPath = DailyChallengeService.GetDateManifestMapPath();
AssetRequest <DatedManifestMap> scheduleAssetRequest = Content.LoadAsync <DatedManifestMap>(dailyChallengesScheduleManifestPath);
yield return(scheduleAssetRequest);
Dictionary <int, ScheduledEventDateDefinition> events = Service.Get <IGameData>().Get <Dictionary <int, ScheduledEventDateDefinition> >();
ScheduledEventDateDefinition def = null;
events.TryGetValue(SupportWindow.Id, out def);
ContentSchedulerService service = new ContentSchedulerService(scheduleAssetRequest.Asset.Map.Keys, PenguinStandardTimeOffsetHours, def);
Service.Set(service);
bool offlineMode = service.HasSupportEndded();
string offline_mode = CommandLineArgs.GetValueForKey("offline_mode");
if (!string.IsNullOrEmpty(offline_mode))
{
offlineMode = offline_mode.ToLower().Trim() == "true";
}
Service.Get <GameSettings>().SetOfflineMode(offlineMode);
}
private IEnumerator loadChestPrefab()
{
PrefabContentKey chestContentKey = (!string.IsNullOrEmpty(popupData.MascotName) && popupData.PopupType != DRewardPopup.RewardPopupType.levelUp) ? Service.Get <MascotService>().GetMascot(popupData.MascotName).Definition.RewardPopupChestContentKey : defaultChestKey;
AssetRequest <GameObject> assetRequest = Content.LoadAsync(chestContentKey);
yield return(assetRequest);
GameObject chestGO = UnityEngine.Object.Instantiate(assetRequest.Asset);
chestGO.transform.SetParent(ChestParent, worldPositionStays: false);
RewardChest = chestGO.GetComponent <RewardPopupChest>();
RewardPopupChest rewardChest = RewardChest;
rewardChest.ChestLandAction = (System.Action)Delegate.Combine(rewardChest.ChestLandAction, new System.Action(onChestLand));
string animationTrigger = "LevelUp";
if (popupData.PopupType == DRewardPopup.RewardPopupType.questComplete || popupData.PopupType == DRewardPopup.RewardPopupType.generic)
{
animationTrigger = "Quest";
}
ParachuteAnimator.SetTrigger(animationTrigger);
RewardChest.ChestAnimator.SetTrigger(animationTrigger);
}
private IEnumerator loadQuestMascotItem(Mascot mascot)
{
PrefabContentKey mascotItemContentKey = new PrefabContentKey(questLogMascotItemContentKey, mascot.Name);
AssetRequest <GameObject> assetRequest = Content.LoadAsync(mascotItemContentKey);
yield return(assetRequest);
mascotKeys.Add(mascotItemContentKey.Key);
GameObject mascotItemGameObject = Object.Instantiate(assetRequest.Asset);
Button button = mascotItemGameObject.GetComponentInChildren <Button>();
if (button != null)
{
button.onClick.AddListener(delegate
{
onMascotButtonPressed(mascot.Name);
});
}
QuestLogMascotItem mascotItem = mascotItemGameObject.GetComponent <QuestLogMascotItem>();
mascotItem.LoadMascotData(mascot);
mascotItemGameObject.transform.SetParent(ScrollContent, worldPositionStays: false);
}
public async Task <ActionResult <object> > Create(
[FromBody] AssetRequest request)
{
#region Create Asset Chain
var assetChainInitializerHandler = new AssetChainInitializerHandler();
var cashAssetHandler = new CashAssetHandler();
var bondAssetHandler = new BondAssetHandler();
var forexAssetHandler = new ForexAssetHandler();
var stockAssetHandler = new StockAssetHandler();
var commodityAssetHandler = new CommodityAssetHandler();
assetChainInitializerHandler
.SetNext(cashAssetHandler)
.SetNext(bondAssetHandler)
.SetNext(forexAssetHandler)
.SetNext(stockAssetHandler)
.SetNext(commodityAssetHandler);
#endregion
assetChainInitializerHandler.Handle(request);
return(Ok());
}
public static async ETVoid CreateJoystickUI(ETTaskCompletionSource <UI> tcs)
{
try
{
AssetRequest assetRequest = Assets.LoadAssetAsync("Assets/Bundles/UI/" + UIType.UIJoystick + ".prefab", typeof(GameObject));
//创建一个角色的3D物体
GameObject bundleGameObject = await ETModel.Game.Scene.GetComponent <ResourcesAsyncComponent>().LoadAssetAsync <GameObject>(assetRequest);
GameObject gameObject = UnityEngine.Object.Instantiate(bundleGameObject);
UI ui = ComponentFactory.Create <UI, string, GameObject, AssetRequest>(UIType.UIJoystick, gameObject, assetRequest, false);
VariableJoystickComponent variableJoystick = ui.AddComponent <VariableJoystickComponent>();
variableJoystick.joystickType = JoystickType.Floating;
tcs.SetResult(ui);
}
catch (Exception e)
{
Log.Error(e);
tcs.SetResult(null);
}
}
private IEnumerator showPhone(bool playTransitionAnimation)
{
eventChannel.AddListener <CellPhoneEvents.HideLoadingScreen>(onHideLoadingScreen);
AssetRequest <GameObject> cellPhoneRequest = null;
if (cellPhonePrefab == null)
{
cellPhoneRequest = Content.LoadAsync(prefabContentKey);
}
AssetRequest <GameObject> animRequest = null;
if (cellPhoneAnimPrefab == null)
{
animRequest = Content.LoadAsync(animPrefabConentKey);
}
if (cellPhoneRequest != null)
{
yield return(cellPhoneRequest);
cellPhonePrefab = cellPhoneRequest.Asset;
}
if (animRequest != null)
{
yield return(animRequest);
cellPhoneAnimPrefab = animRequest.Asset;
}
if (playTransitionAnimation)
{
setupAnimPrefab();
}
else
{
setupCellPhonePrefab();
}
logOpenPhoneBi();
}
/// <summary>
/// Process an asset request. This method will call GetAsset(AssetRequest req)
/// on the subclass.
/// </summary>
public virtual void ProcessNextRequest()
{
AssetRequest req = m_assetRequests.Dequeue();
AssetBase asset;
try
{
asset = GetAsset(req);
}
catch (Exception e)
{
m_log.ErrorFormat("[ASSET]: Asset request for {0} threw exception {1} - Stack Trace: {2}", req.AssetID, e, e.StackTrace);
if (StatsManager.SimExtraStats != null)
{
StatsManager.SimExtraStats.AddAssetServiceRequestFailure();
}
m_receiver.AssetNotFound(req.AssetID, req.IsTexture);
return;
}
if (asset != null)
{
//m_log.DebugFormat("[ASSET]: Asset {0} received from asset server", req.AssetID);
m_receiver.AssetReceived(asset, req.IsTexture);
}
else
{
//m_log.WarnFormat("[ASSET]: Asset {0} not found by asset server", req.AssetID);
m_receiver.AssetNotFound(req.AssetID, req.IsTexture);
}
}
protected override IEnumerator runTest()
{
string payload = "small_text?dl=res&x=txt";
ContentManifest.AssetEntry entry = ContentManifest.AssetEntry.Parse(payload);
DeviceManager manager = new DeviceManager();
ResourceDevice device = new ResourceDevice(manager);
manager.Mount(device);
AssetRequest <TextAsset> request = manager.LoadAsync <TextAsset>(entry.DeviceList, ref entry);
if (request == null)
{
IntegrationTest.Fail("request == null");
yield break;
}
if (request.Finished)
{
IntegrationTest.Fail("Asset did not load async");
}
else if (request.Cancelled)
{
IntegrationTest.Fail("request should not be cancelled");
}
yield return(request);
IntegrationTestEx.FailIf(!request.Finished);
IntegrationTestEx.FailIf(request.Cancelled);
IntegrationTestEx.FailIf(request.Asset == null);
IntegrationTestEx.FailIf(request.Asset.GetType() != typeof(TextAsset));
if (request.Asset != null)
{
IntegrationTestEx.FailIf(!request.Asset.text.StartsWith("hello world"));
}
IntegrationTest.Pass();
}
private void OnAssetRequested(AssetRequest p_args)
{
GameObject gameObject = (GameObject)p_args.Asset;
if (p_args.Status != ERequestStatus.Done)
{
Debug.LogError(String.Concat(new Object[]
{
"Error load asset. ",
p_args.Status,
"\nAssetName: ",
p_args.AssetName
}));
return;
}
if (gameObject == null)
{
Debug.LogError("Error load asset.");
return;
}
if (this == null)
{
if (p_args.AssetBundleName != String.Empty)
{
AssetBundleManagers.Instance.Main.UnloadAssetBundle(p_args.AssetBundleName, true, true, false);
Resources.UnloadUnusedAssets();
}
return;
}
mInstantiatedAsset = (GameObject)Instantiate(gameObject);
mInstantiatedAsset.transform.parent = transform;
mInstantiatedAsset.transform.localPosition = Vector3.zero;
mInstantiatedAsset.transform.localEulerAngles = Vector3.zero;
mInstantiatedAsset.transform.localScale = Vector3.one;
mInstantiatedAsset.SetActive(false);
}
private IEnumerator renderMusicTracks()
{
AssetRequest <GameObject> prefabRequest = Content.LoadAsync(prefabContentKey);
yield return(prefabRequest);
AssetRequest <Texture2D> iconRequest = null;
if (musicTrackDefinition.Icon != null && !string.IsNullOrEmpty(musicTrackDefinition.Icon.Key))
{
iconRequest = Content.LoadAsync(musicTrackDefinition.Icon);
yield return(iconRequest);
}
GameObject prefab = prefabRequest.Asset;
GameObject itemPrefab = Object.Instantiate(prefab);
Sprite sprite = null;
if (iconRequest != null && iconRequest.Asset != null)
{
sprite = Sprite.Create(iconRequest.Asset, new Rect(0f, 0f, iconRequest.Asset.width, iconRequest.Asset.height), Vector2.zero);
}
itemPrefab.GetComponent <RewardPopupLabelComponent>().Init(sprite, Service.Get <Localizer>().GetTokenTranslation(musicTrackDefinition.Name));
callback(null, itemPrefab.GetComponent <RectTransform>());
}
private IEnumerator loadQuestLogAdventureItem(QuestDefinition questDefinition)
{
Mascot mascot = Service.Get <MascotService>().GetMascot(questDefinition.Mascot.name);
AssetRequest <GameObject> assetRequest = Content.LoadAsync(questItemContentKey, mascot.AbbreviatedName);
yield return(assetRequest);
GameObject questLogItemGameObject = Object.Instantiate(assetRequest.Asset);
QuestLogAdventuresItem questLogItem = questLogItemGameObject.GetComponent <QuestLogAdventuresItem>();
questLogItem.LoadQuestData(questDefinition);
questLogItemGameObject.transform.SetParent(ScrollContent, worldPositionStays: false);
adventureItemsLoaded++;
if (adventureItemsLoaded == totalAdventuresItems)
{
CoroutineRunner.Start(scrollToAvailableQuest(), this, "");
if (mascot.Definition.ShowComingSoonInLog)
{
AssetRequest <GameObject> assetRequest2 = Content.LoadAsync(comingSoonContentKey, mascot.AbbreviatedName);
GameObject gameObject = Object.Instantiate(assetRequest2.Asset);
gameObject.transform.SetParent(ScrollContent, worldPositionStays: false);
}
}
}
internal void FireTransferRequestCompletedEvent(AssetRequest request)
{
if (TransferRequestCompletedEvent != null)
{
TransferRequestCompletedEvent(request);
}
}
public void Cache(string assetID, AssetBase asset)
{
if (asset != null)
{
UpdateMemoryCache(asset.IDString, asset);
string filename = GetFileName(asset.IDString);
try
{
// If the file is already cached just update access time
if (File.Exists(filename))
{
lock (m_CurrentlyWriting)
{
if (!m_CurrentlyWriting.Contains(filename))
{
File.SetLastAccessTime(filename, DateTime.Now);
}
}
}
else
{
// Once we start writing, make sure we flag that we're writing
// that object to the cache so that we don't try to write the
// same file multiple times.
lock (m_CurrentlyWriting)
{
#if WAIT_ON_INPROGRESS_REQUESTS
if (m_CurrentlyWriting.ContainsKey(filename))
{
return;
}
else
{
m_CurrentlyWriting.Add(filename, new ManualResetEvent(false));
}
#else
if (m_CurrentlyWriting.Contains(filename))
{
return;
}
else
{
m_CurrentlyWriting.Add(filename);
}
#endif
}
Util.FireAndForget(
delegate { WriteFileCache(filename, asset); });
}
}
catch (Exception e)
{
LogException(e);
}
}
else
{
if (m_assetRequests.ContainsKey(assetID))
{
m_assetRequests[assetID].SavedAmt++;
}
else
{
m_assetRequests[assetID] = new AssetRequest();
}
if (m_assetRequests[assetID].SavedAmt > _forceMemoryCacheAmount)
{
UpdateMemoryCache(assetID, asset, true);
}
}
}
public void RequestAsset(UUID assetID, bool isTexture)
{
AssetRequest req = new AssetRequest();
req.AssetID = assetID;
req.IsTexture = isTexture;
m_assetRequests.Enqueue(req);
//m_log.DebugFormat("[ASSET SERVER]: Added {0} to request queue", assetID);
}
/// <summary> /// This method must be implemented by a subclass to retrieve the asset named in the /// AssetRequest. If the asset is not found, null should be returned. /// </summary> /// <param name="req"></param> /// <returns></returns> /// <exception cref="System.Exception"> /// Thrown if the request failed for some other reason than that the /// asset cannot be found. /// </exception> protected abstract AssetBase GetAsset(AssetRequest req);
public IEnumerator Load(MonoBehaviour coroutineProvider)
{
// 如果asset没有在assetbundle里面，就直接加载
if (mainBundle == null)
{
using (WWW www = new WWW(AssetMgr.LOCAL_ASSET_URL + name))
{
yield return(www);
OnWWWLoaded(www);
}
yield break;
}
// 先加载依赖的所有assetbundles
if (depBundles != null)
{
foreach (Bundle dep in depBundles)
{
if (dep.IsLoaded)
{
continue;
}
yield return(coroutineProvider.StartCoroutine(dep.Load()));
}
}
// 协程加载assetbundle
if (!mainBundle.IsLoaded)
{
yield return(coroutineProvider.StartCoroutine(mainBundle.Load()));
}
// 如果有其它加载asset的方法，直接调用，没有的话就使用默认的asset request
AsyncRequest request;
if (LoadAssetAsync != null)
{
request = LoadAssetAsync(mainBundle);
}
else
{
request = new AssetRequest(mainBundle.LoadAssetAsync(name, typeof(Object)));
}
while (!request.isDone)
{
if (OnProgress != null)
{
OnProgress(request.progress);
}
yield return(0);
}
if (OnProgress != null)
{
OnProgress(1.0f);
}
if (OnAssetLoaded != null)
{
OnAssetLoaded(request.asset);
}
// 加载完成后减少assetbundle的引用，使其能够释放
mainBundle.decRef();
if (depBundles != null)
{
foreach (Bundle dep in depBundles)
{
dep.decRef();
}
}
}
public void GetAssets(GameObject obj, IAssetLoader assetLoader, AssetRequest request)
{
var poolableKey = new AssetLoaderKey(obj, assetLoader, request.key);
LoadAsset(request.path, poolableKey);
}
/// <summary> /// This method must be implemented by a subclass to retrieve the asset named in the /// AssetRequest. If the asset is not found, null should be returned. /// </summary> /// <param name="req"></param> /// <returns></returns> /// <exception cref="System.Exception"> /// Thrown if the request failed for some other reason than that the /// asset cannot be found. /// </exception> protected abstract AssetBase GetAsset(AssetRequest req);
void AssetSupplier.SupplyAsset(AssetRequest assetRequest, AssetSupplyListener listener)
{
listener.supplyTaker.Take(assetPick);
}
public void UnLoad(ref AssetRequest assetRequest)
{
}
public SceneLoadingRequest(string sceneName, AssetRequest <Object> request)
{
SceneName = sceneName;
Request = request;
}
private IEnumerator loadTargetScene(string sceneName, IEnumerable <string> additiveScenes, LoadSceneMode mainSceneLoadingMode, bool allowActivation)
{
int targetFrameRate = -1;
float fixedDeltaTime = 0f;
if (sceneDefinitions.TryGetValue(sceneName, out var mainSceneDefinition))
{
targetFrameRate = mainSceneDefinition.TargetFrameRate;
fixedDeltaTime = mainSceneDefinition.FixedDeltaTime;
}
if (targetFrameRate == -1)
{
targetFrameRate = 30;
}
if (Mathf.Approximately(0f, fixedDeltaTime))
{
fixedDeltaTime = 0.0333333f;
}
Application.targetFrameRate = targetFrameRate;
Time.fixedDeltaTime = fixedDeltaTime;
Queue <string> loadableScenes = new Queue <string>();
List <SceneLoadingRequest> assetRequests = new List <SceneLoadingRequest>();
AssetRequest <Object> mainSceneAssetRequest = null;
sceneAssetKeys = new List <string>();
if (false)
{
foreach (string additiveScene2 in additiveScenes)
{
loadableScenes.Enqueue(additiveScene2);
}
}
else
{
if (Content.ContainsKey(sceneName))
{
mainSceneAssetRequest = Content.LoadAsync <Object>(sceneName);
}
foreach (string additiveScene3 in additiveScenes)
{
if (Content.ContainsKey(additiveScene3))
{
assetRequests.Add(new SceneLoadingRequest(additiveScene3, Content.LoadAsync <Object>(additiveScene3)));
}
else
{
loadableScenes.Enqueue(additiveScene3);
}
}
}
if (mainSceneAssetRequest != null)
{
while (!mainSceneAssetRequest.Finished)
{
yield return(null);
}
}
loadAvailableScene(sceneName, allowActivation, mainSceneLoadingMode);
while (assetRequests.Count > 0 || loadableScenes.Count > 0)
{
while (loadableScenes.Count > 0)
{
string additiveScene = loadableScenes.Dequeue();
if (sceneDefinitions.TryGetValue(additiveScene, out var sceneDefinition) && !(sceneDefinition == null))
{
yield return(loadPrerequisiteContent(sceneDefinition));
}
loadAvailableScene(additiveScene, allowActivation, LoadSceneMode.Additive);
}
int i;
for (i = 0; i < assetRequests.Count && !assetRequests[i].Request.Finished; i++)
{
}
if (i < assetRequests.Count)
{
loadableScenes.Enqueue(assetRequests[i].SceneName);
assetRequests.RemoveAt(i);
}
else
{
yield return(null);
}
}
while (asyncLoadingScenes.Count > 0)
{
yield return(asyncLoadingScenes.First.Value.Operation);
Crittercism.LeaveBreadcrumb($"Finished loading scene '{asyncLoadingScenes.First.Value.Name}'");
asyncLoadingScenes.RemoveFirst();
}
overrideSceneActivation = false;
}
private IEnumerator renderSprite(SpriteContentKey unlockID)
{
AssetRequest<Sprite> assetRequest = Content.LoadAsync(unlockID);
yield return assetRequest;
callback(assetRequest.Asset, null);
}
public override AssetRequest Handle(AssetRequest request)
{
return(base.Handle(request));
}
private IEnumerator _LoadAsync(string prefabName, Transform parent, Action <GameObject> onLoad = null, object param = null)
{
if (parent == null)
{
yield break;
}
if (InstantiateCache.I.CanSpawn(RESOURCE_CATEGORY.UI, prefabName))
{
try
{
GameObject go = null;
var inst = InstantiateCache.I.Spawn(RESOURCE_CATEGORY.UI, prefabName, parent);
if (inst != null)
{
go = inst.gameObject;
}
onLoad?.Invoke(go);
}
catch (Exception e)
{
UnityEngine.Debug.LogError(e);
}
yield break;
}
_prefabLoadingList.Add(prefabName);
bool isCompleted = false;
AssetRequest req = InstantiateCache.LoadAssets(RESOURCE_CATEGORY.UI, prefabName, false, (r) => { isCompleted = true; });
if (!string.IsNullOrEmpty(req.assetPath))
{
var go = Resources.Load(req.assetPath) as GameObject;
var trans = parent ?? tran_Inactive;
go = MonoBehaviour.Instantiate(go, trans);
var view = go.GetComponent <ViewBase>();
go.name = prefabName;
view.OnLoad();
trans.gameObject.SetActive(true);
_OnViewLoadFinish(prefabName, view);
yield return(_OnViewShow(view, param));
}
while (!isCompleted)
{
yield return(null);
}
if (parent != null)
{
if (req.loadedObj != null && req.loadedObj is GameObject)
{
var prefabObj = req.loadedObj as GameObject;
var tran = InstantiateCache.I.Spawn(RESOURCE_CATEGORY.UI, prefabName, parent);
if (tran != null)
{
prefabObj = tran.gameObject;
}
else
{
prefabObj = UnityEngine.Object.Instantiate(prefabObj, parent);
}
if (prefabObj == null)
{
//UnityEngine.Debug.LogError("PrefabObj is error!");
}
else
{
prefabObj.name = prefabName;
try
{
onLoad?.Invoke(prefabObj);
}catch (Exception e)
{
UnityEngine.Debug.LogError(e);
}
}
}
}
_prefabLoadingList.Remove(prefabName);
}
/// <summary>
/// 加载资源，path需要是全路径
/// </summary>
/// <param name="path"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public T LoadAsset <T>(string path) where T : UnityEngine.Object
{
AssetRequest assetRequest = Assets.LoadAsset(path, typeof(T));
return((T)assetRequest.asset);
}
protected override AssetBase GetAsset(AssetRequest req)
{
byte[] idBytes = req.AssetID.Guid.ToByteArray();
string cdir = m_dir + Path.DirectorySeparatorChar + idBytes[0]
+ Path.DirectorySeparatorChar + idBytes[1];
if (File.Exists(cdir + Path.DirectorySeparatorChar + req.AssetID + ".xml"))
{
FileStream x = File.OpenRead(cdir + Path.DirectorySeparatorChar + req.AssetID + ".xml");
AssetBase ret = (AssetBase) m_xs.Deserialize(x);
x.Close();
return ret;
}
return null;
}
public IEnumerator Load(MonoBehaviour coroutineProvider)
{
// 如果asset没有在assetbundle里面，就直接加载
if(mainBundle == null)
{
using (WWW www = new WWW(AssetMgr.LOCAL_ASSET_URL + name))
{
yield return www;
OnWWWLoaded(www);
}
yield break;
}
// 先加载依赖的所有assetbundles
if(depBundles != null)
{
foreach (Bundle dep in depBundles)
{
if (dep.IsLoaded)
continue;
yield return coroutineProvider.StartCoroutine(dep.Load());
}
}
// 协程加载assetbundle
if(!mainBundle.IsLoaded)
yield return coroutineProvider.StartCoroutine(mainBundle.Load());
// 如果有其它加载asset的方法，直接调用，没有的话就使用默认的asset request
AsyncRequest request;
if (LoadAssetAsync != null)
request = LoadAssetAsync(mainBundle);
else
request = new AssetRequest(mainBundle.LoadAssetAsync(name, typeof(Object)));
while (!request.isDone)
{
if (OnProgress != null)
OnProgress(request.progress);
yield return 0;
}
if (OnProgress != null)
OnProgress(1.0f);
if(OnAssetLoaded != null)
OnAssetLoaded(request.asset);
// 加载完成后减少assetbundle的引用，使其能够释放
mainBundle.decRef();
if (depBundles != null)
{
foreach (Bundle dep in depBundles)
dep.decRef();
}
}
public AssetModel get_assets(AssetRequest request)
{
return(new AssetModel()
{
});
}
public Object GetObject(ResType type, string name)
{
AssetRequest req = GetAssetRequest(name, type);
return(req != null ? req.asset : null);
}
private static void OnAssetError(string key, AssetRequest <T> request)
{
}
/// <summary>
/// Called each time a wearable asset is done downloading
/// </summary>
/// <param name="request"></param>
void AManager_TransferRequestCompletedEvent(AssetRequest request)
{
if( !(request is AssetRequestDownload) )
{
return;
}
AssetRequestDownload dlrequest = (AssetRequestDownload)request;
if (dlrequest.AssetID == null)
{
Client.Log("AssetID is null in AssetRequestDownload: " + dlrequest.StatusMsg, Helpers.LogLevel.Error);
}
WearableCacheQueueMutex.WaitOne();
// Remove from the download queue
lock (WearableAssetQueue)
{
if (!WearableAssetQueue.Contains(dlrequest.AssetID))
{
// Looks like we got an asset for something other then what we're waiting for, ignore it
WearableCacheQueueMutex.ReleaseMutex();
return;
}
}
// Since we got a response for this asset, remove it from the queue
WearableAssetQueue.Remove(dlrequest.AssetID);
LogWearableAssetQueueActivity("Received queued asset, and removed: " + dlrequest.AssetID);
// If the request wasn't successful, then don't try to process it.
if (request.Status != AssetRequest.RequestStatus.Success)
{
Client.Log("Error downloading wearable asset: " + dlrequest.AssetID, Helpers.LogLevel.Error);
WearableCacheQueueMutex.ReleaseMutex();
return;
}
AssetWearable wearableAsset = WearableCache[dlrequest.AssetID];
wearableAsset.SetAssetData(dlrequest.GetAssetData());
if ((wearableAsset.AssetData == null) || (wearableAsset.AssetData.Length == 0))
{
Client.Log("Asset retrieval failed for AssetID: " + wearableAsset.AssetID, Helpers.LogLevel.Error);
WearableCacheQueueMutex.ReleaseMutex();
return;
}
else
{
UpdateAgentTextureEntryAndAppearanceParams(wearableAsset);
UpdateAgentTextureEntryOrder();
lock(WearableAssetQueue)
{
if (WearableAssetQueue.Count > 0)
{
RequestNextQueuedWearableAsset();
WearableCacheQueueMutex.ReleaseMutex();
return;
}
}
// Now that all the wearable assets are done downloading,
// send an appearance packet
SendAgentSetAppearance();
WearableCacheQueueMutex.ReleaseMutex();
return;
}
}
private void OnAssetLoaded(string key, AssetRequest <T> request)
{
this[key] = request.Asset;
}
