internal static void Initialize() { AssemblyRegistry.Register(typeof(Module).Assembly, AssemblyCommonCategories.Assets); RuntimeHelpers.RunModuleConstructor(typeof(Asset).Module.ModuleHandle); PackageSessionPublicHelper.FindAndSetMSBuildVersion(); }
/// <summary> /// Given a project <paramref name="name"/> located in <paramref name="outputDirectory"/> try to extract the /// ProjectGuid setting. If file does not exist or does not contain this property, a new Guid is generated. /// </summary> /// <param name="outputDirectory">Location of the project <paramref name="name"/></param> /// <param name="name">Name on disk of the project file</param> /// <param name="guid">Existing Guid for the project, otherwise a new one</param> private static void GetExistingGuid(string outputDirectory, string name, out Guid guid) { // Initialize to new Guid to avoid complex logic after. guid = Guid.NewGuid(); try { if (!PackageSessionPublicHelper.FindAndSetMSBuildVersion()) { throw new InvalidOperationException(); } Microsoft.Build.Evaluation.Project p = new Microsoft.Build.Evaluation.Project(Path.Combine(outputDirectory, name)); var property = p.Properties.Where((prop => prop.Name == "ProjectGuid")).FirstOrDefault(); if (property != null) { Guid.TryParse(property.EvaluatedValue, out guid); } } catch (Exception) { // Ignore exception } }
internal static void Initialize() { // Override search path since we are in a unit test directory DirectoryHelper.PackageDirectoryOverride = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"..\..\..\.."); PackageSessionPublicHelper.FindAndSetMSBuildVersion(); }
internal static void Initialize() { // Override search path since we are in a unit test directory DirectoryHelper.PackageDirectoryOverride = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"..\..\..\.."); AssemblyRegistry.Register(typeof(Module).Assembly, AssemblyCommonCategories.Assets); RuntimeHelpers.RunModuleConstructor(typeof(Asset).Module.ModuleHandle); PackageSessionPublicHelper.FindAndSetMSBuildVersion(); }
public SampleTestFixture(UDirectory outputPath, Guid templateGuid) { // Setup MSBuild PackageSessionPublicHelper.FindAndSetMSBuildVersion(); var logger = new LoggerResult(); var sampleName = outputPath.GetDirectoryName(); var session = GenerateSample(outputPath, templateGuid, sampleName, logger); CompileSample(logger, sampleName, session); }
public void TestBasicPackageCreateSaveLoad() { PackageSessionPublicHelper.FindAndSetMSBuildVersion(); var dirPath = DirectoryTestBase + @"TestBasicPackageCreateSaveLoad"; string testGenerated1 = Path.Combine(dirPath, "TestPackage_TestBasicPackageCreateSaveLoad_Generated1.sdpkg"); // Force the PackageId to be the same each time we run the test // Usually the PackageId is unique and generated each time we create a new project var project = new Package { FullPath = testGenerated1 }; project.AssetFolders.Clear(); project.AssetFolders.Add(new AssetFolder(".")); var session = new PackageSession(project); // Write the solution when saving session.SolutionPath = Path.Combine(dirPath, "TestPackage_TestBasicPackageCreateSaveLoad_Generated1.sln"); // Delete the solution before saving it if (File.Exists(session.SolutionPath)) { File.Delete(session.SolutionPath); } var result = new LoggerResult(); session.Save(result); Assert.False(result.HasErrors); // Reload the raw package and if UFile and UDirectory were saved relative var rawPackage = AssetFileSerializer.Load <Package>(testGenerated1).Asset; var rawSourceFolder = rawPackage.AssetFolders.FirstOrDefault(); Assert.NotNull(rawSourceFolder); Assert.Equal(".", (string)rawSourceFolder.Path); // Reload the package directly from the sdpkg var project2Result = PackageSession.Load(testGenerated1); AssertResult(project2Result); var project2 = project2Result.Session.LocalPackages.FirstOrDefault(); Assert.NotNull(project2); Assert.True(project2.AssetFolders.Count > 0); var sourceFolder = project.AssetFolders.First().Path; Assert.Equal(sourceFolder, project2.AssetFolders.First().Path); }
private BuildResultCode BuildMaster() { 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; builderOptions.Logger.Error(message); return(BuildResultCode.BuildError); } AssetCompilerContext context = null; PackageSession projectSession = null; try { var sessionLoadParameters = new PackageLoadParameters { AutoCompileProjects = !builderOptions.DisableAutoCompileProjects, ExtraCompileProperties = builderOptions.ExtraCompileProperties, RemoveUnloadableObjects = true, BuildConfiguration = builderOptions.ProjectConfiguration, }; // Loads the root Package var projectSessionResult = PackageSession.Load(builderOptions.PackageFile, sessionLoadParameters); projectSessionResult.CopyTo(builderOptions.Logger); if (projectSessionResult.HasErrors) { return(BuildResultCode.BuildError); } projectSession = projectSessionResult.Session; // Find loaded package (either xkpkg or csproj) -- otherwise fallback to first one var packageFile = (UFile)builderOptions.PackageFile; var package = projectSession.LocalPackages.FirstOrDefault(x => x.FullPath == packageFile || (x.Container is SolutionProject project && project.FullPath == packageFile)) ?? projectSession.LocalPackages.First(); // Setup variables var buildDirectory = builderOptions.BuildDirectory; var outputDirectory = builderOptions.OutputDirectory; // Process game settings asset var gameSettingsAsset = package.GetGameSettingsAsset(); if (gameSettingsAsset == null) { builderOptions.Logger.Warning($"Could not find game settings asset at location [{GameSettingsAsset.GameSettingsLocation}]. Use a Default One"); gameSettingsAsset = GameSettingsFactory.Create(); } // Create context context = new AssetCompilerContext { Platform = builderOptions.Platform, CompilationContext = typeof(AssetCompilationContext), BuildConfiguration = builderOptions.ProjectConfiguration, Package = package, }; // Command line properties foreach (var property in builderOptions.Properties) { context.OptionProperties.Add(property.Key, property.Value); } // Set current game settings context.SetGameSettingsAsset(gameSettingsAsset); // Builds the project var assetBuilder = new PackageCompiler(new RootPackageAssetEnumerator(package)); assetBuilder.AssetCompiled += RegisterBuildStepProcessedHandler; context.Properties.Set(BuildAssetNode.VisitRuntimeTypes, true); var assetBuildResult = assetBuilder.Prepare(context); assetBuildResult.CopyTo(builderOptions.Logger); if (assetBuildResult.HasErrors) { return(BuildResultCode.BuildError); } // Setup the remote process build var remoteBuilderHelper = new PackageBuilderRemoteHelper(projectSession.AssemblyContainer, builderOptions); var indexName = "index." + package.Meta.Name; // Add runtime identifier (if any) to avoid clash when building multiple at the same time (this happens when using ExtrasBuildEachRuntimeIdentifier feature of MSBuild.Sdk.Extras) if (builderOptions.Properties.TryGetValue("RuntimeIdentifier", out var runtimeIdentifier)) { indexName += $".{runtimeIdentifier}"; } // Create the builder builder = new Builder(builderOptions.Logger, buildDirectory, indexName) { ThreadCount = builderOptions.ThreadCount, TryExecuteRemote = remoteBuilderHelper.TryExecuteRemote }; builder.MonitorPipeNames.AddRange(builderOptions.MonitorPipeNames); // Add build steps generated by AssetBuilder builder.Root.Add(assetBuildResult.BuildSteps); // Run builder var result = builder.Run(Builder.Mode.Build); builder.WriteIndexFile(false); // Fill list of bundles var bundlePacker = new BundlePacker(); bundlePacker.Build(builderOptions.Logger, projectSession, indexName, outputDirectory, builder.DisableCompressionIds, context.GetCompilationMode() != CompilationMode.AppStore); return(result); } finally { builder?.Dispose(); // Dispose the session (in order to unload assemblies) projectSession?.Dispose(); context?.Dispose(); // Make sure that MSBuild doesn't hold anything else VSProjectHelper.Reset(); } }
public int Run(string[] args) { // This is used by ExecServer to retrieve the logs directly without using the console redirect (which is not working well // in a multi-domain scenario) var redirectLogToAppDomainAction = AppDomain.CurrentDomain.GetData("AppDomainLogToAction") as Action <string, ConsoleColor>; clock = Stopwatch.StartNew(); // TODO this is hardcoded. Check how to make this dynamic instead. RuntimeHelpers.RunModuleConstructor(typeof(IProceduralModel).Module.ModuleHandle); RuntimeHelpers.RunModuleConstructor(typeof(MaterialKeys).Module.ModuleHandle); RuntimeHelpers.RunModuleConstructor(typeof(SpriteFontAsset).Module.ModuleHandle); RuntimeHelpers.RunModuleConstructor(typeof(ModelAsset).Module.ModuleHandle); RuntimeHelpers.RunModuleConstructor(typeof(SpriteStudioAnimationAsset).Module.ModuleHandle); RuntimeHelpers.RunModuleConstructor(typeof(ParticleSystem).Module.ModuleHandle); //var project = new Package(); //project.Save("test.sdpkg"); //Thread.Sleep(10000); //var spriteFontAsset = StaticFontAsset.New(); //Content.Save("test.sdfnt", spriteFontAsset); //project.Refresh(); //args = new string[] { "test.sdpkg", "-o:app_data", "-b:tmp", "-t:1" }; var exeName = Path.GetFileName(Assembly.GetExecutingAssembly().Location); var showHelp = false; var packMode = false; var buildEngineLogger = GlobalLogger.GetLogger("BuildEngine"); var options = new PackageBuilderOptions(new ForwardingLoggerResult(buildEngineLogger)); var p = new OptionSet { "Copyright (c) Stride contributors (https://stride3d.net) and Silicon Studio Corp. (https://www.siliconstudio.co.jp) All Rights Reserved", "Stride Build Tool - Version: " + String.Format( "{0}.{1}.{2}", typeof(Program).Assembly.GetName().Version.Major, typeof(Program).Assembly.GetName().Version.Minor, typeof(Program).Assembly.GetName().Version.Build) + string.Empty, string.Format("Usage: {0} inputPackageFile [options]* -b buildPath", exeName), string.Empty, "=== Options ===", string.Empty, { "h|help", "Show this message and exit", v => showHelp = v != null }, { "v|verbose", "Show more verbose progress logs", v => options.Verbose = v != null }, { "d|debug", "Show debug logs (imply verbose)", v => options.Debug = v != null }, { "log", "Enable file logging", v => options.EnableFileLogging = v != null }, { "disable-auto-compile", "Disable auto-compile of projects", v => options.DisableAutoCompileProjects = v != null }, { "project-configuration=", "Project configuration", v => options.ProjectConfiguration = v }, { "platform=", "Platform name", v => options.Platform = (PlatformType)Enum.Parse(typeof(PlatformType), v) }, { "solution-file=", "Solution File Name", v => options.SolutionFile = v }, { "package-id=", "Package Id from the solution file", v => options.PackageId = Guid.Parse(v) }, { "package-file=", "Input Package File Name", v => options.PackageFile = v }, { "o|output-path=", "Output path", v => options.OutputDirectory = v }, { "b|build-path=", "Build path", v => options.BuildDirectory = v }, { "log-file=", "Log build in a custom file.", v => { options.EnableFileLogging = v != null; options.CustomLogFileName = v; } }, { "log-pipe=", "Log pipe.", v => { if (!string.IsNullOrEmpty(v)) { options.LogPipeNames.Add(v); } } }, { "monitor-pipe=", "Monitor pipe.", v => { if (!string.IsNullOrEmpty(v)) { options.MonitorPipeNames.Add(v); } } }, { "slave=", "Slave pipe", v => options.SlavePipe = v }, // Benlitz: I don't think this should be documented { "server=", "This Compiler is launched as a server", v => { } }, { "pack", "Special mode to copy assets and resources in a folder for NuGet packaging", v => packMode = true }, { "t|threads=", "Number of threads to create. Default value is the number of hardware threads available.", v => options.ThreadCount = int.Parse(v) }, { "test=", "Run a test session.", v => options.TestName = v }, { "property:", "Properties. Format is name1=value1;name2=value2", v => { if (!string.IsNullOrEmpty(v)) { foreach (var nameValue in v.Split(new [] { ';' }, StringSplitOptions.RemoveEmptyEntries)) { var equalIndex = nameValue.IndexOf('='); if (equalIndex == -1) { throw new OptionException("Expect name1=value1;name2=value2 format.", "property"); } options.Properties.Add(nameValue.Substring(0, equalIndex), nameValue.Substring(equalIndex + 1)); } } } }, { "compile-property:", "Compile properties. Format is name1=value1;name2=value2", v => { if (!string.IsNullOrEmpty(v)) { if (options.ExtraCompileProperties == null) { options.ExtraCompileProperties = new Dictionary <string, string>(); } foreach (var nameValue in v.Split(new [] { ';' }, StringSplitOptions.RemoveEmptyEntries)) { var equalIndex = nameValue.IndexOf('='); if (equalIndex == -1) { throw new OptionException("Expect name1=value1;name2=value2 format.", "property"); } options.ExtraCompileProperties.Add(nameValue.Substring(0, equalIndex), nameValue.Substring(equalIndex + 1)); } } } }, { "reattach-debugger=", "Reattach to a Visual Studio debugger", v => { int debuggerProcessId; if (!string.IsNullOrEmpty(v) && int.TryParse(v, out debuggerProcessId)) { if (!Debugger.IsAttached) { using (var debugger = VisualStudioDebugger.GetByProcess(debuggerProcessId)) { debugger?.Attach(); } } } } }, }; TextWriterLogListener fileLogListener = null; BuildResultCode exitCode; RemoteLogForwarder assetLogger = null; try { var unexpectedArgs = p.Parse(args); // Set remote logger assetLogger = new RemoteLogForwarder(options.Logger, options.LogPipeNames); GlobalLogger.GlobalMessageLogged += assetLogger; // Activate proper log level buildEngineLogger.ActivateLog(options.LoggerType); // Output logs to the console with colored messages if (options.SlavePipe == null && !options.LogPipeNames.Any()) { if (redirectLogToAppDomainAction != null) { globalLoggerOnGlobalMessageLogged = new LogListenerRedirectToAction(redirectLogToAppDomainAction); } else { globalLoggerOnGlobalMessageLogged = new ConsoleLogListener { LogMode = ConsoleLogMode.Always }; } globalLoggerOnGlobalMessageLogged.TextFormatter = FormatLog; GlobalLogger.GlobalMessageLogged += globalLoggerOnGlobalMessageLogged; } if (unexpectedArgs.Any()) { throw new OptionException("Unexpected arguments [{0}]".ToFormat(string.Join(", ", unexpectedArgs)), "args"); } try { options.ValidateOptions(); } catch (ArgumentException ex) { throw new OptionException(ex.Message, ex.ParamName); } if (showHelp) { p.WriteOptionDescriptions(Console.Out); return((int)BuildResultCode.Successful); } else if (packMode) { PackageSessionPublicHelper.FindAndSetMSBuildVersion(); var csprojFile = options.PackageFile; var intermediatePackagePath = options.BuildDirectory; var generatedItems = new List <(string SourcePath, string PackagePath)>(); var logger = new LoggerResult(); if (!PackAssetsHelper.Run(logger, csprojFile, intermediatePackagePath, generatedItems)) { foreach (var message in logger.Messages) { Console.WriteLine(message); } return((int)BuildResultCode.BuildError); } foreach (var generatedItem in generatedItems) { Console.WriteLine($"{generatedItem.SourcePath}|{generatedItem.PackagePath}"); } return((int)BuildResultCode.Successful); } // Also write logs from master process into a file if (options.SlavePipe == null) { if (options.EnableFileLogging) { string logFileName = options.CustomLogFileName; if (string.IsNullOrEmpty(logFileName)) { string inputName = Path.GetFileNameWithoutExtension(options.PackageFile); logFileName = "Logs/Build-" + inputName + "-" + DateTime.Now.ToString("yy-MM-dd-HH-mm") + ".txt"; } string dirName = Path.GetDirectoryName(logFileName); if (dirName != null) { Directory.CreateDirectory(dirName); } fileLogListener = new TextWriterLogListener(new FileStream(logFileName, FileMode.Create)) { TextFormatter = FormatLog }; GlobalLogger.GlobalMessageLogged += fileLogListener; } options.Logger.Info("BuildEngine arguments: " + string.Join(" ", args)); options.Logger.Info("Starting builder."); } else { IsSlave = true; } if (!string.IsNullOrEmpty(options.TestName)) { var test = new TestSession(); test.RunTest(options.TestName, options.Logger); exitCode = BuildResultCode.Successful; } else { builder = new PackageBuilder(options); if (!IsSlave && redirectLogToAppDomainAction == null) { Console.CancelKeyPress += OnConsoleOnCancelKeyPress; } exitCode = builder.Build(); } } catch (OptionException e) { options.Logger.Error($"Command option '{e.OptionName}': {e.Message}"); exitCode = BuildResultCode.CommandLineError; } catch (Exception e) { options.Logger.Error($"Unhandled exception", e); exitCode = BuildResultCode.BuildError; } finally { // Flush and close remote logger if (assetLogger != null) { GlobalLogger.GlobalMessageLogged -= assetLogger; assetLogger.Dispose(); } if (fileLogListener != null) { GlobalLogger.GlobalMessageLogged -= fileLogListener; fileLogListener.LogWriter.Close(); } // Output logs to the console with colored messages if (globalLoggerOnGlobalMessageLogged != null) { GlobalLogger.GlobalMessageLogged -= globalLoggerOnGlobalMessageLogged; } if (builder != null && !IsSlave && redirectLogToAppDomainAction == null) { Console.CancelKeyPress -= OnConsoleOnCancelKeyPress; } // Reset cache hold by YamlSerializer YamlSerializer.Default.ResetCache(); } return((int)exitCode); }
internal static void Initialize() { PackageSessionPublicHelper.FindAndSetMSBuildVersion(); }
private BuildResultCode BuildMaster() { // Only querying graphics platform, let's load package, print it and exit if (builderOptions.GetGraphicsPlatform) { return(BuildGetGraphicsPlatform()); } AssetCompilerContext context = null; PackageSession projectSession = null; try { if (!PackageSessionPublicHelper.FindAndSetMSBuildVersion()) { 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."; builderOptions.Logger.Error(message); return(BuildResultCode.BuildError); } var sessionLoadParameters = new PackageLoadParameters { AutoCompileProjects = !builderOptions.DisableAutoCompileProjects, ExtraCompileProperties = builderOptions.ExtraCompileProperties, RemoveUnloadableObjects = true, }; // Loads the root Package var projectSessionResult = PackageSession.Load(builderOptions.PackageFile, sessionLoadParameters); projectSessionResult.CopyTo(builderOptions.Logger); if (projectSessionResult.HasErrors) { return(BuildResultCode.BuildError); } projectSession = projectSessionResult.Session; // Check build configuration var package = projectSession.LocalPackages.Last(); // Check build profile var buildProfile = package.Profiles.FirstOrDefault(pair => pair.Name == builderOptions.BuildProfile); if (buildProfile == null) { builderOptions.Logger.Error($"Unable to find profile [{builderOptions.BuildProfile}] in package [{package.FullPath}]"); return(BuildResultCode.BuildError); } // Setup variables var buildDirectory = builderOptions.BuildDirectory; var outputDirectory = builderOptions.OutputDirectory; // Process game settings asset var gameSettingsAsset = package.GetGameSettingsAsset(); if (gameSettingsAsset == null) { builderOptions.Logger.Warning($"Could not find game settings asset at location [{GameSettingsAsset.GameSettingsLocation}]. Use a Default One"); gameSettingsAsset = GameSettingsFactory.Create(); } // Create context context = new AssetCompilerContext { Profile = builderOptions.BuildProfile, Platform = builderOptions.Platform, CompilationContext = typeof(AssetCompilationContext), BuildConfiguration = builderOptions.ProjectConfiguration }; // Command line properties foreach (var property in builderOptions.Properties) { context.OptionProperties.Add(property.Key, property.Value); } // Set current game settings context.SetGameSettingsAsset(gameSettingsAsset); // Builds the project var assetBuilder = new PackageCompiler(new RootPackageAssetEnumerator(package)); assetBuilder.AssetCompiled += RegisterBuildStepProcessedHandler; context.Properties.Set(BuildAssetNode.VisitRuntimeTypes, true); var assetBuildResult = assetBuilder.Prepare(context); assetBuildResult.CopyTo(builderOptions.Logger); if (assetBuildResult.HasErrors) { return(BuildResultCode.BuildError); } // Setup the remote process build var remoteBuilderHelper = new PackageBuilderRemoteHelper(projectSession.AssemblyContainer, builderOptions); // Create the builder var indexName = "index." + builderOptions.BuildProfile; builder = new Builder(builderOptions.Logger, buildDirectory, builderOptions.BuildProfile, indexName) { ThreadCount = builderOptions.ThreadCount, TryExecuteRemote = remoteBuilderHelper.TryExecuteRemote }; builder.MonitorPipeNames.AddRange(builderOptions.MonitorPipeNames); // Add build steps generated by AssetBuilder builder.Root.Add(assetBuildResult.BuildSteps); // Run builder var result = builder.Run(Builder.Mode.Build); builder.WriteIndexFile(false); // Fill list of bundles var bundlePacker = new BundlePacker(); bundlePacker.Build(builderOptions.Logger, projectSession, buildProfile, indexName, outputDirectory, builder.DisableCompressionIds, context.GetCompilationMode() != CompilationMode.AppStore); return(result); } finally { builder?.Dispose(); // Dispose the session (in order to unload assemblies) projectSession?.Dispose(); context?.Dispose(); // Make sure that MSBuild doesn't hold anything else VSProjectHelper.Reset(); } }
public void TestXkslGeneration() { PackageSessionPublicHelper.FindAndSetMSBuildVersion(); // Create temporary folder string tempDirectory = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()); Directory.CreateDirectory(tempDirectory); // Make sure solution is closed (i.e. previous test failure) var solution = (Solution2)dte.Solution; solution.Close(); // Create project try { // Create new game var session = GenerateNewGame(tempDirectory); solution.Open(session.SolutionPath); // Find NewGame.Game project var newGameFolder = solution.Projects.OfType <EnvDTE.Project>().First(); var newGameProject = newGameFolder.ProjectItems.OfType <ProjectItem>().Select(x => x.SubProject).First(x => x.Name == $"{session.Packages.First().Meta.Name}.Game"); // Add sdsl file var sdslItem = newGameProject.ProjectItems.AddFromFileCopy(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TestGenerator.sdsl")); // Make sure custom tool is properly set Assert.Equal("StrideShaderKeyGenerator", sdslItem.Properties.Item("CustomTool").Value); // Wait for cs file to be generated (up to 5 seconds) // TODO: Is there a better way to wait for it? for (int i = 0; i < 50; ++i) { if (sdslItem.ProjectItems.Count > 0) { break; } Thread.Sleep(100); } // Get generated cs file Assert.Equal(1, sdslItem.ProjectItems.Count); var shaderGeneratedCsharpItem = sdslItem.ProjectItems.OfType <ProjectItem>().First(); var shaderGeneratedCsharpFile = shaderGeneratedCsharpItem.FileNames[0]; // Check content // Note: we could do more advanced code analysis, but just check a few expected stuff is probably good enough to detect if there was no crash generating it var shaderGeneratedCsharpContent = File.ReadAllText(shaderGeneratedCsharpFile); Assert.Contains($"{nameof(ValueParameterKey<float>)}<float> TestFloat", shaderGeneratedCsharpContent); Assert.Contains($"{nameof(ValueParameterKey<Color3>)}<{nameof(Color3)}> TestColor", shaderGeneratedCsharpContent); } finally { solution.Close(); try { Directory.Delete(tempDirectory, true); } catch { } } }
public StrideCommands() { PackageSessionPublicHelper.FindAndSetMSBuildVersion(); }
public void TestBasicPackageCreateSaveLoad() { PackageSessionPublicHelper.FindAndSetMSBuildVersion(); var dirPath = DirectoryTestBase + @"TestBasicPackageCreateSaveLoad"; string testGenerated1 = Path.Combine(dirPath, "TestPackage_TestBasicPackageCreateSaveLoad_Generated1.xkpkg"); string testGenerated2 = Path.Combine(dirPath, "TestPackage_TestBasicPackageCreateSaveLoad_Generated2.xkpkg"); string referenceFilePath = Path.Combine(dirPath, "TestPackage_TestBasicPackageCreateSaveLoad_Reference.xkpkg"); // Force the PackageId to be the same each time we run the test // Usually the PackageId is unique and generated each time we create a new project var project = new Package { Id = Guid.Empty, FullPath = testGenerated1 }; var sharedProfile = new PackageProfile("Shared", new AssetFolder(".")); project.Profiles.Add(sharedProfile); var projectReference = new ProjectReference(Guid.Empty, Path.Combine(dirPath, "test.csproj"), ProjectType.Executable); sharedProfile.ProjectReferences.Add(projectReference); var session = new PackageSession(project); // Write the solution when saving session.SolutionPath = Path.Combine(dirPath, "TestPackage_TestBasicPackageCreateSaveLoad_Generated1.sln"); // Delete the solution before saving it if (File.Exists(session.SolutionPath)) { File.Delete(session.SolutionPath); } var result = new LoggerResult(); session.Save(result); Assert.False(result.HasErrors); // Reload the raw package and if UFile and UDirectory were saved relative var rawPackage = AssetFileSerializer.Load <Package>(testGenerated1).Asset; var rawPackageSharedProfile = rawPackage.Profiles.FirstOrDefault(); Assert.NotNull(rawPackageSharedProfile); var rawSourceFolder = rawPackage.Profiles.First().AssetFolders.FirstOrDefault(); Assert.NotNull(rawSourceFolder); Assert.Equal(".", (string)rawSourceFolder.Path); Assert.Equal("test.csproj", (string)rawPackageSharedProfile.ProjectReferences[0].Location); // Reload the package directly from the xkpkg var project2Result = PackageSession.Load(testGenerated1); AssertResult(project2Result); var project2 = project2Result.Session.LocalPackages.FirstOrDefault(); Assert.NotNull(project2); Assert.Equal(project.Id, project2.Id); Assert.True(project2.Profiles.Count > 0); Assert.True(project2.Profiles.First().AssetFolders.Count > 0); Assert.Equal(project2, project2Result.Session.CurrentPackage); // Check that the current package is setup when loading a single package var sourceFolder = project.Profiles.First().AssetFolders.First().Path; Assert.Equal(sourceFolder, project2.Profiles.First().AssetFolders.First().Path); // Reload the package from the sln var sessionResult = PackageSession.Load(session.SolutionPath); Assert.False(sessionResult.HasErrors); var sessionReload = sessionResult.Session; Assert.Equal(1, sessionReload.LocalPackages.Count()); Assert.Equal(project.Id, sessionReload.LocalPackages.First().Id); Assert.Equal(1, sessionReload.LocalPackages.First().Profiles.Count); var sharedProfileReload = sessionReload.LocalPackages.First().Profiles.First(); Assert.Equal(1, sharedProfileReload.ProjectReferences.Count); Assert.Equal(projectReference, sharedProfileReload.ProjectReferences[0]); }
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; } // Running first time? If yes, create nuget redirect package. var packageVersion = new PackageVersion(XenkoVersion.NuGetVersion); if (PackageStore.Instance.IsDevelopmentStore) { await PackageStore.Instance.CheckDeveloperTargetRedirects("Xenko", packageVersion, PackageStore.Instance.InstallationPath); } // 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, XenkoGameStudio.EditorVersionMajor, true); 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 int Main(string[] args) { if (args.Length < 2) { Console.WriteLine("Invalid number of arguments.\n"); Console.WriteLine("Usage: Xenko.SamplesBootstrapper.exe SampleName SampleGuid"); return(1); } PackageSessionPublicHelper.FindAndSetMSBuildVersion(); Console.WriteLine(@"Bootstrapping: " + args[0]); var session = new PackageSession(); var xenkoPkg = PackageStore.Instance.DefaultPackage; Console.WriteLine("Using Xenko from " + xenkoPkg.FullPath + "..."); var xenkoDir = Path.GetDirectoryName(xenkoPkg.FullPath); var generator = TemplateSampleGenerator.Default; var logger = new LoggerResult(); // Ensure progress is shown while it is happening. logger.MessageLogged += (sender, eventArgs) => Console.WriteLine(eventArgs.Message.Text); var parameters = new SessionTemplateGeneratorParameters { Session = session }; parameters.Unattended = true; TemplateSampleGenerator.SetParameters(parameters, AssetRegistry.SupportedPlatforms.Select(x => new SelectedSolutionPlatform(x, x.Templates.FirstOrDefault())).ToList()); var outputPath = UPath.Combine(new UDirectory(xenkoDir), new UDirectory("samplesGenerated")); outputPath = UPath.Combine(outputPath, new UDirectory(args[0])); session.SolutionPath = UPath.Combine <UFile>(outputPath, args[0] + ".sln"); // Properly delete previous version if (Directory.Exists(outputPath)) { try { Directory.Delete(outputPath, true); } catch (Exception) { logger.Warning($"Unable to delete directory [{outputPath}]"); } } var xenkoTemplates = xenkoPkg.Templates; parameters.Description = xenkoTemplates.First(x => x.Id == new Guid(args[1])); parameters.Name = args[0]; parameters.Namespace = args[0]; parameters.OutputDirectory = outputPath; parameters.Logger = logger; if (!generator.PrepareForRun(parameters).Result) { logger.Error("PrepareForRun returned false for the TemplateSampleGenerator"); } if (!generator.Run(parameters)) { logger.Error("Run returned false for the TemplateSampleGenerator"); } var updaterTemplate = xenkoTemplates.First(x => x.FullPath.ToString().EndsWith("UpdatePlatforms.xktpl")); parameters.Description = updaterTemplate; return(logger.HasErrors ? 1 : 0); }
public void CompilerVisitRuntimeType() { PackageSessionPublicHelper.FindAndSetMSBuildVersion(); var package = new Package(); // ReSharper disable once UnusedVariable - we need a package session to compile var packageSession = new PackageSession(package); var otherAssets = new List <AssetItem> { new AssetItem("contentRB", new MyAssetContentType(0), package), new AssetItem("contentRA", new MyAssetContentType(1), package), new AssetItem("content0B", new MyAssetContentType(2), package), new AssetItem("content0M", new MyAssetContentType(3), package), new AssetItem("content0A", new MyAssetContentType(4), package), new AssetItem("content1B", new MyAssetContentType(5), package), new AssetItem("content1M", new MyAssetContentType(6), package), new AssetItem("content1A", new MyAssetContentType(7), package), new AssetItem("content2B", new MyAssetContentType(8), package), new AssetItem("content2M", new MyAssetContentType(9), package), new AssetItem("content2A", new MyAssetContentType(10), package), new AssetItem("content3B", new MyAssetContentType(11), package), new AssetItem("content3M", new MyAssetContentType(12), package), new AssetItem("content3A", new MyAssetContentType(13), package), new AssetItem("content4B", new MyAssetContentType(14), package), new AssetItem("content4M", new MyAssetContentType(15), package), new AssetItem("content4A", new MyAssetContentType(16), package), }; var assetToVisit = new MyAsset1(); assetToVisit.Before = AttachedReferenceManager.CreateProxyObject <MyContentType>(otherAssets[0].Id, otherAssets[0].Location); assetToVisit.Zafter = AttachedReferenceManager.CreateProxyObject <MyContentType>(otherAssets[1].Id, otherAssets[1].Location); assetToVisit.RuntimeTypes.Add(CreateRuntimeType(otherAssets[2], otherAssets[3], otherAssets[4])); assetToVisit.RuntimeTypes.Add(CreateRuntimeType(otherAssets[5], otherAssets[6], otherAssets[7])); assetToVisit.RuntimeTypes.Add(CreateRuntimeType(otherAssets[8], otherAssets[9], otherAssets[10])); assetToVisit.RuntimeTypes.Add(CreateRuntimeType(otherAssets[11], otherAssets[12], otherAssets[13])); assetToVisit.RuntimeTypes.Add(CreateRuntimeType(otherAssets[14], otherAssets[15], otherAssets[16])); assetToVisit.RuntimeTypes[0].A = assetToVisit.RuntimeTypes[1]; assetToVisit.RuntimeTypes[0].B = assetToVisit.RuntimeTypes[2]; assetToVisit.RuntimeTypes[1].A = assetToVisit.RuntimeTypes[3]; assetToVisit.RuntimeTypes[1].B = assetToVisit.RuntimeTypes[4]; otherAssets.ForEach(x => package.Assets.Add(x)); var assetItem = new AssetItem("asset", assetToVisit, package); package.Assets.Add(assetItem); package.RootAssets.Add(new AssetReference(assetItem.Id, assetItem.Location)); // Create context var context = new AssetCompilerContext { CompilationContext = typeof(AssetCompilationContext) }; // Builds the project var assetBuilder = new PackageCompiler(new RootPackageAssetEnumerator(package)); context.Properties.Set(BuildAssetNode.VisitRuntimeTypes, true); var assetBuildResult = assetBuilder.Prepare(context); Assert.Equal(16, assetBuildResult.BuildSteps.Count); }