private static List <SceneTemplateInfo> GetSceneTemplateInfos()
{
var sceneTemplateList = new List <SceneTemplateInfo>();
// Add the special Empty and Basic template
s_EmptySceneTemplateInfo.isPinned = SceneTemplateProjectSettings.Get().GetPinState(s_EmptySceneTemplateInfo.name);
s_BasicSceneTemplateInfo.isPinned = SceneTemplateProjectSettings.Get().GetPinState(s_BasicSceneTemplateInfo.name);
// Check for real templateAssets:
var sceneTemplateAssetInfos = SceneTemplateUtils.GetSceneTemplatePaths().Select(templateAssetPath =>
{
var sceneTemplateAsset = AssetDatabase.LoadAssetAtPath <SceneTemplateAsset>(templateAssetPath);
return(Tuple.Create(templateAssetPath, sceneTemplateAsset));
})
.Where(templateData => {
if (templateData.Item2 == null)
{
return(false);
}
if (!templateData.Item2.IsValid)
{
return(false);
}
var pipeline = templateData.Item2.CreatePipeline();
if (pipeline == null)
{
return(true);
}
return(pipeline.IsValidTemplateForInstantiation(templateData.Item2));
}).
Select(templateData =>
{
var assetName = Path.GetFileNameWithoutExtension(templateData.Item1);
var isReadOnly = false;
if (templateData.Item1.StartsWith("Packages/") && AssetDatabase.GetAssetFolderInfo(templateData.Item1, out var isRootFolder, out var isImmutable))
{
isReadOnly = isImmutable;
}
return(new SceneTemplateInfo {
name = string.IsNullOrEmpty(templateData.Item2.templateName) ? assetName : templateData.Item2.templateName,
isPinned = templateData.Item2.addToDefaults,
isReadonly = isReadOnly,
assetPath = templateData.Item1,
description = templateData.Item2.description,
thumbnail = templateData.Item2.preview,
sceneTemplate = templateData.Item2,
onCreateCallback = loadAdditively => CreateSceneFromTemplate(templateData.Item1, loadAdditively)
});
}).ToList();
sceneTemplateAssetInfos.Sort();
sceneTemplateList.AddRange(sceneTemplateAssetInfos);
sceneTemplateList.Add(s_EmptySceneTemplateInfo);
sceneTemplateList.Add(s_BasicSceneTemplateInfo);
return(sceneTemplateList);
}
static void HandleSceneSave(Scene scene)
{
{
var result = scene.path;
var directory = Path.GetDirectoryName(result);
var filenameWithoutExt = Path.GetFileNameWithoutExtension(result);
if (s_CurrentInMemorySceneState.hasCloneableDependencies)
{
var oldDependencyFolder = Path.Combine(s_CurrentInMemorySceneState.rootFolder, s_CurrentInMemorySceneState.dependencyFolderName);
var newDependencyFolder = Path.Combine(directory, filenameWithoutExt);
if (Directory.Exists(newDependencyFolder))
{
SceneTemplateUtils.DeleteAsset(newDependencyFolder);
}
var errorMsg = AssetDatabase.MoveAsset(oldDependencyFolder, newDependencyFolder);
if (!string.IsNullOrEmpty(errorMsg))
{
Debug.LogError(errorMsg);
return;
}
}
SceneTemplateUtils.DeleteAsset(s_CurrentInMemorySceneState.rootFolder);
var success = EditorSceneManager.ReloadScene(scene);
if (!success)
{
Debug.LogError($"Failed to reload scene {scene.path}");
}
ClearInMemorySceneState();
}
}
public SceneTemplateCreationEvent(SceneTemplateAsset template, TemplateCreationType templateCreationType)
{
this.templateCreationType = Enum.GetName(typeof(TemplateCreationType), templateCreationType);
sceneName = AssetDatabase.GetAssetPath(template.templateScene);
hasCloneableDependencies = FillAnalyticDepInfos(template, dependencyInfos);
numberOfTemplatesInProject = SceneTemplateUtils.GetSceneTemplates().Count();
}
private void ValidatePosition()
{
const float tolerance = 0.0001f;
if (Math.Abs(position.xMin) < tolerance && position.yMin < tolerance)
{
position = SceneTemplateUtils.GetMainWindowCenteredPosition(k_DefaultWindowSize);
}
}
private void CreateAllSceneTemplateListsUI(VisualElement rootContainer)
{
if (m_SceneTemplateInfos == null)
{
return;
}
var templateItems = CreateGridViewItems();
m_GridView = new GridView(templateItems, L10n.Tr("Scene Templates in Project"), k_ListViewRowHeight, k_MinTileSize, k_MaxTileSize, k_ShowThumbnailTileSizeThreshold, m_DefaultThumbnail, 4f / 3f);
m_GridView.wrapAroundKeyboardNavigation = true;
m_GridView.sizeLevel = EditorPrefs.GetFloat(GetKeyName(nameof(m_GridView.sizeLevel)), 128);
rootContainer.Add(m_GridView);
m_GridView.SetPinned(m_SceneTemplateInfos.Where(template => template.isPinned).Select(template => template.GetHashCode()));
m_GridView.onSelectionChanged += OnTemplateListViewSelectionChanged;
m_GridView.onPinnedChanged += OnPinnedChanged;
m_GridView.onItemsActivated += objects =>
{
var sceneTemplateInfo = objects.First().userData as SceneTemplateInfo;
if (sceneTemplateInfo == null)
{
return;
}
if (m_SelectedButtonIndex != -1)
{
m_Buttons[m_SelectedButtonIndex].callback(sceneTemplateInfo);
}
};
var toSelect = templateItems.FirstOrDefault(item => item.userData.Equals(m_LastSelectedTemplate));
if (toSelect != null)
{
m_GridView.SetSelection(toSelect);
}
else
{
m_GridView.SetSelection(templateItems.First());
}
m_NoUserTemplateHelpBox = new HelpBox(L10n.Tr("To begin using a template, create a template from an existing scene in your project. Click to see Scene template documentation."), HelpBoxMessageType.Info);
m_NoUserTemplateHelpBox.AddToClassList(Styles.sceneTemplateNoTemplateHelpBox);
m_NoUserTemplateHelpBox.RegisterCallback <MouseDownEvent>(e =>
{
SceneTemplateUtils.OpenDocumentationUrl();
});
m_NoUserTemplateHelpBox.style.display = m_SceneTemplateInfos.All(t => t.IsInMemoryScene) ? DisplayStyle.Flex : DisplayStyle.None;
m_GridView.Insert(2, m_NoUserTemplateHelpBox);
EditorApplication.delayCall += () =>
{
m_GridView.SetFocus();
};
}
private void OnSceneTemplateAssetModified(SceneTemplateAsset asset)
{
m_SceneTemplateInfos = SceneTemplateUtils.GetSceneTemplateInfos();
var lastSelectedTemplateIndex = m_SceneTemplateInfos.IndexOf(m_LastSelectedTemplate);
if (lastSelectedTemplateIndex == -1)
{
SetLastSelectedTemplate(GetDefaultSceneTemplateInfo());
}
else
{
SetLastSelectedTemplate(m_SceneTemplateInfos[lastSelectedTemplateIndex]);
}
RefreshTemplateGridView();
UpdateTemplateDescriptionUI(m_LastSelectedTemplate);
}
internal static SceneTemplateAsset CreateTemplateFromScene(SceneAsset sourceSceneAsset, string sceneTemplatePath, SceneTemplateAnalytics.TemplateCreationType creationType)
{
var sourceScenePath = sourceSceneAsset == null ? null : AssetDatabase.GetAssetPath(sourceSceneAsset);
if (sourceSceneAsset != null && sourceScenePath != null && String.IsNullOrEmpty(sceneTemplatePath))
{
var newSceneAssetName = $"{Path.GetFileNameWithoutExtension(sourceScenePath)}.{SceneTemplateAsset.extension}";
sceneTemplatePath = Path.Combine(Path.GetDirectoryName(sourceScenePath), newSceneAssetName).Replace("\\", "/");
sceneTemplatePath = AssetDatabase.GenerateUniqueAssetPath(sceneTemplatePath);
}
if (string.IsNullOrEmpty(sceneTemplatePath))
{
throw new Exception("No path specified for new Scene template");
}
var sceneTemplate = ScriptableObject.CreateInstance <SceneTemplateAsset>();
AssetDatabase.CreateAsset(sceneTemplate, sceneTemplatePath);
if (!String.IsNullOrEmpty(sourceScenePath))
{
if (SceneManager.GetActiveScene().path == sourceScenePath && SceneManager.GetActiveScene().isDirty)
{
EditorSceneManager.SaveScene(SceneManager.GetActiveScene());
}
sceneTemplate.BindScene(sourceSceneAsset);
}
EditorUtility.SetDirty(sceneTemplate);
AssetDatabase.SaveAssets();
AssetDatabase.ImportAsset(sceneTemplatePath);
var sceneCreationEvent = new SceneTemplateAnalytics.SceneTemplateCreationEvent(sceneTemplate, creationType);
SceneTemplateAnalytics.SendSceneTemplateCreationEvent(sceneCreationEvent);
SceneTemplateUtils.SetLastFolder(sceneTemplatePath);
Selection.SetActiveObjectWithContext(sceneTemplate, null);
return(sceneTemplate);
}
private void SetupData()
{
m_SceneTemplateInfos = SceneTemplateUtils.GetSceneTemplateInfos();
LoadSessionPreferences();
m_DefaultThumbnail = EditorGUIUtility.IconContent("d_SceneAsset Icon").image as Texture2D;
foreach (var builtinTemplateInfo in SceneTemplateUtils.builtinTemplateInfos)
{
if (builtinTemplateInfo.thumbnail == null)
{
builtinTemplateInfo.thumbnail = EditorResources.Load <Texture2D>(builtinTemplateInfo.thumbnailPath);
Assert.IsNotNull(builtinTemplateInfo.thumbnail);
}
if (builtinTemplateInfo.badge == null && !string.IsNullOrEmpty(builtinTemplateInfo.badgePath))
{
builtinTemplateInfo.badge = EditorResources.Load <Texture2D>(builtinTemplateInfo.badgePath);
Assert.IsNotNull(builtinTemplateInfo.badge);
}
}
}
static void UpdateSceneTemplatesOnSceneSave(Scene scene)
{
var infos = SceneTemplateUtils.GetSceneTemplateInfos();
foreach (var sceneTemplateInfo in infos)
{
if (sceneTemplateInfo.IsInMemoryScene || sceneTemplateInfo.isReadonly || sceneTemplateInfo.sceneTemplate == null)
{
continue;
}
var scenePath = sceneTemplateInfo.sceneTemplate.GetTemplateScenePath();
if (string.IsNullOrEmpty(scenePath))
{
continue;
}
if (!scene.path.Equals(scenePath, StringComparison.Ordinal))
{
continue;
}
sceneTemplateInfo.sceneTemplate.UpdateDependencies();
}
}
static void InstantiateDefaultScene(CommandExecuteContext context)
{
if (SceneTemplatePreferences.Get().newDefaultSceneOverride == SceneTemplatePreferences.NewDefaultSceneOverride.DefaultBuiltin)
{
EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single);
return;
}
var templateInfos = SceneTemplateUtils.GetSceneTemplateInfos();
var templateInfo = templateInfos.FirstOrDefault(info => info.isPinned && !info.IsInMemoryScene);
if (templateInfo == null)
{
templateInfo = templateInfos.FirstOrDefault(info => !info.isPinned && !info.IsInMemoryScene);
}
if (templateInfo != null && templateInfo.sceneTemplate)
{
Instantiate(templateInfo.sceneTemplate, false);
return;
}
EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single);
}
private static void Send(EventName eventName, object eventData)
{
#if SCENE_TEMPLATE_ANALYTICS_LOGGING
#else
if (SceneTemplateUtils.IsDeveloperMode())
{
return;
}
#endif
if (!RegisterEvents())
{
#if SCENE_TEMPLATE_ANALYTICS_LOGGING
Console.WriteLine($"[ST] Analytics disabled: event='{eventName}', time='{DateTime.Now:HH:mm:ss}', payload={EditorJsonUtility.ToJson(eventData, true)}");
#endif
return;
}
try
{
var result = EditorAnalytics.SendEventWithLimit(eventName.ToString(), eventData);
if (result == AnalyticsResult.Ok)
{
#if SCENE_TEMPLATE_ANALYTICS_LOGGING
Console.WriteLine($"[ST] Event='{eventName}', time='{DateTime.Now:HH:mm:ss}', payload={EditorJsonUtility.ToJson(eventData, true)}");
#endif
}
else
{
Console.WriteLine($"[ST] Failed to send event {eventName}. Result: {result}");
}
}
catch (Exception)
{
// ignored
}
}
private static void SaveTemplateFromCurrentScene()
{
var currentScene = SceneManager.GetActiveScene();
if (string.IsNullOrEmpty(currentScene.path))
{
var suggestedScenePath = SceneTemplateUtils.SaveFilePanelUniqueName(L10n.Tr("Save scene"), "Assets", "newscene", "unity");
if (string.IsNullOrEmpty(suggestedScenePath) || !EditorSceneManager.SaveScene(EditorSceneManager.GetActiveScene(), suggestedScenePath))
{
return;
}
}
var sceneTemplateFile = SceneTemplateUtils.SaveFilePanelUniqueName(L10n.Tr("Save scene"), Path.GetDirectoryName(currentScene.path), Path.GetFileNameWithoutExtension(currentScene.path), SceneTemplateAsset.extension);
if (string.IsNullOrEmpty(sceneTemplateFile))
{
return;
}
var sourceSceneAsset = AssetDatabase.LoadAssetAtPath <SceneAsset>(currentScene.path);
CreateTemplateFromScene(sourceSceneAsset, sceneTemplateFile, SceneTemplateAnalytics.TemplateCreationType.SaveCurrentSceneAsTemplateMenu);
}
private static bool InstantiateScene(SceneTemplateAsset sceneTemplate, string sourceScenePath, ref string newSceneOutputPath)
{
if (String.IsNullOrEmpty(newSceneOutputPath))
{
newSceneOutputPath = SceneTemplateUtils.SaveFilePanelUniqueName(
$"Save scene instantiated from template ({sceneTemplate.name})",
SceneTemplateUtils.GetLastFolder("unity"),
Path.GetFileNameWithoutExtension(sourceScenePath), "unity");
if (string.IsNullOrEmpty(newSceneOutputPath))
{
return(false);
}
}
if (Path.IsPathRooted(newSceneOutputPath))
{
newSceneOutputPath = FileUtil.GetProjectRelativePath(newSceneOutputPath);
}
if (sourceScenePath == newSceneOutputPath)
{
Debug.LogError($"Cannot instantiate over template scene: {newSceneOutputPath}");
return(false);
}
var destinationDir = Path.GetDirectoryName(newSceneOutputPath);
if (destinationDir != null && !Directory.Exists(destinationDir))
{
Directory.CreateDirectory(destinationDir);
}
AssetDatabase.CopyAsset(sourceScenePath, newSceneOutputPath);
return(true);
}
private void BuildUI()
{
// Keyboard events need a focusable element to trigger
rootVisualElement.focusable = true;
rootVisualElement.RegisterCallback <KeyUpEvent>(e =>
{
switch (e.keyCode)
{
case KeyCode.Escape when !docked:
Close();
break;
}
});
// Load stylesheets
rootVisualElement.AddToClassList(Styles.unityThemeVariables);
rootVisualElement.AddToClassList(Styles.sceneTemplateThemeVariables);
rootVisualElement.AddStyleSheetPath(Styles.k_CommonStyleSheetPath);
rootVisualElement.AddStyleSheetPath(Styles.variableStyleSheet);
// Create a container to offset everything nicely inside the window
{
var offsetContainer = new VisualElement();
offsetContainer.AddToClassList(Styles.classOffsetContainer);
rootVisualElement.Add(offsetContainer);
// Create a container for the scene templates and description
{
var mainContainer = new VisualElement();
mainContainer.style.flexDirection = FlexDirection.Row;
mainContainer.AddToClassList(Styles.classMainContainer);
offsetContainer.Add(mainContainer);
{
// Create a container for the scene templates lists(left side)
var sceneTemplatesContainer = new VisualElement();
sceneTemplatesContainer.AddToClassList(Styles.classTemplatesContainer);
sceneTemplatesContainer.AddToClassList(Styles.sceneTemplateDialogBorder);
// mainContainer.Add(sceneTemplatesContainer);
CreateAllSceneTemplateListsUI(sceneTemplatesContainer);
// Create a container for the template description (right side)
var descriptionContainer = new VisualElement();
descriptionContainer.AddToClassList(Styles.classDescriptionContainer);
descriptionContainer.AddToClassList(Styles.classBorder);
// mainContainer.Add(descriptionContainer);
CreateTemplateDescriptionUI(descriptionContainer);
if (EditorPrefs.HasKey(GetKeyName(nameof(m_Splitter))))
{
var splitterPosition = EditorPrefs.GetFloat(GetKeyName(nameof(m_Splitter)));
sceneTemplatesContainer.style.width = splitterPosition;
}
else
{
EditorApplication.delayCall += () =>
{
sceneTemplatesContainer.style.width = position.width * 0.60f;
};
}
m_Splitter = new VisualSplitter(sceneTemplatesContainer, descriptionContainer, FlexDirection.Row);
mainContainer.Add(m_Splitter);
}
}
// Create the button row
{
var buttonRow = new VisualElement();
buttonRow.AddToClassList(Styles.sceneTemplateDialogFooter);
offsetContainer.Add(buttonRow);
buttonRow.style.flexDirection = FlexDirection.Row;
var loadAdditiveToggle = new Toggle()
{
name = k_SceneTemplateCreateAdditiveButtonName, text = L10n.Tr("Load additively"), tooltip = k_LoadAdditivelyToolTip
};
if (SceneTemplateUtils.HasSceneUntitled())
{
loadAdditiveToggle.SetEnabled(false);
loadAdditiveToggle.tooltip = k_LoadAdditivelyToolTipDisabledHasUnsavedUntitled;
}
buttonRow.Add(loadAdditiveToggle);
{
// The buttons need to be right-aligned
var buttonSection = new VisualElement();
buttonSection.style.flexDirection = FlexDirection.RowReverse;
buttonSection.AddToClassList(Styles.classButtons);
buttonRow.Add(buttonSection);
var createSceneButton = new Button(() =>
{
if (m_LastSelectedTemplate == null)
{
return;
}
OnCreateNewScene(m_LastSelectedTemplate);
})
{
text = L10n.Tr("Create"), tooltip = L10n.Tr("Instantiate a new scene from a template")
};
createSceneButton.AddToClassList(Styles.classButton);
var cancelButton = new Button(Close)
{
text = L10n.Tr("Cancel"), tooltip = L10n.Tr("Close scene template dialog without instantiating a new scene.")
};
cancelButton.AddToClassList(Styles.classButton);
buttonSection.Add(cancelButton);
buttonSection.Add(createSceneButton);
m_Buttons = new List <ButtonInfo>
{
new ButtonInfo {
button = createSceneButton, callback = OnCreateNewScene
},
new ButtonInfo {
button = cancelButton, callback = info => Close()
}
};
m_SelectedButtonIndex = m_Buttons.FindIndex(bi => bi.button == createSceneButton);
UpdateSelectedButton();
}
}
SetAllElementSequentiallyFocusable(rootVisualElement, false);
}
if (m_LastSelectedTemplate != null)
{
UpdateTemplateDescriptionUI(m_LastSelectedTemplate);
}
}
internal static System.Tuple <Scene, SceneAsset> Instantiate(SceneTemplateAsset sceneTemplate, bool loadAdditively, string newSceneOutputPath, SceneTemplateAnalytics.SceneInstantiationType instantiationType)
{
if (!sceneTemplate.IsValid)
{
throw new Exception("templateScene is empty");
}
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.dependencies.Any(dep => dep.instantiationMode == TemplateInstantiationMode.Clone);
SceneAsset newSceneAsset = null;
Scene newScene;
var templatePipeline = sceneTemplate.CreatePipeline();
if (hasAnyCloneableDependencies)
{
if (!InstantiateScene(sceneTemplate, sourceScenePath, ref newSceneOutputPath))
{
instantiateEvent.isCancelled = true;
SceneTemplateAnalytics.SendSceneInstantiationEvent(instantiateEvent);
return(null);
}
templatePipeline?.BeforeTemplateInstantiation(sceneTemplate, loadAdditively, newSceneOutputPath);
newSceneTemplateInstantiating?.Invoke(sceneTemplate, newSceneOutputPath, loadAdditively);
var refPathMap = new Dictionary <string, string>();
var refMap = CopyCloneableDependencies(sceneTemplate, newSceneOutputPath, ref refPathMap);
newScene = EditorSceneManager.OpenScene(newSceneOutputPath, loadAdditively ? OpenSceneMode.Additive : OpenSceneMode.Single);
newSceneAsset = AssetDatabase.LoadAssetAtPath <SceneAsset>(newSceneOutputPath);
var idMap = new Dictionary <int, int>();
idMap.Add(sceneTemplate.templateScene.GetInstanceID(), newSceneAsset.GetInstanceID());
EditorSceneManager.RemapAssetReferencesInScene(newScene, refPathMap, idMap);
EditorSceneManager.SaveScene(newScene, newSceneOutputPath);
foreach (var clone in refMap.Values)
{
if (clone)
{
EditorUtility.SetDirty(clone);
}
}
AssetDatabase.SaveAssets();
}
else
{
templatePipeline?.BeforeTemplateInstantiation(sceneTemplate, loadAdditively, newSceneOutputPath);
newSceneTemplateInstantiating?.Invoke(sceneTemplate, newSceneOutputPath, loadAdditively);
if (loadAdditively)
{
newScene = EditorSceneManager.OpenScene(sourceScenePath, OpenSceneMode.Additive);
}
else
{
newScene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
var sourceScene = EditorSceneManager.OpenScene(sourceScenePath, OpenSceneMode.Additive);
SceneManager.MergeScenes(sourceScene, newScene);
}
}
SceneTemplateAnalytics.SendSceneInstantiationEvent(instantiateEvent);
templatePipeline?.AfterTemplateInstantiation(sceneTemplate, newScene, loadAdditively, newSceneOutputPath);
newSceneTemplateInstantiated?.Invoke(sceneTemplate, newScene, newSceneAsset, loadAdditively);
SceneTemplateUtils.SetLastFolder(newSceneOutputPath);
return(new System.Tuple <Scene, SceneAsset>(newScene, newSceneAsset));
}
static SceneTemplateAnalytics()
{
Version = SceneTemplateUtils.GetPackageVersion();
}
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 (!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 clonedAssets = CopyCloneableDependencies(sceneTemplate, newSceneOutputPath, ref refPathMap);
idMap.Add(sceneTemplate.templateScene.GetInstanceID(), newSceneAsset.GetInstanceID());
ReferenceUtils.RemapAssetReferences(refPathMap, idMap);
foreach (var clone in clonedAssets)
{
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);
}
SceneTemplateAnalytics.SendSceneInstantiationEvent(instantiateEvent);
templatePipeline?.AfterTemplateInstantiation(sceneTemplate, newScene, loadAdditively, newSceneOutputPath);
newSceneTemplateInstantiated?.Invoke(sceneTemplate, newScene, newSceneAsset, loadAdditively);
SceneTemplateUtils.SetLastFolder(newSceneOutputPath);
return(new InstantiationResult(newScene, newSceneAsset));
}
internal bool UpdateDependencies()
{
if (!isValid)
{
dependencies = new DependencyInfo[0];
return(false);
}
var scenePath = AssetDatabase.GetAssetPath(templateScene.GetInstanceID());
if (string.IsNullOrEmpty(scenePath))
{
dependencies = new DependencyInfo[0];
return(false);
}
var sceneName = Path.GetFileNameWithoutExtension(scenePath);
var sceneFolder = Path.GetDirectoryName(scenePath).Replace("\\", "/");
var sceneCloneableDependenciesFolder = Path.Combine(sceneFolder, sceneName).Replace("\\", "/");
var depList = new List <Object>();
ReferenceUtils.GetSceneDependencies(scenePath, depList);
var newDependenciesAdded = false;
dependencies = depList.Select(d =>
{
var oldDependencyInfo = dependencies.FirstOrDefault(di => di.dependency.GetInstanceID() == d.GetInstanceID());
if (oldDependencyInfo != null)
{
return(oldDependencyInfo);
}
newDependenciesAdded = true;
var depTypeInfo = SceneTemplateProjectSettings.Get().GetDependencyInfo(d);
var dependencyPath = AssetDatabase.GetAssetPath(d);
var instantiationMode = depTypeInfo.defaultInstantiationMode;
if (depTypeInfo.supportsModification && !string.IsNullOrEmpty(dependencyPath))
{
var assetFolder = Path.GetDirectoryName(dependencyPath).Replace("\\", "/");
if (assetFolder == sceneCloneableDependenciesFolder)
{
instantiationMode = TemplateInstantiationMode.Clone;
}
}
return(new DependencyInfo()
{
dependency = d,
instantiationMode = instantiationMode
});
}).ToArray();
var isAssetReadOnly = SceneTemplateUtils.IsAssetReadOnly(scenePath);
if (newDependenciesAdded && !isAssetReadOnly)
{
EditorUtility.SetDirty(this);
AssetDatabase.SaveAssets();
}
return(newDependenciesAdded);
}
private void CreateTemplateDescriptionUI(VisualElement rootContainer)
{
rootContainer.style.flexDirection = FlexDirection.Column;
// Thumbnail container
m_PreviewArea = new SceneTemplatePreviewArea(k_SceneTemplateThumbnailName, m_LastSelectedTemplate?.thumbnail, "No preview thumbnail available");
var thumbnailElement = m_PreviewArea.Element;
rootContainer.Add(thumbnailElement);
rootContainer.RegisterCallback <GeometryChangedEvent>(evt => UpdatePreviewAreaSize());
// Text container
var sceneTitleLabel = new Label();
sceneTitleLabel.name = k_SceneTemplateTitleLabelName;
sceneTitleLabel.AddToClassList(StyleSheetLoader.Styles.classWrappingText);
rootContainer.Add(sceneTitleLabel);
var assetPathSection = new VisualElement();
assetPathSection.name = k_SceneTemplatePathSection;
{
var scenePathLabel = new Label();
scenePathLabel.name = k_SceneTemplatePathName;
scenePathLabel.AddToClassList(StyleSheetLoader.Styles.classWrappingText);
assetPathSection.Add(scenePathLabel);
var editLocateRow = new VisualElement();
editLocateRow.style.flexDirection = FlexDirection.Row;
{
var scenePathLocate = new Label();
scenePathLocate.text = "Locate";
scenePathLocate.AddToClassList(StyleSheetLoader.Styles.classTextLink);
scenePathLocate.RegisterCallback <MouseDownEvent>(e =>
{
if (string.IsNullOrEmpty(scenePathLabel.text))
{
return;
}
var asset = AssetDatabase.LoadAssetAtPath <SceneTemplateAsset>(scenePathLabel.text);
if (!asset)
{
return;
}
EditorApplication.delayCall += () =>
{
EditorWindow.FocusWindowIfItsOpen(SceneTemplateUtils.GetProjectBrowserWindowType());
EditorApplication.delayCall += () => EditorGUIUtility.PingObject(asset);
};
});
editLocateRow.Add(scenePathLocate);
editLocateRow.Add(new Label()
{
text = " | "
});
var scenePathEdit = new Label();
scenePathEdit.name = k_SceneTemplateEditTemplateButtonName;
scenePathEdit.text = "Edit";
scenePathEdit.AddToClassList(StyleSheetLoader.Styles.classTextLink);
scenePathEdit.RegisterCallback <MouseDownEvent>(e =>
{
OnEditTemplate(m_LastSelectedTemplate);
});
editLocateRow.Add(scenePathEdit);
}
assetPathSection.Add(editLocateRow);
}
rootContainer.Add(assetPathSection);
var descriptionSection = new VisualElement();
descriptionSection.name = k_SceneTemplateDescriptionSection;
{
var descriptionLabel = new Label();
descriptionLabel.AddToClassList(StyleSheetLoader.Styles.classHeaderLabel);
descriptionLabel.text = "Description";
descriptionSection.Add(descriptionLabel);
var sceneDescriptionLabel = new Label();
sceneDescriptionLabel.AddToClassList(StyleSheetLoader.Styles.classWrappingText);
sceneDescriptionLabel.name = k_SceneTemplateDescriptionName;
descriptionSection.Add(sceneDescriptionLabel);
}
rootContainer.Add(descriptionSection);
}