using Thousandto.Code.Logic;
using Thousandto.Core.Asset;
using Thousandto.Core.Base;
using System;
using System.Collections.Generic;
using UnityEngine;

namespace Thousandto.Code.Center
{
    /// <summary>
    /// 场景数据资源还原系统类
    /// </summary>
    public class SceneRestoreSystem
    {
        #region//私有变量
        //三个等级rowCol wide
        private int[] _rowCols = null;
        private int[] _cellWides = null;
        //玩家所在区域的index
        private int[] _playerIndexs = new int[(int)PartType.Count];

        private bool _isInit = false;
        private bool _enable = true;
        private bool _storyEnable = true;
        private bool _userMidleSetting = false;

        //雾效缩放距离
        private float _fogScaleFactor = 1f;

        private Vector2 _initPos = Vector2.zero;
        //点前地图的最小点坐标
        private Vector3 _min = Vector3.zero;
        //当前地图的最大点坐标
        private Vector3 _max = Vector3.zero;
        private ShowScenePartIndexs _partSequence = null;
        //index:0 地图的最小点  index:1 地图最大点
        private List<Vector3> _posList = new List<Vector3>();
        private Dictionary<int, List<Transform>> _transDic = new Dictionary<int, List<Transform>>();
        private Dictionary<int, List<int>> _typeDic = new Dictionary<int, List<int>>();

        //big 区域 所有物件trans
        private Dictionary<int, List<Transform>> _bigPartTransDic = new Dictionary<int, List<Transform>>();
        //midle 区域 所有物件trans
        private Dictionary<int, List<Transform>> _midPartTransDic = new Dictionary<int, List<Transform>>();
        //small 区域 所有物件trans
        private Dictionary<int, List<Transform>> _smallPartTransDic = new Dictionary<int, List<Transform>>();

        //big 区域 所有物件Type
        private Dictionary<int, List<int>> _bigPartTypeDic = new Dictionary<int, List<int>>();
        //mid 区域 所有物件Type
        private Dictionary<int, List<int>> _midPartTypeDic = new Dictionary<int, List<int>>();
        //small 区域 所有物件Type
        private Dictionary<int, List<int>> _smallPartTypeDic = new Dictionary<int, List<int>>();
        //缓存mid大小的物件
        private List<Transform> _cacheMidTrans = new List<Transform>();
        private List<int> _prevSmallPartIndexs = new List<int>(32);
        private List<int> _curSmallPartIndexs = new List<int>(32);

        private static Action<string, int,Transform, Action<Mesh,string>> _loadMesh = null;
        private static Action<string, Action<Mesh>> _loadParticeMesh = null;
        private static Action<string, Action<Texture>> _loadTexture = null;
        //sceneRestorePart代理类
        private SceneRestoreProxy _srProxy = null;
        //是否替换场景shader
        private bool _isReplaceSimpleShader = false;
        //是否替换场景半透明shader
        private bool _isReplaceBlendShader = false;
        //是否替换场景中简单的mesh
        private bool _isReplaceSimpleMesh = false;
        //透明shader名字数组
        //不带法线
        private string[] _blend_Names = {
            "Ares/Scene/Diffuse_AlphaBlend",
            "Ares/Scene/Diffuse_AlphaBlend_RGB",
            "Ares/Animation/AlphaScrollingTwoUV",
            "Ares/Animation/AlphaScrollingTwoUV_Add",
            "Ares/Animation/AlphaScrollingTwoUV_Add_RGB",
            "Ares/Animation/AlphaScrollingTwoUV_RGB",
            "Ares/Animation/AlphaScrollingUV",
            "Ares/Animation/AlphaScrollingUV_Add",
            "Ares/Animation/AlphaScrollingUV_Add_RGB",
            "Ares/Animation/AlphaScrollingUV_RGB",
            "Ares/Animation/Wind_UVA_Alpha",
            "Ares/Animation/Wind_UVA_Alpha_RGB",
        };
        private string _blend_Re_Name = "Ares/Scene/Diffuse";
        //带法线
        private string[] _blend_N_Names = {
            "Ares/Scene/Diffuse_AlphaBlend",
            "Ares/Scene/Diffuse_AlphaBlend_RGB",
        };
        private string _blend_Re_N_Name = "Ares/Scene/Diffuse_Normal";
        //替换cube
        private GameObject _replaceCube = null;

        //所有的ParticFar节点
        private List<Transform> _allParticFarList = new List<Transform>();
        //所有的FarRoot节点
        private List<Transform> _allFarNodeList = new List<Transform>();
        #endregion

        #region//const 常量
        private const int BIG_PART_KEY = 100000;
        private const int MID_PART_KEY = 200000;
        private const int SMALL_PART_KEY = 300000;
        #endregion

        #region//属性
        public Vector2 InitPos
        {
            get
            {
                return _initPos;
            }
            set
            {
                _initPos = value;
            }
        }
        public bool Enable
        {
            get
            {
                return _enable;
            }
            set
            {
                if (_enable != value)
                {
                    try
                    {
                        if (_transDic != null)
                        {  
                            var enumer = _transDic.GetEnumerator();
                            try
                            {
                                if (value)
                                {
                                    while (enumer.MoveNext())
                                    {
                                        for (int i = 0; i < enumer.Current.Value.Count; i++)
                                        {
                                            if (enumer.Current.Value[i] != null)
                                                enumer.Current.Value[i].gameObject.SetActive(!value);
                                        }
                                    }
                                }
                                else
                                {
                                    //高品质
                                    LocalPlayer lp = GameCenter.GameSceneSystem.GetLocalPlayer();
                                    if (lp != null)
                                    {
                                        InitDisableSetting(lp.Position);
                                    }
                                    SetVfxIn_MidleSmallPart(_playerIndexs[(int)PartType.Level_1], true);
                                }
                                
                            }
                            finally
                            {
                                enumer.Dispose();
                            }
                        }
                        if (_isInit)
                        {
                            for (int i = 0; i < _allParticFarList.Count; i++)
                            {
                                GameObject go = _allParticFarList[i].gameObject;
                                if (go && !go.activeSelf)
                                {
                                    go.SetActive(true);
                                }
                            }
                            for (int i = 0; i < _allFarNodeList.Count; i++)
                            {
                                GameObject go = _allFarNodeList[i].gameObject;
                                if (go && !go.activeSelf)
                                {
                                    go.SetActive(true);
                                }
                            }
                            SetBigPartShow();
                            SetMidlePartShow(_playerIndexs[(int)PartType.Level_1], true);
                            SetSmallPartShow(_playerIndexs[(int)PartType.Level_2], true);
                        }
                    }
                    catch (Exception e)
                    {
                        UnityEngine.Debug.LogError(string.Format("场景远景裁剪处理设置失败！！！！{0}", e));
                    }
                }
                _enable = value;
            }
        }

        public bool StoryEnable
        {
            get
            {
                return _storyEnable;
            }

            set
            {
                _storyEnable = value;
                if (!_storyEnable)
                {
                    if (_transDic != null)
                    {
                        var enumer = _transDic.GetEnumerator();
                        try
                        {
                            while (enumer.MoveNext())
                            {
                                for (int i = 0; i < enumer.Current.Value.Count; i++)
                                {
                                    if(enumer.Current.Value[i] != null && !enumer.Current.Value[i].gameObject.activeSelf)
                                        enumer.Current.Value[i].gameObject.SetActive(true);
                                }
                            }
                        }
                        finally
                        {
                            enumer.Dispose();
                        }
                    }
                }
            }
        }

