public NavigationSystem(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.AddRange(
new string[] {
"Runtime/NavigationSystem/Public",
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Runtime/NavigationSystem/Private",
"Runtime/Engine/Private",
"Developer/DerivedDataCache/Public",
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"GeometryCollectionCore",
"GeometryCollectionEngine",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"RHI",
"RenderCore",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"TargetPlatform",
}
);
if (!Target.bBuildRequiresCookedData && Target.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.Add("DerivedDataCache");
}
SetupModulePhysicsSupport(Target);
if (Target.bCompileRecast)
{
PrivateDependencyModuleNames.Add("Navmesh");
PublicDefinitions.Add("WITH_RECAST=1");
}
else
{
// Because we test WITH_RECAST in public Engine header files, we need to make sure that modules
// that import us also have this definition set appropriately. Recast is a private dependency
// module, so it's definitions won't propagate to modules that import Engine.
PublicDefinitions.Add("WITH_RECAST=0");
}
if (Target.bBuildEditor == true)
{
// @todo api: Only public because of WITH_EDITOR and UNREALED_API
PublicDependencyModuleNames.Add("UnrealEd");
CircularlyReferencedDependentModules.Add("UnrealEd");
}
}
public Engine(ReadOnlyTargetRules Target) : base(Target)
{
PrivatePCHHeaderFile = "Private/EnginePrivatePCH.h";
SharedPCHHeaderFile = "Public/EngineSharedPCH.h";
PublicIncludePathModuleNames.AddRange(new string[] { "Renderer", "PacketHandler", "NetworkReplayStreaming", "AudioMixer", "AnimationCore" });
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DerivedDataCache/Public",
"Runtime/SynthBenchmark/Public",
"Runtime/Engine/Private",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"ImageWrapper",
"HeadMountedDisplay",
"EyeTracker",
"MRMesh",
"Advertising",
"NetworkReplayStreaming",
"MovieSceneCapture",
"AutomationWorker",
"MovieSceneCapture",
"DesktopPlatform",
}
);
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(new string[] { "TaskGraph" });
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
}
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"ApplicationCore",
"Json",
"SlateCore",
"Slate",
"InputCore",
"Messaging",
"MessagingCommon",
"RenderCore",
"RHI",
"ShaderCore",
"UtilityShaders",
"AssetRegistry", // Here until FAssetData is moved to engine
"EngineMessages",
"EngineSettings",
"SynthBenchmark",
"GameplayTags",
"DatabaseSupport",
"PacketHandler",
"AudioPlatformConfiguration",
"MeshDescription",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Networking",
"Sockets",
"Landscape",
"UMG",
"Projects",
"MaterialShaderQualitySettings",
"CinematicCamera",
"Analytics",
"AnalyticsET",
}
);
DynamicallyLoadedModuleNames.Add("EyeTracker");
if (Target.bUseXGEController &&
Target.Type == TargetType.Editor &&
(Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32))
{
PrivateDependencyModuleNames.Add("XGEController");
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.Add("Localization");
DynamicallyLoadedModuleNames.Add("Localization");
}
// to prevent "causes WARNING: Non-editor build cannot depend on non-redistributable modules."
if (Target.Type == TargetType.Editor)
{
// for now we depend on this
PrivateDependencyModuleNames.Add("RawMesh");
PrivateDependencyModuleNames.Add("MeshDescriptionOperations");
}
bool bVariadicTemplatesSupported = true;
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
// Use reflection to allow type not to exist if console code is not present
System.Type XboxOnePlatformType = System.Type.GetType("UnrealBuildTool.XboxOnePlatform,UnrealBuildTool");
if (XboxOnePlatformType != null)
{
System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null);
if (VersionName.ToString().Equals("2012"))
{
bVariadicTemplatesSupported = false;
}
}
AddEngineThirdPartyPrivateStaticDependencies(Target,
"libOpus"
);
}
if (bVariadicTemplatesSupported)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
if (Target.Type == TargetType.Editor)
{
// these modules require variadic templates
PrivateDependencyModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
}
}
CircularlyReferencedDependentModules.Add("GameplayTags");
CircularlyReferencedDependentModules.Add("Landscape");
CircularlyReferencedDependentModules.Add("UMG");
CircularlyReferencedDependentModules.Add("MaterialShaderQualitySettings");
CircularlyReferencedDependentModules.Add("CinematicCamera");
// The AnimGraphRuntime module is not needed by Engine proper, but it is loaded in LaunchEngineLoop.cpp,
// and needs to be listed in an always-included module in order to be compiled into standalone games
DynamicallyLoadedModuleNames.Add("AnimGraphRuntime");
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"MovieScene",
"MovieSceneCapture",
"MovieSceneTracks",
"HeadMountedDisplay",
"MRMesh",
"StreamingPauseRendering",
}
);
if (Target.Type != TargetType.Server)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Media",
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Media",
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
}
if (Target.Type == TargetType.Server || Target.Type == TargetType.Editor)
{
PrivateDependencyModuleNames.Add("PerfCounters");
}
if (Target.bBuildDeveloperTools)
{
// Add "BlankModule" so that it gets compiled as an example and will be maintained and tested. This can be removed
// at any time if needed. The module isn't actually loaded by the engine so there is no runtime cost.
DynamicallyLoadedModuleNames.Add("BlankModule");
if (Target.Type != TargetType.Server)
{
PrivateIncludePathModuleNames.Add("MeshUtilities");
DynamicallyLoadedModuleNames.Add("MeshUtilities");
PrivateDependencyModuleNames.AddRange(
new string[] {
"ImageCore",
"RawMesh"
}
);
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping && Target.Configuration != UnrealTargetConfiguration.Test && Target.Type != TargetType.Server)
{
PrivateDependencyModuleNames.Add("CollisionAnalyzer");
CircularlyReferencedDependentModules.Add("CollisionAnalyzer");
PrivateDependencyModuleNames.Add("LogVisualizer");
CircularlyReferencedDependentModules.Add("LogVisualizer");
}
if (Target.Platform == UnrealTargetPlatform.Win64)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"WindowsTargetPlatform",
"WindowsNoEditorTargetPlatform",
"WindowsServerTargetPlatform",
"WindowsClientTargetPlatform",
"AllDesktopTargetPlatform",
"WindowsPlatformEditor",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MacTargetPlatform",
"MacNoEditorTargetPlatform",
"MacServerTargetPlatform",
"MacClientTargetPlatform",
"AllDesktopTargetPlatform",
"MacPlatformEditor",
}
);
}
else if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"LinuxTargetPlatform",
"LinuxNoEditorTargetPlatform",
"LinuxServerTargetPlatform",
"LinuxClientTargetPlatform",
"AllDesktopTargetPlatform",
"LinuxPlatformEditor",
}
);
}
}
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"NetworkReplayStreaming",
"NullNetworkReplayStreaming",
"HttpNetworkReplayStreaming",
"Advertising"
}
);
if (Target.Type != TargetType.Server)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"ImageWrapper"
}
);
}
WhitelistRestrictedFolders.Add("Private/NotForLicensees");
if (!Target.bBuildRequiresCookedData && Target.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"DerivedDataCache",
"TargetPlatform",
"DesktopPlatform"
}
);
}
if (Target.bBuildEditor == true)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"UnrealEd",
"Kismet"
}
); // @todo api: Only public because of WITH_EDITOR and UNREALED_API
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd",
"Kismet"
}
);
PrivateIncludePathModuleNames.Add("TextureCompressor");
PrivateIncludePaths.Add("Developer/TextureCompressor/Public");
PrivateIncludePathModuleNames.Add("HierarchicalLODUtilities");
DynamicallyLoadedModuleNames.Add("HierarchicalLODUtilities");
DynamicallyLoadedModuleNames.Add("AnimationModifiers");
PrivateIncludePathModuleNames.Add("AssetTools");
DynamicallyLoadedModuleNames.Add("AssetTools");
PrivateIncludePathModuleNames.Add("PIEPreviewDeviceProfileSelector");
}
SetupModulePhysXAPEXSupport(Target);
if (Target.bCompilePhysX && (Target.bBuildEditor || Target.bCompileAPEX))
{
DynamicallyLoadedModuleNames.Add("PhysXCooking");
}
// Engine public headers need to know about some types (enums etc.)
PublicIncludePathModuleNames.Add("ClothingSystemRuntimeInterface");
PublicDependencyModuleNames.Add("ClothingSystemRuntimeInterface");
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.Add("ClothingSystemEditorInterface");
PrivateIncludePathModuleNames.Add("ClothingSystemEditorInterface");
}
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
// Head Mounted Display support
// PrivateIncludePathModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
// DynamicallyLoadedModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
}
if (Target.Platform == UnrealTargetPlatform.HTML5)
{
// TODO test this for HTML5 !
//AddEngineThirdPartyPrivateStaticDependencies(Target,
// "UEOgg",
// "Vorbis",
// "VorbisFile"
// );
PublicDependencyModuleNames.Add("HTML5JS");
}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"libOpus"
);
PublicFrameworks.AddRange(new string[] { "AVFoundation", "CoreVideo", "CoreMedia" });
}
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Android))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
PrivateDependencyModuleNames.Add("AndroidRuntimeSettings");
}
if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
{
PrivateDependencyModuleNames.Add("IOSRuntimeSettings");
}
if (Target.Platform == UnrealTargetPlatform.Switch)
{
PrivateDependencyModuleNames.Add("SwitchRuntimeSettings");
}
if (Target.IsInPlatformGroup(UnrealPlatformGroup.Unix))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
}
PublicDefinitions.Add("GPUPARTICLE_LOCAL_VF_ONLY=0");
// Add a reference to the stats HTML files referenced by UEngine::DumpFPSChartToHTML. Previously staged by CopyBuildToStagingDirectory.
if (Target.bBuildEditor || Target.Configuration != UnrealTargetConfiguration.Shipping)
{
RuntimeDependencies.Add("$(EngineDir)/Content/Stats/...", StagedFileType.UFS);
}
}
public TargetPlatform(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.Add("Core");
PublicDependencyModuleNames.Add("AudioPlatformConfiguration");
PublicDependencyModuleNames.Add("DesktopPlatform");
PublicDependencyModuleNames.Add("LauncherPlatform");
PrivateIncludePathModuleNames.Add("Engine");
// no need for all these modules if the program doesn't want developer tools at all (like UnrealFileServer)
if (!Target.bBuildRequiresCookedData && Target.bBuildDeveloperTools)
{
// these are needed by multiple platform specific target platforms, so we make sure they are built with the base editor
DynamicallyLoadedModuleNames.Add("ShaderPreprocessor");
DynamicallyLoadedModuleNames.Add("ShaderFormatOpenGL");
DynamicallyLoadedModuleNames.Add("ImageWrapper");
if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
{
if (Target.bCompileLeanAndMeanUE == false)
{
DynamicallyLoadedModuleNames.Add("TextureFormatIntelISPCTexComp");
}
}
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64)
{
// these are needed by multiple platform specific target platforms, so we make sure they are built with the base editor
DynamicallyLoadedModuleNames.Add("ShaderFormatD3D");
DynamicallyLoadedModuleNames.Add("MetalShaderFormat");
if (Target.bCompileLeanAndMeanUE == false)
{
DynamicallyLoadedModuleNames.Add("TextureFormatDXT");
DynamicallyLoadedModuleNames.Add("TextureFormatPVR");
DynamicallyLoadedModuleNames.Add("TextureFormatASTC");
}
DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed");
if (Target.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.Add("AudioFormatADPCM"); // For IOS cooking
DynamicallyLoadedModuleNames.Add("AudioFormatOgg");
DynamicallyLoadedModuleNames.Add("AudioFormatOpus");
}
if (Target.Type == TargetType.Editor || Target.Type == TargetType.Program)
{
DynamicallyLoadedModuleNames.Add("AndroidTargetPlatform");
DynamicallyLoadedModuleNames.Add("IOSTargetPlatform");
DynamicallyLoadedModuleNames.Add("TVOSTargetPlatform");
DynamicallyLoadedModuleNames.Add("HTML5TargetPlatform");
DynamicallyLoadedModuleNames.Add("MacTargetPlatform");
DynamicallyLoadedModuleNames.Add("MacNoEditorTargetPlatform");
DynamicallyLoadedModuleNames.Add("MacServerTargetPlatform");
DynamicallyLoadedModuleNames.Add("MacClientTargetPlatform");
}
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
if (Target.bCompileLeanAndMeanUE == false)
{
DynamicallyLoadedModuleNames.Add("TextureFormatDXT");
DynamicallyLoadedModuleNames.Add("TextureFormatPVR");
DynamicallyLoadedModuleNames.Add("TextureFormatASTC");
}
DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed");
if (Target.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.Add("AudioFormatOgg");
DynamicallyLoadedModuleNames.Add("AudioFormatOpus");
DynamicallyLoadedModuleNames.Add("AudioFormatADPCM");
}
if (Target.Type == TargetType.Editor || Target.Type == TargetType.Program)
{
DynamicallyLoadedModuleNames.Add("AndroidTargetPlatform");
DynamicallyLoadedModuleNames.Add("IOSTargetPlatform");
DynamicallyLoadedModuleNames.Add("TVOSTargetPlatform");
DynamicallyLoadedModuleNames.Add("HTML5TargetPlatform");
}
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
if (Target.bCompileLeanAndMeanUE == false)
{
DynamicallyLoadedModuleNames.Add("TextureFormatDXT");
DynamicallyLoadedModuleNames.Add("TextureFormatPVR");
DynamicallyLoadedModuleNames.Add("TextureFormatASTC");
}
DynamicallyLoadedModuleNames.Add("TextureFormatUncompressed");
if (Target.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.Add("AudioFormatOgg");
DynamicallyLoadedModuleNames.Add("AudioFormatOpus");
DynamicallyLoadedModuleNames.Add("AudioFormatADPCM");
}
if (Target.Type == TargetType.Editor || Target.Type == TargetType.Program)
{
DynamicallyLoadedModuleNames.Add("AndroidTargetPlatform");
DynamicallyLoadedModuleNames.Add("HTML5TargetPlatform");
}
}
}
if (Target.bBuildDeveloperTools == true && Target.bBuildRequiresCookedData && Target.bCompileAgainstEngine && Target.bCompilePhysX)
{
DynamicallyLoadedModuleNames.Add("PhysXCooking");
}
}
public LandscapeEditor(ReadOnlyTargetRules Target) : base(Target)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"ApplicationCore",
"Slate",
"SlateCore",
"EditorStyle",
"Engine",
"Landscape",
"RenderCore",
"RHI",
"InputCore",
"UnrealEd",
"PropertyEditor",
"ImageWrapper",
"EditorWidgets",
"Foliage",
"ViewportInteraction",
"VREditor",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[]
{
"ViewportInteraction",
"VREditor"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MainFrame",
"DesktopPlatform",
"ContentBrowser",
"AssetTools",
"LevelEditor"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MainFrame",
"DesktopPlatform",
}
);
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32)
{
// VS2015 updated some of the CRT definitions but not all of the Windows SDK has been updated to match.
// Microsoft provides this shim library to enable building with VS2015 until they fix everything up.
//@todo: remove when no longer neeeded (no other code changes should be necessary).
if (Target.WindowsPlatform.bNeedsLegacyStdioDefinitionsLib)
{
PublicAdditionalLibraries.Add("legacy_stdio_definitions.lib");
}
}
// KissFFT is used by the smooth tool.
if (Target.bBuildDeveloperTools &&
(Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Mac || Target.Platform == UnrealTargetPlatform.Linux))
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "Kiss_FFT");
}
else
{
PublicDefinitions.Add("WITH_KISSFFT=0");
}
}
public UnrealEd(TargetInfo Target)
{
SharedPCHHeaderFile = "Editor/UnrealEd/Public/UnrealEd.h";
PrivateIncludePaths.AddRange(
new string[]
{
"Editor/UnrealEd/Private",
"Editor/UnrealEd/Private/Settings",
"Editor/UnrealEd/Private/FeaturePack",
"Editor/PackagesDialog/Public",
"Developer/DerivedDataCache/Public",
"Developer/TargetPlatform/Public",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"Analytics",
"AssetRegistry",
"AssetTools",
"BehaviorTreeEditor",
"ClassViewer",
"ContentBrowser",
"CrashTracker",
"DerivedDataCache",
"DesktopPlatform",
"EnvironmentQueryEditor",
"GameProjectGeneration",
"ProjectTargetPlatformEditor",
"ImageWrapper",
"MainFrame",
"MaterialEditor",
"MergeActors",
"MeshUtilities",
"Messaging",
"NiagaraEditor",
"PlacementMode",
"Settings",
"SettingsEditor",
"SoundClassEditor",
"ViewportSnapping",
"SourceCodeAccess",
"ReferenceViewer",
"IntroTutorials",
"SuperSearch",
"OutputLog",
"Landscape",
"Niagara",
"SizeMap",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"BspMode",
"Core",
"CoreUObject",
"DirectoryWatcher",
"Documentation",
"Engine",
"Json",
"Projects",
"SandboxFile",
"Slate",
"SlateCore",
"EditorStyle",
"SourceControl",
"UnrealEdMessages",
"AIModule",
"BlueprintGraph",
"Http",
"UnrealAudio",
"Niagara",
"VectorVM",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"AnimGraph",
"AppFramework",
"BlueprintGraph",
"OnlineSubsystem",
"OnlineBlueprintSupport",
"DesktopPlatform",
"EditorStyle",
"EngineSettings",
"InputCore",
"InputBindingEditor",
"Internationalization",
"LauncherAutomatedService",
"LauncherServices",
"MaterialEditor",
"MessageLog",
"NetworkFileSystem",
"PakFile",
"PropertyEditor",
"Projects",
"RawMesh",
"RenderCore",
"RHI",
"ShaderCore",
"Sockets",
"SoundClassEditor",
"SoundCueEditor",
"SourceControlWindows",
"StatsViewer",
"SwarmInterface",
"TargetPlatform",
"TargetDeviceServices",
"EditorWidgets",
"GraphEditor",
"Kismet",
"InternationalizationSettings",
"JsonUtilities",
"Landscape",
"HeadMountedDisplay",
"MeshPaint",
"Foliage",
"VectorVM",
"TreeMap",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"CrashTracker",
"MaterialEditor",
"FontEditor",
"StaticMeshEditor",
"TextureEditor",
"Cascade",
"UMGEditor",
"Matinee",
"AssetRegistry",
"AssetTools",
"ClassViewer",
"CollectionManager",
"ContentBrowser",
"CurveTableEditor",
"DataTableEditor",
"DestructibleMeshEditor",
"EditorSettingsViewer",
"LandscapeEditor",
"KismetCompiler",
"DetailCustomizations",
"ComponentVisualizers",
"MainFrame",
"LevelEditor",
"InputBindingEditor",
"PackagesDialog",
"Persona",
"PhAT",
"ProjectLauncher",
"DeviceManager",
"SettingsEditor",
"SessionFrontend",
"Sequencer",
"SoundClassEditor",
"GeometryMode",
"TextureAlignMode",
"FoliageEdit",
"PackageDependencyInfo",
"ImageWrapper",
"Blutility",
"IntroTutorials",
"SuperSearch",
"DesktopPlatform",
"WorkspaceMenuStructure",
"BspMode",
"PlacementMode",
"NiagaraEditor",
"MeshUtilities",
"MergeActors",
"GameProjectGeneration",
"ProjectSettingsViewer",
"ProjectTargetPlatformEditor",
"PListEditor",
"Documentation",
"BehaviorTreeEditor",
"EnvironmentQueryEditor",
"ViewportSnapping",
"UserFeedback",
"GameplayTagsEditor",
"GameplayAbilitiesEditor",
"UndoHistory",
"SourceCodeAccess",
"ReferenceViewer",
"EditorLiveStreaming",
"HotReload",
"IOSPlatformEditor",
"HTML5PlatformEditor",
"SizeMap",
}
);
if (Target.Platform == UnrealTargetPlatform.Win64 || Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.Add("AndroidPlatformEditor");
}
CircularlyReferencedDependentModules.AddRange(
new string[]
{
"GraphEditor",
"Kismet",
}
);
// Add include directory for Lightmass
PublicIncludePaths.Add("Programs/UnrealLightmass/Public");
PublicIncludePathModuleNames.AddRange(
new string[] {
"UserFeedback",
"CollectionManager",
"BlueprintGraph",
"NiagaraEditor",
"Niagara",
"VectorVM",
}
);
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
PublicDependencyModuleNames.Add("XAudio2");
PublicDependencyModuleNames.Add("UnrealAudioXAudio2");
AddThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"DX11Audio"
);
}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicDependencyModuleNames.Add("UnrealAudioCoreAudio");
}
if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PublicDependencyModuleNames.Add("HTML5Audio");
}
AddThirdPartyPrivateStaticDependencies(Target,
"HACD",
"VHACD",
"FBX",
"FreeType2"
);
SetupModulePhysXAPEXSupport(Target);
if (UEBuildConfiguration.bCompileRecast)
{
PrivateDependencyModuleNames.Add("Navmesh");
Definitions.Add("WITH_RECAST=1");
}
else
{
Definitions.Add("WITH_RECAST=0");
}
}
public HoudiniEngineEditor(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseSharedPCHs;
// Check if we are compiling on unsupported platforms.
if (Target.Platform != UnrealTargetPlatform.Win64 &&
Target.Platform != UnrealTargetPlatform.Mac &&
Target.Platform != UnrealTargetPlatform.Linux)
{
string Err = string.Format("Houdini Engine Runtime: Compiling on unsupported platform.");
System.Console.WriteLine(Err);
throw new BuildException(Err);
}
// Find HFS
string HFSPath = GetHFSPath();
if (HFSPath != "")
{
PlatformID buildPlatformId = Environment.OSVersion.Platform;
if (buildPlatformId == PlatformID.Win32NT)
{
Definitions.Add("HOUDINI_ENGINE_HFS_PATH_DEFINE=" + HFSPath);
}
}
// Find the HAPI include directory
string HAPIIncludePath = HFSPath + "/toolkit/include/HAPI";
if (!Directory.Exists(HAPIIncludePath))
{
// Try the custom include path as well in case the toolkit path doesn't exist yet.
HAPIIncludePath = HFSPath + "/custom/houdini/include/HAPI";
if (!Directory.Exists(HAPIIncludePath))
{
System.Console.WriteLine(string.Format("Couldnt find the HAPI include folder!"));
HAPIIncludePath = "";
}
}
if (HAPIIncludePath != "")
{
PublicIncludePaths.Add(HAPIIncludePath);
}
// Get the plugin path
string PluginPath = Path.Combine(ModuleDirectory, "../../");
PluginPath = Utils.MakePathRelativeTo(PluginPath, Target.RelativeEnginePath);
PublicIncludePaths.AddRange(
new string[] {
"HoudiniEngineRuntime/Public/HAPI",
"HoudiniEngineRuntime/Public",
"HoudiniEngineEditor/Public"
}
);
PrivateIncludePaths.AddRange(
new string[] {
"HoudiniEngineEditor/Private",
"HoudiniEngineRuntime/Private"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"PlacementMode"
}
);
// Add common dependencies.
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"HoudiniEngineRuntime",
"Slate",
"SlateCore",
"Landscape"
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"AppFramework",
"AssetTools",
"ContentBrowser",
"DesktopWidgets",
"EditorStyle",
"EditorWidgets",
"Engine",
"InputCore",
"LevelEditor",
"MainFrame",
"Projects",
"PropertyEditor",
"RHI",
"RawMesh",
"RenderCore",
"ShaderCore",
"TargetPlatform",
"UnrealEd",
"ApplicationCore",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"PlacementMode",
}
);
}
public Engine(TargetInfo Target)
{
SharedPCHHeaderFile = "Runtime/Engine/Public/Engine.h";
PublicIncludePathModuleNames.AddRange(new string[] { "Renderer", "PacketHandler" });
PrivateIncludePaths.AddRange(
new string[] {
"Developer/DerivedDataCache/Public",
"Runtime/Online/OnlineSubsystem/Public",
"Runtime/Online/OnlineSubsystemUtils/Public",
"Runtime/SynthBenchmark/Public",
"Runtime/Engine/Private",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"OnlineSubsystem",
"TargetPlatform",
"ImageWrapper",
"HeadMountedDisplay",
"Advertising",
"NetworkReplayStreaming",
"MovieSceneCapture",
"AutomationWorker",
"Analytics",
"MovieSceneCapture",
"DesktopPlatform",
"Analytics"
}
);
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(new string[] { "TaskGraph" });
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
}
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Json",
"SlateCore",
"Slate",
"InputCore",
"Messaging",
"RenderCore",
"RHI",
"ShaderCore",
"AssetRegistry", // Here until FAssetData is moved to engine
"EngineMessages",
"EngineSettings",
"SynthBenchmark",
"AIModule",
"DatabaseSupport",
"PacketHandler",
"HardwareSurvey",
}
);
if (Target.Type == TargetRules.TargetType.Editor)
{
PrivateIncludePathModuleNames.AddRange(new string[] { "CrashTracker" });
DynamicallyLoadedModuleNames.AddRange(new string[] { "CrashTracker" });
PublicDependencyModuleNames.AddRange(
new string[] {
}
);
}
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Networking",
"Sockets",
"Landscape",
"UMG",
"Projects",
"Niagara",
"Internationalization",
"MaterialShaderQualitySettings",
}
);
bool bVariadicTemplatesSupported = true;
if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
// Use reflection to allow type not to exist if console code is not present
System.Type XboxOnePlatformType = System.Type.GetType("UnrealBuildTool.XboxOnePlatform,UnrealBuildTool");
if (XboxOnePlatformType != null)
{
System.Object VersionName = XboxOnePlatformType.GetMethod("GetVisualStudioCompilerVersionName").Invoke(null, null);
if (VersionName.ToString().Equals("2012"))
{
bVariadicTemplatesSupported = false;
}
}
}
if (bVariadicTemplatesSupported)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
if (Target.Type == TargetRules.TargetType.Editor)
{
// these modules require variadic templates
PrivateDependencyModuleNames.AddRange(
new string[] {
"MessagingRpc",
"PortalRpc",
"PortalServices",
}
);
}
}
CircularlyReferencedDependentModules.Add("AIModule");
CircularlyReferencedDependentModules.Add("Landscape");
CircularlyReferencedDependentModules.Add("UMG");
CircularlyReferencedDependentModules.Add("Niagara");
CircularlyReferencedDependentModules.Add("MaterialShaderQualitySettings");
// The AnimGraphRuntime module is not needed by Engine proper, but it is loaded in LaunchEngineLoop.cpp,
// and needs to be listed in an always-included module in order to be compiled into standalone games
DynamicallyLoadedModuleNames.Add("AnimGraphRuntime");
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"MovieScene",
"MovieSceneCapture",
"MovieSceneTracks",
"HeadMountedDisplay",
"StreamingPauseRendering",
}
);
PrivateIncludePathModuleNames.Add("LightPropagationVolumeRuntime");
if (Target.Type != TargetRules.TargetType.Server)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
}
if (Target.Type == TargetRules.TargetType.Server || Target.Type == TargetRules.TargetType.Editor)
{
PrivateDependencyModuleNames.Add("PerfCounters");
}
if (UEBuildConfiguration.bBuildDeveloperTools)
{
// Add "BlankModule" so that it gets compiled as an example and will be maintained and tested. This can be removed
// at any time if needed. The module isn't actually loaded by the engine so there is no runtime cost.
DynamicallyLoadedModuleNames.Add("BlankModule");
if (Target.Type != TargetRules.TargetType.Server)
{
PrivateIncludePathModuleNames.Add("MeshUtilities");
DynamicallyLoadedModuleNames.Add("MeshUtilities");
PrivateDependencyModuleNames.AddRange(
new string[] {
"ImageCore",
"RawMesh"
});
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping && Target.Configuration != UnrealTargetConfiguration.Test && Target.Type != TargetRules.TargetType.Server)
{
PrivateDependencyModuleNames.Add("CollisionAnalyzer");
CircularlyReferencedDependentModules.Add("CollisionAnalyzer");
PrivateDependencyModuleNames.Add("LogVisualizer");
CircularlyReferencedDependentModules.Add("LogVisualizer");
}
if (Target.Platform == UnrealTargetPlatform.Win64)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"WindowsTargetPlatform",
"WindowsNoEditorTargetPlatform",
"WindowsServerTargetPlatform",
"WindowsClientTargetPlatform",
"AllDesktopTargetPlatform",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MacTargetPlatform",
"MacNoEditorTargetPlatform",
"MacServerTargetPlatform",
"MacClientTargetPlatform",
"AllDesktopTargetPlatform",
}
);
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"LinuxTargetPlatform",
"LinuxNoEditorTargetPlatform",
"LinuxServerTargetPlatform",
"AllDesktopTargetPlatform",
}
);
}
}
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Analytics",
"AnalyticsET",
"NetworkReplayStreaming",
"NullNetworkReplayStreaming",
"HttpNetworkReplayStreaming",
"OnlineSubsystem",
"OnlineSubsystemUtils",
"Advertising"
}
);
if (Target.Type.Value != TargetRules.TargetType.Server)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"ImageWrapper",
"GameLiveStreaming"
}
);
}
if (!UEBuildConfiguration.bBuildRequiresCookedData && UEBuildConfiguration.bCompileAgainstEngine)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"DerivedDataCache",
"TargetPlatform",
"DesktopPlatform"
}
);
}
if (UEBuildConfiguration.bBuildEditor == true)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"UnrealEd",
"Kismet"
}
); // @todo api: Only public because of WITH_EDITOR and UNREALED_API
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd",
"Kismet"
}
);
PrivateIncludePathModuleNames.Add("TextureCompressor");
PrivateIncludePaths.Add("Developer/TextureCompressor/Public");
}
SetupModulePhysXAPEXSupport(Target);
if (UEBuildConfiguration.bCompilePhysX && UEBuildConfiguration.bRuntimePhysicsCooking)
{
DynamicallyLoadedModuleNames.Add("PhysXFormats");
PrivateIncludePathModuleNames.Add("PhysXFormats");
}
SetupModuleBox2DSupport(Target);
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
if (UEBuildConfiguration.bCompileLeanAndMeanUE == false)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "DirectShow");
}
// Head Mounted Display support
// PrivateIncludePathModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
// DynamicallyLoadedModuleNames.AddRange(new string[] { "HeadMountedDisplay" });
}
if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
}
if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture != "-win32")
{
PublicDependencyModuleNames.Add("HTML5JS");
}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"libOpus"
);
PublicFrameworks.AddRange(new string[] { "AVFoundation", "CoreVideo", "CoreMedia" });
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile"
);
}
if (Target.Platform == UnrealTargetPlatform.Linux)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"UEOgg",
"Vorbis",
"VorbisFile",
"libOpus"
);
}
if (UEBuildConfiguration.bCompileRecast)
{
PrivateDependencyModuleNames.Add("Navmesh");
Definitions.Add("WITH_RECAST=1");
}
else
{
// Because we test WITH_RECAST in public Engine header files, we need to make sure that modules
// that import this also have this definition set appropriately. Recast is a private dependency
// module, so it's definitions won't propagate to modules that import Engine.
Definitions.Add("WITH_RECAST=0");
}
// Add a reference to the stats HTML files referenced by UEngine::DumpFPSChartToHTML. Previously staged by CopyBuildToStagingDirectory.
if (UEBuildConfiguration.bBuildEditor || Target.Configuration != UnrealTargetConfiguration.Shipping)
{
RuntimeDependencies.Add("$(EngineDir)/Content/Stats/...", StagedFileType.UFS);
}
}
public LevelEditor(TargetInfo Target)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetTools",
"ClassViewer",
"MainFrame",
"PlacementMode",
"ReferenceViewer",
"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",
"Levels",
"WorldBrowser",
"TaskBrowser",
"EditorWidgets",
"AssetTools",
"WorkspaceMenuStructure",
"NewLevelDialog",
"DeviceProfileEditor",
"DeviceProfileServices",
"PlacementMode",
"UserFeedback",
"ReferenceViewer",
"IntroTutorials"
}
);
}
public Landscape(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"Runtime/Engine/Private", // for Engine/Private/Collision/PhysXCollision.h
"Runtime/Landscape/Private",
"../Shaders/Shared"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"DerivedDataCache",
"Foliage",
"Renderer",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"ApplicationCore",
"Engine",
"RenderCore",
"RHI",
"Renderer",
"Foliage",
"DeveloperSettings"
}
);
SetupModulePhysicsSupport(Target);
if (Target.bCompilePhysX && Target.bBuildEditor)
{
DynamicallyLoadedModuleNames.Add("PhysXCooking");
}
if (Target.Type == TargetType.Editor || Target.Type == TargetType.Program)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"MeshDescription",
"StaticMeshDescription",
"MeshUtilitiesCommon"
}
);
}
if (Target.bBuildEditor == true)
{
// TODO: Remove all landscape editing code from the Landscape module!!!
PrivateIncludePathModuleNames.Add("LandscapeEditor");
PrivateDependencyModuleNames.AddRange(
new string[] {
"UnrealEd",
"MaterialUtilities",
"SlateCore",
"Slate",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd",
"MaterialUtilities",
}
);
}
}
public AkAudio(TargetInfo Target)
#endif
{
PCHUsage = PCHUsageMode.UseSharedPCHs;
PrivateIncludePathModuleNames.Add("Settings");
try
{
SwitchTargetPlatform = (UnrealTargetPlatform)Enum.Parse(typeof(UnrealTargetPlatform), "Switch");
}
catch (Exception)
{
SwitchTargetPlatform = UnrealTargetPlatform.Unknown;
}
try
{
VS2013Compiler = (WindowsCompiler)Enum.Parse(typeof(WindowsCompiler), "VisualStudio2013");
}
catch (Exception)
{
VS2013Compiler = (WindowsCompiler)(-1);
}
PrivateIncludePaths.AddRange(
new string[] {
"AkAudio/Private",
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"MovieScene",
"MovieSceneTracks"
});
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"SlateCore",
"NetworkReplayStreaming",
"Projects",
});
string akDir = Path.GetFullPath(Path.Combine(ModuleDirectory, "../../ThirdParty"));
string akPlatformLibDir = "";
Definitions.Add("USE_AKAUDIO");
PublicIncludePaths.AddRange(
new string[] {
// SDK includes
Path.Combine(akDir, "include"),
Path.Combine(akDir, "samples" + Path.DirectorySeparatorChar + "SoundEngine" + Path.DirectorySeparatorChar + "Common"),
Path.Combine(akDir, "samples" + Path.DirectorySeparatorChar + "SoundEngine")
}
);
// These definitions can be set as platform-specific.
if (UEBuildConfiguration.bBuildEditor == true)
{
// Boost the number of IO for the editor, since it uses the old IO system
Definitions.Add("AK_UNREAL_MAX_CONCURRENT_IO=256");
}
else
{
Definitions.Add("AK_UNREAL_MAX_CONCURRENT_IO=32");
}
Definitions.Add("AK_UNREAL_IO_GRANULARITY=32768");
string samplesSoundEngineBasePath = Path.Combine(akDir, "samples" + Path.DirectorySeparatorChar + "SoundEngine");
if (Target.Platform == UnrealTargetPlatform.Win32 || Target.Platform == UnrealTargetPlatform.Win64)
{
string VSVersion;
if (WindowsPlatform.Compiler == VS2013Compiler)
{
VSVersion = "vc120";
}
else /*if(WindowsPlatform.Compiler == WindowsCompiler.VisualStudio2015)*/
{
VSVersion = "vc140";
}
akPlatformLibDir = (Target.Platform == UnrealTargetPlatform.Win32) ? "Win32_" : "x64_";
akPlatformLibDir += VSVersion;
string LibFolder = (Target.Platform == UnrealTargetPlatform.Win32) ? "x86" : "x64";
PublicLibraryPaths.Add("$(DXSDK_DIR)" + Path.DirectorySeparatorChar + "Lib" + Path.DirectorySeparatorChar + LibFolder);
PublicIncludePaths.Add(Path.Combine(samplesSoundEngineBasePath, "Win32"));
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
string VSVersion = "vc140";
// Use reflection because the GitHub version of UE is missing things.
Type XboxOnePlatformType = System.Type.GetType("XboxOnePlatform", false);
if (XboxOnePlatformType != null)
{
System.Reflection.FieldInfo XboxOneCompilerField = XboxOnePlatformType.GetField("Compiler");
if (XboxOneCompilerField != null)
{
var XboxOneCompilerValue = XboxOneCompilerField.GetValue(null);
if (XboxOneCompilerValue.ToString() == "VisualStudio2012")
{
VSVersion = "vc110";
}
}
}
akPlatformLibDir = "XboxOne_" + VSVersion;
PublicIncludePaths.Add(Path.Combine(samplesSoundEngineBasePath, "Win32"));
Definitions.Add("_XBOX_ONE");
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
akPlatformLibDir = "Linux_x64";
PublicIncludePaths.Add(Path.Combine(samplesSoundEngineBasePath, "POSIX"));
PublicIncludePaths.Add(Path.Combine(samplesSoundEngineBasePath, "Common"));
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
akPlatformLibDir = "Mac";
PublicIncludePaths.Add(Path.Combine(samplesSoundEngineBasePath, "POSIX"));
}
else if (Target.Platform == UnrealTargetPlatform.IOS)
{
akPlatformLibDir = "iOS";
PublicIncludePaths.Add(Path.Combine(samplesSoundEngineBasePath, "POSIX"));
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
akPlatformLibDir = "PS4";
PublicIncludePaths.Add(Path.Combine(samplesSoundEngineBasePath, "PS4"));
Definitions.Add("__ORBIS__");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
akPlatformLibDir = "android-9_armeabi-v7a";
PublicIncludePaths.Add(Path.Combine(samplesSoundEngineBasePath, "Android"));
PublicIncludePaths.Add(Path.Combine(samplesSoundEngineBasePath, "POSIX"));
Definitions.Add("__ANDROID__");
}
else if (Target.Platform == SwitchTargetPlatform)
{
akPlatformLibDir = "NX64";
PublicIncludePaths.Add(Path.Combine(samplesSoundEngineBasePath, "NX"));
Definitions.Add("NN_NINTENDO_SDK");
}
if (Target.Platform == UnrealTargetPlatform.Win32 ||
Target.Platform == UnrealTargetPlatform.Win64)
{
if (UEBuildConfiguration.bBuildEditor == true)
{
// Sound frame is required for enabling communication between Wwise Application and the unreal editor.
// Not to be defined in shipping mode.
Definitions.Add("AK_SOUNDFRAME");
}
PublicAdditionalLibraries.Add("dsound.lib");
PublicAdditionalLibraries.Add("dxguid.lib");
PublicAdditionalLibraries.Add("Msacm32.lib");
PublicAdditionalLibraries.Add("XInput.lib");
}
else if (Target.Platform == UnrealTargetPlatform.XboxOne)
{
PublicAdditionalLibraries.Add("AcpHal.lib");
PublicAdditionalLibraries.Add("MMDevApi.lib");
}
else if (Target.Platform == UnrealTargetPlatform.PS4)
{
PublicAdditionalLibraries.Add("SceAjm_stub_weak");
PublicAdditionalLibraries.Add("SceAudio3d_stub_weak");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
// We don't seem to need more libs for Android...
}
if (Target.Configuration == UnrealTargetConfiguration.Shipping)
{
Definitions.Add("AK_OPTIMIZED");
}
string akConfigurationDir;
if (Target.Configuration == UnrealTargetConfiguration.Debug)
{
// change bDebugBuildsActuallyUseDebugCRT to true in BuildConfiguration.cs to actually link debug binaries
if (!BuildConfiguration.bDebugBuildsActuallyUseDebugCRT)
{
akConfigurationDir = "Profile";
}
else
{
akConfigurationDir = "Debug";
}
}
else if (Target.Configuration == UnrealTargetConfiguration.Development ||
Target.Configuration == UnrealTargetConfiguration.Test ||
Target.Configuration == UnrealTargetConfiguration.DebugGame)
{
akConfigurationDir = "Profile";
}
else // if (Target.Configuration == UnrealTargetConfiguration.Shipping)
{
akConfigurationDir = "Release";
}
if (Target.Platform == UnrealTargetPlatform.IOS)
{
akConfigurationDir += "-iphoneos";
}
if (Target.Platform == UnrealTargetPlatform.Linux)
{
// No profiler support in the cross-compile toolchain.
akConfigurationDir = "Release";
}
akLibPath = Path.Combine(Path.Combine(Path.Combine(akDir, akPlatformLibDir), akConfigurationDir), "lib");
PublicLibraryPaths.Add(akLibPath);
if (Target.Platform == UnrealTargetPlatform.Android)
{
// Toolchain will filter properly, add other Android arches here
PublicLibraryPaths.Add(Path.Combine(Path.Combine(akDir, "android-9_x86"), akConfigurationDir));
}
AddWwiseLib(Target, "AkSoundEngine");
AddWwiseLib(Target, "AkMemoryMgr");
AddWwiseLib(Target, "AkStreamMgr");
AddWwiseLib(Target, "AkMusicEngine");
AddWwiseLib(Target, "AkVorbisDecoder");
AddWwiseLib(Target, "AkSilenceSource");
AddWwiseLib(Target, "AkSineSource");
AddWwiseLib(Target, "AkToneSource");
AddWwiseLib(Target, "AkPeakLimiterFX");
AddWwiseLib(Target, "AkMatrixReverbFX");
AddWwiseLib(Target, "AkParametricEQFX");
AddWwiseLib(Target, "AkDelayFX");
AddWwiseLib(Target, "AkExpanderFX");
AddWwiseLib(Target, "AkFlangerFX");
AddWwiseLib(Target, "AkCompressorFX");
AddWwiseLib(Target, "AkGainFX");
AddWwiseLib(Target, "AkHarmonizerFX");
AddWwiseLib(Target, "AkTimeStretchFX");
AddWwiseLib(Target, "AkPitchShifterFX");
AddWwiseLib(Target, "AkStereoDelayFX");
AddWwiseLib(Target, "AkMeterFX");
AddWwiseLib(Target, "AkGuitarDistortionFX");
AddWwiseLib(Target, "AkTremoloFX");
AddWwiseLib(Target, "AkRoomVerbFX");
AddWwiseLib(Target, "AkAudioInputSource");
AddWwiseLib(Target, "AkSynthOne");
AddWwiseLib(Target, "AkConvolutionReverbFX");
AddWwiseLib(Target, "AkRecorderFX");
if ((Target.Platform != UnrealTargetPlatform.Android) && (Target.Platform != UnrealTargetPlatform.Linux) && (Target.Platform != UnrealTargetPlatform.Mac) && (Target.Platform != UnrealTargetPlatform.IOS) && (Target.Platform != SwitchTargetPlatform))
{
AddWwiseLib(Target, "AkMotionGenerator");
AddWwiseLib(Target, "AkRumble");
}
if (Target.Platform == UnrealTargetPlatform.PS4)
{
AddWwiseLib(Target, "SceAudio3dEngine");
}
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicAdditionalFrameworks.Add(new UEBuildFramework("AudioUnit"));
PublicAdditionalFrameworks.Add(new UEBuildFramework("AudioToolbox"));
PublicAdditionalFrameworks.Add(new UEBuildFramework("CoreAudio"));
AddWwiseLib(Target, "AkAACDecoder");
}
if (Target.Platform == UnrealTargetPlatform.IOS)
{
PublicAdditionalFrameworks.Add(new UEBuildFramework("AudioToolbox"));
PublicAdditionalFrameworks.Add(new UEBuildFramework("CoreAudio"));
AddWwiseLib(Target, "AkAACDecoder");
}
// Need to use Enum.Parse because Switch is not present in UE < 4.15
if (Target.Platform == SwitchTargetPlatform)
{
AddWwiseLib(Target, "AkOpusDecoder");
}
if (Definitions.Contains("AK_OPTIMIZED") == false && Target.Platform != UnrealTargetPlatform.Linux)
{
AddWwiseLib(Target, "CommunicationCentral");
}
// SoundFrame libs
if (Definitions.Contains("AK_SOUNDFRAME") == true)
{
PublicAdditionalLibraries.Add("SFLib.lib");
}
// If AK_SOUNDFRAME is defined, make UnrealEd a dependency
if (UEBuildConfiguration.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("SlateCore");
PrivateDependencyModuleNames.Add("Slate");
PrivateDependencyModuleNames.Add("UnrealEd");
}
}
public BlueprintMaterialTextureNodes(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
"Runtime/Engine/Classes/Materials",
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
"BlueprintMaterialTextureNodes/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"AssetRegistry",
"AssetTools",
"RHI",
"StaticMeshEditor",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"UnrealEd",
"Engine",
"PropertyEditor",
"Slate",
"SlateCore",
// ... add private dependencies that you statically link with here ...
}
);
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"Settings",
"AssetTools",
"AssetRegistry",
//"StaticMeshEditor",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
public SteamAudio(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"SteamAudio/Private",
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"AudioMixer",
"InputCore",
"RenderCore",
"RHI"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"Projects",
"AudioMixer",
"AudioExtensions"
}
);
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("UnrealEd");
PrivateDependencyModuleNames.Add("Landscape");
}
else
{
RuntimeDependencies.Add("$(ProjectDir)/Content/SteamAudio/Runtime/...");
}
AddEngineThirdPartyPrivateStaticDependencies(Target, "libPhonon");
if (Target.Platform == UnrealTargetPlatform.Win32)
{
PrivateDependencyModuleNames.Add("XAudio2");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11Audio");
RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/Phonon/Win32/...");
}
else if (Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateDependencyModuleNames.Add("XAudio2");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11Audio");
RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/Phonon/Win64/...");
PublicDelayLoadDLLs.Add("GPUUtilities.dll");
PublicDelayLoadDLLs.Add("tanrt64.dll");
PublicDelayLoadDLLs.Add("embree.dll");
PublicDelayLoadDLLs.Add("tbb.dll");
PublicDelayLoadDLLs.Add("tbbmalloc.dll");
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add("AndroidPlugin", Path.Combine(PluginPath, "SteamAudio_APL.xml"));
}
}
public Launch(TargetInfo Target)
{
PrivateIncludePaths.Add("Runtime/Launch/Private");
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AutomationController",
"OnlineSubsystem",
"TaskGraph",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"MediaAssets",
"MoviePlayer",
"Networking",
"PakFile",
"Projects",
"RenderCore",
"RHI",
"SandboxFile",
"Serialization",
"ShaderCore",
"Slate",
"SlateCore",
"Sockets",
}
);
if (Target.Type != TargetRules.TargetType.Server)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"HeadMountedDisplay",
}
);
if ((Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.Win64))
{
DynamicallyLoadedModuleNames.Add("D3D12RHI");
DynamicallyLoadedModuleNames.Add("D3D11RHI");
DynamicallyLoadedModuleNames.Add("XAudio2");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
DynamicallyLoadedModuleNames.Add("CoreAudio");
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
DynamicallyLoadedModuleNames.Add("ALAudio");
PrivateDependencyModuleNames.Add("Json");
}
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateNullRenderer",
"SlateRHIRenderer"
}
);
}
// UFS clients are not available in shipping builds
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"NetworkFile",
"StreamingFile",
"AutomationWorker",
}
);
}
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Media",
"Renderer",
}
);
if (UEBuildConfiguration.bCompileAgainstEngine)
{
PrivateIncludePathModuleNames.Add("Messaging");
PublicDependencyModuleNames.Add("SessionServices");
PrivateIncludePaths.Add("Developer/DerivedDataCache/Public");
// LaunchEngineLoop.cpp does a LoadModule() on OnlineSubsystem and OnlineSubsystemUtils when compiled WITH_ENGINE, so they must be marked as dependencies so that they get compiled and cleaned
DynamicallyLoadedModuleNames.Add("OnlineSubsystem");
DynamicallyLoadedModuleNames.Add("OnlineSubsystemUtils");
}
if (Target.Configuration != UnrealTargetConfiguration.Shipping)
{
PublicIncludePathModuleNames.Add("ProfilerService");
DynamicallyLoadedModuleNames.AddRange(new string[] { "TaskGraph", "RealtimeProfiler", "ProfilerService" });
}
// The engine can use AutomationController in any connfiguration besides shipping. This module is loaded
// dynamically in LaunchEngineLoop.cpp in non-shipping configurations
if (UEBuildConfiguration.bCompileAgainstEngine && Target.Configuration != UnrealTargetConfiguration.Shipping)
{
DynamicallyLoadedModuleNames.AddRange(new string[] { "AutomationController" });
}
if (UEBuildConfiguration.bBuildEditor == true)
{
PublicIncludePathModuleNames.Add("ProfilerClient");
PrivateDependencyModuleNames.AddRange(
new string[] {
"SourceControl",
"UnrealEd",
"DesktopPlatform"
}
);
// ExtraModules that are loaded when WITH_EDITOR=1 is true
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AutomationWindow",
"ProfilerClient",
"Toolbox",
"GammaUI",
"ModuleUI",
"OutputLog",
"TextureCompressor",
"MeshUtilities",
"SourceCodeAccess"
}
);
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PrivateDependencyModuleNames.Add("MainFrame");
PrivateDependencyModuleNames.Add("Settings");
}
else
{
DynamicallyLoadedModuleNames.Add("MainFrame");
}
}
if (Target.Platform == UnrealTargetPlatform.IOS ||
Target.Platform == UnrealTargetPlatform.TVOS)
{
PrivateDependencyModuleNames.Add("OpenGLDrv");
PrivateDependencyModuleNames.Add("IOSAudio");
DynamicallyLoadedModuleNames.Add("IOSRuntimeSettings");
PublicFrameworks.Add("OpenGLES");
// this is weak for IOS8 support for CAMetalLayer that is in QuartzCore
PublicWeakFrameworks.Add("QuartzCore");
PrivateDependencyModuleNames.Add("LaunchDaemonMessages");
}
if (Target.Platform == UnrealTargetPlatform.Android)
{
PrivateDependencyModuleNames.Add("OpenGLDrv");
PrivateDependencyModuleNames.Add("AndroidAudio");
DynamicallyLoadedModuleNames.Add("AndroidRuntimeSettings");
}
if ((Target.Platform == UnrealTargetPlatform.Win32) ||
(Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Mac) ||
(Target.Platform == UnrealTargetPlatform.Linux && Target.Type != TargetRules.TargetType.Server))
{
// TODO: re-enable after implementing resource tables for OpenGL.
DynamicallyLoadedModuleNames.Add("OpenGLDrv");
}
if (Target.Platform == UnrealTargetPlatform.HTML5)
{
PrivateDependencyModuleNames.Add("ALAudio");
if (Target.Architecture == "-win32")
{
PrivateDependencyModuleNames.Add("HTML5Win32");
PublicIncludePathModuleNames.Add("HTML5Win32");
}
AddThirdPartyPrivateStaticDependencies(Target, "SDL2");
}
// @todo ps4 clang bug: this works around a PS4/clang compiler bug (optimizations)
if (Target.Platform == UnrealTargetPlatform.PS4)
{
bFasterWithoutUnity = true;
}
if (Target.Platform == UnrealTargetPlatform.Linux)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"LinuxCommonStartup"
}
);
}
}
public JoystickPlugin(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"InputCore",
"Slate",
"SlateCore",
// ... add other public dependencies that you statically link with here ...
});
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"InputDevice",
});
if (Target.Type == TargetRules.TargetType.Editor)
{
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"PropertyEditor",
"ActorPickerMode",
"DetailCustomizations",
});
PrivateDependencyModuleNames.AddRange(
new string[]
{
"PropertyEditor",
"DetailCustomizations",
// ... add private dependencies that you statically link with here ...
});
}
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
});
if (UEBuildConfiguration.bBuildEditor == true)
{
LinkThirdPartyStaticallyOnWindows = false;
}
if (Target.Platform == UnrealTargetPlatform.Win64)
{
string SDL2Path = ThirdPartyPath + "SDL2/SDL/";
string SDL2LibPath = SDL2Path + "Lib/";
PublicIncludePaths.Add(Path.Combine(SDL2Path, "include/"));
PrivateIncludePaths.Add(Path.Combine(SDL2Path, "include/")); // Public || Private !? is there documentation ?
if (LinkThirdPartyStaticallyOnWindows)
{
PublicAdditionalLibraries.Add(Path.Combine(SDL2LibPath, "SDL2-static.lib"));
PublicAdditionalLibraries.Add(Path.Combine(SDL2LibPath, "SDL2main.lib"));
}
else
{
PublicAdditionalLibraries.Add(Path.Combine(SDL2LibPath, "SDL2.lib"));
}
PublicAdditionalLibraries.Add("Version.lib");
}
if (Target.Platform == UnrealTargetPlatform.Win32)
{
string SDL2Path = ThirdPartyPath + "SDL2/SDL/";
string SDL2LibPath = SDL2Path + "Lib32/";
PublicIncludePaths.Add(Path.Combine(SDL2Path, "include/"));
if (LinkThirdPartyStaticallyOnWindows)
{
PublicAdditionalLibraries.Add(Path.Combine(SDL2LibPath, "SDL2-static.lib"));
PublicAdditionalLibraries.Add(Path.Combine(SDL2LibPath, "SDL2main.lib"));
}
else
{
PublicAdditionalLibraries.Add(Path.Combine(SDL2LibPath, "SDL2.lib"));
}
PublicAdditionalLibraries.Add("Version.lib");
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
PublicFrameworks.Add("/Library/Frameworks/SDL2.framework");
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
//AddThirdPartyPrivateStaticDependencies(Target, "SDL2");
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
}
}
public VoxelEditor(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
bEnforceIWYU = true;
bLegacyPublicIncludePaths = false;
#if UE_4_24_OR_LATER
#else
#endif
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public"));
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Private"));
PrivateIncludePaths.Add(Path.Combine(EngineDirectory, "Source/Editor/PropertyEditor/Private"));
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"VoxelGraphEditor",
"AssetRegistry",
});
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"Voxel",
"VoxelGraph",
"VoxelEditorDefault",
"Engine",
"Landscape",
"LandscapeEditor",
"PlacementMode",
"AdvancedPreviewScene",
"DesktopPlatform",
"UnrealEd",
"InputCore",
"ImageWrapper",
"Slate",
"SlateCore",
"PropertyEditor",
"EditorStyle",
"Projects",
"RHI",
"MessageLog",
"RawMesh",
"DetailCustomizations",
"WorkspaceMenuStructure",
"BlueprintGraph",
"KismetCompiler",
"ApplicationCore",
"EngineSettings",
"ToolMenus",
#if UE_4_26_OR_LATER
"DeveloperSettings",
#endif
});
PrivateIncludePathModuleNames.AddRange(
new string[] {
"VoxelGraphEditor"
});
}
public ProteusAvatars(ReadOnlyTargetRules Target) : base(Target)
{
// Precompiled header usage for this module
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
string BaseDirectory = Path.GetFullPath(Path.Combine(ModuleDirectory, ".."));
//(This setting is currently not need as we discover all files from the 'Public' folder) List of all paths to include files that are exposed to other modules
PublicIncludePaths.AddRange
(
new string[]
{
BaseDirectory + "/ProteusAvatars/Public",
// Access to ProteusOvrAvatarHelpers.h
BaseDirectory + "/ProteusAvatars/Private",
//Access to OVR_Avatar.h and OVR_Avatar_defs.h
EngineDirectory + "/Source/ThirdParty/Oculus/LibOVRAvatar/LibOVRAvatar/include",
// Access to OculusHMDModule.h
EngineDirectory + "/Plugins/Runtime/Oculus/OculusVR/Source/OculusHMD/Private",
//Access to Avatars Materials
EngineDirectory + "/Plugins/Runtime/Oculus/OculusAvatar"
}
);
// List of public dependency module names (no path needed) (automatically does the private/public include). These are modules that are required by our public source files.
PublicIncludePathModuleNames.AddRange
(
new string[]
{
//Access to the module /Source/ThirdParty/Oculus/OVRPlugin
"OVRPlugin",
"OVRLipSync"
}
);
// List of public dependency module names (no path needed) (automatically does the private/public include).
// These are modules that are required by our public source files
PublicDependencyModuleNames.AddRange
(
new string[]
{
"Core",
// "ProteusAvatarsLibrary",
"Projects",
//Access to the module /Source/ThirdParty/Oculus/OVRPlugin and /LibOVRAvatar
"OVRPlugin",
"LibOVRAvatar",
//Access to /Plugins/Runtime/Oculus/OculusVR/Source/OculusHMD
"OculusHMD",
"CoreUObject",
"Engine",
"InputCore",
"UMG",
"Slate",
"SlateCore",
"RenderCore",
"OnlineSubsystem",
"HeadMountedDisplay",
"Voice",
"OculusAvatar",
"OVRLipSync"
}
);
// List of all paths to this module's internal include files, not exposed to other modules (at least one include to the 'Private' path, more if we want to avoid relative paths)
PrivateIncludePaths.AddRange
(
new string[]
{
BaseDirectory + "/ProteusAvatars/Private"
}
);
// List of modules name(no path needed) with header files that our module's private code files needs access to, but we don't need to "import" or link against.
PrivateIncludePathModuleNames.AddRange
(
new string[]
{
//Access to /Plugins/Runtime/Oculus/OculusVR/Source/OculusHMD
"OculusHMD",
"OVRLipSync"
}
);
// List of private dependency module names.These are modules that our private code depends on but nothing in our public include files depend on.
PrivateDependencyModuleNames.AddRange
(
new string[]
{
"Core", "CoreUObject", "Engine", "InputCore", "UMG", "Slate", "SlateCore", "RenderCore",
"OnlineSubsystem", "HeadMountedDisplay", "OVRPlugin", "OculusHMD", "LibOVRAvatar", "OculusAvatar", "OVRLipSync"
}
);
// Addition modules this module may require at run-time
DynamicallyLoadedModuleNames.AddRange
(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
if (Target.Platform == UnrealTargetPlatform.Win64)
{
// List of delay load DLLs - typically used for External (third party) modules
// Binaries/ThirdParty/Oculus/OVRPlugin/OVRPlugin/Win64/OVRPLugin.dll
PublicDelayLoadDLLs.Add("libovravatar.dll");
// Binaries/ThirdParty/Oculus/OVRPlugin/OVRPlugin/Win64/OVRPLugin.dll
PublicDelayLoadDLLs.Add("OVRPlugin.dll");
// List of files which this module depends on at runtime. These files will be staged along with the target.
RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/Oculus/OVRPlugin/OVRPlugin/" + Target.Platform.ToString() + "/OVRPlugin.dll");
}
// Which targets this module should be precompiled for
else if (Target.Platform == UnrealTargetPlatform.Android)
{
PublicDelayLoadDLLs.Add("libovravatarloader.so");
PublicDelayLoadDLLs.Add("libOVRPlugin.so");
// List of files which this module depends on at runtime. These files will be staged along with the target.
// RuntimeDependencies.Add("$(EngineDir)/Binaries/ThirdParty/Oculus/OVRPlugin/OVRPlugin/Lib/armeabi-v7a/libOVRPlugin.so");
}
else
{
PrecompileForTargets = PrecompileTargetsType.None;
}
}
public DetailCustomizations(TargetInfo Target)
{
PrivateIncludePaths.Add("Editor/DetailCustomizations/Private"); // For PCH includes (because they don't work with relative paths, yet)
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"Core",
"CoreUObject",
"DesktopWidgets",
"Engine",
"Landscape",
"InputCore",
"Slate",
"SlateCore",
"EditorStyle",
"UnrealEd",
"EditorWidgets",
"KismetWidgets",
"MovieSceneCapture",
"SharedSettingsWidgets",
"ContentBrowser",
"BlueprintGraph",
"AnimGraph",
"PropertyEditor",
"LevelEditor",
"DesktopPlatform",
"ClassViewer",
"TargetPlatform",
"ExternalImagePicker",
"MoviePlayer",
"SourceControl",
"InternationalizationSettings",
"SourceCodeAccess",
"RHI",
"MediaAssets",
"HardwareTargeting",
"SharedSettingsWidgets",
"LightPropagationVolumeRuntime",
"AIModule",
"MeshUtilities",
"ConfigEditor",
"Persona",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Engine",
"Media",
"Landscape",
"LandscapeEditor",
"PropertyEditor",
"GameProjectGeneration",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Layers",
"GameProjectGeneration",
}
);
}
public Sequencer(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"Editor/Sequencer/Private",
"Editor/Sequencer/Private/DisplayNodes",
"Editor/UnrealEd/Private" // TODO: Fix this, for now it's needed for the fbx exporter
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"TimeManagement",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AppFramework",
"ApplicationCore",
"CinematicCamera",
"Core",
"CoreUObject",
"CurveEditor",
"InputCore",
"Engine",
"Slate",
"SlateCore",
"EditorStyle",
"UnrealEd",
"MovieScene",
"MovieSceneTracks",
"MovieSceneTools",
"MovieSceneCapture",
"MovieSceneCaptureDialog",
"EditorWidgets",
"SequencerWidgets",
"BlueprintGraph",
"LevelSequence",
"GraphEditor",
"ViewportInteraction",
"SerializedRecorderInterface"
}
);
CircularlyReferencedDependentModules.AddRange(
new string[]
{
"ViewportInteraction",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"ContentBrowser",
"PropertyEditor",
"Kismet",
"SequenceRecorder",
"LevelEditor",
"MainFrame",
"DesktopPlatform",
"SerializedRecorderInterface"
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"PropertyEditor",
"SceneOutliner",
"CurveEditor",
"Analytics",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"PropertyEditor",
"LevelEditor",
"SceneOutliner",
"WorkspaceMenuStructure",
"SequenceRecorder",
"SequenceRecorderSections",
"MainFrame",
}
);
CircularlyReferencedDependentModules.Add("MovieSceneTools");
AddEngineThirdPartyPrivateStaticDependencies(Target, "FBX");
}
public ApplicationCore(ReadOnlyTargetRules Target) : base(Target)
{
PublicDependencyModuleNames.AddRange(
new string[] {
"Core"
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"RHI"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"InputDevice",
"Analytics",
"SynthBenchmark"
}
);
if ((Target.Platform == UnrealTargetPlatform.Win64) ||
(Target.Platform == UnrealTargetPlatform.Win32))
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"XInput"
);
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"OpenGL"
);
if (Target.bBuildEditor == true)
{
PublicAdditionalLibraries.Add("/System/Library/PrivateFrameworks/MultitouchSupport.framework/Versions/Current/MultitouchSupport");
}
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
AddEngineThirdPartyPrivateStaticDependencies(Target,
"SDL2"
);
// We need FreeType2 and GL for the Splash, but only in the Editor
if (Target.Type == TargetType.Editor)
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "FreeType2");
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenGL");
PrivateIncludePathModuleNames.Add("ImageWrapper");
}
}
else if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture == "-win32")
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
AddEngineThirdPartyPrivateStaticDependencies(Target, "OpenAL");
}
else if (Target.Platform == UnrealTargetPlatform.HTML5 && Target.Architecture != "-win32")
{
AddEngineThirdPartyPrivateStaticDependencies(Target, "SDL2");
PrivateDependencyModuleNames.Add("HTML5JS");
PrivateDependencyModuleNames.Add("MapPakDownloader");
}
else if (Target.Platform == UnrealTargetPlatform.IOS || Target.Platform == UnrealTargetPlatform.TVOS)
{
PublicIncludePaths.AddRange(new string[] { "Runtime/ApplicationCore/Public/IOS" });
AddEngineThirdPartyPrivateStaticDependencies(Target, "SoundSwitch");
}
if (!Target.bCompileAgainstApplicationCore)
{
throw new System.Exception("ApplicationCore cannot be used when Target.bCompileAgainstApplicationCore = false.");
}
}
public MainFrame(TargetInfo Target)
{
PublicDependencyModuleNames.AddRange(
new string[]
{
"Documentation",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"CrashTracker",
"Engine",
"EngineSettings",
"InputCore",
"RHI",
"ShaderCore",
"Slate",
"SlateCore",
"EditorStyle",
"SourceControl",
"SourceControlWindows",
"TargetPlatform",
"DesktopPlatform",
"UnrealEd",
"WorkspaceMenuStructure",
"MessageLog",
// "SearchUI",
"TranslationEditor",
"Projects",
"DeviceProfileEditor",
"UndoHistory",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetTools",
"DesktopPlatform",
"GameProjectGeneration",
"ProjectTargetPlatformEditor",
"LevelEditor",
"OutputLog",
"SuperSearch",
"Settings",
"SourceCodeAccess",
}
);
PrivateIncludePaths.AddRange(
new string[] {
"Editor/MainFrame/Private",
"Editor/MainFrame/Private/Frame",
"Editor/MainFrame/Private/Menus",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AssetTools",
"DesktopPlatform",
"Documentation",
"GameProjectGeneration",
"ProjectTargetPlatformEditor",
"LevelEditor",
"OutputLog",
"SuperSearch",
"TranslationEditor",
"SourceCodeAccess",
"EditorLiveStreaming",
"HotReload"
}
);
}
public HoudiniPlusEditor(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseSharedPCHs;
// Check if we are compiling on unsupported platforms.
if (Target.Platform != UnrealTargetPlatform.Win64 &&
Target.Platform != UnrealTargetPlatform.Mac &&
Target.Platform != UnrealTargetPlatform.Linux &&
Target.Platform != UnrealTargetPlatform.Switch)
{
Console.WriteLine(string.Format("Houdini Engine : Compiling on untested platform. Please let us know how it goes!"));
}
// Find HFS
var HFSPath = GetHFSPath();
HFSPath = HFSPath.Replace("\\", "/");
if (!string.IsNullOrEmpty(HFSPath))
{
var Log = string.Format("Houdini Engine : Found Houdini in {0}", HFSPath);
Console.WriteLine(Log);
var BuildPlatformId = Environment.OSVersion.Platform;
if (BuildPlatformId == PlatformID.Win32NT)
{
PublicDefinitions.Add("HOUDINI_ENGINE_HFS_PATH_DEFINE=" + HFSPath);
}
}
// Find the HAPI include directory
var HAPIIncludePath = HFSPath + "/toolkit/include";
if (!Directory.Exists(HAPIIncludePath))
{
// Add the custom include path as well in case the toolkit path doesn't exist yet.
HAPIIncludePath = HFSPath + "/custom/houdini/include";
if (!Directory.Exists(HAPIIncludePath))
{
throw new Exception(string.Format("Couldn't find the HAPI include folder!"));
HAPIIncludePath = string.Empty;
}
}
if (!string.IsNullOrEmpty(HAPIIncludePath))
{
PublicIncludePaths.Add(HAPIIncludePath);
}
// Get the plugin path
var PluginPath = Path.Combine(ModuleDirectory, "../../");
PluginPath = Utils.MakePathRelativeTo(PluginPath, Target.RelativeEnginePath);
PublicIncludePaths.AddRange(
new string[] {
"HoudiniPlusEditor/Public"
});
PrivateIncludePaths.AddRange(
new string[] {
"HoudiniPlusEditor/Private",
});
PrivateIncludePathModuleNames.AddRange(
new string[] {
"PlacementMode"
});
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"Foliage",
"InputCore",
"Landscape",
"RenderCore",
"RHI",
"ShaderCore",
"Slate",
"SlateCore",
"Happy"
});
PrivateDependencyModuleNames.AddRange(
new string[]
{
"AppFramework",
"ApplicationCore",
"AssetTools",
"ContentBrowser",
"DesktopWidgets",
"EditorStyle",
"EditorWidgets",
"LevelEditor",
"MainFrame",
"Projects",
"PropertyEditor",
"RawMesh",
"Settings",
"Slate",
"SlateCore",
"TargetPlatform",
"UnrealEd",
});
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"PlacementMode"
});
var HAPILibPath = Path.Combine(HFSPath, GetLibFolder(), GetLibName());
HAPILibPath = HAPILibPath.Replace("\\", "/");
if (!File.Exists(HAPILibPath))
{
throw new Exception(string.Format("Couldn't find the HAPI lib!"));
}
else
{
PublicDelayLoadDLLs.Add(GetLibName());
RuntimeDependencies.Add(HAPILibPath);
}
}
public HoudiniEngine(ReadOnlyTargetRules Target) : base(Target)
{
bPrecompile = true;
PCHUsage = PCHUsageMode.NoSharedPCHs;
PrivatePCHHeaderFile = "Private/HoudiniEnginePrivatePCH.h";
// Check if we are compiling on unsupported platforms.
if (Target.Platform != UnrealTargetPlatform.Win64 &&
Target.Platform != UnrealTargetPlatform.Mac &&
Target.Platform != UnrealTargetPlatform.Linux)
{
string Err = string.Format("Houdini Engine : Compiling for unsupported platform.");
Log.TraceError(Err);
throw new BuildException(Err);
}
if (Target.bBuildEditor == false)
{
// Actual Runtime Houdini Engine, currently not supported
string Err = string.Format("Houdini Engine : Building as a runtime module is currently not supported.");
Log.TraceError(Err);
throw new BuildException(Err);
}
// Find HFS
string HFSPath = GetHFSPath();
HFSPath = HFSPath.Replace("\\", "/");
if (HFSPath != "")
{
string log = string.Format("Houdini Engine : Found Houdini in {0}", HFSPath);
Log.TraceInformationOnce(log);
PlatformID buildPlatformId = Environment.OSVersion.Platform;
if (buildPlatformId == PlatformID.Win32NT)
{
PublicDefinitions.Add("HOUDINI_ENGINE_HFS_PATH_DEFINE=" + HFSPath);
}
}
PublicIncludePaths.AddRange(
new string[]
{
//Path.Combine(ModuleDirectory, "Public/HAPI"),
//"HoudiniEngineRuntime/Public/HAPI"
}
);
PrivateIncludePaths.AddRange(
new string[]
{
"HoudiniEngineRuntime/Private"
}
);
// Add common dependencies.
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Engine",
"HoudiniEngineRuntime",
"RenderCore",
"InputCore",
"RHI",
"Foliage",
"Landscape",
"StaticMeshDescription",
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Landscape",
"PhysicsCore"
}
);
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.AddRange(
new string[]
{
"AppFramework",
"AssetTools",
"EditorStyle",
"EditorWidgets",
"Kismet",
"LevelEditor",
"MainFrame",
"MeshPaint",
"Projects",
"PropertyEditor",
"RawMesh",
"Settings",
"Slate",
"SlateCore",
"TargetPlatform",
"UnrealEd",
"ApplicationCore",
"LandscapeEditor",
"MeshDescription",
"MeshDescriptionOperations",
"WorldBrowser",
"Messaging",
"SlateNullRenderer"
}
);
}
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"DirectoryWatcher"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
"DirectoryWatcher"
}
);
}
public LevelEditor(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetTools",
"ClassViewer",
"MainFrame",
"PlacementMode",
"SlateReflector",
"IntroTutorials",
"AppFramework",
"PortalServices"
}
);
PublicIncludePathModuleNames.AddRange(
new string[] {
"Settings",
"IntroTutorials",
"HeadMountedDisplay",
"VREditor"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"LevelSequence",
"Analytics",
"Core",
"CoreUObject",
"LauncherPlatform",
"InputCore",
"Slate",
"SlateCore",
"EditorStyle",
"Engine",
"MessageLog",
"SourceControl",
"SourceControlWindows",
"StatsViewer",
"UnrealEd",
"RenderCore",
"DeviceProfileServices",
"ContentBrowser",
"SceneOutliner",
"ActorPickerMode",
"RHI",
"Projects",
"TargetPlatform",
"EngineSettings",
"PropertyEditor",
"Persona",
"Kismet",
"KismetWidgets",
"Sequencer",
"Foliage",
"HierarchicalLODOutliner",
"HierarchicalLODUtilities",
"MaterialShaderQualitySettings",
"PixelInspectorModule",
"FunctionalTesting"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"MainFrame",
"ClassViewer",
"DeviceManager",
"SettingsEditor",
"SessionFrontend",
"SlateReflector",
"AutomationWindow",
"Layers",
"WorldBrowser",
"EditorWidgets",
"AssetTools",
"WorkspaceMenuStructure",
"NewLevelDialog",
"DeviceProfileEditor",
"PlacementMode",
"IntroTutorials",
"HeadMountedDisplay",
"VREditor"
}
);
}
public CustomAssetEditor(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[]
{
"CustomAssetEditor/Public"
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[]
{
"CustomAssetEditor/Private",
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core",
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"Core",
"CoreUObject",
"Json",
"Slate",
"SlateCore",
"Engine",
"InputCore",
"UnrealEd", // for FAssetEditorManager
"KismetWidgets",
"Kismet", // for FWorkflowCentricApplication
"PropertyEditor",
"RenderCore",
"ContentBrowser",
"WorkspaceMenuStructure",
"EditorStyle",
"MeshPaint",
"EditorWidgets",
"Projects",
"AssetRegistry",
"AssetEditorTutorial"
// ... add private dependencies that you statically link with here ...
}
);
PrivateIncludePathModuleNames.AddRange(
new string[]
{
"Settings",
"IntroTutorials",
"AssetTools",
"LevelEditor"
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
"AssetTools"
}
);
}
public MovieSceneTools(ReadOnlyTargetRules Target) : base(Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"Editor/MovieSceneTools/Private",
"Editor/MovieSceneTools/Private/CurveKeyEditors",
"Editor/MovieSceneTools/Private/TrackEditors",
"Editor/MovieSceneTools/Private/TrackEditors/PropertyTrackEditors",
"Editor/MovieSceneTools/Private/TrackEditorThumbnail",
"Editor/MovieSceneTools/Private/Sections",
"Editor/UnrealEd/Private", //compatibility for FBX importer
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"MovieSceneCapture",
"UnrealEd",
"Sequencer"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"ActorPickerMode",
"CinematicCamera",
"CurveEditor",
"DesktopPlatform",
"Json",
"JsonUtilities",
"LevelSequence",
"MessageLog",
"MovieScene",
"MovieSceneTracks",
"BlueprintGraph",
"KismetCompiler",
"GraphEditor",
"ContentBrowser",
"Slate",
"SlateCore",
"EditorStyle",
"EditorWidgets",
"PropertyEditor",
"MaterialEditor",
"RenderCore",
"RHI",
"ShaderCore",
"SequenceRecorder",
"AnimationCore",
"TimeManagement",
"XmlParser",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetRegistry",
"AssetTools",
"Sequencer",
"Settings",
"SceneOutliner",
"MainFrame",
"UnrealEd",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AssetRegistry",
"AssetTools",
"SceneOutliner",
"MainFrame",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"Sequencer",
}
);
AddEngineThirdPartyPrivateStaticDependencies(Target, "FBX");
}
public Landscape(TargetInfo Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"Runtime/Engine/Private",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
"DerivedDataCache",
"ImageWrapper",
"Foliage",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"RenderCore",
"RHI",
"ShaderCore",
"Renderer",
"Foliage",
}
);
SetupModulePhysXAPEXSupport(Target);
if (UEBuildConfiguration.bCompilePhysX && UEBuildConfiguration.bRuntimePhysicsCooking)
{
DynamicallyLoadedModuleNames.Add("PhysXFormats");
PrivateIncludePathModuleNames.Add("PhysXFormats");
}
if (UEBuildConfiguration.bBuildDeveloperTools && Target.Type != TargetRules.TargetType.Server)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"RawMesh"
}
);
}
if (UEBuildConfiguration.bBuildEditor == true)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"UnrealEd",
"MaterialUtilities",
"SlateCore",
"Slate",
}
);
CircularlyReferencedDependentModules.AddRange(
new string[] {
"UnrealEd",
"MaterialUtilities",
}
);
}
}
public MovieSceneTools(TargetInfo Target)
{
PrivateIncludePaths.AddRange(
new string[] {
"Editor/MovieSceneTools/Private",
"Editor/MovieSceneTools/Private/CurveKeyEditors",
"Editor/MovieSceneTools/Private/TrackEditors",
"Editor/MovieSceneTools/Private/TrackEditors/PropertyTrackEditors",
"Editor/MovieSceneTools/Private/TrackEditorThumbnail",
"Editor/MovieSceneTools/Private/Sections"
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"UnrealEd",
"Sequencer"
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"ActorPickerMode",
"LevelSequence",
"MovieScene",
"MovieSceneTracks",
"BlueprintGraph",
"ContentBrowser",
"Slate",
"SlateCore",
"EditorStyle",
"EditorWidgets",
"RenderCore",
"RHI",
"ShaderCore",
"SequenceRecorder",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"AssetRegistry",
"AssetTools",
"Sequencer",
"Settings",
"SceneOutliner",
"PropertyEditor",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"AssetRegistry",
"AssetTools",
"SceneOutliner",
"PropertyEditor",
}
);
CircularlyReferencedDependentModules.Add("Sequencer");
}
public UnrealFrontend(ReadOnlyTargetRules Target) : base(Target)
{
PublicIncludePaths.Add("Runtime/Launch/Public");
PrivateIncludePaths.AddRange(
new string[] {
"Programs/UnrealFrontend/Private",
"Programs/UnrealFrontend/Private/Commands",
"Runtime/Launch/Private", // for LaunchEngineLoop.cpp include
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"AutomationController",
"Core",
"ApplicationCore",
"CoreUObject",
"DeviceManager",
"LauncherServices",
"Messaging",
"OutputLog",
"Profiler",
"ProfilerClient",
"ProjectLauncher",
"Projects",
"SessionFrontend",
"SessionServices",
"Slate",
"SlateCore",
"SourceCodeAccess",
"StandaloneRenderer",
"TargetDeviceServices",
"TargetPlatform",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"SlateReflector",
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"SlateReflector"
}
);
if (Target.Platform == UnrealTargetPlatform.Mac)
{
PrivateDependencyModuleNames.Add("XCodeSourceCodeAccess");
}
else if (Target.Platform == UnrealTargetPlatform.Win64)
{
PrivateDependencyModuleNames.Add("VisualStudioSourceCodeAccess");
}
else if (Target.Platform == UnrealTargetPlatform.Linux)
{
PrivateDependencyModuleNames.AddRange(
new string[] {
"UnixCommonStartup"
}
);
}
// @todo: allow for better plug-in support in standalone Slate apps
PrivateDependencyModuleNames.AddRange(
new string[] {
"Networking",
"Sockets",
"UdpMessaging",
"TcpMessaging",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Messaging",
}
);
}
public SteamAudio(ReadOnlyTargetRules Target) : base(Target)
{
OptimizeCode = CodeOptimization.Never;
PrivateIncludePaths.AddRange(
new string[] {
"SteamAudio/Private",
}
);
PublicDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"AudioMixer",
"InputCore",
"RenderCore",
"ShaderCore",
"RHI"
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"TargetPlatform",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Engine",
"InputCore",
"Projects",
"AudioMixer"
}
);
if (Target.bBuildEditor == true)
{
PrivateDependencyModuleNames.Add("UnrealEd");
PrivateDependencyModuleNames.Add("Landscape");
}
AddEngineThirdPartyPrivateStaticDependencies(Target, "libPhonon");
switch (Target.Platform)
{
case UnrealTargetPlatform.Win32:
case UnrealTargetPlatform.Win64:
PrivateDependencyModuleNames.Add("XAudio2");
AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11Audio");
break;
case UnrealTargetPlatform.Android:
string PluginPath = Utils.MakePathRelativeTo(ModuleDirectory, Target.RelativeEnginePath);
AdditionalPropertiesForReceipt.Add(new ReceiptProperty("AndroidPlugin", Path.Combine(PluginPath, "SteamAudio_APL.xml")));
break;
default:
break;
}
}
public VlcMedia(TargetInfo Target)
{
DynamicallyLoadedModuleNames.AddRange(
new string[] {
"Media",
"Settings",
}
);
PrivateDependencyModuleNames.AddRange(
new string[] {
"Core",
"CoreUObject",
"Projects",
"RenderCore",
}
);
PrivateIncludePathModuleNames.AddRange(
new string[] {
"Media",
"Settings",
}
);
PrivateIncludePaths.AddRange(
new string[] {
"VlcMedia/Private",
"VlcMedia/Private/Player",
"VlcMedia/Private/Shared",
"VlcMedia/Private/Tracks",
"VlcMedia/Private/Vlc",
}
);
// add VLC libraries
string BaseDirectory = Path.GetFullPath(Path.Combine(ModuleDirectory, "..", ".."));
string VlcDirectory = Path.Combine(BaseDirectory, "ThirdParty", "vlc", Target.Platform.ToString());
if (Target.Platform == UnrealTargetPlatform.Linux)
{
// We expect libvlc to be installed for now until we can figure
// out how to configure package dependencies at installation time.
}
else if (Target.Platform == UnrealTargetPlatform.Mac)
{
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(VlcDirectory, "libvlc.dylib")));
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(VlcDirectory, "libvlc.5.dylib")));
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(VlcDirectory, "libvlccore.dylib")));
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(VlcDirectory, "libvlccore.8.dylib")));
}
else if (Target.Platform == UnrealTargetPlatform.Win32)
{
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(VlcDirectory, "libgcc_s_sjlj-1.dll")));
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(VlcDirectory, "libvlc.dll")));
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(VlcDirectory, "libvlccore.dll")));
}
else if (Target.Platform == UnrealTargetPlatform.Win64)
{
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(VlcDirectory, "libgcc_s_seh-1.dll")));
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(VlcDirectory, "libvlc.dll")));
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(VlcDirectory, "libvlccore.dll")));
}
else if (Target.Platform == UnrealTargetPlatform.WinRT)
{
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(VlcDirectory, "libvlc.dll")));
RuntimeDependencies.Add(new RuntimeDependency(Path.Combine(VlcDirectory, "libvlccore.dll")));
}
// add VLC plug-ins
string PluginDirectory = Path.Combine(VlcDirectory, "plugins");
if (Directory.Exists(PluginDirectory))
{
foreach (string Plugin in Directory.EnumerateFiles(PluginDirectory))
{
RuntimeDependencies.Add(new RuntimeDependency(Plugin));
}
}
}
