void HandleFirstTimePrefabStageIsOpened(StageNavigationItem stage)
{
if (stage.isPrefabStage && GetStoredHierarchyState(m_SceneHierarchyWindow, stage) == null)
{
SetDefaultExpandedStateForOpenedPrefab(stage.prefabStage.prefabContentsRoot);
}
}
public void LoadStateIntoHierarchy(SceneHierarchyWindow hierarchy, StageNavigationItem stage)
{
// Restore expanded state always
if (stage.isMainStage)
{
hierarchy.sceneHierarchy.treeViewState.expandedIDs = m_ExpandedSceneGameObjectInstanceIDs;
}
else
{
RestoreExandedStateFromFileIDs(hierarchy, stage, m_ExpandedPrefabGameObjectFileIDs, m_LastClickedFileID);
}
// Restore selection and scroll value when requested
if (stage.setSelectionAndScrollWhenBecomingCurrentStage)
{
Selection.activeInstanceID = stage.isMainStage ? m_LastClickedInstanceID : hierarchy.sceneHierarchy.treeViewState.lastClickedID;
hierarchy.sceneHierarchy.treeViewState.scrollPos.y = m_ScrollY;
}
if (SceneHierarchy.s_DebugPersistingExpandedState)
{
DebugLog("Restoring", stage);
}
}
void OnStageChanged(StageNavigationItem previousStage, StageNavigationItem newStage)
{
SaveCameraState(m_SceneView, previousStage);
SyncToCurrentStage();
m_BreadcrumbInitialized = false;
m_SceneView.OnStageChanged(previousStage, newStage);
}
void OnStageChanging(StageNavigationItem previousStage, StageNavigationItem newStage)
{
// Exit Avatar Editing before entering Prefab Mode so the camera states of the Prefab Mode is set last.
// This is why we use the stageChanging and not stageChanged event.
if (newStage.isPrefabStage && m_EditMode == EditMode.Editing)
{
SwitchToAssetMode(false);
}
}
void DebugLog(string prefix, StageNavigationItem stage)
{
Debug.Log(prefix + (stage.isMainStage ? " Main stage " : " Prefab stage ") + string.Format("-main stage: {0}, -prefab stage: {1}, -scrollY: {2}, -selection {3}, -setSelection {4}",
DebugUtils.ListToString(m_ExpandedSceneGameObjectInstanceIDs),
DebugUtils.ListToString(m_ExpandedPrefabGameObjectFileIDs),
m_ScrollY,
m_LastClickedInstanceID,
stage.setSelectionAndScrollWhenBecomingCurrentStage));
}
static void RestoreExandedStateFromFileIDs(SceneHierarchyWindow hierarchy, StageNavigationItem item, List <UInt64> expandedGameObjectFileIDs, UInt64 lastClickedFileID)
{
var searchRoot = item.prefabStage.prefabContentsRoot;
var fileIDToInstanceIDMapper = new FileIDToInstanceIDMapper(searchRoot.transform, expandedGameObjectFileIDs, lastClickedFileID);
hierarchy.sceneHierarchy.treeViewState.lastClickedID = fileIDToInstanceIDMapper.instanceID;
hierarchy.sceneHierarchy.treeViewState.expandedIDs = fileIDToInstanceIDMapper.instanceIDs;
hierarchy.sceneHierarchy.treeViewState.expandedIDs.Sort(); // required to be sorted (see TreeViewState)
}
void AutoSaveButtons()
{
StageNavigationItem item = StageNavigationManager.instance.currentItem;
if (item.isPrefabStage)
{
if (m_IsPrefabInValidAssetFolder && !m_IsPrefabInImmutableFolder)
{
StatusQueryOptions opts = EditorUserSettings.allowAsyncStatusUpdate ? StatusQueryOptions.UseCachedAsync : StatusQueryOptions.UseCachedIfPossible;
bool openForEdit = AssetDatabase.IsOpenForEdit(item.prefabAssetPath, opts);
PrefabStage stage = item.prefabStage;
if (stage.showingSavingLabel)
{
GUILayout.Label(Styles.autoSavingBadgeContent, Styles.savingBadge);
GUILayout.Space(4);
}
if (!stage.autoSave)
{
using (new EditorGUI.DisabledScope(!openForEdit || !PrefabStageUtility.GetCurrentPrefabStage().HasSceneBeenModified()))
{
if (GUILayout.Button(Styles.saveButtonContent, Styles.button))
{
PrefabStageUtility.GetCurrentPrefabStage().SavePrefabWithVersionControlDialogAndRenameDialog();
}
}
}
using (new EditorGUI.DisabledScope(stage.temporarilyDisableAutoSave))
{
bool autoSaveForScene = stage.autoSave;
EditorGUI.BeginChangeCheck();
autoSaveForScene = GUILayout.Toggle(autoSaveForScene, Styles.autoSaveGUIContent, Styles.saveToggle);
if (EditorGUI.EndChangeCheck())
{
stage.autoSave = autoSaveForScene;
}
}
if (!openForEdit)
{
if (GUILayout.Button(Styles.checkoutButtonContent, Styles.button))
{
Task task = Provider.Checkout(AssetDatabase.LoadAssetAtPath <GameObject>(item.prefabAssetPath), CheckoutMode.Both);
task.Wait();
}
}
}
else
{
GUILayout.Label(Styles.immutablePrefabContent, EditorStyles.boldLabel);
}
}
}
private static void StageNavigationManagerOnStageChanging(StageNavigationItem oldItem, StageNavigationItem newItem)
{
RevertIsolationCurrentStage();
if (!newItem.isMainStage && newItem.prefabStage != null)
{
SceneVisibilityState.SetPrefabStageScene(newItem.prefabStage.scene);
}
else
{
SceneVisibilityState.SetPrefabStageScene(default(Scene));
}
}
void HandleFirstTimePrefabStageIsOpened(StageNavigationItem stage)
{
if (stage.isPrefabStage && GetStoredCameraState(m_SceneView, stage) == null)
{
// Default to scene view lighting if scene itself does not have any lights
if (!HasAnyActiveLights(stage.prefabStage.scene))
{
m_SceneView.sceneLighting = false;
}
// For UI to frame properly we need to delay one full Update for the layouting to have been processed
EditorApplication.update += DelayedFraming;
}
}
void LoadHierarchyState(SceneHierarchyWindow hierarchy, StageNavigationItem stage)
{
if (stage == null)
{
return;
}
var state = GetStoredHierarchyState(hierarchy, stage);
if (state != null)
{
state.LoadStateIntoHierarchy(hierarchy, stage);
}
}
void LoadCameraState(SceneView sceneView, StageNavigationItem stage)
{
if (stage == null)
{
return;
}
var state = GetStoredCameraState(sceneView, stage);
if (state != null)
{
state.RestoreStateToSceneView(sceneView);
}
}
private static void StageNavigationManagerOnStageChanging(StageNavigationItem oldItem, StageNavigationItem newItem)
{
if (!newItem.isMainStage && newItem.prefabStage != null)
{
SceneVisibilityState.SetPrefabStageScene(newItem.prefabStage.scene);
}
else
{
SceneVisibilityState.SetPrefabStageScene(default(Scene));
}
if (!oldItem.isMainStage)
{
SceneVisibilityState.prefabStageIsolated = false;
}
}
void SaveHierarchyState(SceneHierarchyWindow hierarchyWindow, StageNavigationItem stage)
{
if (stage == null)
{
return;
}
string key = StageUtility.CreateWindowAndStageIdentifier(hierarchyWindow.windowGUID, stage);
var state = m_StateCache.GetState(key);
if (state == null)
{
state = new SceneHierarchyState();
}
state.SaveStateFromHierarchy(hierarchyWindow, stage);
m_StateCache.SetState(key, state);
}
void OnStageChanged(StageNavigationItem previousStage, StageNavigationItem newStage)
{
if (previousStage.isMainStage)
{
SaveHierarchyState(m_SceneHierarchyWindow, previousStage); // prefab stage is saved before it is destroyed
}
var stage = StageNavigationManager.instance.currentItem;
SyncHierarchyToCurrentStage(newStage, true);
CachePrefabHeaderText(stage);
if (m_SceneHierarchyWindow.hasSearchFilter)
{
m_SceneHierarchyWindow.SetSearchFilter(string.Empty, m_SceneHierarchyWindow.searchMode, true);
}
}
void SaveCameraState(SceneView sceneView, StageNavigationItem stage)
{
if (stage == null)
{
return;
}
string key = StageUtility.CreateWindowAndStageIdentifier(sceneView.windowGUID, stage);
var state = m_StateCache.GetState <SceneViewCameraState>(key);
if (state == null)
{
state = new SceneViewCameraState();
}
state.SaveStateFromSceneView(sceneView);
m_StateCache.SetState(key, state);
}
void SyncToCurrentStage()
{
StageNavigationItem stage = StageNavigationManager.instance.currentItem;
if (stage.isMainStage)
{
m_SceneView.customScene = new Scene();
m_SceneView.customParentForDraggedObjects = null;
}
else
{
m_SceneView.customScene = PrefabStageUtility.GetCurrentPrefabStage().scene;
m_SceneView.customParentForDraggedObjects = PrefabStageUtility.GetCurrentPrefabStage().prefabContentsRoot.transform;
}
LoadCameraState(m_SceneView, stage);
HandleFirstTimePrefabStageIsOpened(stage);
}
void HandleFirstTimePrefabStageIsOpened(StageNavigationItem stage)
{
if (stage.isPrefabStage && GetStoredCameraState(m_SceneView, stage) == null)
{
// Default to scene view lighting if scene itself does not have any lights
if (!HasAnyActiveLights(stage.prefabStage.scene))
{
m_SceneView.sceneLighting = false;
}
// Default to not showing skybox if user did not specify a custom environment scene.
if (string.IsNullOrEmpty(stage.prefabStage.scene.path))
{
m_SceneView.sceneViewState.showSkybox = false;
}
// For UI to frame properly we need to delay one full Update for the layouting to have been processed
EditorApplication.update += DelayedFraming;
}
}
void CachePrefabHeaderText(StageNavigationItem stage)
{
if (!stage.isPrefabStage)
{
return;
}
var prefabStage = stage.prefabStage;
if (prefabStage == null)
{
return;
}
var prefabAssetPath = prefabStage.prefabAssetPath;
m_PrefabHeaderContent = new GUIContent();
m_PrefabHeaderContent.text = System.IO.Path.GetFileNameWithoutExtension(prefabAssetPath);
// Make room for version control overlay icons.
// GUIStyles don't allow controlling the space between icon and text.
// We could add spacing by splitting text and icon into two rects and two draw operations,
// but just adding a space character is a lot simpler and ends up amounting to the same thing.
// This is cached text so there is minimal overhead.
if (VersionControl.Provider.isActive)
{
m_PrefabHeaderContent.text = " " + m_PrefabHeaderContent.text;
}
PrefabUtility.GetPrefabAssetType(prefabStage.prefabContentsRoot);
m_PrefabHeaderContent.image = prefabStage.prefabFileIcon;
if (!stage.prefabAssetExists)
{
m_PrefabHeaderContent.tooltip = L10n.Tr("Prefab asset has been deleted");
}
if (PrefabStageUtility.GetCurrentPrefabStage().HasSceneBeenModified())
{
m_PrefabHeaderContent.text += "*";
}
}
void SyncHierarchyToCurrentStage(StageNavigationItem stage, bool loadExpandedState)
{
if (loadExpandedState)
{
LoadHierarchyState(m_SceneHierarchyWindow, stage);
}
if (stage.isMainStage)
{
m_SceneHierarchy.customParentForNewGameObjects = null;
m_SceneHierarchy.SetCustomDragHandler(null);
m_SceneHierarchy.customScenes = null;
}
else
{
m_SceneHierarchy.customParentForNewGameObjects = stage.prefabStage.prefabContentsRoot.transform;
m_SceneHierarchy.SetCustomDragHandler(PrefabModeDraggingHandler);
m_SceneHierarchy.customScenes = new[] { stage.prefabStage.scene };
HandleFirstTimePrefabStageIsOpened(stage);
m_SceneHierarchy.FrameObject(stage.prefabStage.prefabContentsRoot.GetInstanceID(), false);
}
}
public void SaveStateFromHierarchy(SceneHierarchyWindow hierarchy, StageNavigationItem stage)
{
var lastClickedGameObject = EditorUtility.InstanceIDToObject(hierarchy.sceneHierarchy.treeViewState.lastClickedID) as GameObject;
if (stage.isMainStage)
{
m_LastClickedInstanceID = lastClickedGameObject != null?lastClickedGameObject.GetInstanceID() : 0;
m_ExpandedSceneGameObjectInstanceIDs = hierarchy.sceneHierarchy.treeViewState.expandedIDs;
}
else
{
m_LastClickedFileID = lastClickedGameObject != null?GetOrGenerateFileID(lastClickedGameObject) : 0;
m_ExpandedPrefabGameObjectFileIDs = GetExpandedGameObjectFileIDs(hierarchy);
}
m_ScrollY = hierarchy.sceneHierarchy.treeViewState.scrollPos.y;
if (SceneHierarchy.s_DebugPersistingExpandedState)
{
DebugLog("Saving", stage);
}
}
void OnPrefabStageReloaded(StageNavigationItem prefabStage)
{
LoadHierarchyState(m_SceneHierarchyWindow, prefabStage); // Load hierarchy state before reloading the tree so the correct rows are loaded
m_SceneHierarchy.customParentForNewGameObjects = prefabStage.prefabStage.prefabContentsRoot.transform;
m_SceneHierarchy.customScenes = new[] { prefabStage.prefabStage.scene }; // This will re-init the TreeView (new scenes to show)
}
void OnPrefabStageReloading(StageNavigationItem prefabStage)
{
SaveHierarchyState(m_SceneHierarchyWindow, prefabStage); // Save hierarchy state so we can load it after the prefab have been reloaded (with new instanceIDs)
}
void OnPrefabStageBeingDestroyed(StageNavigationItem prefabStage)
{
SaveHierarchyState(m_SceneHierarchyWindow, prefabStage);
}
void OnPrefabStageReloaded(StageNavigationItem prefabStage)
{
m_SceneView.customScene = prefabStage.prefabStage.scene;
m_SceneView.customParentForDraggedObjects = prefabStage.prefabStage.prefabContentsRoot.transform;
}
SceneHierarchyState GetStoredHierarchyState(SceneHierarchyWindow hierarchyWindow, StageNavigationItem stage)
{
string key = StageUtility.CreateWindowAndStageIdentifier(hierarchyWindow.windowGUID, stage);
return(m_StateCache.GetState(key));
}
SceneViewCameraState GetStoredCameraState(SceneView sceneView, StageNavigationItem stage)
{
string key = StageUtility.CreateWindowAndStageIdentifier(sceneView.windowGUID, stage);
return(m_StateCache.GetState <SceneViewCameraState>(key));
}
