public void ClassCleanup() { EditorSceneManager.NewScene(NewSceneSetup.EmptyScene); }
private void CreateScene() { AssetDatabase.SaveAssets(); Type.GetType("UnityEditor.LogEntries,UnityEditor.dll") .GetMethod("Clear", BindingFlags.Static | BindingFlags.Public) .Invoke(null, null); newScene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Additive); EditorSceneManager.CloseScene(EditorSceneManager.GetSceneAt(0), true); newScene.name = folderName; //GameObject canvasRoot = new GameObject("CanvasRoot"); CreateEventSystem(); GameObject rootObj = CreateCanvas(); menuRoot = rootObj.AddComponent <MenuRoot>(); //menuRoot.allMenus = new Dictionary<string, MenuManager>(); int tempI = 0; string tempFolder = ""; string tempFolderA = ""; string tempFolderDel = ""; while (tempI < 1000) { tempFolder = "assets/" + TEMP_DIR + tempI.ToString(); if (!Directory.Exists(tempFolder)) { tempFolderDel = tempFolder; tempFolderA = tempFolder + "/Resources"; Directory.CreateDirectory(tempFolderA); break; } else { tempI++; } } tempFolderA += "/" + TEMP_SUB_DIR; FileUtil.CopyFileOrDirectory(sceneDirectory, tempFolderA); //FileUtil.CopyFileOrDirectoryFollowSymlinks(sceneDirectory, tempFolderA); AssetDatabase.Refresh(); MenuData[] menus = Resources.LoadAll <MenuData>(TEMP_SUB_DIR); tempMenus = new Dictionary <string, MenuManager>(); tempButtons = new Dictionary <Button, UiData>(); tempUis = new Queue <KeyValuePair <Transform, List <UiSortData> > >(); foreach (MenuData md in menus) { MenuManager menu = (MenuManager)CreateMenu(md, rootObj.transform); menuRoot.AddMenu(menu); tempMenus.Add(md.name, menu); } foreach (KeyValuePair <Button, UiData> bb in tempButtons) { Type[] arguments = new Type[1]; arguments[0] = typeof(int); MethodInfo method = UnityEventBase.GetValidMethodInfo(menuRoot, "ShowMenu", arguments); UnityAction <int> ua = Delegate.CreateDelegate(typeof(UnityAction <int>), menuRoot, method) as UnityAction <int>; if (bb.Value.action == ButtonAction.ShowMenu) { Debug.Log(menuRoot.allMenus.IndexOf(tempMenus[bb.Value.goTo.name])); int index = menuRoot.allMenus.IndexOf(tempMenus[bb.Value.goTo.name]); UnityEventTools.AddIntPersistentListener(bb.Key.onClick, ua, index); } } while (tempUis.Count > 0) { KeyValuePair <Transform, List <UiSortData> > tempK = tempUis.Dequeue(); List <UiSortData> tempList = tempK.Value; for (int i = 0; i < tempList.Count; i++) { //Debug.Log("^^^: " + tempList[i].layer); tempList[i].ui.SetAsFirstSibling(); } } EditorSceneManager.SaveScene(UnityEngine.SceneManagement.SceneManager.GetSceneAt(0), sceneDirectory + "/" + folderName + ".unity"); FileUtil.DeleteFileOrDirectory(tempFolderDel); AssetDatabase.Refresh(); if (myWindow != null) { myWindow.Close(); } return; Debug.Log(":: " + sceneDirectory + ", " + folderName); // You can either filter files to get only neccessary files by its file extension using LINQ. // It excludes .meta files from all the gathers file list. IEnumerable <string> assetFiles = GetFiles(GetSelectedPathOrFallback()).Where(str => str.Contains(".meta") == false); foreach (string f in assetFiles) { Debug.Log("Files: " + f); } }
// Appends to collectedAssets static void ExportToToolkit_Environment( Environment environment, string targetDirectory, HashSet <string> collectedAssets) { // make an environment var name = environment.name; var settings = environment.m_RenderSettings; EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single); var prefab = AssetDatabase.LoadAssetAtPath <GameObject>( "Assets/Resources/" + settings.m_EnvironmentPrefab + ".prefab"); PrefabUtility.InstantiatePrefab(prefab); RenderSettings.ambientSkyColor = settings.m_AmbientColor; RenderSettings.fogColor = settings.m_FogColor; RenderSettings.reflectionIntensity = settings.m_ReflectionIntensity; RenderSettings.defaultReflectionMode = UnityEngine.Rendering.DefaultReflectionMode.Custom; RenderSettings.fog = settings.m_FogEnabled; RenderSettings.fogMode = settings.m_FogMode; RenderSettings.fogDensity = settings.m_FogDensity; RenderSettings.fogStartDistance = settings.m_FogStartDistance; RenderSettings.fogEndDistance = settings.m_FogEndDistance; // Lights Object.DestroyImmediate(Object.FindObjectOfType <Light>()); for (int li = 0; li < environment.m_Lights.Count; li++) { var lsettings = environment.m_Lights[li]; var light = new GameObject("Light " + li, typeof(Light)).GetComponent <Light>(); light.transform.position = lsettings.m_Position; light.transform.rotation = lsettings.m_Rotation; light.color = lsettings.Color; light.type = lsettings.m_Type; light.range = lsettings.m_Range; light.spotAngle = lsettings.m_SpotAngle; light.intensity = 1.0f; light.shadows = lsettings.m_ShadowsEnabled ? LightShadows.Hard : LightShadows.None; } // Camera var cam = Object.FindObjectOfType <Camera>(); cam.transform.position = new Vector3(0, 15, 0); cam.nearClipPlane = 0.5f; cam.farClipPlane = 10000.0f; cam.fieldOfView = 60; cam.clearFlags = CameraClearFlags.Skybox; cam.backgroundColor = settings.m_ClearColor; RenderSettings.customReflection = settings.m_ReflectionCubemap; if (settings.m_SkyboxCubemap) { Error("These guid shenanigans don't work yet: {0}", name); Material skyboxMaterialTmp = new Material(Shader.Find("Custom/Skybox")); Guid skyboxMaterialGuid = GuidUtils.Uuid5(environment.m_Guid, "skyboxMaterial"); Material skyboxMaterial = CreateAssetWithGuid_Incorrect( skyboxMaterialTmp, name + "_Skybox.mat", skyboxMaterialGuid); string sbAssetPath = AssetDatabase.GetAssetPath(skyboxMaterial); collectedAssets.UnionWith(GetDependencies(sbAssetPath, includeRoot: false)); string sbFinalPath = targetDirectory + "/" + sbAssetPath; CopyAsset(sbAssetPath, sbFinalPath); RenderSettings.skybox = skyboxMaterial; RenderSettings.skybox.SetColor("_Tint", settings.m_SkyboxTint); RenderSettings.skybox.SetFloat("_Exposure", settings.m_SkyboxExposure); RenderSettings.skybox.SetTexture("_Tex", settings.m_SkyboxCubemap); } else { RenderSettings.skybox = null; } Lightmapping.realtimeGI = false; Lightmapping.bakedGI = false; // Store scene var sceneAssetPath = "Assets/Dynamic/" + name + ".unity"; var sceneFinalPath = targetDirectory + "/Environments/" + Path.GetFileName(sceneAssetPath); EditorSceneManager.SaveScene(SceneManager.GetActiveScene(), sceneAssetPath); AssetDatabase.ImportAsset(sceneAssetPath, ImportAssetOptions.ForceSynchronousImport); CopyAsset(sceneAssetPath, sceneFinalPath); collectedAssets.UnionWith(GetDependencies(sceneAssetPath, includeRoot: false)); SetFileGuid_Incorrect(sceneFinalPath, environment.m_Guid); AssetDatabase.DeleteAsset(sceneAssetPath); EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects); }
void CreateSubFolders(string rootPath) { DirectoryInfo rootinfo = null; List <string> folderNames = new List <string>(); // Creating Directory for Art rootinfo = Directory.CreateDirectory(rootPath + "/Art"); if (rootinfo.Exists) { folderNames.Clear(); folderNames.Add("Animation"); folderNames.Add("Audio"); folderNames.Add("Objects/Models"); folderNames.Add("Materials"); folderNames.Add("Prefabs"); folderNames.Add("Textures"); CreateFolders(rootPath + "/Art", folderNames); } // Creating Directory for Code rootinfo = Directory.CreateDirectory(rootPath + "/Code"); if (rootinfo.Exists) { folderNames.Clear(); folderNames.Add("Editor"); folderNames.Add("Scripts"); folderNames.Add("Shaders"); CreateFolders(rootPath + "/Code", folderNames); } // Creating Directory for Resoruces rootinfo = Directory.CreateDirectory(rootPath + "/Resoruces"); if (rootinfo.Exists) { folderNames.Clear(); folderNames.Add("Characters"); folderNames.Add("Managers"); folderNames.Add("Props"); folderNames.Add("UI"); CreateFolders(rootPath + "/Resoruces", folderNames); } // Creating Directory for Prefabs rootinfo = Directory.CreateDirectory(rootPath + "/Prefabs"); if (rootinfo.Exists) { folderNames.Clear(); folderNames.Add("Characters"); folderNames.Add("Props"); folderNames.Add("UI"); CreateFolders(rootPath + "/Prefabs", folderNames); } // Create Scenes DirectoryInfo sceneInfo = Directory.CreateDirectory(rootPath + "/Scenes"); if (sceneInfo.Exists) { // Create base level scenes needed for a simple game Scene currentFrontendScene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single); EditorSceneManager.SaveScene(currentFrontendScene, "Assets/" + gameName + "/Scenes/" + gameName + "_Frontend.unity", true); Scene currentMainScene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single); EditorSceneManager.SaveScene(currentMainScene, "Assets/" + gameName + "/Scenes/" + gameName + "_Main.unity", true); Scene currentStartupScene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single); EditorSceneManager.SaveScene(currentStartupScene, "Assets/" + gameName + "/Scenes/" + gameName + "_Startup.unity", true); } DirectoryInfo devSceneInfo = Directory.CreateDirectory(rootPath + "/Scenes/Development"); if (devSceneInfo.Exists) { // Create base level scenes needed for a simple game Scene currentDevelopmentScene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single); EditorSceneManager.SaveScene(currentDevelopmentScene, "Assets/" + gameName + "/Scenes/Development/" + gameName + "_Development.unity", true); } }
/// <summary> /// Creates a new scene into which we'll load the block. /// </summary> /// <returns></returns> private static Scene CreateSceneForBlock() { var newScene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Additive); return(newScene); }
public static void NewEmptyScene() { EditorSceneManager.NewScene(NewSceneSetup.EmptyScene); }
internal void SwitchToEditMode() { this.m_EditMode = AvatarEditor.EditMode.Starting; this.ChangeInspectorLock(true); this.sceneSetup = EditorSceneManager.GetSceneManagerSetup(); EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects).name = "Avatar Configuration"; this.m_GameObject = UnityEngine.Object.Instantiate <GameObject>(this.prefab); if (base.serializedObject.FindProperty("m_OptimizeGameObjects").boolValue) { AnimatorUtility.DeoptimizeTransformHierarchy(this.m_GameObject); } Animator component = this.m_GameObject.GetComponent <Animator>(); if (component != null && component.runtimeAnimatorController == null) { AnimatorController animatorController = new AnimatorController(); animatorController.hideFlags = HideFlags.DontSave; animatorController.AddLayer("preview"); animatorController.layers[0].stateMachine.hideFlags = HideFlags.DontSave; component.runtimeAnimatorController = animatorController; } Dictionary <Transform, bool> modelBones = AvatarSetupTool.GetModelBones(this.m_GameObject.transform, true, null); AvatarSetupTool.BoneWrapper[] humanBones = AvatarSetupTool.GetHumanBones(base.serializedObject, modelBones); this.m_ModelBones = AvatarSetupTool.GetModelBones(this.m_GameObject.transform, false, humanBones); Selection.activeObject = this.m_GameObject; UnityEngine.Object[] array = Resources.FindObjectsOfTypeAll(typeof(SceneHierarchyWindow)); for (int i = 0; i < array.Length; i++) { SceneHierarchyWindow sceneHierarchyWindow = (SceneHierarchyWindow)array[i]; sceneHierarchyWindow.SetExpandedRecursive(this.m_GameObject.GetInstanceID(), true); } this.CreateEditor(); this.m_EditMode = AvatarEditor.EditMode.Editing; this.m_SceneStates = new List <AvatarEditor.SceneStateCache>(); IEnumerator enumerator = SceneView.sceneViews.GetEnumerator(); try { while (enumerator.MoveNext()) { SceneView sceneView = (SceneView)enumerator.Current; this.m_SceneStates.Add(new AvatarEditor.SceneStateCache { state = new SceneView.SceneViewState(sceneView.m_SceneViewState), view = sceneView }); sceneView.m_SceneViewState.showFlares = false; sceneView.m_SceneViewState.showMaterialUpdate = false; sceneView.m_SceneViewState.showFog = false; sceneView.m_SceneViewState.showSkybox = false; sceneView.m_SceneViewState.showImageEffects = false; sceneView.FrameSelected(); } } finally { IDisposable disposable; if ((disposable = (enumerator as IDisposable)) != null) { disposable.Dispose(); } } }
private void OnGUI() { #region ScrollView scrollPosition = GUILayout.BeginScrollView(scrollPosition); GUILayout.Space(space); if (GUILayout.Button("Create new level", GUILayout.Height(buttonHeight), GUILayout.Width(buttonWidth))) { newSceneIndex = FindAppropriateIndex(); if (EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo()) { // Create new scene EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single); // Add new scene to build settings AddNewSceneToBuildSetting(newSceneIndex); // Add prefabs to new scene AddPrefabsToNewScene(); // Add background to new scene AddBackgroundToNewScene(); // Save scene after adding everything SaveScene(); } return; } GUILayout.Space(space); GUILayout.BeginHorizontal(); GUILayout.Label("Frame type", GUILayout.Width(labelWidth)); // Popup (it's a dropdown) popupIndex = EditorGUILayout.Popup(popupIndex, levelEditorSO.frameType, GUILayout.Height(dropdownHeight), GUILayout.Width(dropdownWidth)); GUILayout.EndHorizontal(); GUILayout.Space(space); GUILayout.BeginHorizontal(); GUILayout.Label("Scene Folder", GUILayout.Width(labelWidth)); GUI.SetNextControlName("dropdownFolderName"); folderIndex = EditorGUILayout.Popup(folderIndex, levelEditorSO.sceneFolderName, GUILayout.Height(dropdownHeight), GUILayout.Width(dropdownWidth)); GUILayout.EndHorizontal(); GUI.enabled = true; #region Edit existing level #region Textfield && Arrows EditorGUILayout.BeginHorizontal(); GUIStyle gUIStyleButton = new GUIStyle(GUI.skin.button); gUIStyleButton.fontSize = 20; // Left arrow if (GUILayout.Button("↤", gUIStyleButton, GUILayout.Height(buttonHeight), GUILayout.Width(50))) { int newNumber = (int.Parse(textFieldNumber) - 1); if (newNumber >= 1) { textFieldNumber = newNumber.ToString(); //ShowYesNoPopup(); ChangeImage(); GUI.FocusControl("dropdownFolderName"); } } // Textfield GUIStyle gUIStyle = new GUIStyle(GUI.skin.textField); gUIStyle.alignment = TextAnchor.MiddleLeft; textFieldNumber = EditorGUILayout.TextField(textFieldNumber, gUIStyle, GUILayout.Height(buttonHeight), GUILayout.Width(100)); // Right arrow if (GUILayout.Button("↦", gUIStyleButton, GUILayout.Height(buttonHeight), GUILayout.Width(50))) { int newNumber = (int.Parse(textFieldNumber) + 1); textFieldNumber = newNumber.ToString(); //ShowYesNoPopup(); ChangeImage(); GUI.FocusControl("dropdownFolderName"); } EditorGUILayout.EndHorizontal(); #endregion GUILayout.Space(space / 2); if (GUILayout.Button($"Open Level {textFieldNumber}", GUILayout.Height(buttonHeight), GUILayout.Width(buttonWidth))) { if (int.TryParse(textFieldNumber, out int i)) { ShowUnSavePopup(); ChangeImage(); } } deleteScene = EditorGUILayout.BeginToggleGroup("Delete current scene", deleteScene); GUILayout.Space(space / 2); if (GUILayout.Button("Delete", GUILayout.Height(buttonHeight), GUILayout.Width(buttonWidth))) { string sceneName = EditorSceneManager.GetActiveScene().name; string filePath = $"Assets/_Main/_Scenes/{levelEditorSO.sceneFolderName[folderIndex]}/{sceneName}.unity"; if (File.Exists(filePath)) { if (EditorUtility.DisplayDialog($"Delete Level{textFieldNumber} scene", $"Do you want to delete {sceneName} scene?", "Yes", "No")) { File.Delete(filePath); #if UNITY_EDITOR AssetDatabase.Refresh(); UpdateSceneAmountInScriptableObject(false); #endif EditorBuildSettingsScene[] originalSettingScenes = EditorBuildSettings.scenes; EditorBuildSettingsScene sceneToRemove = new EditorBuildSettingsScene($"Assets/_Main/_Scenes/{levelEditorSO.sceneFolderName[folderIndex]}/{sceneName}.unity", true); EditorBuildSettingsScene[] newSettings = new EditorBuildSettingsScene[originalSettingScenes.Length - 1]; for (int i = 0, j = 0; i < originalSettingScenes.Length; i++) { if (originalSettingScenes[i].path != sceneToRemove.path) { newSettings[j++] = originalSettingScenes[i]; } } EditorBuildSettings.scenes = newSettings; EditorSceneManager.OpenScene(EditorBuildSettings.scenes[EditorBuildSettings.scenes.Length - 1].path); EditorUtility.DisplayDialog("Message", $"{sceneName} has been deleted from project folder and build settings", "OK"); } } else { EditorUtility.DisplayDialog("File not found", $"Can not find IntroScene in folder {filePath}", "OK"); } } EditorGUILayout.EndToggleGroup(); #endregion #region Intro, Menu, Menu Select Scene int minus = 30; GUILayout.Space(space); GUILayout.BeginHorizontal(); if (GUILayout.Button($"Open {levelEditorSO.sceneFolderName[folderIndex]} Select Level", GUILayout.Width(buttonWidth - minus), GUILayout.Height(buttonHeight))) { if (EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo()) { try { EditorSceneManager.OpenScene($"Assets/_Main/_Scenes/{levelEditorSO.sceneFolderName[folderIndex]}/MenuSelectLevel{folderIndex + 1}.unity"); } catch (Exception) { EditorUtility.DisplayDialog("File not found", $"Can not find MenuSelectLevel{folderIndex + 1} in folder Assets/_Main/_Scenes/{levelEditorSO.sceneFolderName[folderIndex]}", "OK"); } } } if (GUILayout.Button("Open Intro Scene", GUILayout.Width(buttonWidth - minus), GUILayout.Height(buttonHeight))) { if (EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo()) { try { EditorSceneManager.OpenScene("Assets/_Main/_Scenes/IntroScene.unity"); } catch (Exception) { EditorUtility.DisplayDialog("File not found", "Can not find IntroScene in folder Assets/_Main/_Scenes/", "OK"); } } } GUILayout.EndHorizontal(); GUILayout.Space(space); GUILayout.BeginHorizontal(); if (GUILayout.Button("Open Menu Scene", GUILayout.Width(buttonWidth - minus), GUILayout.Height(buttonHeight))) { if (EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo()) { try { EditorSceneManager.OpenScene("Assets/_Main/_Scenes/MenuScene.unity"); } catch (Exception) { EditorUtility.DisplayDialog("File not found", "Can not find MenuScene in folder Assets/_Main/_Scenes/", "OK"); } } } if (GUILayout.Button("Open Menu Select Episode", GUILayout.Width(buttonWidth - minus), GUILayout.Height(buttonHeight))) { if (EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo()) { try { EditorSceneManager.OpenScene("Assets/_Main/_Scenes/MenuSelectEpisode.unity"); } catch (Exception) { EditorUtility.DisplayDialog("File not found", "Can not find MenuSelectEpisode in folder Assets/_Main/_Scenes/", "OK"); } } } GUILayout.EndHorizontal(); #endregion #region Scene Image GUI.enabled = true; GUILayout.Space(space / 2); if (!imageExist) { GUILayout.Label("Image does not exists in folder"); } else { GUILayout.Label(imageOfLevel, GUILayout.Width(Screen.width - 25)); } #endregion GUILayout.EndScrollView(); #endregion end ScrollView }
public void SetupScenes() { // first check if the scene is already open if (EditorSceneManager.sceneCount > 1) { // multiple scenes are open, check if the second one is an extendedUI scene if (EditorSceneManager.GetSceneAt(1).name.Contains(ProWorkstationManager.extendedUIString)) { Debug.Log("extendedUI scene open already"); return; } // multiple scenes are open, but not extended UI scene Debug.Log("secondary scene is open, but is not an extendedUI scene. please close extra scenes and try again."); return; } else { // if only one scene is open var activeScene = EditorSceneManager.GetActiveScene(); EditorSceneManager.SaveOpenScenes(); Debug.Log("active scene saved!"); // first see if this scene is already the extended UI scene string secondSceneName = ""; string newPath = ""; if (activeScene.name.Contains(ProWorkstationManager.extendedUIString)) { // if the active scene is already open, try to load the regular scene secondSceneName = activeScene.name.Substring(0, activeScene.name.IndexOf(ProWorkstationManager.extendedUIString)); newPath = activeScene.path; newPath = newPath.Substring(0, newPath.LastIndexOf(ProWorkstationManager.extendedUIString)) + ".unity"; Debug.Log(secondSceneName); Debug.Log(newPath); } else { // try to load _extendedUI version of that scene instead secondSceneName = activeScene.name + ProWorkstationManager.extendedUIString; newPath = activeScene.path; newPath = newPath.Insert(newPath.LastIndexOf(".unity"), ProWorkstationManager.extendedUIString); } bool loadedSceneSuccessfully = TryLoadingScene(newPath); if (loadedSceneSuccessfully) { Debug.Log("found existing complementary scene, loading"); } else { // if it doesn't exist, create and save it Scene extendedScene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Additive); extendedScene.name = secondSceneName; EditorSceneManager.SaveScene(extendedScene, newPath); Debug.Log("didn't find existing complementary scene, creating it"); } // set active scene to lkg one, just to fix lighting Scene lkgScene = EditorSceneManager.GetActiveScene(); for (int i = 0; i < EditorSceneManager.sceneCount; i++) { if (!EditorSceneManager.GetSceneAt(i).name.Contains(ProWorkstationManager.extendedUIString)) { lkgScene = EditorSceneManager.GetSceneAt(i); } } EditorSceneManager.SetActiveScene(lkgScene); } }
internal void SwitchToAssetMode(bool selectAvatarAsset) { foreach (var state in m_SceneStates) { if (state.view == null) { continue; } state.view.sceneViewState.showFog = state.state.showFog; state.view.sceneViewState.showFlares = state.state.showFlares; state.view.sceneViewState.showMaterialUpdate = state.state.showMaterialUpdate; state.view.sceneViewState.showSkybox = state.state.showSkybox; state.view.sceneViewState.showImageEffects = state.state.showImageEffects; state.view.sceneViewState.showParticleSystems = state.state.showParticleSystems; } m_EditMode = EditMode.Stopping; DestroyEditor(); ChangeInspectorLock(m_InspectorLocked); // if the user started play mode While in Edit mode it not clear what we should do // for now let the active scene open and do nothing if (!EditorApplication.isPlaying) { EditorApplication.CallbackFunction CleanUpSceneOnDestroy = null; CleanUpSceneOnDestroy = () => { string currentScene = SceneManager.GetActiveScene().path; if (currentScene.Length > 0) { // in this case the user did save manually the current scene and want to keep it or // he did open a new scene // do nothing } // Restore scene that was loaded when user pressed Configure button else if (sceneSetup != null && sceneSetup.Length > 0) { EditorSceneManager.RestoreSceneManagerSetup(sceneSetup); sceneSetup = null; } else { EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects); } // 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 -= CleanUpSceneOnDestroy; }; EditorApplication.update += CleanUpSceneOnDestroy; } // Reset back the Edit Mode specific states (they probably should be better encapsulated) m_GameObject = null; m_ModelBones = null; }
public static void OpenEmptyScene() { #if UNITY_EDITOR EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single); #endif }
internal void SwitchToEditMode() { // Ensure we show the main stage before starting editing the Avatar since it will be edited on the Main stage (we are using a main scene for it) if (StageNavigationManager.instance.currentItem.isPrefabStage) { StageNavigationManager.instance.GoToMainStage(false, StageNavigationManager.Analytics.ChangeType.GoToMainViaAvatarSetup); } m_EditMode = EditMode.Starting; // Lock inspector ChangeInspectorLock(true); // Store current setup in hierarchy sceneSetup = EditorSceneManager.GetSceneManagerSetup(); // Load temp scene Scene scene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects); scene.name = "Avatar Configuration"; // Instantiate character m_GameObject = Instantiate(prefab) as GameObject; if (serializedAssetImporter.FindProperty("m_OptimizeGameObjects").boolValue) { AnimatorUtility.DeoptimizeTransformHierarchy(m_GameObject); } SerializedProperty humanBoneArray = serializedAssetImporter.FindProperty("m_HumanDescription.m_Human"); // First get all available modelBones Dictionary <Transform, bool> modelBones = AvatarSetupTool.GetModelBones(m_GameObject.transform, true, null); AvatarSetupTool.BoneWrapper[] humanBones = AvatarSetupTool.GetHumanBones(humanBoneArray, modelBones); m_ModelBones = AvatarSetupTool.GetModelBones(m_GameObject.transform, false, humanBones); Selection.activeObject = m_GameObject; // Unfold all nodes in hierarchy // TODO@MECANIM: Only expand actual bones foreach (SceneHierarchyWindow shw in Resources.FindObjectsOfTypeAll(typeof(SceneHierarchyWindow))) { shw.SetExpandedRecursive(m_GameObject.GetInstanceID(), true); } CreateEditor(); m_EditMode = EditMode.Editing; // Frame in scene view m_SceneStates = new List <SceneStateCache>(); foreach (SceneView s in SceneView.sceneViews) { m_SceneStates.Add(new SceneStateCache { state = new SceneView.SceneViewState(s.sceneViewState), view = s }); s.sceneViewState.showFlares = false; s.sceneViewState.showMaterialUpdate = false; s.sceneViewState.showFog = false; s.sceneViewState.showSkybox = false; s.sceneViewState.showImageEffects = false; s.sceneViewState.showParticleSystems = false; s.FrameSelected(); } }
internal static InstantiationResult Instantiate(SceneTemplateAsset sceneTemplate, bool loadAdditively, string newSceneOutputPath, SceneTemplateAnalytics.SceneInstantiationType instantiationType) { if (!sceneTemplate.isValid) { throw new Exception("templateScene is empty"); } if (EditorApplication.isUpdating) { Debug.LogFormat(LogType.Warning, LogOption.None, null, "Cannot instantiate a new scene while updating the editor is disallowed."); return(null); } // If we are loading additively, we cannot add a new Untitled scene if another unsaved Untitled scene is already opened if (loadAdditively && SceneTemplateUtils.HasSceneUntitled()) { Debug.LogFormat(LogType.Warning, LogOption.None, null, "Cannot instantiate a new scene additively while an unsaved Untitled scene already exists."); return(null); } var sourceScenePath = AssetDatabase.GetAssetPath(sceneTemplate.templateScene); if (String.IsNullOrEmpty(sourceScenePath)) { throw new Exception("Cannot find path for sceneTemplate: " + sceneTemplate.ToString()); } if (!Application.isBatchMode && !loadAdditively && !EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo()) { return(null); } var instantiateEvent = new SceneTemplateAnalytics.SceneInstantiationEvent(sceneTemplate, instantiationType) { additive = loadAdditively }; sceneTemplate.UpdateDependencies(); var hasAnyCloneableDependencies = sceneTemplate.hasCloneableDependencies; SceneAsset newSceneAsset = null; Scene newScene; var templatePipeline = sceneTemplate.CreatePipeline(); if (hasAnyCloneableDependencies || loadAdditively) { if (!InstantiateInMemoryScene(sceneTemplate, sourceScenePath, ref newSceneOutputPath, out var rootFolder, out var isTempMemory)) { instantiateEvent.isCancelled = true; SceneTemplateAnalytics.SendSceneInstantiationEvent(instantiateEvent); return(null); } templatePipeline?.BeforeTemplateInstantiation(sceneTemplate, loadAdditively, isTempMemory ? null : newSceneOutputPath); newSceneTemplateInstantiating?.Invoke(sceneTemplate, isTempMemory ? null : newSceneOutputPath, loadAdditively); newSceneAsset = AssetDatabase.LoadAssetAtPath <SceneAsset>(newSceneOutputPath); var refPathMap = new Dictionary <string, string>(); var idMap = new Dictionary <int, int>(); if (hasAnyCloneableDependencies) { var refMap = CopyCloneableDependencies(sceneTemplate, newSceneOutputPath, ref refPathMap); idMap.Add(sceneTemplate.templateScene.GetInstanceID(), newSceneAsset.GetInstanceID()); ReferenceUtils.RemapAssetReferences(refPathMap, idMap); foreach (var clone in refMap.Values) { if (clone) { EditorUtility.SetDirty(clone); } } AssetDatabase.SaveAssets(); } newScene = EditorSceneManager.OpenScene(newSceneOutputPath, loadAdditively ? OpenSceneMode.Additive : OpenSceneMode.Single); if (hasAnyCloneableDependencies) { EditorSceneManager.RemapAssetReferencesInScene(newScene, refPathMap, idMap); } EditorSceneManager.SaveScene(newScene, newSceneOutputPath); if (isTempMemory) { newSceneAsset = null; newScene.SetPathAndGuid("", newScene.guid); s_CurrentInMemorySceneState.guid = newScene.guid; s_CurrentInMemorySceneState.rootFolder = rootFolder; s_CurrentInMemorySceneState.hasCloneableDependencies = hasAnyCloneableDependencies; s_CurrentInMemorySceneState.dependencyFolderName = Path.GetFileNameWithoutExtension(newSceneOutputPath); } } else { var needTempSceneCleanup = false; if (SceneTemplateUtils.IsAssetReadOnly(sourceScenePath)) { sourceScenePath = CopyToTemporaryScene(sourceScenePath); needTempSceneCleanup = true; } templatePipeline?.BeforeTemplateInstantiation(sceneTemplate, loadAdditively, newSceneOutputPath); newSceneTemplateInstantiating?.Invoke(sceneTemplate, newSceneOutputPath, loadAdditively); newScene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single); var sourceScene = EditorSceneManager.OpenScene(sourceScenePath, OpenSceneMode.Additive); SceneManager.MergeScenes(sourceScene, newScene); if (!string.IsNullOrEmpty(newSceneOutputPath)) { EditorSceneManager.SaveScene(newScene, newSceneOutputPath); } if (needTempSceneCleanup) { SceneTemplateUtils.DeleteAsset(sourceScenePath); } } SceneTemplateAnalytics.SendSceneInstantiationEvent(instantiateEvent); templatePipeline?.AfterTemplateInstantiation(sceneTemplate, newScene, loadAdditively, newSceneOutputPath); newSceneTemplateInstantiated?.Invoke(sceneTemplate, newScene, newSceneAsset, loadAdditively); SceneTemplateUtils.SetLastFolder(newSceneOutputPath); return(new InstantiationResult(newScene, newSceneAsset)); }
/// <summary> /// Generates a scene /// </summary> /// <param name="path">Where the scene is going to be stored</param> /// <param name="name">Name of the scene</param> private void CreateScene(string path, string name) { Scene currentScene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single); EditorSceneManager.SaveScene(currentScene, path + "/" + name + ".unity", true); }
public void Setup() { EditorSceneManager.NewScene(NewSceneSetup.EmptyScene); }
public override void OnInspectorGUI() { GUILayout.Label("relativeAssetPath:" + RelativeAssetPath()); if (GUILayout.Button("Create Scene")) { //SceneManager newScene = EditorSceneManager.NewScene( NewSceneSetup.EmptyScene, NewSceneMode.Additive); mainScene = EditorSceneManager.GetActiveScene(); EditorSceneManager.SetActiveScene(this.newScene); GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube); } if (GUILayout.Button("Save Scene")) { string absolutepath = Application.dataPath; string relativepath = "Assets" + absolutepath.Substring(Application.dataPath.Length); EditorSceneManager.SaveScene( newScene, relativepath + "/newScene" + sceneCount++ + ".unity"); EditorSceneManager.SetActiveScene(this.mainScene); } if (GUILayout.Button("Generate Grid")) { for (int x = 0; x < 3; x++) { for (int z = 0; z < 3; z++) { mainScene = EditorSceneManager.GetActiveScene(); newScene = EditorSceneManager.NewScene( NewSceneSetup.EmptyScene, NewSceneMode.Additive); EditorSceneManager.SetActiveScene(this.newScene); GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube); cube.transform.position = new Vector3(x, 0f, z); string absolutePath = Application.dataPath; string relativePath = "Assets" + absolutePath.Substring(Application.dataPath.Length); EditorSceneManager.SaveScene( newScene, relativePath + "/Scene_" + x + "_" + z + ".unity"); EditorSceneManager.SetActiveScene(this.mainScene); EditorSceneManager.CloseScene(this.newScene, true); } } } if (GUILayout.Button("Load Grid")) { for (int x = 0; x < 3; x++) { for (int z = 0; z < 3; z++) { string relativePath = "Assets" + Application.dataPath.Substring(Application.dataPath.Length) + "/Scene_" + x + "_" + z + ".unity"; Scene sceneToLoad = EditorSceneManager.OpenScene(relativePath, OpenSceneMode.Additive); } } } if (GUILayout.Button(("Merge Scenes to New"))) { this.MergeScenesToNew(); } if (GUILayout.Button("Generate, transfer, load Scenes")) { Stopwatch sw = new Stopwatch(); for (int x = 0; x < 3; x++) { for (int z = 0; z < 3; z++) { sw.Start(); // Aktuelle Szene als MainScene merken mainScene = EditorSceneManager.GetActiveScene(); // Neue (leere) Szene erstellen newScene = EditorSceneManager.NewScene( NewSceneSetup.EmptyScene, NewSceneMode.Additive); // Neue Szene als aktive Szene setzen EditorSceneManager.SetActiveScene(this.newScene); //########################### // Erzeuge Content: GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube); cube.transform.position = new Vector3(x, 0f, z); //########################### // Szene speichern string filename = RelativeAssetPathTo("Scene_" + x + "_" + z + ".unity"); EditorSceneManager.SaveScene(newScene, filename); // ByteArray für Message aus Szene erstellen byte[] bytes = SceneFileToByteArray(this.newScene); // Filename must be send in some form... // // | // | // Transfer via RabbitMQ-Message // | // \|/ // v Scene transferedScene = ByteArrayToScene(filename, bytes); EditorSceneManager.SetActiveScene(transferedScene); EditorSceneManager.CloseScene(this.newScene, true); sw.Stop(); Debug.Log("Szene " + x + "," + z + " took: " + sw.ElapsedMilliseconds + "ms"); } } } }
void OpenEditorScene() { EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo(); EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects); }
private static void ExportPackageImpl() { DisplayProgressBar("Preparing for export...", 0f); // Disable auto recompile. var wasAutoRefreshEnabled = EditorPrefs.GetBool(autoRefreshKey); EditorPrefs.SetBool(autoRefreshKey, false); // Load a temp scene and unload assets to prevent reference errors. sceneSetup = EditorSceneManager.GetSceneManagerSetup(); EditorSceneManager.NewScene(NewSceneSetup.EmptyScene); EditorUtility.UnloadUnusedAssetsImmediate(true); DisplayProgressBar("Pre-processing assets...", 0f); var processors = GetProcessors(); foreach (var proc in processors) { proc.OnPackagePreProcess(); } var assetPaths = AssetDatabase.GetAllAssetPaths().Where(p => p.StartsWith(AssetsPath)); var ignoredPaths = assetPaths.Where(p => IsAssetIgnored(p)); var unignoredPaths = assetPaths.Where(p => !IsAssetIgnored(p)); // Temporary hide ignored assets. DisplayProgressBar("Hiding ignored assets...", .1f); if (IsAnyPathsIgnored) { foreach (var path in ignoredPaths) { File.SetAttributes(path, File.GetAttributes(path) | FileAttributes.Hidden); } AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport); } // Add license file. var needToAddLicense = File.Exists(LicenseFilePath); if (needToAddLicense) { File.Copy(LicenseFilePath, LicenseAssetPath); AssetDatabase.ImportAsset(LicenseAssetPath, ImportAssetOptions.ForceSynchronousImport); } // Modify scripts (namespace and copyright). DisplayProgressBar("Modifying scripts...", .25f); modifiedScripts.Clear(); var needToModify = !string.IsNullOrEmpty(Copyright); if (needToModify) { foreach (var path in unignoredPaths) { if (!path.EndsWith(".cs") && !path.EndsWith(".shader") && !path.EndsWith(".cginc")) { continue; } var fullpath = Application.dataPath.Replace("Assets", string.Empty) + path; var originalScriptText = File.ReadAllText(fullpath, Encoding.UTF8); string scriptText = string.Empty; var isImportedScript = path.Contains("ThirdParty"); var copyright = isImportedScript || string.IsNullOrEmpty(Copyright) ? string.Empty : "// " + Copyright; if (!string.IsNullOrEmpty(copyright) && !isImportedScript) { scriptText += copyright + "\r\n\r\n"; } scriptText += originalScriptText; File.WriteAllText(fullpath, scriptText, Encoding.UTF8); modifiedScripts.Add(fullpath, originalScriptText); } } // Export the package. DisplayProgressBar("Writing package file...", .5f); AssetDatabase.ExportPackage(AssetsPath, OutputPath + "/" + OutputFileName + ".unitypackage", ExportPackageOptions.Recurse); // Restore modified scripts. DisplayProgressBar("Restoring modified scripts...", .75f); if (needToModify) { foreach (var modifiedScript in modifiedScripts) { File.WriteAllText(modifiedScript.Key, modifiedScript.Value, Encoding.UTF8); } } // Remove previously added license asset. if (needToAddLicense) { AssetDatabase.DeleteAsset(LicenseAssetPath); } // Un-hide ignored assets. DisplayProgressBar("Un-hiding ignored assets...", .95f); if (IsAnyPathsIgnored) { foreach (var path in ignoredPaths) { File.SetAttributes(path, File.GetAttributes(path) & ~FileAttributes.Hidden); } AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport); } DisplayProgressBar("Post-processing assets...", 1f); foreach (var proc in processors) { proc.OnPackagePostProcess(); } EditorPrefs.SetBool(autoRefreshKey, wasAutoRefreshEnabled); EditorSceneManager.RestoreSceneManagerSetup(sceneSetup); EditorUtility.ClearProgressBar(); }
/// <summary> /// Initiate the Library change process. /// </summary> /// <param name="newLib"></param> public static bool ChangeLibraries(NetworkLibrary newLib) { // Don't do anything if the adapters already are correct if (newLib == MasterNetAdapter.NetworkLibrary && newLib == NSTNetAdapter.NetLibrary) { return(true); } if (newLib == NetworkLibrary.PUN && !PUN_Exists) { Debug.LogError("Photon PUN does not appear to be installed (Cannot find the PhotonNetwork assembly). Be sure it is installed from the asset store for this project."); return(false); } if (newLib == NetworkLibrary.PUN2 && !PUN2_Exists) { Debug.LogError("Photon PUN2 does not appear to be installed (Cannot find the PhotonNetwork assembly). Be sure it is installed from the asset store for this project."); return(false); } if (!EditorUtility.DisplayDialog("Change Network Library To " + System.Enum.GetName(typeof(NetworkLibrary), newLib) + "?", "Changing libraries is a very messy brute force operation (you may see compile errors and may need to restart Unity). " + "Did you really want to do this, or are you just poking at things to see what they do?", "Change Library", "Cancel")) { return(false); } Debug.Log("Removing current adapters from game objects for Network Library change ..."); PurgeLibraryReferences(); // Close and reopen the current scene to remove the bugginess of orphaned scripts. var curscene = EditorSceneManager.GetActiveScene(); var curscenepath = curscene.path; if (EditorUtility.DisplayDialog("Save Scene Before Reload?", "Scene must be reloaded to complete the purging of old library adapters. Would you like to save this scene?", "Save Scene", "Don't Save")) { EditorSceneManager.SaveScene(curscene); } // force a scene close to eliminate weirdness EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single); if (MasterNetAdapter.NetworkLibrary != newLib) { CopyUncompiledAdapters(newLib); } EditorUtility.DisplayDialog("Touch Nothing!", "Wait for the compiling animation in the bottom right of Unity to stop before doing anything. Touching NST related assets will result in broken scripts and errors.", "I Won't Touch, Promise."); // Flag the need for a deep global find of NSTs and NSTMasters in need of adapters DebugX.LogWarning("Add dependencies pending. Clicking on any NST related object in a scene " + "will trigger the final steps of the transition to " + newLib + ". You may need to select the " + "Player Prefab in the scene or asset folder in order to make it the default player object.", true, true); NetLibrarySettings.Single.dependenciesNeedToBeCheckedEverywhere = true; AssetDatabase.Refresh(); EditorUtility.SetDirty(NetLibrarySettings.single); AssetDatabase.SaveAssets(); return(true); }
private bool ProcessScenes() { var scenePaths = AssetDatabase.FindAssets("t:Scene") .Select(n => AssetDatabase.GUIDToAssetPath(n)) .ToList(); bool hasDirtyScenes = false; for (int i = 0; i < EditorSceneManager.sceneCount; i++) { if (EditorSceneManager.GetSceneAt(i).isDirty) { hasDirtyScenes = true; break; } } if (hasDirtyScenes && !EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo()) { return(false); } var oldSceneSetup = EditorSceneManager.GetSceneManagerSetup(); try { for (int i = 0; i < scenePaths.Count; i++) { var scenePath = scenePaths[i]; if (EditorUtility.DisplayCancelableProgressBar("Scanning Scenes", "Scene " + (i + 1) + "/" + scenePaths.Count + " - " + scenePath, (float)i / scenePaths.Count)) { return(false); } EditorSceneManager.OpenScene(scenePath, OpenSceneMode.Single); var sceneGOs = UnityEngine.Object.FindObjectsOfType <GameObject>(); foreach (var go in sceneGOs) { if ((go.hideFlags & HideFlags.DontSaveInBuild) == 0) { foreach (var component in go.GetComponents <ISerializationCallbackReceiver>()) { component.OnBeforeSerialize(); var prefabSupporter = component as ISupportsPrefabSerialization; if (prefabSupporter != null) { // Also force a serialization of the object's prefab modifications, in case there are unknown types in there List <UnityEngine.Object> objs = null; var mods = UnitySerializationUtility.DeserializePrefabModifications(prefabSupporter.SerializationData.PrefabModifications, prefabSupporter.SerializationData.PrefabModificationsReferencedUnityObjects); UnitySerializationUtility.SerializePrefabModifications(mods, ref objs); } } } } } // Load a new empty scene that will be unloaded immediately, just to be sure we completely clear all changes made by the scan EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single); } finally { try { EditorUtility.DisplayProgressBar("Restoring scene setup", "", 0.5f); EditorSceneManager.RestoreSceneManagerSetup(oldSceneSetup); } finally { EditorUtility.ClearProgressBar(); } } return(true); }
internal void SwitchToAssetMode() { foreach (AvatarEditor.SceneStateCache current in this.m_SceneStates) { if (!(current.view == null)) { current.view.m_SceneViewState.showFog = current.state.showFog; current.view.m_SceneViewState.showFlares = current.state.showFlares; current.view.m_SceneViewState.showMaterialUpdate = current.state.showMaterialUpdate; current.view.m_SceneViewState.showSkybox = current.state.showSkybox; current.view.m_SceneViewState.showImageEffects = current.state.showImageEffects; } } this.m_EditMode = AvatarEditor.EditMode.Stopping; this.DestroyEditor(); this.ChangeInspectorLock(this.m_InspectorLocked); if (!EditorApplication.isUpdating && !Unsupported.IsDestroyScriptableObject(this)) { string path = SceneManager.GetActiveScene().path; if (path.Length <= 0) { if (this.sceneSetup != null && this.sceneSetup.Length > 0) { EditorSceneManager.RestoreSceneManagerSetup(this.sceneSetup); this.sceneSetup = null; } else { EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects); } } } else if (Unsupported.IsDestroyScriptableObject(this)) { EditorApplication.CallbackFunction CleanUpSceneOnDestroy = null; CleanUpSceneOnDestroy = delegate { string path2 = SceneManager.GetActiveScene().path; if (path2.Length <= 0) { if (this.sceneSetup != null && this.sceneSetup.Length > 0) { EditorSceneManager.RestoreSceneManagerSetup(this.sceneSetup); this.sceneSetup = null; } else { EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects); } } EditorApplication.update = (EditorApplication.CallbackFunction)Delegate.Remove(EditorApplication.update, CleanUpSceneOnDestroy); }; EditorApplication.update = (EditorApplication.CallbackFunction)Delegate.Combine(EditorApplication.update, CleanUpSceneOnDestroy); } this.m_GameObject = null; this.m_ModelBones = null; this.SelectAsset(); if (!this.m_CameFromImportSettings) { this.m_EditMode = AvatarEditor.EditMode.NotEditing; } }
private void CreateUIScene() { // Create UI scene Scene previouslyActiveScene = SceneManager.GetActiveScene(); newScene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Additive); EditorSceneManager.SaveScene(newScene, "Assets/" + Constants.GameName.NameOfGame + "/Scenes/UI/" + newSceneName + ".unity"); // Create UI scene camera GameObject sceneCamera = new GameObject("" + newSceneName + "Camera"); sceneCamera.AddComponent <Camera>(); Camera newCamera = sceneCamera.GetComponent <Camera>(); newCamera.clearFlags = CameraClearFlags.Depth; newCamera.cullingMask = (1 << LayerMask.NameToLayer("UI")); newCamera.orthographic = true; newCamera.orthographicSize = 20; newCamera.nearClipPlane = 0.3f; newCamera.farClipPlane = 100; newCamera.depth = 1; newCamera.useOcclusionCulling = false; newCamera.allowHDR = false; newCamera.allowMSAA = false; // Create UI scene canvas GameObject sceneCanvas = new GameObject("MainCanvas"); sceneCanvas.layer = 5; // UI layer sceneCanvas.AddComponent <Canvas>(); Canvas newCanvas = sceneCanvas.GetComponent <Canvas>(); newCanvas.renderMode = RenderMode.ScreenSpaceCamera; newCanvas.worldCamera = newCamera; newCanvas.planeDistance = 10; sceneCanvas.AddComponent <CanvasScaler>(); CanvasScaler cc = sceneCanvas.GetComponent <CanvasScaler>(); cc.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize; cc.referenceResolution = new Vector2(750, 1334); cc.screenMatchMode = CanvasScaler.ScreenMatchMode.MatchWidthOrHeight; cc.matchWidthOrHeight = 0; sceneCanvas.AddComponent <GraphicRaycaster>(); GraphicRaycaster gr = sceneCanvas.GetComponent <GraphicRaycaster>(); // Create background image GameObject canvasBGImageObject = new GameObject("BackgroundImage"); canvasBGImageObject.AddComponent <Image>(); Image image = canvasBGImageObject.GetComponent <Image>(); image.color = new Color32(255, 255, 255, 50); canvasBGImageObject.transform.parent = sceneCanvas.transform; canvasBGImageObject.AddComponent <RectTransform>(); RectTransform rt = canvasBGImageObject.GetComponent <RectTransform>(); rt.anchorMin = new Vector2(0, 0); rt.anchorMax = new Vector2(1, 1); rt.pivot = new Vector2(0.5f, 0.5f); rt.localScale = new Vector3(1, 1, 1); rt.anchoredPosition3D = new Vector3(0, 0, 0); rt.offsetMax = rt.offsetMin = rt.anchoredPosition = new Vector2(0, 0); // Create UI scene activator object GameObject sceneActivator = new GameObject("" + newSceneName + "Activator"); string copyPath = "Assets/" + Constants.GameName.NameOfGame + "/Scripts/ScenesLogic/" + sceneActivator.name + ".cs"; if (File.Exists(copyPath) == false) { // do not overwrite using (StreamWriter outfile = new StreamWriter(copyPath)) { outfile.WriteLine("using System.Collections;"); outfile.WriteLine("using System.Collections.Generic;"); outfile.WriteLine("using UnityEngine;"); outfile.WriteLine("using Peak." + Constants.GameName.NameOfGame + ".Scripts.Common;"); outfile.WriteLine("using Peak." + Constants.GameName.NameOfGame + ".Scripts.Autogenerated;"); outfile.WriteLine(""); outfile.WriteLine("namespace Peak." + Constants.GameName.NameOfGame + ".Scripts.ScenesLogic"); outfile.WriteLine("{"); outfile.WriteLine(" public class " + sceneActivator.name + " : SceneActivationBehaviour<" + sceneActivator.name + "> "); outfile.WriteLine(" {"); outfile.WriteLine(" public override void Initialize()"); outfile.WriteLine(" {"); outfile.WriteLine(" base.Initialize();"); outfile.WriteLine(" }"); outfile.WriteLine(""); outfile.WriteLine(" public override void Show(bool animated = false)"); outfile.WriteLine(" {"); outfile.WriteLine(" base.Show(animated);"); outfile.WriteLine(" }"); outfile.WriteLine(""); outfile.WriteLine(" public override void Hide()"); outfile.WriteLine(" {"); outfile.WriteLine(" base.Hide();"); outfile.WriteLine(" }"); outfile.WriteLine(""); outfile.WriteLine(" //public override void SetButtonsEnabled(bool isEnabled)"); outfile.WriteLine(" //{"); outfile.WriteLine(" //base.SetButtonsEnabled(isEnabled);"); outfile.WriteLine(" //}"); outfile.WriteLine(" }"); outfile.WriteLine("}"); } AssetDatabase.Refresh(); } SceneManager.SetActiveScene(previouslyActiveScene); }
public static void NewScene() { EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects); }
private void CreateGameScene() { // Create game scene Scene previouslyActiveScene = SceneManager.GetActiveScene(); newScene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Additive); EditorSceneManager.SaveScene(newScene, "Assets/" + Constants.GameName.NameOfGame + "/Scenes/Game/" + newSceneName + ".unity"); // Create game scene camera GameObject sceneCamera = new GameObject("" + newSceneName + "Camera"); sceneCamera.AddComponent <Camera>(); Camera newCamera = sceneCamera.GetComponent <Camera>(); newCamera.clearFlags = CameraClearFlags.Depth; newCamera.cullingMask = -1; newCamera.orthographic = true; newCamera.orthographicSize = 20; newCamera.nearClipPlane = 0.3f; newCamera.farClipPlane = 100; newCamera.depth = 1; newCamera.useOcclusionCulling = true; newCamera.allowHDR = false; newCamera.allowMSAA = true; // Create game scene light GameObject sceneLight = new GameObject("" + newSceneName + "Light"); sceneLight.AddComponent <Light>(); Light newLight = sceneLight.GetComponent <Light>(); newLight.type = LightType.Directional; newLight.shadows = LightShadows.None; // Create game scene activator object GameObject sceneActivator = new GameObject("" + newSceneName + "Activator"); string copyPath = "Assets/" + Constants.GameName.NameOfGame + "/Scripts/ScenesLogic/" + sceneActivator.name + ".cs"; if (File.Exists(copyPath) == false) { // do not overwrite using (StreamWriter outfile = new StreamWriter(copyPath)) { outfile.WriteLine("using System.Collections;"); outfile.WriteLine("using System.Collections.Generic;"); outfile.WriteLine("using UnityEngine;"); outfile.WriteLine("using Peak." + Constants.GameName.NameOfGame + ".Scripts.Common;"); outfile.WriteLine("using Peak." + Constants.GameName.NameOfGame + ".Scripts.Autogenerated;"); outfile.WriteLine(""); outfile.WriteLine("namespace Peak." + Constants.GameName.NameOfGame + ".Scripts.ScenesLogic"); outfile.WriteLine("{"); outfile.WriteLine(" public class " + sceneActivator.name + " : SceneActivationBehaviour<" + sceneActivator.name + "> "); outfile.WriteLine(" {"); outfile.WriteLine(" [SerializeField]"); outfile.WriteLine(" public Light[] sceneLights;"); outfile.WriteLine(""); outfile.WriteLine(" [SerializeField]"); outfile.WriteLine(" public GameObject featureRoot;"); outfile.WriteLine(""); outfile.WriteLine(" public override void Initialize()"); outfile.WriteLine(" {"); outfile.WriteLine(" base.Initialize();"); outfile.WriteLine(" }"); outfile.WriteLine(""); outfile.WriteLine(" public override void Show(bool animated = false)"); outfile.WriteLine(" {"); outfile.WriteLine(" base.Show(animated);"); outfile.WriteLine(" }"); outfile.WriteLine(""); outfile.WriteLine(" public override void Hide()"); outfile.WriteLine(" {"); outfile.WriteLine(" base.Hide();"); outfile.WriteLine(" }"); outfile.WriteLine(""); outfile.WriteLine(" //public override void SetButtonsEnabled(bool isEnabled)"); outfile.WriteLine(" //{"); outfile.WriteLine(" //base.SetButtonsEnabled(isEnabled);"); outfile.WriteLine(" //}"); outfile.WriteLine(" }"); outfile.WriteLine("}"); } AssetDatabase.Refresh(); } SceneManager.SetActiveScene(previouslyActiveScene); }
public void ResetScence() { EditorSceneManager.NewScene(NewSceneSetup.EmptyScene); }
public void SetUpOnce() { var scene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene); SceneManager.SetActiveScene(scene); }
public bool ScanScenes(string[] scenePaths, bool includeSceneDependencies, bool showProgressBar) { if (scenePaths.Length == 0) { return(true); } bool formerForceEditorModeSerialization = UnitySerializationUtility.ForceEditorModeSerialization; try { UnitySerializationUtility.ForceEditorModeSerialization = true; bool hasDirtyScenes = false; for (int i = 0; i < EditorSceneManager.sceneCount; i++) { if (EditorSceneManager.GetSceneAt(i).isDirty) { hasDirtyScenes = true; break; } } if (hasDirtyScenes && !EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo()) { return(false); } var oldSceneSetup = EditorSceneManager.GetSceneManagerSetup(); try { for (int i = 0; i < scenePaths.Length; i++) { var scenePath = scenePaths[i]; if (showProgressBar && DisplaySmartUpdatingCancellableProgressBar("Scanning scenes for AOT support", "Scene " + (i + 1) + "/" + scenePaths.Length + " - " + scenePath, (float)i / scenePaths.Length)) { return(false); } var openScene = EditorSceneManager.OpenScene(scenePath, OpenSceneMode.Single); var sceneGOs = Resources.FindObjectsOfTypeAll <GameObject>(); foreach (var go in sceneGOs) { if (go.scene != openScene) { continue; } if ((go.hideFlags & HideFlags.DontSaveInBuild) == 0) { foreach (var component in go.GetComponents <ISerializationCallbackReceiver>()) { try { this.allowRegisteringScannedTypes = true; component.OnBeforeSerialize(); var prefabSupporter = component as ISupportsPrefabSerialization; if (prefabSupporter != null) { // Also force a serialization of the object's prefab modifications, in case there are unknown types in there List <UnityEngine.Object> objs = null; var mods = UnitySerializationUtility.DeserializePrefabModifications(prefabSupporter.SerializationData.PrefabModifications, prefabSupporter.SerializationData.PrefabModificationsReferencedUnityObjects); UnitySerializationUtility.SerializePrefabModifications(mods, ref objs); } } finally { this.allowRegisteringScannedTypes = false; } } } } } // Load a new empty scene that will be unloaded immediately, just to be sure we completely clear all changes made by the scan // Sometimes this fails for unknown reasons. In that case, swallow any exceptions, and just soldier on and hope for the best! // Additionally, also eat any debug logs that happen here, because logged errors can stop the build process, and we don't want // that to happen. UnityEngine.ILogger logger = null; if (Debug_Logger_Property != null) { logger = (UnityEngine.ILogger)Debug_Logger_Property.GetValue(null, null); } bool previous = true; try { if (logger != null) { previous = logger.logEnabled; logger.logEnabled = false; } EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single); } catch { } finally { if (logger != null) { logger.logEnabled = previous; } } } finally { if (oldSceneSetup != null && oldSceneSetup.Length > 0) { if (showProgressBar) { EditorUtility.DisplayProgressBar("Restoring scene setup", "", 1.0f); } EditorSceneManager.RestoreSceneManagerSetup(oldSceneSetup); } } if (includeSceneDependencies) { for (int i = 0; i < scenePaths.Length; i++) { var scenePath = scenePaths[i]; if (showProgressBar && DisplaySmartUpdatingCancellableProgressBar("Scanning scene dependencies for AOT support", "Scene " + (i + 1) + "/" + scenePaths.Length + " - " + scenePath, (float)i / scenePaths.Length)) { return(false); } string[] dependencies = AssetDatabase.GetDependencies(scenePath, recursive: true); foreach (var dependency in dependencies) { this.ScanAsset(dependency, includeAssetDependencies: false); // All dependencies of this asset were already included recursively by Unity } } } return(true); } finally { if (showProgressBar) { EditorUtility.ClearProgressBar(); } UnitySerializationUtility.ForceEditorModeSerialization = formerForceEditorModeSerialization; } }
public void TearDownOnce() { EditorSceneManager.NewScene(NewSceneSetup.EmptyScene); }
private static void CleanupScene() { EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single); }
public void ClassInit() { var scene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene); SceneManager.SetActiveScene(scene); }