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);
}
}
}
