private void OnSkinChanged(SkinInstance si, int nPart)
{
if (!Valid)
{
return;
}
UpdateBindBoneTransform();
}
public override void SetVisible(bool bVisible, bool ApplyAll = false)
{
m_currStateData.Vislble = bVisible;
if (!SkinInstance.isNullOrEmpry(CurrentSkinInstance))
{
SetVisible_Impl(bVisible, CurrentSkinInstance);
}
}
protected void InvokeSkinChangedEvent(SkinInstance ins, int nPart)
{
if (null == onSkinChanged)
{
return;
}
onSkinChanged.Invoke(ins, nPart);
}
public static bool isNullOrEmpry(SkinInstance instance)
{
if (null == instance)
{
return(true);
}
return(!instance.isValid);
}
private static void BuildTankSkinInstance(Skin sk, GameObject instanceSkin, ref SkinInstance si)
{
if (!sk.isValid)
{
return;
}
return;
}
private static void OnRelateSkinLoadFinish(Skin sk)
{
if (!sk.isValid)
{
return;
}
SkinInstance go = sk.Instantiate_Main();
if (go != null)
{
SkinManager.CacheSkinInstance(go);
}
}
private void ApplyMonsterSkinDataToMachine(MonsterStateMachine machine, SkinInstance instance)
{
MonsterSkinConfig SkinConfig = instance.entitySkinConfig as MonsterSkinConfig;
if (null == SkinConfig)
{
Debug.LogError("切换皮肤重大错误-ApplyMonsterSkinDataToMachine");
return;
}
machine.animator = instance.MainAnimator;
machine.RefershAnimatorDataWhenSkinChangedFinish();
instance.ReferencedSkinCtrl = this;
}
public void ApplyOrginalData(SkinInstance instance)
{
if (SkinInstance.isNullOrEmpry(instance))
{
return;
}
Transform mainTrs = instance.GetBonesTransform("Main");
if (mainTrs)
{
mainTrs.localScale = OrginalData.mainBonesScale;
}
}
/// <summary>
/// 是否可以寻找骨骼,因为皮肤属于异步加载逻辑，有可能皮肤没有加载完成，光效已经出来了。对于绑定光效是找不到骨骼的
/// </summary>
/// <param name="entityID"></param>
/// <returns></returns>
public static bool IsCanFindTransform(int entityID)
{
U3D_Render.EntityView ev = EntityFactory.getEntityViewByID(entityID);
if (U3D_Render.EntityView.isNullOrEmpty(ev))
{
return(true);
}
BaseStateMachine machine = GetStateMachine(entityID);
if (!machine)
{
return(true);
}
return(!SkinInstance.isNullOrEmpry(machine.SkinControl.CurrentSkinInstance));
}
/// <summary>
/// 普通血条更新
/// </summary>
private void NormalUpdate()
{
m_InvalidList.Clear();
if (null != m_BloodMap)
{
foreach (UBlood var in m_BloodMap.Values)
{
UBlood ub = var;
EntityView view = ub.Entity;
if (view == null || !view.IsValid)
{
m_InvalidList.Enqueue(ub);
continue;
}
//如果实体未激活,或者尚未加载完毕则隐藏血条
if (SkinInstance.isNullOrEmpry(view.SkinControl.CurrentSkinInstance) || !view.StateMachine.GetVisible())
{
ub.SetEnable(false);
if (view.Type == ENTITY_TYPE.TYPE_PLAYER_ROLE)
{
ub.OnUpdate();
}
}
else
{
ub.SetEnable(true);
//需要更新的血条进行正常更新
ub.OnUpdate();
}
}
}
while (m_InvalidList.Count > 0)
{
UBlood ub = m_InvalidList.Dequeue();
if (bPreWarmBlood)
{
CacheBlood(ub);
}
else
{
DestroyBlood(ub);
}
}
m_InvalidList.Clear();
}
public async Task BuyCase(int n)
{
UserData user = GetUserData(Context.Message.Author.Id);
if (CSGOConfigs.config.caseprice > user.cash)
{
await QuickEmbed($"Insufficient funds! A case costs ``${CSGOConfigs.config.caseprice}``");
return;
}
if (n >= Cases.cases.Length || n < 0)
{
await QuickEmbed($"Please enter a number between 0 and {Cases.cases.Length - 1}");
return;
}
Console.WriteLine($"There are {Cases.cases.Length} cases aval");
user.cash -= CSGOConfigs.config.caseprice;
SkinInstance skin = Cases.cases[n].OpenCase();
user.skins.Add(skin);
ChangeUserData(Context.Message.Author.Id, user);
var embed = new EmbedBuilder();
embed.WithDescription($"{Context.Message.Author.Mention} just unboxed a")
.AddField("---------------", $"**{skin.ToString()}** \n" +
$"from a {Cases.cases[n].name}!\n" +
$"Value **${skin.worth}**")
.WithColor(CSGOConfigs.GetColor(skin.skinData.rarity));
if (skin.skinData.imageURL != "")
{
embed.WithImageUrl(skin.skinData.imageURL);
}
await ReplyAsync(embed : embed.Build());
}
public static void UnRegsiterSkinChangedEvent(int entityID, UnityAction <SkinInstance, int> action)
{
U3D_Render.EntityView ev = EntityFactory.getEntityViewByID(entityID);
if (U3D_Render.EntityView.isNullOrEmpty(ev))
{
return;
}
BaseStateMachine machine = GetStateMachine(entityID);
if (!machine)
{
return;
}
if (SkinInstance.isNullOrEmpry(machine.SkinControl.CurrentSkinInstance))
{
return;
}
machine.SkinControl.UnRegsiterSkinChangedEvent(action);
}
public void SaveOrginalData(SkinInstance instance)
{
if (bGetOrginalData)
{
return;
}
if (SkinInstance.isNullOrEmpry(instance))
{
return;
}
bGetOrginalData = true;
OrginalData = new SkinOrginalData();
OrginalData.mainBonesScale = Vector3.one;
Transform mainTrs = instance.GetBonesTransform("Main");
if (mainTrs)
{
OrginalData.mainBonesScale = mainTrs.localScale;
}
}
public static void DeleteSkin(ref SkinInstance instance)
{
if (null == instance)
{
return;
}
if (instance.nSkinID <= 0)
{
return;
}
if (!instance.isLoadFinish)
{
Debug.LogWarning("异步加载的皮肤，使用了同步卸载接口,可能会出现一些问题:" + instance.nSkinID);
}
SkinManager.CacheSkinInstance(instance);
ReleaseSkin(instance.nSkinID);
instance = null;
}
public static void DisableSkinInstance(SkinInstance instance)
{
if (null == instance)
{
return;
}
if (!instance.isValid)
{
return;
}
Skin sk = null;
m_SkinMap.TryGetValue(instance.nSkinID, out sk);
sk.ApplyOrginalData(instance);
if (instance.playEntityStaticEffect)
{
instance.playEntityStaticEffect.Stop();
}
if (instance.switchEffectWithHeroDistance)
{
instance.switchEffectWithHeroDistance.DisableAll();
}
instance.SkinObj.SetActive(false);
instance.SetVisible(true); //重置可见性
instance.SetBindEffectEnabled(false); //重置绑定特效
BipedIKAnimator anc = instance.SkinObj.GetComponent <BipedIKAnimator>();
if (anc != null)
{
if (anc.goA != null)
{
anc.goA.SetActive(false);
}
if (anc.goB != null)
{
anc.goB.SetActive(false);
}
}
}
public static Transform FindTransformWound(int entityID, string woundName)
{
if (string.IsNullOrEmpty(woundName))
{
return(null);
}
U3D_Render.EntityView ev = EntityFactory.getEntityViewByID(entityID);
if (null != ev && null != ev.SkinControl)
{
SkinInstance si = ev.SkinControl.CurrentSkinInstance;
if (null != si && null != si.SkinDataObj)
{
Transform wound = si.SkinDataObj.FindChild(woundName);
if (wound != null)
{
return(wound);
}
}
}
return(null);
}
public static void CacheSkinInstance(SkinInstance instance)
{
if (SkinInstance.isNullOrEmpry(instance))
{
return;
}
if (instance.isBeCached)
{
return;
}
instance.isBeCached = true;
Skin sk = null;
m_SkinMap.TryGetValue(instance.nSkinID, out sk);
sk.Main_CacheList.Enqueue(instance);
if (EntityFactory.SkinCacheGroup != null)
{
instance.SkinObj.transform.parent = EntityFactory.SkinCacheGroup.transform;
}
DisableSkinInstance(instance);
instance.SkinObj.transform.localScale = instance.PrefabScale;
instance.SkinObj.transform.localPosition = Vector3.zero;
instance.ReferencedSkinCtrl = null;
if (instance.bindEffect_A)
{
instance.bindEffect_A.ClearEvent();
}
if (instance.bindEffect_B)
{
instance.bindEffect_B.ClearEvent();
}
if (instance.bindSound)
{
instance.bindSound.ClearEvent();
}
}
public static void BuildSkinInstance(Skin sk, GameObject instanceSkin, ref SkinInstance skinInstance)
{
if (!sk.isValid)
{
return;
}
switch (sk.SkinType)
{
case ENTITY_TYPE.TYPE_MONSTER:
BuildMonsterSkinInstance(sk, instanceSkin, ref skinInstance);
return;
case ENTITY_TYPE.TYPE_PLAYER_ROLE:
BuildPlayerSkinInstance(sk, instanceSkin, ref skinInstance);
return;
case ENTITY_TYPE.TYPE_TANK:
BuildTankSkinInstance(sk, instanceSkin, ref skinInstance);
return;
default:
return;
}
}
public async Task Inspect(int index)
{
if (index < 0)
{
await EnterNonNegativeValue();
return;
}
List <SkinInstance> skins = GetUserData(Context.Message.Author.Id).skins;
if (index >= skins.Count)
{
await QuickEmbed($"Please enter a number between 0 and {skins.Count - 1}");
return;
}
SkinInstance skin = skins[index];
var e = new EmbedBuilder();
e.WithDescription($"{Context.Message.Author.Mention}'s **{skin.skinData.weapon} {skin.skinData.name}**")
.AddField("=======================",
$"Value: **${skin.worth}**\n" +
$"Float: **{skin.floatValue}**\n" +
$"Condition: **{CSGOConfigs.LogCondition(skin.condition)}**\n" +
$"Rarity: **{CSGOConfigs.LogRarity(skin.skinData.rarity)}**\n" +
$"Stattrak? **{(skin.stattrak? "YES" : "NO")}**\n" +
$"ID: **{skin.id}**\n" +
$"Description: *{skin.skinData.description}*")
.WithColor(CSGOConfigs.GetColor(skin.skinData.rarity));
if (skin.skinData.imageURL != "")
{
e.WithImageUrl(skin.skinData.imageURL);
}
await ReplyAsync(embed : e.Build());
}
/// <summary>
/// 当皮肤已经被改变-消息通知
/// </summary>
/// <param name="nSkinID">皮肤ID</param>
/// <param name="nPart">哪个部位</param>
protected override void OnSkinChanged(SkinInstance sk, int nPart)
{
if (null == sk || !sk.isValid)
{
return;
}
m_DistanceVisible = true;
EntityView ev = EntityFactory.getMonsterViewByID(this.entityID);
ChangeStateMachineParams();
ChangeCreaturePropety();
ChangeMask(ev);
gameObject.name = SkinManager.GetSkinName(sk.nSkinID) + "(entityID:" + entityID + ")";
base.OnSkinChanged(sk, nPart);
//关于ward结界类型的特殊处理
//结界类型的物理盒子放在LayerWard层，用于阻挡指定类型的玩家
//但是结界有可以选中和不可以选中，
//这里只将配置的ScreenCastObject改为其他层，那么不可选中的结界不配置ScreenCastObject，就不影响结界后面实体的技能选中，
//除了ScreenCastObject之外，实体的其他部分仍然为LayerWard，
//那么hit到了之后LayerWard在判断实体有效性的时候，也将LayerWard加入有效层的范围内，这样就结界的选中就是合法的了。
if (creature.gameObject.layer == LayerMask.NameToLayer(Config.LayerWard_Enemy))
{
if (creaturePropety.ScreenCastObject)
{
GameUtil.SetLayer(LayerMask.NameToLayer(Config.LayerMonsterEnemy), creaturePropety.ScreenCastObject, false);
}
}
else if (creature.gameObject.layer == LayerMask.NameToLayer(Config.LayerWard_Friend))
{
if (creaturePropety.ScreenCastObject)
{
GameUtil.SetLayer(LayerMask.NameToLayer(Config.LayerMonsterFriend), creaturePropety.ScreenCastObject, false);
}
}
goRootTransform = FindTransformEx("Main");
currentGravity = creaturePropety.downGravity;
SkinInstance si = SkinControl.CurrentSkinInstance;
if (si.playEntityStaticEffect)
{
si.playEntityStaticEffect.ResetLayer();
si.playEntityStaticEffect.Stop();
si.playEntityStaticEffect.Play(ev);
}
if (si.switchEffectWithHeroDistance)
{
si.switchEffectWithHeroDistance.ResetLayer();
si.switchEffectWithHeroDistance.SetEntitiyView(ev);
}
#if !ENABLE_YUNYING_MODE
if (SkinConfig.OcclusCollider)
{
if (!startCheckOcclusCoroutine)
{
startCheckOcclusCoroutine = true;
cor_CheckOcclus = StartCoroutine(CheckOcclus());
}
}
#endif
}
private void OnSkinLoadFinish(Skin skin)
{
if (skin == null)
{
return;
}
//回调的，跟当前ID不匹配，卸载这个皮肤
if (skin.nSkinID != currentSkinId)
{
if (m_currentLoadedSkinInstance != null)
{
if (m_currentLoadedSkinInstance.isValid)
{
//看看当前的skininstance是不是与skin的ID一样
if (m_currentLoadedSkinInstance.nSkinID == skin.nSkinID)
{
SkinManager.CacheSkinInstance(m_currentLoadedSkinInstance);
m_currentLoadedSkinInstance = null;
}
}
}
RemoveCallBack(skin.nSkinID);
SkinManager.DeleteSkinAsync(skin.nSkinID, OnSkinLoadFinish, NotReleaseFromCache);
return;
}
//如果已经被裁剪了，卸载这个皮肤
if (isCull && SkinManager.enabledSkinCull)
{
if (m_currentLoadedSkinInstance != null)
{
if (m_currentLoadedSkinInstance.isValid)
{
//看看当前的skininstance是不是与skin的ID一样
if (m_currentLoadedSkinInstance.nSkinID == skin.nSkinID)
{
SkinManager.CacheSkinInstance(m_currentLoadedSkinInstance);
m_currentLoadedSkinInstance = null;
}
}
}
SkinManager.DeleteSkinAsync(skin.nSkinID, OnSkinLoadFinish, NotReleaseFromCache);
return;
}
if (m_currentLoadedSkinInstance != null)
{
if (m_currentLoadedSkinInstance.isValid)
{
SkinManager.CacheSkinInstance(m_currentLoadedSkinInstance);
RemoveCallBack(m_currentLoadedSkinInstance.nSkinID);
SkinManager.DeleteSkinAsync(m_currentLoadedSkinInstance.nSkinID, OnSkinLoadFinish, NotReleaseFromCache);
m_currentLoadedSkinInstance = null;
}
}
SkinControlAsyncLoadingObj obj = AllocSkinControlAsyncLoadingObj(skin.nSkinID);
if (m_ChangeSkinData.ContainsKey(skin.nSkinID))
{
obj.loadFinish = true;
}
SkinInstance si = skin.Instantiate_Main();
if (si == null)
{
m_currentLoadedSkinInstance = null;
ClearPersonSkinDataFromMachine(m_machine);
return;
}
GameUtil.SetLayer(m_machine.creature.gameObject.layer, si.SkinObj, true);
m_currentLoadedSkinInstance = si;
PersonSkinConfig psp = si.entitySkinConfig as PersonSkinConfig;
si.SkinObj.transform.parent = transform;
si.SkinObj.transform.localPosition = Vector3.zero;
si.SkinObj.transform.localRotation = Quaternion.identity;
si.SkinObj.transform.name = skin.ResSkinObj.AssetName + "-skin" + skin.nSkinID + "_C";;
if (psp.AttackAnimatorLayer <= 0)
{
si.SkinObj_A.transform.parent = transform;
si.SkinObj_B.transform.parent = transform;
}
if (si.SkinObj_A)
{
si.SkinObj_A.transform.parent = transform;
si.SkinObj_A.transform.localPosition = new Vector3(-1.0f, 0.0f, 0.0f);
si.SkinObj_A.transform.localRotation = Quaternion.identity;
si.SkinObj_A.name = skin.ResSkinObj.AssetName + "-skin" + skin.nSkinID + "_A";
}
if (si.SkinObj_B)
{
si.SkinObj_B.transform.parent = transform;
si.SkinObj_B.transform.localPosition = new Vector3(-1.0f, 0.0f, 0.0f);
si.SkinObj_B.transform.localRotation = Quaternion.identity;
si.SkinObj_B.name = skin.ResSkinObj.AssetName + "-skin" + skin.nSkinID + "_A";
}
foreach (RenderVisibleHelper skre in si.VisibleHelperList)
{
skre.hostSkin = null;
}
foreach (RenderVisibleHelper skre in si.VisibleHelperList)
{
skre.hostSkin = this;
}
ApplyStateData(m_currStateData);
ApplyPersonSkinDataToMachine(m_machine, si);
}
private void OnSkinLoadFinish(Skin skin)
{
if (skin == null)
{
return;
}
//回调的，跟当前ID不匹配，卸载这个皮肤
if (skin.nSkinID != currentSkinId)
{
if (m_currentLoadedSkinInstance != null)
{
if (m_currentLoadedSkinInstance.isValid)
{
//看看当前的skininstance是不是与skin的ID一样
if (m_currentLoadedSkinInstance.nSkinID == skin.nSkinID)
{
SkinManager.CacheSkinInstance(m_currentLoadedSkinInstance);
m_currentLoadedSkinInstance = null;
}
}
}
RemoveCallBack(skin.nSkinID);
SkinManager.DeleteSkinAsync(skin.nSkinID, OnSkinLoadFinish);
return;
}
if (m_currentLoadedSkinInstance != null)
{
if (m_currentLoadedSkinInstance.isValid)
{
SkinManager.CacheSkinInstance(m_currentLoadedSkinInstance);
RemoveCallBack(m_currentLoadedSkinInstance.nSkinID);
SkinManager.DeleteSkinAsync(m_currentLoadedSkinInstance.nSkinID, OnSkinLoadFinish);
m_currentLoadedSkinInstance = null;
}
}
SkinControlAsyncLoadingObj obj = AllocSkinControlAsyncLoadingObj(skin.nSkinID);
if (m_ChangeSkinData.ContainsKey(skin.nSkinID))
{
obj.loadFinish = true;
}
SkinInstance si = skin.Instantiate_Main();
if (si == null)
{
m_currentLoadedSkinInstance = null;
ClearMonsterSkinDataFromMachine(m_machine);
return;
}
GameObject go = si.SkinObj;
GameUtil.SetLayer(m_machine.creature.gameObject.layer, go, true);
m_currentLoadedSkinInstance = si;
go.transform.parent = m_machine.creature;
go.transform.localPosition = Vector3.zero;
go.transform.localRotation = Quaternion.identity;
go.name = skin.ResSkinObj.AssetName + "-skin" + skin.nSkinID;
go = null;
ApplyStateData(m_currStateData);
ApplyMonsterSkinDataToMachine(m_machine, si);
}
private static void BuildMonsterSkinInstance(Skin skin, GameObject instanceSkin, ref SkinInstance si)
{
if (!skin.isValid)
{
return;
}
if (null == si)
{
si = new SkinInstance();
si.m_nSkinID = skin.nSkinID;
}
si.m_SkinType = skin.SkinType;
Transform SkinDataObj = instanceSkin.transform.FindChild("SkinDataObj");
SkinDataObj.localPosition = Vector3.zero;
SkinDataObj.localRotation = Quaternion.identity;
SkinDataObj.localScale = Vector3.one;
MonsterSkinConfig msp = SkinDataObj.GetComponent <MonsterSkinConfig>();
si.m_SkinDataObj = SkinDataObj;
if (msp.ColliderShape)
{
msp.StandradColliderShapeSize = msp.ColliderShape.transform.localScale;
}
if (msp.OcclusCollider)
{
msp.OcclusCollider.isTrigger = true;
msp.gameObject.layer = LayerMask.NameToLayer(Config.LayerWater);
}
si.m_entitySkinConfig = msp;
si.m_SkinObj = instanceSkin;
si.m_creatureProperty = SkinDataObj.GetComponent <CreatureProperty>();
si.m_ConfigScale = skin.fSkinScale;
si.m_PrefabScale = instanceSkin.transform.localScale;
if (!skin.isStaticSkin)
{
si.m_MainAnimator = instanceSkin.GetComponent <Animator>();
}
bool enableAnimator = true;
if (msp.BodyNeedToBakeMesh)
{
SkinnedMeshRenderer smr = msp.BodyRender as SkinnedMeshRenderer;
BakeMeshNode nod = BakeMesh(smr);
if (null != nod)
{
skin.AllBakeMesh.Add(nod);
msp.BodyRender = MakeBakeMeshRender(smr, nod);
enableAnimator = false;
}
}
if (msp.RightWeaponNeedToBakeMesh)
{
SkinnedMeshRenderer smr = msp.RightWeaponRender as SkinnedMeshRenderer;
BakeMeshNode nod = BakeMesh(smr);
if (null != nod)
{
skin.AllBakeMesh.Add(nod);
msp.RightWeaponRender = MakeBakeMeshRender(smr, nod);
enableAnimator = false;
}
}
if (msp.LeftWeaponNeedToBakeMesh)
{
SkinnedMeshRenderer smr = msp.LeftWeaponRender as SkinnedMeshRenderer;
BakeMeshNode nod = BakeMesh(smr);
if (null != nod)
{
skin.AllBakeMesh.Add(nod);
msp.LeftWeaponRender = MakeBakeMeshRender(smr, nod);
enableAnimator = false;
}
}
if (msp.BackBodyNeedToBakeMesh)
{
SkinnedMeshRenderer smr = msp.BackBodyRender as SkinnedMeshRenderer;
BakeMeshNode nod = BakeMesh(smr);
if (null != nod)
{
skin.AllBakeMesh.Add(nod);
msp.BackBodyRender = MakeBakeMeshRender(smr, nod);
enableAnimator = false;
}
}
if (!skin.isStaticSkin)
{
if (!enableAnimator)
{
si.MainAnimator.enabled = false;
si.m_MainAnimator = null;
}
}
si.m_switchEffectWithHeroDistance = SkinDataObj.GetComponent <Effect.SwitchEffectWithHeroDistance>();
si.m_playEntityStaticEffect = SkinDataObj.GetComponent <Effect.Effect_PlayEntityStaticEffect>();
si.SkinnedMeshRenderList.AddRange(instanceSkin.GetComponentsInChildren <SkinnedMeshRenderer>());
si.MeshRenderList.AddRange(instanceSkin.GetComponentsInChildren <MeshRenderer>());
int length = si.SkinnedMeshRenderList.Count;
//移除skindataobj下的物体
for (int k = 0; k < length; k++)
{
si.SkinnedMeshRenderList[k].motionVectors = false;
si.SkinnedMeshRenderList[k].skinnedMotionVectors = false;
Transform t = si.SkinnedMeshRenderList[k].transform;
if (t.IsChildOf(SkinDataObj.transform))
{
si.SkinnedMeshRenderList.RemoveAt(k);
}
else
{
si.AllRenders.Add(si.SkinnedMeshRenderList[k]);
}
}
length = si.MeshRenderList.Count;
//移除skindataobj下的物体
for (int k = 0; k < length; k++)
{
si.MeshRenderList[k].motionVectors = false;
Transform t = si.MeshRenderList[k].transform;
if (t.IsChildOf(SkinDataObj.transform))
{
si.MeshRenderList.RemoveAt(k);
}
else
{
si.AllRenders.Add(si.MeshRenderList[k]);
}
}
//必须放到最后
if (si.playEntityStaticEffect)
{
si.playEntityStaticEffect.Init();
}
si.Init();
return;
}
/// <summary>
/// 模型加载完成初始化回调
/// </summary>
/// <param name="sk"></param>
/// <param name="nPart"></param>
protected void OnSkinChanged(SkinInstance sk, int nPart)
{
m_SkinControl.UnRegsiterSkinChangedEvent(OnSkinChanged);
OnSkinChangedLoacl();
}
private static void BuildPlayerSkinInstance(Skin skin, GameObject instanceSkin, ref SkinInstance si)
{
if (!skin.isValid)
{
return;
}
if (null == si)
{
si = new SkinInstance();
si.m_nSkinID = skin.nSkinID;
}
si.m_SkinType = skin.SkinType;
Transform SkinDataObj = instanceSkin.transform.FindChild("SkinDataObj");
SkinDataObj.localPosition = Vector3.zero;
SkinDataObj.localRotation = Quaternion.identity;
SkinDataObj.localScale = Vector3.one;
PersonSkinConfig psc = SkinDataObj.GetComponent <PersonSkinConfig>();
si.m_SkinDataObj = SkinDataObj;
si.m_SkinObj = instanceSkin;
si.m_characterController = SkinDataObj.GetComponent <CharacterController>();
si.m_characterController.enabled = false;
si.m_entitySkinConfig = psc;
si.m_cameraProperty = SkinDataObj.GetComponent <CameraProperty>();
if (psc.AttackAnimatorLayer > 0)
{
si.m_MainAnimator = instanceSkin.GetComponent <Animator>();
si.m_AnimatorB = si.MainAnimator;
si.m_overrideController = new AnimatorOverrideController();
si.orginalAnimatorController = si.MainAnimator.runtimeAnimatorController;
si.overrideController.runtimeAnimatorController = si.orginalAnimatorController;
si.MainAnimator.runtimeAnimatorController = si.overrideController;
}
else
{
Debug.LogError("BuildPlayerSkinInstance--- psc.AttackAnimatorLayer <= 0");
}
//else
//{
// Debug.Log("--------------皮肤调试信息-----------------------" + instanceSkin.name);
// GameObject goa = CreateSkinObject(skin, false, psc.controllerA);
// GameObject gob = CreateSkinObject(skin, false, psc.controllerB);
// Transform skina = goa.transform.FindChild("SkinDataObj");
// if (skina != null)
// {
// var temp = skina.gameObject;
// ResNode.DestroyRes(ref temp);
// }
// Transform skinb = gob.transform.FindChild("SkinDataObj");
// if (skinb != null)
// {
// var temp = skinb.gameObject;
// ResNode.DestroyRes(ref temp);
// }
// Renderer[] rsa = goa.GetComponentsInChildren<Renderer>();
// foreach (Renderer ra in rsa)
// {
// var temp = ra;
// ResNode.DestroyRes(ref temp);
// }
// Renderer[] rsb = gob.GetComponentsInChildren<Renderer>();
// foreach (Renderer rb in rsb)
// {
// var temp = rb;
// ResNode.DestroyRes(ref temp);
// }
// si.MainAnimator = goa.GetComponent<Animator>();
// si.AnimatorB = gob.GetComponent<Animator>();
// Animator anoldc = instanceSkin.GetComponent<Animator>();
// if (anoldc != null)
// {
// ResNode.DestroyRes(ref anoldc);
// }
// si.bipedIKAnimator = instanceSkin.AddComponent<BipedIKAnimator>();
// si.bipedIKAnimator.goA = goa;
// si.bipedIKAnimator.goB = gob;
// si.bipedIKAnimator.Build();
// si.SkinObj_A = goa;
// si.SkinObj_B = gob;
//}
si.MainAnimator.applyRootMotion = false;
si.MainAnimator.cullingMode = AnimatorCullingMode.AlwaysAnimate;//有的动作会飞出屏幕，所以需要这个
si.AnimatorB.applyRootMotion = false;
// si.AnimatorB.cullingMode = AnimatorCullingMode.AlwaysAnimate;
si.m_bindSound = instanceSkin.AddComponent <BindSound>();
si.m_bindEffect_A = instanceSkin.AddComponent <BindEffect>();
if (si.SkinObj_B)
{
si.m_bindEffect_B = si.SkinObj_B.AddComponent <BindEffect>();
}
else
{
si.m_bindEffect_B = instanceSkin.AddComponent <BindEffect>();
}
if (psc.weaponObject)
{
si.m_weaponAnimator = psc.weaponObject.GetComponent <Animator>();
}
if (psc.weaponObject2)
{
si.m_weaponAnimator2 = psc.weaponObject2.GetComponent <Animator>();
}
si.m_creatureProperty = SkinDataObj.GetComponent <CreatureProperty>();
si.m_sidekickEntity = SkinDataObj.GetComponent <SidekickEntity>();
if (si.sidekickEntity)
{
si.sidekickEntity.init();
}
si.m_ConfigScale = skin.fSkinScale;
si.m_PrefabScale = instanceSkin.transform.localScale;
if (psc.BodyNeedToBakeMesh)
{
SkinnedMeshRenderer smr = psc.BodyRender as SkinnedMeshRenderer;
BakeMeshNode nod = BakeMesh(smr);
if (null != nod)
{
skin.AllBakeMesh.Add(nod);
psc.BodyRender = MakeBakeMeshRender(smr, nod);
}
}
if (psc.RightWeaponNeedToBakeMesh)
{
SkinnedMeshRenderer smr = psc.RightWeaponRender as SkinnedMeshRenderer;
BakeMeshNode nod = BakeMesh(smr);
if (null != nod)
{
skin.AllBakeMesh.Add(nod);
psc.RightWeaponRender = MakeBakeMeshRender(smr, nod);
}
}
if (psc.LeftWeaponNeedToBakeMesh)
{
SkinnedMeshRenderer smr = psc.LeftWeaponRender as SkinnedMeshRenderer;
BakeMeshNode nod = BakeMesh(smr);
if (null != nod)
{
skin.AllBakeMesh.Add(nod);
psc.LeftWeaponRender = MakeBakeMeshRender(smr, nod);
}
}
if (psc.BackBodyNeedToBakeMesh)
{
SkinnedMeshRenderer smr = psc.BackBodyRender as SkinnedMeshRenderer;
BakeMeshNode nod = BakeMesh(smr);
if (null != nod)
{
skin.AllBakeMesh.Add(nod);
psc.BackBodyRender = MakeBakeMeshRender(smr, nod);
}
}
si.m_characterShadow = instanceSkin.AddComponent <CharacterShadow>();
si.m_characterShadow.Bake(instanceSkin.transform, psc.BodyRender);
si.m_characterShadow.Init(Initialize.mainCam);
//si.m_characterShadow.enabled = false;
si.m_switchEffectWithHeroDistance = SkinDataObj.GetComponent <Effect.SwitchEffectWithHeroDistance>();
si.m_playEntityStaticEffect = SkinDataObj.GetComponent <Effect.Effect_PlayEntityStaticEffect>();
si.SkinnedMeshRenderList.AddRange(instanceSkin.GetComponentsInChildren <SkinnedMeshRenderer>());
si.MeshRenderList.AddRange(instanceSkin.GetComponentsInChildren <MeshRenderer>());
foreach (SkinnedMeshRenderer skr in si.SkinnedMeshRenderList)
{
RenderVisibleHelper vb = skr.gameObject.AddComponent <RenderVisibleHelper>();
si.VisibleHelperList.Add(vb);
}
int length = si.SkinnedMeshRenderList.Count;
//移除skindataobj下的物体
for (int k = 0; k < length; k++)
{
si.SkinnedMeshRenderList[k].motionVectors = false;
si.SkinnedMeshRenderList[k].skinnedMotionVectors = false;
Transform t = si.SkinnedMeshRenderList[k].transform;
if (t.IsChildOf(SkinDataObj.transform))
{
si.SkinnedMeshRenderList.RemoveAt(k);
}
else
{
si.AllRenders.Add(si.SkinnedMeshRenderList[k]);
}
}
length = si.MeshRenderList.Count;
//移除skindataobj下的物体
for (int k = 0; k < length; k++)
{
si.MeshRenderList[k].motionVectors = false;
Transform t = si.MeshRenderList[k].transform;
if (t.IsChildOf(SkinDataObj.transform))
{
si.MeshRenderList.RemoveAt(k);
}
else
{
si.AllRenders.Add(si.MeshRenderList[k]);
}
}
if (si.playEntityStaticEffect)
{
si.playEntityStaticEffect.Init();
}
si.Init();
return;
}
public static bool SetChangeHeroSkin(int nSkinId, int nHeroId, ref SkinInstance objLastSkin, ref int nLastSkinId, Transform transHeroFrame, HEROSKIN_RENDER_TYPE renderType = HEROSKIN_RENDER_TYPE.SCENE, PERSONMODELVIEWID viewType = PERSONMODELVIEWID.PERSONMODELVIEWID_GAMEWAITINGROOM)
{
SkinManager.DeleteSkin(ref objLastSkin);
nLastSkinId = 0;
objLastSkin = null;
if (nSkinId < 0)
{
Debug.LogWarning("SetChangeHeroSkin---皮肤ID小于0");
return(false);
}
SkinInstance si = SkinManager.GetSkin(nSkinId);
if (si == null || !si.isValid)
{
Trace.LogWarning("切换皮肤失败，找不到对应的皮肤ID：" + nSkinId + "，请[--策划--]检查配置文件");
return(false);
}
GameObject goc = si.SkinObj;
// 动画
if (viewType == PERSONMODELVIEWID.PERSONMODELVIEWID_SHOP)
{
si.MainAnimator.Play("loginr");
}
//effectNodeHero.PlayEffect(0, null, null);
PersonModelTransFormInfo instance = PersonModelTransFormInfo.Instance;
Vector3 pos = instance.GetHeroModelPosition(viewType, nHeroId);
Vector3 scale = instance.GetHeroModelScale(viewType, nHeroId);
Vector3 rotation = instance.GetHeroModelRotation(viewType, nHeroId);
if (renderType == HEROSKIN_RENDER_TYPE.CAMERA)
{
GameUtil.SetLayer(LayerMask.NameToLayer(Config.LayerUI), goc, true);
Vector2 size = new Vector2(1280f, 720f);
UEffectMeshObject MeshObject = new UEffectMeshObject(si.SkinObj, pos, rotation, scale, _bIsSceneObj: true);
UEffectMeshCamera MeshCamera = new UEffectMeshCamera();
UEffectParamBase param = new UEffectMeshParam(size, new List <UEffectMeshObject>()
{
MeshObject
}, MeshCamera, transHeroFrame);
UEffectManager.Instance.CreateEffect(UEffectType.UET_EffectMesh, ref param);
}
else if (renderType == HEROSKIN_RENDER_TYPE.SCENE)
{
GameUtil.SetLayer(LayerMask.NameToLayer(Config.LayerHero), goc, true);
goc.transform.parent = transHeroFrame;
goc.transform.localPosition = pos;
goc.transform.localEulerAngles = rotation;
goc.transform.localScale = scale;
}
nLastSkinId = nSkinId;
objLastSkin = si;
return(true);
}
