public override PresentationResult OnInspectorGui(PresentationParamater parameter) { FortScene fortScene = (FortScene)parameter.Instance; SceneAsset oldScene = fortScene == null?null: AssetDatabase.LoadAssetAtPath <SceneAsset>(fortScene.SceneName); if (fortScene == null) { fortScene = new FortScene(); } EditorGUI.BeginChangeCheck(); Object result = EditorGUILayout.ObjectField(parameter.Title, oldScene, typeof(SceneAsset), false); if (EditorGUI.EndChangeCheck()) { var newPath = AssetDatabase.GetAssetPath(result); fortScene.SceneName = newPath; return(new PresentationResult { Result = fortScene, Change = new Change { IsDataChanged = true } }); } return(new PresentationResult { Result = fortScene, Change = new Change { IsDataChanged = false } }); }
public override void OnGUI(Rect rect, string name, ref object value) { base.OnGUI(rect, name, ref value); EditorGUI.BeginDisabledGroup(IsReadOnly); EditorGUI.HandlePrefixLabel(rect, GetControlRect(), new GUIContent(name)); try { var scene = (EditorBuildSettingsScene)value; SceneAsset asset = null; if (scene != null && !string.IsNullOrEmpty(scene.path)) { asset = AssetDatabase.LoadAssetAtPath <SceneAsset>(scene.path); } var nAsset = EditorGUI.ObjectField(GetControlRect(), asset, typeof(SceneAsset), true); if (nAsset != asset) { if (nAsset != null) { value = Find(AssetDatabase.GetAssetOrScenePath(nAsset)); } else { value = null; } } } catch (ExitGUIException) { } EditorGUI.EndDisabledGroup(); }
public TestResultViewItem(int id, int depth, string displayName, SceneAsset sceneObject) { this.id = id; this.depth = depth; this.displayName = displayName; this.sceneObject = sceneObject; }
/// <summary> /// Return true if the scene belongs to the persistant scene bundle /// </summary> /// <param name="scene"></param> /// <returns></returns> public static bool IsPersistantScene(this SceneAsset scene) { if (scene == null) { return(false); } SceneBundleList currentList = EnhancedSceneManager.GetCurrentSceneList(); if (currentList == null) { return(false); } if (currentList.PersistantScenesBundle == null) { return(false); } for (int i = 0; i < currentList.PersistantScenesBundle.ScenesCount; i++) { if (currentList.PersistantScenesBundle.ContainsScene(scene.name)) { return(true); } } return(false); }
void RestorePreviousValues() { string serializedJson = EditorPrefs.GetString("JSON_KEY", ""); // Debug.LogWarning(serializedJson); experiences = JsonUtility.FromJson <ListWrapper>(serializedJson); // Debug.LogWarning(experiences == null ? "NULL" : "NOT NULL"); if (experiences != null) { // foldoutExperiences = new List<bool>(experiences.list.Count); // load experiences's scene assets for (int experienceID = 0; experienceID < experiences.list.Count; experienceID++) { List <SceneAsset> sceneAssets = new List <SceneAsset>(); for (int sceneID = 0; sceneID < experiences.list[experienceID].scenePaths.Count; sceneID++) { SceneAsset sceneAsset = AssetDatabase.LoadAssetAtPath <SceneAsset>(experiences.list[experienceID].scenePaths[sceneID]); sceneAssets.Add(sceneAsset); } experiencesSceneAssets.Add(sceneAssets); // foldoutExperiences.Add(experiences.list[experienceID].foldout); } } else { experiences = new ListWrapper(); experiences.list = new List <Experience>(); // foldoutExperiences = new List<bool>(); } }
private void Reload(SceneAsset _sceneAsset = null) { sceneAsset = _sceneAsset; if (sceneAsset == null) { return; } if (templateImage != null && templateImage != Texture2D.whiteTexture) { DestroyImmediate(templateImage); } tmpPath = ""; GetTemplateImage(); string templatePath = Path.Combine(TestFrameworkTools.s_RootPath, "ImageTemplates"); templateLocation = Path.Combine(templatePath, string.Format("{0}.{1}", tmpPath, "png")); GetDiffMaterial(); // Search for fail image if it exists. GetResultImage(); diffMaterial.SetTexture("_CompareTex", resultImage); ApplyValues(); testResultTreeView.Reload(); }
private void OnGUI() { if (_scenesContainer == null) { return; } for (int i = 0; i < _scenesContainer.SceneAssets.Count; i++) { var sceneNumber = (i + 1).ToString(); SceneAsset newAsset = EditorGUILayout.ObjectField(new GUIContent("Scene " + sceneNumber + " (Shift+" + (i + 1).ToString().Substring(sceneNumber.Length - 1) + ")"), _scenesContainer.SceneAssets[i], typeof(SceneAsset), false) as SceneAsset; if (newAsset != _scenesContainer.SceneAssets[i]) { _scenesContainer.SceneAssets[i] = newAsset; EditorUtility.SetDirty(_scenesContainer); } } GUILayout.BeginHorizontal(); if (GUILayout.Button("Clear")) { for (int i = 0; i < 10; i++) { _scenesContainer.SceneAssets[i] = null; } EditorUtility.SetDirty(_scenesContainer); } GUILayout.EndHorizontal(); }
private void OnEnable() { // In case domain was not reloaded after entering play mode prevSceneAsset = null; PopulateScenePath(); onEnabled?.Invoke(this); }
private void UpdateAsyncOperation() { if (m_AsyncOperation != null) { if (m_AsyncOperation.isDone) { if (m_AsyncOperation.allowSceneActivation) { SceneAsset sceneAsset = new SceneAsset(); LoadResourceAgentHelperLoadCompleteEventArgs loadResourceAgentHelperLoadCompleteEventArgs = LoadResourceAgentHelperLoadCompleteEventArgs.Create(sceneAsset); m_LoadResourceAgentHelperLoadCompleteEventHandler(this, loadResourceAgentHelperLoadCompleteEventArgs); ReferencePool.Release(loadResourceAgentHelperLoadCompleteEventArgs); m_AssetName = null; m_LastProgress = 0f; m_AsyncOperation = null; } else { LoadResourceAgentHelperErrorEventArgs loadResourceAgentHelperErrorEventArgs = LoadResourceAgentHelperErrorEventArgs.Create(LoadResourceStatus.AssetError, Utility.Text.Format("Can not load scene asset '{0}' from asset bundle.", m_AssetName)); m_LoadResourceAgentHelperErrorEventHandler(this, loadResourceAgentHelperErrorEventArgs); ReferencePool.Release(loadResourceAgentHelperErrorEventArgs); } } else if (m_AsyncOperation.progress != m_LastProgress) { m_LastProgress = m_AsyncOperation.progress; LoadResourceAgentHelperUpdateEventArgs loadResourceAgentHelperUpdateEventArgs = LoadResourceAgentHelperUpdateEventArgs.Create(LoadResourceProgress.LoadScene, m_AsyncOperation.progress); m_LoadResourceAgentHelperUpdateEventHandler(this, loadResourceAgentHelperUpdateEventArgs); ReferencePool.Release(loadResourceAgentHelperUpdateEventArgs); } } }
private void GoToMainMenu() { AssetID sceneID = "Scenes/MainMenu.scene"; SceneAsset scene = _as.Database.LoadAsset <SceneAsset>(sceneID, cache: false); _sls.LoadScene(scene); }
private static void CreatePresetFromOpenScenes() { MultiScene multi = CreateInstance <MultiScene>(); multi.name = "New Multi-Scene"; Scene activeScene = SceneManager.GetActiveScene(); int sceneCount = SceneManager.sceneCount; for (int i = 0; i < sceneCount; i++) { Scene scene = SceneManager.GetSceneAt(i); SceneAsset sceneAsset = AssetDatabase.LoadAssetAtPath <SceneAsset>(scene.path); if (activeScene == scene) { multi.activeScene = sceneAsset; } multi.sceneAssets.Add(new MultiScene.SceneInfo(sceneAsset, scene.isLoaded)); } string directory = AssetDatabase.GetAssetPath(Selection.activeObject.GetInstanceID()); bool isDirectory = Directory.Exists(directory); if (!isDirectory) { directory = Path.GetDirectoryName(directory); } ProjectWindowUtil.CreateAsset(multi, $"{directory}/{multi.name}.asset"); }
/// <summary> /// Destroys all scene assets that were created over the course of testing. /// Used only in editor tests. /// </summary> public static void EditorTearDownScenes() { #if UNITY_EDITOR if (!EditorApplication.isPlaying) { // If any of our scenes were saved, tear down the assets SceneAsset primaryTestSceneAsset = AssetDatabase.LoadAssetAtPath <SceneAsset>(primaryTestSceneTemporarySavePath); if (primaryTestSceneAsset != null) { AssetDatabase.DeleteAsset(primaryTestSceneTemporarySavePath); } for (int i = 0; i < additiveTestScenes.Length; i++) { string path = additiveTestSceneTemporarySavePath.Replace("#", i.ToString()); SceneAsset additiveTestSceneAsset = AssetDatabase.LoadAssetAtPath <SceneAsset>(path); if (additiveTestSceneAsset != null) { AssetDatabase.DeleteAsset(path); } } AssetDatabase.Refresh(); } #endif }
private void Start() { SceneManager.sceneLoaded += onSceneLoaded; _nextScene = FindObjectOfType <NextSceneStorage>()?.StoredScene; Debug.Log("Next scene is " + _nextScene.name); // Time.timeScale = 3f; }
public static void RemoveSceneFromBuildSettings(SceneAsset scene) { if (EditorBuildSettings.scenes.Length == 0) { return; } if (string.IsNullOrEmpty(AssetDatabase.GetAssetPath(scene))) { return; } if (!SceneAddedToBuildCriterion.SceneIsAddedToBuildSettings(scene)) { return; } var sceneAsset = new EditorBuildSettingsScene(AssetDatabase.GetAssetPath(scene), true); var scenes = new EditorBuildSettingsScene[EditorBuildSettings.scenes.Length - 1]; var j = 0; for (int i = 0; i < EditorBuildSettings.scenes.Length; ++i) { if (EditorBuildSettings.scenes[i].guid != sceneAsset.guid) { scenes[j++] = EditorBuildSettings.scenes[i]; } } EditorBuildSettings.scenes = scenes; }
void CreateSceneRootPerfab(SceneAsset sceneAsset) { Scene needOpenScene = EditorSceneManager.OpenScene(AssetDatabase.GetAssetPath(sceneAsset.GetInstanceID())); List <GameObject> sceneRootGameObjects = new List <GameObject>(); sceneRootGameObjects.AddRange(needOpenScene.GetRootGameObjects()); foreach (GameObject g in sceneRootGameObjects) { if (CheckNeedRemoveObject(g)) { sceneRootGameObjects.Remove(g); } } GameObject sceneRoot = new GameObject(); sceneRoot.name = name + "SceneRoot"; foreach (GameObject g in sceneRootGameObjects) { g.transform.parent = sceneRoot.transform; } string createPrefabPath = "Assets/intermediate/" + needOpenScene.name + "_SceneRoot.prefab"; GameObject createPrefab = PrefabUtility.CreatePrefab(createPrefabPath, sceneRoot); AssetImporter assetImporter = AssetImporter.GetAtPath(createPrefabPath); //得到Asset assetImporter.assetBundleName = createPrefab.name.ToLower(); //最终设置assetBundleName EditorSceneManager.NewScene(new NewSceneSetup()); }
public static IList <IValidationError> ValidateAllGameObjectsInScenes(IEnumerable <Scene> scenes, bool earlyExitOnError = false) { List <IValidationError> validationErrors = new List <IValidationError>(); foreach (Scene scene in scenes) { // NOTE (darren): use SceneAsset instead of Scene as the context object // because scene is a struct and was being lost when returning out-of-scope as // part of IValidationError SceneAsset sceneAsset = AssetDatabase.LoadMainAssetAtPath(scene.path) as SceneAsset; if (sceneAsset == null) { Debug.LogWarning("Cannot validate game objects with missing SceneAsset at path: " + scene.path); continue; } GameObject[] rootObjects = scene.GetRootGameObjects(); foreach (GameObject rootObject in rootObjects) { Validator.Validate(rootObject, contextObject: sceneAsset, recursive: true, validationErrors: validationErrors); if (earlyExitOnError && validationErrors.Count > 0) { return(validationErrors); } } } return(validationErrors); }
private void DrawLoadingSceneShortcut() { GUILayout.BeginVertical("box"); EditorGUILayout.Space(); string loadingScenePath = EditorPrefs.GetString(LOADING_SCENE_KEY); if (_loadingScene == null && !string.IsNullOrEmpty(loadingScenePath)) { _loadingScene = AssetDatabase.LoadAssetAtPath <SceneAsset>(loadingScenePath); } _loadingScene = EditorGUILayout.ObjectField("Loading Scene", _loadingScene, typeof(SceneAsset), true) as SceneAsset; if (_loadingScene != null) { EditorPrefs.SetString(LOADING_SCENE_KEY, AssetDatabase.GetAssetPath(_loadingScene)); } _automaticallyLoadScenes = EditorGUILayout.Toggle("Automatically Load Scenes", _automaticallyLoadScenes); EditorPrefs.SetBool(AUTO_LOAD_KEY, _automaticallyLoadScenes); EditorGUILayout.Space(); GUILayout.EndVertical(); }
public static void FirstProjectLaunch() { if (!FindObjectOfType <FMCGameManager>()) { new GameObject("FMC").AddComponent <FMCGameManager>(); EditorSceneManager.SaveScene(UnityEngine.SceneManagement.SceneManager.GetActiveScene(), fmc.game.GameSceneDefaultPath); FMCGameSettings Target = FMCGameSettings.LoadOrCreateGameSettings(); //Searching scenes in project if (string.IsNullOrEmpty(Target.Public.gameSceneGUID)) { SceneAsset s = GetSceneFromGUID(null, fmc.game.GameSceneDefaultName); if (s) { Target.Public.gameSceneGUID = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetOrScenePath(s)); } } if (string.IsNullOrEmpty(Target.Public.splashScreenSceneGUID)) { SceneAsset s = GetSceneFromGUID(null, fmc.game.SplashScreenSceneName); if (s) { Target.Public.splashScreenSceneGUID = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetOrScenePath(s)); } } UpdateUnitySettings(Target); } }
public async Task <SceneWrapper> LoadScene(Project project, SceneAsset asset) { if (asset != null) { if (this.CurrentScene != null && this.HasChanges) { var message = this.CurrentScene.SceneAsset != null ? $"Would you like to save {this.CurrentScene.SceneAsset.Name}?" : "Would you like to save the current scene?"; var result = this._dialogService.ShowYesNoCancelMessageBox($"Save Scene", message); if (result == MessageBoxResult.Cancel || (result == MessageBoxResult.Yes && !await this.SaveCurrentScene(project))) { return(null); } } this.CurrentScene = await Task.Run(() => new SceneWrapper(asset)); this.RefreshSpritesFromAssets(project); this.RefreshAudioClipsFromAssets(project); this.RefreshFontsFromAssets(project); this.HasChanges = false; return(this.CurrentScene); } return(null); }
private void ApplySceneSetting() { List <EditorBuildSettingsScene> editorScenes = new List <EditorBuildSettingsScene>(); EditorSceneManager.playModeStartScene = (SceneAsset)preloadSceneProperty.objectReferenceValue; // If there is a preload scene, assign it to build index 0 if (preloadSceneProperty.objectReferenceValue != null) { SceneAsset preloadScene = (SceneAsset)preloadSceneProperty.objectReferenceValue; string preloadScenePath = AssetDatabase.GetAssetPath(preloadScene); editorScenes.Add(new EditorBuildSettingsScene(preloadScenePath, true)); } for (int i = 0; i < scenesProperty.arraySize; i++) { SceneAsset scene = (SceneAsset)scenesProperty.GetArrayElementAtIndex(i).objectReferenceValue; if (scene != null) { string path = AssetDatabase.GetAssetPath(scene); editorScenes.Add(new EditorBuildSettingsScene(path, true)); } } EditorBuildSettings.scenes = editorScenes.ToArray(); }
private void EditMap(string mapName) { string sceneName = "Edit" + mapName; string scenePath = "Assets/Scenes/" + sceneName + ".unity"; if (EditorSceneManager.GetActiveScene().name != sceneName) { SceneAsset scene = AssetDatabase.LoadAssetAtPath <SceneAsset>(scenePath); if (scene == null) { EditorUtility.DisplayDialog("提示", "找不到场景文件" + scenePath, "好的"); return; } else { EditorSceneManager.OpenScene(scenePath); } } GameObject mapGo = GameObject.FindObjectOfType <BaseMap>()?.gameObject; if (mapGo == null) { EditorUtility.DisplayDialog("提示", "该场景中找不到地图", "好的"); return; } Selection.activeGameObject = mapGo; SetCurrentSceneIndex(); ToolsHelperEditor.SetStartupScene(mapName); }
public void TestCopyPasteEntityAtRoot() { var sceneAsset = new SceneAsset(); var entity = new EntityDesign { Entity = new Entity { Id = GuidGenerator.Get(1) } }; entity.Entity.Transform.Position = Vector3.UnitZ; sceneAsset.Hierarchy.RootParts.Add(entity.Entity); sceneAsset.Hierarchy.Parts.Add(entity); var assetTest = new CopyPasteTest <SceneAsset>(sceneAsset); var service = TestHelper.CreateCopyPasteService(); service.PropertyGraphContainer.RegisterGraph(assetTest.AssetGraph); var clipboard = Copy(service, assetTest.AssetGraph, new[] { entity }); Paste(service, clipboard, assetTest.AssetGraph, null, null); Assert.Equal(2, assetTest.Asset.Hierarchy.Parts.Count); Assert.True(assetTest.Asset.Hierarchy.Parts.Values.Contains(entity)); var pastedEntity = assetTest.Asset.Hierarchy.Parts.Values.Single(x => x != entity); Assert.Equal(2, assetTest.Asset.Hierarchy.RootParts.Count); Assert.Contains(pastedEntity.Entity, assetTest.Asset.Hierarchy.RootParts); Assert.Equal(string.Empty, pastedEntity.Folder); Assert.NotEqual(entity.Entity.Id, pastedEntity.Entity.Id); Assert.NotEqual(entity.Entity.Transform.Id, pastedEntity.Entity.Transform.Id); Assert.Equal(Vector3.UnitZ, pastedEntity.Entity.Transform.Position); }
static SceneData makeData(SceneAsset asset) { SceneData data = (SceneData)CreateAsset <SceneData>(asset.name + "_data"); processData(data, asset); return(data); }
/// <summary> /// Finds a missing scene asset reference for a SceneInfo struct. /// </summary> /// <returns>True if scene was found.</returns> public static bool FindScene(SerializedProperty nameProperty, SerializedProperty pathProperty, ref UnityEngine.Object asset) { // Attempt to load via the scene path SceneAsset newSceneAsset = AssetDatabase.LoadAssetAtPath <SceneAsset>(pathProperty.stringValue); if (newSceneAsset != null) { Debug.Log("Found missing scene at path " + pathProperty.stringValue); asset = newSceneAsset; return(true); } else { // If we didn't find it this way, search for all scenes in the project and try a name match foreach (string sceneGUID in AssetDatabase.FindAssets("t:Scene")) { string scenePath = AssetDatabase.GUIDToAssetPath(sceneGUID); string sceneName = System.IO.Path.GetFileNameWithoutExtension(scenePath); if (sceneName == nameProperty.stringValue) { pathProperty.stringValue = scenePath; newSceneAsset = AssetDatabase.LoadAssetAtPath <SceneAsset>(scenePath); if (newSceneAsset != null) { Debug.Log("Found missing scene at path " + scenePath); asset = newSceneAsset; return(true); } } } } return(false); }
/// <summary> /// Overrides Unity display of scenes tagged with [Scene]. /// </summary> public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) { // Only override rendering on properties with type of string (otherwise it doesn't work). if (property.propertyType == SerializedPropertyType.String) { // Get currently selected object (generated from previous string value). SceneAsset sceneObject = GetSceneObject(property.stringValue); // Render a SceneAsset object field, with the previous string value, shown as a SceneAsset. Object scene = EditorGUI.ObjectField(position, label, sceneObject, typeof(SceneAsset), true); if (scene == null) { // We get nulls if the scene asset isn't found so wipe the string value. property.stringValue = ""; // If the scene name doesn't match the property they have changed it // either by drag n drop or the object picker. } else if (scene.name != property.stringValue) { // Convert the Object to a SceneAsset. SceneAsset sceneObj = GetSceneObject(scene.name); // If its a valid scene asset we use it, otherwise assume select invalid and ignore. if (sceneObj != null) { property.stringValue = scene.name; } } } else { EditorGUI.LabelField(position, label.text, "Use [Scene] with strings."); } }
/// <summary> /// Creates a new scene with sceneName and saves to path. /// </summary> public static SceneInfo CreateAndSaveScene(string sceneName, string path = null) { SceneInfo sceneInfo = default(SceneInfo); if (!EditorSceneManager.EnsureUntitledSceneHasBeenSaved("Save untitled scene before proceeding?")) { return(sceneInfo); } Scene newScene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Additive); if (string.IsNullOrEmpty(path)) { path = "Assets/" + sceneName + ".unity"; } if (!EditorSceneManager.SaveScene(newScene, path)) { Debug.LogError("Couldn't create and save scene " + sceneName + " at path " + path); return(sceneInfo); } SceneAsset sceneAsset = AssetDatabase.LoadAssetAtPath <SceneAsset>(path); sceneInfo.Asset = sceneAsset; sceneInfo.Name = sceneAsset.name; sceneInfo.Path = path; return(sceneInfo); }
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) { if (property.propertyType == SerializedPropertyType.String) { SceneAsset sceneObject = GetSceneObject(property.stringValue); SceneAsset scene = (SceneAsset)EditorGUI.ObjectField(position, label, sceneObject, typeof(SceneAsset), true); if (scene == null) { property.stringValue = ""; } else if (scene.name != property.stringValue) { SceneAsset sceneObj = GetSceneObject(scene.name); if (sceneObj == null) { Debug.LogWarning("The scene " + scene.name + " cannot be used. To use this scene add it to the build settings for the project"); } else { property.stringValue = scene.name; } } } else { EditorGUI.LabelField(position, label.text, "Use [Scene] with strings."); } }
public static void AddAllWorldScenes() { // Find valid Scene paths and make a list of EditorBuildSettingsScene List <EditorBuildSettingsScene> editorBuildSettingsScenes = new List <EditorBuildSettingsScene>(); List <SceneAsset> m_SceneAssets = new List <SceneAsset>(); string folderName = Application.dataPath + "/Scenes/WorldMap/"; var dirInfo = new DirectoryInfo(folderName); var allFileInfos = dirInfo.GetFiles("*.unity", SearchOption.AllDirectories); foreach (var fileInfo in allFileInfos) { SceneAsset sa = AssetDatabase.LoadAssetAtPath <SceneAsset>("Assets/Scenes/WorldMap/" + fileInfo.Name); m_SceneAssets.Add(sa); } foreach (var sceneAsset in m_SceneAssets) { string scenePath = AssetDatabase.GetAssetPath(sceneAsset); if (!string.IsNullOrEmpty(scenePath)) { editorBuildSettingsScenes.Add(new EditorBuildSettingsScene(scenePath, true)); } } // Set the Build Settings window Scene list EditorBuildSettings.scenes = editorBuildSettingsScenes.ToArray(); }
/// <summary> /// Add the currently loaded scenes to the /// </summary> private void AddOpenedScenes() { for (int i = 0; i < EditorSceneManager.sceneCount; i++) { SceneAsset sceneAsset = AssetDatabase.LoadAssetAtPath(EditorSceneManager.GetSceneAt(i).path, typeof(SceneAsset)) as SceneAsset; if (SceneAssets.ContainsObjects(sceneAsset)) { continue; } if (sceneAsset.IsPersistantScene()) { continue; } if (SceneAssets.arraySize > 0) { SceneAssets.InsertArrayElementAtIndex(SceneAssets.arraySize - 1); } else { SceneAssets.InsertArrayElementAtIndex(0); } SceneAssets.GetArrayElementAtIndex(SceneAssets.arraySize - 1).objectReferenceValue = sceneAsset; UpdateScenesLabels(); } }
void CreateAndAddNewSceneReference(SceneAsset newSceneReferenceLevel) { if (newSceneReferenceLevel == null) { return; } SceneReference newSceneReference = CreateInstance <SceneReference> (); newSceneReference.levelScene = newSceneReferenceLevel; newSceneReference.menuScene = AssetDatabase.LoadAssetAtPath <SceneAsset> (((SceneMenu)target).gameObject.scene.path); string newSceneReferencePath = AssetDatabase.GenerateUniqueAssetPath(k_NewSceneReferencePath); AssetDatabase.CreateAsset(newSceneReference, newSceneReferencePath); string newLevelPath = AssetDatabase.GetAssetOrScenePath(newSceneReferenceLevel); Scene newLevelScene = EditorSceneManager.OpenScene(newLevelPath, OpenSceneMode.Additive); SceneCompletion sceneCompletion = FindObjectOfType <SceneCompletion> (); sceneCompletion.sceneReference = newSceneReference; EditorUtility.SetDirty(sceneCompletion); EditorSceneManager.SaveScene(newLevelScene); EditorSceneManager.CloseScene(newLevelScene, true); m_LevelsProp.arraySize++; m_LevelsProp.GetArrayElementAtIndex(m_LevelsProp.arraySize - 1).FindPropertyRelative("level").objectReferenceValue = newSceneReference; }
private void OnLoaded(SceneAsset asset, Object obj) { //Debug.Log(string.Format("OnLoaded {0} \n", asset.ResName)); //if (asset.Type != ResourceCenter.AssetType.scene) { ++mLoadedCount; if (asset.Handle != null) asset.Handle(obj); CheckDone(); } // else // { // mAsyncOpt = Application.LoadLevelAsync(asset.ResName); // } }
private GameObject FindObject(SceneAsset.SceneObjectType type, int customID) { for(int i = 0; i < asset.sceneObjects.Length; i++) { if(asset.sceneObjects[i].type == type || (type == SceneAsset.SceneObjectType.Custom && asset.sceneObjects[i].customID == customID)) { return asset.sceneObjects[i].prefab; } } return null; }
private void RequestAsset(SceneAsset asset) { switch (asset.Type) { case ResourceCenter.AssetType.normal: { ResourceCenter.instance.LoadObject(asset.ResName, (Object obj) => { OnLoaded(asset, obj); }); break; } case ResourceCenter.AssetType.scene: { ResourceCenter.instance.LoadScene(asset.ResName, (Object obj) => { OnLoaded(asset, obj); }); break; } case ResourceCenter.AssetType.additive_scene: { ResourceCenter.instance.LoadAdditiveScene(asset.ResName, (Object obj) => { OnLoaded(asset, obj); }); break; } case ResourceCenter.AssetType.audio: { ResourceCenter.instance.LoadAudio(asset.ResName, (Object obj) => { OnLoaded(asset, obj); }); break; } case ResourceCenter.AssetType.texture: { ResourceCenter.instance.LoadTexture(asset.ResName, (Object obj) => { OnLoaded(asset, obj); }); break; } default: { Logger.instance.Error("Unprocess AssetType : {0} : {1}\n", asset.Type, asset.ResName); break; } } }