/// <summary>
/// Write C++ toolchain information to JSON writer
/// </summary>
/// <param name="Target"></param>
/// <param name="Writer"></param>
private static void ExportEnvironmentToJson(UEBuildTarget Target, JsonWriter Writer)
{
CppCompileEnvironment GlobalCompileEnvironment = Target.CreateCompileEnvironmentForProjectFiles();
Writer.WriteArrayStart("EnvironmentIncludePaths");
foreach (DirectoryReference Path in GlobalCompileEnvironment.UserIncludePaths)
{
Writer.WriteValue(Path.FullName);
}
foreach (DirectoryReference Path in GlobalCompileEnvironment.SystemIncludePaths)
{
Writer.WriteValue(Path.FullName);
}
// TODO: get corresponding includes for specific platforms
if (UEBuildPlatform.IsPlatformInGroup(Target.Platform, UnrealPlatformGroup.Windows))
{
foreach (DirectoryReference Path in Target.Rules.WindowsPlatform.Environment.IncludePaths)
{
Writer.WriteValue(Path.FullName);
}
}
Writer.WriteArrayEnd();
Writer.WriteArrayStart("EnvironmentDefinitions");
foreach (string Definition in GlobalCompileEnvironment.Definitions)
{
Writer.WriteValue(Definition);
}
Writer.WriteArrayEnd();
}
public override void SetUpEnvironment(ReadOnlyTargetRules Target, CppCompileEnvironment CompileEnvironment, LinkEnvironment LinkEnvironment)
{
CompileEnvironment.Definitions.Add("PLATFORM_DESKTOP=0");
CompileEnvironment.Definitions.Add("PLATFORM_CAN_SUPPORT_EDITORONLY_DATA=0");
CompileEnvironment.Definitions.Add("WITH_OGGVORBIS=1");
CompileEnvironment.Definitions.Add("UNICODE");
CompileEnvironment.Definitions.Add("_UNICODE");
CompileEnvironment.Definitions.Add("PLATFORM_ANDROID=1");
CompileEnvironment.Definitions.Add("ANDROID=1");
CompileEnvironment.Definitions.Add("WITH_EDITOR=0");
CompileEnvironment.Definitions.Add("USE_NULL_RHI=0");
SetUpSpecificEnvironment(Target, CompileEnvironment, LinkEnvironment);
// LinkEnvironment.AdditionalLibraries.Add("libc++_shared");
LinkEnvironment.AdditionalLibraries.Add("c");
LinkEnvironment.AdditionalLibraries.Add("dl");
LinkEnvironment.AdditionalLibraries.Add("log");
LinkEnvironment.AdditionalLibraries.Add("m");
// LinkEnvironment.AdditionalLibraries.Add("stdc++");
LinkEnvironment.AdditionalLibraries.Add("z");
LinkEnvironment.AdditionalLibraries.Add("atomic");
}
public override void SetUpEnvironment(ReadOnlyTargetRules Target, CppCompileEnvironment CompileEnvironment, LinkEnvironment LinkEnvironment)
{
CompileEnvironment.Definitions.Add("PLATFORM_DESKTOP=0");
CompileEnvironment.Definitions.Add("PLATFORM_CAN_SUPPORT_EDITORONLY_DATA=0");
CompileEnvironment.Definitions.Add("WITH_OGGVORBIS=1");
CompileEnvironment.Definitions.Add("UNICODE");
CompileEnvironment.Definitions.Add("_UNICODE");
CompileEnvironment.Definitions.Add("PLATFORM_ANDROID=1");
CompileEnvironment.Definitions.Add("ANDROID=1");
CompileEnvironment.Definitions.Add("WITH_DATABASE_SUPPORT=0");
CompileEnvironment.Definitions.Add("WITH_EDITOR=0");
CompileEnvironment.Definitions.Add("USE_NULL_RHI=0");
CompileEnvironment.Definitions.Add("REQUIRES_ALIGNED_INT_ACCESS");
SetUpSpecificEnvironment(Target, CompileEnvironment, LinkEnvironment);
LinkEnvironment.AdditionalLibraries.Add("gnustl_shared");
LinkEnvironment.AdditionalLibraries.Add("gcc");
LinkEnvironment.AdditionalLibraries.Add("z");
LinkEnvironment.AdditionalLibraries.Add("c");
LinkEnvironment.AdditionalLibraries.Add("m");
LinkEnvironment.AdditionalLibraries.Add("log");
LinkEnvironment.AdditionalLibraries.Add("dl");
}
public override void SetUpSpecificEnvironment(ReadOnlyTargetRules Target, CppCompileEnvironment CompileEnvironment, LinkEnvironment LinkEnvironment)
{
CompileEnvironment.Definitions.Add("PLATFORM_LUMIN=1");
CompileEnvironment.Definitions.Add("USE_ANDROID_JNI=0");
CompileEnvironment.Definitions.Add("USE_ANDROID_AUDIO=0");
CompileEnvironment.Definitions.Add("USE_ANDROID_FILE=0");
CompileEnvironment.Definitions.Add("USE_ANDROID_INPUT=0");
CompileEnvironment.Definitions.Add("USE_ANDROID_LAUNCH=0");
CompileEnvironment.Definitions.Add("USE_ANDROID_EVENTS=0");
CompileEnvironment.Definitions.Add("USE_ANDROID_OPENGL=0");
CompileEnvironment.Definitions.Add("WITH_OGGVORBIS=1");
DirectoryReference MLSDKDir = new DirectoryReference(Environment.GetEnvironmentVariable("MLSDK"));
CompileEnvironment.SystemIncludePaths.Add(DirectoryReference.Combine(MLSDKDir, "lumin/stl/gnu-libstdc++/include"));
CompileEnvironment.SystemIncludePaths.Add(DirectoryReference.Combine(MLSDKDir, "lumin/stl/gnu-libstdc++/include/aarch64-linux-android"));
CompileEnvironment.SystemIncludePaths.Add(DirectoryReference.Combine(MLSDKDir, "include"));
LinkEnvironment.LibraryPaths.Add(DirectoryReference.Combine(MLSDKDir, "lib/lumin"));
LinkEnvironment.LibraryPaths.Add(DirectoryReference.Combine(MLSDKDir, "lumin/stl/gnu-libstdc++/lib"));
LinkEnvironment.AdditionalLibraries.Add("GLESv2");
LinkEnvironment.AdditionalLibraries.Add("EGL");
LinkEnvironment.AdditionalLibraries.Add("ml_lifecycle");
LinkEnvironment.AdditionalLibraries.Add("ml_ext_logging");
LinkEnvironment.AdditionalLibraries.Add("ml_dispatch");
}
/// <summary>
/// Setup the target environment for building
/// </summary>
/// <param name="Target">Settings for the target being compiled</param>
/// <param name="CompileEnvironment">The compile environment for this target</param>
/// <param name="LinkEnvironment">The link environment for this target</param>
public override void SetUpEnvironment(ReadOnlyTargetRules Target, CppCompileEnvironment CompileEnvironment, LinkEnvironment LinkEnvironment)
{
if (Target.Architecture == "-win32")
{
LinkEnvironment.ExcludedLibraries.Add("LIBCMT");
}
CompileEnvironment.Definitions.Add("PLATFORM_HTML5=1");
if (CompileEnvironment.Architecture == "-win32")
{
CompileEnvironment.Definitions.Add("PLATFORM_HTML5_WIN32=1");
LinkEnvironment.AdditionalLibraries.Add("delayimp.lib");
}
else
{
CompileEnvironment.Definitions.Add("PLATFORM_HTML5_BROWSER=1");
}
// @todo needed?
CompileEnvironment.Definitions.Add("UNICODE");
CompileEnvironment.Definitions.Add("_UNICODE");
CompileEnvironment.Definitions.Add("WITH_AUTOMATION_WORKER=0");
CompileEnvironment.Definitions.Add("REQUIRES_ALIGNED_INT_ACCESS");
CompileEnvironment.Definitions.Add("WITH_OGGVORBIS=1");
CompileEnvironment.Definitions.Add("USE_SCENE_LOCK=0");
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="Module">The module with a valid shared PCH</param>
/// <param name="BaseCompileEnvironment">The compile environment to use</param>
/// <param name="HeaderFile">The header file to generate a PCH from</param>
/// <param name="OutputDir">Output directory for instances of this PCH</param>
public PrecompiledHeaderTemplate(UEBuildModuleCPP Module, CppCompileEnvironment BaseCompileEnvironment, FileItem HeaderFile, DirectoryReference OutputDir)
{
this.Module = Module;
this.BaseCompileEnvironment = BaseCompileEnvironment;
this.HeaderFile = HeaderFile;
this.OutputDir = OutputDir;
}
public override void SetUpEnvironment(ReadOnlyTargetRules Target, CppCompileEnvironment CompileEnvironment, LinkEnvironment LinkEnvironment)
{
CompileEnvironment.Definitions.Add("PLATFORM_DESKTOP=0");
CompileEnvironment.Definitions.Add("PLATFORM_CAN_SUPPORT_EDITORONLY_DATA=0");
CompileEnvironment.Definitions.Add("WITH_OGGVORBIS=1");
CompileEnvironment.Definitions.Add("UNICODE");
CompileEnvironment.Definitions.Add("_UNICODE");
CompileEnvironment.Definitions.Add("PLATFORM_ANDROID=1");
CompileEnvironment.Definitions.Add("ANDROID=1");
CompileEnvironment.Definitions.Add("WITH_EDITOR=0");
CompileEnvironment.Definitions.Add("USE_NULL_RHI=0");
SetUpSpecificEnvironment(Target, CompileEnvironment, LinkEnvironment);
// deliberately not linking stl or stdc++ here (c++_shared is default)
LinkEnvironment.SystemLibraries.Add("c");
LinkEnvironment.SystemLibraries.Add("dl");
LinkEnvironment.SystemLibraries.Add("log");
LinkEnvironment.SystemLibraries.Add("m");
LinkEnvironment.SystemLibraries.Add("z");
LinkEnvironment.SystemLibraries.Add("atomic");
}
/// <summary>
/// Setup the target environment for building
/// </summary>
/// <param name="Target">Settings for the target being compiled</param>
/// <param name="CompileEnvironment">The compile environment for this target</param>
/// <param name="LinkEnvironment">The link environment for this target</param>
public override void SetUpEnvironment(ReadOnlyTargetRules Target, CppCompileEnvironment CompileEnvironment, LinkEnvironment LinkEnvironment)
{
CompileEnvironment.Definitions.Add("PLATFORM_IOS=1");
CompileEnvironment.Definitions.Add("PLATFORM_APPLE=1");
CompileEnvironment.Definitions.Add("WITH_TTS=0");
CompileEnvironment.Definitions.Add("WITH_SPEECH_RECOGNITION=0");
CompileEnvironment.Definitions.Add("WITH_DATABASE_SUPPORT=0");
CompileEnvironment.Definitions.Add("WITH_EDITOR=0");
CompileEnvironment.Definitions.Add("USE_NULL_RHI=0");
CompileEnvironment.Definitions.Add("REQUIRES_ALIGNED_INT_ACCESS");
IOSProjectSettings ProjectSettings = ((IOSPlatform)UEBuildPlatform.GetBuildPlatform(UnrealTargetPlatform.IOS)).ReadProjectSettings(Target.ProjectFile);
if (ProjectSettings.bNotificationsEnabled)
{
CompileEnvironment.Definitions.Add("NOTIFICATIONS_ENABLED=1");
}
else
{
CompileEnvironment.Definitions.Add("NOTIFICATIONS_ENABLED=0");
}
if (Target.Architecture == "-simulator")
{
CompileEnvironment.Definitions.Add("WITH_SIMULATOR=1");
}
else
{
CompileEnvironment.Definitions.Add("WITH_SIMULATOR=0");
}
LinkEnvironment.AdditionalFrameworks.Add(new UEBuildFramework("GameKit"));
LinkEnvironment.AdditionalFrameworks.Add(new UEBuildFramework("StoreKit"));
}
private void ExportModuleCpp(UEBuildModuleCPP ModuleCPP, CppCompileEnvironment ModuleCompileEnvironment, JsonWriter Writer)
{
Writer.WriteValue("GeneratedCodeDirectory", ModuleCPP.GeneratedCodeDirectory != null ? ModuleCPP.GeneratedCodeDirectory.FullName : string.Empty);
ToolchainInfo ModuleToolchainInfo = GenerateToolchainInfo(ModuleCompileEnvironment);
if (!ModuleToolchainInfo.Equals(RootToolchainInfo))
{
Writer.WriteObjectStart("ToolchainInfo");
foreach (Tuple <string, object> Field in ModuleToolchainInfo.GetDiff(RootToolchainInfo))
{
WriteField(ModuleCPP.Name, Writer, Field);
}
Writer.WriteObjectEnd();
}
if (ModuleCompileEnvironment.PrecompiledHeaderIncludeFilename != null)
{
string CorrectFilePathPch;
if (ExtractWrappedIncludeFile(ModuleCompileEnvironment.PrecompiledHeaderIncludeFilename, out CorrectFilePathPch))
{
Writer.WriteValue("SharedPCHFilePath", CorrectFilePathPch);
}
}
}
/// <summary>
/// Setup the target environment for building
/// </summary>
/// <param name="Target">Settings for the target being compiled</param>
/// <param name="CompileEnvironment">The compile environment for this target</param>
/// <param name="LinkEnvironment">The link environment for this target</param>
public override void SetUpEnvironment(ReadOnlyTargetRules Target, CppCompileEnvironment CompileEnvironment, LinkEnvironment LinkEnvironment)
{
CompileEnvironment.Definitions.Add("WITH_DATABASE_SUPPORT=0"); //@todo linux: valid?
// During the native builds, check the system includes as well (check toolchain when cross-compiling?)
string BaseLinuxPath = SDK.GetBaseLinuxPathForArchitecture(Target.Architecture);
if (BuildHostPlatform.Current.Platform == UnrealTargetPlatform.Linux && String.IsNullOrEmpty(BaseLinuxPath))
{
CompileEnvironment.IncludePaths.SystemIncludePaths.Add(new DirectoryReference("/usr/include"));
}
if (CompileEnvironment.bAllowLTCG != LinkEnvironment.bAllowLTCG)
{
Log.TraceWarning("Inconsistency between LTCG settings in Compile and Link environments: link one takes priority");
CompileEnvironment.bAllowLTCG = LinkEnvironment.bAllowLTCG;
}
// disable to LTO for modular builds
if (CompileEnvironment.bAllowLTCG && Target.LinkType != TargetLinkType.Monolithic)
{
Log.TraceWarning("LTO (LTCG) for modular builds is not supported, disabling it");
CompileEnvironment.bAllowLTCG = false;
LinkEnvironment.bAllowLTCG = false;
}
// link with Linux libraries.
LinkEnvironment.AdditionalLibraries.Add("pthread");
// let this class or a sub class do settings specific to that class
SetUpSpecificEnvironment(CompileEnvironment, LinkEnvironment);
}
/// <summary>
/// Setup the target environment for building
/// </summary>
/// <param name="Target">Settings for the target being compiled</param>
/// <param name="CompileEnvironment">The compile environment for this target</param>
/// <param name="LinkEnvironment">The link environment for this target</param>
public override void SetUpEnvironment(ReadOnlyTargetRules Target, CppCompileEnvironment CompileEnvironment, LinkEnvironment LinkEnvironment)
{
base.SetUpEnvironment(Target, CompileEnvironment, LinkEnvironment);
CompileEnvironment.Definitions.Add("PLATFORM_TVOS=1");
// TVOS uses only IOS header files, so use it's platform headers
CompileEnvironment.Definitions.Add("OVERRIDE_PLATFORM_HEADER_NAME=IOS");
}
/// <summary>
/// Setup the target environment for building
/// </summary>
/// <param name="Target">Settings for the target being compiled</param>
/// <param name="CompileEnvironment">The compile environment for this target</param>
/// <param name="LinkEnvironment">The link environment for this target</param>
public override void SetUpEnvironment(ReadOnlyTargetRules Target, CppCompileEnvironment CompileEnvironment, LinkEnvironment LinkEnvironment)
{
CompileEnvironment.Definitions.Add("PLATFORM_MAC=1");
CompileEnvironment.Definitions.Add("PLATFORM_APPLE=1");
CompileEnvironment.Definitions.Add("WITH_TTS=0");
CompileEnvironment.Definitions.Add("WITH_SPEECH_RECOGNITION=0");
}
public CppCompileEnvironment CreateBinaryCompileEnvironment(CppCompileEnvironment GlobalCompileEnvironment)
{
CppCompileEnvironment BinaryCompileEnvironment = new CppCompileEnvironment(GlobalCompileEnvironment);
BinaryCompileEnvironment.bIsBuildingDLL = IsBuildingDll(Type);
BinaryCompileEnvironment.bIsBuildingLibrary = IsBuildingLibrary(Type);
return(BinaryCompileEnvironment);
}
/// <summary>
/// Setup the target environment for building
/// </summary>
/// <param name="Target">Settings for the target being compiled</param>
/// <param name="CompileEnvironment">The compile environment for this target</param>
/// <param name="LinkEnvironment">The link environment for this target</param>
public override void SetUpEnvironment(ReadOnlyTargetRules Target, CppCompileEnvironment CompileEnvironment, LinkEnvironment LinkEnvironment)
{
CompileEnvironment.Definitions.Add("PLATFORM_IOS=1");
CompileEnvironment.Definitions.Add("PLATFORM_APPLE=1");
CompileEnvironment.Definitions.Add("GLES_SILENCE_DEPRECATION=1"); // suppress GLES "deprecated" warnings until a proper solution is implemented (see UE-65643)
CompileEnvironment.Definitions.Add("WITH_TTS=0");
CompileEnvironment.Definitions.Add("WITH_SPEECH_RECOGNITION=0");
CompileEnvironment.Definitions.Add("WITH_DATABASE_SUPPORT=0");
CompileEnvironment.Definitions.Add("WITH_EDITOR=0");
CompileEnvironment.Definitions.Add("USE_NULL_RHI=0");
IOSProjectSettings ProjectSettings = ((IOSPlatform)UEBuildPlatform.GetBuildPlatform(Target.Platform)).ReadProjectSettings(Target.ProjectFile);
if (ProjectSettings.bNotificationsEnabled)
{
CompileEnvironment.Definitions.Add("NOTIFICATIONS_ENABLED=1");
}
else
{
CompileEnvironment.Definitions.Add("NOTIFICATIONS_ENABLED=0");
}
if (ProjectSettings.bBackgroundFetchEnabled)
{
CompileEnvironment.Definitions.Add("BACKGROUNDFETCH_ENABLED=1");
}
else
{
CompileEnvironment.Definitions.Add("BACKGROUNDFETCH_ENABLED=0");
}
CompileEnvironment.Definitions.Add("UE_DISABLE_FORCE_INLINE=" + (ProjectSettings.bDisableForceInline ? "1" : "0"));
if (Target.Architecture == "-simulator")
{
CompileEnvironment.Definitions.Add("WITH_SIMULATOR=1");
}
else
{
CompileEnvironment.Definitions.Add("WITH_SIMULATOR=0");
}
// if the project has an Oodle compression Dll, enable the decompressor on IOS
if (Target.ProjectFile != null)
{
DirectoryReference ProjectDir = DirectoryReference.GetParentDirectory(Target.ProjectFile);
string OodleDllPath = DirectoryReference.Combine(ProjectDir, "Binaries/ThirdParty/Oodle/Mac/libUnrealPakPlugin.dylib").FullName;
if (File.Exists(OodleDllPath))
{
Log.TraceVerbose(" Registering custom oodle compressor for {0}", UnrealTargetPlatform.IOS.ToString());
CompileEnvironment.Definitions.Add("REGISTER_OODLE_CUSTOM_COMPRESSOR=1");
}
}
LinkEnvironment.AdditionalFrameworks.Add(new UEBuildFramework("GameKit"));
LinkEnvironment.AdditionalFrameworks.Add(new UEBuildFramework("StoreKit"));
LinkEnvironment.AdditionalFrameworks.Add(new UEBuildFramework("DeviceCheck"));
}
/// <summary>
/// Copy constructor.
/// </summary>
/// <param name="Other">Environment to copy settings from</param>
public CppCompileEnvironment(CppCompileEnvironment Other)
{
Platform = Other.Platform;
Configuration = Other.Configuration;
Architecture = Other.Architecture;
MetadataCache = Other.MetadataCache;
SharedPCHs = Other.SharedPCHs;
PrecompiledHeaderIncludeFilename = Other.PrecompiledHeaderIncludeFilename;
PrecompiledHeaderAction = Other.PrecompiledHeaderAction;
bUseSharedBuildEnvironment = Other.bUseSharedBuildEnvironment;
bUseRTTI = Other.bUseRTTI;
bUseInlining = Other.bUseInlining;
bCompileISPC = Other.bCompileISPC;
bUseAVX = Other.bUseAVX;
bUseUnity = Other.bUseUnity;
MinSourceFilesForUnityBuildOverride = Other.MinSourceFilesForUnityBuildOverride;
MinFilesUsingPrecompiledHeaderOverride = Other.MinFilesUsingPrecompiledHeaderOverride;
bBuildLocallyWithSNDBS = Other.bBuildLocallyWithSNDBS;
bEnableExceptions = Other.bEnableExceptions;
bEnableObjCExceptions = Other.bEnableObjCExceptions;
ShadowVariableWarningLevel = Other.ShadowVariableWarningLevel;
UnsafeTypeCastWarningLevel = Other.UnsafeTypeCastWarningLevel;
bUndefinedIdentifierWarningsAsErrors = Other.bUndefinedIdentifierWarningsAsErrors;
bEnableUndefinedIdentifierWarnings = Other.bEnableUndefinedIdentifierWarnings;
bOptimizeCode = Other.bOptimizeCode;
bOptimizeForSize = Other.bOptimizeForSize;
bCreateDebugInfo = Other.bCreateDebugInfo;
bIsBuildingLibrary = Other.bIsBuildingLibrary;
bIsBuildingDLL = Other.bIsBuildingDLL;
bUseStaticCRT = Other.bUseStaticCRT;
bUseDebugCRT = Other.bUseDebugCRT;
bOmitFramePointers = Other.bOmitFramePointers;
bEnableOSX109Support = Other.bEnableOSX109Support;
bUsePDBFiles = Other.bUsePDBFiles;
bPreprocessOnly = Other.bPreprocessOnly;
bSupportEditAndContinue = Other.bSupportEditAndContinue;
bUseIncrementalLinking = Other.bUseIncrementalLinking;
bAllowLTCG = Other.bAllowLTCG;
bPGOOptimize = Other.bPGOOptimize;
bPGOProfile = Other.bPGOProfile;
PGOFilenamePrefix = Other.PGOFilenamePrefix;
PGODirectory = Other.PGODirectory;
bPrintTimingInfo = Other.bPrintTimingInfo;
bGenerateDependenciesFile = Other.bGenerateDependenciesFile;
bAllowRemotelyCompiledPCHs = Other.bAllowRemotelyCompiledPCHs;
UserIncludePaths = new HashSet <DirectoryReference>(Other.UserIncludePaths);
SystemIncludePaths = new HashSet <DirectoryReference>(Other.SystemIncludePaths);
bCheckSystemHeadersForModification = Other.bCheckSystemHeadersForModification;
ForceIncludeFiles.AddRange(Other.ForceIncludeFiles);
AdditionalPrerequisites.AddRange(Other.AdditionalPrerequisites);
Definitions.AddRange(Other.Definitions);
AdditionalArguments = Other.AdditionalArguments;
AdditionalFrameworks.AddRange(Other.AdditionalFrameworks);
PrecompiledHeaderFile = Other.PrecompiledHeaderFile;
bHackHeaderGenerator = Other.bHackHeaderGenerator;
bHideSymbolsByDefault = Other.bHideSymbolsByDefault;
CppStandard = Other.CppStandard;
}
string GetCLArguments_Global(CppCompileEnvironment CompileEnvironment)
{
string Result = GetSharedArguments_Global(CompileEnvironment.Configuration, CompileEnvironment.bOptimizeForSize, CompileEnvironment.Architecture, CompileEnvironment.bEnableShadowVariableWarnings, CompileEnvironment.bShadowVariableWarningsAsErrors, CompileEnvironment.bEnableUndefinedIdentifierWarnings, CompileEnvironment.bUndefinedIdentifierWarningsAsErrors, CompileEnvironment.bUseInlining);
// no longer needed as of UE4.18
// Result += " -Wno-reorder"; // we disable constructor order warnings.
return(Result);
}
/// <summary>
/// Write a Target to a JSON writer. Is array is empty, don't write anything
/// </summary>
/// <param name="Target"></param>
/// <param name="Writer">Writer for the array data</param>
private static void ExportTarget(UEBuildTarget Target, JsonWriter Writer)
{
Writer.WriteObjectStart();
Writer.WriteValue("Name", Target.TargetName);
Writer.WriteValue("Configuration", Target.Configuration.ToString());
Writer.WriteValue("Platform", Target.Platform.ToString());
Writer.WriteValue("TargetFile", Target.TargetRulesFile.FullName);
if (Target.ProjectFile != null)
{
Writer.WriteValue("ProjectFile", Target.ProjectFile.FullName);
}
ExportEnvironmentToJson(Target, Writer);
if (Target.Binaries.Any())
{
Writer.WriteArrayStart("Binaries");
foreach (UEBuildBinary Binary in Target.Binaries)
{
Writer.WriteObjectStart();
ExportBinary(Binary, Writer);
Writer.WriteObjectEnd();
}
Writer.WriteArrayEnd();
}
CppCompileEnvironment GlobalCompileEnvironment = Target.CreateCompileEnvironmentForProjectFiles();
HashSet <string> ModuleNames = new HashSet <string>();
Writer.WriteObjectStart("Modules");
foreach (UEBuildBinary Binary in Target.Binaries)
{
CppCompileEnvironment BinaryCompileEnvironment = Binary.CreateBinaryCompileEnvironment(GlobalCompileEnvironment);
foreach (UEBuildModule Module in Binary.Modules)
{
if (ModuleNames.Add(Module.Name))
{
Writer.WriteObjectStart(Module.Name);
ExportModule(Module, Binary.OutputDir, Target.GetExecutableDir(), Writer);
UEBuildModuleCPP ModuleCpp = Module as UEBuildModuleCPP;
if (ModuleCpp != null)
{
CppCompileEnvironment ModuleCompileEnvironment = ModuleCpp.CreateCompileEnvironmentForIntellisense(Target.Rules, BinaryCompileEnvironment);
ExportModuleCpp(ModuleCpp, ModuleCompileEnvironment, Writer);
}
Writer.WriteObjectEnd();
}
}
}
Writer.WriteObjectEnd();
ExportPluginsFromTarget(Target, Writer);
Writer.WriteObjectEnd();
}
public virtual void SetUpSpecificEnvironment(CppCompileEnvironment CompileEnvironment, LinkEnvironment LinkEnvironment)
{
CompileEnvironment.Definitions.Add("PLATFORM_LINUX=1");
CompileEnvironment.Definitions.Add("PLATFORM_UNIX=1");
CompileEnvironment.Definitions.Add("LINUX=1"); // For libOGG
// this define does not set jemalloc as default, just indicates its support
CompileEnvironment.Definitions.Add("PLATFORM_SUPPORTS_JEMALLOC=1");
}
public override CPPOutput CompileRCFiles(CppCompileEnvironment CompileEnvironment, List <FileItem> RCFiles, ActionGraph ActionGraph)
{
CPPOutput Result = new CPPOutput();
if (CompileEnvironment.Architecture == "-win32") // simulator
{
return(base.CompileRCFiles(CompileEnvironment, RCFiles, ActionGraph));
}
return(Result);
}
static string GetCLArguments_CPP(CppCompileEnvironment CompileEnvironment)
{
string Result = "";
if (CompileEnvironment.Architecture != "-win32") // ! simulator
{
Result = " -std=c++14";
}
return(Result);
}
string GetCLArguments_Global(CppCompileEnvironment CompileEnvironment)
{
string Result = GetSharedArguments_Global(CompileEnvironment.Configuration, CompileEnvironment.bOptimizeForSize, CompileEnvironment.Architecture, CompileEnvironment.bEnableShadowVariableWarnings, CompileEnvironment.bShadowVariableWarningsAsErrors, CompileEnvironment.bEnableUndefinedIdentifierWarnings, CompileEnvironment.bUndefinedIdentifierWarningsAsErrors);
if (CompileEnvironment.Architecture != "-win32") // ! simulator
{
Result += " -Wno-reorder"; // we disable constructor order warnings.
}
return(Result);
}
/// <summary>
/// Setup the target environment for building
/// </summary>
/// <param name="Target">Settings for the target being compiled</param>
/// <param name="CompileEnvironment">The compile environment for this target</param>
/// <param name="LinkEnvironment">The link environment for this target</param>
public override void SetUpEnvironment(ReadOnlyTargetRules Target, CppCompileEnvironment CompileEnvironment, LinkEnvironment LinkEnvironment)
{
CompileEnvironment.Definitions.Add("PLATFORM_HTML5=1");
// @todo needed?
CompileEnvironment.Definitions.Add("UNICODE");
CompileEnvironment.Definitions.Add("_UNICODE");
CompileEnvironment.Definitions.Add("WITH_AUTOMATION_WORKER=0");
CompileEnvironment.Definitions.Add("WITH_OGGVORBIS=1");
CompileEnvironment.Definitions.Add("USE_SCENE_LOCK=0");
}
static string GetCLArguments_Global(CppCompileEnvironment CompileEnvironment)
{
string Result = GetSharedArguments_Global(CompileEnvironment.Configuration, CompileEnvironment.Architecture, CompileEnvironment.bEnableShadowVariableWarnings, CompileEnvironment.bShadowVariableWarningsAsErrors, CompileEnvironment.bEnableUndefinedIdentifierWarnings, CompileEnvironment.bUndefinedIdentifierWarningsAsErrors);
if (CompileEnvironment.Architecture != "-win32") // ! simulator
{
// do we want debug info?
// if (CompileEnvironment.bCreateDebugInfo)
// {
// Result += " -g";
//
// // dump headers: http://stackoverflow.com/questions/42308/tool-to-track-include-dependencies
// Result += " -H";
// }
// Result += " -Wno-warn-absolute-paths "; // as of emscripten 1.35.0 complains that this is unknown
Result += " -Wno-reorder"; // we disable constructor order warnings.
if (CompileEnvironment.Configuration == CppConfiguration.Debug || CompileEnvironment.Configuration == CppConfiguration.Development)
{
Result += " -s GL_ASSERTIONS=1";
}
if (!CompileEnvironment.bOptimizeCode)
{
Result += " -O0";
}
else // development & shipiing
{
Result += " -s ASM_JS=1";
if (CompileEnvironment.bOptimizeForSize)
{
Result += " -Oz -s OUTLINING_LIMIT=40000";
}
else
{
Result += " -s OUTLINING_LIMIT=110000";
if (CompileEnvironment.Configuration == CppConfiguration.Development)
{
Result += " -O2";
}
if (CompileEnvironment.Configuration == CppConfiguration.Shipping)
{
Result += " -O3";
}
}
}
}
return(Result);
}
/// <summary>
/// Checks whether this template is valid for the given compile environment
/// </summary>
/// <param name="CompileEnvironment">Compile environment to check with</param>
/// <returns>True if the template is compatible with the given compile environment</returns>
public bool IsValidFor(CppCompileEnvironment CompileEnvironment)
{
if (CompileEnvironment.bIsBuildingDLL != BaseCompileEnvironment.bIsBuildingDLL)
{
return(false);
}
if (CompileEnvironment.bIsBuildingLibrary != BaseCompileEnvironment.bIsBuildingLibrary)
{
return(false);
}
return(true);
}
/// <summary>
/// Setup the target environment for building
/// </summary>
/// <param name="Target">Settings for the target being compiled</param>
/// <param name="CompileEnvironment">The compile environment for this target</param>
/// <param name="LinkEnvironment">The link environment for this target</param>
public override void SetUpEnvironment(ReadOnlyTargetRules Target, CppCompileEnvironment CompileEnvironment, LinkEnvironment LinkEnvironment)
{
CompileEnvironment.Definitions.Add("PLATFORM_MAC=1");
CompileEnvironment.Definitions.Add("PLATFORM_APPLE=1");
CompileEnvironment.Definitions.Add("WITH_TTS=0");
CompileEnvironment.Definitions.Add("WITH_SPEECH_RECOGNITION=0");
if (!CompileEnvironment.Definitions.Contains("WITH_DATABASE_SUPPORT=0") && !CompileEnvironment.Definitions.Contains("WITH_DATABASE_SUPPORT=1"))
{
CompileEnvironment.Definitions.Add("WITH_DATABASE_SUPPORT=0");
}
}
protected override string GetCLArguments_Global(CppCompileEnvironment CompileEnvironment, string Architecture)
{
string Params = base.GetCLArguments_Global(CompileEnvironment, Architecture);
Params += " -Wno-undefined-var-template";
Params += " -DPLATFORM_LUMINGL4=" + ((GPUArchitectures[0] == "-gl4") ? "1" : "0");
// jf: added for seal, as XGE seems to not preserve case in includes properly
Params += " -Wno-nonportable-include-path"; // not all of these are real
return(Params);
}
/// <summary>
/// Copy constructor.
/// </summary>
/// <param name="Other">Environment to copy settings from</param>
public CppCompileEnvironment(CppCompileEnvironment Other)
{
Platform = Other.Platform;
Configuration = Other.Configuration;
Architecture = Other.Architecture;
OutputDirectory = Other.OutputDirectory;
PCHOutputDirectory = Other.PCHOutputDirectory;
LocalShadowDirectory = Other.LocalShadowDirectory;
PrecompiledHeaderIncludeFilename = Other.PrecompiledHeaderIncludeFilename;
PrecompiledHeaderAction = Other.PrecompiledHeaderAction;
bUseRTTI = Other.bUseRTTI;
bUseInlining = Other.bUseInlining;
bUseAVX = Other.bUseAVX;
bFasterWithoutUnity = Other.bFasterWithoutUnity;
MinSourceFilesForUnityBuildOverride = Other.MinSourceFilesForUnityBuildOverride;
MinFilesUsingPrecompiledHeaderOverride = Other.MinFilesUsingPrecompiledHeaderOverride;
bBuildLocallyWithSNDBS = Other.bBuildLocallyWithSNDBS;
bEnableExceptions = Other.bEnableExceptions;
bEnableObjCExceptions = Other.bEnableObjCExceptions;
bShadowVariableWarningsAsErrors = Other.bShadowVariableWarningsAsErrors;
bEnableShadowVariableWarnings = Other.bEnableShadowVariableWarnings;
bUndefinedIdentifierWarningsAsErrors = Other.bUndefinedIdentifierWarningsAsErrors;
bEnableUndefinedIdentifierWarnings = Other.bEnableUndefinedIdentifierWarnings;
bOptimizeCode = Other.bOptimizeCode;
bOptimizeForSize = Other.bOptimizeForSize;
bCreateDebugInfo = Other.bCreateDebugInfo;
bIsBuildingLibrary = Other.bIsBuildingLibrary;
bIsBuildingDLL = Other.bIsBuildingDLL;
bUseStaticCRT = Other.bUseStaticCRT;
bUseDebugCRT = Other.bUseDebugCRT;
bOmitFramePointers = Other.bOmitFramePointers;
bEnableOSX109Support = Other.bEnableOSX109Support;
bUsePDBFiles = Other.bUsePDBFiles;
bSupportEditAndContinue = Other.bSupportEditAndContinue;
bUseIncrementalLinking = Other.bUseIncrementalLinking;
bAllowLTCG = Other.bAllowLTCG;
bPGOOptimize = Other.bPGOOptimize;
bPGOProfile = Other.bPGOProfile;
PGOFilenamePrefix = Other.PGOFilenamePrefix;
PGODirectory = Other.PGODirectory;
bPrintTimingInfo = Other.bPrintTimingInfo;
bAllowRemotelyCompiledPCHs = Other.bAllowRemotelyCompiledPCHs;
IncludePaths = new CppIncludePaths(Other.IncludePaths);
ForceIncludeFiles.AddRange(Other.ForceIncludeFiles);
Definitions.AddRange(Other.Definitions);
AdditionalArguments = Other.AdditionalArguments;
AdditionalFrameworks.AddRange(Other.AdditionalFrameworks);
PrecompiledHeaderFile = Other.PrecompiledHeaderFile;
Headers = Other.Headers;
bHackHeaderGenerator = Other.bHackHeaderGenerator;
bHideSymbolsByDefault = Other.bHideSymbolsByDefault;
}
public void GatherDataForProjectFiles(ReadOnlyTargetRules Target, CppCompileEnvironment GlobalCompileEnvironment)
{
CppCompileEnvironment BinaryCompileEnvironment = CreateBinaryCompileEnvironment(GlobalCompileEnvironment);
foreach (UEBuildModuleCPP Module in Modules.OfType <UEBuildModuleCPP>())
{
ProjectFile ProjectFileForIDE;
if (ProjectFileGenerator.ModuleToProjectFileMap.TryGetValue(Module.Name, out ProjectFileForIDE))
{
Module.GatherDataForProjectFile(Target, BinaryCompileEnvironment, ProjectFileForIDE);
}
}
}
private static void ExportModuleCpp(UEBuildModuleCPP ModuleCPP, CppCompileEnvironment ModuleCompileEnvironment, JsonWriter Writer)
{
Writer.WriteValue("GeneratedCodeDirectory", ModuleCPP.GeneratedCodeDirectory != null ? ModuleCPP.GeneratedCodeDirectory.FullName : string.Empty);
if (ModuleCompileEnvironment.PrecompiledHeaderIncludeFilename != null)
{
string CorrectFilePathPch;
if (ExtractWrappedIncludeFile(ModuleCompileEnvironment.PrecompiledHeaderIncludeFilename, out CorrectFilePathPch))
{
Writer.WriteValue("SharedPCHFilePath", CorrectFilePathPch);
}
}
}
/// <summary>
/// Write C++ toolchain information to JSON writer
/// </summary>
/// <param name="Target"></param>
/// <param name="Writer"></param>
private void ExportEnvironmentToJson(UEBuildTarget Target, JsonWriter Writer)
{
CppCompileEnvironment GlobalCompileEnvironment = Target.CreateCompileEnvironmentForProjectFiles();
RootToolchainInfo = GenerateToolchainInfo(GlobalCompileEnvironment);
Writer.WriteObjectStart("ToolchainInfo");
foreach (Tuple <string, object> Field in RootToolchainInfo.GetFields())
{
WriteField(Target.TargetName, Writer, Field);
}
Writer.WriteObjectEnd();
Writer.WriteArrayStart("EnvironmentIncludePaths");
foreach (DirectoryReference Path in GlobalCompileEnvironment.UserIncludePaths)
{
Writer.WriteValue(Path.FullName);
}
foreach (DirectoryReference Path in GlobalCompileEnvironment.SystemIncludePaths)
{
Writer.WriteValue(Path.FullName);
}
if (UEBuildPlatform.IsPlatformInGroup(Target.Platform, UnrealPlatformGroup.Windows))
{
foreach (DirectoryReference Path in Target.Rules.WindowsPlatform.Environment.IncludePaths)
{
Writer.WriteValue(Path.FullName);
}
}
else if (UEBuildPlatform.IsPlatformInGroup(Target.Platform, UnrealPlatformGroup.Apple) &&
UEBuildPlatform.IsPlatformInGroup(BuildHostPlatform.Current.Platform, UnrealPlatformGroup.Apple))
{
// Only generate Apple system include paths when host platform is Apple OS
// TODO: Fix case when working with MacOS on Windows host platform
foreach (string Path in AppleHelper.GetAppleSystemIncludePaths(GlobalCompileEnvironment.Architecture, Target.Platform))
{
Writer.WriteValue(Path);
}
}
// TODO: get corresponding includes for Linux
Writer.WriteArrayEnd();
Writer.WriteArrayStart("EnvironmentDefinitions");
foreach (string Definition in GlobalCompileEnvironment.Definitions)
{
Writer.WriteValue(Definition);
}
Writer.WriteArrayEnd();
}
