Beispiel #1
0
 private static void UnLoadPKRelateSkin(int sourceSkin)
 {
     int[] nRelateSkinID = ASpeedGame.Data.PreLoadSkinLayout.PreLoadSkinLayout.Instance.GetRelateSkinID(sourceSkin);
     if (nRelateSkinID != null)
     {
         for (int j = 0; j < nRelateSkinID.Length; ++j)
         {
             if (nRelateSkinID[j] > 0)
             {
                 SkinManager.DeleteSkinAsync(nRelateSkinID[j], OnRelateSkinLoadFinish);
             }
         }
     }
 }
Beispiel #2
0
        private void CollectAsyncData()
        {
            SkinManager.CacheSkinInstance(m_currentLoadedSkinInstance);
            SkinManager.DeleteSkinAsync(currentSkinId, OnSkinLoadFinish);

            RemoveCallBack(currentSkinId);
            //没有加载完的,卸载掉
            if (m_ChangeSkinData.Count > 0)
            {
                foreach (int id in m_ChangeSkinData.Keys)
                {
                    SkinManager.DeleteSkinAsync(id, OnSkinLoadFinish);
                }
            }
            m_ChangeSkinData.Clear();
            m_currentLoadedSkinInstance = null;
            ClearAllocSkinControlAsyncLoadingObj();
        }
        public override void OnCull()
        {
            if (!SkinManager.enabledSkinCull)
            {
                return;
            }
            if (currentSkinId == InvalidSkinID)
            {
                return;
            }

            if (isCull)
            {
                return;
            }
            isCull = true;
            RemoveCallBack(currentSkinId);
            InvokeSkinCullEvent();
            int currentValidSkinID = InvalidSkinID;

            if (m_currentLoadedSkinInstance != null && m_currentLoadedSkinInstance.isValid)
            {
                currentValidSkinID = m_currentLoadedSkinInstance.nSkinID;
                SkinManager.CacheSkinInstance(m_currentLoadedSkinInstance);
                SkinManager.DeleteSkinAsync(currentValidSkinID, OnSkinLoadFinish, NotReleaseFromCache);

                m_currentLoadedSkinInstance = null;
            }

            if (currentValidSkinID != currentSkinId)
            {
                SkinManager.DeleteSkinAsync(currentSkinId, OnSkinLoadFinish, NotReleaseFromCache);
            }

            ClearPersonSkinDataFromMachine(m_machine);
        }
        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);
        }
Beispiel #5
0
        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);
        }