public static MeshTreeBase FindMeshTreeFromMeshTransform(Transform meshTransform)
{
Terrain terrain = meshTransform.GetComponent <Terrain>();
if (terrain != null && terrain.terrainData != null)
{
string[] trees = AssetDatabase.FindAssets("t:TerrainMeshTree");
{
var __array1 = trees;
var __arrayLength1 = __array1.Length;
for (int __i1 = 0; __i1 < __arrayLength1; ++__i1)
{
var guid = (string)__array1[__i1];
{
TerrainMeshTree meshTree = AssetDatabase.LoadAssetAtPath(AssetDatabase.GUIDToAssetPath(guid), typeof(TerrainMeshTree)) as TerrainMeshTree;
if (meshTree.terrainData == terrain.terrainData)
{
return(meshTree);
}
}
}
}
}
Object prefab = PrefabUtility.GetPrefabParent(meshTransform.gameObject);
if (prefab != null)
{
string[] trees = AssetDatabase.FindAssets("t:MeshTree");
{
var __array2 = trees;
var __arrayLength2 = __array2.Length;
for (int __i2 = 0; __i2 < __arrayLength2; ++__i2)
{
var guid = (string)__array2[__i2];
{
MeshTree meshTree = AssetDatabase.LoadAssetAtPath(AssetDatabase.GUIDToAssetPath(guid), typeof(MeshTree)) as MeshTree;
if (meshTree.srcMesh == prefab)
{
return(meshTree);
}
}
}
}
}
return(null);
}
public override void OnInspectorGUI()
{
MeshTreeBase meshTreeBase = target as MeshTreeBase;
if (meshTreeBase.IsBuilding())
{
GUI.enabled = false;
}
DrawDefaultInspector();
if (meshTreeBase is MeshTree)
{
MeshTree meshTree = meshTreeBase as MeshTree;
Object meshObject = EditorGUILayout.ObjectField(meshTree.srcMesh is Mesh ? "Mesh" : "Root Object", meshTree.srcMesh, typeof(Object), true);
if (meshObject != meshTree.srcMesh && meshObject is GameObject && Event.current.command)
{
MeshFilter meshFilter = ((GameObject)meshObject).GetComponent <MeshFilter>();
if (meshFilter != null && meshFilter.sharedMesh != null)
{
meshObject = meshFilter.sharedMesh;
}
}
if (meshObject != meshTree.srcMesh)
{
Undo.RegisterCompleteObjectUndo(meshTree, "Inspector");
meshTree.srcMesh = meshObject;
EditorUtility.SetDirty(meshTree);
}
if (meshObject is GameObject)
{
PrefabType prefabType = PrefabUtility.GetPrefabType(meshObject);
if (prefabType != PrefabType.Prefab && prefabType != PrefabType.ModelPrefab)
{
if (m_errorStyle == null)
{
m_errorStyle = new GUIStyle();
m_errorStyle.richText = true;
m_errorStyle.wordWrap = true;
}
GUILayout.TextArea("<color=red>A reference to a scene object will not be serialized in Asset data. You will need to set the root object again when you rebuild the tree. Use a prefab instead.</color>", m_errorStyle);
}
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_layerMask"));
SerializedProperty excludeRenderTypes = serializedObject.FindProperty("m_excludeRenderTypes");
excludeRenderTypes.isExpanded = EditorGUILayout.Foldout(excludeRenderTypes.isExpanded, "Exclude Render Types");
if (excludeRenderTypes.isExpanded)
{
for (int i = 0; i < excludeRenderTypes.arraySize + 1; ++i)
{
string renderType;
if (m_editingRenderType == i)
{
renderType = m_editingString;
}
else if (i < excludeRenderTypes.arraySize)
{
renderType = excludeRenderTypes.GetArrayElementAtIndex(i).stringValue;
}
else
{
renderType = "";
}
string controlName = "RenderType" + i.ToString();
GUI.SetNextControlName(controlName);
string newRenderType = EditorGUILayout.TextField(renderType);
string focusedControl = GUI.GetNameOfFocusedControl();
if (m_editingRenderType == i)
{
m_editingString = newRenderType;
if (focusedControl != controlName || (/*Event.current.isKey &&*/ (Event.current.keyCode == KeyCode.Return || Event.current.keyCode == KeyCode.KeypadEnter)))
{
ApplyEditingRenderType();
}
else if (/*Event.current.isKey &&*/ Event.current.keyCode == KeyCode.Escape)
{
CancelEditingRenderType();
}
}
else if (renderType != newRenderType)
{
ApplyEditingRenderType();
m_editingRenderType = i;
m_editingString = newRenderType;
}
}
}
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_scaledOffset"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_fixedOffset"));
serializedObject.ApplyModifiedProperties();
}
}
if (meshTreeBase is TerrainMeshTree)
{
TerrainMeshTree terrainMeshTree = meshTreeBase as TerrainMeshTree;
Object terrainObj = EditorGUILayout.ObjectField("Terrain Data", terrainMeshTree.terrainData, typeof(Object), true);
if (terrainObj != terrainMeshTree.terrainData)
{
TerrainData terrainData = terrainObj as TerrainData;
if (terrainData == null && terrainObj is GameObject)
{
Terrain terrain = ((GameObject)terrainObj).GetComponent <Terrain>();
if (terrain != null)
{
terrainData = terrain.terrainData;
}
}
if (terrainData != null || terrainObj == null)
{
terrainMeshTree.terrainData = terrainData;
}
}
}
if (meshTreeBase.IsBuilding())
{
GUI.enabled = true;
m_isBuilding = true;
EditorGUILayout.LabelField("Building... " + Mathf.FloorToInt(100 * meshTreeBase.GetBuildProgress()).ToString() + "%");
}
else
{
GUI.enabled = meshTreeBase.IsReadyToBuild();
if (m_isBuilding)
{
m_isBuilding = false;
m_memoryUsage = meshTreeBase.GetMemoryUsage();
EditorUtility.SetDirty(meshTreeBase);
}
if (meshTreeBase.IsPrebuilt())
{
m_showBuiltData = EditorGUILayout.Foldout(m_showBuiltData, "Built Tree Info");
if (m_showBuiltData)
{
string memorySize;
float mb = m_memoryUsage / (1024.0f * 1024.0f);
if (1.0f <= mb)
{
memorySize = mb.ToString("f3") + "MB";
}
else
{
float kb = m_memoryUsage / 1024.0f;
memorySize = kb.ToString("f3") + "KB";
}
EditorGUILayout.LabelField("Memory", memorySize);
EditorGUILayout.LabelField("Node Count", meshTreeBase.GetNodeCount().ToString());
}
}
if (GUILayout.Button(meshTreeBase.IsPrebuilt() ? "Rebuild" : "Build"))
{
ApplyEditingRenderType();
m_isBuilding = true;
BuildMeshTree(meshTreeBase);
}
}
GUI.enabled = true;
}
void OnGUISelectMeshTreeTypeAndCreate()
{
EditorGUILayout.LabelField("Type of Mesh Tree");
if (m_srcMesh is TerrainData)
{
EditorGUILayout.BeginHorizontal();
GUILayout.Space(30);
GUILayout.Label("Terrain Mesh Tree");
EditorGUILayout.EndHorizontal();
}
else
{
EditorGUILayout.BeginHorizontal();
GUILayout.Space(30);
bool bBinaryTree = GUILayout.Toggle(m_bBinaryTree, "Binary Mesh Tree");
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Space(30);
bool bOctree = GUILayout.Toggle(!m_bBinaryTree, "Oct Mesh Tree");
EditorGUILayout.EndHorizontal();
if (bOctree && m_bBinaryTree)
{
m_bBinaryTree = !bOctree;
}
else if (bBinaryTree && !m_bBinaryTree)
{
m_bBinaryTree = bBinaryTree;
}
EditorGUILayout.BeginHorizontal();
GUILayout.Space(30);
if (GUILayout.Button("<color=blue>What's the difference?</color>", m_errorStyle))
{
Application.OpenURL("http://nyahoon.com/products/fast-shadow-receiver/create-a-mesh-tree");
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.Separator();
EditorGUILayout.LabelField("Select Source Object");
EditorGUILayout.BeginHorizontal();
GUILayout.Space(30);
bool bSceneObject = GUILayout.Toggle(m_srcMesh == m_rootObject, "Scene Object");
EditorGUILayout.ObjectField(m_rootObject, typeof(GameObject), true);
EditorGUILayout.EndHorizontal();
if (bSceneObject && m_srcMesh != m_rootObject)
{
m_srcMesh = m_rootObject;
}
EditorGUILayout.BeginHorizontal();
GameObject prefabObject = PrefabUtility.GetPrefabParent(m_rootObject) as GameObject;
GUILayout.Space(30);
if (prefabObject == null)
{
GUI.enabled = false;
}
bool bPrefabObject = GUILayout.Toggle(m_srcMesh == prefabObject, "Prefab Object");
if (prefabObject != null)
{
EditorGUILayout.ObjectField(prefabObject, typeof(GameObject), true);
}
else
{
GUI.enabled = true;
if (GUILayout.Button("Create Prefab"))
{
string path = EditorUtility.SaveFilePanelInProject("Create Prefab", m_rootObject.name, "prefab", "Select a path for the prefab of " + m_rootObject.name);
if (!string.IsNullOrEmpty(path))
{
prefabObject = PrefabUtility.CreatePrefab(path, m_rootObject, ReplacePrefabOptions.ConnectToPrefab);
m_srcMesh = prefabObject;
bSceneObject = false;
}
}
}
EditorGUILayout.EndHorizontal();
if (bPrefabObject && m_srcMesh != prefabObject)
{
m_srcMesh = prefabObject;
}
if (m_srcMesh == m_rootObject)
{
EditorGUILayout.BeginHorizontal();
GUILayout.Space(30);
GUILayout.TextArea("<color=red>If you choose Scene Object, the reference to the object cannot be stored in Mesh Tree settings. So, you will need to set the reference again when you rebuild the mesh tree.</color>", m_errorStyle);
EditorGUILayout.EndHorizontal();
}
else if (m_srcMesh == prefabObject)
{
// check if m_rootObject is modified from prefabObject.
for (int i = 0; i < srcMeshes.Length; ++i)
{
GameObject go = srcMeshes[i].gameObject;
GameObject prefab = PrefabUtility.GetPrefabParent(go) as GameObject;
if (go.layer != prefab.layer)
{
EditorGUILayout.BeginHorizontal();
GUILayout.Space(30);
GUILayout.TextArea("<color=red>The layer of the scene object was modified from the prefab.</color>", m_errorStyle);
EditorGUILayout.ObjectField(go, typeof(GameObject), true);
EditorGUILayout.EndHorizontal();
break;
}
if (go.transform.localPosition != prefab.transform.localPosition || go.transform.localRotation != prefab.transform.localRotation || go.transform.localScale != prefab.transform.localScale)
{
EditorGUILayout.BeginHorizontal();
GUILayout.Space(30);
GUILayout.TextArea("<color=red>The transform of the scene object was modified from the prefab.</color>", m_errorStyle);
EditorGUILayout.ObjectField(go, typeof(GameObject), true);
EditorGUILayout.EndHorizontal();
break;
}
}
}
}
EditorGUILayout.Separator();
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (GUILayout.Button("Create Mesh Tree"))
{
string path = GetDefaultPathFromSourceMesh(m_srcMesh, m_bBinaryTree);
path = EditorUtility.SaveFilePanelInProject("Create New Mesh Tree", System.IO.Path.GetFileName(path), "asset", "Select a path for the new Mesh Tree", System.IO.Path.GetDirectoryName(path));
if (!string.IsNullOrEmpty(path))
{
MeshTreeBase meshTreeBase;
if (m_srcMesh is TerrainData)
{
TerrainMeshTree meshTree = ScriptableObject.CreateInstance <TerrainMeshTree>();
meshTree.terrainData = m_srcMesh as TerrainData;
meshTreeBase = meshTree;
}
else if (m_bBinaryTree)
{
BinaryMeshTree meshTree = ScriptableObject.CreateInstance <BinaryMeshTree>();
meshTree.srcMesh = m_srcMesh;
meshTree.layerMask = m_layers;
meshTree.scaledOffset = 1.0f;
meshTreeBase = meshTree;
}
else
{
OctMeshTree meshTree = ScriptableObject.CreateInstance <OctMeshTree>();
meshTree.srcMesh = m_srcMesh;
meshTree.layerMask = m_layers;
meshTree.scaledOffset = 1.0f;
meshTreeBase = meshTree;
}
AssetDatabase.CreateAsset(meshTreeBase, path);
AssetDatabase.Refresh();
m_meshTree = AssetDatabase.LoadAssetAtPath(path, typeof(MeshTreeBase)) as MeshTreeBase;
if (m_receiver != null)
{
m_receiver.meshTree = m_meshTree;
}
if (m_srcMesh is TerrainData)
{
// just build and close. because TerrainMeshTree doesn't have build options.
MeshTreeEditor.BuildMeshTree(m_meshTree);
Close();
}
else
{
m_serializedObject = new SerializedObject(m_meshTree);
++m_currentPage;
}
}
}
}