        public Vector3 Min
        {
            get
            {
                return _min;
            }
        }

        public Vector3 Max
        {
            get
            {
                return _max;
            }
        }
        //雾效缩放因子
        public float FogScaleFactor
        {
            get
            {
                return _fogScaleFactor;
            }
        }
        public bool IsRePlaceSimpleShader
        {
            set
            {
                _isReplaceSimpleShader = value;
                if (value)
                {
                    RePlaceShader();
                }
            }
        }
        public bool IsReplaceBlendShader
        {
            set
            {
                _isReplaceBlendShader = value;
                if (value)
                {
                    RePlaceBlendShader();
                }
            }
        }
        public bool IsReplaceSimpleMesh
        {
            set
            {
                _isReplaceSimpleMesh = value;
                if (value)
                {
                    RePlaceSimpleMesh();
                }
            }
        }

        #endregion

        #region//回调函数
        //private void OnSettingChanged(object o, object sender = null)
        //{
        //    GameSettingKeyCode code = (GameSettingKeyCode)o;
        //    if (code == GameSettingKeyCode.QualityLevel)
        //    {
        //        int value = GameCenter.GameSetting.GetSetting(GameSettingKeyCode.QualityLevel);
        //        SetEnable(value);
        //    }
        //}
        #endregion

        #region//公共属性
        #endregion

        #region//私有函数
        private void LoadMesh(string path, int type, Transform trans, Action<Mesh,string> regMesh)
        {
            ResourcesEx.LoadAsync(path, AssetTypeCode.Mesh, (o, b, err) =>
            {
                if (o is Mesh)
                {
                    Mesh ms = o as Mesh;
                    switch (type)
                    {
                        case (int)SceneNodeRendererType.MeshRenderer:
                            {
                                MeshFilter mf = trans.GetComponent<MeshFilter>();
                                if (mf != null)
                                {
                                    mf.sharedMesh = ms;
                                }
                            }
                            break;
                        case (int)SceneNodeRendererType.SkinMesh:
                            {
                                SkinnedMeshRenderer skinRender = trans.GetComponent<SkinnedMeshRenderer>();
                                if (skinRender != null)
                                {
                                    skinRender.sharedMesh = ms;
                                }
                            }
                            break;
                    }
                    if (regMesh != null)
                    {
                        regMesh(ms, path);
                    }
                }

            }, AsyncActionType.LoadObject);
        }

        private void LoadParticeMesh(string path, Action<Mesh> action)
        {
            ResourcesEx.LoadAsync(path, AssetTypeCode.Mesh, (o, b, err) =>
            {
                if (o is Mesh)
                {
                    Mesh ms = o as Mesh;
                    if (action != null)
                    {
                        action(ms);
                    }
                }

            }, AsyncActionType.LoadObject);
        }

        private void LoadTexture(string path, Action<Texture> action)
        {
            TextureManager.SharedInstance.LoadTexture(path, (info) =>
            {
                if (action != null)
                {
                    action(info.AssetObject);
                }
            });
        }

        //设置各个层级格子的行列数
        private void SetPartRowCols(int standWide, ref int rowCol)
        {
            float wide = _max.x - _min.x;
            float celWide = wide / 1;
            SetRowCol(celWide, wide, standWide, ref rowCol);
        }

        private void SetRowCol(float celWide, float wide, float standWide, ref int rowCol)
        {
            if (celWide > standWide)
            {
                rowCol += 1;
                celWide = wide / rowCol;
                SetRowCol(celWide, wide, standWide, ref rowCol);
            }
        }

        //获取玩家所在格子的索引
        private int[] _playerCellCache = new int[(int)PartType.Count];
        private int[] GetPlayerCel(Vector3 pos)
        {
            for (int i = 0; i < (int)PartType.Count; i++)
            {
                int row = (int)Math.Floor((pos.z - _min.y) / (_max.y - _min.y) * _rowCols[i]);
                int col = (int)Math.Floor((pos.x - _min.x) / (_max.x - _min.x) * _rowCols[i]);
                int cel = row * _rowCols[i] + col;
                _playerCellCache[i] = cel;
            }
            return _playerCellCache;
        }

        //设置大格子包含的小格子序号
        private Dictionary<int, int> GetSmallCellRangeByBigIndex(int cellId)
        {
            Dictionary<int, int> ret = new Dictionary<int, int>();
            _partSequence.ResetNineCel(cellId, _rowCols[(int)PartType.Level_0]);
            var enumer = _partSequence.DicIndexs.GetEnumerator();
            try
            {
                while (enumer.MoveNext())
                {
                    for (int m = 0; m < enumer.Current.Value.Count; m++)
                    {
                        int index = enumer.Current.Value[m];
                        int cr = _rowCols[(int)PartType.Level_0];
                        int num = cr * 9;
                        int row = index / cr;
                        int col = index % cr;
                        int min = row * 9 * num + col * 9;
                        int max = (row + 1) * 9 * num -  num + col * 9 + 9;
                        for (int i = min; i < max; i++)
                        {
                            int sRow = i / num;
                            int sCol = i % num;
                            //计算当前行的起始值
                            int sMax = sRow * num + col * 9 + 9 - 1;
                            int sMin = sMax - 9;
                            if (i > sMin && i <= sMax)
                            {
                                ret.Add(i, 1);
                            }
                        }
                    }
                }
            }
            finally
            {
                enumer.Dispose();
            }
            return ret;
        }

