1042 lines
40 KiB
C#
1042 lines
40 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
namespace Thousandto.Launcher.ExternalLibs
|
|
{
|
|
/// <summary>
|
|
/// 场景数据资源还原系统类
|
|
/// </summary>
|
|
public class SceneRestoreParts
|
|
{
|
|
#region//私有变量
|
|
private bool _isMatLoadFinished = false;
|
|
private bool _isSetPartOver = false;
|
|
private int _texReMainCount = 0;
|
|
|
|
private Vector3 _pos = Vector3.zero;
|
|
private SceneAssetsDiscriptFile _fileScript = null;
|
|
//private ShowScenePartIndexs _firstShowParts = null;
|
|
private Dictionary<string, Mesh> _dicMeshAsset = new Dictionary<string, Mesh>();
|
|
private Dictionary<string, List<RegObj>> _dicRegMesh = new Dictionary<string, List<RegObj>>();
|
|
//场景材质球
|
|
Dictionary<int, Material> _dicSceneMat = new Dictionary<int, Material>();
|
|
|
|
//加载mesh资源
|
|
private static Action<string, int, Transform, Action<Mesh,string>> _loadMeshRes;
|
|
private static Action<string, Action<Mesh>> _loadParticeMesh;
|
|
private static Action<string, Action<Texture>> _loadTextureRes;
|
|
|
|
//static
|
|
private static SceneRestoreParts _instance = null;
|
|
#endregion
|
|
|
|
#region//公共属性
|
|
private bool IsSetPartOver
|
|
{
|
|
get
|
|
{
|
|
return _isSetPartOver;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region//回调函数
|
|
private void OnMaterialTextureCallBack(Material mat, string pName)
|
|
{
|
|
_texReMainCount--;
|
|
if (_texReMainCount == 0)
|
|
{
|
|
if (!_isMatLoadFinished)
|
|
{
|
|
_isMatLoadFinished = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void RegMesh(Mesh ms, string path)
|
|
{
|
|
if (_dicMeshAsset.ContainsKey(path) && _dicMeshAsset[path] == null)
|
|
{
|
|
_dicMeshAsset[path] = ms;
|
|
SetRegMeshes(path, ms);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region//私有函数
|
|
private void SetPartRender(RegionPart part)
|
|
{
|
|
if (part == null)
|
|
return;
|
|
for (int i = 0; i < part.Descripts.Length; i++)
|
|
{
|
|
var descrip = part.Descripts[i];
|
|
if (descrip.NType == NodeRootType.NearRoot || descrip.NType == NodeRootType.ParticNear)
|
|
{
|
|
if (descrip.Trans)
|
|
{
|
|
descrip.Trans.gameObject.SetActive(true);
|
|
if (descrip.IsSetAsset)
|
|
continue;
|
|
var trans = descrip.Trans;
|
|
Renderer rd = trans.GetComponent<Renderer>();
|
|
//SetMesh(descrip, trans, descrip.RenderType);
|
|
descrip.IsSetAsset = true;
|
|
//part.IsRePlace = true;
|
|
}
|
|
}
|
|
//SetMaterial(descrip.MatsData, descrip.Trans, descrip.RenderType);
|
|
}
|
|
}
|
|
private void SetMesh(SceneAssetDescript descrip, Transform trans, RendererType type)
|
|
{
|
|
//if (type != RendererType.ParticleSystemRenderer)
|
|
//{
|
|
// int index = descrip.MeshIndexs != null && descrip.MeshIndexs.Length > 0 ? descrip.MeshIndexs[0] : -1;
|
|
// if (index != -1)
|
|
// {
|
|
// string path = _fileScript.GetMeshPath(index);
|
|
// //SetMesh(trans, path, type);
|
|
// }
|
|
//}
|
|
//else
|
|
//{
|
|
// List<string> list = new List<string>();
|
|
// for (int i = 0; descrip.MeshIndexs != null && i < descrip.MeshIndexs.Length; i++)
|
|
// {
|
|
// int index = descrip.MeshIndexs[i];
|
|
// string path = string.Empty;
|
|
// if (descrip.SubMeshIndex != -1)
|
|
// {
|
|
// //网格被合并过
|
|
// path = _fileScript.GetCombinMeshPath(index);
|
|
// }
|
|
// else
|
|
// {
|
|
// //没有合并网格
|
|
// path = _fileScript.GetMeshPath(index);
|
|
// }
|
|
// if (!string.IsNullOrEmpty(path))
|
|
// {
|
|
// list.Add(path);
|
|
// }
|
|
// }
|
|
// //SetParticleMesh(trans, list.ToArray());
|
|
//}
|
|
|
|
}
|
|
private void SetMesh(Transform trans, string path ,RendererType type)
|
|
{
|
|
if (trans == null)
|
|
return;
|
|
if (_dicMeshAsset.ContainsKey(path))
|
|
{
|
|
Mesh ms = _dicMeshAsset[path];
|
|
if (ms == null)
|
|
{
|
|
List<RegObj> list = null;
|
|
if (_dicRegMesh.ContainsKey(path))
|
|
{
|
|
list = _dicRegMesh[path];
|
|
if (list != null)
|
|
{
|
|
RegObj obj = new RegObj();
|
|
obj.trans = trans;
|
|
obj.type = type;
|
|
list.Add(obj);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
list = new List<RegObj>();
|
|
RegObj obj = new RegObj();
|
|
obj.trans = trans;
|
|
obj.type = type;
|
|
list.Add(obj);
|
|
_dicRegMesh.Add(path, list);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (type)
|
|
{
|
|
case RendererType.MeshRenderer:
|
|
{
|
|
MeshFilter mf = trans.GetComponent<MeshFilter>();
|
|
if (mf != null)
|
|
{
|
|
//mf.sharedMesh = ms;
|
|
}
|
|
}
|
|
break;
|
|
case RendererType.SkinMesh:
|
|
{
|
|
SkinnedMeshRenderer skinRender = trans.GetComponent<SkinnedMeshRenderer>();
|
|
if (skinRender != null)
|
|
{
|
|
//skinRender.sharedMesh = ms;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (_loadMeshRes != null)
|
|
{
|
|
_loadMeshRes(path, (int)type, trans, RegMesh);
|
|
}
|
|
_dicMeshAsset.Add(path, null);
|
|
}
|
|
}
|
|
private void SetParticleMesh(Transform trans, string[] paths)
|
|
{
|
|
int index = 0;
|
|
List<Mesh> list = new List<Mesh>();
|
|
for (int i = 0; i < paths.Length; i++)
|
|
{
|
|
if (_dicMeshAsset.ContainsKey(paths[i]))
|
|
{
|
|
if (_dicMeshAsset[paths[i]] != null)
|
|
{
|
|
list.Add(_dicMeshAsset[paths[i]]);
|
|
}
|
|
index += 1;
|
|
if (index == paths.Length)
|
|
{
|
|
ParticleSystemRenderer prd = trans.GetComponent<ParticleSystemRenderer>();
|
|
//prd.SetMeshes(list.ToArray());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (_loadParticeMesh != null)
|
|
{
|
|
_loadParticeMesh(paths[i], (ms)=> {
|
|
if (ms != null)
|
|
{
|
|
list.Add(ms);
|
|
index += 1;
|
|
if (_dicMeshAsset.ContainsKey(paths[i]))
|
|
{
|
|
_dicMeshAsset[paths[i]] = ms;
|
|
}
|
|
if (index == paths.Length)
|
|
{
|
|
ParticleSystemRenderer prd = trans.GetComponent<ParticleSystemRenderer>();
|
|
//prd.SetMeshes(list.ToArray());
|
|
}
|
|
}
|
|
});
|
|
}
|
|
_dicMeshAsset.Add(paths[i], null);
|
|
}
|
|
}
|
|
}
|
|
private void SetRegMeshes(string path, Mesh ms)
|
|
{
|
|
if (!_dicRegMesh.ContainsKey(path))
|
|
return;
|
|
List<RegObj> list = _dicRegMesh[path];
|
|
if (list == null)
|
|
return;
|
|
for (int i = 0; i < list.Count;i++)
|
|
{
|
|
switch (list[i].type)
|
|
{
|
|
case RendererType.MeshRenderer:
|
|
{
|
|
MeshFilter mf = list[i].trans.GetComponent<MeshFilter>();
|
|
if (mf != null)
|
|
{
|
|
//mf.sharedMesh = ms;
|
|
}
|
|
}
|
|
break;
|
|
case RendererType.SkinMesh:
|
|
{
|
|
SkinnedMeshRenderer skinRender = list[i].trans.GetComponent<SkinnedMeshRenderer>();
|
|
if (skinRender != null)
|
|
{
|
|
//skinRender.sharedMesh = ms;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
private void SetMaterial(MatrialAssetData[] dataArray, Transform trans, RendererType type)
|
|
{
|
|
Material[] mats = new Material[dataArray.Length];
|
|
List<Material> matList = new List<Material>(dataArray.Length);
|
|
for (int i = 0; i < dataArray.Length; i++)
|
|
{
|
|
Material mat = null;
|
|
//mats[i] =
|
|
if (_dicSceneMat.ContainsKey(dataArray[i].Index))
|
|
{
|
|
mat = _dicSceneMat[dataArray[i].Index];
|
|
}
|
|
else
|
|
{
|
|
mat = RestoreMaterail(dataArray[i]);
|
|
_dicSceneMat.Add(dataArray[i].Index, mat);
|
|
}
|
|
matList.Add(mat);
|
|
}
|
|
mats = matList.ToArray();
|
|
switch (type)
|
|
{
|
|
case RendererType.MeshRenderer:
|
|
{
|
|
MeshRenderer mRd = trans.GetComponent<MeshRenderer>();
|
|
if (mRd != null)
|
|
{
|
|
mRd.sharedMaterials = mats;
|
|
}
|
|
}
|
|
break;
|
|
case RendererType.SkinMesh:
|
|
{
|
|
SkinnedMeshRenderer sRd = trans.GetComponent<SkinnedMeshRenderer>();
|
|
if (sRd != null)
|
|
{
|
|
sRd.sharedMaterials = mats;
|
|
}
|
|
}
|
|
break;
|
|
case RendererType.ParticleSystemRenderer:
|
|
{
|
|
ParticleSystemRenderer pRd = trans.GetComponent<ParticleSystemRenderer>();
|
|
if (pRd != null)
|
|
{
|
|
// 0 是 materail 1 是trailMaterail
|
|
for (int i = 0; i < dataArray.Length; i++)
|
|
{
|
|
if (!dataArray[i].IsTrail)
|
|
{
|
|
if (_dicSceneMat.ContainsKey(dataArray[i].Index))
|
|
{
|
|
pRd.sharedMaterial = _dicSceneMat[dataArray[i].Index];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (_dicSceneMat.ContainsKey(dataArray[i].Index))
|
|
{
|
|
pRd.trailMaterial = _dicSceneMat[dataArray[i].Index];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
private Material RestoreMaterail(MatrialAssetData data)
|
|
{
|
|
if (data == null)
|
|
return null;
|
|
if (data.Index == -1)
|
|
return null;
|
|
MatAssetsProperty property = _fileScript.GetMatProperty(data.Index);
|
|
if (property == null)
|
|
return null;
|
|
Shader sh = PrefabAssetRuntimeUtil.FindShader(property.ShaderName);
|
|
if (sh == null)
|
|
{
|
|
Debug.LogError("RestoreMaterial:not find shader;;" + property.ShaderName);
|
|
return null;
|
|
}
|
|
Material mat = new Material(sh);
|
|
//设置需要动态加载的纹理
|
|
if (property.TexIndexs != null)
|
|
{
|
|
//_isMatLoadFinished = false;
|
|
_texReMainCount = property.TexIndexs.Length;
|
|
for (int i = 0; i < property.TexIndexs.Length; i++)
|
|
{
|
|
//如果纹理名字是null
|
|
//string texPath = _fileScript.GetTexturePath(property.TexIndexs[i].Index);
|
|
Texture tex = property.TexIndexs[i].tex;
|
|
if (tex == null)
|
|
{
|
|
mat.SetTexture(property.TexIndexs[i].Name, null);
|
|
_texReMainCount--;
|
|
}
|
|
else
|
|
{
|
|
var texName = property.TexIndexs[i].Name;
|
|
//if (_loadTextureRes != null)
|
|
//{
|
|
// _loadTextureRes(texPath, (tex) =>
|
|
// {
|
|
// mat.SetTexture(texName, tex);
|
|
// });
|
|
//}
|
|
mat.SetTexture(texName, tex);
|
|
}
|
|
mat .SetTextureOffset(property.TexIndexs[i].Name, property.TexOffset[i]);
|
|
mat.SetTextureScale(property.TexIndexs[i].Name, property.TexScale[i]);
|
|
}
|
|
//if (_texReMainCount == 0)
|
|
//{
|
|
// if (!_isMatLoadFinished)
|
|
// {
|
|
// _isMatLoadFinished = true;
|
|
// }
|
|
//}
|
|
}
|
|
|
|
//设置四元值
|
|
if (property.Vec != null)
|
|
{
|
|
for (int i = 0; i < property.Vec.Length; i++)
|
|
{
|
|
mat.SetVector(property.Vec[i].Name, property.Vec[i].Value);
|
|
}
|
|
}
|
|
|
|
//设置颜色
|
|
if (property.Color != null)
|
|
{
|
|
for (int i = 0; i < property.Color.Length; i++)
|
|
{
|
|
mat.SetColor(property.Color[i].Name, property.Color[i].Value);
|
|
}
|
|
}
|
|
|
|
//设置float值
|
|
if (property.Float != null)
|
|
{
|
|
for (int i = 0; i < property.Float.Length; i++)
|
|
{
|
|
mat.SetFloat(property.Float[i].Name, property.Float[i].Value);
|
|
}
|
|
}
|
|
return mat;
|
|
}
|
|
#endregion
|
|
|
|
#region//static函数
|
|
public static void InitSceneData(GameObject root, Vector3 pos, Action<string, int, Transform, Action<Mesh,string>> loadMesh, Action<string, Action<Texture>> loadTexture,
|
|
Action<string,Action<Mesh>> loadParticeMesh,List<Vector3> posList, Dictionary<int,List<Transform>> dic, Dictionary<int, List<int>> typeDic)
|
|
{
|
|
_loadMeshRes = loadMesh;
|
|
_loadParticeMesh = loadParticeMesh;
|
|
_loadTextureRes = loadTexture;
|
|
_instance = new SceneRestoreParts();
|
|
_instance.SetSceneData(root, pos, posList, dic, typeDic);
|
|
}
|
|
public static void RestoreLeftParts()
|
|
{
|
|
if (_instance != null)
|
|
{
|
|
List<int> list = new List<int>((int)CellType.Count);
|
|
for (int i = 0; i < (int)CellType.Count; i++)
|
|
{
|
|
int row = (int)Math.Floor((_instance._pos.z - _instance._fileScript.Min.y) / (_instance._fileScript.Max.y - _instance._fileScript.Min.y) * _instance._fileScript.RC[i]);
|
|
int col = (int)Math.Floor((_instance._pos.x - _instance._fileScript.Min.x) / (_instance._fileScript.Max.x - _instance._fileScript.Min.x) * _instance._fileScript.RC[i]);
|
|
int cel = row * _instance._fileScript.RC[i] + col;
|
|
list.Add(cel);
|
|
}
|
|
|
|
for (int i = 0; i < list.Count; i++)
|
|
{
|
|
ShowScenePartIndexs partIndex = new ShowScenePartIndexs(list[i], _instance._fileScript.RC[i]);
|
|
if (i == 0)
|
|
{
|
|
_instance.SetOtherPartRes(_instance._fileScript.PBig, partIndex, _instance._fileScript.RC[i]);
|
|
}
|
|
else if (i == 1)
|
|
{
|
|
_instance.SetOtherPartRes(_instance._fileScript.PMidle, partIndex, _instance._fileScript.RC[i]);
|
|
}
|
|
else if (i == 2)
|
|
{
|
|
_instance.SetOtherPartRes(_instance._fileScript.PSmall, partIndex, _instance._fileScript.RC[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region//私有函数
|
|
private void SetSceneData(GameObject root, Vector3 pos, List<Vector3> posList, Dictionary<int, List<Transform>> dic, Dictionary<int, List<int>> typeDic)
|
|
{
|
|
if (root == null)
|
|
return;
|
|
_fileScript = root.GetComponent<SceneAssetsDiscriptFile>();
|
|
if (_fileScript == null)
|
|
return;
|
|
_pos = pos;
|
|
posList.Clear();
|
|
posList.Add(_fileScript.Min);
|
|
posList.Add(_fileScript.Max);
|
|
//int playerIndex = 0;
|
|
dic.Clear();
|
|
typeDic.Clear();
|
|
for (int j = 0; j < (int)CellType.Count; j++)
|
|
{
|
|
var parts = _fileScript.GetParts((CellType)j);
|
|
for (int k = 0; k < parts.Length; k++)
|
|
{
|
|
for (int m = 0; m < parts[k].Descripts.Length; m++)
|
|
{
|
|
var trans = parts[k].Descripts[m].Trans;
|
|
if (parts[k] == null || parts[k].Descripts[m] == null || trans == null)
|
|
{
|
|
#if UNITY_EDITOR
|
|
UnityEngine.Debug.LogError("场景远近处理数据错误");
|
|
#endif
|
|
continue;
|
|
}
|
|
if (parts[k].Descripts[m].IsActive)
|
|
{
|
|
int key = k + 100000 * (j + 1);
|
|
List<Transform> l = dic.TryGetValue(key, out l) ? l : null;
|
|
if (l != null)
|
|
{
|
|
l.Add(trans);
|
|
}
|
|
else
|
|
{
|
|
l = new List<Transform>(parts[k].Descripts.Length);
|
|
l.Add(trans);
|
|
dic.Add(key, l);
|
|
}
|
|
|
|
List<int> typeList = typeDic.TryGetValue(key, out typeList) ? typeList : null;
|
|
if (typeList != null)
|
|
{
|
|
typeList.Add((int)parts[k].Descripts[m].NType);
|
|
}
|
|
else
|
|
{
|
|
typeList = new List<int>(parts[k].Descripts.Length);
|
|
typeList.Add((int)parts[k].Descripts[m].NType);
|
|
typeDic.Add(key, typeList);
|
|
}
|
|
}
|
|
//----暂时不处理场景物件隐藏
|
|
//if (parts[k].Descripts[m].NodeType == NodeRootType.Default || parts[k].Descripts[m].NodeType == NodeRootType.FarRoot ||
|
|
// parts[k].Descripts[m].NodeType == NodeRootType.Other || parts[k].Descripts[m].NodeType == NodeRootType.ParticFar)
|
|
//{
|
|
// if (!trans.gameObject.activeSelf)
|
|
// trans.gameObject.SetActive(true);
|
|
//}
|
|
//else
|
|
//{
|
|
// if(trans.gameObject.activeSelf)
|
|
// trans.gameObject.SetActive(false);
|
|
//}
|
|
}
|
|
}
|
|
}
|
|
|
|
_dicMeshAsset.Clear();
|
|
_dicRegMesh.Clear();
|
|
_isSetPartOver = false;
|
|
//_rowCol = _fileScript.RowCols[(int)CellType.Level_2];
|
|
|
|
|
|
List<int> list = new List<int>((int)CellType.Count);
|
|
for (int i = 0; i < (int)CellType.Count; i++)
|
|
{
|
|
int row = (int)Math.Floor((pos.z - _fileScript.Min.y) / (_fileScript.Max.y - _fileScript.Min.y) * _fileScript.RC[i]);
|
|
int col = (int)Math.Floor((pos.x - _fileScript.Min.x) / (_fileScript.Max.x - _fileScript.Min.x) * _fileScript.RC[i]);
|
|
int cel = row * _fileScript.RC[i] + col;
|
|
list.Add(cel);
|
|
}
|
|
//屏蔽场景快速显示第一部分模型和材质球还原，材质球还原已经被放在场景脚本里面调用，场景物件第一次初始化全部都是默认显示的
|
|
//for (int i = 0; i < list.Count; i++)
|
|
//{
|
|
// ShowScenePartIndexs partIndex = new ShowScenePartIndexs(list[i], _fileScript.RowCols[i]);
|
|
// if (i == 0)
|
|
// {
|
|
// SetFastPartRes(_fileScript.Parts_Big, partIndex);
|
|
// }
|
|
// else if (i == 1)
|
|
// {
|
|
// SetFastPartRes(_fileScript.Parts_Midle, partIndex);
|
|
// }
|
|
// else if (i == 2)
|
|
// {
|
|
// SetFastPartRes(_fileScript.Parts_Small, partIndex);
|
|
// }
|
|
//}
|
|
|
|
//_firstShowParts = new ShowScenePartIndexs(playerIndex, _rowCol);
|
|
|
|
//SetFastPartRes(_fileScript.Parts_Small);
|
|
//SetOtherPartRes(_fileScript.Parts);
|
|
}
|
|
|
|
private bool IntersertBounds(Bounds bs, Vector3 pos)
|
|
{
|
|
if (bs.Contains(pos))
|
|
return true;
|
|
return false;
|
|
}
|
|
#endregion
|
|
|
|
#region//公共函数
|
|
//设置firstShowParts资源
|
|
public void SetFastPartRes(RegionPart[] partArray, ShowScenePartIndexs partIndex)
|
|
{
|
|
var enumer = partIndex.DicIndexs.GetEnumerator();
|
|
try
|
|
{
|
|
while (enumer.MoveNext())
|
|
{
|
|
for (int i = 0; i < enumer.Current.Value.Count; i++)
|
|
{
|
|
int index = enumer.Current.Value[i];
|
|
if (index == -1)
|
|
continue;
|
|
if (partArray.Length > index)
|
|
{
|
|
RegionPart part = partArray[index];
|
|
SetPartRender(part);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
enumer.Dispose();
|
|
}
|
|
}
|
|
|
|
//顺序设置其他part资源
|
|
public void SetOtherPartRes(RegionPart[] partArray, ShowScenePartIndexs partIndex,int type)
|
|
{
|
|
while (partIndex.DicIndexs.Count != 0)
|
|
{
|
|
var enumer = partIndex.DicIndexs.GetEnumerator();
|
|
try
|
|
{
|
|
while (enumer.MoveNext())
|
|
{
|
|
var list = enumer.Current.Value;
|
|
for (int i = 0; i < list.Count; i++)
|
|
{
|
|
if (list[i] >= 0 && list[i] < partArray.Length)
|
|
{
|
|
RegionPart part = partArray[list[i]];
|
|
if(part != null && !part.IsRePlace)
|
|
SetPartRender(part);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
enumer.Dispose();
|
|
}
|
|
partIndex.SetRoundIndexs(type);
|
|
}
|
|
_isSetPartOver = true;
|
|
}
|
|
#endregion
|
|
|
|
#region//私有类
|
|
/// <summary>
|
|
/// 格子索引数据类
|
|
/// </summary>
|
|
public 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>>((int)IndexType.Count);
|
|
#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(int index, int rowCol)
|
|
{
|
|
ResetNineCel(index, rowCol);
|
|
}
|
|
|
|
public void ResetNineCel(int index, int rowCol)
|
|
{
|
|
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);
|
|
}
|
|
|
|
public void SetRoundIndexs(int rowCol)
|
|
{
|
|
List<int> list = null;
|
|
Dictionary<int, List<int>> dicTemp = new Dictionary<int, List<int>>();
|
|
if (_dicIndexs == null)
|
|
return;
|
|
int row = 0;
|
|
int result = 0;
|
|
//添加left Index
|
|
List<int> tempList1 = new List<int>();
|
|
_dicIndexs.TryGetValue((int)IndexType.LeftTop, out list);
|
|
if (list != null && list.Count > 0 && list[0] != -1)
|
|
{
|
|
row = list[0] / rowCol;
|
|
result = list[0] - 1;
|
|
result = result >= row * rowCol ? result : -1;
|
|
if (result != -1)
|
|
{
|
|
tempList1.Add(result);
|
|
//设置leftTop
|
|
result = result + rowCol;
|
|
result = result < Mathf.Pow(rowCol, 2) ? result : -1;
|
|
if (result != -1)
|
|
{
|
|
List<int> speList = new List<int>();
|
|
speList.Add(result);
|
|
dicTemp.Add((int)IndexType.LeftTop, speList);
|
|
}
|
|
}
|
|
}
|
|
_dicIndexs.TryGetValue((int)IndexType.Left, out list);
|
|
if (list != null)
|
|
{
|
|
for (int i = 0; i < list.Count; i++)
|
|
{
|
|
row = list[i] / rowCol;
|
|
result = list[i] - 1;
|
|
result = result >= row * rowCol ? result : -1;
|
|
if (result != -1)
|
|
{
|
|
tempList1.Add(result);
|
|
}
|
|
}
|
|
}
|
|
_dicIndexs.TryGetValue((int)IndexType.LeftBottom, out list);
|
|
if (list != null)
|
|
{
|
|
row = list[0] / rowCol;
|
|
result = list[0] - 1;
|
|
result = result >= row * rowCol ? result : -1;
|
|
if (result != -1)
|
|
{
|
|
tempList1.Add(result);
|
|
//设置leftBottom
|
|
List<int> speList = new List<int>();
|
|
result = result - rowCol;
|
|
result = result >= 0 ? result : -1;
|
|
if (result != -1)
|
|
{
|
|
speList.Add(result);
|
|
dicTemp.Add((int)IndexType.LeftBottom, speList);
|
|
}
|
|
}
|
|
}
|
|
if (tempList1.Count > 0)
|
|
{
|
|
dicTemp.Add((int)IndexType.Left, tempList1);
|
|
}
|
|
|
|
//添加Riht Index
|
|
List<int> tempList2 = new List<int>();
|
|
_dicIndexs.TryGetValue((int)IndexType.RightTop, out list);
|
|
if (list != null && list.Count > 0 && list[0] != -1)
|
|
{
|
|
row = list[0] / rowCol;
|
|
result = list[0] + 1;
|
|
result = result <= (row + 1) * rowCol - 1 ? result : -1;
|
|
if (result != -1)
|
|
{
|
|
tempList2.Add(result);
|
|
//设置rightTop
|
|
result = result + rowCol;
|
|
result = result < Mathf.Pow(rowCol, 2) ? result : -1;
|
|
if (result != -1)
|
|
{
|
|
List<int> speList = new List<int>();
|
|
speList.Add(result);
|
|
dicTemp.Add((int)IndexType.RightTop, speList);
|
|
}
|
|
}
|
|
}
|
|
_dicIndexs.TryGetValue((int)IndexType.Right, out list);
|
|
if (list != null)
|
|
{
|
|
for (int i = 0; i < list.Count; i++)
|
|
{
|
|
row = list[i] / rowCol;
|
|
result = list[i] + 1;
|
|
result = result <= (row + 1) * rowCol - 1 ? result : -1;
|
|
if (result != -1)
|
|
{
|
|
tempList2.Add(result);
|
|
}
|
|
}
|
|
}
|
|
_dicIndexs.TryGetValue((int)IndexType.RightBottom, out list);
|
|
if (list != null)
|
|
{
|
|
row = list[0] / rowCol;
|
|
result = list[0] + 1;
|
|
result = result <= (row + 1) * rowCol - 1 ? result : -1;
|
|
if (result != -1)
|
|
{
|
|
tempList2.Add(result);
|
|
//设置rightBottom
|
|
List<int> speList = new List<int>();
|
|
result = result - rowCol;
|
|
result = result >= 0 ? result : -1;
|
|
if (result != -1)
|
|
{
|
|
speList.Add(result);
|
|
dicTemp.Add((int)IndexType.RightBottom, speList);
|
|
}
|
|
}
|
|
}
|
|
if (tempList2.Count > 0)
|
|
{
|
|
dicTemp.Add((int)IndexType.Right, tempList2);
|
|
}
|
|
|
|
//添加Top Index
|
|
List<int> tempList3 = new List<int>();
|
|
_dicIndexs.TryGetValue((int)IndexType.LeftTop, out list);
|
|
if (list != null && list.Count > 0 && list[0] != -1)
|
|
{
|
|
row = list[0] / rowCol;
|
|
result = list[0] + rowCol;
|
|
result = result < Mathf.Pow(rowCol, 2) ? result : -1;
|
|
if (result != -1)
|
|
{
|
|
tempList3.Add(result);
|
|
list.Clear();
|
|
}
|
|
}
|
|
_dicIndexs.TryGetValue((int)IndexType.Top, out list);
|
|
if (list != null)
|
|
{
|
|
for (int i = 0; i < list.Count; i++)
|
|
{
|
|
row = list[i] / rowCol;
|
|
result = list[i] + rowCol;
|
|
result = result < Mathf.Pow(rowCol, 2) ? result : -1;
|
|
if (result != -1)
|
|
{
|
|
tempList3.Add(result);
|
|
}
|
|
}
|
|
}
|
|
_dicIndexs.TryGetValue((int)IndexType.RightTop, out list);
|
|
if (list != null)
|
|
{
|
|
row = list[0] / rowCol;
|
|
result = list[0] + rowCol;
|
|
result = result < Mathf.Pow(rowCol, 2) ? result : -1;
|
|
if (result != -1)
|
|
{
|
|
tempList3.Add(result);
|
|
}
|
|
}
|
|
if (tempList3.Count > 0)
|
|
{
|
|
dicTemp.Add((int)IndexType.Top, tempList3);
|
|
}
|
|
|
|
//添加Bottom Index
|
|
List<int> tempList4 = new List<int>();
|
|
_dicIndexs.TryGetValue((int)IndexType.LeftBottom, out list);
|
|
if (list != null && list.Count > 0 && list[0] != -1)
|
|
{
|
|
row = list[0] / rowCol;
|
|
result = list[0] - rowCol;
|
|
result = result >= 0 ? result : -1;
|
|
if (result != -1)
|
|
{
|
|
tempList4.Add(result);
|
|
}
|
|
}
|
|
_dicIndexs.TryGetValue((int)IndexType.Bottom, out list);
|
|
if (list != null)
|
|
{
|
|
for (int i = 0; i < list.Count; i++)
|
|
{
|
|
row = list[i] / rowCol;
|
|
result = list[i] - rowCol;
|
|
result = result >= 0 ? result : -1;
|
|
if (result != -1)
|
|
{
|
|
tempList4.Add(result);
|
|
}
|
|
}
|
|
}
|
|
_dicIndexs.TryGetValue((int)IndexType.RightBottom, out list);
|
|
if (list != null)
|
|
{
|
|
row = list[0] / rowCol;
|
|
result = list[0] - rowCol;
|
|
result = result >= 0 ? result : -1;
|
|
if (result != -1)
|
|
{
|
|
tempList4.Add(result);
|
|
}
|
|
}
|
|
if (tempList4.Count > 0)
|
|
{
|
|
dicTemp.Add((int)IndexType.Bottom, tempList4);
|
|
}
|
|
_dicIndexs.Clear();
|
|
_dicIndexs = dicTemp;
|
|
}
|
|
#endregion
|
|
|
|
#region//enum
|
|
private enum IndexType
|
|
{
|
|
Left = 0,
|
|
Right,
|
|
Top,
|
|
Bottom,
|
|
LeftTop,
|
|
LeftBottom,
|
|
RightTop,
|
|
RightBottom,
|
|
Center,
|
|
Count,
|
|
}
|
|
#endregion
|
|
}
|
|
private class RegObj
|
|
{
|
|
public Transform trans = null;
|
|
public RendererType type = RendererType.None;
|
|
}
|
|
#endregion
|
|
}
|
|
}
|
|
|