private static BuildPlayerOptions GetBuildOptions(Scene scene) { BuildPlayerOptions options = new BuildPlayerOptions(); options.scenes = new string[] { scene.path }; options.options |= BuildOptions.AutoRunPlayer | BuildOptions.Development; options.target = EditorUserBuildSettings.activeBuildTarget; string str = Path.Combine(Path.Combine(FileUtil.GetUniqueTempPathInProject(), "TestRun"), "test." + PostprocessBuildPlayer.GetExtensionForBuildTarget(options.target, options.options)); options.locationPathName = str; return options; }
private void BuildAndRunPlayer(Scene scene) { string str = BuildPipeline.BuildPlayer(GetBuildOptions(scene)); if (!string.IsNullOrEmpty(str)) { Debug.LogError(str); } }
void Start() { if (sceneToLoad < 0) return; this.fadeOverlay.gameObject.SetActive(true); // Making sure it's on so that we can crossfade Alpha this.currentScene = SceneManager.GetActiveScene(); this.StartCoroutine(this.LoadAsync(sceneToLoad)); }
public static Scene[] GetAllScenes() { Scene[] sceneArray = new Scene[sceneCount]; for (int i = 0; i < sceneCount; i++) { sceneArray[i] = GetSceneAt(i); } return sceneArray; }
int GetSceneIndex(Scene scene) { for (int i = 0; i < SceneManager.sceneCount; i++) { if (SceneManager.GetSceneAt(i) == scene) { return i; } } throw Assert.CreateException(); }
static public int constructor(IntPtr l) { try { UnityEngine.SceneManagement.Scene o; o=new UnityEngine.SceneManagement.Scene(); pushValue(l,true); pushValue(l,o); return 2; } catch(Exception e) { return error(l,e); } }
/// <summary> /// Return the Singleton for a given scene (there is one per Scene). /// </summary> /// <param name="scene">The Scene to obtain the singleton for</param> /// <returns>The per-scene singleton</returns> public static AmsCrossSceneReferences GetSceneSingleton( Scene scene, bool bCreateIfNotFound ) { var multiSceneSetup = GameObjectEx.GetSceneSingleton<AmsMultiSceneSetup>( scene, bCreateIfNotFound ); if ( !multiSceneSetup ) return null; var existing = multiSceneSetup.gameObject.GetComponent<AmsCrossSceneReferences>(); if ( existing ) return existing; else if ( bCreateIfNotFound ) return multiSceneSetup.gameObject.AddComponent<AmsCrossSceneReferences>(); return null; }
private static void OnHierarchyChange () { #if UNITY_5_3 Scene currentSceneName = EditorSceneManager.GetActiveScene (); #else string currentSceneName = Application.loadedLevelName; #endif if (loadedScene != currentSceneName) { if (justOpenedNewScene != null) justOpenedNewScene.Invoke (); loadedScene = currentSceneName; } }
private void HideNoUndo(Scene scene) { if (!scene.IsValid()) { return; } if (!scene.isLoaded) { return; } SceneVisibilityState.ShowScene(scene); scene.GetRootGameObjects(m_RootBuffer); SceneVisibilityState.SetGameObjectsHidden(m_RootBuffer.ToArray(), true, true); }
public static int GetSceneByBuildIndex_wrap(long L) { try { long VM = FCLibHelper.fc_get_vm_ptr(L); int arg0 = FCLibHelper.fc_get_int(L, 0); UnityEngine.SceneManagement.Scene ret = UnityEngine.SceneManagement.SceneManager.GetSceneByBuildIndex(arg0); long ret_ptr = FCLibHelper.fc_get_return_ptr(L); long v = FCGetObj.PushObj(ret); FCLibHelper.fc_set_value_wrap_objptr(VM, ret_ptr, v); } catch (Exception e) { Debug.LogException(e); } return(0); }
private static void EditorSceneManagerOnSceneOpened(Scene scene, OpenSceneMode mode) { if (mode == OpenSceneMode.Single) { SceneVisibilityState.isolation = false; } if (mode == OpenSceneMode.Additive) { //make sure added scenes are isolated when opened if main stage is isolated if (!StageNavigationManager.instance.currentItem.isPrefabStage) { Undo.ClearUndo(SceneVisibilityState.GetInstance()); } } instance.VisibilityChanged(); instance.PickableContentChanged(); }
public void OnProcessScene(UnityEngine.SceneManagement.Scene scene) { if (!sawManager) { if (scene.isLoaded) { foreach (var gameObject in scene.GetRootGameObjects()) { if (gameObject.GetComponentInChildren <PolyToolkitManager>() != null) { sawManager = true; break; } } } } }
public void OnGUI() { UnityEngine.SceneManagement.Scene sc = SceneManager.GetSceneByName("ExampleMenu"); if (sc.IsValid()) { GUI.BeginGroup(new Rect(Screen.width - 150, Screen.height - 40, 300, 400)); GUILayout.BeginVertical("box", GUILayout.Width(150)); if (GUILayout.Button("Back")) { SceneManager.LoadScene(0); } GUILayout.EndVertical(); GUI.EndGroup(); } }
public static int UnloadSceneAsync2_wrap(long L) { try { long VM = FCLibHelper.fc_get_vm_ptr(L); UnityEngine.SceneManagement.Scene arg0 = FCGetObj.GetObj <UnityEngine.SceneManagement.Scene>(FCLibHelper.fc_get_wrap_objptr(L, 0)); UnityEngine.AsyncOperation ret = UnityEngine.SceneManagement.SceneManager.UnloadSceneAsync(arg0); long ret_ptr = FCLibHelper.fc_get_return_ptr(L); long v = FCGetObj.PushObj(ret); FCLibHelper.fc_set_value_wrap_objptr(VM, ret_ptr, v); } catch (Exception e) { Debug.LogException(e); } return(0); }
public static int CreateScene_wrap(long L) { try { long VM = FCLibHelper.fc_get_vm_ptr(L); string arg0 = FCLibHelper.fc_get_string_a(L, 0); UnityEngine.SceneManagement.Scene ret = UnityEngine.SceneManagement.SceneManager.CreateScene(arg0); long ret_ptr = FCLibHelper.fc_get_return_ptr(L); long v = FCGetObj.PushObj(ret); FCLibHelper.fc_set_value_wrap_objptr(VM, ret_ptr, v); } catch (Exception e) { Debug.LogException(e); } return(0); }
public static int Equals_wrap(long L) { try { long nThisPtr = FCLibHelper.fc_get_inport_obj_ptr(L); UnityEngine.SceneManagement.Scene obj = get_obj(nThisPtr); System.Object arg0 = FCGetObj.GetSystemObj(FCLibHelper.fc_get_param_ptr(L, 0)); bool ret = obj.Equals(arg0); long ret_ptr = FCLibHelper.fc_get_return_ptr(L); FCLibHelper.fc_set_value_bool(ret_ptr, ret); } catch (Exception e) { Debug.LogException(e); } return(0); }
void OnSceneLoaded(UnityEngine.SceneManagement.Scene scene, UnityEngine.SceneManagement.LoadSceneMode mode) { if (SceneManager.GetActiveScene().buildIndex == 0) { /*if (mobile == null) { * mobile = GameObject.FindGameObjectWithTag ("MobileController"); * } * mobile.SetActive (false);*/ //Destroy (gameObject); GameObject[] allObjects = GameObject.FindGameObjectsWithTag("SceneChanger"); foreach (GameObject obj in allObjects) { Destroy(obj); } } }
public Scene() { components.Add(new Octree()); components.Add(new DebugRenderer()); components.Add(new Zone()); components.Add(new Skybox()); List <GameObject> rootObjects = new List <GameObject>(); UnityEngine.SceneManagement.Scene scene = SceneManager.GetActiveScene(); scene.GetRootGameObjects(rootObjects); foreach (GameObject node in rootObjects) { nodes.Add(new Node(node)); } }
/** * Call this when the player crosses the bounds into another scene so adjacent scenes are loaded. */ public static void SceneTransitionMade(int x, int y) { string name = SceneMap.GetPartition(x, y); if (activeScene.Equals(name) || name == null) { return; } activeSceneX = x; activeSceneY = y; activeScene = name; UnityEngine.SceneManagement.Scene scene = SceneManager.GetSceneByName(name); UnloadScenes(); LoadAdjacentScenes(); SceneManager.SetActiveScene(SceneManager.GetSceneByName(name)); //printSceneInfo(); }
public static int GetHashCode_wrap(long L) { try { long VM = FCLibHelper.fc_get_vm_ptr(L); long nThisPtr = FCLibHelper.fc_get_inport_obj_ptr(L); UnityEngine.SceneManagement.Scene obj = get_obj(nThisPtr); int ret = obj.GetHashCode(); long ret_ptr = FCLibHelper.fc_get_return_ptr(L); FCLibHelper.fc_set_value_int(ret_ptr, ret); } catch (Exception e) { Debug.LogException(e); } return(0); }
bool GetSceneSetState(string sceneName, bool activity) { UnityEngine.SceneManagement.Scene scene = UnityEngine.SceneManagement.SceneManager.GetSceneByName(sceneName); if (scene != null && scene.IsValid() && scene.isLoaded) { GameObject[] objs = scene.GetRootGameObjects(); if (objs != null) { foreach (var obj in objs) { obj.SetActive(activity); } } return(true); } return(false); }
public static int GetRootGameObjects_wrap(long L) { try { long VM = FCLibHelper.fc_get_vm_ptr(L); long nThisPtr = FCLibHelper.fc_get_inport_obj_ptr(L); UnityEngine.SceneManagement.Scene obj = get_obj(nThisPtr); UnityEngine.GameObject[] ret = obj.GetRootGameObjects(); long ret_ptr = FCLibHelper.fc_get_return_ptr(L); FCCustomParam.ReturnArray(VM, ret, ret_ptr); } catch (Exception e) { Debug.LogException(e); } return(0); }
public static int GetRootGameObjects1_wrap(long L) { try { long VM = FCLibHelper.fc_get_vm_ptr(L); long nThisPtr = FCLibHelper.fc_get_inport_obj_ptr(L); UnityEngine.SceneManagement.Scene obj = get_obj(nThisPtr); List <UnityEngine.GameObject> arg0 = null; arg0 = FCCustomParam.GetList(ref arg0, L, 0); obj.GetRootGameObjects(arg0); } catch (Exception e) { Debug.LogException(e); } return(0); }
/// <summary> /// Sets the active scene. When using Load or LoadAsync, newly loaded scene will automatically be set to active if scene was not loaded additive. /// </summary> /// <param name="sceneName">Scene name.</param> public void SetActiveScene(string sceneID) { UnityEngine.SceneManagement.Scene scene = SceneManager.GetSceneByName(sceneID); if (scene.isLoaded == true) { //Activate scene ActivateScene(sceneID); //Set as active scene SceneManager.SetActiveScene(scene); //Fire signal trigger //_sceneSetAsActiveSignalTrigger.Fire(sceneName); _eventService.Publish(new Events.SceneSetAsActiveEvent { sceneID = sceneID }); Debug.Log("Setting " + scene.name + " as active scene"); } }
static void SaveAll() { UnityEngine.SceneManagement.Scene sc = UnityEngine.SceneManagement.SceneManager.GetActiveScene(); if (!sc.IsValid()) { return; } SceneConfig data = new SceneConfig(); data.Data.LevelName = sc.name; GameObject[] array = GameObject.FindGameObjectsWithTag(SERIALIZE_SCENE_OBJECT_TAG); if (array == null) { return; } for (int i = 0; i < array.Length; ++i) { UnityEngine.Object parentObject = PrefabUtility.GetPrefabParent(array[i]); string path = AssetDatabase.GetAssetPath(parentObject); if (string.IsNullOrEmpty(path)) { continue; } var transform = array[i].transform; var parent = transform.parent; //写入数据 var obj = new SceneConfigData.SceneObject(); obj.AssetName = path; obj.Position = transform.position; obj.Scale = transform.lossyScale; obj.Rotation = transform.rotation; obj.ParentName = parent != null? Common.CalcTransformHierarchyPath(parent) : ""; data.Data.SceneObjects.Add(obj); } data.Save(SceneConfig.GetSceneConfigPath(sc.path)); AssetDatabase.Refresh(); }
private void SceneManager_sceneLoaded(UnityEngine.SceneManagement.Scene _scene, LoadSceneMode _mode) { if (_scene.name == "UIScene") { return; } SceneManager.SetActiveScene(_scene); if (!m_activeObjectsByScene.ContainsKey(_scene.path)) { // First Load, activate only initial objects List <string> activeObjects = new List <string>(); ClickableObject[] allObjects = FindObjectsOfType <ClickableObject>(); foreach (ClickableObject obj in allObjects) { if (obj.m_InitalActive) { activeObjects.Add(obj.m_ObjectName + obj.name); obj.gameObject.SetActive(true); } else { obj.gameObject.SetActive(false); } } m_activeObjectsByScene.Add(_scene.path, activeObjects); } else { // reload ClickableObject[] allObjects = FindObjectsOfType <ClickableObject>(); List <string> activeObjects = m_activeObjectsByScene[_scene.path]; foreach (ClickableObject obj in allObjects) { if (activeObjects.Contains(obj.m_ObjectName + obj.name)) { obj.gameObject.SetActive(true); } else { obj.gameObject.SetActive(false); } } } }
static void OnLevelFinishedLoading(sm.Scene scene, sm.LoadSceneMode mode) { // Stuff to do when scene has finished loading if (current.scenes[scene.buildIndex].gameScene) { CoreManager.current.inGame = true; CoreManager.current.player = GameObject.FindGameObjectWithTag("Player").GetComponent <Player>(); } else { CoreManager.current.inGame = false; } CoreManager.UpdatePresence(); sm.SceneManager.sceneLoaded -= OnLevelFinishedLoading; }
static public T[] SearchScene <T>(UnityEngine.SceneManagement.Scene scene, bool searchInActiveGameObjects) where T : Component { if (!scene.isLoaded) { return(null); } var gos = scene.GetRootGameObjects(); var list = new FastList <T>(); foreach (var go in gos) { list.AddRange(SearchParent <T>(go, searchInActiveGameObjects)); } return(list.ToArray()); }
static private void ProcOnSceneLoaded(UnityEngine.SceneManagement.Scene arg0, UnityEngine.SceneManagement.LoadSceneMode arg1) { if (CManagerUILocalize.instance != null) { CManagerUILocalize.instance.DoSetLocalize_CurrentScene(); } p_pManagerScene.EventCheckIsLoadComplete(); instance.OnSceneLoaded(arg0, arg1); if (_OnFinishLoad_Scene != null && _strCallBackRequest_SceneName != null && _strCallBackRequest_SceneName.CompareTo(arg0.name) == 0) { _strCallBackRequest_SceneName = ""; System.Action OnFinishCurrentScene = _OnFinishLoad_Scene; _OnFinishLoad_Scene = null; OnFinishCurrentScene(); } }
void OnSceneLoaded(UnityEngine.SceneManagement.Scene scene, UnityEngine.SceneManagement.LoadSceneMode mode) { //if (scene.name == "StoryScene") //{ // bgm.volume -= Time.deltaTime; // Destroy(gameObject); // //Debug.Log("I am inside the if statement"); //} if (bgm != null) { if (scene.name == "StoryScene") { bgm.volume -= Time.deltaTime; Destroy(gameObject); //Debug.Log("I am inside the if statement"); } } }
protected override void OnDrawForm(int id) { m_ScrollPos = GUILayout.BeginScrollView(m_ScrollPos); { Label(GetString("Scene Count"), SceneManager.sceneCount.ToString()); Label(GetString("Scene Count In Build Settings"), SceneManager.sceneCountInBuildSettings.ToString()); UnityEngine.SceneManagement.Scene activeScene = SceneManager.GetActiveScene(); Label(GetString("Active Scene Name"), activeScene.name); Label(GetString("Active Scene Path"), activeScene.path); Label(GetString("Active Scene Build Index"), activeScene.buildIndex.ToString()); Label(GetString("Active Scene Is Dirty"), activeScene.isDirty.ToString()); Label(GetString("Active Scene Is Loaded"), activeScene.isLoaded.ToString()); Label(GetString("Active Scene Is Valid"), activeScene.IsValid().ToString()); Label(GetString("Active Scene Root Count"), activeScene.rootCount.ToString()); } GUILayout.EndScrollView(); }
public bool AreAllDescendantsHidden(Scene scene) { if (scene.rootCount == 0) { return(false); } scene.GetRootGameObjects(m_RootBuffer); foreach (GameObject root in m_RootBuffer) { if (!SceneVisibilityState.IsHierarchyHidden(root)) { return(false); } } return(true); }
private void SceneManager_sceneLoaded(UnityEngine.SceneManagement.Scene arg0, LoadSceneMode arg1) { if (arg0.name == this._sceneName) { SceneManager.sceneLoaded -= this.SceneManager_sceneLoaded; if (arg0.rootCount == 1) { this._loadedSceneRoot = arg0.GetRootGameObjects()[0]; } else { Debug.Log("More than one root object in cave scene: " + this._sceneName); this._loadedSceneRoot = (string.IsNullOrEmpty(this._sceneObjectName) ? GameObject.FindWithTag(this._sceneObjectTag) : GameObject.Find(this._sceneObjectName)); } this._onFinishedLoading.Invoke(); this.OnActionFinished(); } }
private void SceneManager_sceneLoaded(UnityEngine.SceneManagement.Scene arg0, LoadSceneMode arg1) { if (arg0.name == this.SceneName) { SceneManager.sceneLoaded -= this.SceneManager_sceneLoaded; if (arg0.rootCount == 1) { this.LoadedCaveGo = arg0.GetRootGameObjects()[0]; } else { Debug.Log("More than one root object in cave scene: " + this.SceneName); this.LoadedCaveGo = GameObject.Find(this.RootName); } this.Loading = false; this.Async = null; } }
/// <summary> /// Save Configuration of a single datamanager /// </summary> static void SaveDataManagerConfiguration() { // Add send data option here string currentPath = SceneManager.GetActiveScene().path; ConfigurationManager.manager.appId = ConfigurationManager.appId; ConfigurationManager.manager.appToken = ConfigurationManager.appToken; ConfigurationManager.manager.testMode = ConfigurationManager.testMode; ConfigurationManager.manager.pauseSendFlag = ConfigurationManager.pauseSendFlag; ConfigurationManager.manager.periodicSendFlag = ConfigurationManager.periodicSendFlag; ConfigurationManager.manager.pauseOnHeadsetRemoval = ConfigurationManager.pauseOnHeadsetRemoval; AddEventScripts(ConfigurationManager.manager.gameObject); EditorUtility.SetDirty(ConfigurationManager.manager); // Tells unity that it is modified and save it if (currentPath.Length > 0) { UnityEngine.SceneManagement.Scene scene = SceneManager.GetSceneByPath(currentPath); EditorSceneManager.SaveScene(scene); } }
private void Show(Scene scene, bool sendContentChangedEvent) { if (!scene.IsValid()) { return; } if (!scene.isLoaded) { return; } SceneVisibilityState.ShowScene(scene); if (sendContentChangedEvent) { VisibilityChanged(); } }
static void RemoveAll() { UnityEngine.SceneManagement.Scene sc = UnityEngine.SceneManagement.SceneManager.GetActiveScene(); if (!sc.IsValid()) { return; } GameObject[] array = GameObject.FindGameObjectsWithTag(SERIALIZE_SCENE_OBJECT_TAG); if (array == null) { return; } for (int i = 0; i < array.Length; ++i) { GameObject.DestroyImmediate(array[i]); } }
private void SceneManager_sceneLoaded(Scene arg0, LoadSceneMode arg1) { try { var currentMap = GetCurrentMapNo(); if (_lastLoadedMapNo == currentMap) { return; } _lastLoadedMapNo = currentMap; StartCoroutine(MobManager.SpawnMobs(currentMap, arg0.name)); } catch (Exception ex) { // Don't crash the event Logger.LogError(ex); } }
internal static void LoadScenesForMerging() { Scene activeScene = new Scene(); AmsMultiSceneSetup activeSetup = null; List<AmsMultiSceneSetup.SceneEntry> bakedScenes = new List<AmsMultiSceneSetup.SceneEntry>(); GetCommonParameters( ref activeScene, ref activeSetup, bakedScenes ); if ( bakedScenes.Count < 1 ) return; AmsDebug.Log( null, "Running LoadScenesForBaking on Scene {0}", activeScene.name ); // Now load all of the scenes foreach( var entry in bakedScenes ) { var realScene = entry.scene.scene; if ( !realScene.IsValid() ) { // This is good. This means it's not loaded yet. realScene = EditorSceneManager.OpenScene( entry.scene.editorPath, OpenSceneMode.Additive ); if ( !realScene.IsValid() ) { AmsDebug.LogError( activeSetup, "BakeScene: Scene {0} ({1}) referenced from Multi-Scene Setup in {2} is invalid.", entry.scene.editorPath, entry.scene.name, activeScene.name ); continue; } } // Let's catch this... if ( !realScene.isLoaded ) { realScene = EditorSceneManager.OpenScene( realScene.path, OpenSceneMode.Additive ); // if we're still not loaded, we're probably in trouble. if ( !realScene.isLoaded ) { AmsDebug.LogError( activeSetup, "BakeScene: Scene {0} ({1}) referenced from Multi-Scene Setup in {2} could not load.", entry.scene.editorPath, entry.scene.name, activeScene.name ); continue; } } } }
private static void GetCommonParameters( ref Scene activeScene, ref AmsMultiSceneSetup activeSceneSetup, List<AmsMultiSceneSetup.SceneEntry> bakedScenes ) { // We can only execute this when building the player. Otherwise we expect entries to already be in the scene. if ( !BuildPipeline.isBuildingPlayer ) return; // Get the SceneSetup for the Active Scene. activeScene = EditorSceneManager.GetActiveScene(); activeSceneSetup = GameObjectEx.GetSceneSingleton<AmsMultiSceneSetup>( activeScene, false ); if ( !activeSceneSetup ) return; var scenesInSetup = activeSceneSetup.GetSceneSetup(); foreach( var entry in scenesInSetup ) { bool bShouldBake = entry.loadMethod == AmsMultiSceneSetup.LoadMethod.Baked; if ( bShouldBake ) bakedScenes.Add( entry ); } }
void SelectContext(Scene scene) { var rootObjects = scene.GetRootGameObjects(); var sceneContexts = rootObjects .SelectMany(x => x.GetComponentsInChildren<SceneContext>()).FirstOrDefault(); if (sceneContexts != null) { Selection.activeGameObject = sceneContexts.gameObject; } else { var decoratorContexts = rootObjects .SelectMany(x => x.GetComponentsInChildren<SceneDecoratorContext>()).FirstOrDefault(); if (decoratorContexts != null) { Selection.activeGameObject = decoratorContexts.gameObject; } } }
public override void Run() { ConsoleWindow.SetConsoleErrorPause(false); Application.runInBackground = true; string sceneName = base.CreateSceneName(); this.m_Scene = base.CreateBootstrapScene(sceneName, delegate (PlaymodeTestsController runner) { PlaymodeTestsControllerExtensions.AddEventHandlerMonoBehaviour<ResultsRenderer>(runner); PlaymodeTestsControllerExtensions.AddEventHandlerScriptableObject<WindowResultUpdater>(runner); PlaymodeTestsControllerExtensions.AddEventHandlerScriptableObject<TestRunnerCallback>(runner); if (this.m_Settings.isBatchModeRun) { PlaymodeTestsControllerExtensions.AddEventHandlerScriptableObject<PlaymodeResultSaverCallback>(runner); PlaymodeTestsControllerExtensions.AddEventHandlerScriptableObject<BatchRunCallback>(runner); } runner.settings = this.m_Settings; }); if (this.m_Settings.sceneBased) { EditorBuildSettings.scenes = new List<EditorBuildSettingsScene> { new EditorBuildSettingsScene(sceneName, true) }.ToArray(); } EditorApplication.update = (EditorApplication.CallbackFunction) Delegate.Combine(EditorApplication.update, new EditorApplication.CallbackFunction(this.UpdateCallback)); this.m_InitPlaying = 3; }
private static extern bool INTERNAL_CALL_MarkSceneDirty(ref Scene scene);
public static extern bool SaveModifiedScenesIfUserWantsTo(Scene[] scenes);
public Map(Scene scene) { this.index = scene.buildIndex; this.name = scene.name; this.path = scene.path; }
static void RestoreCrossSceneReferences() { Scene activeScene = new Scene(); AmsMultiSceneSetup activeSetup = null; List<AmsMultiSceneSetup.SceneEntry> bakedScenes = new List<AmsMultiSceneSetup.SceneEntry>(); GetCommonParameters( ref activeScene, ref activeSetup, bakedScenes ); if ( bakedScenes.Count < 1 ) return; AmsDebug.Log( null, "Running RestoreCrossSceneReferences on Scene {0}", activeScene.name ); // Do the merge (bake) var targetCrossRefs = AmsCrossSceneReferences.GetSceneSingleton( activeScene, false ); if ( targetCrossRefs ) targetCrossRefs.ResolvePendingCrossSceneReferences(); foreach( var entry in bakedScenes ) { if ( !entry.scene.isLoaded ) { AmsDebug.LogError( activeSetup, "Could not restore cross-scene references for non-loaded scene: {0}", entry.scene.name ); continue; } var sourceCrossRefs = AmsCrossSceneReferences.GetSceneSingleton( entry.scene.scene, false ); if ( sourceCrossRefs ) sourceCrossRefs.ResolvePendingCrossSceneReferences(); } }
private void OnSceneLoaded(Scene scene, LoadSceneMode sceneMode) { if (instance != this) { return; } if (androidUIResizeMode == AndroidUIResizeMode.ResizeCamera || androidUIResizeMode == AndroidUIResizeMode.ResizeCameraAndReferenceResolution) { Camera.main.pixelRect = new Rect(0, 0, Screen.width, Screen.height - webViewHeight); } if (androidUIResizeMode == AndroidUIResizeMode.ResizeCameraAndReferenceResolution) { UnityEngine.UI.CanvasScaler[] allCanvasScalers = GameObject.FindObjectsOfType<UnityEngine.UI.CanvasScaler> (); for (int i = 0; i < allCanvasScalers.Length; ++i) { allCanvasScalers[i].referenceResolution = new Vector2 (allCanvasScalers[i].referenceResolution.x, allCanvasScalers[i].referenceResolution.y / (allCanvasScalers[i].referenceResolution.y - webViewHeight) * allCanvasScalers[i].referenceResolution.y); } } }
private static extern bool INTERNAL_CALL_CloseScene(ref Scene scene, bool removeScene);
private void Initialize() { Audio._instance = this; UnityEngine.SceneManagement.Scene startScene = new UnityEngine.SceneManagement.Scene(); int sceneCount = UnityEngine.SceneManagement.SceneManager.sceneCount; for(int i = 0;i < sceneCount;++i) { UnityEngine.SceneManagement.Scene tmpScene = UnityEngine.SceneManagement.SceneManager.GetSceneAt(i); if (tmpScene.name == GameLord.startSceneName) { startScene = tmpScene; break; } } _audioSourceObjectPool = new AudioSourceObjectPool(_transform, 24); int sourceCount = _audioSourceObjectPool.Size; AudioSource[] sources = _audioSourceObjectPool.Pool; //for(int i = 0;i < sourceCount;++i) //{ // UnityEngine.SceneManagement.SceneManager.MoveGameObjectToScene(sources[i].gameObject, startScene); //} if (_music != null) { _musicSource = this.gameObject.AddComponent<AudioSource>(); _musicSource.clip = _music; _musicSource.loop = true; _musicSource.Play(); _musicSource.volume = 0.0f; } }
public static extern bool SaveScenes(Scene[] scenes);
private static extern void INTERNAL_CALL_NewScene(NewSceneSetup setup, NewSceneMode mode, out Scene value);
/// <summary> /// Find the Scene of an object instance and use a cache to help look-ups. /// </summary> /// <param name="instance">The instance to look at</param> /// <param name="cache">The cache to populate</param> /// <returns>The scene instance belongs to</returns> private static Scene FindSceneCached( Object instance, Dictionary<Object, Scene> cache ) { // Null SubScene if ( !instance ) return new Scene(); // Quick case, it's already cached... Scene scene = new Scene(); if ( cache.TryGetValue(instance, out scene) ) return scene; // Persistent objects are Assets if ( !EditorUtility.IsPersistent(instance) ) { var gameObj = GameObjectEx.EditorGetGameObjectFromComponent( instance ); if ( gameObj ) scene = gameObj.scene; } cache.Add(instance, scene); return scene; }
public void OnSceneWasLoaded(Scene scene, LoadSceneMode m) { OnSceneLoaded(); }
/// <summary> /// <para>Close the scene. If removeScene flag is true, the closed scene will also be removed from EditorSceneManager.</para> /// </summary> /// <param name="scene">The scene to be closed/removed.</param> /// <param name="removeScene">Bool flag to indicate if the scene should be removed after closing.</param> /// <returns> /// <para>Returns true if the scene is closed/removed.</para> /// </returns> public static bool CloseScene(Scene scene, bool removeScene) { return EditorSceneManager.INTERNAL_CALL_CloseScene(ref scene, removeScene); }
private static extern bool INTERNAL_CALL_SaveScene(ref Scene scene, string dstScenePath, bool saveAsCopy);
/// <summary> /// <para>Mark the scene as modified.</para> /// </summary> /// <param name="scene">The scene to be marked as modified.</param> public static bool MarkSceneDirty(Scene scene) { return EditorSceneManager.INTERNAL_CALL_MarkSceneDirty(ref scene); }
protected virtual void OnSceneLoaded(Scene scene, LoadSceneMode mode) { // Ignore additive scene loads if (mode == LoadSceneMode.Additive) { return; } // We first assume that this is a 'normal' scene load rather than a saved game being loaded. // If we subsequently receive a notification that a saved game was loaded then the load action // set here will be overridden by the OnSavePointLoaded callback above. if (loadAction == null) { loadAction = ExecuteStartBlock; } }
static void MergeScenes() { Scene activeScene = new Scene(); AmsMultiSceneSetup activeSetup = null; List<AmsMultiSceneSetup.SceneEntry> bakedScenes = new List<AmsMultiSceneSetup.SceneEntry>(); GetCommonParameters( ref activeScene, ref activeSetup, bakedScenes ); if ( bakedScenes.Count < 1 ) return; AmsDebug.Log( null, "Running MergeScenes on Scene {0}", activeScene.name ); foreach( var entry in bakedScenes ) { if ( !entry.scene.isLoaded ) { AmsDebug.LogError( activeSetup, "Could not merge non-loaded scene: {0}", entry.scene.name ); continue; } var sourceCrossRefs = AmsCrossSceneReferences.GetSceneSingleton( entry.scene.scene, false ); if ( sourceCrossRefs ) GameObject.DestroyImmediate( sourceCrossRefs.gameObject, false ); AmsDebug.Log( null, "Merging {0} into {1}", entry.scene.name, activeScene.name ); EditorSceneManager.MergeScenes( entry.scene.scene, activeScene ); } } // MergeScenes
private static extern void INTERNAL_CALL_OpenScene(string scenePath, OpenSceneMode mode, out Scene value);
/// <summary> /// Method used to load the scene additively. /// /// When loading a scene, it means that is the first time that it will be activated after it was previously destroyed. /// /// This means that no subscene should be loaded /// </summary> public void LoadSceneAdditive() { //Application.LoadLevelAdditive(m_name); SceneManager.LoadScene(m_name, UnityEngine.SceneManagement.LoadSceneMode.Additive); m_scene = SceneManager.GetSceneByName(m_name); m_loaded = true; m_activated = true; m_subscenes.Clear(); }