protected virtual void OnSceneGUI() { DayNightCycle _target = (DayNightCycle)target; if (!_target.gameObject.scene.IsValid() || StageUtility.GetMainStage() == null) { return; } if (_target.sunLight == null || Camera.current == null) { return; } if (Event.current.type == EventType.Repaint) { Handles.color = _target.sunLight.color; Handles.ArrowHandleCap( 0, _target.sunLight.transform.position + _target.sunLight.transform.forward, _target.sunLight.transform.rotation, Vector3.Distance(Camera.current.transform.position, _target.transform.position) / 5, EventType.Repaint ); } }
public IEnumerator NavMeshSurfacePrefab_WhenEmptyAndInstantiated_InstanceHasEmptyNavMeshData() { var prefab = AssetDatabase.LoadAssetAtPath <GameObject>(m_PrefabPath); var instance = PrefabUtility.InstantiatePrefab(prefab) as GameObject; Assert.IsNotNull(instance); instance.name = "Surface" + m_TestCounter + "PrefabInstance"; var instanceSurface = instance.GetComponent <NavMeshSurface>(); Assert.IsTrue(instanceSurface.navMeshData != null, "NavMeshSurface in prefab instance must have NavMeshData."); AssetDatabase.OpenAsset(prefab); var prefabStage = PrefabStageUtility.GetCurrentPrefabStage(); var prefabSurface = prefabStage.prefabContentsRoot.GetComponent <NavMeshSurface>(); NavMeshAssetManager.instance.ClearSurfaces(new Object[] { prefabSurface }); PrefabSavingUtil.SavePrefab(prefabStage); StageUtility.GoToMainStage(); Assert.IsTrue(instanceSurface.navMeshData == null, "After the NavMeshSurface in the prefab has been cleared the prefab instance should no longer hold NavMeshData."); var expectedAreaMask = 1 << k_PrefabDefaultArea; Assert.IsFalse(HasNavMeshAtPosition(Vector3.zero, expectedAreaMask)); #if !KEEP_ARTIFACTS_FOR_INSPECTION Object.DestroyImmediate(instance); #endif yield return(null); }
static void Place(GameObject go, GameObject parent) { if (parent != null) { var transform = go.transform; Undo.SetTransformParent(transform, parent.transform, "Reparenting"); transform.localPosition = Vector3.zero; transform.localRotation = Quaternion.identity; transform.localScale = Vector3.one; go.layer = parent.layer; if (parent.GetComponent <RectTransform>()) { ObjectFactory.AddComponent <RectTransform>(go); } } else { go.transform.position = Vector3.zero; StageUtility.PlaceGameObjectInCurrentStage(go); // may change parent } // Only at this point do we know the actual parent of the object and can modify its name accordingly. GameObjectUtility.EnsureUniqueNameForSibling(go); Undo.SetCurrentGroupName("Create " + go.name); Selection.activeGameObject = go; }
public static GameObject CreateNewUI() { // Root for the UI var root = new GameObject("Canvas"); root.layer = LayerMask.NameToLayer(kUILayerName); Canvas canvas = root.AddComponent <Canvas>(); canvas.renderMode = RenderMode.ScreenSpaceOverlay; root.AddComponent <CanvasScaler>(); root.AddComponent <GraphicRaycaster>(); // Works for all stages. StageUtility.PlaceGameObjectInCurrentStage(root); bool customScene = false; PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage(); if (prefabStage != null) { root.transform.SetParent(prefabStage.prefabContentsRoot.transform, false); customScene = true; } Undo.RegisterCreatedObjectUndo(root, "Create " + root.name); // If there is no event system add one... // No need to place event system in custom scene as these are temporary anyway. // It can be argued for or against placing it in the user scenes, // but let's not modify scene user is not currently looking at. if (!customScene) { CreateEventSystem(false); } return(root); }
public IEnumerator Setup() { var plane = GameObject.CreatePrimitive(PrimitiveType.Plane); plane.name = "NavMeshSurface" + (++m_TestCounter) + "Prefab"; var surface = plane.AddComponent <NavMeshSurface>(); surface.collectObjects = CollectObjects.Children; m_PrefabPath = Path.Combine(m_TempFolder, plane.name + ".prefab"); var planePrefab = PrefabUtility.SaveAsPrefabAsset(plane, m_PrefabPath); Object.DestroyImmediate(plane); AssetDatabase.OpenAsset(planePrefab); var prefabStage = PrefabStageUtility.GetCurrentPrefabStage(); var prefabSurface = prefabStage.prefabContentsRoot.GetComponent <NavMeshSurface>(); yield return(BakeNavMeshAsync(() => prefabSurface, k_PrefabDefaultArea)); PrefabSavingUtil.SavePrefab(prefabStage); StageUtility.GoToMainStage(); NavMesh.RemoveAllNavMeshData(); yield return(null); }
// Helper function that returns a Solver GameObject; preferably a parent of the selection, or other existing Canvas. private static GameObject GetOrCreateSolverObject() { GameObject selectedGo = Selection.activeGameObject; // Try to find a gameobject that is the selected GO or one if its parents. ObiSolver solver = (selectedGo != null) ? selectedGo.GetComponentInParent <ObiSolver>() : null; if (IsValidSolver(solver)) { return(solver.gameObject); } // No solver in selection or its parents? Then use any valid solver. // We have to find all loaded solvers, not just the ones in main scenes. ObiSolver[] solverArray = StageUtility.GetCurrentStageHandle().FindComponentsOfType <ObiSolver>(); for (int i = 0; i < solverArray.Length; i++) { if (IsValidSolver(solverArray[i])) { return(solverArray[i].gameObject); } } // No solver in the scene at all? Then create a new one. return(CreateNewSolver()); }
protected override void OnEnable() { base.OnEnable(); m_PickupAction = (PickupAction)m_Action; m_EffectProp = serializedObject.FindProperty("m_Effect"); // Collect Pickup Triggers that depend on this Pickup Action. m_DependentTriggers.Clear(); var pickupTriggers = StageUtility.GetCurrentStageHandle().FindComponentsOfType <PickupTrigger>(); foreach (var trigger in pickupTriggers) { if (trigger.GetMode() == PickupTrigger.Mode.SpecificPickups) { var specificPickups = trigger.GetSpecificPickupActions(); if (specificPickups.Contains(m_PickupAction)) { m_DependentTriggers.Add(trigger); } } } }
static public GameObject CreateNewUI() { var root = new GameObject("Canvas"); root.layer = LayerMask.NameToLayer("UI"); Canvas canvas = root.AddComponent <Canvas>(); canvas.renderMode = RenderMode.ScreenSpaceOverlay; root.AddComponent <CanvasScaler>(); root.AddComponent <GraphicRaycaster>(); StageUtility.PlaceGameObjectInCurrentStage(root); bool customScene = false; PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage(); if (prefabStage != null) { root.transform.SetParent(prefabStage.prefabContentsRoot.transform, false); customScene = true; } Undo.RegisterCreatedObjectUndo(root, "Create " + root.name); if (!customScene) { CreateEventSystem(false); } return(root); }
internal void CleanupEditor() { bool selectAvatarAsset = StageUtility.GetCurrentStageHandle() == StageUtility.GetMainStageHandle(); m_EditMode = EditMode.Stopping; DestroyEditor(); ChangeInspectorLock(m_InspectorLocked); EditorApplication.CallbackFunction CleanUpOnDestroy = null; CleanUpOnDestroy = () => { // Make sure that we restore the "original" selection if we exit Avatar Editing mode // from the avatar tooling itself (e.g by clicking done). if (selectAvatarAsset) { SelectAsset(); } if (!m_CameFromImportSettings) { m_EditMode = EditMode.NotEditing; } EditorApplication.update -= CleanUpOnDestroy; }; EditorApplication.update += CleanUpOnDestroy; // Reset back the Edit Mode specific states (they probably should be better encapsulated) m_GameObject = null; m_ModelBones = null; }
private void OnGUI() { this.scroll = EditorGUILayout.BeginScrollView(this.scroll); var prefabs = Resources.LoadAll("Prefabs/UI/Views"); if (GUILayout.Button("Main scene", GUILayout.Height(40), GUILayout.Width(100))) { StageUtility.GoToMainStage(); } GUILayout.Space(10); foreach (var item in prefabs) { if (item.name.Equals("ExempleScreen")) { continue; } GUILayout.Space(5); if (GUILayout.Button(item.name, GUILayout.Height(30), GUILayout.Width(100))) { AssetDatabase.OpenAsset(item); } } EditorGUILayout.EndScrollView(); }
// UnityEditor.UI.MenuOptions public static GameObject GetOrCreateCanvasGameObject() { GameObject activeGameObject = Selection.activeGameObject; Canvas canvas = (!(activeGameObject != null)) ? null : activeGameObject.GetComponentInParent <Canvas>(); GameObject result; if (SpringGUIMenuOptions.IsValidCanvas(canvas)) { result = canvas.gameObject; } else { Canvas[] array = StageUtility.GetCurrentStageHandle().FindComponentsOfType <Canvas>(); for (int i = 0; i < array.Length; i++) { if (SpringGUIMenuOptions.IsValidCanvas(array[i])) { result = array[i].gameObject; return(result); } } result = SpringGUIMenuOptions.CreateNewUI(); } return(result); }
// UnityEditor.UI.MenuOptions public static GameObject CreateNewUI() { GameObject gameObject = new GameObject("Canvas"); gameObject.layer = LayerMask.NameToLayer("UI"); Canvas canvas = gameObject.AddComponent <Canvas>(); canvas.renderMode = RenderMode.ScreenSpaceOverlay; gameObject.AddComponent <CanvasScaler>(); gameObject.AddComponent <GraphicRaycaster>(); StageUtility.PlaceGameObjectInCurrentStage(gameObject); bool flag = false; PrefabStage currentPrefabStage = PrefabStageUtility.GetCurrentPrefabStage(); if (currentPrefabStage != null) { gameObject.transform.SetParent(currentPrefabStage.prefabContentsRoot.transform, false); flag = true; } Undo.RegisterCreatedObjectUndo(gameObject, "Create " + gameObject.name); if (!flag) { SpringGUIMenuOptions.CreateEventSystem(false); } return(gameObject); }
private static bool BelongsToCurrentStage(this GameObject go, PrefabStage prefabStage, StageHandle stageHandleMain) { var stageHandleFromObject = StageUtility.GetStageHandle(go); bool result = prefabStage != null ? (stageHandleFromObject == prefabStage.stageHandle) : (stageHandleFromObject == stageHandleMain); return(result); }
private static void OnPrefabStageClosed(PrefabStage prefabStage) { if (log) { Debug.LogWarning(string.Format("Prefab stage closed, checking NGUI objects | Cameras: {0} | Panels: {1} | Drawcalls: {2}/{3}", UICamera.list.size, UIPanel.list.Count, UIDrawCall.activeList.size, UIDrawCall.inactiveList.size)); } CheckNGUIObjects(); // Since no events happened from standpoint of main stage objects, we have force them to update var stageHandleMain = StageUtility.GetMainStageHandle(); for (int s = 0; s < SceneManager.sceneCount; s++) { var sceneFromList = SceneManager.GetSceneAt(s); if (!sceneFromList.isLoaded) { continue; } var stageHandleFromList = StageUtility.GetStageHandle(sceneFromList); if (stageHandleFromList != stageHandleMain) { continue; } var sceneRootObjects = sceneFromList.GetRootGameObjects(); for (int i = 0; i < sceneRootObjects.Length; i++) { FindAndRefreshPanels(sceneRootObjects[i].transform); } } }
void AddCameraToCameraList(Rect rect, ReorderableList list) { // Need to do clear the list here otherwise the meu just fills up with more and more entries validCameras.Clear(); StageHandle stageHandle = StageUtility.GetStageHandle(camera.gameObject); var allCameras = stageHandle.FindComponentsOfType <Camera>(); foreach (var camera in allCameras) { var component = camera.gameObject.GetComponent <UniversalAdditionalCameraData>(); if (component != null) { if (validCameraTypes.Contains(component.renderType)) { validCameras.Add(camera); } } } var names = new GUIContent[validCameras.Count]; for (int i = 0; i < validCameras.Count; ++i) { names[i] = new GUIContent((i + 1) + " " + validCameras[i].name); } if (!validCameras.Any()) { names = new GUIContent[1]; names[0] = new GUIContent("No Overlay Cameras exist."); } EditorUtility.DisplayCustomMenu(rect, names, -1, AddCameraToCameraListMenuSelected, null); }
public override void OnToolGUI(EditorWindow window) { var view = window as SceneView; if (!view || !Selection.activeTransform || Tools.s_Hidden) { return; } if (!StageUtility.IsGameObjectRenderedByCamera(Selection.activeTransform.gameObject, Camera.current)) { return; } bool isStatic = (!Tools.s_Hidden && EditorApplication.isPlaying && GameObjectUtility.ContainsStatic(Selection.gameObjects)); using (new EditorGUI.DisabledScope(isStatic)) { Vector3 handlePosition = Tools.handlePosition; ToolGUI(view, handlePosition, isStatic); Handles.ShowStaticLabelIfNeeded(handlePosition); } }
static void OnPrefabStageClosing(PrefabStage stage) { // When closing, we want the bricks that are in the scene var bricks = StageUtility.GetMainStageHandle().FindComponentsOfType <Brick>(); SetShowBricks(showAllBricks, bricks); }
public IEnumerator NavMeshSurfacePrefab_AfterClearedInstanceAppliedBack_HasEmptyData() { var prefab = AssetDatabase.LoadAssetAtPath <GameObject>(m_PrefabPath); var instance = PrefabUtility.InstantiatePrefab(prefab) as GameObject; Assert.IsNotNull(instance); instance.name = "Surface" + m_TestCounter + "PrefabInstance"; TestNavMeshExistsAloneAtPosition(k_PrefabDefaultArea, Vector3.zero); var instanceSurface = instance.GetComponent <NavMeshSurface>(); Assert.IsNotNull(instanceSurface); NavMeshAssetManager.instance.ClearSurfaces(new Object[] { instanceSurface }); var expectedAreaMask = 1 << k_PrefabDefaultArea; Assert.IsFalse(HasNavMeshAtPosition(Vector3.zero, expectedAreaMask)); PrefabUtility.ApplyPrefabInstance(instance, InteractionMode.AutomatedAction); AssetDatabase.OpenAsset(prefab); var prefabStage = PrefabStageUtility.GetCurrentPrefabStage(); var prefabSurface = prefabStage.prefabContentsRoot.GetComponent <NavMeshSurface>(); Assert.IsTrue(prefabSurface.navMeshData == null, "Prefab should have empty NavMeshData when empty data has been applied back from the instance."); StageUtility.GoToMainStage(); #if !KEEP_ARTIFACTS_FOR_INSPECTION Object.DestroyImmediate(instance); #endif yield return(null); }
static void CreateTerrain(MenuCommand menuCommand) { // Create the storage for the terrain in the project // (So we can reuse it in multiple scenes) TerrainData terrainData = new TerrainData(); const int size = 1025; terrainData.heightmapResolution = size; terrainData.size = new Vector3(1000, 600, 1000); terrainData.heightmapResolution = 512; terrainData.baseMapResolution = 1024; terrainData.SetDetailResolution(1024, terrainData.detailResolutionPerPatch); AssetDatabase.CreateAsset(terrainData, AssetDatabase.GenerateUniqueAssetPath("Assets/New Terrain.asset")); var parent = menuCommand.context as GameObject; GameObject terrain = Terrain.CreateTerrainGameObject(terrainData); terrain.name = "Terrain"; GameObjectUtility.SetParentAndAlign(terrain, parent); StageUtility.PlaceGameObjectInCurrentStage(terrain); GameObjectUtility.EnsureUniqueNameForSibling(terrain); Selection.activeObject = terrain; Undo.RegisterCreatedObjectUndo(terrain, "Create terrain"); }
internal static void CutGO() { m_GOCutboard = Selection.transforms; m_SelectedObjects = Selection.objects; // Selection.transform does not provide correct list order, so we have to do it manually m_GOCutboard = m_GOCutboard.ToList().OrderBy(g => Array.IndexOf(m_SelectedObjects, g.gameObject)).ToArray(); // Return if nothing selected if (!hasCutboardData) { return; } m_StageCutWasPerformedIn = StageUtility.GetStage(m_GOCutboard[0].gameObject); // If cut gameObject is prefab, get its root transform for (int i = 0; i < m_GOCutboard.Length; i++) { if (PrefabUtility.GetPrefabAssetType(m_GOCutboard[i].gameObject) != PrefabAssetType.NotAPrefab) { m_GOCutboard[i] = PrefabUtility.GetOutermostPrefabInstanceRoot(m_GOCutboard[i].gameObject)?.transform; } } // Cut gameObjects should be visually marked as cut, so adding them to the hashset m_CutAffectedGOs.Clear(); foreach (var item in m_GOCutboard) { m_CutAffectedGOs.Add(item); AddChildrenToHashset(item); } // Clean pasteboard when cutting gameObjects Unsupported.ClearPasteboard(); }
protected static System.Collections.Generic.IEnumerable <T> GetObjectsForLightingExplorer <T>() where T : UnityEngine.Component { var objects = Resources.FindObjectsOfTypeAll <T>().Where((T obj) => { return(!EditorUtility.IsPersistent(obj) && !obj.hideFlags.HasFlag(HideFlags.HideInHierarchy) && !obj.hideFlags.HasFlag(HideFlags.HideAndDontSave)); }); var prefabStage = PrefabStageUtility.GetCurrentPrefabStage(); // No prefab mode. if (prefabStage == null) { // Return all object instances in the scene including prefab instances, but not those that are in prefab assets. return(objects); } // In Context prefab mode with Normal rendering mode else if (prefabStage.mode == PrefabStage.Mode.InContext && StageNavigationManager.instance.contextRenderMode == StageUtility.ContextRenderMode.Normal) { // Return all object instances in the scene and objects in the opened prefab asset, but not objects in the opened prefab instance. return(objects.Where((T obj) => { return !StageUtility.IsPrefabInstanceHiddenForInContextEditing(obj.gameObject); })); } // All remaining cases, e.g. In Context with Hidden or GrayedOut rendering mode, or In Isolation prefab mode. else { // Return only objects in the opened prefab asset. return(objects.Where((T obj) => { return EditorSceneManager.IsPreviewSceneObject(obj); })); } }
private static void CreateEventSystem(bool select, GameObject parent) { StageHandle stage = parent == null?StageUtility.GetCurrentStageHandle() : StageUtility.GetStageHandle(parent); var esys = stage.FindComponentOfType <EventSystem>(); if (esys == null) { var eventSystem = new GameObject("EventSystem"); if (parent == null) { StageUtility.PlaceGameObjectInCurrentStage(eventSystem); } else { GameObjectUtility.SetParentAndAlign(eventSystem, parent); } esys = eventSystem.AddComponent <EventSystem>(); eventSystem.AddComponent <StandaloneInputModule>(); Undo.RegisterCreatedObjectUndo(eventSystem, "Create " + eventSystem.name); } if (select && esys != null) { Selection.activeGameObject = esys.gameObject; } }
void SaveCameraState(SceneView sceneView, Stage stage) { if (stage == null) { return; } // Allows stage to override which stage should be used for saving the state. // Useful for Prefab Mode in Context where we want to save the context scene state. Stage contextStage = stage.GetContextStage(); if (contextStage == null) { return; } string key = StageUtility.CreateWindowAndStageIdentifier(sceneView.windowGUID, contextStage); var state = m_StateCache.GetState(key); if (state == null) { state = new SceneViewCameraState(); } state.SaveStateFromSceneView(sceneView); m_StateCache.SetState(key, state); }
/// <summary> /// Returns true if the given object is being edited in prefab mode. /// </summary> /// <param name="obj">Object to check</param> /// <returns>True if object is in prefab mode</returns> public static bool IsEditingInPrefabMode(GameObject obj) { #if UNITY_EDITOR if (EditorUtility.IsPersistent(obj)) { // Stored on disk (some sort of prefab) return true; } else { #if UNITY_2018_3_OR_NEWER // If not persistent, check if in prefab stage if (StageUtility.GetMainStageHandle() != StageUtility.GetStageHandle(obj)) { var stage = PrefabStageUtility.GetPrefabStage(obj); if (stage != null) { return true; } } #endif } #endif return false; }
public static OpenSceneResult OpenSceneWithSavePrompt(string path, bool activate = true) { #if UNITY_2018_3_OR_NEWER StageUtility.GoToMainStage(); #endif var result = new OpenSceneResult(); var targetScene = SceneManager.GetSceneByPath(path); if (targetScene == SceneManager.GetActiveScene()) { result.scene = targetScene; result.success = true; result.scenePath = path; return(result); } if (!SaveCurrentModifiedScenesIfUserWantsTo()) { return(result); } return(OpenScene(path, activate)); }
// Helper function that returns a Canvas GameObject; preferably a parent of the selection, or other existing Canvas. public static GameObject GetOrCreateCanvasGameObject() { GameObject selectedGo = Selection.activeGameObject; // Try to find a gameobject that is the selected GO or one if its parents. Canvas canvas = (selectedGo != null) ? selectedGo.GetComponentInParent <Canvas>() : null; if (IsValidCanvas(canvas)) { return(canvas.gameObject); } // No canvas in selection or its parents? Then use any valid canvas. // We have to find all loaded Canvases, not just the ones in main scenes. Canvas[] canvasArray = StageUtility.GetCurrentStageHandle().FindComponentsOfType <Canvas>(); for (int i = 0; i < canvasArray.Length; i++) { if (IsValidCanvas(canvasArray[i])) { return(canvasArray[i].gameObject); } } // No canvas in the scene at all? Then create a new one. return(CreateNewUI()); }
public override List <Point2> Selecting(Unit _user, KeyCode _key) { LightPanelPopper.Instance.AllActiveOff(); List <Point2> returnPoints = new List <Point2>(); var redPoint = RightClickRayShot.GetMouseRayHitObject <BlockPointGetter>(); if (redPoint == null) { return(returnPoints); } var points = StageUtility.GetCrossPoint(redPoint.point, effectRange); foreach (var p in points) { LightPanelPopper.Instance.ActiveOn(p, Color.red); } var pointGetter = RightClickRayShot.GetMouseRayHitObject <BlockPointGetter>(_key); if (pointGetter != null) { returnPoints = StageUtility.GetCrossPoint(pointGetter.point, effectRange); } return(returnPoints); }
public IEnumerator NavMeshSurfacePrefab_AfterBakingInPrefabMode_LeavesMainSceneUntouched() { Assert.IsFalse(HasNavMeshAtPosition(Vector3.zero)); var prefab = AssetDatabase.LoadAssetAtPath <GameObject>(m_PrefabPath); AssetDatabase.OpenAsset(prefab); var prefabStage = PrefabStageUtility.GetCurrentPrefabStage(); Assert.IsNotNull(prefabStage); Assert.IsNotNull(prefabStage.prefabContentsRoot); var prefabSurface = prefabStage.prefabContentsRoot.GetComponent <NavMeshSurface>(); var initialPrefabNavMeshData = prefabSurface.navMeshData; yield return(BakeNavMeshAsync(() => prefabSurface, k_RedArea)); Assert.AreNotSame(initialPrefabNavMeshData, prefabSurface.navMeshData); PrefabSavingUtil.SavePrefab(prefabStage); StageUtility.GoToMainStage(); Assert.IsFalse(HasNavMeshAtPosition(Vector3.zero, NavMesh.AllAreas, 0, 1000.0f)); yield return(null); }
public List <Point2> GetCanMovePoint(Unit _unit) { List <Point2> standingList = CompornentUtility.FindCompornentOnScene <UnitManager>().GetStandingPoints(); List <Point2> canMovePoints = new List <Point2>(); Point2 pivot = _unit.pos; int moveRange = _unit.GetUnitStatus.moveRange; var crossPoints = StageUtility.GetCrossPoint(pivot, moveRange); foreach (var point in crossPoints) { //既にunitがいた場合continue if (standingList.Contains(point)) { continue; } //たどり着けるかチェック var pathList = pathCreater.GetPath(_unit.pos, point, _unit.GetUnitStatus.stepHeight); if (pathList == null) { continue; } //unitの設定歩数で行けるかチェック if (pathList.Count > moveRange) { continue; } canMovePoints.Add(point); } return(canMovePoints); }
public IEnumerator NavMeshSurfacePrefab_WhenInstanceCleared_PrefabKeepsNavMeshData() { var prefab = AssetDatabase.LoadAssetAtPath <GameObject>(m_PrefabPath); var instance = PrefabUtility.InstantiatePrefab(prefab) as GameObject; Assert.IsNotNull(instance); instance.name = "Surface" + m_TestCounter + "PrefabInstance"; var instanceSurface = instance.GetComponent <NavMeshSurface>(); Assert.IsNotNull(instanceSurface); var initialPrefabNavMeshData = instanceSurface.navMeshData; NavMeshAssetManager.instance.ClearSurfaces(new Object[] { instanceSurface }); var expectedAreaMask = 1 << k_PrefabDefaultArea; Assert.IsFalse(HasNavMeshAtPosition(Vector3.zero, expectedAreaMask)); AssetDatabase.OpenAsset(prefab); var prefabStage = PrefabStageUtility.GetCurrentPrefabStage(); var prefabSurface = prefabStage.prefabContentsRoot.GetComponent <NavMeshSurface>(); var prefabNavMeshData = prefabSurface.navMeshData; Assert.IsTrue(prefabNavMeshData != null, "NavMeshSurface in the prefab must still have NavMeshData even though the instance was cleared."); Assert.AreSame(initialPrefabNavMeshData, prefabNavMeshData); StageUtility.GoToMainStage(); #if !KEEP_ARTIFACTS_FOR_INSPECTION Object.DestroyImmediate(instance); #endif yield return(null); }
public override IEnumerator InitializeAsync(SceneUICtrl sceneUICtrl) { yield return StartCoroutine (base.InitializeAsync (sceneUICtrl)); uiCtrl = base._sceneUICtrl as StageSelectUICtrl; stageUtility = Utilities.stageUtility; }