        //区分物件属于哪个区域
        private void DiferencePartTrans()
        {
            var enumer = _transDic.GetEnumerator();
            try
            {
                while (enumer.MoveNext())
                {
                    int key = enumer.Current.Key;
                    for (int i = 0; i < enumer.Current.Value.Count; i++)
                    {
                        int count = enumer.Current.Value.Count;
                        Transform trans = enumer.Current.Value[i];
                        if (key >= BIG_PART_KEY && key< MID_PART_KEY)
                        {
                            AddPartTrans(key, BIG_PART_KEY, trans, _bigPartTransDic, count);
                        }
                        else if (key >= MID_PART_KEY && key < SMALL_PART_KEY)
                        {
                            AddPartTrans(key, MID_PART_KEY, trans, _midPartTransDic, count);
                        }
                        else if (key >= SMALL_PART_KEY)
                        {
                            AddPartTrans(key, SMALL_PART_KEY, trans, _smallPartTransDic, count);
                        }
                    }
                }
            }
            finally
            {
                enumer.Dispose();
            }
        }
        //区分物件type所属区域
        private void DiferencePartTransType()
        {
            var enumer = _typeDic.GetEnumerator();
            try
            {
                while (enumer.MoveNext())
                {
                    int key = enumer.Current.Key;
                    for (int i = 0; i < enumer.Current.Value.Count; i++)
                    {
                        int count = enumer.Current.Value.Count;
                        int type = enumer.Current.Value[i];
                        if (key >= BIG_PART_KEY && key<MID_PART_KEY)
                        {
                            AddPartType(key, BIG_PART_KEY, type, _bigPartTypeDic, count, _bigPartTransDic);
                        }
                        else if (key >= MID_PART_KEY && key < SMALL_PART_KEY)
                        {
                            AddPartType(key, MID_PART_KEY, type, _midPartTypeDic, count, _midPartTransDic);
                        }
                        else if (key >= SMALL_PART_KEY)
                        {
                            AddPartType(key, SMALL_PART_KEY, type, _smallPartTypeDic, count, _smallPartTransDic);
                        }
                    }
                }
            }
            finally
            {
                enumer.Dispose();

            }
        }
        private void AddPartTrans(int index, int partKey, Transform trans, Dictionary<int,List<Transform>> dic, int count)
        {
            int key = index % partKey;
            List<Transform> list = dic.TryGetValue(key,out list) ? list:null;
            if (list != null)
            {
                list.Add(trans);
            }
            else
            {
                list = new List<Transform>(count);
                list.Add(trans);
                dic.Add(key, list);
            }
        }
        private void AddPartType(int index, int partKey, int type, Dictionary<int, List<int>> dic, int count, Dictionary<int , List<Transform>> transDic)
        {
            int key = index % partKey;
            List<int> list = dic.TryGetValue(key,out list)? list:null;
            if (list!= null)
            {
                list.Add(type);
            }
            else
            {
                list = new List<int>(count);
                list.Add(type);
                dic.Add(key, list);
            }
            if (type == (int)NodeRootType.ParticFar && transDic.ContainsKey(key))
            {
                List<Transform> transList = transDic[key];
                if (transList != null && list.Count <= transList.Count)
                {
                    Transform trans = transList[list.Count - 1];
                    if (trans && !trans.gameObject.activeSelf)
                    {
                        trans.gameObject.SetActive(true);
                        _allParticFarList.Add(trans);
                    }
                }
            }
            else if (type == (int)NodeRootType.FarRoot && transDic.ContainsKey(key))
            {
                List<Transform> transList = transDic[key];
                if (transList != null && list.Count <= transList.Count)
                {
                    Transform trans = transList[list.Count - 1];
                    if (trans && !trans.gameObject.activeSelf)
                    {
                        trans.gameObject.SetActive(true);
                        _allFarNodeList.Add(trans);
                    }
                }
            }
        }

        //高画质设置
        private void InitDisableSetting(Vector3 pos)
        {
            var enumerSmall = _smallPartTransDic.GetEnumerator();
            try
            {
                while (enumerSmall.MoveNext())
                {
                    List<Transform> listTrans = _smallPartTransDic[enumerSmall.Current.Key];
                    List<int> typeList = _smallPartTypeDic[enumerSmall.Current.Key];
                    for (int i = 0; i < listTrans.Count; i++)
                    {
                        var trans = listTrans[i];
                        if (trans)
                        {
                            if (typeList[i] == (int)NodeRootType.ParticMidle || typeList[i] == (int)NodeRootType.ParticNear)
                            {
                                SetVisable(false, trans);
                            }
                            else
                            {
                                SetVisable(true, trans);
                            }
                        }
                    }
                }
            }
            finally
            {
                enumerSmall.Dispose();
            }

            var enumerMid = _midPartTransDic.GetEnumerator();
            try
            {
                while (enumerMid.MoveNext())
                {
                    List<Transform> listTrans = _midPartTransDic[enumerMid.Current.Key];
                    List<int> typeList = _midPartTypeDic[enumerMid.Current.Key];
                    for (int i = 0; i < listTrans.Count; i++)
                    {
                        var trans = listTrans[i];
                        if (trans)
                        {
                            if (typeList[i] == (int)NodeRootType.ParticMidle || typeList[i] == (int)NodeRootType.ParticNear)
                            {
                                SetVisable(false, trans);
                            }
                            else
                            {
                                SetVisable(true, trans);
                            }
                        }
                    }
                }
            }
            finally
            {
                enumerMid.Dispose();
            }


            //设置bigPart
            var enumerBig = _bigPartTransDic.GetEnumerator();
            try
            {
                while (enumerBig.MoveNext())
                {
                    List<Transform> listTrans = _bigPartTransDic[enumerBig.Current.Key];
                    List<int> typeList = _bigPartTypeDic[enumerBig.Current.Key];
                    //只显示物件不显示mid mear 特效
                    for (int m = 0; m < listTrans.Count; m++)
                    {
                        Transform trans = listTrans[m];
                        if (trans)
                        {
                            if (typeList[m] == (int)NodeRootType.ParticMidle || typeList[m] == (int)NodeRootType.ParticNear)
                            {
                                SetVisable(false, trans);
                            }
                            else
                            {
                                SetVisable(true, trans);
                            }
                        }
                    }
                }
            }
            finally
            {
                enumerBig.Dispose();
            }
        }

        //高画质设置
        private void InitEnableSetting(Vector3 pos)
        {
            var enumerSmall = _smallPartTransDic.GetEnumerator();
            try
            {
                while (enumerSmall.MoveNext())
                {
                    List<Transform> listTrans = _smallPartTransDic[enumerSmall.Current.Key];
                    List<int> typeList = _smallPartTypeDic[enumerSmall.Current.Key];
                    for (int i = 0; i < listTrans.Count; i++)
                    {
                        var trans = listTrans[i];
                        if (trans)
                        {
                            if (typeList[i] == (int)NodeRootType.ParticFar)
                            {
                                SetVisable(true, trans);
                            }
                        }
                    }
                }
            }
            finally
            {
                enumerSmall.Dispose();
            }

            var enumerMid = _midPartTransDic.GetEnumerator();
            try
            {
                while (enumerMid.MoveNext())
                {
                    List<Transform> listTrans = _midPartTransDic[enumerMid.Current.Key];
                    List<int> typeList = _midPartTypeDic[enumerMid.Current.Key];
                    for (int i = 0; i < listTrans.Count; i++)
                    {
                        var trans = listTrans[i];
                        if (trans)
                        {
                            if (typeList[i] == (int)NodeRootType.ParticFar)
                            {
                                SetVisable(true, trans);
                            }
                        }
                    }
                }
            }
            finally
            {
                enumerMid.Dispose();
            }


            //设置bigPart
            var enumerBig = _bigPartTransDic.GetEnumerator();
            try
            {
                while (enumerBig.MoveNext())
                {
                    List<Transform> listTrans = _bigPartTransDic[enumerBig.Current.Key];
                    List<int> typeList = _bigPartTypeDic[enumerBig.Current.Key];
                    //只显示物件不显示mid mear 特效
                    for (int m = 0; m < listTrans.Count; m++)
                    {
                        Transform trans = listTrans[m];
                        if (trans)
                        {
                            if (typeList[m] == (int)NodeRootType.ParticFar)
                            {
                                SetVisable(false, trans);
                            }
                        }
                    }
                }
            }
            finally
            {
                enumerBig.Dispose();
            }
        }

