| private IsPersistent ( Object target ) : bool | ||
| target | Object | |
| return | bool | |
static bool CreatePrefabVariantValidation()
{
var go = Selection.activeGameObject;
return(go != null && EditorUtility.IsPersistent(go));
}
internal static IEnumerable <Object> DuplicateAssets(IEnumerable <Object> assets)
{
AssetDatabase.Refresh();
var copiedPaths = new List <string>();
Object firstDuplicatedObjectToFail = null;
foreach (var asset in assets)
{
var assetPath = AssetDatabase.GetAssetPath(asset);
// if duplicating a sub-asset, then create a copy next to the main asset file
if (!String.IsNullOrEmpty(assetPath) && AssetDatabase.IsSubAsset(asset))
{
if (asset is ISubAssetNotDuplicatable)
{
firstDuplicatedObjectToFail = firstDuplicatedObjectToFail ? firstDuplicatedObjectToFail : asset;
continue;
}
var extension = NativeFormatImporterUtility.GetExtensionForAsset(asset);
// We dot sanitize or block unclean the asset filename (asset.name)
// since the assertdb will do it for us and has a whole tailored logic for that.
// It feels wrong that the asset name (that can apparently contain any char)
// is conflated with the orthogonal notion of filename. From the user's POV
// it will force an asset dup but with mangled names if the original name contained
// "invalid chars" for filenames.
// Path.Combine is not used here to avoid blocking asset names that might
// contain chars not allowed in filenames.
if ((new HashSet <char>(Path.GetInvalidFileNameChars())).Intersect(asset.name).Count() != 0)
{
Debug.LogWarning(string.Format("Duplicated asset name '{0}' contains invalid characters. Those will be replaced in the duplicated asset name.", asset.name));
}
var newPath = AssetDatabase.GenerateUniqueAssetPath(
string.Format("{0}{1}{2}.{3}",
Path.GetDirectoryName(assetPath),
Path.DirectorySeparatorChar,
asset.name,
extension)
);
AssetDatabase.CreateAsset(Object.Instantiate(asset), newPath);
copiedPaths.Add(newPath);
}
// otherwise duplicate the main asset file
else if (EditorUtility.IsPersistent(asset))
{
var newPath = AssetDatabase.GenerateUniqueAssetPath(assetPath);
if (newPath.Length > 0 && AssetDatabase.CopyAsset(assetPath, newPath))
{
copiedPaths.Add(newPath);
}
}
}
if (firstDuplicatedObjectToFail != null)
{
var errString = string.Format(
"Duplication error: One or more sub assets (with types of {0}) can not be duplicated directly, use the appropriate editor instead",
firstDuplicatedObjectToFail.GetType().Name
);
Debug.LogError(errString, firstDuplicatedObjectToFail);
}
AssetDatabase.Refresh();
return(copiedPaths.Select(AssetDatabase.LoadMainAssetAtPath));
}
internal static Object DoDropField(Rect position, int id, System.Type objType, ObjectFieldValidator validator, bool allowSceneObjects, GUIStyle style)
{
if (validator == null)
{
validator = ValidateObjectFieldAssignment;
}
Event evt = Event.current;
EventType eventType = evt.type;
// special case test, so we continue to ping/select objects with the object field disabled
if (!GUI.enabled && GUIClip.enabled && (Event.current.rawType == EventType.MouseDown))
{
eventType = Event.current.rawType;
}
switch (eventType)
{
case EventType.DragExited:
if (GUI.enabled)
{
HandleUtility.Repaint();
}
break;
case EventType.DragUpdated:
case EventType.DragPerform:
if (position.Contains(Event.current.mousePosition) && GUI.enabled)
{
Object[] references = DragAndDrop.objectReferences;
Object validatedObject = validator(references, objType, null, ObjectFieldValidatorOptions.None);
if (validatedObject != null)
{
// If scene objects are not allowed and object is a scene object then clear
if (!allowSceneObjects && !EditorUtility.IsPersistent(validatedObject))
{
validatedObject = null;
}
}
if (validatedObject != null)
{
DragAndDrop.visualMode = DragAndDropVisualMode.Generic;
if (eventType == EventType.DragPerform)
{
GUI.changed = true;
DragAndDrop.AcceptDrag();
DragAndDrop.activeControlID = 0;
Event.current.Use();
return(validatedObject);
}
else
{
DragAndDrop.activeControlID = id;
Event.current.Use();
}
}
}
break;
case EventType.Repaint:
style.Draw(position, GUIContent.none, id, DragAndDrop.activeControlID == id);
break;
}
return(null);
}
public static void DoFixerUI(GameObject gameObject)
{
if (s_Styles == null)
{
s_Styles = new Styles();
}
var srpAsset = GraphicsSettings.currentRenderPipeline;
var defaultSpeedTree8Shader = srpAsset != null ? srpAsset.defaultSpeedTree8Shader : null;
if (defaultSpeedTree8Shader == null)
{
defaultSpeedTree8Shader = Shader.Find("Nature/SpeedTree8");
}
var defaultSpeedTree7Shader = srpAsset != null ? srpAsset.defaultSpeedTree7Shader : null;
if (defaultSpeedTree7Shader == null)
{
defaultSpeedTree7Shader = Shader.Find("Nature/SpeedTree");
}
if (defaultSpeedTree8Shader == null || defaultSpeedTree7Shader == null)
{
return;
}
HashSet <Material> materialsUsedForBothVersion = null, speedTreeV7MaterialsToFix = null, speedTreeV8MaterialsToFix = null;
foreach (var meshRenderer in EnumerateMeshRenderers(gameObject))
{
var meshFilter = meshRenderer.GetComponent <MeshFilter>();
if (meshFilter == null)
{
continue;
}
var mesh = meshFilter.sharedMesh;
if (mesh == null || !EditorUtility.IsPersistent(mesh))
{
continue;
}
var assetPath = AssetDatabase.GetAssetPath(mesh);
var speedTreeImporter = AssetImporter.GetAtPath(assetPath) as SpeedTreeImporter;
if (speedTreeImporter == null)
{
continue;
}
if (materialsUsedForBothVersion == null)
{
materialsUsedForBothVersion = new HashSet <Material>();
speedTreeV7MaterialsToFix = new HashSet <Material>();
speedTreeV8MaterialsToFix = new HashSet <Material>();
}
bool meshIsV8 = speedTreeImporter.isV8;
foreach (var material in meshRenderer.sharedMaterials)
{
if (material == null)
{
continue;
}
// If the material is used for both v7 & v8 mesh: ignore.
if (materialsUsedForBothVersion.Contains(material))
{
continue;
}
// We only fix materials with wrong speedtree shader assigned. We don't know if it's "wrong" if user uses their custom shaders.
var wrongShader = meshIsV8 ? defaultSpeedTree7Shader : defaultSpeedTree8Shader;
if (material.shader != wrongShader)
{
continue;
}
var targetMaterialSet = meshIsV8 ? speedTreeV8MaterialsToFix : speedTreeV7MaterialsToFix;
var otherMaterialSet = meshIsV8 ? speedTreeV7MaterialsToFix : speedTreeV8MaterialsToFix;
if (otherMaterialSet.Contains(material))
{
// rare case that the same material is used both for v7 & v8 material:
materialsUsedForBothVersion.Add(material);
otherMaterialSet.Remove(material);
}
else
{
targetMaterialSet.Add(material);
}
}
}
// No speedtree meshes.
if (materialsUsedForBothVersion == null)
{
return;
}
if (speedTreeV7MaterialsToFix.Count > 0 || speedTreeV8MaterialsToFix.Count > 0)
{
EditorGUILayout.Space();
EditorGUILayout.HelpBox(s_Styles.Message, MessageType.Error);
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (GUILayout.Button(s_Styles.FixSpeedTreeShaders, GUILayout.ExpandWidth(false)))
{
Undo.RecordObjects(speedTreeV7MaterialsToFix.Concat(speedTreeV8MaterialsToFix).ToArray(), "Fix SpeedTree Shaders");
foreach (var material in speedTreeV7MaterialsToFix)
{
material.shader = defaultSpeedTree7Shader;
}
foreach (var material in speedTreeV8MaterialsToFix)
{
material.shader = defaultSpeedTree8Shader;
}
}
GUILayout.EndHorizontal();
}
if (materialsUsedForBothVersion.Count != 0)
{
EditorGUILayout.Space();
EditorGUILayout.HelpBox("Some of the materials are used for both SpeedTree 7 and SpeedTree 8 assets. Unity won't be able to fix that. Please create separate materials.", MessageType.Error);
}
}
static Object DoObjectField(Rect position, Rect dropRect, int id, Object obj, Object objBeingEdited, System.Type objType, System.Type additionalType, SerializedProperty property, ObjectFieldValidator validator, bool allowSceneObjects, GUIStyle style, GUIStyle buttonStyle)
{
if (validator == null)
{
validator = ValidateObjectFieldAssignment;
}
if (property != null)
{
obj = property.objectReferenceValue;
}
Event evt = Event.current;
EventType eventType = evt.type;
// special case test, so we continue to ping/select objects with the object field disabled
if (!GUI.enabled && GUIClip.enabled && (Event.current.rawType == EventType.MouseDown))
{
eventType = Event.current.rawType;
}
bool hasThumbnail = EditorGUIUtility.HasObjectThumbnail(objType);
// Determine visual type
ObjectFieldVisualType visualType = ObjectFieldVisualType.IconAndText;
if (hasThumbnail && position.height <= kObjectFieldMiniThumbnailHeight && position.width <= kObjectFieldMiniThumbnailWidth)
{
visualType = ObjectFieldVisualType.MiniPreview;
}
else if (hasThumbnail && position.height > kSingleLineHeight)
{
visualType = ObjectFieldVisualType.LargePreview;
}
Vector2 oldIconSize = EditorGUIUtility.GetIconSize();
if (visualType == ObjectFieldVisualType.IconAndText)
{
EditorGUIUtility.SetIconSize(new Vector2(12, 12)); // Have to be this small to fit inside a single line height ObjectField
}
else if (visualType == ObjectFieldVisualType.LargePreview)
{
EditorGUIUtility.SetIconSize(new Vector2(64, 64));
}
if ((eventType == EventType.MouseDown && Event.current.button == 1 ||
(eventType == EventType.ContextClick && visualType == ObjectFieldVisualType.IconAndText)) &&
position.Contains(Event.current.mousePosition))
{
var actualObject = property != null ? property.objectReferenceValue : obj;
var contextMenu = new GenericMenu();
if (FillPropertyContextMenu(property, null, contextMenu) != null)
{
contextMenu.AddSeparator("");
}
contextMenu.AddItem(GUIContent.Temp("Properties..."), false, () => PropertyEditor.OpenPropertyEditor(actualObject));
contextMenu.DropDown(position);
Event.current.Use();
}
switch (eventType)
{
case EventType.DragExited:
if (GUI.enabled)
{
HandleUtility.Repaint();
}
break;
case EventType.DragUpdated:
case EventType.DragPerform:
if (eventType == EventType.DragPerform)
{
string errorString;
if (!ValidDroppedObject(DragAndDrop.objectReferences, objType, out errorString))
{
Object reference = DragAndDrop.objectReferences[0];
EditorUtility.DisplayDialog("Can't assign script", errorString, "OK");
break;
}
}
if (dropRect.Contains(Event.current.mousePosition) && GUI.enabled)
{
Object[] references = DragAndDrop.objectReferences;
Object validatedObject = validator(references, objType, property, ObjectFieldValidatorOptions.None);
if (validatedObject != null)
{
// If scene objects are not allowed and object is a scene object then clear
if (!allowSceneObjects && !EditorUtility.IsPersistent(validatedObject))
{
validatedObject = null;
}
}
if (validatedObject != null)
{
DragAndDrop.visualMode = DragAndDropVisualMode.Generic;
if (eventType == EventType.DragPerform)
{
if (property != null)
{
property.objectReferenceValue = validatedObject;
}
else
{
obj = validatedObject;
}
GUI.changed = true;
DragAndDrop.AcceptDrag();
DragAndDrop.activeControlID = 0;
}
else
{
DragAndDrop.activeControlID = id;
}
Event.current.Use();
}
}
break;
case EventType.MouseDown:
if (position.Contains(Event.current.mousePosition) && Event.current.button == 0)
{
// Get button rect for Object Selector
Rect buttonRect = GetButtonRect(visualType, position);
EditorGUIUtility.editingTextField = false;
if (buttonRect.Contains(Event.current.mousePosition))
{
if (GUI.enabled)
{
GUIUtility.keyboardControl = id;
var types = additionalType == null ? new Type[] { objType } : new Type[] { objType, additionalType };
if (property != null)
{
ObjectSelector.get.Show(types, property, allowSceneObjects);
}
else
{
ObjectSelector.get.Show(obj, types, objBeingEdited, allowSceneObjects);
}
ObjectSelector.get.objectSelectorID = id;
evt.Use();
GUIUtility.ExitGUI();
}
}
else
{
Object actualTargetObject = property != null ? property.objectReferenceValue : obj;
Component com = actualTargetObject as Component;
if (com)
{
actualTargetObject = com.gameObject;
}
if (showMixedValue)
{
actualTargetObject = null;
}
// One click shows where the referenced object is, or pops up a preview
if (Event.current.clickCount == 1)
{
GUIUtility.keyboardControl = id;
PingObjectOrShowPreviewOnClick(actualTargetObject, position);
var selectedMaterial = actualTargetObject as Material;
if (selectedMaterial != null)
{
PingObjectInSceneViewOnClick(selectedMaterial);
}
evt.Use();
}
// Double click opens the asset in external app or changes selection to referenced object
else if (Event.current.clickCount == 2)
{
if (actualTargetObject)
{
AssetDatabase.OpenAsset(actualTargetObject);
evt.Use();
GUIUtility.ExitGUI();
}
}
}
}
break;
case EventType.ExecuteCommand:
string commandName = evt.commandName;
if (commandName == ObjectSelector.ObjectSelectorUpdatedCommand && ObjectSelector.get.objectSelectorID == id && GUIUtility.keyboardControl == id && (property == null || !property.isScript))
{
return(AssignSelectedObject(property, validator, objType, evt));
}
else if (commandName == ObjectSelector.ObjectSelectorClosedCommand && ObjectSelector.get.objectSelectorID == id && GUIUtility.keyboardControl == id && property != null && property.isScript)
{
if (ObjectSelector.get.GetInstanceID() == 0)
{
// User canceled object selection; don't apply
evt.Use();
break;
}
return(AssignSelectedObject(property, validator, objType, evt));
}
else if ((evt.commandName == EventCommandNames.Delete || evt.commandName == EventCommandNames.SoftDelete) && GUIUtility.keyboardControl == id)
{
if (property != null)
{
property.objectReferenceValue = null;
}
else
{
obj = null;
}
GUI.changed = true;
evt.Use();
}
break;
case EventType.ValidateCommand:
if ((evt.commandName == EventCommandNames.Delete || evt.commandName == EventCommandNames.SoftDelete) && GUIUtility.keyboardControl == id)
{
evt.Use();
}
break;
case EventType.KeyDown:
if (GUIUtility.keyboardControl == id)
{
if (evt.keyCode == KeyCode.Backspace || (evt.keyCode == KeyCode.Delete && (evt.modifiers & EventModifiers.Shift) == 0))
{
if (property != null)
{
if (property.propertyPath.EndsWith("]"))
{
var parentArrayPropertyPath = property.propertyPath.Substring(0, property.propertyPath.LastIndexOf(".Array.data[", StringComparison.Ordinal));
var parentArrayProperty = property.serializedObject.FindProperty(parentArrayPropertyPath);
bool isReorderableList = PropertyHandler.s_reorderableLists.ContainsKey(ReorderableListWrapper.GetPropertyIdentifier(parentArrayProperty));
// If it's an element of an non-orderable array and it is displayed inside a list, remove that element from the array (cases 1379541 & 1335322)
if (!isReorderableList && GUI.isInsideList && GetInsideListDepth() == parentArrayProperty.depth)
{
TargetChoiceHandler.DeleteArrayElement(property);
}
else
{
property.objectReferenceValue = null;
}
}
else
{
property.objectReferenceValue = null;
}
}
else
{
obj = null;
}
GUI.changed = true;
evt.Use();
}
// Apparently we have to check for the character being space instead of the keyCode,
// otherwise the Inspector will maximize upon pressing space.
if (evt.MainActionKeyForControl(id))
{
var types = additionalType == null ? new Type[] { objType } : new Type[] { objType, additionalType };
if (property != null)
{
ObjectSelector.get.Show(types, property, allowSceneObjects);
}
else
{
ObjectSelector.get.Show(obj, types, objBeingEdited, allowSceneObjects);
}
ObjectSelector.get.objectSelectorID = id;
evt.Use();
GUIUtility.ExitGUI();
}
}
break;
case EventType.Repaint:
GUIContent temp;
if (showMixedValue)
{
temp = s_MixedValueContent;
}
else
{
// If obj or objType are both null, we have to rely on
// property.objectReferenceStringValue to display None/Missing and the
// correct type. But if not, EditorGUIUtility.ObjectContent is more reliable.
// It can take a more specific object type specified as argument into account,
// and it gets the icon at the same time.
if (obj == null && objType == null && property != null)
{
temp = EditorGUIUtility.TempContent(property.objectReferenceStringValue);
}
else
{
// In order for ObjectContext to be able to distinguish between None/Missing,
// we need to supply an instanceID. For some reason, getting the instanceID
// from property.objectReferenceValue is not reliable, so we have to
// explicitly check property.objectReferenceInstanceIDValue if a property exists.
if (property != null)
{
temp = EditorGUIUtility.ObjectContent(obj, objType, property.objectReferenceInstanceIDValue);
}
else
{
temp = EditorGUIUtility.ObjectContent(obj, objType);
}
}
if (property != null)
{
if (obj != null)
{
Object[] references = { obj };
if (EditorSceneManager.preventCrossSceneReferences && CheckForCrossSceneReferencing(obj, property.serializedObject.targetObject))
{
if (!EditorApplication.isPlaying)
{
temp = s_SceneMismatch;
}
else
{
temp.text = temp.text + string.Format(" ({0})", GetGameObjectFromObject(obj).scene.name);
}
}
else if (validator(references, objType, property, ObjectFieldValidatorOptions.ExactObjectTypeValidation) == null)
{
temp = s_TypeMismatch;
}
}
}
}
switch (visualType)
{
case ObjectFieldVisualType.IconAndText:
BeginHandleMixedValueContentColor();
style.Draw(position, temp, id, DragAndDrop.activeControlID == id, position.Contains(Event.current.mousePosition));
Rect buttonRect = buttonStyle.margin.Remove(GetButtonRect(visualType, position));
buttonStyle.Draw(buttonRect, GUIContent.none, id, DragAndDrop.activeControlID == id, buttonRect.Contains(Event.current.mousePosition));
EndHandleMixedValueContentColor();
break;
case ObjectFieldVisualType.LargePreview:
DrawObjectFieldLargeThumb(position, id, obj, temp);
break;
case ObjectFieldVisualType.MiniPreview:
DrawObjectFieldMiniThumb(position, id, obj, temp);
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
}
EditorGUIUtility.SetIconSize(oldIconSize);
return(obj);
}
internal static void AddGameObjectsToPrefabAndConnect(GameObject[] gameObjects, Object targetPrefab)
{
if (gameObjects == null)
{
throw new ArgumentNullException("gameObjects");
}
if (gameObjects.Length == 0)
{
throw new ArgumentException("gameObjects array is empty");
}
if (targetPrefab == null)
{
throw new ArgumentNullException("targetPrefab");
}
if (!PrefabUtility.IsPartOfPrefabAsset(targetPrefab))
{
throw new ArgumentException("Target Prefab has to be a Prefab Asset");
}
Object targetPrefabInstance = null;
var targetPrefabObject = PrefabUtility.GetPrefabAssetHandle(targetPrefab);
foreach (GameObject go in gameObjects)
{
if (go == null)
{
throw new ArgumentException("GameObject in input 'gameObjects' array is null");
}
if (EditorUtility.IsPersistent(go)) // Prefab asset
{
throw new ArgumentException("Game object is part of a prefab");
}
var parentPrefabInstance = GetParentPrefabInstance(go);
if (parentPrefabInstance == null)
{
throw new ArgumentException("GameObject is not (directly) parented under a target Prefab instance.");
}
if (targetPrefabInstance == null)
{
targetPrefabInstance = parentPrefabInstance;
if (!IsPrefabInstanceObjectOf(go.transform.parent, targetPrefabObject))
{
throw new ArgumentException("GameObject is not parented under a target Prefab instance.");
}
}
else
{
if (parentPrefabInstance != targetPrefabInstance)
{
throw new ArgumentException("GameObjects must be parented under the same Prefab instance.");
}
}
if (PrefabUtility.IsPartOfNonAssetPrefabInstance(go))
{
var correspondingGO = PrefabUtility.GetCorrespondingObjectFromSource(go);
var correspondingGOPrefabObject = PrefabUtility.GetPrefabAssetHandle(correspondingGO);
if (targetPrefabObject == correspondingGOPrefabObject)
{
throw new ArgumentException("GameObject is already part of target prefab");
}
}
}
string prefabGUID = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(targetPrefab));
if (!VerifyNestingFromScript(gameObjects, prefabGUID, null))
{
throw new ArgumentException("Cyclic nesting detected");
}
AddGameObjectsToPrefabAndConnect_Internal(gameObjects, targetPrefab);
}
internal static Object DoObjectField(Rect position, Rect dropRect, int id, Object obj, System.Type objType, SerializedProperty property, ObjectFieldValidator validator, bool allowSceneObjects, GUIStyle style)
{
if (validator == null)
{
validator = ValidateObjectFieldAssignment;
}
Event evt = Event.current;
EventType eventType = evt.type;
// special case test, so we continue to ping/select objects with the object field disabled
if (!GUI.enabled && GUIClip.enabled && (Event.current.rawType == EventType.MouseDown))
{
eventType = Event.current.rawType;
}
bool hasThumbnail = EditorGUIUtility.HasObjectThumbnail(objType);
// Determine visual type
ObjectFieldVisualType visualType = ObjectFieldVisualType.IconAndText;
if (hasThumbnail && position.height <= kObjectFieldMiniThumbnailHeight && position.width <= kObjectFieldMiniThumbnailWidth)
{
visualType = ObjectFieldVisualType.MiniPreview;
}
else if (hasThumbnail && position.height > kSingleLineHeight)
{
visualType = ObjectFieldVisualType.LargePreview;
}
Vector2 oldIconSize = EditorGUIUtility.GetIconSize();
if (visualType == ObjectFieldVisualType.IconAndText)
{
EditorGUIUtility.SetIconSize(new Vector2(12, 12)); // Have to be this small to fit inside a single line height ObjectField
}
else if (visualType == ObjectFieldVisualType.LargePreview)
{
EditorGUIUtility.SetIconSize(new Vector2(64, 64));
}
switch (eventType)
{
case EventType.DragExited:
if (GUI.enabled)
{
HandleUtility.Repaint();
}
break;
case EventType.DragUpdated:
case EventType.DragPerform:
if (dropRect.Contains(Event.current.mousePosition) && GUI.enabled)
{
Object[] references = DragAndDrop.objectReferences;
Object validatedObject = validator(references, objType, property, ObjectFieldValidatorOptions.None);
if (validatedObject != null)
{
// If scene objects are not allowed and object is a scene object then clear
if (!allowSceneObjects && !EditorUtility.IsPersistent(validatedObject))
{
validatedObject = null;
}
}
if (validatedObject != null)
{
DragAndDrop.visualMode = DragAndDropVisualMode.Generic;
if (eventType == EventType.DragPerform)
{
if (property != null)
{
property.objectReferenceValue = validatedObject;
}
else
{
obj = validatedObject;
}
GUI.changed = true;
DragAndDrop.AcceptDrag();
DragAndDrop.activeControlID = 0;
}
else
{
DragAndDrop.activeControlID = id;
}
Event.current.Use();
}
}
break;
case EventType.MouseDown:
// Ignore right clicks
if (Event.current.button != 0)
{
break;
}
if (position.Contains(Event.current.mousePosition))
{
// Get button rect for Object Selector
Rect buttonRect;
switch (visualType)
{
case ObjectFieldVisualType.IconAndText:
case ObjectFieldVisualType.MiniPreview:
buttonRect = new Rect(position.xMax - 15, position.y, 15, position.height);
break;
case ObjectFieldVisualType.LargePreview:
buttonRect = new Rect(position.xMax - 36, position.yMax - 14, 36, 14);
break;
default:
throw new ArgumentOutOfRangeException();
}
EditorGUIUtility.editingTextField = false;
if (buttonRect.Contains(Event.current.mousePosition))
{
if (GUI.enabled)
{
GUIUtility.keyboardControl = id;
ObjectSelector.get.Show(obj, objType, property, allowSceneObjects);
ObjectSelector.get.objectSelectorID = id;
evt.Use();
GUIUtility.ExitGUI();
}
}
else
{
Object actualTargetObject = property != null ? property.objectReferenceValue : obj;
Component com = actualTargetObject as Component;
if (com)
{
actualTargetObject = com.gameObject;
}
if (showMixedValue)
{
actualTargetObject = null;
}
// One click shows where the referenced object is, or pops up a preview
if (Event.current.clickCount == 1)
{
GUIUtility.keyboardControl = id;
PingObjectOrShowPreviewOnClick(actualTargetObject, position);
evt.Use();
}
// Double click opens the asset in external app or changes selection to referenced object
else if (Event.current.clickCount == 2)
{
if (actualTargetObject)
{
AssetDatabase.OpenAsset(actualTargetObject);
GUIUtility.ExitGUI();
}
evt.Use();
}
}
}
break;
case EventType.ExecuteCommand:
string commandName = evt.commandName;
if (commandName == ObjectSelector.ObjectSelectorUpdatedCommand && ObjectSelector.get.objectSelectorID == id && GUIUtility.keyboardControl == id && (property == null || !property.isScript))
{
return(AssignSelectedObject(property, validator, objType, evt));
}
else if (commandName == ObjectSelector.ObjectSelectorClosedCommand && ObjectSelector.get.objectSelectorID == id && GUIUtility.keyboardControl == id && property != null && property.isScript)
{
if (ObjectSelector.get.GetInstanceID() == 0)
{
// User canceled object selection; don't apply
evt.Use();
break;
}
return(AssignSelectedObject(property, validator, objType, evt));
}
break;
case EventType.KeyDown:
if (GUIUtility.keyboardControl == id)
{
if (evt.keyCode == KeyCode.Backspace || evt.keyCode == KeyCode.Delete)
{
if (property != null)
{
property.objectReferenceValue = null;
}
else
{
obj = null;
}
GUI.changed = true;
evt.Use();
}
// Apparently we have to check for the character being space instead of the keyCode,
// otherwise the Inspector will maximize upon pressing space.
if (evt.MainActionKeyForControl(id))
{
ObjectSelector.get.Show(obj, objType, property, allowSceneObjects);
ObjectSelector.get.objectSelectorID = id;
evt.Use();
GUIUtility.ExitGUI();
}
}
break;
case EventType.Repaint:
GUIContent temp;
if (showMixedValue)
{
temp = s_MixedValueContent;
}
else if (property != null)
{
temp = EditorGUIUtility.TempContent(property.objectReferenceStringValue, AssetPreview.GetMiniThumbnail(property.objectReferenceValue));
obj = property.objectReferenceValue;
if (obj != null)
{
Object[] references = { obj };
if (EditorSceneManager.preventCrossSceneReferences && CheckForCrossSceneReferencing(obj, property.serializedObject.targetObject))
{
if (!EditorApplication.isPlaying)
{
temp = s_SceneMismatch;
}
else
{
temp.text = temp.text + string.Format(" ({0})", GetGameObjectFromObject(obj).scene.name);
}
}
else if (validator(references, objType, property, ObjectFieldValidatorOptions.ExactObjectTypeValidation) == null)
{
temp = s_TypeMismatch;
}
}
}
else
{
temp = EditorGUIUtility.ObjectContent(obj, objType);
}
switch (visualType)
{
case ObjectFieldVisualType.IconAndText:
BeginHandleMixedValueContentColor();
style.Draw(position, temp, id, DragAndDrop.activeControlID == id, position.Contains(Event.current.mousePosition));
EndHandleMixedValueContentColor();
break;
case ObjectFieldVisualType.LargePreview:
DrawObjectFieldLargeThumb(position, id, obj, temp);
break;
case ObjectFieldVisualType.MiniPreview:
DrawObjectFieldMiniThumb(position, id, obj, temp);
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
}
EditorGUIUtility.SetIconSize(oldIconSize);
return(obj);
}
internal static void DisplayObjectContextMenu(Rect position, Object[] context, int contextUserData)
{
// Don't show context menu if we're inside the side-by-side diff comparison.
if (EditorGUIUtility.comparisonViewMode != EditorGUIUtility.ComparisonViewMode.None)
{
return;
}
Vector2 temp = GUIUtility.GUIToScreenPoint(new Vector2(position.x, position.y));
position.x = temp.x;
position.y = temp.y;
GenericMenu pm = new GenericMenu();
if (context != null && context.Length == 1 && context[0] is Component)
{
Object targetObject = context[0];
Component targetComponent = (Component)targetObject;
// Do nothing if component is not on a prefab instance.
if (PrefabUtility.GetCorrespondingConnectedObjectFromSource(targetComponent.gameObject) == null)
{
}
// Handle added component.
else if (PrefabUtility.GetCorrespondingObjectFromSource(targetObject) == null && targetComponent != null)
{
GameObject instanceGo = targetComponent.gameObject;
PrefabUtility.HandleApplyRevertMenuItems(
"Added Component",
instanceGo,
(menuItemContent, sourceGo) =>
{
TargetChoiceHandler.ObjectInstanceAndSourcePathInfo info = new TargetChoiceHandler.ObjectInstanceAndSourcePathInfo();
info.instanceObject = targetComponent;
info.assetPath = AssetDatabase.GetAssetPath(sourceGo);
GameObject rootObject = PrefabUtility.GetRootGameObject(sourceGo);
if (!PrefabUtility.IsPartOfPrefabThatCanBeAppliedTo(rootObject) || EditorUtility.IsPersistent(instanceGo))
{
pm.AddDisabledItem(menuItemContent);
}
else
{
pm.AddItem(menuItemContent, false, TargetChoiceHandler.ApplyPrefabAddedComponent, info);
}
},
(menuItemContent) =>
{
pm.AddItem(menuItemContent, false, TargetChoiceHandler.RevertPrefabAddedComponent, targetComponent);
}
);
}
else
{
SerializedObject so = new SerializedObject(targetObject);
SerializedProperty property = so.GetIterator();
bool hasPrefabOverride = false;
while (property.Next(property.hasChildren))
{
if (property.isInstantiatedPrefab && property.prefabOverride && !property.isDefaultOverride)
{
hasPrefabOverride = true;
break;
}
}
// Handle modified component.
if (hasPrefabOverride)
{
bool defaultOverrides =
PrefabUtility.IsObjectOverrideAllDefaultOverridesComparedToAnySource(targetObject);
PrefabUtility.HandleApplyRevertMenuItems(
"Modified Component",
targetObject,
(menuItemContent, sourceObject) =>
{
TargetChoiceHandler.ObjectInstanceAndSourcePathInfo info = new TargetChoiceHandler.ObjectInstanceAndSourcePathInfo();
info.instanceObject = targetObject;
info.assetPath = AssetDatabase.GetAssetPath(sourceObject);
GameObject rootObject = PrefabUtility.GetRootGameObject(sourceObject);
if (!PrefabUtility.IsPartOfPrefabThatCanBeAppliedTo(rootObject) || EditorUtility.IsPersistent(targetObject))
{
pm.AddDisabledItem(menuItemContent);
}
else
{
pm.AddItem(menuItemContent, false, TargetChoiceHandler.ApplyPrefabObjectOverride, info);
}
},
(menuItemContent) =>
{
pm.AddItem(menuItemContent, false, TargetChoiceHandler.RevertPrefabObjectOverride, targetObject);
},
defaultOverrides
);
}
}
}
pm.ObjectContextDropDown(position, context, contextUserData);
ResetMouseDown();
}
internal void Show(UnityObject obj, Type requiredType, SerializedProperty property, bool allowSceneObjects, List <int> allowedInstanceIDs, Action <UnityObject> onObjectSelectorClosed, Action <UnityObject> onObjectSelectedUpdated)
{
m_ObjectSelectorReceiver = null;
m_AllowSceneObjects = allowSceneObjects;
m_IsShowingAssets = true;
m_AllowedIDs = allowedInstanceIDs;
m_OnObjectSelectorClosed = onObjectSelectorClosed;
m_OnObjectSelectorUpdated = onObjectSelectedUpdated;
if (property != null)
{
if (requiredType == null)
{
ScriptAttributeUtility.GetFieldInfoFromProperty(property, out requiredType);
// case 951876: built-in types do not actually have reflectable fields, so their object types must be extracted from the type string
// this works because built-in types will only ever have serialized references to other built-in types, which this window's filter expects as unqualified names
if (requiredType == null)
{
m_RequiredType = s_MatchPPtrTypeName.Match(property.type).Groups[1].Value;
}
}
obj = property.objectReferenceValue;
m_ObjectBeingEdited = property.serializedObject.targetObject;
// Do not allow to show scene objects if the object being edited is persistent
if (m_ObjectBeingEdited != null && EditorUtility.IsPersistent(m_ObjectBeingEdited))
{
m_AllowSceneObjects = false;
}
}
// Set which tab should be visible at startup
if (m_AllowSceneObjects)
{
if (obj != null)
{
if (typeof(Component).IsAssignableFrom(obj.GetType()))
{
obj = ((Component)obj).gameObject;
}
// Set the right tab visible (so we can see our selection)
m_IsShowingAssets = EditorUtility.IsPersistent(obj);
}
else
{
m_IsShowingAssets = (requiredType != typeof(GameObject) && !typeof(Component).IsAssignableFrom(requiredType));
}
}
else
{
m_IsShowingAssets = true;
}
// Set member variables
m_DelegateView = GUIView.current;
// type filter requires unqualified names for built-in types, but will prioritize them over user types, so ensure user types are namespace-qualified
if (requiredType != null)
{
m_RequiredType = typeof(ScriptableObject).IsAssignableFrom(requiredType) || typeof(MonoBehaviour).IsAssignableFrom(requiredType) ? requiredType.FullName : requiredType.Name;
}
m_SearchFilter = "";
m_OriginalSelection = obj;
m_ModalUndoGroup = Undo.GetCurrentGroup();
// Freeze to prevent flicker on OSX.
// Screen will be updated again when calling
// SetFreezeDisplay(false) further down.
ContainerWindow.SetFreezeDisplay(true);
ShowWithMode(ShowMode.AuxWindow);
titleContent = EditorGUIUtility.TrTextContent("Select " + (requiredType == null ? m_RequiredType : requiredType.Name));
// Deal with window size
Rect p = m_Parent.window.position;
p.width = EditorPrefs.GetFloat("ObjectSelectorWidth", 200);
p.height = EditorPrefs.GetFloat("ObjectSelectorHeight", 390);
position = p;
minSize = new Vector2(kMinWidth, kMinTopSize + kPreviewExpandedAreaHeight + 2 * kPreviewMargin);
maxSize = new Vector2(10000, 10000);
SetupPreview();
// Focus
Focus();
ContainerWindow.SetFreezeDisplay(false);
m_FocusSearchFilter = true;
// Add after unfreezing display because AuxWindowManager.cpp assumes that aux windows are added after we get 'got/lost'- focus calls.
m_Parent.AddToAuxWindowList();
// Initial selection
int initialSelection = obj != null?obj.GetInstanceID() : 0;
if (property != null && property.hasMultipleDifferentValues)
{
initialSelection = 0; // don't select anything on multi selection
}
if (ShouldTreeViewBeUsed(requiredType))
{
m_ObjectTreeWithSearch.Init(position, this, CreateAndSetTreeView, TreeViewSelection, ItemWasDoubleClicked, initialSelection, 0);
}
else
{
// To frame the selected item we need to wait to initialize the search until our window has been setup
InitIfNeeded();
m_ListArea.InitSelection(new[] { initialSelection });
if (initialSelection != 0)
{
m_ListArea.Frame(initialSelection, true, false);
}
}
}
