public static GameObject CreateDragGO(Sprite frame, Vector3 position, SceneView sceneView)
{
string name = string.IsNullOrEmpty(frame.name) ? "Sprite" : frame.name;
name = GameObjectUtility.GetUniqueNameForSibling(null, name);
// ObjectFactory registers an Undo for the GameObject created, which we do not
// want for the drag preview. We register an Undo only when the user does a
// DragPerform to confirm the creation of the Sprite GameObject.
// The GameObject is cloned and returned while the original is destroyed to
// remove the Undo operation.
GameObject go = ObjectFactory.CreateGameObject(name, typeof(SpriteRenderer));
GameObject cloneGO = GameObject.Instantiate(go);
Object.DestroyImmediate(go);
go = cloneGO;
go.name = name;
SpriteRenderer spriteRenderer = go.GetComponent <SpriteRenderer>();
spriteRenderer.sprite = frame;
go.transform.position = position;
go.hideFlags = HideFlags.HideInHierarchy;
Scene destinationScene = GetDestinationSceneForNewGameObjectsForSceneView(sceneView);
// According to how GameOjectInspector.cs moves the object into scene
if (EditorApplication.isPlaying && !EditorSceneManager.IsPreviewScene(destinationScene))
{
SceneManager.MoveGameObjectToScene(go, destinationScene);
}
return(go);
}
void FilterSettingsChanged()
{
var filter = new SearchFilter();
if (m_IsShowingAssets)
{
filter.searchArea = SearchFilter.SearchArea.AllAssets;
}
filter.SearchFieldStringToFilter(m_SearchFilter);
if (!string.IsNullOrEmpty(m_RequiredType) && filter.classNames.Length == 0)
{
filter.classNames = new[] { m_RequiredType };
}
var hierarchyType = m_IsShowingAssets ? HierarchyType.Assets : HierarchyType.GameObjects;
if (hierarchyType == HierarchyType.GameObjects)
{
if (m_ObjectBeingEdited != null)
{
var scene = GetSceneFromObject(m_ObjectBeingEdited);
if (scene.IsValid())
{
// We do not support cross scene references so ensure we only show game objects
// from the same scene as the object being edited is part of.
// Also don't allow references to other scenes if object being edited
// is in a preview scene.
if (EditorSceneManager.IsPreviewScene(scene) || EditorSceneManager.preventCrossSceneReferences)
{
filter.sceneHandles = new[] { scene.handle }
}
;
}
}
else
{
// If we don't know which object is being edited, assume it's one in current stage.
PreviewSceneStage previewSceneStage = StageUtility.GetCurrentStage() as PreviewSceneStage;
if (previewSceneStage != null)
{
filter.sceneHandles = new[] { previewSceneStage.scene.handle };
}
}
}
if (hierarchyType == HierarchyType.Assets)
{
// When AssemblyDefinitionAsset is the required type, don't skip hidden packages
if (!string.IsNullOrEmpty(m_RequiredType) && m_RequiredType == typeof(AssemblyDefinitionAsset).Name)
{
m_SkipHiddenPackages = false;
}
filter.skipHidden = m_SkipHiddenPackages;
}
m_ListArea.Init(listPosition, hierarchyType, filter, true);
}
void OnDestroy()
{
if (!EditorSceneManager.IsPreviewScene(gameObject.scene))
{
foreach (var item in GUIDObjects)
{
GUIDCollector.Instance.unregisterGrobalReference(item.GUID);
}
}
}
static bool IsPrefabStageHeader(GameObjectTreeViewItem item)
{
if (!item.isSceneHeader)
{
return(false);
}
Scene scene = EditorSceneManager.GetSceneByHandle(item.id);
if (!scene.IsValid())
{
return(false);
}
return(EditorSceneManager.IsPreviewScene(scene));
}
void OnValidate()
{
if (!registerGUID)
{
return;
}
// Undo などで値が変更された場合の処理
if (!EditorSceneManager.IsPreviewScene(gameObject.scene))
{
foreach (var item in GUIDObjects.ToList())
{
// 二重で登録されてしまうことは無いため、全て登録しなおす
GUIDCollector.Instance.registerGrobalReference(item.GUID, item.Target);
}
}
}
// Modified version of StageHandle.FindComponentsOfType<T>()
// This version more closely represents unity object referencing restrictions.
// I added these restrictions:
// - Can not reference scene object outside scene
// - Can not reference cross scenes
// - Can reference child objects if it is prefab
Camera[] FindCamerasToReference(GameObject gameObject)
{
var scene = gameObject.scene;
var inScene = !EditorUtility.IsPersistent(camera) || scene.IsValid();
var inPreviewScene = EditorSceneManager.IsPreviewScene(scene) && scene.IsValid();
var inCurrentScene = !EditorUtility.IsPersistent(camera) && scene.IsValid();
Camera[] cameras = Resources.FindObjectsOfTypeAll <Camera>();
List <Camera> result = new List <Camera>();
if (!inScene)
{
foreach (var camera in cameras)
{
if (camera.transform.IsChildOf(gameObject.transform))
{
result.Add(camera);
}
}
}
else if (inPreviewScene)
{
foreach (var camera in cameras)
{
if (camera.gameObject.scene == scene)
{
result.Add(camera);
}
}
}
else if (inCurrentScene)
{
foreach (var camera in cameras)
{
if (!EditorUtility.IsPersistent(camera) && !EditorSceneManager.IsPreviewScene(camera.gameObject.scene) && camera.gameObject.scene == scene)
{
result.Add(camera);
}
}
}
return(result.ToArray());
}
static void CloseScene(Scene scene, GameObject root)
{
if (!scene.IsValid())
{
return;
}
if (root != null)
{
UnityObjectUtils.Destroy(root);
}
if (EditorSceneManager.IsPreviewScene(scene))
{
EditorSceneManager.ClosePreviewScene(scene);
}
else
{
SceneManager.UnloadSceneAsync(scene);
}
}
/// <summary>
/// Gets the current scene infos for the build. If BuildCurrentScene is checked, all open scenes are returned.
/// </summary>
/// <returns>The array of SceneInfos.</returns>
public SceneInfo[] GetSceneInfosForBuild()
{
if (BuildCurrentScene)
{
// Build a list of the root scenes
var rootScenes = new List <SceneInfo>();
for (int i = 0; i != EditorSceneManager.sceneCount; i++)
{
var scene = EditorSceneManager.GetSceneAt(i);
if (scene.isSubScene)
{
continue;
}
if (!scene.isLoaded)
{
continue;
}
if (EditorSceneManager.IsPreviewScene(scene))
{
continue;
}
if (string.IsNullOrEmpty(scene.path))
{
continue;
}
var sceneAsset = AssetDatabase.LoadAssetAtPath <SceneAsset>(scene.path);
rootScenes.Add(new SceneInfo()
{
AutoLoad = true, Scene = GlobalObjectId.GetGlobalObjectIdSlow(sceneAsset)
});
}
return(rootScenes.ToArray());
}
else
{
return(SceneInfos.ToArray());
}
}
public override VisualElement CreatePropertyGUI(SerializedProperty property)
{
var container = new VisualElement();
var keyProperty = property.FindPropertyRelative("key");
var targetProperty = keyProperty.FindPropertyRelative("target");
var itemContainer = new PropertyField(property.FindPropertyRelative("item"));
var component = (Component)property.serializedObject.targetObject;
var scene = component.gameObject.scene;
var isInScene = scene.name != null && !EditorSceneManager.IsPreviewScene(scene);
var messageType = isInScene ? MessageType.Error : MessageType.Warning;
var localPlayerHelpBox = new IMGUIContainer(() => EditorGUILayout.HelpBox(LocalPlayerGimmickValidation.ErrorMessage, messageType));
void SwitchDisplayItem(GimmickTarget target)
{
itemContainer.SetVisibility(target == GimmickTarget.Item);
localPlayerHelpBox.SetVisibility(!LocalPlayerGimmickValidation.IsValid(target, component));
}
SwitchDisplayItem((GimmickTarget)targetProperty.enumValueIndex);
var targetField = EnumField.Create(
targetProperty.displayName,
targetProperty,
LocalPlayerGimmickValidation.IsLocalizable(component) ? LocalizableSelectables : ConsistentlySyncSelectables,
(GimmickTarget)targetProperty.enumValueIndex,
FormatTarget, SwitchDisplayItem);
var keyField = new PropertyField(keyProperty.FindPropertyRelative("key"));
container.Add(localPlayerHelpBox);
container.Add(targetField);
container.Add(keyField);
container.Add(itemContainer);
return(container);
}
void OnEnable()
{
if (!!registerGUID)
{
return;
}
registerGUID = true;
// プレビューシーンでは登録しない (一時的なオブジェクトとして生成されるため)
if (!EditorSceneManager.IsPreviewScene(gameObject.scene))
{
foreach (var item in GUIDObjects.ToList()) // 内部でGUIDObjectsの要素数が変化するため、現時点のキャッシュに対して処理する
// ここで、GUIDがすでに登録済みであれば、自身が複製されたものとして新しいGUIDを割り当てる
{
if (!GUIDCollector.Instance.registerGrobalReference(item.GUID, item.Target))
{
GUIDObjects.RemoveAt(GUIDObjects.FindIndex(guidObject => guidObject.Target == item.Target));
createGUID(item.Target);
}
}
}
}
public string[] GetScenePathsForBuild()
{
if (BuildCurrentScene)
{
// Build a list of the root scenes
var rootScenes = new List <string>();
for (int i = 0; i != EditorSceneManager.sceneCount; i++)
{
var scene = EditorSceneManager.GetSceneAt(i);
if (scene.isSubScene)
{
continue;
}
if (!scene.isLoaded)
{
continue;
}
if (EditorSceneManager.IsPreviewScene(scene))
{
continue;
}
if (string.IsNullOrEmpty(scene.path))
{
continue;
}
rootScenes.Add(scene.path);
}
return(rootScenes.ToArray());
}
else
{
return(Scenes.Select(id => id.assetGUID.ToString()).Select(AssetDatabase.GUIDToAssetPath).ToArray());
}
}
internal void OnSceneDragInternal(SceneView sceneView, int index, EventType type, Vector2 mousePosition, bool alt)
{
GameObject go = target as GameObject;
if (!PrefabUtility.IsPartOfPrefabAsset(go))
{
return;
}
var prefabAssetRoot = go.transform.root.gameObject;
switch (type)
{
case EventType.DragUpdated:
Scene destinationScene = sceneView.customScene.IsValid() ? sceneView.customScene : SceneManager.GetActiveScene();
if (m_DragObject == null)
{
// While dragging the instantiated prefab we do not want to record undo for this object
// this will cause a remerge of the instance since changes are undone while dragging.
// The DrivenRectTransformTracker by default records Undo when used when driving
// UI components. This breaks our hideflag setup below due to a remerge of the dragged instance.
// StartRecordingUndo() is called on DragExited. Fixes case 1223793.
DrivenRectTransformTracker.StopRecordingUndo();
if (!EditorApplication.isPlaying || EditorSceneManager.IsPreviewScene(destinationScene))
{
m_DragObject = (GameObject)PrefabUtility.InstantiatePrefab(prefabAssetRoot, destinationScene);
m_DragObject.name = go.name;
}
else
{
// Instatiate as regular GameObject in Play Mode so runtime logic
// won't run into restrictions on restructuring Prefab instances.
m_DragObject = Instantiate(prefabAssetRoot);
SceneManager.MoveGameObjectToScene(m_DragObject, destinationScene);
}
m_DragObject.hideFlags = HideFlags.HideInHierarchy;
if (HandleUtility.ignoreRaySnapObjects == null)
{
HandleUtility.ignoreRaySnapObjects = m_DragObject.GetComponentsInChildren <Transform>();
}
else
{
HandleUtility.ignoreRaySnapObjects = HandleUtility.ignoreRaySnapObjects.Union(m_DragObject.GetComponentsInChildren <Transform>()).ToArray();
}
PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
if (prefabStage != null)
{
GameObject prefab = AssetDatabase.LoadMainAssetAtPath(prefabStage.assetPath) as GameObject;
if (prefab != null)
{
if (PrefabUtility.CheckIfAddingPrefabWouldResultInCyclicNesting(prefab, target))
{
s_CyclicNestingDetected = true;
}
}
}
}
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
Vector3 point, normal;
float offset = 0;
if (index == 0)
{
s_PlaceObject = HandleUtility.PlaceObject(mousePosition, out s_PlaceObjectPoint, out s_PlaceObjectNormal);
}
point = s_PlaceObjectPoint;
normal = s_PlaceObjectNormal;
if (s_PlaceObject)
{
if (Tools.pivotMode == PivotMode.Center)
{
float geomOffset = HandleUtility.CalcRayPlaceOffset(m_DragObject.GetComponentsInChildren <Transform>(), normal);
if (geomOffset != Mathf.Infinity)
{
offset = Vector3.Dot(m_DragObject.transform.position, normal) - geomOffset;
}
}
m_DragObject.transform.position = Matrix4x4.identity.MultiplyPoint(point + (normal * offset));
}
else
{
m_DragObject.transform.position = HandleUtility.GUIPointToWorldRay(mousePosition).GetPoint(10);
}
if (alt)
{
if (offset != 0)
{
m_DragObject.transform.position = point;
}
m_DragObject.transform.position += prefabAssetRoot.transform.localPosition;
}
// Use prefabs original z position when in 2D mode
if (sceneView.in2DMode)
{
Vector3 dragPosition = m_DragObject.transform.position;
dragPosition.z = prefabAssetRoot.transform.position.z;
m_DragObject.transform.position = dragPosition;
}
// Schedule selection clearing for when we start performing the actual drag action
s_ShouldClearSelection = true;
break;
case EventType.DragPerform:
DragPerform(sceneView, m_DragObject, go);
m_DragObject = null;
break;
case EventType.DragExited:
// DragExited is always fired after DragPerform so we do no need to call StartRecordingUndo
// in DragPerform
DrivenRectTransformTracker.StartRecordingUndo();
if (m_DragObject)
{
DestroyImmediate(m_DragObject, false);
HandleUtility.ignoreRaySnapObjects = null;
m_DragObject = null;
}
s_ShouldClearSelection = false;
s_CyclicNestingDetected = false;
break;
}
}
void Refresh()
{
// Resources.FindObjectsOfTypeAll will find hidden root objects that scene.GetRootGameObjects doesn't contain
var gameObjects = Resources.FindObjectsOfTypeAll <GameObject>();
var sceneCount = SceneManager.sceneCount;
// Set up a dictionary to map scene -> GameObject for faster lookup below
k_SceneGameObjectMap.Clear();
m_FreeGameObjects.Clear();
foreach (var gameObject in gameObjects)
{
// We only care about root objects
if (gameObject.transform.parent != null)
{
continue;
}
var scene = gameObject.scene;
if (!scene.IsValid())
{
// If the scene is not valid, and this isn't a prefab, it is a "free floating" GameObject
if (!PrefabUtility.IsPartOfPrefabAsset(gameObject))
{
m_FreeGameObjects.Add(gameObject);
}
continue;
}
if (!k_SceneGameObjectMap.TryGetValue(scene, out var list))
{
list = new List <GameObject>();
k_SceneGameObjectMap[scene] = list;
}
list.Add(gameObject);
}
// Sort by sibling index so that order matches actual hierarchy
foreach (var kvp in k_SceneGameObjectMap)
{
kvp.Value.Sort((a, b) => a.transform.GetSiblingIndex().CompareTo(b.transform.GetSiblingIndex()));
}
// Store the objects in a list of lists to keep scene sorting order
m_RootObjectLists.Clear();
for (var i = 0; i < sceneCount; i++)
{
var scene = SceneManager.GetSceneAt(i);
if (!scene.IsValid())
{
continue;
}
if (!k_SceneGameObjectMap.TryGetValue(scene, out var list))
{
continue;
}
k_SceneGameObjectMap.Remove(scene);
var sceneName = scene.name;
// Untitled scene will have a blank scene name; replace with Untitled to match actual hierarchy
if (string.IsNullOrEmpty(sceneName))
{
sceneName = k_UntitledSceneName;
}
m_RootObjectLists.Add(new KeyValuePair <string, List <GameObject> >(sceneName, list));
}
foreach (var kvp in k_SceneGameObjectMap)
{
var scene = kvp.Key;
var label = scene.name;
if (EditorSceneManager.IsPreviewScene(scene))
{
label = string.Format(k_PreviewSceneLabelFormat, label);
}
m_RootObjectLists.Add(new KeyValuePair <string, List <GameObject> >(label, kvp.Value));
}
}
public void OnSceneDrag(SceneView sceneView)
{
GameObject go = target as GameObject;
if (!PrefabUtility.IsPartOfPrefabAsset(go))
{
return;
}
var prefabAssetRoot = go.transform.root.gameObject;
Event evt = Event.current;
switch (evt.type)
{
case EventType.DragUpdated:
Scene destinationScene = sceneView.customScene.IsValid() ? sceneView.customScene : SceneManager.GetActiveScene();
if (dragObject == null)
{
if (!EditorApplication.isPlaying || EditorSceneManager.IsPreviewScene(destinationScene))
{
dragObject = (GameObject)PrefabUtility.InstantiatePrefab(prefabAssetRoot, destinationScene);
dragObject.name = go.name;
}
else
{
// Instatiate as regular GameObject in Play Mode so runtime logic
// won't run into restrictions on restructuring Prefab instances.
dragObject = Instantiate(prefabAssetRoot);
SceneManager.MoveGameObjectToScene(dragObject, destinationScene);
}
dragObject.hideFlags = HideFlags.HideInHierarchy;
}
if (HandleUtility.ignoreRaySnapObjects == null)
{
HandleUtility.ignoreRaySnapObjects = dragObject.GetComponentsInChildren <Transform>();
}
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
Vector3 point, normal;
if (HandleUtility.PlaceObject(evt.mousePosition, out point, out normal))
{
float offset = 0;
if (Tools.pivotMode == PivotMode.Center)
{
float geomOffset = HandleUtility.CalcRayPlaceOffset(HandleUtility.ignoreRaySnapObjects, normal);
if (geomOffset != Mathf.Infinity)
{
offset = Vector3.Dot(dragObject.transform.position, normal) - geomOffset;
}
}
dragObject.transform.position = Matrix4x4.identity.MultiplyPoint(point + (normal * offset));
}
else
{
dragObject.transform.position = HandleUtility.GUIPointToWorldRay(evt.mousePosition).GetPoint(10);
}
// Use prefabs original z position when in 2D mode
if (sceneView.in2DMode)
{
Vector3 dragPosition = dragObject.transform.position;
dragPosition.z = prefabAssetRoot.transform.position.z;
dragObject.transform.position = dragPosition;
}
evt.Use();
break;
case EventType.DragPerform:
if (!DragPerform(sceneView, dragObject, go))
{
return;
}
dragObject = null;
evt.Use();
break;
case EventType.DragExited:
if (dragObject)
{
UnityObject.DestroyImmediate(dragObject, false);
HandleUtility.ignoreRaySnapObjects = null;
dragObject = null;
evt.Use();
}
break;
}
}
public void OnSceneDrag(SceneView sceneView)
{
GameObject go = target as GameObject;
if (!PrefabUtility.IsPartOfPrefabAsset(go))
{
return;
}
var prefabAssetRoot = go.transform.root.gameObject;
Event evt = Event.current;
switch (evt.type)
{
case EventType.DragUpdated:
Scene destinationScene = sceneView.customScene.IsValid() ? sceneView.customScene : SceneManager.GetActiveScene();
if (dragObject == null)
{
// While dragging the instantiated prefab we do not want to record undo for this object
// this will cause a remerge of the instance since changes are undone while dragging.
// The DrivenRectTransformTracker by default records Undo when used when driving
// UI components. This breaks our hideflag setup below due to a remerge of the dragged instance.
// StartRecordingUndo() is called on DragExited. Fixes case 1223793.
DrivenRectTransformTracker.StopRecordingUndo();
if (!EditorApplication.isPlaying || EditorSceneManager.IsPreviewScene(destinationScene))
{
dragObject = (GameObject)PrefabUtility.InstantiatePrefab(prefabAssetRoot, destinationScene);
dragObject.name = go.name;
}
else
{
// Instatiate as regular GameObject in Play Mode so runtime logic
// won't run into restrictions on restructuring Prefab instances.
dragObject = Instantiate(prefabAssetRoot);
SceneManager.MoveGameObjectToScene(dragObject, destinationScene);
}
dragObject.hideFlags = HideFlags.HideInHierarchy;
}
if (HandleUtility.ignoreRaySnapObjects == null)
{
HandleUtility.ignoreRaySnapObjects = dragObject.GetComponentsInChildren <Transform>();
}
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
Vector3 point, normal;
if (HandleUtility.PlaceObject(evt.mousePosition, out point, out normal))
{
float offset = 0;
if (Tools.pivotMode == PivotMode.Center)
{
float geomOffset = HandleUtility.CalcRayPlaceOffset(HandleUtility.ignoreRaySnapObjects, normal);
if (geomOffset != Mathf.Infinity)
{
offset = Vector3.Dot(dragObject.transform.position, normal) - geomOffset;
}
}
dragObject.transform.position = Matrix4x4.identity.MultiplyPoint(point + (normal * offset));
}
else
{
dragObject.transform.position = HandleUtility.GUIPointToWorldRay(evt.mousePosition).GetPoint(10);
}
// Use prefabs original z position when in 2D mode
if (sceneView.in2DMode)
{
Vector3 dragPosition = dragObject.transform.position;
dragPosition.z = prefabAssetRoot.transform.position.z;
dragObject.transform.position = dragPosition;
}
evt.Use();
break;
case EventType.DragPerform:
if (!DragPerform(sceneView, dragObject, go))
{
return;
}
dragObject = null;
evt.Use();
break;
case EventType.DragExited:
// DragExited is always fired after DragPerform so we do no need to call StartRecordingUndo
// in DragPerform
DrivenRectTransformTracker.StartRecordingUndo();
if (dragObject)
{
UnityObject.DestroyImmediate(dragObject, false);
HandleUtility.ignoreRaySnapObjects = null;
dragObject = null;
evt.Use();
}
break;
}
}
public void OnSceneDrag(SceneView sceneView)
{
GameObject go = target as GameObject;
if (!PrefabUtility.IsPartOfPrefabAsset(go))
{
return;
}
var prefabAssetRoot = go.transform.root.gameObject;
Event evt = Event.current;
switch (evt.type)
{
case EventType.DragUpdated:
Scene destinationScene = sceneView.customScene.IsValid() ? sceneView.customScene : SceneManager.GetActiveScene();
if (dragObject == null)
{
if (!EditorApplication.isPlaying || EditorSceneManager.IsPreviewScene(destinationScene))
{
dragObject = (GameObject)PrefabUtility.InstantiatePrefab(prefabAssetRoot, destinationScene);
dragObject.name = go.name;
}
else
{
// Instatiate as regular GameObject in Play Mode so runtime logic
// won't run into restrictions on restructuring Prefab instances.
dragObject = Instantiate(prefabAssetRoot);
SceneManager.MoveGameObjectToScene(dragObject, destinationScene);
}
dragObject.hideFlags = HideFlags.HideInHierarchy;
}
if (HandleUtility.ignoreRaySnapObjects == null)
{
HandleUtility.ignoreRaySnapObjects = dragObject.GetComponentsInChildren <Transform>();
}
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
object hit = HandleUtility.RaySnap(HandleUtility.GUIPointToWorldRay(evt.mousePosition));
if (hit != null)
{
RaycastHit rh = (RaycastHit)hit;
float offset = 0;
if (Tools.pivotMode == PivotMode.Center)
{
float geomOffset = HandleUtility.CalcRayPlaceOffset(HandleUtility.ignoreRaySnapObjects, rh.normal);
if (geomOffset != Mathf.Infinity)
{
offset = Vector3.Dot(dragObject.transform.position, rh.normal) - geomOffset;
}
}
dragObject.transform.position = Matrix4x4.identity.MultiplyPoint(rh.point + (rh.normal * offset));
}
else
{
dragObject.transform.position = HandleUtility.GUIPointToWorldRay(evt.mousePosition).GetPoint(10);
}
// Use prefabs original z position when in 2D mode
if (sceneView.in2DMode)
{
Vector3 dragPosition = dragObject.transform.position;
dragPosition.z = prefabAssetRoot.transform.position.z;
dragObject.transform.position = dragPosition;
}
evt.Use();
break;
case EventType.DragPerform:
var stage = StageNavigationManager.instance.currentStage;
if (stage is PrefabStage)
{
var prefabAssetThatIsAddedTo = AssetDatabase.LoadMainAssetAtPath(stage.assetPath);
if (PrefabUtility.CheckIfAddingPrefabWouldResultInCyclicNesting(prefabAssetThatIsAddedTo, go))
{
PrefabUtility.ShowCyclicNestingWarningDialog();
return;
}
}
Transform parent = sceneView.customParentForDraggedObjects;
string uniqueName = GameObjectUtility.GetUniqueNameForSibling(parent, dragObject.name);
if (parent != null)
{
dragObject.transform.parent = parent;
}
dragObject.hideFlags = 0;
Undo.RegisterCreatedObjectUndo(dragObject, "Place " + dragObject.name);
EditorUtility.SetDirty(dragObject);
DragAndDrop.AcceptDrag();
Selection.activeObject = dragObject;
HandleUtility.ignoreRaySnapObjects = null;
if (SceneView.mouseOverWindow != null)
{
SceneView.mouseOverWindow.Focus();
}
if (!Application.IsPlaying(dragObject))
{
dragObject.name = uniqueName;
}
dragObject = null;
evt.Use();
break;
case EventType.DragExited:
if (dragObject)
{
UnityObject.DestroyImmediate(dragObject, false);
HandleUtility.ignoreRaySnapObjects = null;
dragObject = null;
evt.Use();
}
break;
}
}
bool ShouldShowSceneHeaders()
{
// Don't show headers if there's a single scene and it's a preview scene.
return(scenes == null || scenes.Length != 1 || !EditorSceneManager.IsPreviewScene(scenes[0]));
}
void FilterSettingsChanged()
{
var filter = new SearchFilter();
if (m_IsShowingAssets)
{
filter.searchArea = SearchFilter.SearchArea.AllAssets;
}
filter.SearchFieldStringToFilter(m_SearchFilter);
if (filter.classNames.Length == 0 && m_RequiredTypes.All(type => !string.IsNullOrEmpty(type)))
{
filter.classNames = m_RequiredTypes;
}
var hierarchyType = m_IsShowingAssets ? HierarchyType.Assets : HierarchyType.GameObjects;
if (hierarchyType == HierarchyType.GameObjects)
{
if (m_ObjectBeingEdited != null)
{
var scene = GetSceneFromObject(m_ObjectBeingEdited);
if (scene.IsValid())
{
// We do not support cross scene references so ensure we only show game objects
// from the same scene as the object being edited is part of.
// Also don't allow references to other scenes if object being edited
// is in a preview scene.
if (EditorSceneManager.IsPreviewScene(scene) || EditorSceneManager.preventCrossSceneReferences)
{
filter.sceneHandles = new[] { scene.handle }
}
;
}
}
else
{
// If we don't know which object is being edited, assume it's one in current stage.
PreviewSceneStage previewSceneStage = StageUtility.GetCurrentStage() as PreviewSceneStage;
if (previewSceneStage != null)
{
filter.sceneHandles = new[] { previewSceneStage.scene.handle };
}
}
}
if (hierarchyType == HierarchyType.Assets)
{
// When AssemblyDefinitionAsset is the required type, don't skip hidden packages
foreach (var type in m_RequiredTypes)
{
if (!string.IsNullOrEmpty(type) && type == typeof(AssemblyDefinitionAsset).Name)
{
m_SkipHiddenPackages = false;
break;
}
}
filter.skipHidden = m_SkipHiddenPackages;
}
bool hasObject = false;
var requiredTypes = new List <Type>();
var objectTypes = TypeCache.GetTypesDerivedFrom <UnityEngine.Object>();
foreach (var type in m_RequiredTypes)
{
foreach (var objectType in objectTypes)
{
if (objectType.Name == type)
{
requiredTypes.Add(objectType);
}
else if (!hasObject)
{
requiredTypes.Add(typeof(UnityObject));
hasObject = true;
}
}
}
m_ListArea.InitForSearch(listPosition, hierarchyType, filter, true, s =>
{
foreach (var type in requiredTypes)
{
var asset = AssetDatabase.LoadAssetAtPath(s, type);
if (asset != null && asset.GetInstanceID() != 0)
{
return(asset.GetInstanceID());
}
}
return(0);
}, m_LegacySearchSessionOptions);
}
