522 lines
21 KiB
C#
522 lines
21 KiB
C#
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
using System.Threading.Tasks;
|
|
using EpicGames.Core;
|
|
using Microsoft.Extensions.Logging;
|
|
using UnrealBuildBase;
|
|
using static UnrealBuildTool.VCProjectFile;
|
|
|
|
namespace UnrealBuildTool
|
|
{
|
|
internal class VSWorkspaceProjectFile : ProjectFile
|
|
{
|
|
private readonly HashSet<TargetType> TargetTypes;
|
|
private readonly CommandLineArguments Arguments;
|
|
|
|
/// <summary>
|
|
/// Collection of output files for this project
|
|
/// </summary>
|
|
public List<ExportedTargetInfo> ExportedTargetProjects { get; set; } = new();
|
|
|
|
public DirectoryReference RootPath { get; }
|
|
|
|
public VSWorkspaceProjectFile(FileReference InProjectFilePath, DirectoryReference BaseDir,
|
|
DirectoryReference RootPath, HashSet<TargetType> TargetTypes, CommandLineArguments Arguments)
|
|
: base(InProjectFilePath, BaseDir)
|
|
{
|
|
this.RootPath = RootPath;
|
|
this.TargetTypes = TargetTypes;
|
|
this.Arguments = Arguments;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Collect available configurations for the project storing it at <c>availableConfigurations</c> dictionary.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Keys for the dictionary are available project names.
|
|
/// </remarks>
|
|
/// <param name="availableConfigurations"></param>
|
|
/// <param name="InPlatforms"></param>
|
|
/// <param name="InConfigurations"></param>
|
|
/// <param name="PlatformProjectGenerators"></param>
|
|
/// <param name="Minimize"></param>
|
|
/// <param name="Logger"></param>
|
|
public void CollectAvailableConfigurations(Dictionary<string, AvailableConfiguration> availableConfigurations,
|
|
List<UnrealTargetPlatform> InPlatforms,
|
|
List<UnrealTargetConfiguration> InConfigurations,
|
|
PlatformProjectGeneratorCollection PlatformProjectGenerators,
|
|
JsonWriterStyle Minimize,
|
|
ILogger Logger)
|
|
{
|
|
ProcessProjectFiles(
|
|
InPlatforms,
|
|
InConfigurations,
|
|
PlatformProjectGenerators,
|
|
// always provide null in here as we want to collect all available data.
|
|
null,
|
|
(UnrealTargetConfiguration Configuration, UnrealTargetPlatform Platform, ProjectTarget ProjectTarget) =>
|
|
{
|
|
if (!availableConfigurations.TryGetValue(ProjectTarget.Name, out AvailableConfiguration? availableConfiguration))
|
|
{
|
|
availableConfiguration = new AvailableConfiguration();
|
|
availableConfigurations.Add(ProjectTarget.Name, availableConfiguration);
|
|
}
|
|
availableConfiguration.TargetType = ProjectTarget.TargetRules?.Type.ToString() ?? string.Empty;
|
|
availableConfiguration.Configurations.Add(Configuration.ToString());
|
|
availableConfiguration.Platforms.Add(Platform.ToString());
|
|
availableConfiguration.TargetPath = ProjectTarget.TargetFilePath.FullName;
|
|
availableConfiguration.ProjectPath = ProjectTarget.UnrealProjectFilePath?.FullName ?? string.Empty;
|
|
|
|
return Task.CompletedTask;
|
|
});
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write project file info in JSON file.
|
|
/// For every combination of <c>UnrealTargetPlatform</c>, <c>UnrealTargetConfiguration</c> and <c>TargetType</c>
|
|
/// will be generated separate JSON file.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// * <c>TargetType.Editor</c> will be generated for current platform only and will ignore <c>UnrealTargetConfiguration.Test</c> and <c>UnrealTargetConfiguration.Shipping</c> configurations
|
|
/// * <c>TargetType.Program</c> will be generated for current platform only and <c>UnrealTargetConfiguration.Development</c> configuration only
|
|
/// </remarks>
|
|
/// <param name="InPlatforms"></param>
|
|
/// <param name="InConfigurations"></param>
|
|
/// <param name="PlatformProjectGenerators"></param>
|
|
/// <param name="Minimize"></param>
|
|
/// <param name="Logger"></param>
|
|
/// <param name="ProjectGenerationDescriptionData"></param>
|
|
/// <param name="VCFormat"></param>
|
|
/// <returns></returns>
|
|
public bool WriteProjectFile(List<UnrealTargetPlatform> InPlatforms,
|
|
List<UnrealTargetConfiguration> InConfigurations,
|
|
PlatformProjectGeneratorCollection PlatformProjectGenerators,
|
|
JsonWriterStyle Minimize,
|
|
ILogger Logger,
|
|
Dictionary<string, AvailableConfiguration>? ProjectGenerationDescriptionData,
|
|
VCProjectFileFormat VCFormat)
|
|
{
|
|
DirectoryReference ProjectRootFolder = RootPath;
|
|
|
|
ProcessProjectFiles(
|
|
InPlatforms,
|
|
InConfigurations,
|
|
PlatformProjectGenerators,
|
|
ProjectGenerationDescriptionData,
|
|
(UnrealTargetConfiguration Configuration, UnrealTargetPlatform Platform, ProjectTarget ProjectTarget) => Task.Run(async () =>
|
|
{
|
|
bool bBuildByDefault = ShouldBuildByDefaultForSolutionTargets && ProjectTarget.SupportedPlatforms.Contains(Platform);
|
|
|
|
UnrealArchitectures ProjectArchitectures = UEBuildPlatform
|
|
.GetBuildPlatform(Platform)
|
|
.ArchitectureConfig.ActiveArchitectures(ProjectTarget.UnrealProjectFilePath, ProjectTarget.Name);
|
|
|
|
TargetDescriptor TargetDesc = new(ProjectTarget.UnrealProjectFilePath, ProjectTarget.Name,
|
|
Platform, Configuration, ProjectArchitectures, Arguments);
|
|
TargetDesc.IntermediateEnvironment = UnrealIntermediateEnvironment.GenerateProjectFiles;
|
|
|
|
try
|
|
{
|
|
foreach (var Architecture in TargetDesc.Architectures.Architectures)
|
|
{
|
|
UEBuildTarget BuildTarget = UEBuildTarget.Create(TargetDesc, false, false, false, UnrealIntermediateEnvironment.GenerateProjectFiles, Logger);
|
|
BuildTarget.PreBuildSetup(Logger);
|
|
|
|
ExportedTargetInfo TargetInfo = ExportTarget(BuildTarget, Architecture, bBuildByDefault, PlatformProjectGenerators, Logger, VCFormat);
|
|
|
|
var sb = new StringBuilder();
|
|
sb.Append(ProjectTarget.TargetFilePath.GetFileNameWithoutAnyExtensions());
|
|
sb.Append("_");
|
|
sb.Append(TargetInfo.Configuration);
|
|
sb.Append("_");
|
|
sb.Append(TargetInfo.Platform);
|
|
|
|
if (!string.IsNullOrEmpty(TargetInfo.Architecture))
|
|
{
|
|
sb.Append("_");
|
|
sb.Append(TargetInfo.Architecture);
|
|
}
|
|
|
|
sb.Append(".json");
|
|
|
|
FileReference OutputFile = FileReference.Combine(ProjectRootFolder, sb.ToString());
|
|
|
|
DirectoryReference.CreateDirectory(OutputFile.Directory);
|
|
using FileStream Stream = new(OutputFile.FullName, FileMode.Create, FileAccess.Write);
|
|
await JsonSerializer.SerializeAsync(Stream, TargetInfo, options: new JsonSerializerOptions()
|
|
{
|
|
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
|
|
WriteIndented = Minimize == JsonWriterStyle.Readable,
|
|
});
|
|
|
|
lock (ExportedTargetProjects)
|
|
{
|
|
ExportedTargetProjects.Add(TargetInfo);
|
|
}
|
|
}
|
|
|
|
}
|
|
catch (Exception Ex)
|
|
{
|
|
Logger.LogWarning("Exception while generating include data for Target:{0}, Platform: {1}, Configuration: {2}", TargetDesc.Name, Platform.ToString(), Configuration.ToString());
|
|
Logger.LogWarning("{0}", Ex.ToString());
|
|
}
|
|
}));
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Filter configurations based on what is supported by the project.
|
|
/// </summary>
|
|
/// <param name="InPlatforms"></param>
|
|
/// <param name="InConfigurations"></param>
|
|
/// <param name="PlatformProjectGenerators"></param>
|
|
/// <param name="ProjectGenerationDescriptionData"></param>
|
|
/// <param name="Handler"></param>
|
|
private void ProcessProjectFiles(List<UnrealTargetPlatform> InPlatforms,
|
|
List<UnrealTargetConfiguration> InConfigurations,
|
|
PlatformProjectGeneratorCollection PlatformProjectGenerators,
|
|
Dictionary<string, AvailableConfiguration>? ProjectGenerationDescriptionData,
|
|
Func<UnrealTargetConfiguration, UnrealTargetPlatform, ProjectTarget, Task> Handler)
|
|
{
|
|
List<Task> Tasks = new List<Task>();
|
|
List<(UnrealTargetConfiguration, UnrealTargetPlatform, ProjectTarget)> ret = new List<(UnrealTargetConfiguration, UnrealTargetPlatform, ProjectTarget)>();
|
|
foreach (UnrealTargetConfiguration Configuration in InConfigurations)
|
|
{
|
|
foreach (UnrealTargetPlatform Platform in InPlatforms)
|
|
{
|
|
foreach (ProjectTarget ProjectTarget in ProjectTargets.OfType<ProjectTarget>())
|
|
{
|
|
if (TargetTypes.Any() && !TargetTypes.Contains(ProjectTarget.TargetRules!.Type))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Skip Programs for all configs except for current platform + Development & Debug configurations
|
|
if (ProjectTarget.TargetRules!.Type == TargetType.Program &&
|
|
(BuildHostPlatform.Current.Platform != Platform ||
|
|
!(Configuration == UnrealTargetConfiguration.Development || Configuration == UnrealTargetConfiguration.Debug)))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Skip Editor for all platforms except for current platform
|
|
if (ProjectTarget.TargetRules.Type == TargetType.Editor &&
|
|
(BuildHostPlatform.Current.Platform != Platform ||
|
|
(Configuration == UnrealTargetConfiguration.Test || Configuration == UnrealTargetConfiguration.Shipping)))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Skip invalid platforms for the current TargetType
|
|
if (!ProjectTarget.SupportedPlatforms.Contains(Platform))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (ShouldSkipConfiguration(ProjectGenerationDescriptionData, Configuration, Platform, ProjectTarget))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
Tasks.Add(Handler(Configuration, Platform, ProjectTarget));
|
|
}
|
|
}
|
|
|
|
Task.WaitAll(Tasks.ToArray());
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write a Target to a JSON writer. Is array is empty, don't write anything
|
|
/// </summary>
|
|
/// <param name="Target"></param>
|
|
/// <param name="Architecture"></param>
|
|
/// <param name="bBuildByDefault"></param>
|
|
/// <param name="PlatformProjectGenerators"></param>
|
|
/// <param name="Logger">Logger for output</param>
|
|
/// <param name="VCFormat">Project file format.</param>
|
|
private ExportedTargetInfo ExportTarget(
|
|
UEBuildTarget Target, UnrealArch? Architecture, bool bBuildByDefault, PlatformProjectGeneratorCollection PlatformProjectGenerators, ILogger Logger, VCProjectFileFormat VCFormat)
|
|
{
|
|
ExportedTargetInfo TargetInfo = new()
|
|
{
|
|
TargetName = Target.TargetName,
|
|
TargetPath = Target.TargetRulesFile.FullName,
|
|
ProjectPath = Target.ProjectFile?.FullName ?? String.Empty,
|
|
TargetType = Target.TargetType.ToString(),
|
|
Platform = Target.Platform.ToString(),
|
|
VCPlatform = GetVCPlatform(Target, Architecture, PlatformProjectGenerators, VCFormat),
|
|
Configuration = Target.Configuration.ToString(),
|
|
VCConfiguration = GetVCConfiguration(Target, Architecture, PlatformProjectGenerators, VCFormat),
|
|
Architecture = GetArchitecture(Target, Architecture, PlatformProjectGenerators, VCFormat),
|
|
BuildInfo = ExportBuildInfo(Target, Architecture, PlatformProjectGenerators, bBuildByDefault, Logger)
|
|
};
|
|
|
|
UEToolChain TargetToolChain = Target.CreateToolchain(Target.Platform, Logger);
|
|
CppCompileEnvironment GlobalCompileEnvironment = Target.CreateCompileEnvironmentForProjectFiles(Logger);
|
|
|
|
HashSet<string> ModuleNames = new();
|
|
foreach (UEBuildBinary Binary in Target.Binaries)
|
|
{
|
|
CppCompileEnvironment BinaryCompileEnvironment = Binary.CreateBinaryCompileEnvironment(GlobalCompileEnvironment);
|
|
IEnumerable<UEBuildModuleCPP> CandidateModules = Binary.Modules.Where(x => x is UEBuildModuleCPP).Cast<UEBuildModuleCPP>();
|
|
|
|
foreach (UEBuildModuleCPP ModuleCpp in CandidateModules)
|
|
{
|
|
if (!ModuleNames.Add(ModuleCpp.Name))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
CppCompileEnvironment ModuleCompileEnvironment = ModuleCpp.CreateCompileEnvironmentForIntellisense(Target.Rules, BinaryCompileEnvironment, Logger);
|
|
TargetInfo.ModuleToCompileSettings.Add(ModuleCpp.Name, ExportModule(ModuleCpp, TargetToolChain, ModuleCompileEnvironment));
|
|
|
|
foreach (DirectoryReference ModuleDirectory in ModuleCpp.ModuleDirectories)
|
|
{
|
|
TargetInfo.DirToModule.TryAdd(ModuleDirectory.FullName, ModuleCpp.Name);
|
|
}
|
|
|
|
if (ModuleCpp.GeneratedCodeDirectory != null)
|
|
{
|
|
TargetInfo.DirToModule.TryAdd(ModuleCpp.GeneratedCodeDirectory.FullName, ModuleCpp.Name);
|
|
}
|
|
}
|
|
}
|
|
|
|
return TargetInfo;
|
|
}
|
|
|
|
private static bool ShouldSkipConfiguration(Dictionary<string, AvailableConfiguration>? ProjectGenerationDescriptionData,
|
|
UnrealTargetConfiguration Configuration,
|
|
UnrealTargetPlatform Platform,
|
|
ProjectTarget ProjectTarget)
|
|
{
|
|
// No restrictions were provided, we should not skip anything.
|
|
if (ProjectGenerationDescriptionData == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Configs were provided, but we could not find it in the dictionary, so we should not skip it.
|
|
if (!ProjectGenerationDescriptionData.TryGetValue(ProjectTarget.Name, out AvailableConfiguration? availableConfiguration))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return !availableConfiguration.Configurations.Contains(Configuration.ToString()) || !availableConfiguration.Platforms.Contains(Platform.ToString());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write a Module to a JSON writer. If array is empty, don't write anything
|
|
/// </summary>
|
|
/// <param name="TargetToolChain"></param>
|
|
/// <param name="ModuleCompileEnvironment"></param>
|
|
/// <param name="Module"></param>
|
|
private static ExportedModuleInfo ExportModule(UEBuildModuleCPP Module, UEToolChain TargetToolChain, CppCompileEnvironment ModuleCompileEnvironment)
|
|
{
|
|
ExportedModuleInfo Result = new()
|
|
{
|
|
Name = Module.Name,
|
|
Directory = Module.ModuleDirectory.FullName,
|
|
Rules = Module.RulesFile.FullName,
|
|
GeneratedCodeDirectory = Module.GeneratedCodeDirectory != null ? Module.GeneratedCodeDirectory.FullName : String.Empty,
|
|
Standard = ModuleCompileEnvironment.CppStandard.ToString(),
|
|
};
|
|
|
|
Result.IncludePaths.AddRange(Module.PublicIncludePaths.Select(x => x.FullName));
|
|
Result.IncludePaths.AddRange(Module.PublicSystemIncludePaths.Select(x => x.FullName));
|
|
Result.IncludePaths.AddRange(Module.InternalIncludePaths.Select(x => x.FullName));
|
|
Result.IncludePaths.AddRange(Module.LegacyPublicIncludePaths.Select(x => x.FullName));
|
|
Result.IncludePaths.AddRange(Module.LegacyParentIncludePaths.Select(x => x.FullName));
|
|
Result.IncludePaths.AddRange(Module.PrivateIncludePaths.Select(x => x.FullName));
|
|
|
|
Result.IncludePaths.AddRange(ModuleCompileEnvironment.UserIncludePaths.Select(x => x.FullName));
|
|
|
|
Result.IncludePaths.AddRange(Module.PublicSystemLibraryPaths.Select(x => x.FullName));
|
|
Result.IncludePaths.AddRange(Module.PublicSystemLibraries.Concat(Module.PublicLibraries.Select(x => x.FullName)));
|
|
|
|
if (TargetToolChain is VCToolChain TargetVCToolChain)
|
|
{
|
|
Result.IncludePaths.AddRange(TargetVCToolChain.GetVCIncludePaths().Select(x => x.ToString()));
|
|
}
|
|
|
|
Result.Defines.AddRange(Module.PublicDefinitions);
|
|
Result.Defines.AddRange(Module.Rules.PrivateDefinitions);
|
|
Result.Defines.AddRange(Module.Rules.bTreatAsEngineModule ? Array.Empty<string>() : Module.Rules.Target.ProjectDefinitions);
|
|
Result.Defines.AddRange(Module.GetEmptyApiMacros());
|
|
|
|
List<FileItem> ForcedIncludes = ModuleCompileEnvironment.ForceIncludeFiles.ToList();
|
|
if (ModuleCompileEnvironment.PrecompiledHeaderAction == PrecompiledHeaderAction.Include)
|
|
{
|
|
FileItem IncludeHeader = FileItem.GetItemByFileReference(ModuleCompileEnvironment.PrecompiledHeaderIncludeFilename!);
|
|
ForcedIncludes.Insert(0, IncludeHeader);
|
|
|
|
Result.PrecompiledHeader = IncludeHeader.FullName;
|
|
}
|
|
|
|
Result.ForcedIncludes.AddRange(ForcedIncludes.Select(x => x.FullName));
|
|
|
|
Result.CompilerPath = TargetToolChain.GetCppCompilerPath()?.ToString();
|
|
Result.CompilerArgs.AddRange(TargetToolChain.GetGlobalCommandLineArgs(ModuleCompileEnvironment));
|
|
Result.CompilerAdditionalArgs.Add("c", TargetToolChain.GetCCommandLineArgs(ModuleCompileEnvironment).ToList());
|
|
Result.CompilerAdditionalArgs.Add("cpp", TargetToolChain.GetCPPCommandLineArgs(ModuleCompileEnvironment).ToList());
|
|
|
|
return Result;
|
|
}
|
|
|
|
private TargetBuildInfo? ExportBuildInfo(UEBuildTarget Target, UnrealArch? Architecture, PlatformProjectGeneratorCollection PlatformProjectGenerators, bool bBuildByDefault, ILogger Logger)
|
|
{
|
|
if (!BuildHostPlatform.Current.Platform.IsInGroup(UnrealPlatformGroup.Windows))
|
|
{
|
|
Logger.LogWarning("Unsupported platform for Build Information: {Platform}", BuildHostPlatform.Current.Platform.ToString());
|
|
return null;
|
|
}
|
|
|
|
if (IsStubProject)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
ProjectTarget ProjectTarget = ProjectTargets.OfType<ProjectTarget>().Single(It => Target.TargetRulesFile == It.TargetFilePath);
|
|
UnrealTargetPlatform Platform = Target.Platform;
|
|
UnrealTargetConfiguration Configuration = Target.Configuration;
|
|
|
|
string UProjectPath = "";
|
|
if (IsForeignProject)
|
|
{
|
|
UProjectPath = String.Format("\"{0}\"", ProjectTarget.UnrealProjectFilePath!.FullName);
|
|
}
|
|
|
|
PlatformProjectGenerator? ProjGenerator = PlatformProjectGenerators.GetPlatformProjectGenerator(Platform, true);
|
|
VCProjectFile.BuildCommandBuilder BuildCommandBuilder = new(
|
|
new PlatformProjectGenerator.VSSettings(Platform, Configuration, VCProjectFileFormat.Default, Architecture), ProjectTarget, UProjectPath)
|
|
{
|
|
ProjectGenerator = ProjGenerator,
|
|
bIsForeignProject = IsForeignProject
|
|
};
|
|
|
|
string BuildArguments = BuildCommandBuilder.GetBuildArguments();
|
|
|
|
return new TargetBuildInfo()
|
|
{
|
|
BuildCmd = $"\"{BuildCommandBuilder.BuildScript.FullName}\" {BuildArguments}",
|
|
RebuildCmd = $"\"{BuildCommandBuilder.RebuildScript.FullName}\" {BuildArguments}",
|
|
CleanCmd = $"\"{BuildCommandBuilder.CleanScript.FullName}\" {BuildArguments}",
|
|
PrimaryOutput = Target.Binaries[0].OutputFilePath.FullName,
|
|
BuildByDefault = bBuildByDefault,
|
|
};
|
|
}
|
|
|
|
private string GetVCPlatform(UEBuildTarget Target, UnrealArch? Architecture, PlatformProjectGeneratorCollection Generators, VCProjectFileFormat VCFormat)
|
|
{
|
|
PlatformProjectGenerator? Generator = Generators.GetPlatformProjectGenerator(Target.Platform, true);
|
|
if (Generator != null)
|
|
{
|
|
PlatformProjectGenerator.VSSettings VSSettings = new(Target.Platform, Target.Configuration, VCFormat, Architecture);
|
|
if (Generator.HasVisualStudioSupport(VSSettings))
|
|
{
|
|
return Generator.GetVisualStudioPlatformName(VSSettings);
|
|
}
|
|
|
|
return DefaultPlatformName;
|
|
}
|
|
|
|
return string.Empty;
|
|
}
|
|
|
|
private string GetVCConfiguration(UEBuildTarget Target, UnrealArch? Architecture, PlatformProjectGeneratorCollection Generators, VCProjectFileFormat VCFormat)
|
|
{
|
|
PlatformProjectGenerator? Generator = Generators.GetPlatformProjectGenerator(Target.Platform, true);
|
|
if (Generator != null)
|
|
{
|
|
PlatformProjectGenerator.VSSettings VSSettings = new(Target.Platform, Target.Configuration, VCFormat, Architecture);
|
|
if (Generator.HasVisualStudioSupport(VSSettings))
|
|
{
|
|
if (!Generator.RequiresDistinctVisualStudioConfigurationName(VSSettings))
|
|
{
|
|
return Target.Configuration.ToString();
|
|
}
|
|
}
|
|
|
|
return string.Format("{0}{1}_{2}", Target.Platform.ToString(), Architecture != null ? "_" + Architecture.ToString() : string.Empty, Target.Configuration.ToString()); ;
|
|
}
|
|
|
|
return string.Empty;
|
|
}
|
|
|
|
private string GetArchitecture(UEBuildTarget Target, UnrealArch? Architecture, PlatformProjectGeneratorCollection Generators, VCProjectFileFormat VCFormat)
|
|
{
|
|
PlatformProjectGenerator? Generator = Generators.GetPlatformProjectGenerator(Target.Platform, true);
|
|
if (Generator != null)
|
|
{
|
|
PlatformProjectGenerator.VSSettings VSSettings = new(Target.Platform, Target.Configuration, VCFormat, Architecture);
|
|
if (Generator.HasVisualStudioSupport(VSSettings))
|
|
{
|
|
if (!Generator.RequiresDistinctVisualStudioConfigurationName(VSSettings))
|
|
{
|
|
return string.Empty;
|
|
}
|
|
}
|
|
|
|
if (Architecture != null)
|
|
{
|
|
var result = Architecture.ToString();
|
|
return result != null ? result : string.Empty;
|
|
}
|
|
}
|
|
|
|
return string.Empty;
|
|
}
|
|
|
|
internal class ExportedTargetInfo
|
|
{
|
|
public string TargetName { get; set; } = String.Empty;
|
|
public string TargetPath { get; set; } = String.Empty;
|
|
public string ProjectPath { get; set; } = String.Empty;
|
|
public string TargetType { get; set; } = String.Empty;
|
|
public string Platform { get; set; } = String.Empty;
|
|
public string VCPlatform { get; set; } = String.Empty;
|
|
public string Configuration { get; set; } = String.Empty;
|
|
public string VCConfiguration { get; set; } = String.Empty;
|
|
public string Architecture { get; set; } = String.Empty;
|
|
public TargetBuildInfo? BuildInfo { get; set; }
|
|
public Dictionary<string, ExportedModuleInfo> ModuleToCompileSettings { get; set; } = new();
|
|
public Dictionary<string, string> DirToModule { get; set; } = new();
|
|
}
|
|
|
|
internal class ExportedModuleInfo
|
|
{
|
|
public string Name { get; set; } = String.Empty;
|
|
public string Directory { get; set; } = String.Empty;
|
|
public string Rules { get; set; } = String.Empty;
|
|
public string GeneratedCodeDirectory { get; set; } = String.Empty;
|
|
public List<string> IncludePaths { get; set; } = new();
|
|
public List<string> Defines { get; set; } = new();
|
|
public string? Standard { get; set; }
|
|
public string? PrecompiledHeader { get; set; }
|
|
public List<string> ForcedIncludes { get; set; } = new();
|
|
public string? CompilerPath { get; set; }
|
|
public List<string> CompilerArgs { get; set; } = new();
|
|
public Dictionary<string, List<string>> CompilerAdditionalArgs { get; set; } = new();
|
|
public string? WindowsSdkVersion { get; set; }
|
|
}
|
|
|
|
internal class TargetBuildInfo
|
|
{
|
|
public string BuildCmd { get; set; } = String.Empty;
|
|
public string RebuildCmd { get; set; } = String.Empty;
|
|
public string CleanCmd { get; set; } = String.Empty;
|
|
public string PrimaryOutput { get; set; } = String.Empty;
|
|
public bool BuildByDefault { get; internal set; }
|
|
}
|
|
}
|
|
}
|