        //设置 90 乘以 90 格子显示
        private void SetBigPartShow()
        {
            var enumer = _bigPartTransDic.GetEnumerator();
            try
            {
                while (enumer.MoveNext())
                {
                    for (int i = 0; i < enumer.Current.Value.Count; i++)
                    {
                        var trans = enumer.Current.Value[i];
                        if (trans && !trans.gameObject.activeSelf)
                            trans.gameObject.SetActive(true);
                    }
                }
            }
            finally
            {
                enumer.Dispose();
            }
        }
        //设置30 乘以 30 九宫格显示  以玩家所在格子为中心的九宫格内除了 near 层的 物件都显示出来
        private void SetMidlePartShow(int playerCell, bool visable = true)
        {
            if (_rowCols != null && _rowCols[(int)PartType.Level_1] != 0)
            {
                _partSequence.ResetNineCel(playerCell, _rowCols[(int)PartType.Level_1]);
            }
            var enumer = _partSequence.DicIndexs.GetEnumerator();
            try
            {
                while (enumer.MoveNext())
                {
                    for (int i = 0; i < enumer.Current.Value.Count; i++)
                    {
                        int index = enumer.Current.Value[i];
                        if (_midPartTransDic.ContainsKey(index) && _midPartTypeDic.ContainsKey(index))
                        {
                            List<Transform> listTrans = _midPartTransDic[index];
                            List<int> typeList = _midPartTypeDic[index];
                            for (int m = 0; m < listTrans.Count; m++)
                            {
                                Transform trans = listTrans[m];
                                if (typeList[m] == (int)NodeRootType.FarRoot || typeList[m] == (int)NodeRootType.ParticFar)
                                {

                                    if (trans)
                                    {
                                        if (!trans.gameObject.activeSelf)
                                        {
                                            trans.gameObject.SetActive(true);
                                        }

                                    }
                                }
                                if (trans)
                                    SetVisable(visable, trans);
                            }
                        }

                        ShowScenePartIndexs partsIndex = new ShowScenePartIndexs();
                        int row = index / _rowCols[(int)PartType.Level_1];
                        int col = index % _rowCols[(int)PartType.Level_1];
                        row = row * 3 + 1;
                        col = col * 3 + 1;
                        int cel = row * _rowCols[(int)PartType.Level_2] + col;
                        if (_rowCols != null && _rowCols[(int)PartType.Level_2] != 0)
                        {
                            partsIndex.ResetNineCel(cel, _rowCols[(int)PartType.Level_2]);
                        }
                        var enum_small = partsIndex.DicIndexs.GetEnumerator();
                        try
                        {
                            while (enum_small.MoveNext())
                            {
                                int smallIndex = enum_small.Current.Value[i];
                                if (_smallPartTransDic.ContainsKey(smallIndex) && _smallPartTypeDic.ContainsKey(smallIndex))
                                {
                                    List<Transform> listTrans = _smallPartTransDic[smallIndex];
                                    List<int> typeList = _smallPartTypeDic[smallIndex];
                                    for (int m = 0; m < listTrans.Count; m++)
                                    {
                                        Transform trans = listTrans[m];
                                        if (typeList[m] == (int)NodeRootType.FarRoot || typeList[m] == (int)NodeRootType.ParticFar)
                                        {
                                            if (trans)
                                            {
                                                if (!trans.gameObject.activeSelf)
                                                {
                                                    trans.gameObject.SetActive(true);
                                                }

                                            }
                                        }
                                        //如果使用中品质
                                        if (_userMidleSetting)
                                        {
                                            //显示mid和near 物件
                                            if (trans)
                                                SetVisable(visable, trans);
                                        }
                                        else
                                        {
                                            //显示mid 物件
                                            if (trans && typeList[m] == (int)NodeRootType.MidleRoot)
                                                SetVisable(visable, trans);
                                        }
                                    }
                                }
                            }
                        }
                        finally
                        {
                            enum_small.Dispose();
                        }
                    }
                }
            }
            finally
            {
                enumer.Dispose();
            }
        }
        //隐藏mid格子中的small格子的物件
        private void SetTransIn_MidleSmallPart(int playerCell, bool visable)
        {
            if (_rowCols != null && _rowCols[(int)PartType.Level_1] != 0)
            {
                _partSequence.ResetNineCel(playerCell, _rowCols[(int)PartType.Level_1]);
            }
            var enumer = _partSequence.DicIndexs.GetEnumerator();
            try
            {
                while (enumer.MoveNext())
                {
                    for (int i = 0; i < enumer.Current.Value.Count; i++)
                    {
                        int index = enumer.Current.Value[i];
                        ShowScenePartIndexs partsIndex = new ShowScenePartIndexs();
                        int row = index / _rowCols[(int)PartType.Level_1];
                        int col = index % _rowCols[(int)PartType.Level_1];
                        row = row * 3 + 1;
                        col = col * 3 + 1;
                        int cel = row * _rowCols[(int)PartType.Level_2] + col;
                        if (_rowCols != null && _rowCols[(int)PartType.Level_2] != 0)
                        {
                            partsIndex.ResetNineCel(cel, _rowCols[(int)PartType.Level_2]);
                        }
                        var enum_small = partsIndex.DicIndexs.GetEnumerator();
                        while (enum_small.MoveNext())
                        {
                            int smallIndex = enum_small.Current.Value[i];
                            if (_smallPartTransDic.ContainsKey(smallIndex) && _smallPartTypeDic.ContainsKey(smallIndex))
                            {
                                List<Transform> listTrans = _smallPartTransDic[smallIndex];
                                List<int> typeList = _smallPartTypeDic[smallIndex];
                                for (int m = 0; m < listTrans.Count; m++)
                                {
                                    if (typeList[m] == (int)NodeRootType.FarRoot || typeList[m] == (int)NodeRootType.ParticFar)
                                    {
                                        if (listTrans[m])
                                            continue;
                                    }
                                    if (listTrans[m])
                                    {
                                        SetVisable(visable, listTrans[m]);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            finally
            {
                enumer.Dispose();
            }
        }

        //隐藏mid格子中的small格子的物件
        private void SetVfxIn_MidleSmallPart(int playerCell, bool visable)
        {
            if (_partSequence == null)
                return;
            if (_rowCols != null && _rowCols[(int)PartType.Level_1] != 0)
            {
                _partSequence.ResetNineCel(playerCell, _rowCols[(int)PartType.Level_1]);
            }
            var enumer = _partSequence.DicIndexs.GetEnumerator();
            try
            {
                while (enumer.MoveNext())
                {
                    for (int i = 0; i < enumer.Current.Value.Count; i++)
                    {
                        int index = enumer.Current.Value[i];
                        if (_midPartTransDic.ContainsKey(index))
                        {
                            List<Transform> midListTrans = _midPartTransDic[index];
                            List<int> midTypeList = _midPartTypeDic[index];
                            for (int k = 0; k < midListTrans.Count; k++)
                            {
                                if (midTypeList[k] == (int)NodeRootType.ParticMidle || midTypeList[k] == (int)NodeRootType.ParticNear)
                                {
                                    SetVisable(visable, midListTrans[k]);
                                }
                            }
                        }

                        ShowScenePartIndexs partsIndex = new ShowScenePartIndexs();
                        int row = 0;
                        int col = 0;
                        if (_rowCols[(int)PartType.Level_1] != 0)
                        {
                            row = index / _rowCols[(int)PartType.Level_1];
                            col = index % _rowCols[(int)PartType.Level_1];
                        }
                        row = row * 3 + 1;
                        col = col * 3 + 1;
                        int cel = row * _rowCols[(int)PartType.Level_2] + col;
                        if (_rowCols != null && _rowCols[(int)PartType.Level_2] != 0)
                        {
                            partsIndex.ResetNineCel(cel, _rowCols[(int)PartType.Level_2]);
                        }
                        var enum_small = partsIndex.DicIndexs.GetEnumerator();
                        while (enum_small.MoveNext())
                        {
                            int smallIndex = enum_small.Current.Value[i];
                            if (_smallPartTransDic.ContainsKey(smallIndex) && _smallPartTypeDic.ContainsKey(smallIndex))
                            {
                                List<Transform> listTrans = _smallPartTransDic[smallIndex];
                                List<int> typeList = _smallPartTypeDic[smallIndex];
                                for (int m = 0; m < listTrans.Count; m++)
                                {
                                    if (typeList[m] == (int)NodeRootType.ParticMidle || typeList[m] == (int)NodeRootType.ParticNear)
                                    {
                                        if (listTrans[m])
                                        {
                                            SetVisable(visable, listTrans[m]);
                                        }
                                    }
                                   
                                }
                            }
                        }
                    }
                }
            }
            finally
            {
                enumer.Dispose();
            }
        }

        private void HideOverPart(int prevPlayerCell, int curPlayerCell, PartType partType,Dictionary<int,List<Transform>> partIndexs, Dictionary<int,List<int>> partTypes)
        {
            _prevSmallPartIndexs.Clear();
            _curSmallPartIndexs.Clear();
            if (_rowCols != null && _rowCols[(int)partType] != 0)
            {
                _partSequence.ResetNineCel(prevPlayerCell, _rowCols[(int)partType]);
            }
            var enumer1 = _partSequence.DicIndexs.GetEnumerator();
            try
            {
                while (enumer1.MoveNext())
                {
                    for (int i = 0; i < enumer1.Current.Value.Count; i++)
                    {
                        int index1 = enumer1.Current.Value[i];
                        _prevSmallPartIndexs.Add(index1);
                    }
                }
            }
            finally
            {
                enumer1.Dispose();
            }
            if (_rowCols != null && _rowCols[(int)partType] != 0)
            {
                _partSequence.ResetNineCel(curPlayerCell, _rowCols[(int)partType]);
            }
            var enumer2 = _partSequence.DicIndexs.GetEnumerator();
            try
            {
                while (enumer2.MoveNext())
                {
                    for (int m = 0; m < enumer2.Current.Value.Count; m++)
                    {
                        int index2 = enumer2.Current.Value[m];
                        _curSmallPartIndexs.Add(index2);
                    }
                }
            }
            finally
            {
                enumer2.Dispose();
            }
            for (int i = 0; i < _prevSmallPartIndexs.Count; i++)
            {
                bool isFind = false;
                for (int m = 0; m < _curSmallPartIndexs.Count; m++)
                {
                    if (_prevSmallPartIndexs[i] == _curSmallPartIndexs[m])
                    {
                        isFind = true;
                    }
                }
                if (!isFind)
                {
                    var index = _prevSmallPartIndexs[i];
                    if (partIndexs.ContainsKey(index) && partIndexs.ContainsKey(index))
                    {
                        List<Transform> listTrans = partIndexs[index];
                        List<int> typeList = partTypes[index];
                        for (int m = 0; m < listTrans.Count; m++)
                        {
                            if (listTrans[m])
                            {
                                if (partType == PartType.Level_2)
                                {
                                    if (typeList[m] == (int)NodeRootType.MidleRoot
                                    || typeList[m] == (int)NodeRootType.ParticMidle
                                    || typeList[m] == (int)NodeRootType.FarRoot
                                    || typeList[m] == (int)NodeRootType.ParticFar)
                                    {
                                        continue;
                                    }
                                    else
                                    {
                                        SetVisable(false, listTrans[m]);
                                    }
                                }
                                else
                                {
                                    if (typeList[m] == (int)NodeRootType.FarRoot
                                     || typeList[m] == (int)NodeRootType.ParticFar)
                                    {
                                        continue;
                                    }
                                    else
                                    {
                                        SetVisable(false, listTrans[m]);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        //设置10 乘以 10 九宫格显示 以玩家所在格子为中心的九宫格内的所有 near层的物件都显示出来 其他物件都隐藏
        private void SetSmallPartShow(int playerCell,bool visable = true)
        {
            if (_rowCols != null && _rowCols[(int)PartType.Level_2] != 0)
            {
                _partSequence.ResetNineCel(playerCell, _rowCols[(int)PartType.Level_2]);
            }
            var enumer = _partSequence.DicIndexs.GetEnumerator();
            try
            {
                while (enumer.MoveNext())
                {
                    for (int i = 0; i < enumer.Current.Value.Count; i++)
                    {
                        int index = enumer.Current.Value[i];
                        if (_smallPartTransDic.ContainsKey(index) && _smallPartTypeDic.ContainsKey(index))
                        {
                            List<Transform> listTrans = _smallPartTransDic[index];
                            List<int> typeList = _smallPartTypeDic[index];
                            for (int m = 0; m < listTrans.Count; m++)
                            {
                                if (listTrans[m])
                                {
                                    if (typeList[m] == (int)NodeRootType.ParticNearHide)
                                    {
                                        if (visable)
                                            continue;
                                    }
                                    else
                                    {
                                        if (!visable)
                                        {
                                            if (typeList[m] == (int)NodeRootType.MidleRoot
                                            || typeList[m] == (int)NodeRootType.ParticMidle
                                            || typeList[m] == (int)NodeRootType.FarRoot
                                            || typeList[m] == (int)NodeRootType.ParticFar)
                                            {
                                                if (typeList[m] == (int)NodeRootType.MidleRoot
                                                || typeList[m] == (int)NodeRootType.ParticMidle)
                                                {
                                                    _cacheMidTrans.Add(listTrans[m]);
                                                }
                                                continue;
                                            }
                                            else
                                            {
                                                SetVisable(visable, listTrans[m]);
                                            }
                                        }
                                        else
                                        {
                                            SetVisable(visable, listTrans[m]);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            finally
            {
                enumer.Dispose();
            }
        }

        private void SetSmallPartMidHide(int playerCell)
        {
            if (_rowCols != null && _rowCols[(int)PartType.Level_2] != 0)
            {
                _partSequence.ResetNineCel(playerCell, _rowCols[(int)PartType.Level_2]);
            }
            var enumer = _partSequence.DicIndexs.GetEnumerator();
            try
            {
                while (enumer.MoveNext())
                {
                    for (int i = 0; i < enumer.Current.Value.Count; i++)
                    {
                        int index = enumer.Current.Value[i];
                        if (_smallPartTransDic.ContainsKey(index) && _smallPartTypeDic.ContainsKey(index))
                        {
                            List<Transform> listTrans = _smallPartTransDic[index];
                            List<int> typeList = _smallPartTypeDic[index];
                            for (int m = 0; m < listTrans.Count; m++)
                            {
                                if (listTrans[m])
                                {
                                    for (int k = _cacheMidTrans.Count - 1; k >= 0; k--)
                                    {
                                        if (_cacheMidTrans[k] == listTrans[m])
                                        {
                                            _cacheMidTrans.RemoveAt(k);
                                        }
                                    }
                                }
                            }
                            for (int m = _cacheMidTrans.Count - 1; m >= 0; m--)
                            {
                                _cacheMidTrans[m].gameObject.SetActive(false);
                                _cacheMidTrans.RemoveAt(m);
                            }
                            _cacheMidTrans.Clear();
                        }
                    }
                }
            }
            finally
            {
                enumer.Dispose();
            }
        }
        private void SetVisable(bool visable, Transform trans)
        {
            //if (!GameCenter.SceneOcSystem.IsLoadFinish)
            //{
            //    trans.gameObject.SetActive(visable);
            //    return;
            //}
            //if (visable)
            //{
            //    if (CheckOcVisable(trans))
            //    {
            //        trans.gameObject.SetActive(true);
            //        return;
            //    }
            //}
            //trans.gameObject.SetActive(false);
            if (trans.gameObject.activeSelf != visable)
            {
                trans.gameObject.SetActive(visable);
            }
        }
        private bool CheckOcVisable(Transform trans)
        {
            return GameCenter.SceneOcSystem.CheckOc(trans);
        }

        //替换简单shader
        private void RePlaceShader()
        {
            var enumer = _transDic.GetEnumerator();
            try
            {
                while (enumer.MoveNext())
                {
                    for (int i = 0; i < enumer.Current.Value.Count; i++)
                    {
                        Transform trans = enumer.Current.Value[i];
                        Renderer rd = trans.GetComponent<Renderer>();
                        Shader sh = Shader.Find("Gonbest/FallBack/FBWithSimpleShader");
                        Material mat = new Material(sh);
                        rd.sharedMaterial = mat;
                    }
                }
            }
            finally
            {
                enumer.Dispose();
            }
        }

        //替换半透明shader
        private void RePlaceBlendShader()
        {
            var enumer = _transDic.GetEnumerator();
            try
            {
                while (enumer.MoveNext())
                {
                    for (int i = 0; i < enumer.Current.Value.Count; i++)
                    {
                        Transform trans = enumer.Current.Value[i];
                        Renderer rd = trans.GetComponent<Renderer>();
                        for (int m = 0; m < _blend_Names.Length; m++)
                        {
                            Shader sh = Shader.Find(_blend_Re_Name);
                            Material mat = new Material(sh);
                            rd.sharedMaterial = mat;
                        }
                        for (int m = 0; m < _blend_N_Names.Length; m++)
                        {
                            Shader sh = Shader.Find(_blend_Re_N_Name);
                            Material mat = new Material(sh);
                            rd.sharedMaterial = mat;
                        }
                    }
                }
            }
            finally
            {
                enumer.Dispose();
            }
        }

        //替换简单mesh
        private void RePlaceSimpleMesh()
        {
            if (_replaceCube == null)
            {
                _replaceCube = CreateCube();
            }
            if (_replaceCube)
            {
                _replaceCube.gameObject.SetActive(false);
                MeshFilter cubeMf = _replaceCube.GetComponent<MeshFilter>();
                Mesh cubMesh = cubeMf == null ? null : cubeMf.sharedMesh;
                if (cubMesh)
                {
                    var enumer = _transDic.GetEnumerator();
                    try
                    {
                        while (enumer.MoveNext())
                        {
                            for (int i = 0; i < enumer.Current.Value.Count; i++)
                            {
                                Transform trans = enumer.Current.Value[i];
                                MeshFilter mf = trans.GetComponent<MeshFilter>();
                                if (mf)
                                {
                                    mf.sharedMesh = cubMesh;
                                }
                            }
                        }
                    }
                    finally
                    {
                        enumer.Dispose();
                    }
                }
            }
        }

        //创建cube
        private GameObject CreateCube()
        {
            GameObject cube = new GameObject("cube");
            MeshFilter mf = cube.AddComponent<MeshFilter>();
            MeshRenderer mr = cube.AddComponent<MeshRenderer>();


            Vector3[] vertices = new Vector3[24];
            int[] triangles = new int[36];

            //forward
            vertices[0].Set(0.5f, -0.5f, 0.5f);
            vertices[1].Set(-0.5f, -0.5f, 0.5f);
            vertices[2].Set(0.5f, 0.5f, 0.5f);
            vertices[3].Set(-0.5f, 0.5f, 0.5f);
            //back
            vertices[4].Set(vertices[2].x, vertices[2].y, -0.5f);
            vertices[5].Set(vertices[3].x, vertices[3].y, -0.5f);
            vertices[6].Set(vertices[0].x, vertices[0].y, -0.5f);
            vertices[7].Set(vertices[1].x, vertices[1].y, -0.5f);
            //up
            vertices[8] = vertices[2];
            vertices[9] = vertices[3];
            vertices[10] = vertices[4];
            vertices[11] = vertices[5];
            //down
            vertices[12].Set(vertices[10].x, -0.5f, vertices[10].z);
            vertices[13].Set(vertices[11].x, -0.5f, vertices[11].z);
            vertices[14].Set(vertices[8].x, -0.5f, vertices[8].z);
            vertices[15].Set(vertices[9].x, -0.5f, vertices[9].z);
            //right
            vertices[16] = vertices[6];
            vertices[17] = vertices[0];
            vertices[18] = vertices[4];
            vertices[19] = vertices[2];
            //left
            vertices[20].Set(-0.5f, vertices[18].y, vertices[18].z);
            vertices[21].Set(-0.5f, vertices[19].y, vertices[19].z);
            vertices[22].Set(-0.5f, vertices[16].y, vertices[16].z);
            vertices[23].Set(-0.5f, vertices[17].y, vertices[17].z);

            int currentCount = 0;
            for (int i = 0; i < 24; i = i + 4)
            {
                triangles[currentCount++] = i;
                triangles[currentCount++] = i + 3;
                triangles[currentCount++] = i + 1;

                triangles[currentCount++] = i;
                triangles[currentCount++] = i + 2;
                triangles[currentCount++] = i + 3;

            }

            mf.mesh.vertices = vertices;
            mf.mesh.triangles = triangles;
            return cube;
        }
        #endregion

        #region//公共函数
        public void Initialize()
        {
            //GameCenter.EventManager.UnRegFixEventHandle(CoreEventDefine.EID_CORE_GAME_SETTING_CHANGED, OnSettingChanged);
            //GameCenter.EventManager.RegFixEventHandle(CoreEventDefine.EID_CORE_GAME_SETTING_CHANGED, OnSettingChanged);
        }
        public void Uninitialize()
        {
            //GameCenter.EventManager.UnRegFixEventHandle(CoreEventDefine.EID_CORE_GAME_SETTING_CHANGED, OnSettingChanged);
        }
        public void InitSceneData(GameObject sceneRoot, Vector2? position = null)
        {
            UnInitSceneData();
            if (sceneRoot == null)
                return;
            _rowCols = new int[(int)PartType.Count];
            for (int i = 0; i < _rowCols.Length; i++)
            {
                _rowCols[i] = 0;
            }
            _cellWides = new int[(int)PartType.Count];
            _cellWides[0] = 90;
            _cellWides[1] = 30;
            _cellWides[2] = 10;

            _loadMesh = LoadMesh;
            _loadParticeMesh = LoadParticeMesh;
            _loadTexture = LoadTexture;
            try
            {
                Vector3 pos = new Vector3(position.Value.x, 0, position.Value.y);
                _srProxy = new SceneRestoreProxy(sceneRoot, _loadMesh, _loadTexture, _loadParticeMesh, _posList, _transDic, _typeDic, pos);
                if (_posList != null && _posList.Count >= 2)
                {
                    _min = _posList[0];
                    _max = _posList[1];
                    for (int i = 0; i < (int)PartType.Count; i++)
                    {
                        SetPartRowCols(_cellWides[i], ref _rowCols[i]);
                    }
                    var array = GetPlayerCel(pos);
                    for (int i = 0; i < _playerIndexs.Length; ++i)
                    {
                        _playerIndexs[i] = array[i];
                    }
                    DiferencePartTrans();
                    DiferencePartTransType();
                    if (_partSequence == null)
                    {
                        _partSequence = new ShowScenePartIndexs();
                    }
                    if (_enable)
                    {
                        SetBigPartShow();
                        SetMidlePartShow(_playerIndexs[(int)PartType.Level_1], true);
                        SetSmallPartShow(_playerIndexs[(int)PartType.Level_2], true);
                    }
                    else
                    {
                        //高品质
                        InitDisableSetting(pos);
                        SetVfxIn_MidleSmallPart(_playerIndexs[(int)PartType.Level_1], true);
                    }
                    if (_isReplaceSimpleShader)
                    {
                        RePlaceShader();
                    }
                    if (_isReplaceBlendShader)
                    {
                        RePlaceBlendShader();
                    }
                    if (_isReplaceSimpleMesh)
                    {
                        RePlaceSimpleMesh();
                    }
                    _isInit = true;
                }
                
            }
            catch (Exception e)
            {
                UnityEngine.Debug.LogError(string.Format("加载地图远近处理数据失败!!!!{0}", e));
            }
        }
        public void UnInitSceneData()
        {
            _posList.Clear();
            _transDic.Clear();
            _typeDic.Clear();
            _smallPartTransDic.Clear();
            _midPartTransDic.Clear();
            _bigPartTransDic.Clear();
            _smallPartTypeDic.Clear();
            _midPartTypeDic.Clear();
            _bigPartTypeDic.Clear();
            _allParticFarList.Clear();
            _allFarNodeList.Clear();
        }
        public void RestoryLeftParts()
        {
            //if (!_enable)
            //    return;
            if (_srProxy!=null) _srProxy.RestoryLeftParts();
            //加载场景遮挡剔除数据
            //GameCenter.SceneOcSystem.LoadParam();
        }
        public void ClearCache()
        {
            _transDic.Clear();
            _cacheMidTrans.Clear();
            _isInit = false;
        }
        public void Update()
        {
            if (!_isInit)
                return;
            if (!_storyEnable)
                return;
            if (!_enable)
            {
                ////高品质
                //LocalPlayer lp = GameCenter.GameSceneSystem.GetLocalPlayer();
                //if (lp != null)
                //{
                //    int[] cells = GetPlayerCel(lp.Position);
                //    if (cells[(int)PartType.Level_0] != _playerIndexs[(int)PartType.Level_0])
                //    {
                //        //如果玩家位置变化了
                //        //隐藏之前格子的物件
                //        Dictionary<int, int> smallCellIndexs = GetSmallCellRangeByBigIndex(_playerIndexs[(int)PartType.Level_0]);
                //        var enumer = smallCellIndexs.GetEnumerator();
                //        try
                //        {
                //            while (enumer.MoveNext())
                //            {
                //                bool b = _smallPartTransDic.ContainsKey(enumer.Current.Key);
                //                if (b)
                //                {
                //                    List<Transform> listTrans = _smallPartTransDic[enumer.Current.Key];
                //                    if (listTrans != null)
                //                    {
                //                        for (int i = 0; i < listTrans.Count; i++)
                //                        {
                //                            SetVisable(false, listTrans[i]);
                //                        }
                //                    }
                //                }
                //            }
                //        }
                //        finally
                //        {
                //            enumer.Dispose();
                //        }
                //        _playerIndexs[(int)PartType.Level_0] = cells[(int)PartType.Level_0];
                //        SetPartByDisable(lp.Position);
                //    }
                //}
                //return;
            }
            if (!IsValid())
                return;
            UpdateAllPart();
        }

        private void UpdateAllPart()
        {
            LocalPlayer lp = GameCenter.GameSceneSystem.GetLocalPlayer();
            if (lp != null)
            {
                bool isMidChange = false;
                //更新玩家所在各个层级格子位置
                int[] cells = GetPlayerCel(lp.Position);
                if (cells[(int)PartType.Level_1] != _playerIndexs[(int)PartType.Level_1])
                {
                    isMidChange = true;
                    if (!_enable)
                    {
                        //如果是高品质
                        SetVfxIn_MidleSmallPart(_playerIndexs[(int)PartType.Level_1], false);
                        SetVfxIn_MidleSmallPart(cells[(int)PartType.Level_1], true);
                        _playerIndexs[(int)PartType.Level_1] = cells[(int)PartType.Level_1];
                    }
                    else
                    {
                        UpdateMidlePart(cells);
                    }
                }
                if (cells[(int)PartType.Level_2] != _playerIndexs[(int)PartType.Level_2])
                {
                    if (_enable)
                    {
                        UpdateSmallPart(cells, isMidChange);
                    }
                }
            }
        }
        private void UpdateMidlePart(int[] cells)
        {
            //如果所在玩家Mid格子位置变更了
            //清除一次缓存的mid物件
            //重新显示small物件
            SetSmallPartMidHide(_playerIndexs[(int)PartType.Level_2]);
            HideOverPart(_playerIndexs[(int)PartType.Level_1], cells[(int)PartType.Level_1], PartType.Level_1, _midPartTransDic, _midPartTypeDic);
            //隐藏mid中的small物件
            SetTransIn_MidleSmallPart(_playerIndexs[(int)PartType.Level_1], false);
            //SetMidlePartShow(_playerIndexs[(int)PartType.Level_1], false);
            SetMidlePartShow(cells[(int)PartType.Level_1], true);
            _playerIndexs[(int)PartType.Level_1] = cells[(int)PartType.Level_1];
        }

        private void UpdateSmallPart(int[] cells, bool isMidChange = false)
        {
            //如果所在玩家Small格子位置变更了
            //SetSmallPartShow(_playerIndexs[(int)PartType.Level_2], false);
            if (_userMidleSetting)
            {
                if (cells[(int)PartType.Level_1] != _playerIndexs[(int)PartType.Level_1] || isMidChange)
                {
                    HideOverPart(_playerIndexs[(int)PartType.Level_2], cells[(int)PartType.Level_2], PartType.Level_2, _smallPartTransDic, _smallPartTypeDic);
                }
            }
            else
            {
                HideOverPart(_playerIndexs[(int)PartType.Level_2], cells[(int)PartType.Level_2], PartType.Level_2, _smallPartTransDic, _smallPartTypeDic);
            }
            SetSmallPartShow(cells[(int)PartType.Level_2], true);
            _playerIndexs[(int)PartType.Level_2] = cells[(int)PartType.Level_2];
        }

        private bool IsValid()
        {
            bool ret = true;
            if (_rowCols == null)
                return false;
            for (int i = 0; i < _rowCols.Length; i++)
            {
                if (_rowCols[i] == 0)
                    ret = false;
            }
            return ret;
        }

        public void SetEnable(int value)
        {
            if (value == 2)
            {
                Enable = false;
                _userMidleSetting = false;
            }
            else if (value == 1)
            {
                _userMidleSetting = true;
                if (Enable)
                {
                    //从低画质切换到中画质
                    LocalPlayer lp = GameCenter.GameSceneSystem.GetLocalPlayer();
                    if (lp != null && IsValid())
                    {
                        int[] cells = GetPlayerCel(lp.Position);
                        SetTransIn_MidleSmallPart(cells[(int)PartType.Level_1], true);
                    }
                }
                Enable = true;
            }
            else
            {
                _userMidleSetting = false;
                if (Enable)
                {
                    //从中画质切换到低画质
                    LocalPlayer lp = GameCenter.GameSceneSystem.GetLocalPlayer();
                    if (lp != null && IsValid())
                    {
                        if (_rowCols != null)
                        {
                            int[] cells = GetPlayerCel(lp.Position);
                            //隐藏midle中包含的small格子中的物件
                            SetTransIn_MidleSmallPart(cells[(int)PartType.Level_1], false);
                            //重设small格子中的物件
                            SetSmallPartShow(cells[(int)PartType.Level_2], true);
                        }
                    }
                }
                Enable = true;
            }
        }

        public void SetAllDicTrans(Dictionary<string, Transform> dic)
        {
            var enumer = _smallPartTransDic.GetEnumerator();
        }

        public void SetDicTrans(Dictionary<string, Transform> dic)
        {

        }
        public Dictionary<int,List<Transform>> GetDicTrans()
        {
            return _transDic;
        }
        #endregion
        /// <summary>
        /// 格子索引类
        /// </summary>
        private class ShowScenePartIndexs
        {
            #region//公共变量
            private int _centerIndex = -1;
            private int _leftIndex = -1;
            private int _rightIndex = -1;
            private int _topIndex = -1;
            private int _bottomIndex = -1;
            private int _leftTopIndex = -1;
            private int _leftBottomIndex = -1;
            private int _rightTopIndex = -1;
            private int _rightBottomIndex = -1;
            private Dictionary<int, List<int>> _dicIndexs = new Dictionary<int, List<int>>();
            #endregion

            #region//公共属性
            public int CenterIndex
            {
                get
                {
                    return _centerIndex;
                }
            }
            public int LeftIndex
            {
                get
                {
                    return _leftIndex;
                }
            }
            public int RightIndex
            {
                get
                {
                    return _rightIndex;
                }
            }
            public int TopIndex
            {
                get
                {
                    return _topIndex;
                }
            }
            public int BottomIndex
            {
                get
                {
                    return _bottomIndex;
                }
            }
            public int LeftTopIndex
            {
                get
                {
                    return _leftTopIndex;
                }
            }
            public int LeftBottomIndex
            {
                get
                {
                    return _leftBottomIndex;
                }
            }
            public int RightTopIndex
            {
                get
                {
                    return _rightTopIndex;
                }
            }
            public int RightBottomIndex
            {
                get
                {
                    return _rightBottomIndex;
                }
            }
            public Dictionary<int, List<int>> DicIndexs
            {
                get
                {
                    return _dicIndexs;
                }
            }
            #endregion

            #region//构造函数
            public ShowScenePartIndexs()
            {
            }
            public ShowScenePartIndexs(int index, int rowCol)
            {
                ResetNineCel(index, rowCol);
            }

            public void ResetNineCel(int index, int rowCol)
            {
                if (rowCol == 0)
                    return;
                int result = 0;
                int row = index / rowCol;
                _dicIndexs.Clear();
                _centerIndex = index;
                result = _centerIndex - 1;
                _leftIndex = result >= row * rowCol ? result : -1;
                result = _centerIndex + 1;
                _rightIndex = result <= (row + 1) * rowCol - 1 ? result : -1;
                result = _centerIndex + rowCol;
                _topIndex = result < Mathf.Pow(rowCol, 2) ? result : -1;
                result = _centerIndex - rowCol;
                _bottomIndex = result >= 0 ? result : -1;
                result = _centerIndex + rowCol - 1;
                _leftTopIndex = result < Mathf.Pow(rowCol, 2) && result >= (row + 1) * rowCol ? result : -1;
                result = _centerIndex + rowCol + 1;
                _rightTopIndex = result < Mathf.Pow(rowCol, 2) && result <= (row + 1) * rowCol + rowCol - 1 ? result : -1;
                result = _centerIndex - rowCol - 1;
                _leftBottomIndex = result >= 0 && result >= (row - 1) * rowCol ? result : -1;
                result = _centerIndex - rowCol + 1;
                _rightBottomIndex = result >= 0 && result <= (row - 1) * rowCol + rowCol - 1 ? result : -1;

                List<int> centerList = new List<int>();
                List<int> leftList = new List<int>();
                List<int> rightList = new List<int>();
                List<int> topList = new List<int>();
                List<int> bottomList = new List<int>();
                List<int> leftTopList = new List<int>();
                List<int> leftBottomList = new List<int>();
                List<int> rightTopList = new List<int>();
                List<int> rightBottomList = new List<int>();
                centerList.Add(_centerIndex);
                leftList.Add(_leftIndex);
                rightList.Add(_rightIndex);
                topList.Add(_topIndex);
                bottomList.Add(_bottomIndex);
                leftTopList.Add(_leftTopIndex);
                leftBottomList.Add(_leftBottomIndex);
                rightTopList.Add(_rightTopIndex);
                rightBottomList.Add(_rightBottomIndex);

                _dicIndexs.Add((int)IndexType.Center, centerList);
                _dicIndexs.Add((int)IndexType.Left, leftList);
                _dicIndexs.Add((int)IndexType.Right, rightList);
                _dicIndexs.Add((int)IndexType.Top, topList);
                _dicIndexs.Add((int)IndexType.Bottom, bottomList);
                _dicIndexs.Add((int)IndexType.LeftTop, leftTopList);
                _dicIndexs.Add((int)IndexType.LeftBottom, leftBottomList);
                _dicIndexs.Add((int)IndexType.RightTop, rightTopList);
                _dicIndexs.Add((int)IndexType.RightBottom, rightBottomList);
            }
            #endregion

            #region//enum
            private enum IndexType
            {
                Left = 0,
                Right,
                Top,
                Bottom,
                LeftTop,
                LeftBottom,
                RightTop,
                RightBottom,
                Center,
            }
            #endregion
        }
        #region//私有枚举
        //Render类型
        private enum SceneNodeRendererType
        {
            None,
            //Mesh渲染
            MeshRenderer,
            //skin
            SkinMesh,
            //粒子渲染
            ParticleSystemRenderer,

        }
        private enum NodeRootType
        {
            Default = 0,
            FarRoot = 1,                   //远处可视节点
            NearRoot,                      //进出可视节点
            MidleRoot,                     //midel节点
            ParticFar,                     //特效远
            ParticMidle,                   //特效中
            ParticNear,                    //特效进节点
            ParticNearHide,                //特效near节点隐藏
            Other,                         //其他节点
        }
        //part 类型
        private enum PartType
        {
            Level_0 = 0,
            Level_1 = 1,
            Level_2 = 2,
            Count = 3,
        }
        #endregion
    }
}