/// <summary>
/// Copy any referenced asset packages to the project's folder
/// </summary>
private static void CopyAssetPacks(SessionTemplateGeneratorParameters parameters, Package package)
{
var logger = parameters.Logger;
var presentationPackageFile = PackageStore.Instance.GetPackageFileName("Stride.Samples.Templates", new PackageVersionRange(new PackageVersion(Stride.Samples.Templates.ThisPackageVersion.Current)));
var assetPackagesDir = UDirectory.Combine(presentationPackageFile.GetFullDirectory(), @"Templates\Samples\Templates\Packs");
var assetPacks = parameters.TryGetTag(AssetsKey);
if (assetPacks == null)
{
return;
}
try
{
var outAssetDir = UPath.Combine(package.RootDirectory, (UDirectory)"Assets");
var outResourceDir = UPath.Combine(package.RootDirectory, (UDirectory)"Resources");
foreach (var uDirectory in assetPacks)
{
var packageDir = UDirectory.Combine(assetPackagesDir, uDirectory);
var inputAssetDir = UDirectory.Combine(packageDir, "Assets");
foreach (var directory in FileUtility.EnumerateDirectories(inputAssetDir, SearchDirection.Down))
{
foreach (var file in directory.GetFiles())
{
var relativeFile = new UFile(file.FullName).MakeRelative(inputAssetDir);
var outputFile = UPath.Combine(outAssetDir, relativeFile);
var outputFileDirectory = outputFile.GetParent();
if (!Directory.Exists(outputFileDirectory))
{
Directory.CreateDirectory(outputFileDirectory);
}
File.Copy(file.FullName, outputFile, true);
}
}
var inputResourceDir = UDirectory.Combine(packageDir, "Resources");
foreach (var directory in FileUtility.EnumerateDirectories(inputResourceDir, SearchDirection.Down))
{
foreach (var file in directory.GetFiles())
{
var relativeFile = new UFile(file.FullName).MakeRelative(inputResourceDir);
var outputFile = UPath.Combine(outResourceDir, relativeFile);
{ // Create the output directory if needed
var outputFileDirectory = outputFile.GetParent();
if (!Directory.Exists(outputFileDirectory))
{
Directory.CreateDirectory(outputFileDirectory);
}
}
File.Copy(file.FullName, outputFile, true);
}
}
}
}
catch (Exception ex)
{
logger.Error("Unexpected exception while copying asset packages", ex);
}
}
private static async void Startup(UFile initialSessionPath)
{
try
{
InitializeLanguageSettings();
var serviceProvider = InitializeServiceProvider();
try
{
PackageSessionPublicHelper.FindAndSetMSBuildVersion();
}
catch (Exception e)
{
var message = "Could not find a compatible version of MSBuild.\r\n\r\n" +
"Check that you have a valid installation with the required workloads, or go to [www.visualstudio.com/downloads](https://www.visualstudio.com/downloads) to install a new one.\r\n\r\n" +
e;
await serviceProvider.Get <IEditorDialogService>().MessageBox(message, Core.Presentation.Services.MessageBoxButton.OK, Core.Presentation.Services.MessageBoxImage.Error);
app.Shutdown();
return;
}
// We use a MRU that contains the older version projects to display in the editor
var mru = new MostRecentlyUsedFileCollection(InternalSettings.LoadProfileCopy, InternalSettings.MostRecentlyUsedSessions, InternalSettings.WriteFile);
mru.LoadFromSettings();
var editor = new GameStudioViewModel(serviceProvider, mru);
AssetsPlugin.RegisterPlugin(typeof(XenkoDefaultAssetsPlugin));
AssetsPlugin.RegisterPlugin(typeof(XenkoEditorPlugin));
// Attempt to load the startup session, if available
if (!UPath.IsNullOrEmpty(initialSessionPath))
{
var sessionLoaded = await editor.OpenInitialSession(initialSessionPath);
if (sessionLoaded == true)
{
var mainWindow = new GameStudioWindow(editor);
Application.Current.MainWindow = mainWindow;
WindowManager.ShowMainWindow(mainWindow);
return;
}
}
// No session successfully loaded, open the new/open project window
bool?completed;
// The user might cancel after chosing a template to instantiate, in this case we'll reopen the window
var startupWindow = new ProjectSelectionWindow
{
WindowStartupLocation = WindowStartupLocation.CenterScreen,
ShowInTaskbar = true,
};
var viewModel = new NewOrOpenSessionTemplateCollectionViewModel(serviceProvider, startupWindow);
startupWindow.Templates = viewModel;
startupWindow.ShowDialog();
// The user selected a template to instantiate
if (startupWindow.NewSessionParameters != null)
{
// Clean existing entry in the MRU data
var directory = startupWindow.NewSessionParameters.OutputDirectory;
var name = startupWindow.NewSessionParameters.OutputName;
var mruData = new MRUAdditionalDataCollection(InternalSettings.LoadProfileCopy, GameStudioInternalSettings.MostRecentlyUsedSessionsData, InternalSettings.WriteFile);
mruData.RemoveFile(UFile.Combine(UDirectory.Combine(directory, name), new UFile(name + SessionViewModel.SolutionExtension)));
completed = await editor.NewSession(startupWindow.NewSessionParameters);
}
// The user selected a path to open
else if (startupWindow.ExistingSessionPath != null)
{
completed = await editor.OpenSession(startupWindow.ExistingSessionPath);
}
// The user cancelled from the new/open project window, so exit the application
else
{
completed = true;
}
if (completed != true)
{
var windowsClosed = new List <Task>();
foreach (var window in Application.Current.Windows.Cast <Window>().Where(x => x.IsLoaded))
{
var tcs = new TaskCompletionSource <int>();
window.Unloaded += (s, e) => tcs.SetResult(0);
windowsClosed.Add(tcs.Task);
}
await Task.WhenAll(windowsClosed);
// When a project has been partially loaded, it might already have initialized some plugin that could conflict with
// the next attempt to start something. Better start the application again.
var commandLine = string.Join(" ", Environment.GetCommandLineArgs().Skip(1).Select(x => $"\"{x}\""));
var process = new Process {
StartInfo = new ProcessStartInfo(typeof(Program).Assembly.Location, commandLine)
};
process.Start();
app.Shutdown();
return;
}
if (editor.Session != null)
{
// If a session was correctly loaded, show the main window
var mainWindow = new GameStudioWindow(editor);
Application.Current.MainWindow = mainWindow;
WindowManager.ShowMainWindow(mainWindow);
}
else
{
// Otherwise, exit.
app.Shutdown();
}
}
catch (Exception)
{
app.Shutdown();
}
}
private static void GenerateUnitTestProject(string outputDirectory, string templateFile, string name)
{
var projectTemplate = ProjectTemplate.Load(templateFile);
// Force reference to Paradox.Assets (to have acess to SolutionPlatform)
projectTemplate.Assemblies.Add(typeof(GraphicsProfile).Assembly.FullName);
projectTemplate.Assemblies.Add(typeof(ParadoxConfig).Assembly.FullName);
var options = new Dictionary <string, object>();
var session = new PackageSession();
var result = new LoggerResult();
var templateGeneratorParameters = new TemplateGeneratorParameters();
templateGeneratorParameters.OutputDirectory = outputDirectory;
templateGeneratorParameters.Session = session;
templateGeneratorParameters.Name = name;
templateGeneratorParameters.Logger = result;
templateGeneratorParameters.Description = new TemplateDescription();
PackageUnitTestGenerator.Default.Generate(templateGeneratorParameters);
if (result.HasErrors)
{
Console.WriteLine("Error generating package: {0}", result.ToText());
return;
}
var package = templateGeneratorParameters.Package;
var previousCurrent = session.CurrentPackage;
session.CurrentPackage = package;
// Compute Paradox Sdk relative path
// We are supposed to be in standard output binary folder, so Paradox root should be at ..\..
var paradoxPath = UDirectory.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), new UDirectory(@"..\.."));
var paradoxRelativePath = new UDirectory(paradoxPath)
.MakeRelative(outputDirectory)
.ToString()
.Replace('/', '\\');
paradoxRelativePath = paradoxRelativePath.TrimEnd('\\');
options["Namespace"] = name;
options["Package"] = package;
options["Platforms"] = new List <SolutionPlatform>(AssetRegistry.SupportedPlatforms);
options["ParadoxSdkRelativeDir"] = paradoxRelativePath;
// Generate project template
var projectGuid = Guid.NewGuid();
result = projectTemplate.Generate(outputDirectory, name, projectGuid, options);
if (result.HasErrors)
{
Console.WriteLine("Error generating solution: {0}", result.ToText());
return;
}
var sharedProfile = package.Profiles.FindSharedProfile();
// Setup the assets folder
Directory.CreateDirectory(UPath.Combine(outputDirectory, (UDirectory)"Assets/Shared"));
// Add Windows test as Shared library
var projectWindowsRef = new ProjectReference();
projectWindowsRef.Id = projectGuid;
projectWindowsRef.Location = UPath.Combine(outputDirectory, (UFile)(name + ".Windows.csproj"));
projectWindowsRef.Type = SiliconStudio.Assets.ProjectType.Library;
sharedProfile.ProjectReferences.Add(projectWindowsRef);
// Generate executable projects for each platform
foreach (var platform in AssetRegistry.SupportedPlatforms)
{
var platformProfile = new PackageProfile(platform.Name)
{
Platform = platform.Type
};
platformProfile.AssetFolders.Add(new AssetFolder("Assets/" + platform.Name));
// Log progress
var projectName = name + "." + platform.Type;
// Create project reference
var projectPlatformRef = new ProjectReference();
projectPlatformRef.Id = projectGuid;
projectPlatformRef.Location = UPath.Combine(outputDirectory, (UFile)(projectName + ".csproj"));
projectPlatformRef.Type = SiliconStudio.Assets.ProjectType.Executable;
platformProfile.ProjectReferences.Add(projectPlatformRef);
// Add build configuration per platform
platform.Properties.CopyTo(platformProfile.Properties, true);
package.Profiles.Add(platformProfile);
}
session.CurrentPackage = previousCurrent;
result = session.Save();
if (result.HasErrors)
{
Console.WriteLine("Error saving package: {0}", result.ToText());
return;
}
}
