998 lines
47 KiB
C#
998 lines
47 KiB
C#
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
|
||
}
|
||
}
|
||
|
||
|