bool OnGUISelectLayers()
{
MeshShadowReceiver receiver = null;
if (0 < m_projectorManager.receivers.Count)
{
receiver = m_projectorManager.receivers[0] as MeshShadowReceiver;
}
if (receiver == null)
{
if (m_isGoingBack)
{
--m_currentPage;
}
else
{
++m_currentPage;
}
return(false);
}
EditorGUILayout.PropertyField(m_serializedObject.FindProperty("m_receiverLayerMask"));
m_serializedObject.ApplyModifiedProperties();
GUILayout.TextArea("Receiver Layer Mask is used to assign a unique layer to each shadow receiver instance so that only the projector associated with the shadow receiver instance can cast a shadow on it.\n" +
"If \"Nothing\" is specified, all the unnamed layers will be used.");
m_isAbleToGoNext = true;
return(true);
}
public static void CreateWizard(Transform meshTransform, LayerMask layers, MeshShadowReceiver receiver)
{
CreateMeshTreeWizard window = ScriptableObject.CreateInstance <CreateMeshTreeWizard>();
window.Initialize(meshTransform, layers, receiver);
window.title = "Create Mesh Tree";
window.ShowUtility();
}
void Initialize(Transform meshTransform, LayerMask layers, MeshShadowReceiver receiver)
{
m_rootObject = meshTransform.gameObject;
m_receiver = receiver;
m_layers = layers;
m_currentPage = 0;
m_srcMesh = null;
Terrain terrain = m_rootObject.GetComponent <Terrain>();
if (terrain != null)
{
m_srcMesh = terrain.terrainData;
}
m_errorString = null;
if (m_srcMesh == null)
{
m_meshes = m_rootObject.GetComponentsInChildren <MeshFilter>();
if (m_meshes == null || m_meshes.Length == 0)
{
// error
m_currentPage = -1;
m_errorString = "<color=red>Object \"" + meshTransform.name + "\" does not contain any meshes! Cannot create MeshShadowReceiver.</color>";
}
else
{
GameObject prefabObject = PrefabUtility.GetPrefabParent(m_rootObject) as GameObject;
if (prefabObject != null)
{
m_srcMesh = prefabObject;
}
else
{
m_srcMesh = m_rootObject;
}
}
}
m_errorStyle = new GUIStyle();
m_errorStyle.richText = true;
m_errorStyle.wordWrap = true;
}
bool OnGUISetEnvironment()
{
MeshShadowReceiver receiver = null;
if (0 < m_projectorManager.receivers.Count)
{
receiver = m_projectorManager.receivers[0] as MeshShadowReceiver;
}
GameObject rootObject = null;
MeshTreeBase meshTree = null;
if (receiver != null)
{
if (receiver.meshTransform != null)
{
rootObject = receiver.meshTransform.gameObject;
}
meshTree = receiver.meshTree;
GameObject newRootObject = EditorGUILayout.ObjectField("Root Object", rootObject, typeof(GameObject), true) as GameObject;
if (newRootObject != rootObject)
{
Undo.RecordObject(receiver, "Easy Setup: Set Root Object");
receiver.meshTransform = (newRootObject == null) ? null : newRootObject.transform;
EditorUtility.SetDirty(receiver);
rootObject = newRootObject;
m_environmentMeshes = null;
}
}
EditorGUILayout.PropertyField(m_serializedObject.FindProperty("m_environmentLayers"));
m_serializedObject.ApplyModifiedProperties();
bool findObject = false;
if (receiver != null && receiver.meshTransform != null)
{
// check Environment Layers
for (int i = 0; i < environmentMeshes.Length; ++i)
{
if ((m_projectorManager.environmentLayers & (1 << environmentMeshes[i].gameObject.layer)) != 0)
{
findObject = true;
break;
}
}
if (!findObject)
{
GUILayout.TextArea("<color=red>No child objects of Root Object found in Environment Layers.</color>", m_errorStyle);
}
}
GUILayout.TextArea("The objects in the Environment Layers will be ignored by Projectors. They will not receive the shadows casted by the Projectors. Instead, shadow receiver will receive the shadows on behalf of them.");
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (GUILayout.Button("Edit Layers"))
{
Selection.activeObject = AssetDatabase.LoadAllAssetsAtPath("ProjectSettings/TagManager.asset")[0];
}
if (receiver != null)
{
if (rootObject == null)
{
GUI.enabled = false;
}
if (GUILayout.Button("Collect Layers from Root Object"))
{
LayerMask layers = 0;
MeshFilter[] meshes = rootObject.GetComponentsInChildren <MeshFilter>();
{
var __array1 = meshes;
var __arrayLength1 = __array1.Length;
for (int __i1 = 0; __i1 < __arrayLength1; ++__i1)
{
var mesh = (MeshFilter)__array1[__i1];
{
layers |= (1 << mesh.gameObject.layer);
}
}
}
if (layers != m_projectorManager.environmentLayers)
{
Undo.RecordObject(m_projectorManager, "Easy Setup: Collect Layers from Root Object");
m_projectorManager.environmentLayers = layers;
EditorUtility.SetDirty(m_projectorManager);
m_serializedObject.Update();
}
}
GUI.enabled = true;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.Separator();
if (receiver == null)
{
m_isAbleToGoNext = m_projectorManager.environmentLayers != 0;
return(true);
}
MeshTreeBase newMeshTree = EditorGUILayout.ObjectField("Mesh Tree", meshTree, typeof(MeshTreeBase), false) as MeshTreeBase;
if (newMeshTree != meshTree)
{
Undo.RecordObject(receiver, "Easy Setup: Set Mesh Tree");
receiver.meshTree = newMeshTree;
meshTree = newMeshTree;
EditorUtility.SetDirty(receiver);
}
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (rootObject == null || !findObject)
{
GUI.enabled = false;
}
if (GUILayout.Button("Search Assets folder"))
{
newMeshTree = MeshShadowReceiverEditor.FindMeshTreeFromMeshTransform(rootObject.transform);
if (newMeshTree == null)
{
EditorUtility.DisplayDialog("No mesh tree found for the Root Object.", "", "OK");
}
else
{
Undo.RecordObject(receiver, "Easy Setup: Set Mesh Tree");
receiver.meshTree = newMeshTree;
meshTree = newMeshTree;
EditorUtility.SetDirty(receiver);
}
}
if (GUILayout.Button("Create a New Mesh Tree"))
{
CreateMeshTreeWizard.CreateWizard(rootObject.transform, m_projectorManager.environmentLayers, receiver);
}
GUI.enabled = true;
EditorGUILayout.EndHorizontal();
m_errorString = null;
LayerMask missingLayers = 0;
LayerMask existingLayers = 0;
bool multiObjectMeshTree = false;
if (meshTree != null && rootObject != null)
{
if (meshTree is TerrainMeshTree)
{
Terrain terrain = rootObject.GetComponent <Terrain>();
if (terrain == null)
{
m_errorString = "<color=red>The mesh tree is a TerrainMeshTree but Root Object is not a terrain object.</color>";
}
else if (terrain.terrainData != ((TerrainMeshTree)meshTree).terrainData)
{
m_errorString = "<color=red>The mesh tree was not the one which was created from the Root Object</color>";
}
else if ((m_projectorManager.environmentLayers & (1 << rootObject.layer)) == 0)
{
m_errorString = "<color=red>Environment Layers doesn't contain the layer of the Root Object.</color>";
missingLayers |= (1 << rootObject.layer);
}
}
else
{
Object srcMesh = ((MeshTree)meshTree).srcMesh;
if (srcMesh is Mesh)
{
MeshFilter mesh = rootObject.GetComponent <MeshFilter>();
if (mesh == null || mesh.sharedMesh != srcMesh)
{
m_errorString = "<color=red>The mesh tree was created from a single mesh but the Root Object doesn't have the mesh.</color>";
}
else if ((m_projectorManager.environmentLayers & (1 << rootObject.layer)) == 0)
{
m_errorString = "<color=red>Environment Layers doesn't contain the layer of the Root Object.</color>";
missingLayers |= (1 << rootObject.layer);
}
}
else
{
multiObjectMeshTree = true;
if (srcMesh != null)
{
if (PrefabUtility.GetPrefabParent(rootObject) != srcMesh && rootObject != srcMesh)
{
PrefabType type = PrefabUtility.GetPrefabType(srcMesh);
if (type == PrefabType.Prefab || type == PrefabType.ModelPrefab)
{
m_errorString = "<color=red>The mesh tree was created from a prefab object but the Root Object was not instantiated from the prefab.</color>";
}
else
{
m_errorString = "<color=red>The mesh tree was not created from the Root Object.</color>";
}
}
}
if (m_errorString == null)
{
MeshFilter[] meshes = rootObject.GetComponentsInChildren <MeshFilter>();
LayerMask meshTreeLayers = ((MeshTree)meshTree).layerMask;
{
var __array2 = meshes;
var __arrayLength2 = __array2.Length;
for (int __i2 = 0; __i2 < __arrayLength2; ++__i2)
{
var mesh = (MeshFilter)__array2[__i2];
{
if ((meshTreeLayers & (1 << mesh.gameObject.layer)) != 0)
{
if ((m_projectorManager.environmentLayers & (1 << mesh.gameObject.layer)) == 0)
{
missingLayers |= (1 << mesh.gameObject.layer);
}
else
{
existingLayers |= (1 << mesh.gameObject.layer);
}
}
}
}
}
if (missingLayers != 0)
{
m_errorString = "<color=red>Some of the mesh tree layers are missing in Environment Layers.</color>";
}
}
}
}
}
if (m_errorString != null)
{
GUILayout.TextArea(m_errorString, m_errorStyle);
if (missingLayers != 0)
{
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (GUILayout.Button("Add mesh tree layers to Environment Layers"))
{
Undo.RecordObject(m_projectorManager, "Easy Setup: Add mesh tree layers to Environment Layers");
m_projectorManager.environmentLayers |= missingLayers;
EditorUtility.SetDirty(m_projectorManager);
m_serializedObject.Update();
}
EditorGUILayout.EndHorizontal();
if (multiObjectMeshTree && existingLayers != 0)
{
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (GUILayout.Button("Rebuild the mesh tree with Environment Layers"))
{
((MeshTree)meshTree).layerMask &= ~missingLayers;
if (((MeshTree)meshTree).srcMesh == null)
{
((MeshTree)meshTree).srcMesh = rootObject;
}
MeshTreeEditor.BuildMeshTree(meshTree);
}
EditorGUILayout.EndHorizontal();
}
}
}
m_isAbleToGoNext = rootObject != null && meshTree != null && m_errorString == null && m_projectorManager.environmentLayers != 0;
return(true);
}
bool OnGUISetMeshShadowReceiver()
{
MeshShadowReceiver receiver = null;
if (0 < m_projectorManager.receivers.Count)
{
receiver = m_projectorManager.receivers[0] as MeshShadowReceiver;
}
MeshShadowReceiver newReceiver = EditorGUILayout.ObjectField("Mesh Shadow Receiver", receiver, typeof(MeshShadowReceiver), true) as MeshShadowReceiver;
if (receiver != newReceiver)
{
Undo.RecordObject(m_projectorManager, "Easy Setup: Select Shadow Receiver");
if (receiver != null)
{
m_projectorManager.RemoveReceiver(receiver);
}
if (newReceiver != null)
{
m_projectorManager.AddReceiver(newReceiver);
}
EditorUtility.SetDirty(m_projectorManager);
receiver = newReceiver;
}
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (GUILayout.Button("Create a New Shadow Receiver"))
{
GameObject go = new GameObject("Shadow Receiver");
newReceiver = go.AddComponent <MeshShadowReceiver>();
EditorSettings editorSettings = EditorSettings.GetSettings(UnityEditor.MonoScript.FromScriptableObject(this));
Renderer renderer = newReceiver.GetComponent <Renderer>();
renderer.sharedMaterial = editorSettings.m_defaultReceiverMaterial;
#if (UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_4_7) // support Unity 4.3 or later
renderer.castShadows = false;
#else
renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
renderer.reflectionProbeUsage = UnityEngine.Rendering.ReflectionProbeUsage.Off;
#endif
renderer.useLightProbes = false;
renderer.receiveShadows = false;
newReceiver.hasNormals = true;
go.transform.parent = m_projectorManager.transform;
Undo.RegisterCreatedObjectUndo(go, "Easy Setup: Create Shadow Receiver");
Undo.RecordObject(m_projectorManager, "Easy Setup: Create Shadow Receiver");
if (receiver != null)
{
m_projectorManager.RemoveReceiver(receiver);
}
if (newReceiver != null)
{
m_projectorManager.AddReceiver(newReceiver);
}
EditorUtility.SetDirty(m_projectorManager);
receiver = newReceiver;
}
EditorGUILayout.EndHorizontal();
GUILayout.TextArea("Mesh Shadow Receiver is necessary for casting shadows on the environment mesh surface. " +
"If the environment is flat or doesn't have high curvature points, you don't need Mesh Shadow Receiver. " +
"Instead, shadows can be casted on an infinite plane or a tangent plane at a point where raycast hits.");
m_isAbleToGoNext = true;
return(true);
}
public override void OnInspectorGUI()
{
MeshShadowReceiver receiver = target as MeshShadowReceiver;
Transform oldMeshTransform = receiver.meshTransform;
MeshTreeBase oldMeshTree = receiver.meshTree;
if (!string.IsNullOrEmpty(m_errorString))
{
EditorGUILayout.TextArea(m_errorString, errorStyle);
}
base.OnInspectorGUI();
SerializedProperty property = serializedObject.FindProperty("m_enablePrediction");
bool bPredictEnabled = EditorGUILayout.Toggle("Enable Prediction", property.boolValue);
if (bPredictEnabled != property.boolValue)
{
Undo.RecordObject(target, "Inspector");
property.boolValue = bPredictEnabled;
EditorUtility.SetDirty(target);
}
if (bPredictEnabled)
{
Component predictor = (Component)EditorGUILayout.ObjectField("Predictor", receiver.predictor as Component, typeof(Component), true);
if (predictor != receiver.predictor)
{
if (predictor == null)
{
Undo.RecordObject(receiver, "Inspector");
receiver.predictor = null;
EditorUtility.SetDirty(receiver);
}
else
{
Component[] components = predictor.GetComponents <Component>();
for (int i = 0; i < components.Length; ++i)
{
if (components[i] is ITransformPredictor)
{
Undo.RecordObject(receiver, "Inspector");
receiver.predictor = components[i] as ITransformPredictor;
EditorUtility.SetDirty(receiver);
break;
}
}
}
}
}
property = serializedObject.FindProperty("m_updateOnlyWhenProjectorMoved");
bool bCheckMove = EditorGUILayout.Toggle("Update Only When Projector Moved", property.boolValue);
if (bCheckMove != property.boolValue)
{
Undo.RecordObject(target, "Inspector");
property.boolValue = bCheckMove;
EditorUtility.SetDirty(target);
}
if (bCheckMove)
{
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_margin"));
}
serializedObject.ApplyModifiedProperties();
if (receiver.meshTree == null && receiver.meshTransform != null)
{
if (receiver.meshTransform != oldMeshTransform)
{
// to make it easier to setup mesh shadow receiver, find a mesh tree from meshTransform.
MeshTreeBase meshTree = FindMeshTreeFromMeshTransform(receiver.meshTransform);
if (meshTree != null)
{
receiver.meshTree = meshTree;
EditorUtility.SetDirty(receiver);
}
}
// if not found, show create button
if (receiver.meshTree == null)
{
if (GUILayout.Button("Create a new MeshTree"))
{
LayerMask layers = -1;
if (receiver.unityProjector != null)
{
layers = receiver.unityProjector.ignoreLayers;
}
CreateMeshTreeWizard.CreateWizard(receiver.meshTransform, layers, receiver);
}
}
}
if (receiver.meshTree != null && receiver.meshTransform != null && (receiver.meshTree != oldMeshTree || receiver.meshTransform != oldMeshTransform))
{
string error = receiver.meshTree.CheckError(receiver.meshTransform.gameObject);
if (!string.IsNullOrEmpty(error))
{
Debug.LogError(error, receiver);
m_errorString = "<color=red>" + error + "</color>";
}
else
{
m_errorString = null;
}
}
}
