void UpdatePlayingEffect(EffectLocalObjectPool pool, IEnumerable <ClientEffectEmitter> playingEffects)
{
waitReusableList.Clear();
foreach (ClientEffectEmitter effect in playingEffects)
{
switch (effect.StageType)
{
case EEffectStageType.WaitCreate:
if (!effect.IsValid)
{
effect.StageType = EEffectStageType.WaitFinish;
}
else if (effect.CanPlayRightNow)
{
effect.DoRealPlay();
}
else
{
if (effect.IsPreload)
{
assetManager.LoadAssetAsync(effect.Asset.AssetName, effect.Asset, effect.OnPreLoadSucess, new AssetLoadOption(true));
}
else
{
assetManager.LoadAssetAsync(effect.Asset.AssetName, effect.Asset, effect.OnLoadSucess, new AssetLoadOption(true));
}
effect.StageType = EEffectStageType.AsynLoading;
}
break;
case EEffectStageType.AsynLoading:
if (Time.time > effect.LoadAsyncTimestamp + GlobalConst.MaxLoadAsyncWaitTime)
{
effect.StageType = EEffectStageType.WaitFinish;
}
break;
case EEffectStageType.WaitFinish:
waitReusableList.Add(effect);
break;
case EEffectStageType.Playing:
effect.DoFrameUpdate();
break;
}
}
foreach (var value in waitReusableList)
{
pool.Reusable(value);
}
}
private void LoadOne(int subId)
{
if (subId >= _terrains.Length)
{
return;
}
if (_terrains[subId] != null)
{
return;
}
AssetInfo assetInfo = GetAssetInfo(_mapName, subId);
int[] para = { (int)EAssetType.BYTES, subId };
_assetManager.LoadAssetAsync(para, assetInfo, OnLoadSucc);
}
public LocalizeSessionSystem(ISessionState sessionState, IUnityAssetManager assetManager)
{
_sessionState = sessionState;
_assetManager = assetManager;
sessionState.CreateExitCondition(typeof(LocalizeSessionSystem));
assetManager.LoadAssetAsync("", new AssetInfo(ASSETBUNDLENAME, ASSETNAME), OnLoadSucc);
}
public override void OnLoadResources(IUnityAssetManager assetManager)
{
base.OnLoadResources(assetManager);
foreach (var entity in _player.GetEntities())
{
if (entity.hasAppearanceInterface)
{
var loadRequests = entity.appearanceInterface.Appearance.GetLoadRequests();
foreach (var request in loadRequests)
{
var intercept = _interceptPool.Get();
intercept.SetParam(entity, request.GetHandler <PlayerEntity>());
assetManager.LoadAssetAsync(entity, request.AssetInfo, intercept.Call);
}
var recycleRequests = entity.appearanceInterface.Appearance.GetRecycleRequests();
foreach (var request in recycleRequests)
{
entity.RemoveAsset(request);
assetManager.Recycle(request);
}
entity.appearanceInterface.Appearance.ClearRequests();
}
}
}
public void LoadAsync(AssetInfo assetInfo, Action <UnityEngine.Object> callback, GameObject parent = null, Type objectType = null)
{
if (string.IsNullOrEmpty(assetInfo.BundleName) || string.IsNullOrEmpty(assetInfo.AssetName))
{
Debug.LogError("asset error." + assetInfo.BundleName + "," + assetInfo.AssetName);
return;
}
_assetManager.LoadAssetAsync("UiResourceLoader", assetInfo, (source, unityObj) => {
try
{
if (callback != null)
{
callback(unityObj);
}
else
{
AddToGameObjectPool(unityObj);
}
}
catch (Exception e)
{
Logger.ErrorFormat("ui resource loaded failed: {0} {1}", e, assetInfo);
}
}, new AssetLoadOption(parent: _uiLoaderRoot, recyclable: true, objectType: objectType));
}
public void Load(IUnityAssetManager assetManager)
{
foreach (var assetInfo in _assetInfos)
{
assetManager.LoadAssetAsync("BatchLoadHandler", assetInfo, OnLoadSucc, new AssetLoadOption(dontAutoActive: true));
}
}
private void ProcessCommonResources(TEntity entity, ICommonResourceComponent res, IUnityAssetManager loadRequestManager)
{
var time = (int)(MyGameTime.time * 1000);
var resourceLength = res.Resources.Length;
for (var i = 0; i < resourceLength; i++)
{
var asset = res.Resources[i];
var actions = GetActions(i);
if (asset == null || actions == null)
{
continue;
}
if (asset.Status == EAssetLoadStatus.UnLoad)
{
asset.Status = EAssetLoadStatus.Loading;
asset.LastRequestTime = time;
loadRequestManager.LoadAssetAsync(
new AssetRequestSource(GetEntityKey(entity), res.GetComponentId(), asset.ResIndex, asset.LastRequestTime),
asset.AssetInfo, OnLoadSucc, _assetLoadOption);
}
else if (asset.Status == EAssetLoadStatus.UnInit)
{
if (actions.CanInit(entity, asset))
{
actions.Init(entity, asset);
asset.Status = EAssetLoadStatus.Loaded;
}
}
}
}
public void LoadAllGlobalEffect(IUnityAssetManager assetManager, Action allLoadSucc)
{
foreach (var kv in _assetBundles)
{
assetManager.LoadAssetAsync(kv.Key, kv.Value, OnLoadSucc);
}
_allLoadSucc = allLoadSucc;
}
public ClientSessionStateProgress(IContexts contexts)
{
_contexts = contexts as Contexts;
UiCommon.InitUI(UiRootName);
_assetManager = _contexts.session.commonSession.AssetManager;
_assetManager.LoadAssetAsync(GetType().ToString(), new AssetInfo(LoadingUiBundleName, LoadingUiAssetName), OnLoadSucc);
}
public void OnLoadResources(IUnityAssetManager assetManager)
{
if (Reload)
{
foreach (var cfg in _configs)
{
assetManager.LoadAssetAsync("ConfigReloadSystem", new AssetInfo("tables", cfg.Asset), OnLoadSucc);
}
Reload = false;
}
}
protected bool AddLoadRequest(AssetInfo asset)
{
if (!_assetSet.Contains(asset))
{
_loadingAsset.Add(asset);
_assetManager.LoadAssetAsync(GetType().ToString(), asset, OnLoadSucc);
_assetSet.Add(asset);
return(true);
}
return(false);
}
public void LoadAsset(AssetInfo asset)
{
#if !UnitTest
if (Logger.IsDebugEnabled)
{
Logger.DebugFormat("LoadAsset {0}", asset);
}
#endif
if (!_loadKeys.ContainsKey(asset))
{
var loadKey = new LoadKey();
_loadKeys[asset] = loadKey;
_assetManager.LoadAssetAsync("WeaponModelLoader", asset, OnLoadSucc);
}
}
private void RequestForResource(IUnityAssetManager assetManager)
{
_levelManager.GetRequests(_sceneRequests, _goRequests);
foreach (var request in _sceneRequests)
{
assetManager.LoadSceneAsync(request, true);
}
foreach (var request in _goRequests)
{
assetManager.LoadAssetAsync("InitialSceneLoadingSystem", request, _levelManager.GoLoadedWrapper);
}
_sceneRequests.Clear();
_goRequests.Clear();
}
public void Execute()
{
if (SingletonManager.Get <T>().IsInitialized)
{
IsDone = true;
}
else if (!_isLoding)
{
_isLoding = true;
_assetManager.LoadAssetAsync(typeof(T).ToString(), _assetInfo, OnLoadSucc);
}
if (IsDone && !_isExit)
{
_sessionState.FullfillExitCondition(GetConditionId());
_isExit = true;
Logger.InfoFormat("Exit {0}", GetConditionId());
}
}
/// <summary>
/// 加载环境特效
/// </summary>
/// <param name="assetManager"></param>
public override void LoadMapAmbient(IUnityAssetManager assetManager)
{
_logger.Info("Req Load Map Amb ");
MapAmbInfo ambInfo;
Wwise_IDs.GetMapAmb(mapId, out ambInfo);
if (ambInfo.Id > 0 && !string.IsNullOrEmpty(ambInfo.EnvironmentAmb))
{
GameAudioMedia.LoadSimpleBank(string.Format("Map_{0}", mapId), AudioBank_LoadMode.Aync, (akresult) =>
{
if (akresult.Sucess())
{
_logger.Info("try Load Map Amb " + ambInfo.EnvironmentAmb);
assetManager.LoadAssetAsync(entity, new AssetInfo(MapAmbInfo.AssetName, ambInfo.EnvironmentAmb),
OnLoadMapAmbientSucess);
}
});
}
}
public void OnLoadResources(IUnityAssetManager assetManager)
{
_terrainRenderer.GetTerrainDataNames(_terrainName);
if (_terrainName.Count > 0)
{
for (int i = 0; i < _terrainName.Count; ++i)
{
AssetInfo addr = new AssetInfo("tablesfrombuilding", _terrainName[i]);
_logger.InfoFormat("´òËãÔØÈë _terrainName£¬BundleName={0}, AssetName={1}", addr.BundleName, addr.AssetName);
assetManager.LoadAssetAsync((UnityEngine.Object)null, addr, _terrainRenderer.LoadedTerrainData);
}
_terrainName.Clear();
}
if (_sessionState != null)
{
if (_levelManager.NotFinishedRequests <= 0 &&
_terrainRenderer.IsLoadingEnd)
{
_sessionState.FullfillExitCondition(typeof(TerrainDataLoadSystem));
}
else
{
if ((System.DateTime.Now - _lastPrintTime).TotalMilliseconds > _logInterval)
{
_lastPrintTime = System.DateTime.Now;
_logger.InfoFormat("NotFinishedRequests =={0}, IsLoadingEnd =={1}", _levelManager.NotFinishedRequests, _terrainRenderer.IsLoadingEnd);
_logger.InfoFormat(_levelManager.GetRequestString());
//if (_logInterval < 60000)
// _logInterval *= 2;
}
}
}
}
public void OnLoadResources(IUnityAssetManager assetManager)
{
_terrainRenderer.GetTerrainDataNames(_terrainName);
if (_terrainName.Count > 0)
{
for (int i = 0; i < _terrainName.Count; ++i)
{
AssetInfo addr = new AssetInfo("tablesfrombuilding", _terrainName[i]);
assetManager.LoadAssetAsync((UnityEngine.Object)null, addr, _terrainRenderer.LoadedTerrainData);
}
_terrainName.Clear();
}
if (_sessionState != null)
{
if (_levelManager.NotFinishedRequests <= 0 &&
_terrainRenderer.IsLoadingEnd)
{
_sessionState.FullfillExitCondition(typeof(TerrainDataLoadSystem));
}
}
}
public void OnLoadResources(IUnityAssetManager assetManager)
{
if (!_isLoading)
{
_assetManager = assetManager;
var assetInfos = _assetInfoProvider.AssetInfos;
foreach (var assetInfo in assetInfos)
{
_assetManager.LoadAssetAsync("PreLoadSystem", assetInfo, OnLoadSucc);
}
_loadingCount = assetInfos.Count;
_isLoading = true;
if (_loadingCount == 0)
{
_sessionState.FullfillExitCondition(typeof(PreLoadSystem));
}
_logger.InfoFormat("Loading count {0}", _loadingCount);
}
}
public void LoadAsync(AssetInfo assetInfo, Action <UnityEngine.Object> callback, GameObject parent = null, Type objectType = null)
{
if (string.IsNullOrEmpty(assetInfo.BundleName) || string.IsNullOrEmpty(assetInfo.AssetName))
{
//Debug.LogError("asset error." + assetInfo.BundleName + "," + assetInfo.AssetName);
return;
}
if (parent == null)
{
parent = _uiLoaderRoot;
}
_assetManager.LoadAssetAsync("UiResourceLoader", assetInfo, (source, unityObj) =>
{
if (callback != null)
{
callback(unityObj);
}
else
{
AddToGameObjectPool(unityObj);
}
}, new AssetLoadOption(parent: parent, recyclable: true, objectType: objectType));
}
/// <summary>
/// 客户端加载
/// </summary>
/// <param name="manager"></param>
public void OnInitModule(IUnityAssetManager assetManager)
{
assetManager.LoadAssetAsync(GetType().ToString(), AssetConfig.GetAnimationConfigAssetInfo(), OnLoadSucc);
}
public void OnLoadSucc(PlayerEntity player, UnityObject unityObj)
{
GameObject go = unityObj;
RemoveRagdollOnServerSide(go);
HandleLoadedModel(player, go);
player.AddAsset(unityObj);
player.AddThirdPersonModel(go);
go.name = go.name.Replace("(Clone)", "");
go.transform.SetParent(player.RootGo().transform);
go.transform.localPosition = Vector3.zero;
go.transform.localRotation = Quaternion.identity;
go.transform.localScale = Vector3.one;
_logger.InfoFormat("P3 loaded: {0}", player.entityKey);
BoneTool.CacheTransform(go);
if (!player.hasBones)
{
player.AddBones(null, null, null);
}
player.bones.Head = BoneMount.FindChildBoneFromCache(go, BoneName.CharacterHeadBoneName);
player.bones.Spine = BoneMount.FindChildBoneFromCache(go, BoneName.CharacterSpineName);
player.AddThirdPersonAnimator(go.GetComponent <Animator>());
var ik = go.AddComponent <PlayerIK>();
ik.SetAnimator(AvatarIKGoal.LeftHand, player.thirdPersonAnimator.UnityAnimator);
ik.SetIKLayer(AvatarIKGoal.LeftHand, NetworkAnimatorLayer.ThirdPersonIKPassLayer);
ik.SetAnimator(AvatarIKGoal.RightHand, player.thirdPersonAnimator.UnityAnimator);
ik.SetIKLayer(AvatarIKGoal.RightHand, NetworkAnimatorLayer.ThirdPersonIKPassLayer);
if (player.isFlagSelf)
{
var animationEvent = go.AddComponent <AnimationClipEvent>();
animationEvent.Player = player;
player.animatorClip.ClipManager.SetAnimationCleanEventCallback(animationEvent.InterruptAnimationEventFunc);
// 设置大厅传入的roleId和avatarId
player.appearanceInterface.Appearance.SetRoleModelIdAndInitAvatar(player.playerInfo.RoleModelId, player.playerInfo.AvatarIds);
}
else
{
go.AddComponent <ThirdPersonAnimationClipEvent>();
}
player.characterControllerInterface.CharacterController.SetCharacterRoot(player.characterContoller.Value.gameObject);
player.appearanceInterface.Appearance.SetThirdPersonCharacter(go);
player.thirdPersonAnimator.UnityAnimator.Update(0);
player.characterBoneInterface.CharacterBone.SetCharacterRoot(player.characterContoller.Value.gameObject);
player.characterBoneInterface.CharacterBone.SetThirdPersonCharacter(go);
player.characterBoneInterface.CharacterBone.SetStablePelvisRotation();
player.appearanceInterface.Appearance.SetAnimatorP3(player.thirdPersonAnimator.UnityAnimator);
player.appearanceInterface.Appearance.PlayerReborn();
player.characterControllerInterface.CharacterController.PlayerReborn();
// 实际应该使用SharedConfig.IsServer，但离线模式中其值为false
if (!player.hasNetworkAnimator)
{
player.AddNetworkAnimator(NetworkAnimatorUtil.CreateAnimatorLayers(player.thirdPersonAnimator.UnityAnimator),
NetworkAnimatorUtil.GetAnimatorParams(player.thirdPersonAnimator.UnityAnimator));
player.networkAnimator.SetEntityName(player.entityKey.ToString());
}
if (!player.hasOverrideNetworkAnimator)
{
player.AddOverrideNetworkAnimator();
}
if (SharedConfig.IsServer)
{
player.AddNetworkAnimatiorServerTime(0);
}
// 禁用非可见状态下的动画更新，在获取Stable状态之后
if (SharedConfig.IsServer || !player.isFlagSelf)
{
player.thirdPersonAnimator.UnityAnimator.cullingMode = AnimatorCullingMode.CullUpdateTransforms;
}
else
{
player.thirdPersonAnimator.UnityAnimator.cullingMode = AnimatorCullingMode.AlwaysAnimate;
}
_assetManager.LoadAssetAsync(player, AssetConfig.GetCharacterHitboxAssetInfo(player.playerInfo.ModelName), new HitboxLoadResponseHandler().OnLoadSucc);
}
private void LoadSimpleItem(SceneObjectEntity sceneObjectEntity)
{
var category = sceneObjectEntity.simpleItem.Category;
var id = sceneObjectEntity.simpleItem.Id;
if (id < 1)
{
Logger.ErrorFormat("itemid is illegal for item {0}", sceneObjectEntity.entityKey);
return;
}
switch ((ECategory)category)
{
case ECategory.Avatar:
var avatarCfg = SingletonManager.Get <RoleAvatarConfigManager>().GetConfigById(id);
if (null != avatarCfg)
{
if (null != _playerContext.flagSelfEntity && _playerContext.flagSelfEntity.hasPlayerInfo)
{
LoadAvatar(sceneObjectEntity, _playerContext.flagSelfEntity, avatarCfg);
}
}
break;
case ECategory.WeaponPart:
var partId = SingletonManager.Get <WeaponPartSurvivalConfigManager>().GetDefaultPartBySetId(id);
var partCfg = SingletonManager.Get <WeaponPartsConfigManager>().GetConfigById(partId);
var partAsset = new AssetInfo(partCfg.Bundle, partCfg.Res);
if (string.IsNullOrEmpty(partAsset.AssetName) || string.IsNullOrEmpty(partAsset.BundleName))
{
break;
}
var partSize = SingletonManager.Get <WeaponPartSurvivalConfigManager>().GetSizeById(id);
if (partSize != 1)
{
sceneObjectEntity.AddSize(partSize);
}
_assetManager.LoadAssetAsync(sceneObjectEntity, partAsset,
simpleLoadHandler.OnLoadUnityObjectSucess);
sceneObjectEntity.effects.AddGlobalEffect(GlobalEffectManager.GlobalGroundPropFlash);
break;
case ECategory.GameItem:
var itemSsset = SingletonManager.Get <GameItemConfigManager>().GetAssetById(id);
if (string.IsNullOrEmpty(itemSsset.AssetName) || string.IsNullOrEmpty(itemSsset.BundleName))
{
#if UNITY_EDITOR
UnityEngine.Debug.LogError(string.Format("item is not config for id {0}", id));
#else
Logger.ErrorFormat("item is not config for id {0}", id);
#endif
return;
}
var itemSize = SingletonManager.Get <GameItemConfigManager>().GetSizeById(id);
if (itemSize != 1)
{
sceneObjectEntity.AddSize(itemSize);
}
_assetManager.LoadAssetAsync(sceneObjectEntity, itemSsset,
simpleLoadHandler.OnLoadUnityObjectSucess);
sceneObjectEntity.effects.AddGlobalEffect(GlobalEffectManager.GlobalGroundPropFlash);
break;
}
}
private void OnLoadSucc(string source, UnityObject unityObj)
{
var obj = unityObj.AsGameObject;
if (obj != null)
{
_loadingUi = obj;
var rect = _loadingUi.GetComponent <RectTransform>();
rect.anchorMin = Vector2.zero;
rect.anchorMax = new Vector2(1, 1);
rect.offsetMin = Vector2.zero;
rect.offsetMax = Vector2.zero;
FillField();
// _loadingSlider = _loadingUi.GetComponentInChildren<Slider>();
var bgBundle = SingletonManager.Get <MapConfigManager>().MapIconBundle;
var bgAsset = SingletonManager.Get <MapConfigManager>().MapIconAsset;
if (string.IsNullOrEmpty(bgBundle) || string.IsNullOrEmpty(bgAsset))
{
bgBundle = AssetBundleConstant.Icon_Map;
bgAsset = MapIconAssetName;
}
_assetManager.LoadAssetAsync(GetType().ToString(), new AssetInfo(bgBundle, bgAsset),
(sour, data) =>
{
if (data.AsObject is Texture2D)
{
var tex = data.As <Texture2D>();
if (_bg != null)
{
_bg.sprite = Sprite.Create(tex, new Rect(0, 0, tex.width, tex.height), Vector2.zero);
}
if (_bgRawImg != null)
{
_bgRawImg.texture = tex;
}
}
else
{
if (_bg != null)
{
_bg.sprite = data.As <Sprite>();
}
}
if (_bg != null)
{
_bg.color = Color.white;
}
if (_bgRawImg != null)
{
_bgRawImg.color = Color.white;
}
});
var root = UiCommon.UIManager.UIRoot;
if (root == null)
{
_logger.ErrorFormat("The client ui root does not exist!");
}
else
{
_loadingUi.transform.SetParent(root.transform, false);
_loadingUi.SetActive(true);
}
}
}
public void LoadResource(string name, IUnityAssetManager assetManager, AssetInfo request)
{
assetManager.LoadAssetAsync(name, request, GoLoadedWrapper, _assetLoadOption);
}
public void OnInitModule(IUnityAssetManager assetManager)
{
assetManager.LoadAssetAsync("InitOcclusionCullingControllerSystem", _ocDataAssetInfo, OnOCDataLoaded);
}
public void OnInitModule(IUnityAssetManager assetManager)
{
assetManager.LoadAssetAsync(GetType().ToString(), new AssetInfo("tables", "input"), OnLoadSucc);
}
