static void OnPlayModeChanged(PlayModeStateChange state) { // Reset State when entering editmode or play mode if (state == PlayModeStateChange.EnteredEditMode || state == PlayModeStateChange.EnteredPlayMode) { if (Active) { Active = true; } else { Active = false; } } else // Cleanup before switching state { if (s_GameObject != null) { Object.DestroyImmediate(s_GameObject); } } }
private static void OnPlayModeChanged(PlayModeStateChange playMode) { if (playMode == PlayModeStateChange.EnteredPlayMode) { var data = GameObject.FindObjectOfType <PlayFromSceneData>(); if (data == null) { return; } EditorSceneManager.LoadSceneInPlayMode(data.scenePath, new LoadSceneParameters(LoadSceneMode.Single)); } if (playMode == PlayModeStateChange.EnteredEditMode) { var data = GameObject.FindObjectOfType <PlayFromSceneData>(); if (data == null) { return; } GameObject.DestroyImmediate(data.gameObject); } }
void LogPlayModeState(PlayModeStateChange state) { if (state == PlayModeStateChange.EnteredPlayMode) { SyncAPSubsystemSettingsToEditor(); SyncScalerSettingsToEditor(); SyncDeviceSettingsToSimulator(); // Set bottleneck so we get CPU/GPU frametimes and a valid bottleneck SetBottleneck((PerformanceBottleneck)m_Bottleneck.value, Subsystem()); if (AdaptivePerformanceGeneralSettings.Instance?.Manager.activeLoader.GetSettings().enableBoostOnStartup == true) { Debug.Log("[Adaptive Performance Simulator] Enabled boost mode on launch"); } EditorApplication.update += Update; } else { EditorApplication.update -= Update; } }
static void OnPlayStateChanged(PlayModeStateChange state) { if (Application.isPlaying) { ConstellationUnityWindow.ShowWindow(); WindowInstance.Recover(); WindowInstance.CompileScripts(); } WindowInstance.Recover(); WindowInstance.previousSelectedGameObject = null; WindowInstance.ResetInstances(); if (WindowInstance.scriptDataService.GetEditorData().ExampleData.openExampleConstellation&& state == PlayModeStateChange.EnteredPlayMode) { var nodeExampleLoader = new ExampleSceneLoader(); nodeExampleLoader.RunExample(WindowInstance.scriptDataService.GetEditorData().ExampleData.constellationName, WindowInstance.scriptDataService); WindowInstance.scriptDataService.GetEditorData().ExampleData.openExampleConstellation = false; } EditorApplication.playModeStateChanged -= OnPlayStateChanged; WindowInstance.Repaint(); }
private void OnPlayModeStateChanged(PlayModeStateChange playModeStateChange) { switch (playModeStateChange) { case PlayModeStateChange.EnteredEditMode: Reload(); break; case PlayModeStateChange.ExitingEditMode: break; case PlayModeStateChange.EnteredPlayMode: Reload(); break; case PlayModeStateChange.ExitingPlayMode: break; default: throw new ArgumentOutOfRangeException(nameof(playModeStateChange), playModeStateChange, null); } }
private static void OnChangedPlayMode(PlayModeStateChange state) { if (state == PlayModeStateChange.ExitingEditMode) { for (int i = 0; i < 3; i += 1) { // File.Copy(TARGET_DIRECTORY_PATH[i], DESTINATION_DIRECTORY_PATH[i], overwrite: true); } } else if (state == PlayModeStateChange.EnteredPlayMode) { } else if (state == PlayModeStateChange.ExitingPlayMode) { } else if (state == PlayModeStateChange.EnteredEditMode) { } else { } }
static void OnPlayModeStateChanged(PlayModeStateChange state) { if (state == PlayModeStateChange.ExitingEditMode) { try { ValidateMultiSceneSetupAndLoadDefaultSceneParents(); } catch (Exception e) { EditorApplication.isPlaying = false; throw new UniDiException( "Failure occurred when attempting to load default scene parent contracts!", e); } } else if (state == PlayModeStateChange.EnteredEditMode) { // It would be cool to restore the initial scene set up here but in order to do this // we would have to make sure that the user saves the scene before running which // would be too annoying, so just leave any changes we've made alone } }
static void OnPlayModeChanged(PlayModeStateChange status) { switch (status) { case PlayModeStateChange.EnteredEditMode: break; case PlayModeStateChange.ExitingEditMode: break; case PlayModeStateChange.EnteredPlayMode: if (!GameConfig.useAsb) { SceneSettingManager.SetAllSceneToBuildSetting(); } break; case PlayModeStateChange.ExitingPlayMode: //SceneManager.setReleaseSceneToBuildSetting(); break; } }
private static void LogPlayModeState(PlayModeStateChange state) { bool hasInit = false; if (PlayModeStateChange.EnteredPlayMode == state) { int sceneCount = SceneManager.sceneCount; for (int i = 0; i < sceneCount; i++) { if (SceneManager.GetSceneAt(i).buildIndex == 0) { hasInit = true; } } if (!hasInit) { SceneManager.LoadScene(0); } } }
/// <summary> /// Used to serialize playmode properties in order to restore properties AFTER coming back from play mode. /// </summary> static void OnPlayModeStateChanged(PlayModeStateChange state) { switch (state) { case PlayModeStateChange.EnteredPlayMode: SerializeObjects(); //Debug.Log(serializedObjectDict.Count + " objects in dictionary during EnteredPlayMode event"); break; case PlayModeStateChange.ExitingPlayMode: //Debug.Log(serializedObjectDict.Count + " objects in dictionary during ExitingPlayMode event"); SerializeProperties(); break; case PlayModeStateChange.EnteredEditMode: //Debug.Log(serializedObjectDict.Count + " objects in dictionary during EnteredEditMode event"); ApplyModifiedProperties(); break; } }
static void OnEditorChangePlayMode(PlayModeStateChange change) { _playMode = change; if (_isPlaying) { // Go through registered SmartRefs and bind if necessary var refs = SmartData.Editors.SmartDataRegistry.GetSmartReferences(); if (refs.Count > 0) { FieldInfo autoListen = typeof(SmartData.Abstract.SmartRefBase).GetField("_autoListen", BindingFlags.NonPublic | BindingFlags.Instance); FieldInfo owner = typeof(SmartData.Abstract.SmartRefBase).GetField("_owner", BindingFlags.NonPublic | BindingFlags.Instance); FieldInfo ownerName = typeof(SmartData.Abstract.SmartRefBase).GetField("_ownerName", BindingFlags.NonPublic | BindingFlags.Instance); foreach (var a in refs) { if (a.Key.IsAlive) { var sr = (SmartData.Abstract.SmartRefBase)a.Key.Target; if ((bool)autoListen.GetValue(sr)) { GameObject ownerGo = (GameObject)owner.GetValue(sr); if (!ownerGo) { Debug.LogErrorFormat( "Error initialising SmartRefUnbinder on GameObject {0} (SmartRef type {1})", ownerName.GetValue(sr), sr.GetType().Name ); } else { SmartData.Components.SmartRefUnbinder.UnbindUnityEventOnDestroy(sr, ownerGo, true); } } } } } EditorApplication.playModeStateChanged -= OnEditorChangePlayMode; } }
// Play mode change callback handles the scene load/reload. private static void OnPlayModeChanged(PlayModeStateChange state) { if (!LoadMasterOnPlay) { return; } if (!EditorApplication.isPlaying && EditorApplication.isPlayingOrWillChangePlaymode) { // User pressed play -- autoload master scene. PreviousScene = EditorSceneManager.GetActiveScene().path; if (EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo()) { try { EditorSceneManager.OpenScene(MasterScene); } catch { Debug.LogError(string.Format("error: scene not found: {0}", MasterScene)); EditorApplication.isPlaying = false; } } else { // User cancelled the save operation -- cancel play as well. EditorApplication.isPlaying = false; } } // isPlaying check required because cannot OpenScene while playing if (!EditorApplication.isPlaying && !EditorApplication.isPlayingOrWillChangePlaymode) { // User pressed stop -- reload previous scene. try { EditorSceneManager.OpenScene(PreviousScene); } catch { Debug.LogError(string.Format("error: scene not found: {0}", PreviousScene)); } } }
private static void ToggleScenes(PlayModeStateChange state) { if (EditorPrefs.GetBool(DefaultScenePrefs.isActive)) { string defaultScene = SceneUtility.GetScenePathByBuildIndex(EditorPrefs.GetInt(DefaultScenePrefs.defaultSceneIndex)); string currentScenePath = SceneManager.GetActiveScene().path; if (state == PlayModeStateChange.ExitingEditMode) { EditorPrefs.SetString(DefaultScenePrefs.returnPath, currentScenePath); if (currentScenePath != defaultScene) { if (EditorPrefs.GetBool(DefaultScenePrefs.autoSave)) { EditorSceneManager.SaveOpenScenes(); } else { EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo(); } EditorSceneManager.OpenScene(defaultScene); } } if (state == PlayModeStateChange.EnteredEditMode) { string returnPath = EditorPrefs.GetString(DefaultScenePrefs.returnPath); if (currentScenePath != returnPath) { EditorSceneManager.OpenScene(returnPath); } } } }
private static void OnPlayModeStateChanged(PlayModeStateChange state) { if (state != PlayModeStateChange.EnteredPlayMode) { return; } if (!EditorPrefs.HasKey(SsmUtility.PlayModeSceneToResetKey)) { return; } string playModeSceneToReset = EditorPrefs.GetString(SsmUtility.PlayModeSceneToResetKey); if (playModeSceneToReset == "null") { EditorSceneManager.playModeStartScene = null; } else { foreach (EditorBuildSettingsScene settingsScene in EditorBuildSettings.scenes) { if (playModeSceneToReset != SsmUtility.SceneFileName(settingsScene)) { continue; } var sceneAsset = AssetDatabase.LoadAssetAtPath <SceneAsset>(settingsScene.path); EditorSceneManager.playModeStartScene = sceneAsset; break; } } EditorPrefs.DeleteKey(SsmUtility.PlayModeSceneToResetKey); if (IsOpen) { instance.Repaint(); } }
/// <summary> /// Playmode state change listener. /// Firing entering playmode event. /// </summary> #if UNITY_2017_2_OR_NEWER protected static void PlaymodeStateChanged(PlayModeStateChange state) { if (GameObject.FindWithTag("Volplane") == null) { return; } if (state == PlayModeStateChange.EnteredPlayMode) { Extensions.processedEnteringPlaymode = true; Extensions.StartBrowserPlaySession(); // Fire entering playmode event if (Extensions.EnteringPlaymode != null) { Extensions.EnteringPlaymode(); } } else { Extensions.processedEnteringPlaymode = false; } }
public void onPlayModeChanged(PlayModeStateChange state) { if (state == PlayModeStateChange.EnteredPlayMode) { wasPlaying = true; } if (EditorApplication.isCompiling) { return; } if (state == PlayModeStateChange.EnteredEditMode) { if (wasPlaying) { loader = null; try { triggerRebuild(); wasPlaying = false; } catch { } } } }
protected override void OnPlayModeStateChange(PlayModeStateChange stateChange) { switch (stateChange) { // Update the tree view only when entering case PlayModeStateChange.EnteredPlayMode: case PlayModeStateChange.EnteredEditMode: updateTreeView = true; if (this.target) { this.OnTargetSelected(); } break; // Don't bother trying to update while exiting case PlayModeStateChange.ExitingEditMode: case PlayModeStateChange.ExitingPlayMode: updateTreeView = false; break; } //Trace.Script($"Change = {stateChange}, UpdateTreeView = {updateTreeView}"); }
private static void PlaymodeStateChanged(PlayModeStateChange playModeStateChange) { if (EditorApplication.isPlaying) { if (!DebugConsoleEditorSettings.AutomaticallyLoadConsoleInEditor) { return; } if (Object.FindObjectOfType <DebugConsole>() == null) { var debugConsolePath = Path.Combine(DebugConsoleEditorSettings.OpencodingDirectoryLocation, "Console/Prefabs/DebugConsole.prefab"); var prefab = AssetDatabase.LoadMainAssetAtPath(debugConsolePath); if (prefab == null) { Debug.LogWarning("Couldn't load DebugConsole as the DebugConsole prefab couldn't be found at " + debugConsolePath + ". If you have moved the OpenCoding folder, please update the location in DebugConsoleEditorSettings."); return; } var go = Object.Instantiate(prefab); go.name = "DebugConsole (Automatically Instantiated)"; } } }
private void onPlayModeStateChanged(PlayModeStateChange playState) { if (playState == PlayModeStateChange.EnteredPlayMode) { this.RefreshVideoClips(); var player = GameObject.FindObjectOfType <ATVideoClipPlayer>(); player.OnChangeClip = null; player.OnChangeClip += this.OnRuntimeChangeClip; this.OnRuntimeChangeClip(player.mProject.clips[player.currentVideoClipIndex]); player.OnUpdate = null; player.OnUpdate += this.OnRuntimeUpdate; } else { var prevClip = rootVisualElement.Q <VisualElement>(null, "ActiveClip"); if (prevClip != null) { prevClip.RemoveFromClassList("ActiveClip"); } } }
static void RestoreScenes(PlayModeStateChange state) { if (state != PlayModeStateChange.EnteredEditMode) { return; } if (string.IsNullOrEmpty(PlayerPrefs.GetString(DataKey))) { return; } var joinedPaths = PlayerPrefs.GetString(DataKey); var scenePaths = joinedPaths.Split(';'); for (var i = 0; i < scenePaths.Length; i++) { var pathData = scenePaths[i].Split('#'); var path = pathData[0]; var openSceneMode = pathData.Length > 1 ? OpenSceneMode.AdditiveWithoutLoading : OpenSceneMode.Additive; EditorSceneManager.OpenScene(path, i == 0 ? OpenSceneMode.Single : openSceneMode); } }
private static void HandlePlayModeStateChanged(PlayModeStateChange playModeStateChange) { if (EditorPrefs.GetBool(AUTO_LOAD_KEY, false)) { if (playModeStateChange == PlayModeStateChange.EnteredEditMode) { string cachedScene = EditorPrefs.GetString(CACHED_SCENE_KEY); if (!string.IsNullOrEmpty(cachedScene)) { EditorSceneManager.OpenScene(cachedScene); } } else if (playModeStateChange == PlayModeStateChange.ExitingEditMode) { EditorPrefs.SetString(CACHED_SCENE_KEY, EditorApplication.currentScene); string loadingScenePath = EditorPrefs.GetString(LOADING_SCENE_KEY); if (!string.IsNullOrEmpty(loadingScenePath)) { EditorSceneManager.OpenScene(loadingScenePath); } } } }
private static void ModeChanged(PlayModeStateChange playModeState) { if (playModeState == PlayModeStateChange.EnteredEditMode) { var loadingHandler = GameObject.Find("LoadingHandler")?.GetComponent <LoadingHandler>(); if (loadingHandler != null) { loadingHandler.loadMenu = true; } var initializers = Resources.FindObjectsOfTypeAll <Initializer>(); foreach (var initializer in initializers) { initializer.gameObject.SetActive(true); } var destroyOnEditModes = GameObject.FindGameObjectsWithTag("DestroyOnEditMode"); foreach (var destroyOnEditMode in destroyOnEditModes) { Object.DestroyImmediate(destroyOnEditMode); } } }
public static void OnEditorPlayeModeChanged(PlayModeStateChange state) { //HFLog.C(Application.dataPath + "../../HotFix/HotFix.csproj"); //CompilerHotFixDLL(); switch (state) { case PlayModeStateChange.EnteredEditMode: break; case PlayModeStateChange.ExitingEditMode: //CompilerHotFixDLL(); break; case PlayModeStateChange.EnteredPlayMode: break; case PlayModeStateChange.ExitingPlayMode: break; default: break; } }
private void OnPlayModeStateChanged(PlayModeStateChange state) { switch (state) { case PlayModeStateChange.EnteredEditMode: if (goBefPlay) { ChangeTreeBySelection(goBefPlay.GetComponent <BehaviourExecutor>()); } else { ChangeTreeBySelection(); } UpdateUndoVisible(); break; case PlayModeStateChange.EnteredPlayMode: goBefPlay = latestGo; ChangeTreeBySelection(); UpdateUndoVisible(); break; } }
/************************************************************************ * Coroutine Declaration * ************************************************************************/ /************************************************************************ * Private Method Declaration * ************************************************************************/ /************************************************************************ * Protected Method Declaration * ************************************************************************/ /************************************************************************ * Event Method Declaration * ************************************************************************/ private void ChangedPlayMode(PlayModeStateChange state) { if (this._playMode != state) { bool send = false; switch (state) { case PlayModeStateChange.EnteredEditMode: case PlayModeStateChange.EnteredPlayMode: send = true; break; default: break; } this._playMode = state; if (send) { XTween.PlayModeChanged(this._playMode.Equals(PlayModeStateChange.EnteredEditMode)); } } }
private static void HandlePrefabsOnPlayMode(PlayModeStateChange state) { if (!StripSettings.StripFoldersFromPrefabsInPlayMode || StripSettings.PlayMode == StrippingMode.DoNothing) { return; } // Calling it not in EnteredPlayMode because scripts may instantiate prefabs in Awake or OnEnable // which happens before EnteredPlayMode. if (state == PlayModeStateChange.ExitingEditMode) { // Stripping folders from all prefabs in the project instead of only the ones referenced in the scenes // because a prefab may be hot-swapped in Play Mode. using (AssetImportGrouper.Init()) { StripFoldersFromAllPrefabs(); } } else if (state == PlayModeStateChange.ExitingPlayMode) { RevertChanges(); } }
private static void PlayModeStateChanged(PlayModeStateChange state) { if (EditorApplication.isPlaying == false && EditorApplication.isPlayingOrWillChangePlaymode) { WriteRuntimeConfigFile(); var activeConfig = EditorAppConfig.ActiveAppConfig; foreach (var settings in EditorAppConfig.GetActiveConfigSettings()) { settings.OnEnteringPlayMode(activeConfig); } } else if (state == PlayModeStateChange.ExitingPlayMode) { var activeConfig = EditorAppConfig.ActiveAppConfig; foreach (var settings in EditorAppConfig.GetActiveConfigSettings()) { settings.OnExitingPlayMode(activeConfig); } } }
private static void OnPlayModeChange(PlayModeStateChange obj) { var autoXR = FindObjectOfType <AutoXRSupport>(); if (!autoXR) { return; } if (obj == PlayModeStateChange.ExitingEditMode) { if (autoXR.OnPlay == XRSupport.Enable) { Debug.Log("Enable ´Virtual Reality Support", autoXR); PlayerSettings.virtualRealitySupported = true; } else if (autoXR.OnPlay == XRSupport.Disable) { Debug.Log("Disable Virtual Reality Support", autoXR); PlayerSettings.virtualRealitySupported = false; } } }
static void OnPlayModeToggle(PlayModeStateChange state) { if (state == PlayModeStateChange.ExitingEditMode) { SavePrefs(); if (saveOnPlay) { SaveAllOpenScenes(); Debug.Log("Saved on play at: " + System.DateTime.Now); } } if (state == PlayModeStateChange.ExitingPlayMode) { LoadPrefs(); if (saveRoutine != null) { EditorCoroutineUtility.StopCoroutine(saveRoutine); } saveRoutine = EditorCoroutineUtility.StartCoroutineOwnerless(SaveOpenScenesCoroutine()); } }
private static void PlayModeStateChanged(PlayModeStateChange playModeState) { if (!EditorApplication.isPlaying && EditorApplication.isPlayingOrWillChangePlaymode) { if (EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo()) { SceneAsset tartgetScene = LaunchSetting.instance.lunchScene; if (tartgetScene != null && !EditorSceneManager.GetActiveScene().name.Equals(tartgetScene.name)) { originScenePath = EditorSceneManager.GetActiveScene().path; EditorSceneManager.OpenScene(AssetDatabase.GetAssetPath(tartgetScene)); } } } if (!EditorApplication.isPlaying && !EditorApplication.isPlayingOrWillChangePlaymode) { if (!string.IsNullOrEmpty(originScenePath)) { EditorSceneManager.OpenScene(originScenePath); } } }