public void Generate(TemplateGeneratorParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
parameters.Validate();
var name = parameters.Name;
var outputDirectory = parameters.OutputDirectory;
// Creates the package
var package = NewPackage(name);
// Setup the default namespace
package.Meta.RootNamespace = parameters.Namespace;
// Setup the path to save it
package.FullPath = UPath.Combine(outputDirectory, new UFile(name + Package.PackageFileExtension));
// Set the package
parameters.Package = package;
// Add it to the current session
var session = parameters.Session;
session.Packages.Add(package);
// Load missing references
session.LoadMissingReferences(parameters.Logger);
}
private static int Main(string[] args)
{
Console.WriteLine(@"Bootstrapping: " + args[0]);
var xenkoDir = Environment.GetEnvironmentVariable("SiliconStudioXenkoDir");
var xenkoPkgPath = UPath.Combine(xenkoDir, new UFile("Xenko.xkpkg"));
var session = PackageSession.Load(xenkoPkgPath);
var generator = TemplateSampleGenerator.Default;
var logger = new LoggerResult();
var parameters = new TemplateGeneratorParameters {
Session = session.Session
};
var outputPath = UPath.Combine(new UDirectory(xenkoDir), new UDirectory("samplesGenerated"));
outputPath = UPath.Combine(outputPath, new UDirectory(args[0]));
var xenkoTemplates = session.Session.Packages.First().Templates;
parameters.Description = xenkoTemplates.First(x => x.Group.StartsWith("Samples") && x.Id == new Guid(args[1]));
parameters.Name = args[0];
parameters.Namespace = args[0];
parameters.OutputDirectory = outputPath;
parameters.Logger = logger;
generator.Generate(parameters);
var updaterTemplate = xenkoTemplates.First(x => x.FullPath.ToString().EndsWith("UpdatePlatforms.xktpl"));
parameters.Description = updaterTemplate;
var updater = UpdatePlatformsTemplateGenerator.Default;
var gameSettingsAsset = session.Session.Packages.Last().GetGameSettingsAsset();
var renderingSettings = gameSettingsAsset.Get <RenderingSettings>();
var updateParams = new GameTemplateParameters
{
Common = parameters,
ForcePlatformRegeneration = true,
GraphicsProfile = renderingSettings.DefaultGraphicsProfile,
IsHDR = false,
Orientation = (DisplayOrientation)renderingSettings.DisplayOrientation,
Platforms = AssetRegistry.SupportedPlatforms.ToList()
};
updater.Generate(updateParams);
Console.WriteLine(logger.ToText());
return(logger.HasErrors ? 1 : 0);
}
public override Action PrepareForRun(TemplateGeneratorParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
parameters.Validate();
return(() => Generate(parameters));
}
public static void AddOption(TemplateGeneratorParameters parameters, string optionName, object optionValue)
{
if (!parameters.Tags.TryGetValue(OptionsKey, out Dictionary<string, object> options))
{
options = new Dictionary<string, object>();
parameters.Tags.Add(OptionsKey, options);
}
options[optionName] = optionValue;
}
public static ProjectTemplate PrepareTemplate(TemplateGeneratorParameters parameters, Package package, UFile templateRelativePath, PlatformType platformType, GraphicsPlatform? graphicsPlatform, ProjectType projectType)
{
if (platformType != PlatformType.Shared && !graphicsPlatform.HasValue)
{
throw new ArgumentException(@"Expecting a value for GraphicsPlatform when platformType is specified.", nameof(graphicsPlatform));
}
var rootTemplateDir = parameters.Description.TemplateDirectory;
var templateFilePath = UPath.Combine(rootTemplateDir, templateRelativePath);
var projectTemplate = ProjectTemplate.Load(templateFilePath);
// TODO: Assemblies are not configurable from the outside
projectTemplate.Assemblies.Add(typeof(ProjectType).Assembly.FullName);
projectTemplate.Assemblies.Add(typeof(StrideConfig).Assembly.FullName);
projectTemplate.Assemblies.Add(typeof(GraphicsPlatform).Assembly.FullName);
projectTemplate.Assemblies.Add(typeof(DisplayOrientation).Assembly.FullName);
AddOption(parameters, "Package", package);
AddOption(parameters, "PackageName", package.Meta.Name);
// PackageNameCode, same as PackageName without '.' and ' '.
AddOption(parameters, "PackageNameCode",
package.Meta.Name.Replace(" ", string.Empty)
.Replace(".", string.Empty));
AddOption(parameters, "PackageDisplayName", package.Meta.Title ?? package.Meta.Name);
// Escape illegal characters for the short name
AddOption(parameters, "PackageNameShort", Utilities.BuildValidClassName(package.Meta.Name.Replace(" ", string.Empty)));
AddOption(parameters, "CurrentPlatform", platformType);
if (platformType != PlatformType.Shared)
{
AddOption(parameters, "CurrentGraphicsPlatform", graphicsPlatform);
}
AddOption(parameters, "ProjectType", projectType);
AddOption(parameters, "Namespace", parameters.Namespace ?? Utilities.BuildValidNamespaceName(package.Meta.Name));
if (platformType == PlatformType.Windows)
{
var isNETFramework = RuntimeInformation.FrameworkDescription.StartsWith(".NET Framework");
AddOption(parameters, "TargetFramework", isNETFramework ? "net461" : "net5.0-windows");
}
return projectTemplate;
}
public static SolutionProject GenerateTemplate(TemplateGeneratorParameters parameters, ICollection<SelectedSolutionPlatform> platforms, UFile templateRelativePath, string projectName, PlatformType platformType, GraphicsPlatform? graphicsPlatform, ProjectType projectType, DisplayOrientation orientation, Guid? projectGuid = null)
{
AddOption(parameters, "Platforms", platforms.Select(x => x.Platform).ToList());
AddOption(parameters, "CurrentPlatform", platformType);
AddOption(parameters, "Orientation", orientation);
var project = GenerateTemplate(parameters, templateRelativePath, projectName, platformType, graphicsPlatform, projectType, out List<string> generatedFiles, projectGuid);
// Special case for sdfx files
foreach (var file in generatedFiles)
{
if (file.EndsWith(".sdfx"))
{
ConvertSdfxToCSharp(file);
}
}
return project;
}
public static ProjectReference GenerateTemplate(TemplateGeneratorParameters parameters, Package package, UFile templateRelativePath, string projectName, PlatformType platformType, GraphicsPlatform?graphicsPlatform, ProjectType projectType, out List <string> generatedFiles, Guid?projectGuidArg = null)
{
var options = GetOptions(parameters);
var projectTemplate = PrepareTemplate(parameters, package, templateRelativePath, platformType, graphicsPlatform, projectType);
var outputDirectoryPath = UPath.Combine(parameters.OutputDirectory, (UDirectory)projectName);
Directory.CreateDirectory(outputDirectoryPath);
generatedFiles = new List <string>();
parameters.Logger.Verbose($"Generating {projectName}...");
var projectGuid = projectGuidArg ?? Guid.NewGuid();
projectTemplate.Generate(outputDirectoryPath, projectName, projectGuid, parameters.Logger, options, generatedFiles);
// Mark the package as dirty
package.IsDirty = true;
return(new ProjectReference(projectGuid, UPath.Combine(outputDirectoryPath, (UFile)(projectName + ".csproj")), ProjectType.Library));
}
public static SolutionProject GenerateTemplate(TemplateGeneratorParameters parameters, UFile templateRelativePath, string projectName, PlatformType platformType, GraphicsPlatform?graphicsPlatform, ProjectType projectType, out List <string> generatedFiles, Guid?projectGuidArg = null)
{
var options = GetOptions(parameters);
var outputDirectoryPath = UPath.Combine(parameters.OutputDirectory, (UDirectory)projectName);
Directory.CreateDirectory(outputDirectoryPath);
generatedFiles = new List <string>();
parameters.Logger.Verbose($"Generating {projectName}...");
var projectGuid = projectGuidArg ?? Guid.NewGuid();
var packagePath = UPath.Combine(outputDirectoryPath, (UFile)(projectName + Package.PackageFileExtension));
var projectFullPath = UPath.Combine(outputDirectoryPath, (UFile)(projectName + ".csproj"));
var package = new Package
{
Meta =
{
Name = projectName,
Version = new PackageVersion("1.0.0.0")
},
FullPath = packagePath,
IsDirty = true,
};
package.AssetFolders.Add(new AssetFolder("Assets"));
package.ResourceFolders.Add("Resources");
var projectTemplate = PrepareTemplate(parameters, package, templateRelativePath, platformType, graphicsPlatform, projectType);
projectTemplate.Generate(outputDirectoryPath, projectName, projectGuid, parameters.Logger, options, generatedFiles);
var project = new SolutionProject(package, projectGuid, projectFullPath);
project.Type = projectType;
project.Platform = platformType;
return(project);
}
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[PlatformType.Shared];
// 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;
}
}
public bool AfterRun(TemplateGeneratorParameters parameters)
{
return(true);
}
public Func <bool> PrepareForRun(TemplateGeneratorParameters parameters)
{
// Nothing to do in the tests
return(null);
}
public static IReadOnlyDictionary <string, object> GetOptions(TemplateGeneratorParameters parameters)
{
Dictionary <string, object> options;
return(parameters.Tags.TryGetValue(OptionsKey, out options) ? options : new Dictionary <string, object>());
}
public static void UpdatePackagePlatforms(TemplateGeneratorParameters parameters, ICollection <SelectedSolutionPlatform> platforms, DisplayOrientation orientation, Guid sharedProjectGuid, string name, Package package, bool forcePlatformRegeneration)
{
if (platforms == null)
{
throw new ArgumentNullException(nameof(platforms));
}
var logger = parameters.Logger;
// Setup the ProjectGameGuid to be accessible from exec (in order to be able to link to the game project.
AddOption(parameters, "ProjectGameGuid", sharedProjectGuid);
// Add projects
var stepIndex = 0;
var stepCount = platforms.Count + 1;
var profilesToRemove = package.Profiles.Where(profile => platforms.All(platform => profile.Platform != PlatformType.Shared && platform.Platform.Type != profile.Platform)).ToList();
stepCount += profilesToRemove.Count;
foreach (var platform in platforms)
{
stepIndex++;
// Don't add a platform that is already in the package
var platformProfile = package.Profiles.FirstOrDefault(profile => profile.Platform == platform.Platform.Type);
if (platformProfile != null && !forcePlatformRegeneration)
{
continue;
}
var projectGuid = Guid.NewGuid();
if (platformProfile == null)
{
platformProfile = new PackageProfile(platform.Platform.Name)
{
Platform = platform.Platform.Type
};
platformProfile.AssetFolders.Add(new AssetFolder("Assets/" + platform.Platform.Name));
}
else
{
// We are going to regenerate this platform, so we are removing it before
var previousExeProject = platformProfile.ProjectReferences.FirstOrDefault(project => project.Type == ProjectType.Executable);
if (previousExeProject != null)
{
projectGuid = previousExeProject.Id;
RemoveProject(previousExeProject, logger);
platformProfile.ProjectReferences.Remove(previousExeProject);
}
}
var templatePath = platform.Template?.TemplatePath ?? $"ProjectExecutable.{platform.Platform.Name}/ProjectExecutable.{platform.Platform.Name}.ttproj";
// Log progress
var projectName = Utilities.BuildValidNamespaceName(name) + "." + platform.Platform.Name;
Progress(logger, $"Generating {projectName}...", stepIndex - 1, stepCount);
var graphicsPlatform = platform.Platform.Type.GetDefaultGraphicsPlatform();
var newExeProject = GenerateTemplate(parameters, platforms, package, templatePath, projectName, platform.Platform.Type, platformProfile.Name, graphicsPlatform, ProjectType.Executable, orientation, projectGuid);
newExeProject.Type = ProjectType.Executable;
platformProfile.ProjectReferences.Add(newExeProject);
if (!package.Profiles.Contains(platformProfile))
{
package.Profiles.Add(platformProfile);
}
package.IsDirty = true;
}
// Remove existing platform profiles
foreach (var profileToRemove in profilesToRemove)
{
package.Profiles.Remove(profileToRemove);
package.IsDirty = true;
foreach (var projectReference in profileToRemove.ProjectReferences)
{
// Try to remove the directory
Progress(logger, $"Deleting {projectReference.Location}...", stepIndex++, stepCount);
RemoveProject(projectReference, logger);
}
// We are completely removing references from profile
profileToRemove.ProjectReferences.Clear();
}
}
public void AfterRun(TemplateGeneratorParameters parameters)
{
}
