public override void SetupGlobalEnvironment(
TargetInfo Target,
ref LinkEnvironmentConfiguration OutLinkEnvironmentConfiguration,
ref CPPEnvironmentConfiguration OutCPPEnvironmentConfiguration
)
{
// Turn off various third party features we don't need
// Currently we force Lean and Mean mode
UEBuildConfiguration.bCompileLeanAndMeanUE = true;
// Currently this app is not linking against the engine, so we'll compile out references from Core to the rest of the engine
UEBuildConfiguration.bCompileAgainstEngine = false;
UEBuildConfiguration.bCompileAgainstCoreUObject = false;
UEBuildConfiguration.bBuildWithEditorOnlyData = true;
// Never use malloc profiling in ShaderCompileWorker.
BuildConfiguration.bUseMallocProfiler = false;
// Force all shader formats to be built and included.
UEBuildConfiguration.bForceBuildShaderFormats = true;
// ShaderCompileWorker is a console application, not a Windows app (sets entry point to main(), instead of WinMain())
OutLinkEnvironmentConfiguration.bIsBuildingConsoleApplication = true;
// Disable logging, as the workers are spawned often and logging will just slow them down
OutCPPEnvironmentConfiguration.Definitions.Add("ALLOW_LOG_FILE=0");
// Linking against wer.lib/wer.dll causes XGE to bail when the worker is run on a Windows 8 machine, so turn this off.
OutCPPEnvironmentConfiguration.Definitions.Add("ALLOW_WINDOWS_ERROR_REPORT_LIB=0");
}
public OneSkyLocalizationService(TargetInfo Target)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"InputCore",
"Slate",
"SlateCore",
"EditorStyle",
"LocalizationService",
"Json",
"Internationalization",
"HTTP",
"Serialization",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"LocalizationService",
"Json",
"Internationalization",
"HTTP",
}
);
}
public ScreenShotComparisonTools(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AutomationMessages",
"UnrealEdMessages",
"Slate",
"EditorStyle",
"ImageWrapper",
"Json",
"JsonUtilities"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Messaging"
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Developer/ScreenShotComparisonTools/Private"
}
);
}
public bool LoadHydraLib(TargetInfo Target)
{
bool isLibrarySupported = false;
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
isLibrarySupported = true;
string PlatformString = (Target.Platform == UnrealTargetPlatform.Win64) ? "x64" : "x32";
string LibrariesPath = Path.Combine(ThirdPartyPath, "Sixense", "Lib");
//Lib based bind unsupported due to sixense wrong lib version compile, limiting platforms to windows 32/64
//PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "sixense_s_" + PlatformString + ".lib"));
}
if (isLibrarySupported)
{
// Include path
PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "Sixense", "Include"));
}
//Definitions.Add(string.Format("WITH_HYDRA_BINDING={0}", isLibrarySupported ? 1 : 0));
return isLibrarySupported;
}
public SceneOutliner(TargetInfo Target)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"SlateCore",
"EditorStyle",
"UnrealEd",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"LevelEditor"
}
);
}
public CodeView(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Slate",
"InputCore",
"Core",
"CoreUObject",
"Engine",
"UnrealEd",
"EditorStyle",
"PropertyEditor",
"DesktopPlatform",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"DetailCustomizations",
"SlateCore",
}
);
}
public override void SetupGlobalEnvironment(
TargetInfo Target,
ref LinkEnvironmentConfiguration OutLinkEnvironmentConfiguration,
ref CPPEnvironmentConfiguration OutCPPEnvironmentConfiguration
)
{
UEBuildConfiguration.bCompileNetworkProfiler = false;
// Lean and mean
UEBuildConfiguration.bCompileLeanAndMeanUE = true;
// Never use malloc profiling in Unreal Header Tool. We set this because often UHT is compiled right before the engine
// automatically by Unreal Build Tool, but if bUseMallocProfiler is defined, UHT can operate incorrectly.
BuildConfiguration.bUseMallocProfiler = false;
// No editor needed
UEBuildConfiguration.bBuildEditor = false;
// Editor-only data, however, is needed
UEBuildConfiguration.bBuildWithEditorOnlyData = true;
// Currently this app is not linking against the engine, so we'll compile out references from Core to the rest of the engine
UEBuildConfiguration.bCompileAgainstEngine = false;
UEBuildConfiguration.bCompileAgainstCoreUObject = false;
// UnrealHeaderTool is a console application, not a Windows app (sets entry point to main(), instead of WinMain())
OutLinkEnvironmentConfiguration.bIsBuildingConsoleApplication = true;
}
public MeshUtilities(TargetInfo Target)
{
PrivateDependencyModuleNames.AddRange(
new string [] {
"Core",
"CoreUObject",
"Engine",
"RawMesh",
"RenderCore", // For FPackedNormal
"Slate", // For FSlateTextureAtlas
"SlateCore",
"UnrealEd",
}
);
AddThirdPartyPrivateStaticDependencies(Target, "nvTriStrip");
AddThirdPartyPrivateStaticDependencies(Target, "ForsythTriOptimizer");
AddThirdPartyPrivateStaticDependencies(Target, "MeshSimplifier");
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
AddThirdPartyPrivateStaticDependencies(Target, "DX9");
}
if (UEBuildConfiguration.bCompileSimplygon == true)
{
AddThirdPartyPrivateDynamicDependencies(Target, "SimplygonMeshReduction");
}
}
public DirectShow(TargetInfo Target)
{
Type = ModuleType.External;
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
string DirectShowLibPath = UEBuildConfiguration.UEThirdPartySourceDirectory
+ "DirectShow/DirectShow-1.0.0/Lib/" + ((Target.Platform == UnrealTargetPlatform.Win32) ? "Win32" : "Win64") + "/vs" + WindowsPlatform.GetVisualStudioCompilerVersionName() + "/";
PublicIncludePaths.Add(UEBuildConfiguration.UEThirdPartySourceDirectory + "DirectShow/DirectShow-1.0.0/src/Public");
PublicLibraryPaths.Add( DirectShowLibPath );
string LibraryName = "DirectShow";
if (Target.Configuration == UnrealTargetConfiguration.Debug && BuildConfiguration.bDebugBuildsActuallyUseDebugCRT)
{
LibraryName += "d";
}
if (Target.Platform == UnrealTargetPlatform.Win64)
{
LibraryName += "_64";
}
LibraryName += ".lib";
PublicAdditionalLibraries.Add(LibraryName);
}
}
public override void SetupGlobalEnvironment(
TargetInfo Target,
ref LinkEnvironmentConfiguration OutLinkEnvironmentConfiguration,
ref CPPEnvironmentConfiguration OutCPPEnvironmentConfiguration
)
{
if( UnrealBuildTool.UnrealBuildTool.BuildingRocket() )
{
UEBuildConfiguration.bCompileLeanAndMeanUE = true;
// Don't need editor or editor only data
UEBuildConfiguration.bBuildEditor = false;
UEBuildConfiguration.bBuildWithEditorOnlyData = false;
UEBuildConfiguration.bCompileAgainstEngine = true;
// Tag it as a Rocket build
OutCPPEnvironmentConfiguration.Definitions.Add("UE_ROCKET=1");
// no exports, so no need to verify that a .lib and .exp file was emitted by the linker.
OutLinkEnvironmentConfiguration.bHasExports = false;
}
else
{
// Tag it as a UE4Game build
OutCPPEnvironmentConfiguration.Definitions.Add("UE4GAME=1");
}
}
public MovieSceneCaptureDialog(TargetInfo Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"Editor/MovieSceneCaptureDialog/Private"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"EditorStyle",
"Engine",
"InputCore",
"Json",
"JsonUtilities",
"MovieScene",
"MovieSceneCapture",
"PropertyEditor",
"SessionServices",
"Slate",
"SlateCore",
"UnrealEd",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"LevelEditor"
}
);
}
public ClassViewer(TargetInfo Target)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetRegistry",
"EditorWidgets",
"PropertyEditor"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"SlateCore",
"EditorStyle",
"UnrealEd",
"PropertyEditor",
"GameProjectGeneration"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AssetRegistry",
"EditorWidgets",
"PropertyEditor"
}
);
}
public BlockConstructorPlugin(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[] {
"BlockConstructorPlugin/Public",
"BlockConstructorPlugin/System",
"BlockConstructorPlugin/UI"
}
);
PrivateIncludePaths.AddRange(
new string[] {
"BlockConstructorPlugin/Private"
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Engine",
"Core",
"CoreUObject",
"Slate",
"UnrealEd"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Engine",
"Projects",
"CoreUObject",
"InputCore",
"UnrealEd",
"LevelEditor",
"PropertyEditor",
"Slate",
"SlateCore"
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public override void SetupGlobalEnvironment(
TargetInfo Target,
ref LinkEnvironmentConfiguration OutLinkEnvironmentConfiguration,
ref CPPEnvironmentConfiguration OutCPPEnvironmentConfiguration
)
{
// Lean and mean
UEBuildConfiguration.bCompileLeanAndMeanUE = true;
// Never use malloc profiling in Unreal Header Tool. We set this because often UHT is compiled right before the engine
// automatically by Unreal Build Tool, but if bUseMallocProfiler is defined, UHT can operate incorrectly.
BuildConfiguration.bUseMallocProfiler = false;
// No editor needed
UEBuildConfiguration.bBuildEditor = false;
// Editor-only data, however, is needed
UEBuildConfiguration.bBuildWithEditorOnlyData = true;
// Currently this app is not linking against the engine, so we'll compile out references from Core to the rest of the engine
UEBuildConfiguration.bCompileAgainstEngine = false;
// Force execption handling across all modules.
UEBuildConfiguration.bForceEnableExceptions = true;
// Plugin support
UEBuildConfiguration.bCompileWithPluginSupport = true;
UEBuildConfiguration.bBuildDeveloperTools = true;
// UnrealHeaderTool is a console application, not a Windows app (sets entry point to main(), instead of WinMain())
OutLinkEnvironmentConfiguration.bIsBuildingConsoleApplication = true;
OutCPPEnvironmentConfiguration.Definitions.Add("HACK_HEADER_GENERATOR=1");
}
public AndroidDeviceProfileSelector(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[] {
"Runtime/AndroidDeviceProfileSelector/Public",
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Runtime/AndroidDeviceProfileSelector/Private",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
}
);
}
public override void SetupGlobalEnvironment(
TargetInfo Target,
ref LinkEnvironmentConfiguration OutLinkEnvironmentConfiguration,
ref CPPEnvironmentConfiguration OutCPPEnvironmentConfiguration
)
{
}
public bool LoadLeapLib(TargetInfo Target)
{
bool isLibrarySupported = false;
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
isLibrarySupported = true;
string PlatformString = (Target.Platform == UnrealTargetPlatform.Win64) ? "Win64" : "Win32";
PublicAdditionalLibraries.Add(Path.Combine(LibraryPath, PlatformString, "Leap.lib"));
PublicDelayLoadDLLs.Add("Leap.dll");
RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/ThirdParty/LeapMotion/" + Target.Platform.ToString() + "/" + "Leap.dll"));
}
else if (Target.Platform == UnrealTargetPlatform.Mac){
isLibrarySupported = true;
string PlatformString = "Mac";
PublicAdditionalLibraries.Add(Path.Combine(BinariesPath, PlatformString, "libLeap.dylib"));
}
return isLibrarySupported;
}
public FluidSurface(TargetInfo Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"FluidSurface/Private",
"FluidSurface/Private/Modifiers"
}
);
PublicIncludePaths.AddRange(
new string[] {
"FluidSurfaceRender/Public"
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"ShaderCore",
"RHI",
"FluidSurfaceEngine"
}
);
}
private bool LoadV8(TargetInfo Target)
{
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
string LibrariesPath = Path.Combine(ThirdPartyPath, "v8", "Libraries", "Windows");
if (Target.Platform == UnrealTargetPlatform.Win64)
{
LibrariesPath = Path.Combine(LibrariesPath, "x64");
}
else
{
LibrariesPath = Path.Combine(LibrariesPath, "x86");
}
LibrariesPath = Path.Combine(LibrariesPath, "Release");
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "icui18n.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "icuuc.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_base.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_libbase.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_libplatform.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_nosnapshot.lib"));
PublicAdditionalLibraries.Add(Path.Combine(LibrariesPath, "v8_snapshot.lib"));
PublicIncludePaths.Add(Path.Combine(ThirdPartyPath, "v8", "Includes"));
Definitions.Add(string.Format("WITH_FLATHEAD=1"));
return true;
}
Definitions.Add(string.Format("WITH_FLATHEAD=0"));
return false;
}
public Godzilla(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });
LoadVRPN(Target);
LoadQuat(Target);
}
public DesktopWidgets(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"Slate",
"SlateCore",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"DesktopPlatform",
"InputCore",
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DesktopWidgets/Private",
"Developer/DesktopWidgets/Private/Widgets",
"Developer/DesktopWidgets/Private/Widgets/Input",
}
);
}
public override void SetupGlobalEnvironment(
TargetInfo Target,
ref LinkEnvironmentConfiguration OutLinkEnvironmentConfiguration,
ref CPPEnvironmentConfiguration OutCPPEnvironmentConfiguration
)
{
OutCPPEnvironmentConfiguration.Definitions.Add("WITH_DATABASE_SUPPORT=1");
UEBuildConfiguration.bCompileLeanAndMeanUE = true;
// Don't need editor
UEBuildConfiguration.bBuildEditor = false;
// MinidumpDiagnostics doesn't ever compile with the engine linked in
UEBuildConfiguration.bCompileAgainstEngine = false;
UEBuildConfiguration.bIncludeADO = true;
// MinidumpDiagnostics.exe has no exports, so no need to verify that a .lib and .exp file was emitted by the linker.
OutLinkEnvironmentConfiguration.bHasExports = false;
// Do NOT produce additional console app exe
OutLinkEnvironmentConfiguration.bIsBuildingConsoleApplication = true;
OutCPPEnvironmentConfiguration.Definitions.Add("MINIDUMPDIAGNOSTICS=1");
}
public override void GetModulesToPrecompile(TargetInfo Target, List<string> ModuleNames)
{
ModuleNames.Add("Launch");
ModuleNames.Add("GameMenuBuilder");
ModuleNames.Add("JsonUtilities");
ModuleNames.Add("RuntimeAssetCache");
ModuleNames.Add("UnrealCodeAnalyzerTests");
if ((Target.Platform == UnrealTargetPlatform.Win32) || (Target.Platform == UnrealTargetPlatform.Win64))
{
ModuleNames.Add("OnlineSubsystemNull");
ModuleNames.Add("OnlineSubsystemAmazon");
if (UEBuildConfiguration.bCompileSteamOSS == true)
{
ModuleNames.Add("OnlineSubsystemSteam");
}
ModuleNames.Add("OnlineSubsystemFacebook");
}
else if (Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux)
{
ModuleNames.Add("OnlineSubsystemNull");
if (UEBuildConfiguration.bCompileSteamOSS == true)
{
ModuleNames.Add("OnlineSubsystemSteam");
}
}
}
public AutomationController(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"AutomationMessages",
"CoreUObject",
"Networking",
"UnrealEdMessages",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"Messaging",
}
);
PrivateIncludePaths.AddRange(
new string[]
{
"Runtime/AutomationController/Private"
}
);
}
public SuperSearch(TargetInfo Target)
{
if (UEBuildConfiguration.bBuildEditor == true)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject", // @todo Mac: for some reason it's needed to link in debug on Mac
"Engine",
"InputCore",
"Json",
"UnrealEd",
"Slate",
"SlateCore",
"EditorStyle",
"HTTP",
"IntroTutorials"
}
);
}
else
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject", // @todo Mac: for some reason it's needed to link in debug on Mac
"InputCore",
"Slate",
"SlateCore",
"HTTP",
"Json",
}
);
}
}
public override void SetupGlobalEnvironment(
TargetInfo Target,
ref LinkEnvironmentConfiguration OutLinkEnvironmentConfiguration,
ref CPPEnvironmentConfiguration OutCPPEnvironmentConfiguration
)
{
UEBuildConfiguration.bCompileNetworkProfiler = false;
UEBuildConfiguration.bCompileLeanAndMeanUE = true;
// Don't need editor
UEBuildConfiguration.bBuildEditor = false;
// CrashReportClient doesn't ever compile with the engine linked in
UEBuildConfiguration.bCompileAgainstEngine = false;
UEBuildConfiguration.bCompileAgainstCoreUObject = false;
UEBuildConfiguration.bIncludeADO = (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32);
// CrashReportClient.exe has no exports, so no need to verify that a .lib and .exp file was emitted by
// the linker.
OutLinkEnvironmentConfiguration.bHasExports = false;
// Do NOT produce additional console app exe
OutLinkEnvironmentConfiguration.bBuildAdditionalConsoleApplication = false;
if (UnrealBuildTool.UnrealBuildTool.BuildingRocket())
{
// Tag it as a Rocket build
OutCPPEnvironmentConfiguration.Definitions.Add("UE_ROCKET=1");
}
}
public DesktopPlatform(TargetInfo Target)
{
PrivateIncludePaths.Add("Developer/DesktopPlatform/Private");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"Json",
}
);
if (Target.Platform == UnrealTargetPlatform.Linux)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateFileDialogs",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateFileDialogs",
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
//AddEngineThirdPartyPrivateStaticDependencies(Target, "LinuxNativeDialogs");
}
}
public MaterialShaderQualitySettings(TargetInfo Target)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"RHI",
}
);
PrivateIncludePathModuleNames.Add("Engine");
if (UEBuildConfiguration.bBuildEditor == true)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Slate",
"SlateCore",
"EditorStyle",
"PropertyEditor",
"TargetPlatform",
"InputCore",
}
);
}
}
public Cascade(TargetInfo Target)
{
PublicIncludePaths.AddRange(
new string[] {
"Editor/DistCurveEditor/Public",
"Editor/UnrealEd/Public",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Core",
"CoreUObject",
"InputCore",
"Engine",
"Slate",
"SlateCore",
"EditorStyle",
"DistCurveEditor",
"UnrealEd",
"RHI"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MainFrame",
"PropertyEditor"
}
);
}
public MeshPaint(TargetInfo Target)
{
PrivateIncludePathModuleNames.Add("AssetTools");
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Core",
"CoreUObject",
"DesktopPlatform",
"Engine",
"InputCore",
"RenderCore",
"RHI",
"ShaderCore",
"Slate",
"SlateCore",
"EditorStyle",
"UnrealEd",
"RawMesh",
"SourceControl"
}
);
DynamicallyLoadedModuleNames.Add("AssetTools");
}
public NamedPipesUE4EditorTarget(TargetInfo Target) : base(Target)
{
Type = TargetType.Editor;
ExtraModuleNames.AddRange(new string[] { "NamedPipesUE4" });
}
public MinecraftEditorTarget(TargetInfo Target)
{
Type = TargetType.Editor;
}
public ToasterMadnessEditorTarget(TargetInfo Target)
{
Type = TargetType.Editor;
}
public DependencyContext Build()
{
bool includeCompilationLibraries = _compilationOptions != null;
IEnumerable <LockFileTargetLibrary> runtimeExports = _projectContext.GetRuntimeLibraries(_excludeFromPublishPackageIds);
IEnumerable <LockFileTargetLibrary> compilationExports =
includeCompilationLibraries ?
_projectContext.GetCompileLibraries(_excludeFromPublishPackageIds) :
Enumerable.Empty <LockFileTargetLibrary>();
var dependencyLookup = compilationExports
.Concat(runtimeExports)
.Distinct()
.Select(library => new Dependency(library.Name, library.Version.ToString()))
.ToDictionary(dependency => dependency.Name, StringComparer.OrdinalIgnoreCase);
var libraryLookup = new LockFileLookup(_projectContext.LockFile);
var runtimeSignature = string.Empty;
IEnumerable <RuntimeLibrary> runtimeLibraries = Enumerable.Empty <RuntimeLibrary>();
if (_includeMainProjectInDepsFile)
{
runtimeLibraries = runtimeLibraries.Concat(new[]
{
GetProjectRuntimeLibrary(
_mainProjectInfo,
_projectContext,
dependencyLookup,
includeCompilationLibraries)
});
}
runtimeLibraries = runtimeLibraries
.Concat(GetRuntimePackLibraries(_runtimePackAssets))
.Concat(GetLibraries(runtimeExports, libraryLookup, dependencyLookup, runtime: true).Cast <RuntimeLibrary>())
.Concat(GetDirectReferenceRuntimeLibraries())
.Concat(GetDependencyReferenceRuntimeLibraries());
IEnumerable <CompilationLibrary> compilationLibraries = Enumerable.Empty <CompilationLibrary>();
if (includeCompilationLibraries)
{
if (_includeMainProjectInDepsFile)
{
compilationLibraries = compilationLibraries.Concat(new[]
{
GetProjectCompilationLibrary(
_mainProjectInfo,
_projectContext,
dependencyLookup,
includeCompilationLibraries)
});
}
compilationLibraries = compilationLibraries
.Concat(GetReferenceAssemblyLibraries())
.Concat(GetLibraries(compilationExports, libraryLookup, dependencyLookup, runtime: false).Cast <CompilationLibrary>())
.Concat(GetDirectReferenceCompilationLibraries());
}
var targetInfo = new TargetInfo(
_projectContext.LockFileTarget.TargetFramework.DotNetFrameworkName,
_projectContext.LockFileTarget.RuntimeIdentifier,
runtimeSignature,
_projectContext.IsPortable);
return(new DependencyContext(
targetInfo,
_compilationOptions ?? CompilationOptions.Default,
compilationLibraries,
runtimeLibraries,
new RuntimeFallbacks[] { }));
}
public Chapter_11EditorTarget(TargetInfo Target) : base(Target)
{
Type = TargetType.Editor;
ExtraModuleNames.AddRange(new string[] { "Chapter_11" });
}
public PixelateTarget(TargetInfo Target) : base(Target)
{
Type = TargetType.Game;
ExtraModuleNames.Add("Pixelate");
}
public LevelEditor(TargetInfo Target)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetTools",
"ClassViewer",
"MainFrame",
"PlacementMode",
"ReferenceViewer",
"SizeMap",
"IntroTutorials",
"AppFramework"
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"Settings",
"UserFeedback",
"IntroTutorials"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Analytics",
"Core",
"CoreUObject",
"DesktopPlatform",
"InputCore",
"Slate",
"SlateCore",
"SlateReflector",
"EditorStyle",
"Engine",
"MessageLog",
"NewsFeed",
"SourceControl",
"SourceControlWindows",
"StatsViewer",
"UnrealEd",
"RenderCore",
"DeviceProfileServices",
"ContentBrowser",
"SceneOutliner",
"ActorPickerMode",
"RHI",
"Projects",
"TargetPlatform",
"EngineSettings",
"PropertyEditor",
"WebBrowser",
"Persona",
"Kismet",
"KismetWidgets"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MainFrame",
"PropertyEditor",
"SceneOutliner",
"ClassViewer",
"DeviceManager",
"SettingsEditor",
"SessionFrontend",
"AutomationWindow",
"Layers",
"WorldBrowser",
"EditorWidgets",
"AssetTools",
"WorkspaceMenuStructure",
"NewLevelDialog",
"DeviceProfileEditor",
"DeviceProfileServices",
"PlacementMode",
"UserFeedback",
"ReferenceViewer",
"SizeMap",
"IntroTutorials"
}
);
}
public HackMWTarget(TargetInfo Target)
{
Type = TargetType.Game;
}
public C_EscapeRoomEditorTarget(TargetInfo Target) : base(Target)
{
Type = TargetType.Editor;
ExtraModuleNames.AddRange(new string[] { "C_EscapeRoom" });
}
public TP_TopDown(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });
}
public GDKTestGymsEditorTarget(TargetInfo Target) : base(Target)
{
Type = TargetType.Editor;
ExtraModuleNames.Add("GDKTestGyms");
}
public CDLODTarget(TargetInfo Target) : base(Target)
{
Type = TargetType.Game;
ExtraModuleNames.AddRange(new string[] { "CDLOD" });
}
public Species_cppEditorTarget(TargetInfo Target) : base(Target)
{
Type = TargetType.Editor;
ExtraModuleNames.Add("Species_cpp");
}
public Noah(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "HeadMountedDisplay" });
}
public GladiatorArenaEditorTarget(TargetInfo Target) : base(Target)
{
Type = TargetType.Editor;
ExtraModuleNames.AddRange(new string[] { "GladiatorArena" });
}
public PgrEditorTarget(TargetInfo Target) : base(Target)
{
Type = TargetType.Editor;
ExtraModuleNames.AddRange(new string[] { "Pgr" });
}
public TutorialSandboxEditorTarget(TargetInfo Target) : base(Target)
{
Type = TargetType.Editor;
ExtraModuleNames.AddRange(new string[] { "TutorialSandbox" });
}
public Mega_lo_ManiaTarget(TargetInfo Target) : base(Target)
{
Type = TargetType.Game;
ExtraModuleNames.AddRange(new string[] { "Mega_lo_Mania" });
}
public VRTestingEditorTarget(TargetInfo Target)
{
Type = TargetType.Editor;
}
public BattleTanksTarget(TargetInfo Target) : base(Target)
{
Type = TargetType.Game;
ExtraModuleNames.AddRange(new string[] { "BattleTanks" });
}
public TestCrawlerTarget(TargetInfo Target) : base(Target)
{
Type = TargetType.Game;
DefaultBuildSettings = BuildSettingsVersion.V2;
ExtraModuleNames.Add("TestCrawler");
}
public MaterialAndShadingTarget(TargetInfo Target) : base(Target)
{
Type = TargetType.Game;
ExtraModuleNames.AddRange(new string[] { "MaterialAndShading" });
}
public ShaderPluginDemoTarget(TargetInfo Target) : base(Target)
{
Type = TargetType.Game;
ExtraModuleNames.AddRange(new string[] { "ShaderPluginDemo" });
}
public CodingProjectEditorTarget(TargetInfo Target) : base(Target)
{
Type = TargetType.Editor;
DefaultBuildSettings = BuildSettingsVersion.V2;
ExtraModuleNames.AddRange(new string[] { "CodingProject" });
}
public UnrealLightmass(TargetInfo Target)
{
PublicIncludePaths.Add("Runtime/Launch/Public");
PrivateDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "zlib", "SwarmInterface", "Projects" });
Definitions.Add("UE_LIGHTMASS=1");
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX9");
// Unreallightmass requires GetProcessMemoryInfo exported by psapi.dll. http://msdn.microsoft.com/en-us/library/windows/desktop/ms683219(v=vs.85).aspx
PublicAdditionalLibraries.Add("psapi.lib");
PrivateDependencyModuleNames.AddRange(
new string[] {
"Messaging",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux)
{
// On Mac/Linux UnrealLightmass is executed locally and communicates with the editor using Messaging module instead of SwarmAgent
// @todo: allow for better plug-in support in standalone Slate apps
PrivateDependencyModuleNames.AddRange(
new string[] {
"Networking",
"Sockets",
"Messaging",
"UdpMessaging",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Messaging",
}
);
}
// Lightmass ray tracing is 8% faster with buffer security checks disabled due to fixed size arrays on the stack in the kDOP ray tracing functions
// Warning: This means buffer overwrites will not be detected
bEnableBufferSecurityChecks = false;
PrivateIncludePaths.Add("Runtime/Launch/Private"); // For LaunchEngineLoop.cpp include
PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/Launch");
PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/ImportExport");
PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/CPUSolver");
PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/Lighting");
PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/LightmassCore");
PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/LightmassCore/Misc");
PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/LightmassCore/Math");
PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/LightmassCore/Templates");
PrivateIncludePaths.Add("Programs/UnrealLightmass/Private/LightmassCore/Types");
// EMBREE
if (Target.Platform == UnrealTargetPlatform.Win64)
{
string SDKDir = UEBuildConfiguration.UEThirdPartySourceDirectory + "IntelEmbree/Embree270/Win64/";
PublicIncludePaths.Add(SDKDir + "include");
PublicLibraryPaths.Add(SDKDir + "lib");
PublicAdditionalLibraries.Add("embree.lib");
RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/Win64/embree.dll"));
RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/Win64/tbb.dll"));
RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/Win64/tbbmalloc.dll"));
Definitions.Add("USE_EMBREE=1");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
string SDKDir = UEBuildConfiguration.UEThirdPartySourceDirectory + "IntelEmbree/Embree270/MacOSX/";
PublicIncludePaths.Add(SDKDir + "include");
PublicAdditionalLibraries.Add(SDKDir + "lib/libembree.2.dylib");
RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/Mac/libembree.2.dylib"));
RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/Mac/libtbb.dylib"));
RuntimeDependencies.Add(new RuntimeDependency("$(EngineDir)/Binaries/Mac/libtbbmalloc.dylib"));
Definitions.Add("USE_EMBREE=1");
}
else
{
Definitions.Add("USE_EMBREE=0");
}
}