using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEngine;
using UnityEngine.Gonbest.MagicCube;
using UnityEngine.SceneManagement;
namespace Thousandto.Launcher.ExternalLibs
{
public class SceneSplit
{
private const string _rootName = "SceneRoot";
private const string _vfxName = "[vfx]";
private const string _farName = "[far]";
private const string _nearName = "[near]";
private const string _midle = "[midle]";
private const string _timeLine = "[timeline]";
private GameObject _sceneRoot = null;
private GameObject _effectRoot = null;
private SceneAssetsDiscriptFile _sceneScript = null;
private List<SceneNodeCommpent> _childs = new List<SceneNodeCommpent>();
private Dictionary<int, Mesh> _dicCombinMesh = new Dictionary<int, Mesh>();
private List<SceneNodeCommpent> _tempNodeList = new List<SceneNodeCommpent>(500);
//替换shader
private Shader _replaceShader = null;
private Material _replaceMat = null;
//默认场景shader
private Shader _defaultShader = null;
private Material _defaultMat = null;
private bool _isHideObj = false;
#region//私有函数
//初始化Root
private void InitRoot()
{
if (_sceneRoot == null)
_sceneRoot = GameObject.Find(_rootName);
//if (_effectRoot == null)
// _effectRoot = _sceneRoot.transform.Find(_vfxName).gameObject;
_childs.Clear();
Renderer[] f_rdList = null;
Renderer[] n_rdList = null;
Renderer[] m_rdList = null;
Renderer[] pf_rdList = null;
Renderer[] pm_rdList = null;
Renderer[] pn_rdList = null;
Renderer[] pn_rdList_hide = null;
Renderer[] ot_rdList = null;
for (int i = 0; i < _sceneRoot.transform.childCount; i++)
{
var child = _sceneRoot.transform.GetChild(i);
if (child.name == _farName)
{
f_rdList = child.GetComponentsInChildren<Renderer>(true);
for (int j = 0; j < f_rdList.Length; j++)
{
if (f_rdList[j].transform)
{
SceneNodeCommpent node = new SceneNodeCommpent();
node.Trans = f_rdList[j].transform;
node.RootType = NodeRootType.FarRoot;
if (f_rdList[j] is MeshRenderer)
node.RenderType = RendererType.MeshRenderer;
else if (f_rdList[j] is SkinnedMeshRenderer)
node.RenderType = RendererType.SkinMesh;
else if (f_rdList[j] is ParticleSystemRenderer)
{
node.RenderType = RendererType.ParticleSystemRenderer;
node.RootType = NodeRootType.ParticFar;
}
AddNode(node);
}
}
}
else if (child.name == _nearName)
{
//添加Near节点
n_rdList = child.GetComponentsInChildren<Renderer>(true);
for (int j = 0; j < n_rdList.Length; j++)
{
if (n_rdList[j].transform)
{
SceneNodeCommpent node = new SceneNodeCommpent();
node.Trans = n_rdList[j].transform;
node.RootType = NodeRootType.NearRoot;
if (n_rdList[j] is MeshRenderer)
node.RenderType = RendererType.MeshRenderer;
else if (n_rdList[j] is SkinnedMeshRenderer)
node.RenderType = RendererType.SkinMesh;
else if (n_rdList[j] is ParticleSystemRenderer)
{
node.RenderType = RendererType.ParticleSystemRenderer;
node.RootType = NodeRootType.ParticNear;
}
AddNode(node);
}
}
}
else if (child.name == _midle)
{
//添加Midle节点
m_rdList = child.GetComponentsInChildren<Renderer>(true);
for (int j = 0; j < m_rdList.Length; j++)
{
if (m_rdList[j].transform)
{
SceneNodeCommpent node = new SceneNodeCommpent();
node.Trans = m_rdList[j].transform;
node.RootType = NodeRootType.MidleRoot;
if (m_rdList[j] is MeshRenderer)
node.RenderType = RendererType.MeshRenderer;
else if (m_rdList[j] is SkinnedMeshRenderer)
node.RenderType = RendererType.SkinMesh;
else if (m_rdList[j] is ParticleSystemRenderer)
{
node.RenderType = RendererType.ParticleSystemRenderer;
node.RootType = NodeRootType.ParticMidle;
}
AddNode(node);
}
}
}
else if (child.name == _vfxName)
{
for (int m = 0; m < child.childCount; m++)
{
var pChild = child.GetChild(m);
if (pChild.name == "[1]" || pChild.name == "[2]" || pChild.name == "[3]")
{
for (int k = 0; k < pChild.childCount; k++)
{
var ppChild = pChild.GetChild(k);
if (ppChild.name == "[far]")
{
pf_rdList = ppChild.GetComponentsInChildren<Renderer>(true);
//添加粒子Far节点
for (int n = 0; n < pf_rdList.Length; n++)
{
ParticleSystemRenderer prd = pf_rdList[n].GetComponent<ParticleSystemRenderer>();
if (prd != null)
{
SceneNodeCommpent node = new SceneNodeCommpent();
node.Trans = pf_rdList[n].transform;
node.RenderType = RendererType.ParticleSystemRenderer;
node.RootType = NodeRootType.ParticFar;
AddNode(node);
}
else
{
SceneNodeCommpent node = new SceneNodeCommpent();
node.Trans = pf_rdList[n].transform;
node.RootType = NodeRootType.NearRoot;
if (pf_rdList[n] is MeshRenderer)
node.RenderType = RendererType.MeshRenderer;
else if (pf_rdList[n] is SkinnedMeshRenderer)
node.RenderType = RendererType.SkinMesh;
else if (pf_rdList[n] is TrailRenderer)
node.RenderType = RendererType.TrailRender;
AddNode(node);
}
}
}
else if (ppChild.name == "[midle]")
{
pm_rdList = ppChild.GetComponentsInChildren<Renderer>(true);
//添加粒子Near节点
for (int n = 0; n < pm_rdList.Length; n++)
{
ParticleSystemRenderer prd = pm_rdList[n].GetComponent<ParticleSystemRenderer>();
if (prd != null)
{
SceneNodeCommpent node = new SceneNodeCommpent();
node.Trans = pm_rdList[n].transform;
node.RenderType = RendererType.ParticleSystemRenderer;
node.RootType = NodeRootType.ParticMidle;
AddNode(node);
}
else
{
SceneNodeCommpent node = new SceneNodeCommpent();
node.Trans = pm_rdList[n].transform;
node.RootType = NodeRootType.MidleRoot;
if (pm_rdList[n] is MeshRenderer)
node.RenderType = RendererType.MeshRenderer;
else if (pm_rdList[n] is SkinnedMeshRenderer)
node.RenderType = RendererType.SkinMesh;
else if (pm_rdList[n] is TrailRenderer)
node.RenderType = RendererType.TrailRender;
AddNode(node);
}
}
}
else if (ppChild.name == "[near]")
{
pn_rdList = ppChild.GetComponentsInChildren<Renderer>(true);
//添加粒子Near节点
for (int n = 0; n < pn_rdList.Length; n++)
{
ParticleSystemRenderer prd = pn_rdList[n].GetComponent<ParticleSystemRenderer>();
if (prd != null)
{
SceneNodeCommpent node = new SceneNodeCommpent();
node.Trans = pn_rdList[n].transform;
node.RenderType = RendererType.ParticleSystemRenderer;
node.RootType = NodeRootType.ParticNear;
AddNode(node);
}
else
{
SceneNodeCommpent node = new SceneNodeCommpent();
node.Trans = pn_rdList[n].transform;
node.RootType = NodeRootType.NearRoot;
if (pn_rdList[n] is MeshRenderer)
node.RenderType = RendererType.MeshRenderer;
else if (pn_rdList[n] is SkinnedMeshRenderer)
node.RenderType = RendererType.SkinMesh;
else if (pn_rdList[n] is TrailRenderer)
node.RenderType = RendererType.TrailRender;
AddNode(node);
}
}
}
else if (ppChild.name == "[nearHide]")
{
pn_rdList_hide = ppChild.GetComponentsInChildren<Renderer>(true);
//添加粒子Near节点
for (int n = 0; n < pn_rdList_hide.Length; n++)
{
ParticleSystemRenderer prd = pn_rdList[n].GetComponent<ParticleSystemRenderer>();
if (prd != null)
{
SceneNodeCommpent node = new SceneNodeCommpent();
node.Trans = pn_rdList_hide[n].transform;
node.RenderType = RendererType.ParticleSystemRenderer;
node.RootType = NodeRootType.ParticNearHide;
AddNode(node);
}
else
{
SceneNodeCommpent node = new SceneNodeCommpent();
node.Trans = pn_rdList_hide[n].transform;
node.RootType = NodeRootType.NearRoot;
if (pn_rdList_hide[n] is MeshRenderer)
node.RenderType = RendererType.MeshRenderer;
else if (pn_rdList_hide[n] is SkinnedMeshRenderer)
node.RenderType = RendererType.SkinMesh;
else if (pn_rdList_hide[n] is TrailRenderer)
node.RenderType = RendererType.TrailRender;
AddNode(node);
}
}
}
}
}
else
{
ot_rdList = pChild.GetComponentsInChildren<Renderer>(true);
//添加粒子Near节点
for (int n = 0; n < ot_rdList.Length; n++)
{
ParticleSystemRenderer prd = ot_rdList[n].GetComponent<ParticleSystemRenderer>();
if (prd != null)
{
SceneNodeCommpent node = new SceneNodeCommpent();
node.Trans = ot_rdList[n].transform;
node.RenderType = RendererType.ParticleSystemRenderer;
node.RootType = NodeRootType.Other;
AddNode(node);
}
else
{
SceneNodeCommpent node = new SceneNodeCommpent();
node.Trans = ot_rdList[n].transform;
node.RootType = NodeRootType.Other;
if (ot_rdList[n] is MeshRenderer)
node.RenderType = RendererType.MeshRenderer;
else if (ot_rdList[n] is SkinnedMeshRenderer)
node.RenderType = RendererType.SkinMesh;
else if (ot_rdList[n] is TrailRenderer)
node.RenderType = RendererType.TrailRender;
AddNode(node);
}
}
}
}
}
else if (child.name == _timeLine)
{
ot_rdList = child.GetComponentsInChildren<Renderer>(true);
for (int j = 0; j < ot_rdList.Length; j++)
{
if (ot_rdList[j].transform)
{
SceneNodeCommpent node = new SceneNodeCommpent();
node.Trans = ot_rdList[j].transform;
node.RootType = NodeRootType.FarRoot;
if (ot_rdList[j] is MeshRenderer)
node.RenderType = RendererType.MeshRenderer;
else if (ot_rdList[j] is SkinnedMeshRenderer)
node.RenderType = RendererType.SkinMesh;
else if (ot_rdList[j] is ParticleSystemRenderer)
node.RenderType = RendererType.ParticleSystemRenderer;
else if (ot_rdList[j] is TrailRenderer)
node.RenderType = RendererType.TrailRender;
AddNode(node);
}
}
}
else
{
ot_rdList = child.GetComponentsInChildren<Renderer>(true);
for (int j = 0; j < ot_rdList.Length; j++)
{
if (ot_rdList[j].transform)
{
SceneNodeCommpent node = new SceneNodeCommpent();
node.Trans = ot_rdList[j].transform;
node.RootType = NodeRootType.Other;
if (ot_rdList[j] is MeshRenderer)
node.RenderType = RendererType.MeshRenderer;
else if (ot_rdList[j] is SkinnedMeshRenderer)
node.RenderType = RendererType.SkinMesh;
else if (ot_rdList[j] is ParticleSystemRenderer)
node.RenderType = RendererType.ParticleSystemRenderer;
else if (ot_rdList[j] is TrailRenderer)
node.RenderType = RendererType.TrailRender;
AddNode(node);
}
}
}
}
}
private void AddNode(SceneNodeCommpent node)
{
if (node != null)
{
node.IsActive = node.Trans.gameObject.activeSelf;
_childs.Add(node);
}
}
//开始lodmesh
private void SplitScene()
{
_isHideObj = !string.Equals(SceneManager.GetActiveScene().name, "map039");
InitRoot();
//_sceneScript = ScriptableObject.CreateInstance<SceneAssetsDiscriptFile>();
_sceneScript = RequireComponent<SceneAssetsDiscriptFile>(_sceneRoot);
_sceneScript.Initialized();
CalScene();
//#if UNITY_EDITOR
// EditorCoroutineRunner.StartEditorCoroutine();
//#endif
}
private void CalScene()
{
Vector2 min = Vector2.zero;
Vector2 max = Vector2.zero;
bool isInitMinMax = false;
for (int i = 0; i < _childs.Count; i++)
{
if (!_childs[i].Trans.gameObject.activeSelf)
continue;
Vector3 childMin = Vector3.zero;
Vector3 childMax = Vector3.zero;
var rd = _childs[i].Trans.GetComponent<Renderer>();
Mesh ms = null;
if (_childs[i].RenderType == RendererType.MeshRenderer)
{
MeshFilter mf = _childs[i].Trans.GetComponent<MeshFilter>();
ms = mf.sharedMesh;
}
else if (_childs[i].RenderType == RendererType.SkinMesh)
{
SkinnedMeshRenderer skinRender = _childs[i].Trans.GetComponent<SkinnedMeshRenderer>();
ms = skinRender.sharedMesh;
}
else if (_childs[i].RenderType == RendererType.ParticleSystemRenderer)
{
ParticleSystemRenderer prd = _childs[i].Trans.GetComponent<ParticleSystemRenderer>();
if (prd.meshCount != 0)
{
Mesh[] msArray = new Mesh[prd.meshCount];
prd.GetMeshes(msArray);
for (int j = 0; j < msArray.Length; j++)
{
if (_childs[i] == null || msArray[j] == null)
break;
ms = msArray[j];
break;
}
}
}
if (ms == null)
continue;
Vector3[] tempVec = ms.vertices;
for (int j = 0; j < tempVec.Length; j++)
{
//var time = Time.realtimeSinceStartup;
Vector3 worldVec = _childs[i].Trans.TransformPoint(tempVec[j]);
//获取最小坐标和最大坐标
if (!isInitMinMax)
{
min.x = worldVec.x;
min.y = worldVec.z;
max.x = worldVec.x;
max.y = worldVec.z;
isInitMinMax = true;
}
else
{
min.x = worldVec.x < min.x ? worldVec.x : min.x;
min.y = worldVec.z < min.y ? worldVec.z : min.y;
max.x = worldVec.x > max.x ? worldVec.x : max.x;
max.y = worldVec.z > max.y ? worldVec.z : max.y;
}
if (j == 0)
{
childMin.x = worldVec.x;
childMin.y = worldVec.z;
childMax.x = worldVec.x;
childMax.y = worldVec.z;
}
else
{
childMin.x = worldVec.x < childMin.x ? worldVec.x : childMin.x;
childMin.y = worldVec.z < childMin.y ? worldVec.z : childMin.y;
childMax.x = worldVec.x > childMax.x ? worldVec.x : childMax.x;
childMax.y = worldVec.z > childMax.y ? worldVec.z : childMax.y;
}
//time = Time.realtimeSinceStartup - time;
//UnityEngine.Debug.LogError("11111111111111111111---------:" + time);
}
_childs[i].Min = childMin;
_childs[i].Max = childMax;
}
if (Math.Abs(max.x - min.x) > 2048 || Math.Abs(max.y - min.y) > 2048)
{
#if UNITY_EDITOR
UnityEditor.SceneManagement.EditorSceneManager.CloseScene(SceneManager.GetActiveScene(), true);
Debug.LogError(string.Format("场景有一个非鸡儿远的节点！！！！！！！！！快点检查，内存着不住了了！！！！！场景名字是：{0}", SceneManager.GetActiveScene().name));
return;
#endif
}
for (int i = 0; i < (int)CellType.Count; i++)
{
_sceneScript.SetRegion(min, max, (CellType)i);
var parts = _sceneScript.GetParts((CellType)i);
CheckChild(parts, (CellType)i);
}
for (int i = 0; i < (int)CellType.Count; i++)
{
var parts = _sceneScript.GetParts((CellType)i);
for (int m = 0; m < _childs.Count; m++)
{
DifferentNode(parts, _childs[m], (CellType)i);
if (_isHideObj)
{
_childs[m].Trans.gameObject.SetActive(false);
}
}
}
for (int i = 0; i < (int)CellType.Count; i++)
{
var parts = _sceneScript.GetParts((CellType)i);
CheckPart(parts, (CellType)i);
}
//_sceneScript.ConvertMeshPath();
_sceneScript.ConvertTexPath();
_sceneScript.ConvertMatProperty();
_sceneScript.ConvertCombinMeshPath();
//合并场景网格
//CombinMesh();
//AssetDatabase.CreateAsset(_sceneScript, "Assets/TestScript/SceneAssetsDiscriptFile.asset");
#if UNITY_EDITOR
//测试写材质球名字
//SaveCSV();
UnityEditor.SceneManagement.EditorSceneManager.SaveScene(SceneManager.GetActiveScene());
UnityEditor.SceneManagement.EditorSceneManager.CloseScene(SceneManager.GetActiveScene(), true);
#endif
_childs.Clear();
//Resources.UnloadAsset()
GC.Collect();
GC.WaitForPendingFinalizers();
}
public void SaveCSV()
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
//写出列名称
for (int i = 0; i < _sceneScript.MatP_Dic.Length; i++)
{
var matInfo = _sceneScript.MatP_Dic[i];
sb.Append(string.Format("材质球名字： {0} ", matInfo.matName));
sb.Append("\n");
}
System.IO.File.WriteAllText("EditorOut/" + "场景导出mat名字.csv", sb.ToString(), System.Text.Encoding.UTF8);
Debug.LogFormat("结果文件被存储到：{0}", "EditorOut/" + "场景导出mat名字.csv");
}
private Material GetReplaceMat()
{
if (_replaceMat == null)
{
Shader sh = Shader.Find("Gonbest/FallBack/FBWithLightmap");
Material mat = new Material(sh);
_replaceShader = sh;
_replaceMat = mat;
}
return _replaceMat;
}
private Material GetDefaultMat()
{
if (_defaultMat == null)
{
Shader sh = Shader.Find("Ares/Scene/NoDiffuse");
Material mat = new Material(sh);
_defaultShader = sh;
_defaultMat = mat;
}
return _defaultMat;
}
private void CheckChild(RegionPart[] parts, CellType type)
{
for (int i = 0; i < _childs.Count; i++)
{
Bounds bounds;
switch (_childs[i].RenderType)
{
case RendererType.MeshRenderer:
{
Mesh ms = _childs[i].Trans.GetComponent<MeshFilter>().sharedMesh;
Transform trans = _childs[i].Trans;
if (trans == null || ms == null)
break;
bounds = GetBounds(_childs[i], ms);
_childs[i].SetBounds(bounds);
SetCommpentPart(parts,type, _childs[i], bounds);
}
break;
case RendererType.SkinMesh:
{
SkinnedMeshRenderer skinnedRender = _childs[i].Trans.GetComponent<SkinnedMeshRenderer>();
if (_childs[i].Trans == null || skinnedRender.sharedMesh == null)
break;
bounds = GetBounds(_childs[i], skinnedRender.sharedMesh);
_childs[i].SetBounds(bounds);
SetCommpentPart(parts, type, _childs[i], bounds);
}
break;
case RendererType.ParticleSystemRenderer:
{
ParticleSystemRenderer prd = _childs[i].Trans.GetComponent<ParticleSystemRenderer>();
if (prd.meshCount == 0)
{
SetCommpentPart(parts, type, _childs[i]);
}
else
{
Mesh[] msArray = new Mesh[prd.meshCount];
prd.GetMeshes(msArray);
for (int j = 0; j < msArray.Length; j++)
{
if (_childs[i] == null || msArray[j] == null)
break;
//bounds = GetBounds(_childs[i], msArray[j]);
bounds = GetParticleBounds(_childs[i], msArray[j]);
SetCommpentPart(parts, type, _childs[i], bounds, j != 0 ? true : false);
}
}
}
break;
case RendererType.TrailRender:
{
TrailRenderer trd = _childs[i].Trans.GetComponent<TrailRenderer>();
var center = _childs[i].Trans.localToWorldMatrix.MultiplyPoint3x4(trd.bounds.center);
var extents = trd.bounds.extents;
var childMin = center - extents;
var childMax = center + extents;
var tr_Bounds = new Bounds(center, extents * 2);
tr_Bounds.min = childMin;
tr_Bounds.max = childMax;
SetCommpentPart(parts, type, _childs[i], tr_Bounds);
_childs[i].SetBounds(tr_Bounds);
}
break;
}
}
//for (int i = 0; i < parts.Length; i++)
//{
// var part = parts[i];
// if (part.Descripts == null || (part.Descripts != null && part.Descripts.Length == 0))
// {
// part.IsAvailable = false;
// }
//}
}
private void CheckPart(RegionPart[] parts, CellType type)
{
for (int i = 0; i < parts.Length; i++)
{
var part = parts[i];
var nodeList = part.GetNodes();
List<SceneAssetDescript> dataList = new List<SceneAssetDescript>();
for (int m = 0; m < nodeList.Count; m++)
{
var node = nodeList[m];
Bounds bounds = new Bounds();
switch (node.RenderType)
{
case RendererType.MeshRenderer:
{
Mesh ms = node.Trans.GetComponent<MeshFilter>().sharedMesh;
Transform trans = node.Trans;
if (trans == null || ms == null)
break;
var data = GetDataFile(node);
dataList.Add(data);
MeshFilter mf = node.Trans.GetComponent<MeshFilter>();
MeshRenderer mRd = node.Trans.GetComponent<MeshRenderer>();
if (node.IsUseDefaultShader)
{
Material mat = GetDefaultMat();
mRd.sharedMaterials = new Material[] { mat };
}
else
{
Material mat = GetReplaceMat();
mRd.sharedMaterials = new Material[] { mat };
}
}
break;
case RendererType.SkinMesh:
{
SkinnedMeshRenderer skinnedRender = node.Trans.GetComponent<SkinnedMeshRenderer>();
if (node.Trans == null || skinnedRender.sharedMesh == null)
break;
var data = GetDataFile(node);
dataList.Add(data);
if (node.IsUseDefaultShader)
{
Material mat = GetDefaultMat();
skinnedRender.sharedMaterials = new Material[] { mat };
}
else
{
Material mat = GetReplaceMat();
skinnedRender.sharedMaterials = new Material[] { mat };
}
//skinnedRender.sharedMaterials = new Material[0];
//skinnedRender.sharedMesh = null;
}
break;
case RendererType.ParticleSystemRenderer:
{
ParticleSystemRenderer prd = node.Trans.GetComponent<ParticleSystemRenderer>();
if (prd.meshCount == 0)
{
var data = GetDataFile(node);
dataList.Add(data);
}
else
{
Mesh[] msArray = new Mesh[prd.meshCount];
prd.GetMeshes(msArray);
for (int j = 0; j < msArray.Length; j++)
{
if (node == null || msArray[j] == null)
break;
bounds = GetBounds(node, msArray[j]);
var data = GetDataFile(node, bounds);
dataList.Add(data);
}
}
if (node.IsUseDefaultShader)
{
Material mat = GetDefaultMat();
int lenght = prd.sharedMaterials.Length;
prd.sharedMaterials = new Material[lenght];
for (int k = 0; k < lenght; k++)
{
prd.sharedMaterials[k] = mat;
}
}
else
{
Material mat = GetReplaceMat();
int lenght = prd.sharedMaterials.Length;
prd.sharedMaterials = new Material[lenght];
for (int k = 0; k < lenght; k++)
{
prd.sharedMaterials[k] = mat;
}
}
//prd.SetMeshes(new Mesh[0]);
//prd.sharedMaterials = new Material[0];
}
break;
case RendererType.TrailRender:
{
TrailRenderer trd = node.Trans.GetComponent<TrailRenderer>();
var center = node.Trans.localToWorldMatrix.MultiplyPoint3x4(trd.bounds.center);
var extents = trd.bounds.extents;
var childMin = center - extents;
var childMax = center + extents;
var tr_Bounds = new Bounds(center, extents * 2);
tr_Bounds.min = childMin;
tr_Bounds.max = childMax;
var data = GetDataFile(node, bounds);
dataList.Add(data);
if (node.IsUseDefaultShader)
{
Material mat = GetDefaultMat();
trd.sharedMaterials = new Material[] { mat };
}
else
{
Material mat = GetReplaceMat();
trd.sharedMaterials = new Material[] { mat };
}
}
break;
}
}
SortChilds(ref dataList);
part.Descripts = dataList.ToArray();
}
}
private SceneAssetDescript GetDataFile(SceneNodeCommpent node)
{
SceneAssetDescript discript = new SceneAssetDescript();
discript.NType = node.RootType;
Bounds bounds = node.GetBounds();
discript.SetBound(bounds);
discript.SetData(node, node.RenderType, _sceneScript);
return discript;
}
private SceneAssetDescript GetDataFile(SceneNodeCommpent node, Bounds bounds)
{
SceneAssetDescript discript = new SceneAssetDescript();
discript.NType = node.RootType;
discript.SetBound(bounds);
discript.SetData(node, node.RenderType, _sceneScript);
return discript;
}
private void SetCommpentPart(RegionPart[] parts,CellType type, SceneNodeCommpent node, Bounds bounds, bool isCheckName = false)
{
for (int j = 0; j < parts.Length; j++)
{
//if (j > 0)
// break;
bool isLast = j == parts.Length - 1 ? true : false;
//判断是否相交
bool isIntersects = parts[j].Intersects(bounds);
if (isIntersects)
{
parts[j].AddNode(node);
List<int> refrenceList = null;
if (node.RefrenceDic.ContainsKey((int)type))
{
refrenceList = node.RefrenceDic[(int)type];
refrenceList.Add(j);
}
else
{
refrenceList = new List<int>();
refrenceList.Add(j);
node.RefrenceDic.Add((int)type, refrenceList);
}
}
}
}
private void SetCommpentPart(RegionPart[] parts, CellType type, SceneNodeCommpent node, bool isCheckName = false)
{
for (int j = 0; j < parts.Length; j++)
{
//if (j > 0)
// break;
bool isLast = j == parts.Length - 1 ? true : false;
//判断是否相交
Bounds bounds = GetParticleBounds(node, null);
node.SetBounds(bounds);
bool isIntersects = parts[j].Intersects(bounds);
if (isIntersects)
{
parts[j].AddNode(node);
List<int> refrenceList = null;
if (node.RefrenceDic.ContainsKey((int)type))
{
refrenceList = node.RefrenceDic[(int)type];
refrenceList.Add(j);
}
else
{
refrenceList = new List<int>();
refrenceList.Add(j);
node.RefrenceDic.Add((int)type, refrenceList);
}
}
}
}
private void DifferentNode(RegionPart[] parts,SceneNodeCommpent node, CellType type)
{
List<int> list = node.GetRefrenceIds(CellType.Level_2);
RefrenceSize size = _sceneScript.GetRefSize(type);
if (list != null)
{
if (list.Count < size.Min || list.Count >= size.Max)
{
list = node.GetRefrenceIds(type);
for (int i = 0; list != null && i < list.Count; i++)
{
_tempNodeList.Clear();
//List<SceneAssetDescript> desList = new List<SceneAssetDescript>();
//for (int m = 0; m < parts[list[i]].Descripts.Length; m++)
//{
// if (parts[list[i]].Descripts[m].Trans != node.Trans)
// {
// desList.Add(parts[list[i]].Descripts[m]);
// }
//}
var nodeList = parts[list[i]].GetNodes();
for (int m = 0; m < nodeList.Count; m++)
{
if (nodeList[m].Trans != node.Trans)
{
_tempNodeList.Add(nodeList[m]);
}
}
//parts[list[i]].Descripts = desList.ToArray();
parts[list[i]].SetNodes(_tempNodeList);
}
}
}
}
private Bounds GetBounds(SceneNodeCommpent node, Mesh ms)
{
var center = node.Trans.localToWorldMatrix.MultiplyPoint3x4(ms.bounds.center);
var extents = new Vector3(Mathf.Abs(center.x - node.Min.x), 10, Mathf.Abs(center.z - node.Min.y));
var childMin = center - extents;
var childMax = center + extents;
var bounds = new Bounds(center, extents * 2);
bounds.min = childMin;
bounds.max = childMax;
return bounds;
}
private Bounds GetParticleBounds(SceneNodeCommpent node, Mesh ms)
{
Vector3 center = Vector3.zero;
Vector3 extents = Vector3.zero;
Bounds bounds;
ParticleSystem ps = node.Trans.GetComponent<ParticleSystem>();
if (ps.shape.enabled)
{
center = node.Trans.position;
extents = new Vector3(ps.shape.radius / 2, 10, ps.shape.radius / 2);
}
else
{
if (ms == null)
{
center = node.Trans.position;
extents = new Vector3(0.5f, 10, 0.5f);
}
else
{
//使用mesh来求
center = node.Trans.localToWorldMatrix.MultiplyPoint3x4(ms.bounds.center);
extents = new Vector3(Mathf.Abs(center.x - node.Min.x), 10, Mathf.Abs(center.z - node.Min.y));
}
}
var childMin = center - extents;
var childMax = center + extents;
bounds = new Bounds(center, extents * 2);
bounds.min = childMin;
bounds.max = childMax;
return bounds;
}
private void SortChilds(ref List<SceneAssetDescript> list)
{
if (list == null)
return;
list.Sort((x, y) =>
{
if (x.Sort > y.Sort)
{
return -1;
}
else if (x.Sort == y.Sort)
{
return 0;
}
else
{
return 1;
}
});
}
private void SetScale(Transform trans, ref float scale)
{
Transform parent = trans.parent;
if (parent)
{
scale *= parent.localScale.x;
SetScale(parent, ref scale);
}
}
//合并场景相同材质球的网格
//private void CombinMesh()
//{
// _dicCombinMesh.Clear();
// string combinPath = "GameAssets/Resources/Scene/CombinMesh";
// string floderPath = Application.dataPath + "/" + combinPath;
// if (!Directory.Exists(floderPath))
// Directory.CreateDirectory(floderPath);
// //开始合并mesh
// var enumer = _sceneScript.DicCombinData.GetEnumerator();
// try
// {
// while (enumer.MoveNext())
// {
// //新建一个合并组，长度与 meshfilters一致
// CombineInstance[] combineInstances = new CombineInstance[enumer.Current.Value.Count];
// for (int i = 0; i < enumer.Current.Value.Count; i++)
// {
// //将共享mesh，赋值
// combineInstances[i].mesh = enumer.Current.Value[i].mesh;
// //本地坐标转矩阵，赋值
// combineInstances[i].transform = enumer.Current.Value[i].trans.localToWorldMatrix;
// }
// //声明一个新网格对象
// Mesh newMesh = new Mesh();
// //MatAssetsProperty matProperty = _sceneScript.GetMatProperty(enumer.Current.Key);
// newMesh.name = string.Format("Comb_MatProperty_{0}_Mesh",enumer.Current.Key );
// //将combineInstances数组传入函数
// newMesh.CombineMeshes(combineInstances,false);
// //保存合并的网格
// string assetPath = "Assets/GameAssets/Resources/";
// string path = string.Format("Scene/CombinMesh/{0}", newMesh.name);
// assetPath = assetPath + path + ".asset";
// UnityEditor.AssetDatabase.CreateAsset(newMesh, assetPath);
// if (!_dicCombinMesh.ContainsKey(enumer.Current.Key))
// {
// _dicCombinMesh[enumer.Current.Key] = newMesh;
// }
// }
// }
// finally
// {
// enumer.Dispose();
// }
//}
//获取或者添加脚本
private T RequireComponent<T>(GameObject go) where T : Component
{
T ret = go.GetComponent<T>();
if (ret == null)
{
ret = go.AddComponent<T>();
}
return ret;
}
#endregion
#region//公共函数
public static void SplitSceneData()
{
SceneSplit split = new SceneSplit();
split.SplitScene();
}
#endregion
}
}