public override Func<bool> PrepareForRun(TemplateGeneratorParameters parameters)
{
if (parameters == null) throw new ArgumentNullException(nameof(parameters));
parameters.Validate();
return () => Generate(parameters);
}
public bool Generate(TemplateGeneratorParameters parameters)
{
if (parameters == null) throw new ArgumentNullException(nameof(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);
return true;
}
public override Action PrepareForRun(TemplateGeneratorParameters parameters)
{
if (parameters == null) throw new ArgumentNullException("parameters");
parameters.Validate();
return () => Generate(parameters);
}
protected TemplateGeneratorParameters(TemplateGeneratorParameters parameters)
{
Name = parameters.Name;
Namespace = parameters.Namespace;
OutputDirectory = parameters.OutputDirectory;
Description = parameters.Description;
Logger = parameters.Logger;
parameters.Tags.CopyTo(ref Tags);
}
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 updateParams = new GameTemplateParameters
{
Common = parameters,
ForcePlatformRegeneration = true,
GraphicsProfile = gameSettingsAsset.DefaultGraphicsProfile,
IsHDR = false,
Orientation = gameSettingsAsset.DisplayOrientation,
Platforms = AssetRegistry.SupportedPlatforms.ToList()
};
updater.Generate(updateParams);
Console.WriteLine(logger.ToText());
return logger.HasErrors ? 1 : 0;
}
public virtual void AfterRun(TemplateGeneratorParameters parameters)
{
}
public abstract Action PrepareForRun(TemplateGeneratorParameters parameters);
public PackageTemplateGeneratorParameters(TemplateGeneratorParameters parameters, Package package)
: base(parameters)
{
Package = package;
}
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 virtual void AfterRun(TemplateGeneratorParameters parameters)
{
}
public abstract Action PrepareForRun(TemplateGeneratorParameters parameters);
public virtual bool AfterRun(TemplateGeneratorParameters parameters)
{
return(true);
}
public abstract Func <bool> PrepareForRun(TemplateGeneratorParameters parameters);
public abstract Func<bool> PrepareForRun(TemplateGeneratorParameters parameters);
