Beispiel #1
0
 public void OnCache()
 {
     if (!isValid)
     {
         return;
     }
     foreach (SkinInstance go in AllSkin)
     {
         SkinManager.CacheSkinInstance(go);
     }
 }
Beispiel #2
0
        private static void OnRelateSkinLoadFinish(Skin sk)
        {
            if (!sk.isValid)
            {
                return;
            }
            SkinInstance go = sk.Instantiate_Main();

            if (go != null)
            {
                SkinManager.CacheSkinInstance(go);
            }
        }
Beispiel #3
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();
        }
Beispiel #4
0
    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 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 #7
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);
        }